shokupan 0.12.0 → 0.13.0

package/dist/index.cjs

@@ -25,12 +25,11 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const nanoid = require("nanoid");
 const promises = require("node:fs/promises");
 const node_util = require("node:util");
+const surrealdb = require("surrealdb");
 const eta$1 = require("eta");
 const promises$1 = require("fs/promises");
 const path = require("path");
-const api = require("@opentelemetry/api");
-const surrealdb = require("surrealdb");
-const jsYaml = require("js-yaml");
+const cockatiel = require("cockatiel");
 const http$1 = require("node:http");
 require("node:https");
 const node_async_hooks = require("node:async_hooks");
@@ -43,8 +42,10 @@ const net = require("node:net");
 const os = require("node:os");
 const node_module = require("node:module");
 const node_perf_hooks = require("node:perf_hooks");
+const bun = require("bun");
+const analyzer_impl = require("./analyzer.impl-CUDO6vpn.cjs");
 const fs$1 = require("node:fs");
-const analyzer = require("./analyzer-DM-OlRq8.cjs");
+const analyzer = require("./analyzer-BOtveWL-.cjs");
 const node_stream = require("node:stream");
 const zlib = require("node:zlib");
 const Ajv = require("ajv");
@@ -373,6 +374,10 @@ const $cachedCookies = /* @__PURE__ */ Symbol.for("Shokupan.ctx.cachedCookies");
 const $ws = /* @__PURE__ */ Symbol.for("Shokupan.ctx.ws");
 const $socket = /* @__PURE__ */ Symbol.for("Shokupan.ctx.socket");
 const $io = /* @__PURE__ */ Symbol.for("Shokupan.ctx.io");
+const $mcpTools = /* @__PURE__ */ Symbol.for("Shokupan.mcp.tools");
+const $mcpPrompts = /* @__PURE__ */ Symbol.for("Shokupan.mcp.prompts");
+const $mcpResources = /* @__PURE__ */ Symbol.for("Shokupan.mcp.resources");
+const $resilienceConfig = /* @__PURE__ */ Symbol.for("Shokupan.resilience.config");
 function isValidCookieDomain(domain, currentHost) {
   const hostWithoutPort = currentHost.split(":")[0];
   if (domain === hostWithoutPort) return true;
@@ -1159,31 +1164,109 @@ const compose = (middleware) => {
         console.error(`[Middleware Error] Item at index ${i} is not a function! It is: ${typeof fn} (${name})`, fn);
         throw new TypeError(`Middleware at index ${i} must be a function, got ${name}`);
       }
-      if (!context[$debug]) {
-        return fn(context, () => runner(i + 1));
+      const trackingEnabled = context.app?.applicationConfig?.enableMiddlewareTracking;
+      const meta = fn.metadata;
+      let trackingStartTime = 0;
+      if (trackingEnabled && meta) {
+        trackingStartTime = performance.now();
+        context.handlerStack.push({
+          name: meta.name || fn.name || "anonymous",
+          file: meta.file,
+          line: meta.line,
+          isBuiltin: meta.isBuiltin,
+          startTime: trackingStartTime,
+          duration: -1
+        });
       }
       const debug = context[$debug];
-      const debugId = fn._debugId || fn.name || "anonymous";
-      const previousNode = debug.getCurrentNode();
-      debug.trackEdge(previousNode, debugId);
-      debug.setNode(debugId);
-      const start = performance.now();
+      let debugId;
+      let previousNode;
+      let debugStart = 0;
+      if (debug) {
+        debugId = fn._debugId || fn.name || "anonymous";
+        previousNode = debug.getCurrentNode();
+        debug.trackEdge(previousNode, debugId);
+        debug.setNode(debugId);
+        debugStart = performance.now();
+      }
       try {
-        const res = await Promise.resolve(fn(context, () => runner(i + 1)));
-        debug.trackStep(debugId, "middleware", performance.now() - start, "success");
+        const res = await fn(context, () => runner(i + 1));
+        if (trackingEnabled && meta) {
+          const duration = performance.now() - trackingStartTime;
+          const stackItem = context.handlerStack[context.handlerStack.length - 1];
+          if (stackItem) stackItem.duration = duration;
+          Promise.resolve().then(async () => {
+            try {
+              const db = context.app?.db;
+              if (!db) return;
+              const timestamp = Date.now();
+              await db.upsert(new surrealdb.RecordId("middleware_tracking", {
+                timestamp,
+                name: meta.name
+              }), {
+                name: meta.name,
+                path: context.path,
+                timestamp,
+                duration,
+                file: meta.file,
+                line: meta.line,
+                error: void 0,
+                metadata: {
+                  isBuiltin: meta.isBuiltin,
+                  pluginName: meta.pluginName
+                }
+              });
+            } catch (e) {
+            }
+          });
+        }
+        if (debug) {
+          debug.trackStep(debugId, "middleware", performance.now() - debugStart, "success");
+        }
         return res;
       } catch (err) {
-        debug.trackStep(debugId, "middleware", performance.now() - start, "error", err);
-        return Promise.reject(err);
+        if (trackingEnabled && meta) {
+          const duration = performance.now() - trackingStartTime;
+          const stackItem = context.handlerStack[context.handlerStack.length - 1];
+          if (stackItem) stackItem.duration = duration;
+          Promise.resolve().then(async () => {
+            try {
+              const db = context.app?.db;
+              if (!db) return;
+              const timestamp = Date.now();
+              await db.upsert(new surrealdb.RecordId("middleware_tracking", {
+                timestamp,
+                name: meta.name
+              }), {
+                name: meta.name,
+                path: context.path,
+                timestamp,
+                duration,
+                file: meta.file,
+                line: meta.line,
+                error: String(err),
+                metadata: {
+                  isBuiltin: meta.isBuiltin,
+                  pluginName: meta.pluginName
+                }
+              });
+            } catch (e) {
+            }
+          });
+        }
+        if (debug) {
+          debug.trackStep(debugId, "middleware", performance.now() - debugStart, "error", err);
+        }
+        throw err;
       } finally {
-        if (previousNode) debug.setNode(previousNode);
+        if (debug && previousNode) debug.setNode(previousNode);
       }
     }
     return runner(0);
   };
 };
 function isObject(item) {
-  return item && typeof item === "object" && !Array.isArray(item);
+  return !!(item && typeof item === "object" && !Array.isArray(item));
 }
 function deepMerge(target, ...sources) {
   if (!sources.length) return target;
@@ -1448,7 +1531,7 @@ async function generateOpenApi(rootRouter, options = {}) {
   let astMiddlewareRegistry = {};
   let applications = [];
   try {
-    const { OpenAPIAnalyzer } = await Promise.resolve().then(() => require("./analyzer-DM-OlRq8.cjs"));
+    const { OpenAPIAnalyzer } = await Promise.resolve().then(() => require("./analyzer-BOtveWL-.cjs"));
     const entrypoint = rootRouter.metadata?.file;
     const analyzer2 = new OpenAPIAnalyzer(process.cwd(), entrypoint);
     const analysisResult = await analyzer2.analyze();
@@ -1500,7 +1583,7 @@ async function generateOpenApi(rootRouter, options = {}) {
       isBuiltinPlugin = true;
       pluginName = router.metadata.pluginName;
       tag = pluginName.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
-    } else if (router.metadata?.file && router.metadata.file.includes("plugins/application/")) {
+    } else if (router.metadata?.file && router.metadata.file.includes("plugins/application/") && !router.metadata.file.match(/\.(spec|test)\.ts$/)) {
       isBuiltinPlugin = true;
       const match = router.metadata.file.match(/plugins\/application\/([^/]+)/);
       if (match) {
@@ -1658,7 +1741,39 @@ async function generateOpenApi(rootRouter, options = {}) {
         const params = [];
         if (astMatch.requestTypes?.query) {
           for (const [name, _type] of Object.entries(astMatch.requestTypes.query)) {
-            params.push({ name, in: "query", schema: { type: "string" } });
+            let type = "string";
+            let format;
+            if (_type === "integer") {
+              type = "integer";
+              format = "int32";
+            } else if (_type === "number") {
+              type = "number";
+              format = "float";
+            } else if (_type === "boolean") type = "boolean";
+            const schema = { type };
+            if (format) schema.format = format;
+            params.push({ name, in: "query", schema });
+          }
+        }
+        if (astMatch.requestTypes?.params) {
+          for (const [name, _type] of Object.entries(astMatch.requestTypes.params)) {
+            let type = "string";
+            let format;
+            if (_type === "integer") {
+              type = "integer";
+              format = "int32";
+            } else if (_type === "number") {
+              type = "number";
+              format = "float";
+            } else if (_type === "boolean") type = "boolean";
+            const schema = { type };
+            if (format) schema.format = format;
+            params.push({ name, in: "path", required: true, schema });
+          }
+        }
+        if (astMatch.requestTypes?.headers) {
+          for (const [name, _type] of Object.entries(astMatch.requestTypes.headers)) {
+            params.push({ name, in: "header", schema: { type: "string" } });
           }
         }
         if (params.length > 0) {
@@ -1716,9 +1831,7 @@ async function generateOpenApi(rootRouter, options = {}) {
         const mergedParams = [...existingParams];
         pathParams.forEach((p) => {
           const idx = mergedParams.findIndex((ep) => ep.in === "path" && ep.name === p.name);
-          if (idx >= 0) {
-            mergedParams[idx] = deepMerge(mergedParams[idx], p);
-          } else {
+          if (idx === -1) {
             mergedParams.push(p);
           }
         });
@@ -2007,6 +2120,166 @@ function serveStatic(config, prefix) {
   serveStaticMiddleware.pluginName = "ServeStatic";
   return serveStaticMiddleware;
 }
+class OpenTelemetryPlugin {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  api;
+  sdk;
+  async onInit(app) {
+    try {
+      this.api = await import("@opentelemetry/api");
+    } catch (e) {
+      console.warn("OpenTelemetry API not found. OpenTelemetryPlugin will be disabled.");
+      return;
+    }
+    if (this.options.enableAutoInstrumentation !== false) {
+      app.use(this.middleware());
+    }
+  }
+  middleware() {
+    return async (ctx, next) => {
+      if (!this.api) return next();
+      const tracer = this.api.trace.getTracer("shokupan");
+      return tracer.startActiveSpan(`${ctx.req.method} ${ctx.req.path}`, {
+        kind: this.api.SpanKind.SERVER,
+        attributes: {
+          "http.method": ctx.req.method,
+          "http.url": ctx.req.url,
+          "http.host": ctx.req.host,
+          "http.user_agent": ctx.req.headers.get("user-agent") || void 0
+        }
+      }, async (span) => {
+        try {
+          const res = await next();
+          span.setAttributes({
+            "http.status_code": ctx.res.status
+          });
+          if (ctx.res.status >= 500) {
+            span.setStatus({ code: this.api.SpanStatusCode.ERROR });
+          } else {
+            span.setStatus({ code: this.api.SpanStatusCode.OK });
+          }
+          return res;
+        } catch (err) {
+          span.recordException(err);
+          span.setStatus({ code: this.api.SpanStatusCode.ERROR, message: err.message });
+          throw err;
+        } finally {
+          span.end();
+        }
+      });
+    };
+  }
+}
+function traceMiddleware(fn, name) {
+  let api;
+  try {
+    api = require("@opentelemetry/api");
+  } catch {
+  }
+  if (!api) return fn;
+  const tracer = api.trace.getTracer("shokupan.middleware");
+  const middlewareName = name || fn.name || "anonymous middleware";
+  return async (ctx, next) => {
+    return tracer.startActiveSpan(`middleware - ${middlewareName}`, {
+      kind: api.SpanKind.INTERNAL,
+      attributes: {
+        "code.function": middlewareName,
+        "component": "shokupan.middleware"
+      }
+    }, async (span) => {
+      try {
+        const result = await fn(ctx, next);
+        return result;
+      } catch (err) {
+        span.recordException(err);
+        span.setStatus({ code: api.SpanStatusCode.ERROR, message: err.message });
+        throw err;
+      } finally {
+        span.end();
+      }
+    });
+  };
+}
+function traceHandler(fn, name) {
+  let api;
+  try {
+    api = require("@opentelemetry/api");
+  } catch {
+  }
+  if (!api) return fn;
+  const tracer = api.trace.getTracer("shokupan.middleware");
+  return async function(...args) {
+    return tracer.startActiveSpan(`route handler - ${name}`, {
+      kind: api.SpanKind.INTERNAL,
+      attributes: {
+        "http.route": name,
+        "component": "shokupan.route"
+      }
+    }, async (span) => {
+      try {
+        const result = await fn.apply(this, args);
+        return result;
+      } catch (err) {
+        span.recordException(err);
+        span.setStatus({ code: api.SpanStatusCode.ERROR, message: err.message });
+        throw err;
+      } finally {
+        span.end();
+      }
+    });
+  };
+}
+class ResilienceFactory {
+  static createPolicy(config) {
+    const policies = [];
+    if (config.retry) {
+      const builder = cockatiel.handleAll;
+      let retries = (config.retry.attempts ?? 3) - 1;
+      if (retries < 0) retries = 0;
+      let retryPolicy;
+      if (config.retry.backoff === "exponential") {
+        retryPolicy = cockatiel.retry(builder, {
+          maxAttempts: retries,
+          backoff: new cockatiel.ExponentialBackoff({
+            initialDelay: config.retry.delay || 1e3,
+            maxDelay: config.retry.maxDelay || 3e4
+          })
+        });
+      } else {
+        retryPolicy = cockatiel.retry(builder, {
+          maxAttempts: retries,
+          backoff: new cockatiel.ConstantBackoff(config.retry.delay || 1e3)
+        });
+      }
+      policies.push(retryPolicy);
+    }
+    if (config.circuitBreaker) {
+      const builder = cockatiel.handleAll;
+      const breaker = cockatiel.circuitBreaker(builder, {
+        halfOpenAfter: config.circuitBreaker.resetTimeout || 1e4,
+        breaker: new cockatiel.ConsecutiveBreaker(config.circuitBreaker.threshold || 5)
+      });
+      policies.push(breaker);
+    }
+    if (config.timeout) {
+      policies.push(cockatiel.timeout(config.timeout, { strategy: cockatiel.TimeoutStrategy.Aggressive, abortOnReturn: true }));
+    }
+    if (config.bulkhead) {
+      policies.push(cockatiel.bulkhead(config.bulkhead));
+    }
+    if (config.fallback !== void 0) {
+      const builder = cockatiel.handleAll;
+      const fb = cockatiel.fallback(builder, config.fallback);
+      policies.push(fb);
+    }
+    if (policies.length === 0) {
+      return { execute: (fn) => fn() };
+    }
+    return cockatiel.wrap(...policies.reverse());
+  }
+}
 const metadataStore = /* @__PURE__ */ new WeakMap();
 function defineMetadata(key, value, target, propertyKey) {
   let targetMetadata = metadataStore.get(target);
@@ -2103,29 +2376,6 @@ const di = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   Container
 }, Symbol.toStringTag, { value: "Module" }));
-const tracer = api.trace.getTracer("shokupan.middleware");
-function traceHandler(fn, name) {
-  return async function(...args) {
-    return tracer.startActiveSpan(`route handler - ${name}`, {
-      kind: api.SpanKind.INTERNAL,
-      attributes: {
-        "http.route": name,
-        "component": "shokupan.route"
-      }
-    }, async (span) => {
-      try {
-        const result = await fn.apply(this, args);
-        return result;
-      } catch (err) {
-        span.recordException(err);
-        span.setStatus({ code: api.SpanStatusCode.ERROR, message: err.message });
-        throw err;
-      } finally {
-        span.end();
-      }
-    });
-  };
-}
 function getCallerInfo(skipFrames = 1) {
   let file = "unknown";
   let line = 0;
@@ -2143,6 +2393,7 @@ function getCallerInfo(skipFrames = 1) {
       if (l.includes("src/router.ts")) continue;
       if (l.includes("src/util/decorators.ts")) continue;
       if (l.includes("src/shokupan.ts")) continue;
+      if (l.includes("src/plugins/application/openapi/openapi.ts")) continue;
       found++;
       if (found >= skipFrames) {
         const match = l.match(/\((.*):(\d+):(\d+)\)/) || l.match(/at (.*):(\d+):(\d+)/);
@@ -2211,6 +2462,10 @@ class ControllerScanner {
     const decoratedArgs = instance[$routeArgs] || proto && proto[$routeArgs];
     const methodMiddlewareMap = instance[$middleware] || proto && proto[$middleware];
     const decoratedEvents = instance[$eventMethods] || proto && proto[$eventMethods];
+    const mcpTools = instance[$mcpTools] || proto && proto[$mcpTools];
+    const mcpPrompts = instance[$mcpPrompts] || proto && proto[$mcpPrompts];
+    const mcpResources = instance[$mcpResources] || proto && proto[$mcpResources];
+    const resilienceConfigMap = instance[$resilienceConfig] || proto && proto[$resilienceConfig];
     let routesAttached = 0;
     for (let i = 0; i < Array.from(methods).length; i++) {
       const name = Array.from(methods)[i];
@@ -2335,6 +2590,14 @@ class ControllerScanner {
             return composed(ctx, () => wrappedHandler(ctx));
           };
         }
+        const config = resilienceConfigMap?.get(name);
+        if (config) {
+          const policy = ResilienceFactory.createPolicy(config);
+          const baseHandler = finalHandler;
+          finalHandler = async (ctx) => {
+            return policy.execute(() => baseHandler(ctx));
+          };
+        }
         finalHandler.originalHandler = originalHandler;
         if (finalHandler !== wrappedHandler) {
           wrappedHandler.originalHandler = originalHandler;
@@ -2391,6 +2654,25 @@ class ControllerScanner {
         wrappedHandler.originalHandler = originalHandler;
         router.event(eventConfig.eventName, wrappedHandler);
       }
+      const toolConfig = mcpTools?.get(name);
+      if (toolConfig) {
+        const handler = originalHandler.bind(instance);
+        router.tool(toolConfig.name || name, toolConfig.inputSchema, handler);
+      }
+      const promptConfig = mcpPrompts?.get(name);
+      if (promptConfig) {
+        const handler = originalHandler.bind(instance);
+        router.prompt(promptConfig.name || name, promptConfig.arguments, handler);
+      }
+      const resourceConfig = mcpResources?.get(name);
+      if (resourceConfig) {
+        const handler = originalHandler.bind(instance);
+        router.resource(resourceConfig.uri, {
+          name: resourceConfig.name || name,
+          description: resourceConfig.description,
+          mimeType: resourceConfig.mimeType
+        }, handler);
+      }
     }
     if (routesAttached === 0) {
       console.warn(`No routes attached to controller ${instance.constructor.name}`);
@@ -2421,71 +2703,177 @@ function getErrorStatus(err) {
   }
   return 500;
 }
+class NotFoundError extends HttpError {
+  constructor(message = "Not Found") {
+    super(message, 404);
+    this.name = "NotFoundError";
+  }
+}
 class EventError extends HttpError {
   constructor(message = "Event Error") {
     super(message, 500);
     this.name = "EventError";
   }
 }
+class McpProtocol {
+  tools = /* @__PURE__ */ new Map();
+  prompts = /* @__PURE__ */ new Map();
+  resources = /* @__PURE__ */ new Map();
+  constructor(tools = [], prompts = [], resources = []) {
+    tools.forEach((t) => this.tools.set(t.name, t));
+    prompts.forEach((p) => this.prompts.set(p.name, p));
+    resources.forEach((r) => this.resources.set(r.uri, r));
+  }
+  addTool(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  addPrompt(prompt) {
+    this.prompts.set(prompt.name, prompt);
+  }
+  addResource(resource) {
+    this.resources.set(resource.uri, resource);
+  }
+  merge(other) {
+    other.tools.forEach((t) => this.tools.set(t.name, t));
+    other.prompts.forEach((p) => this.prompts.set(p.name, p));
+    other.resources.forEach((r) => this.resources.set(r.uri, r));
+  }
+  async handleMessage(message) {
+    if (message.jsonrpc !== "2.0") {
+      return this.error(message.id, -32600, "Invalid Request");
+    }
+    try {
+      switch (message.method) {
+        case "initialize":
+          return this.success(message.id, {
+            protocolVersion: "2024-11-05",
+            serverInfo: {
+              name: "Shokupan MCP",
+              version: "1.0.0"
+            },
+            capabilities: {
+              tools: this.tools.size > 0 ? {} : void 0,
+              prompts: this.prompts.size > 0 ? {} : void 0,
+              resources: this.resources.size > 0 ? {} : void 0
+            }
+          });
+        case "ping":
+          return this.success(message.id, {});
+        case "tools/list":
+          if (this.tools.size === 0) return this.success(message.id, { tools: [] });
+          return this.success(message.id, {
+            tools: Array.from(this.tools.values()).map((t) => ({
+              name: t.name,
+              description: t.description,
+              inputSchema: t.inputSchema || { type: "object", properties: {} }
+            }))
+          });
+        case "tools/call": {
+          if (!message.params || !message.params.name) {
+            return this.error(message.id, -32602, "Invalid params: name required");
+          }
+          const tool = this.tools.get(message.params.name);
+          if (!tool) {
+            return this.error(message.id, -32601, `Tool not found: ${message.params.name}`);
+          }
+          try {
+            const result = await tool.handler(message.params.arguments || {});
+            return this.success(message.id, result);
+          } catch (e) {
+            return {
+              jsonrpc: "2.0",
+              id: message.id ?? null,
+              result: {
+                isError: true,
+                content: [{ type: "text", text: e.message || String(e) }]
+              }
+            };
+          }
+        }
+        case "prompts/list":
+          if (this.prompts.size === 0) return this.success(message.id, { prompts: [] });
+          return this.success(message.id, {
+            prompts: Array.from(this.prompts.values()).map((p) => ({
+              name: p.name,
+              description: p.description,
+              arguments: p.arguments
+            }))
+          });
+        case "prompts/get": {
+          if (!message.params || !message.params.name) {
+            return this.error(message.id, -32602, "Invalid params: name required");
+          }
+          const prompt = this.prompts.get(message.params.name);
+          if (!prompt) {
+            return this.error(message.id, -32601, `Prompt not found: ${message.params.name}`);
+          }
+          const result = await prompt.handler(message.params.arguments || {});
+          return this.success(message.id, result);
+        }
+        case "resources/list":
+          if (this.resources.size === 0) return this.success(message.id, { resources: [] });
+          return this.success(message.id, {
+            resources: Array.from(this.resources.values()).map((r) => ({
+              uri: r.uri,
+              name: r.name,
+              description: r.description,
+              mimeType: r.mimeType
+            }))
+          });
+        case "resources/read": {
+          if (!message.params || !message.params.uri) {
+            return this.error(message.id, -32602, "Invalid params: uri required");
+          }
+          let resource = this.resources.get(message.params.uri);
+          if (!resource) {
+            return this.error(message.id, -32601, `Resource not found: ${message.params.uri}`);
+          }
+          const result = await resource.handler(message.params.uri);
+          return this.success(message.id, result);
+        }
+        default:
+          if (message.id === void 0) return null;
+          return this.error(message.id, -32601, "Method not found");
+      }
+    } catch (err) {
+      return this.error(message.id, -32603, "Internal Error", err.message);
+    }
+  }
+  success(id, result) {
+    return {
+      jsonrpc: "2.0",
+      id: id ?? null,
+      result
+    };
+  }
+  error(id, code, message, data) {
+    return {
+      jsonrpc: "2.0",
+      id: id ?? null,
+      error: { code, message, data }
+    };
+  }
+}
 class MiddlewareTracker {
   static wrap(handler, context) {
     const { file, line, name, isBuiltin, pluginName } = context;
     const handlerName = name || handler.name || "anonymous";
-    const trackedHandler = async (ctx, next) => {
-      if (!ctx.app?.applicationConfig.enableMiddlewareTracking) {
-        return handler(ctx, next);
-      }
-      const startTime = performance.now();
-      let error = void 0;
-      try {
-        ctx.handlerStack.push({
-          name: handlerName,
-          file,
-          line,
-          isBuiltin,
-          startTime,
-          duration: -1
-        });
-        return await handler(ctx, next);
-      } catch (e) {
-        error = e;
-        throw e;
-      } finally {
-        const duration = performance.now() - startTime;
-        const stackItem = ctx.handlerStack[ctx.handlerStack.length - 1];
-        if (stackItem && stackItem.name === handlerName) {
-          stackItem.duration = duration;
+    try {
+      handler.metadata = context;
+      if (!handler.name || handler.name === "anonymous") {
+        try {
+          Object.defineProperty(handler, "name", { value: handlerName, configurable: true });
+        } catch (e) {
         }
-        Promise.resolve().then(async () => {
-          try {
-            const db = ctx.app?.db;
-            if (!db) return;
-            const timestamp = Date.now();
-            await db.upsert(new surrealdb.RecordId("middleware_tracking", {
-              timestamp,
-              name: handlerName
-            }), {
-              name: handlerName,
-              path: ctx.path,
-              timestamp,
-              duration,
-              file,
-              line,
-              error: error ? String(error) : void 0,
-              metadata: {
-                isBuiltin,
-                pluginName
-              }
-            });
-          } catch (err) {
-          }
-        });
       }
-    };
-    trackedHandler.metadata = handler.metadata || context;
-    Object.defineProperty(trackedHandler, "name", { value: handlerName });
-    trackedHandler.originalHandler = handler.originalHandler || handler;
-    return trackedHandler;
+    } catch (e) {
+      const wrapped = handler.bind(null);
+      wrapped.metadata = context;
+      Object.defineProperty(wrapped, "name", { value: handlerName });
+      wrapped.originalHandler = handler.originalHandler || handler;
+      return wrapped;
+    }
+    return handler;
   }
 }
 class ShokupanRequestBase {
@@ -2699,6 +3087,7 @@ class ShokupanRouter {
   trie = new RouterTrie();
   metadata;
   // Metadata for the router itself
+  mcpProtocol = new McpProtocol();
   currentGuards = [];
   eventHandlers = /* @__PURE__ */ new Map();
   /**
@@ -2824,6 +3213,39 @@ class ShokupanRouter {
     handlers.push(handler);
     return this;
   }
+  /**
+   * Registers an MCP Tool.
+   */
+  tool(name, schema, handler) {
+    this.mcpProtocol.addTool({
+      name,
+      inputSchema: schema,
+      handler
+    });
+    return this;
+  }
+  /**
+   * Registers an MCP Prompt.
+   */
+  prompt(name, args, handler) {
+    this.mcpProtocol.addPrompt({
+      name,
+      arguments: args,
+      handler
+    });
+    return this;
+  }
+  /**
+   * Registers an MCP Resource.
+   */
+  resource(uri, options, handler) {
+    this.mcpProtocol.addResource({
+      uri,
+      handler,
+      ...options
+    });
+    return this;
+  }
   /**
    * Finds an event handler(s) by name.
    */
@@ -3122,59 +3544,48 @@ class ShokupanRouter {
         }
       }
     }
-    let wrappedHandler = async (ctx) => {
-      return handler(ctx);
-    };
-    wrappedHandler.originalHandler = handler.originalHandler || handler;
-    const routeGuards = [...this.currentGuards];
     const effectiveTimeout = requestTimeout ?? this.requestTimeout ?? this.rootConfig?.requestTimeout;
-    if (effectiveTimeout !== void 0 && effectiveTimeout > 0) {
-      const originalHandler = wrappedHandler;
+    const effectiveRenderer = renderer ?? this.config?.renderer ?? this.rootConfig?.renderer;
+    const routeGuards = [...this.currentGuards];
+    let wrappedHandler = handler;
+    if (effectiveTimeout && effectiveTimeout > 0 || effectiveRenderer || routeGuards.length > 0) {
+      const originalHandler = handler;
       wrappedHandler = async (ctx) => {
-        if (ctx.server) {
+        if (effectiveTimeout && effectiveTimeout > 0 && ctx.server) {
           ctx.server.timeout(ctx.req, effectiveTimeout / 1e3);
         }
-        return originalHandler(ctx);
-      };
-      wrappedHandler.originalHandler = originalHandler.originalHandler || originalHandler;
-    }
-    if (routeGuards.length > 0) {
-      const innerHandler = wrappedHandler;
-      wrappedHandler = async (ctx) => {
-        for (let i = 0; i < routeGuards.length; i++) {
-          const guard = routeGuards[i];
-          let guardPassed = false;
-          let nextCalled = false;
-          const next = () => {
-            nextCalled = true;
-            return Promise.resolve();
-          };
-          try {
-            const result = await guard.handler(ctx, next);
-            if (result === true || nextCalled) {
-              guardPassed = true;
-            } else if (result !== void 0 && result !== null && result !== false) {
-              return result;
-            } else {
+        if (effectiveRenderer) {
+          ctx.setRenderer(effectiveRenderer);
+        }
+        if (routeGuards.length > 0) {
+          for (let i = 0; i < routeGuards.length; i++) {
+            const guard = routeGuards[i];
+            let guardPassed = false;
+            let nextCalled = false;
+            const next = () => {
+              nextCalled = true;
+              return Promise.resolve();
+            };
+            try {
+              const result = await guard.handler(ctx, next);
+              if (result === true || nextCalled) {
+                guardPassed = true;
+              } else if (result !== void 0 && result !== null && result !== false) {
+                return result;
+              } else {
+                return ctx.json({ error: "Forbidden" }, 403);
+              }
+            } catch (error) {
+              throw error;
+            }
+            if (!guardPassed) {
               return ctx.json({ error: "Forbidden" }, 403);
             }
-          } catch (error) {
-            throw error;
-          }
-          if (!guardPassed) {
-            return ctx.json({ error: "Forbidden" }, 403);
           }
         }
-        return innerHandler(ctx);
-      };
-    }
-    const effectiveRenderer = renderer ?? this.config?.renderer ?? this.rootConfig?.renderer;
-    if (effectiveRenderer) {
-      const innerHandler = wrappedHandler;
-      wrappedHandler = async (ctx) => {
-        ctx.setRenderer(effectiveRenderer);
-        return innerHandler(ctx);
+        return originalHandler(ctx);
       };
+      wrappedHandler.originalHandler = handler.originalHandler || handler;
     }
     const { file, line } = metadata || getCallerInfo();
     wrappedHandler = MiddlewareTracker.wrap(wrappedHandler, {
@@ -3875,6 +4286,32 @@ class SurrealDatastore {
     return this.db.close();
   }
 }
+const kContext = /* @__PURE__ */ Symbol("kContext");
+let patched = false;
+function enablePromisePatch() {
+  if (patched) return;
+  patched = true;
+  const OriginalPromise = global.Promise;
+  global.Promise = class PatchedPromise extends OriginalPromise {
+    [kContext];
+    constructor(executor) {
+      const store = asyncContext.getStore();
+      const stack = new Error().stack || "No parent stack";
+      super(executor);
+      this[kContext] = {
+        store,
+        stack
+      };
+    }
+  };
+  for (const prop of Object.getOwnPropertyNames(OriginalPromise)) {
+    if (prop !== "prototype" && prop !== "length" && prop !== "name") {
+      if (typeof OriginalPromise[prop] === "function") {
+        global.Promise[prop] = OriginalPromise[prop];
+      }
+    }
+  }
+}
 const defaults = {
   port: 3e3,
   hostname: "localhost",
@@ -3918,15 +4355,32 @@ class Shokupan extends ShokupanRouter {
       line,
       name: "ShokupanApplication"
     };
-    if (this.applicationConfig.securityHeaders !== false) {
+    if (this.applicationConfig.defaultSecurityHeaders) {
       const { SecurityHeaders: SecurityHeaders2 } = require("./plugins/middleware/security-headers");
-      this.use(SecurityHeaders2(this.applicationConfig.securityHeaders === true ? {} : this.applicationConfig.securityHeaders));
+      this.use(SecurityHeaders2(this.applicationConfig.defaultSecurityHeaders === true ? {} : this.applicationConfig.defaultSecurityHeaders));
     }
     if (this.applicationConfig.adapter !== "wintercg") {
       this.dbPromise = this.initDatastore().catch((err) => {
         this.logger?.debug("Failed to initialize default datastore", { error: err });
       });
     }
+    if (this.applicationConfig.enablePromiseMonkeypatch) {
+      enablePromisePatch();
+      const processRef = typeof process !== "undefined" ? process : void 0;
+      if (processRef && processRef.on) {
+        processRef.on("unhandledRejection", (reason, promise) => {
+          const ctx = promise?.[kContext];
+          if (ctx && ctx.store && ctx.store.app === this) {
+            const { requestId } = ctx.store;
+            this.logger.error("Unhandled Rejection in Shokupan Request", {
+              error: reason,
+              requestId,
+              creationStack: ctx.stack
+            });
+          }
+        });
+      }
+    }
   }
   async initDatastore() {
     let engines = this.applicationConfig.surreal?.engines;
@@ -4012,7 +4466,8 @@ class Shokupan extends ShokupanRouter {
       this.get("/.well-known/openapi.yaml", async (ctx) => {
         try {
           await this.openApiSpecPromise;
-          const yaml = jsYaml.dump(this.openApiSpec);
+          const { dump } = await import("js-yaml");
+          const yaml = dump(this.openApiSpec);
           return ctx.send(yaml, { status: 200, headers: { "content-type": "application/yaml" } });
         } catch (e) {
           this.logger?.error("Failed to generate OpenAPI YAML", { error: e });
@@ -4203,7 +4658,8 @@ class Shokupan extends ShokupanRouter {
    */
   async fetch(req, server) {
     if (this.applicationConfig.enableTracing) {
-      const tracer2 = api.trace.getTracer("shokupan.application");
+      const { trace, context } = await import("@opentelemetry/api");
+      const tracer = trace.getTracer("shokupan.application");
       const store = asyncContext.getStore();
       const attrs = {
         attributes: {
@@ -4212,8 +4668,8 @@ class Shokupan extends ShokupanRouter {
         }
       };
       const parent = store?.span;
-      const ctx = parent ? api.trace.setSpan(api.context.active(), parent) : void 0;
-      return tracer2.startActiveSpan(`${req.method} ${new URL(req.url).pathname}`, attrs, ctx, (span) => {
+      const ctx = parent ? trace.setSpan(context.active(), parent) : void 0;
+      return tracer.startActiveSpan(`${req.method} ${new URL(req.url).pathname}`, attrs, ctx, (span) => {
         const ctxStore = new RequestContextStore();
         ctxStore.span = span;
         ctxStore.request = req;
@@ -4221,16 +4677,19 @@ class Shokupan extends ShokupanRouter {
       });
     }
     if (this.applicationConfig.enableAsyncLocalStorage) {
+      const requestId = this.applicationConfig.idGenerator?.() ?? nanoid.nanoid();
       const ctxStore = new RequestContextStore();
       ctxStore.request = req;
-      return asyncContext.run(ctxStore, () => this.handleRequest(req, server));
+      ctxStore["requestId"] = requestId;
+      ctxStore["app"] = this;
+      return asyncContext.run(ctxStore, () => this.handleRequest(req, server, requestId));
     }
     return this.handleRequest(req, server);
   }
-  async handleRequest(req, server) {
+  async handleRequest(req, server, requestId) {
     const request = req;
     const controller = new AbortController();
-    const ctx = new ShokupanContext(request, server, void 0, this, controller.signal, this.applicationConfig.enableMiddlewareTracking);
+    const ctx = new ShokupanContext(request, server, void 0, this, controller.signal, this.applicationConfig.enableMiddlewareTracking, requestId);
     const handle = async () => {
       if (this.cpuMonitor && this.cpuMonitor.getUsage() > (this.applicationConfig.autoBackpressureLevel ?? 60)) {
         const msg = "Too Many Requests (CPU Backpressure)";
@@ -4251,9 +4710,91 @@ class Shokupan extends ShokupanRouter {
             ctx[$routeMatched] = true;
             ctx.params = match.params;
             if (bodyParsing) await bodyParsing;
+            if (this.applicationConfig.enableMiddlewareTracking) {
+              const handler = match.handler;
+              const meta = handler.metadata;
+              if (meta) {
+                const trackingStartTime = performance.now();
+                const handlerName = meta.name || handler.name || "anonymous";
+                ctx.handlerStack.push({
+                  name: handlerName,
+                  file: meta.file,
+                  line: meta.line,
+                  isBuiltin: meta.isBuiltin,
+                  startTime: trackingStartTime,
+                  duration: -1
+                });
+                try {
+                  const res = await handler(ctx);
+                  const duration = performance.now() - trackingStartTime;
+                  const stackItem = ctx.handlerStack[ctx.handlerStack.length - 1];
+                  if (stackItem) stackItem.duration = duration;
+                  Promise.resolve().then(async () => {
+                    try {
+                      const db = this.db;
+                      if (!db) return;
+                      const timestamp = Date.now();
+                      await db.upsert(new surrealdb.RecordId("middleware_tracking", {
+                        timestamp,
+                        name: handlerName
+                      }), {
+                        name: handlerName,
+                        path: ctx.path,
+                        timestamp,
+                        duration,
+                        file: meta.file,
+                        line: meta.line,
+                        error: void 0,
+                        metadata: {
+                          isBuiltin: meta.isBuiltin,
+                          pluginName: meta.pluginName
+                        }
+                      });
+                    } catch (e) {
+                    }
+                  });
+                  return res;
+                } catch (err) {
+                  const duration = performance.now() - trackingStartTime;
+                  const stackItem = ctx.handlerStack[ctx.handlerStack.length - 1];
+                  if (stackItem) stackItem.duration = duration;
+                  Promise.resolve().then(async () => {
+                    try {
+                      const db = this.db;
+                      if (!db) return;
+                      const timestamp = Date.now();
+                      await db.upsert(new surrealdb.RecordId("middleware_tracking", {
+                        timestamp,
+                        name: handlerName
+                      }), {
+                        name: handlerName,
+                        path: ctx.path,
+                        timestamp,
+                        duration,
+                        file: meta.file,
+                        line: meta.line,
+                        error: String(err),
+                        metadata: {
+                          isBuiltin: meta.isBuiltin,
+                          pluginName: meta.pluginName
+                        }
+                      });
+                    } catch (e) {
+                    }
+                  });
+                  throw err;
+                }
+              }
+            }
             return match.handler(ctx);
           }
-          return null;
+          if (ctx.upgrade()) {
+            return void 0;
+          }
+          if (ctx.response.status !== HTTP_STATUS.OK) {
+            return ctx.send(null, { status: ctx.response.status, headers: ctx.response.headers });
+          }
+          throw new NotFoundError();
         });
         let response;
         if (result instanceof Response) {
@@ -4272,14 +4813,7 @@ class Shokupan extends ShokupanRouter {
             }
             response = ctx.send(null, { status, headers: ctx.response.headers });
           } else {
-            if (ctx.upgrade()) {
-              return void 0;
-            }
-            if (ctx.response.status !== HTTP_STATUS.OK) {
-              response = ctx.send(null, { status: ctx.response.status, headers: ctx.response.headers });
-            } else {
-              response = ctx.text("Not Found", HTTP_STATUS.NOT_FOUND);
-            }
+            throw new NotFoundError();
           }
         } else if (typeof result === "object") {
           response = ctx.json(result);
@@ -4646,6 +5180,37 @@ function Event(eventName) {
 function RateLimit(options) {
   return Use(RateLimitMiddleware(options));
 }
+function Tool(options) {
+  return (target, propertyKey, descriptor) => {
+    target[$mcpTools] ??= /* @__PURE__ */ new Map();
+    target[$mcpTools].set(propertyKey, {
+      name: options?.name,
+      description: options?.description,
+      inputSchema: options?.inputSchema
+    });
+  };
+}
+function Prompt(options) {
+  return (target, propertyKey, descriptor) => {
+    target[$mcpPrompts] ??= /* @__PURE__ */ new Map();
+    target[$mcpPrompts].set(propertyKey, {
+      name: options?.name,
+      description: options?.description,
+      arguments: options?.arguments
+    });
+  };
+}
+function Resource(uri, options) {
+  return (target, propertyKey, descriptor) => {
+    target[$mcpResources] ??= /* @__PURE__ */ new Map();
+    target[$mcpResources].set(propertyKey, {
+      uri,
+      name: options?.name,
+      description: options?.description,
+      mimeType: options?.mimeType
+    });
+  };
+}
 function ApiExplorerApp({ spec, base, asyncSpec, config }) {
   const hierarchy = /* @__PURE__ */ new Map();
   const addRoute = (groupKey, route) => {
@@ -5277,7 +5842,7 @@ async function generateAsyncApi(rootRouter, options = {}) {
   let astMiddlewareRegistry = {};
   let applications = [];
   try {
-    const { OpenAPIAnalyzer } = await Promise.resolve().then(() => require("./analyzer-DM-OlRq8.cjs"));
+    const { OpenAPIAnalyzer } = await Promise.resolve().then(() => require("./analyzer-BOtveWL-.cjs"));
     const entrypoint = globalThis.Bun?.main || require.main?.filename || process.argv[1];
     const analyzer2 = new OpenAPIAnalyzer(process.cwd(), entrypoint);
     const analysisResult = await analyzer2.analyze();
@@ -7549,6 +8114,463 @@ class Dashboard {
 function unknownError(ctx) {
   return ctx.json({ error: "Unknown Error" }, 500);
 }
+let isPatched = false;
+function applyMonkeyPatch() {
+  if (isPatched) return;
+  isPatched = true;
+  Error.stackTraceLimit = 50;
+}
+async function readSourceContext(filePath, line, contextLines = 5) {
+  if (!filePath || filePath.startsWith("node:") || filePath.startsWith("bun:") || filePath.includes("node_modules")) {
+    return null;
+  }
+  const path2 = filePath.startsWith("file://") ? filePath.slice(7) : filePath;
+  try {
+    const f = bun.file(path2);
+    if (!await f.exists()) return null;
+    const content = await f.text();
+    const allLines = content.split("\n");
+    const targetIndex = line - 1;
+    if (targetIndex < 0 || targetIndex >= allLines.length) return null;
+    const start = Math.max(0, targetIndex - contextLines);
+    const end = Math.min(allLines.length, targetIndex + contextLines + 1);
+    const subset = allLines.slice(start, end).map((code, i) => ({
+      line: start + i + 1,
+      code,
+      isTarget: start + i + 1 === line
+    }));
+    return {
+      lines: subset,
+      startLine: start + 1,
+      file: path2
+    };
+  } catch (e) {
+    return null;
+  }
+}
+async function renderErrorView(ctx, error) {
+  const frames = [];
+  const cwd = process.cwd();
+  const errorName = error?.name || "Error";
+  const errorMessage = error?.message || "Unknown error occurred";
+  const errorId = error?.id || ctx.requestId || "unknown-id";
+  const errorTimestamp = error?.timestamp ? new Date(error.timestamp).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+  const errorScope = error?.scope || {};
+  const lines = (error?.stack || "").split("\n").slice(1);
+  for (const line of lines) {
+    const match = line.match(/at (?:(.+?)\s+\()?(?:(.+?):(\d+):(\d+))\)?/);
+    if (match) {
+      const [_, method, file, lineNo, colNo] = match;
+      const fileName = file || "";
+      let relativeFile = fileName;
+      if (fileName.startsWith(cwd)) {
+        relativeFile = fileName.slice(cwd.length + 1);
+      }
+      let isInternal = fileName.startsWith("node:") || fileName.startsWith("bun:") || fileName === "undefined" || fileName === "";
+      if (isInternal && (method.includes("setTimeout") || method.includes("setInterval") || method.includes("setImmediate"))) {
+        isInternal = false;
+      }
+      let isShokupan = false;
+      if (fileName.includes("node_modules/@dotglitch/shokupan")) {
+        isShokupan = true;
+      } else if (relativeFile.startsWith("src/") || fileName.includes("/shokupan/dist/")) {
+        isShokupan = true;
+      }
+      const isDependency = fileName.includes("node_modules") && !isShokupan;
+      frames.push({
+        method: method || "<anonymous>",
+        file: fileName,
+        line: parseInt(lineNo),
+        column: parseInt(colNo),
+        isNative: false,
+        isInternal,
+        isShokupan,
+        isDependency,
+        shortFile: fileName.split("/").pop() || fileName,
+        relativeFile
+      });
+    }
+  }
+  let focusFrame = frames.find((f) => !f.isInternal && !f.isShokupan && !f.isDependency && !f.isNative);
+  if (!focusFrame) focusFrame = frames[0];
+  let sourceContext = null;
+  if (focusFrame && focusFrame.file && !focusFrame.isInternal) {
+    sourceContext = await readSourceContext(focusFrame.file, focusFrame.line, 8);
+  }
+  const renderFrames = frames.map((frame, index) => {
+    const classes = [
+      "stack-entry",
+      frame.isInternal ? "internal" : "",
+      frame.isShokupan ? "shokupan" : "",
+      frame.isDependency ? "dependency" : "",
+      frame === focusFrame ? "active" : ""
+    ].join(" ");
+    const fileLink = `vscode://file/${frame.file}:${frame.line}:${frame.column}`;
+    return `
+            <li class="${classes}">
+                <a href="${fileLink}" style="text-decoration:none; color:inherit; display:block">
+                    <div class="stack-method">${frame.method === "<anonymous>" ? "Anonymous" : frame.method}</div>
+                    <div class="stack-file">${frame.relativeFile}:${frame.line}</div>
+                </a>
+            </li>
+        `;
+  }).join("");
+  const highlightCode = (code) => {
+    return code.replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/(")(.*?)(")/g, '<span style="color:#a5d6ff">$1$2$3</span>').replace(/(')(.*?)(')/g, '<span style="color:#a5d6ff">$1$2$3</span>').replace(/(`)(.*?)(`)/g, '<span style="color:#a5d6ff">$1$2$3</span>').replace(/\b(const|let|var|function|class|import|export|from|return|if|else|switch|case|default|break|continue|try|catch|finally|throw|new|async|await|interface|type|extends|implements|public|private|protected|static|readonly|true|false|null|undefined)\b/g, '<span style="color:#ff7b72">$1</span>').replace(/(=>|===|==|!=|!==|\|\||&&|\+|\-|\*|\/|%|\+\+|\-\-)/g, '<span style="color:#ff7b72">$1</span>').replace(/\b([A-Z][a-zA-Z0-9_]*)\b/g, '<span style="color:#79c0ff">$1</span>').replace(/\b([a-zA-Z0-9_]+)(?=\()/g, '<span style="color:#d2a8ff">$1</span>').replace(/(\/\/.*)/g, '<span style="color:#8b949e; font-style:italic">$1</span>');
+  };
+  if (sourceContext) {
+    sourceContext.lines.map((l) => `
+            <div class="code-line ${l.isTarget ? "target" : ""}">
+                <div class="line-number">${l.line}</div>
+                <div class="line-content">${highlightCode(l.code)}</div>
+            </div>
+        `).join("");
+  }
+  const renderKV = (data) => {
+    if (!data || Object.keys(data).length === 0) return '<div style="color:var(--text-muted)">None</div>';
+    return `<table class="kv-table">
+            ${Object.entries(data).map(([k, v]) => {
+      let displayVal = String(v);
+      let valClass = "";
+      if (typeof v === "number") {
+        valClass = "kv-val-number";
+      } else if (typeof v === "boolean") {
+        valClass = "kv-val-bool";
+      } else if (typeof v === "object" && v !== null) {
+        try {
+          displayVal = JSON.stringify(v, null, 2);
+          valClass = "kv-val-json";
+        } catch (e) {
+          displayVal = "[Circular]";
+        }
+      }
+      return `
+                <tr>
+                    <td class="kv-key">${k}</td>
+                    <td class="kv-val ${valClass}">${displayVal}</td>
+                </tr>`;
+    }).join("")}
+        </table>`;
+  };
+  const ICON_COPY = `<svg class="icon" viewBox="0 0 24 24"><path d="M16 1H4C2.9 1 2 1.9 2 3V17H4V3H16V1ZM19 5H8C6.9 5 6 5.9 6 7V21C6 22.1 6.9 23 8 23H19C20.1 23 21 22.1 21 21V7C21 5.9 20.1 5 19 5ZM19 21H8V7H19V21Z"/></svg>`;
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>${errorName}: ${errorMessage}</title>
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/line-numbers/prism-line-numbers.min.css" rel="stylesheet" />
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/line-highlight/prism-line-highlight.min.css" rel="stylesheet" />
+    <link href="/_shokupan/error-view/prismjs.theme.css" rel="stylesheet" />
+    <link href="/_shokupan/error-view/styles.css" rel="stylesheet" />
+    <link href="/_shokupan/error-view/theme.css" rel="stylesheet" />
+
+</head>
+<body class="">
+    
+    <div class="page">
+        <!-- HEADER -->
+        <header class="chapter-header">
+            <div class="chapter-meta">
+                <div class="meta-item">
+                     <span>${ctx.method}</span>
+                </div>
+                <div class="meta-item">
+                     <span>${ctx.url.pathname}</span>
+                </div>
+                <div class="meta-item">
+                     <span>${ctx.response.status || 500}</span>
+                </div>
+                <div class="meta-item" style="margin-left:auto">
+                     <span class="id-badge" onclick="copyText('${errorId}')" title="Copy ID">ID: ${errorId}</span>
+                </div>
+            </div>
+            
+            <h1 class="error-title">${errorName}</h1>
+            
+            <div class="error-message-container">
+                <h2 class="error-message">${errorMessage}</h2>
+                <button class="action-btn" onclick="copyText('${errorMessage.replace(/'/g, "\\'")}')" title="Copy Message" style="padding:4px 8px">
+                    ${ICON_COPY}
+                </button>
+            </div>
+            
+            <div class="actions-bar">
+                <button class="action-btn" onclick="copyText()">
+                    ${ICON_COPY} Copy Error
+                </button>
+                <button class="action-btn" onclick="document.getElementById('raw-modal').style.display='flex'">
+                     View Raw Error
+                </button>
+            </div>
+        </header>
+
+        <!-- CODE FIGURE -->
+        <section class="figure">
+            <div class="figure-caption">
+                ${focusFrame ? `<a href="vscode://file${focusFrame.file}:${focusFrame.line}" style="color:var(--text-muted); text-decoration:none">${focusFrame ? focusFrame.relativeFile : sourceContext?.file || "Unknown Source"}</a>` : ""}
+            </div>
+            <div class="figure-body">
+                ${sourceContext ? `
+                <pre class="line-numbers" data-line="${sourceContext.lines.find((l) => l.isTarget)?.line}" data-start="${sourceContext.lines[0].line}"><code class="language-typescript">${sourceContext.lines.map((l) => l.code.replace(/</g, "&lt;").replace(/>/g, "&gt;")).join("\n")}</code></pre>
+                ` : `<div style="padding: 2rem; color: var(--text-muted); text-align: center;">Source code not available.</div>`}
+            </div>
+        </section>
+
+        <!-- NARRATIVE STACK -->
+        <section class="narrative">
+            <div class="section-title">
+                <span>Stack Trace</span>
+                <div class="filter-group">
+                    <span class="badge" onclick="this.classList.toggle('active'); document.body.classList.toggle('show-internals')">Internals</span>
+                    <span class="badge" onclick="this.classList.toggle('active'); document.body.classList.toggle('show-shokupan')">Framework</span>
+                    <span class="badge" onclick="this.classList.toggle('active'); document.body.classList.toggle('show-dependencies')">Dependencies</span>
+                </div>
+            </div>
+            <ul class="stack-list">
+                ${renderFrames}
+            </ul>
+        </section>
+
+        <!-- APPENDICES -->
+        <section class="appendix">
+             <div class="section-title">Context & Environment</div>
+             <div class="appendix-grid">
+                 <div class="data-block">
+                     <h3>Request</h3>
+                     ${renderKV({
+    id: errorId,
+    timestamp: errorTimestamp,
+    ...errorScope || {}
+  })}
+                 </div>
+                 <div class="data-block">
+                     <h3>Headers</h3>
+                     ${renderKV(Object.fromEntries(ctx.headers))}
+                 </div>
+                 <div class="data-block">
+                     <h3>Query & Params</h3>
+                     ${renderKV({ ...ctx.params, ...ctx.query })}
+                 </div>
+             </div>
+        </section>
+    </div>
+    
+    <!-- RAW ERROR MODAL -->
+    <div id="raw-modal" class="modal-overlay" onclick="if(event.target === this) this.style.display='none'">
+        <div class="modal-content">
+            <div class="modal-header">
+                <span>Raw Error Object</span>
+                <button class="action-btn" onclick="document.getElementById('raw-modal').style.display='none'">Close</button>
+            </div>
+            <div class="modal-body" id="raw-content"></div>
+        </div>
+    </div>
+
+    <!-- PrismJS Scripts -->
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/prism.min.js"><\/script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/components/prism-typescript.min.js"><\/script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/line-numbers/prism-line-numbers.min.js"><\/script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/line-highlight/prism-line-highlight.min.js"><\/script>
+
+    <script>
+        // Prepare Raw Error
+        // circular ref safe stringify
+        const getCircularReplacer = () => {
+          const seen = new WeakSet();
+          return (key, value) => {
+            if (typeof value === "object" && value !== null) {
+              if (seen.has(value)) {
+                return "[Circular]";
+              }
+              seen.add(value);
+            }
+            return value;
+          };
+        };
+        
+        // Inject error data from SERVER side
+        const rawError = ${(() => {
+    const serializeError = (err) => {
+      const obj = {
+        name: err.name,
+        message: err.message,
+        stack: err.stack,
+        ...err
+        // Spread enumerable props
+      };
+      if (err.cause) obj.cause = err.cause;
+      if (err.code) obj.code = err.code;
+      if (err.status) obj.status = err.status;
+      if (err.statusCode) obj.statusCode = err.statusCode;
+      return JSON.stringify(obj, (key, value) => {
+        if (key === "structuredStack") return void 0;
+        return value;
+      }, 2);
+    };
+    return serializeError(error);
+  })()};
+        
+        // At this point 'rawError' is an Object in Client JS (because serializeError returned a JSON string)
+        const RAW_ERROR_JSON = JSON.stringify(rawError, getCircularReplacer(), 2);
+        // "Normally printed" usually means standard stacktrace string which includes name/message
+        const RAW_ERROR_TEXT = rawError.stack || (rawError.name + ': ' + rawError.message);
+        
+        document.getElementById('raw-content').innerText = RAW_ERROR_JSON;
+
+        function copyText(text) {
+             if (!text) text = RAW_ERROR_TEXT; // Default to text representation (Message + Stack)
+             navigator.clipboard.writeText(text).then(() => {
+                console.log('Copied');
+             });
+        }
+    <\/script>
+</body>
+</html>`;
+}
+function renderStatusView(ctx, status, error) {
+  const title = `${status} ${error.message || "Error"}`;
+  const method = ctx.method;
+  const path2 = ctx.url.pathname;
+  const css = `
+        body {
+            background: var(--bg-primary);
+            color: var(--text-primary);
+            font-family: var(--shokupan-font);
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            height: 100vh;
+            margin: 0;
+            overflow: hidden;
+        }
+        .container {
+            text-align: center;
+            animation: fadeIn 0.3s ease-out;
+            background: var(--bg-card);
+            padding: 3rem 4rem;
+            border-radius: 16px;
+            border: 1px solid var(--card-border);
+            box-shadow: 0 10px 30px rgba(0,0,0,0.3);
+            max-width: 600px;
+        }
+        h1 {
+            font-size: 6rem;
+            margin: 0;
+            color: var(--primary);
+            line-height: 1;
+            font-weight: 800;
+            letter-spacing: -2px;
+            text-shadow: 0 4px 20px rgba(255, 179, 128, 0.2); 
+        }
+        h2 {
+            font-size: 1.5rem;
+            margin: 1rem 0 2rem 0;
+            font-weight: 400;
+            color: var(--text-secondary);
+        }
+        .meta {
+            color: var(--text-muted);
+            font-family: var(--shokupan-font-mono);
+            font-size: 1rem;
+            background: var(--bg-primary);
+            padding: 0.75rem 1.5rem;
+            border-radius: 8px;
+            display: inline-block;
+            border: 1px solid var(--border-color);
+        }
+        .method {
+            font-weight: bold;
+            margin-right: 0.5rem;
+            padding: 0.2rem 0.5rem;
+            border-radius: 4px;
+        }
+        .path {
+            color: var(--text-primary);
+        }
+        @keyframes fadeIn {
+            from { opacity: 0; transform: translateY(20px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+    `;
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${title}</title>
+    <link href="/_shokupan/error-view/theme.css" rel="stylesheet" />
+    <style>${css}</style>
+</head>
+<body>
+    <div class="container">
+        <h1>${status}</h1>
+        <h2>${error.message || "An error occurred"}</h2>
+        <div class="meta">
+            <span class="method badge-${method}">${method}</span>
+            <span class="path">${path2}</span>
+        </div>
+    </div>
+</body>
+</html>`;
+}
+class ErrorView {
+  constructor(config = {}) {
+    this.config = config;
+  }
+  name = "error-view";
+  async onInit(app) {
+    applyMonkeyPatch();
+    const errorViewMiddleware = async (ctx, next) => {
+      try {
+        return await next();
+      } catch (err) {
+        const accept = ctx.get("accept") || "";
+        if (!accept.includes("text/html")) {
+          throw err;
+        }
+        if (!err.timestamp) {
+          Object.defineProperty(err, "timestamp", {
+            value: Date.now(),
+            enumerable: false,
+            writable: true,
+            configurable: true
+          });
+        }
+        if (!err.id) {
+          Object.defineProperty(err, "id", {
+            value: ctx.requestId,
+            enumerable: false,
+            writable: true,
+            configurable: true
+          });
+        }
+        if (!err.scope) {
+          const store = asyncContext.getStore();
+          if (store) {
+            Object.defineProperty(err, "scope", {
+              value: { ...store },
+              enumerable: false,
+              writable: true,
+              configurable: true
+            });
+          }
+        }
+        const status = getErrorStatus(err);
+        if (status === 404 || status === 401 || status === 403) {
+          const html2 = await renderStatusView(ctx, status, err);
+          return ctx.html(html2, status);
+        }
+        const html = await renderErrorView(ctx, err);
+        return ctx.html(html, status);
+      }
+    };
+    Object.defineProperty(errorViewMiddleware, "name", { value: "ErrorViewMiddleware" });
+    const { join } = await import("path");
+    const assetDir = join(void 0, "assets");
+    app.static("/_shokupan/error-view", assetDir);
+    app.use(errorViewMiddleware);
+  }
+}
 class GraphQLApolloPlugin extends ShokupanRouter {
   // Use generic any or verify type
   constructor(pluginOptions) {
@@ -7623,6 +8645,377 @@ class GraphQLApolloPlugin extends ShokupanRouter {
     });
   }
 }
+class GraphQLYogaPlugin extends ShokupanRouter {
+  constructor(pluginOptions) {
+    super();
+    this.pluginOptions = pluginOptions;
+    this.pluginOptions.path ??= "/graphql";
+  }
+  yoga;
+  async onInit(app, options) {
+    const { createYoga } = await import("graphql-yoga");
+    const path2 = options?.path || this.pluginOptions.path || "/graphql";
+    this.yoga = createYoga({
+      ...this.pluginOptions.yogaConfig,
+      graphqlEndpoint: path2
+    });
+    app.mount(path2, this);
+    const handler = async (ctx) => {
+      let body;
+      if (ctx.req.method !== "GET" && ctx.req.method !== "HEAD") {
+        body = await ctx.body();
+        if (typeof body === "object" && body !== null) {
+          body = JSON.stringify(body);
+        }
+      }
+      const response = await this.yoga.fetch(
+        new Request(ctx.req.url, {
+          method: ctx.req.method,
+          headers: ctx.req.headers,
+          body
+        }),
+        {
+          ...ctx
+        }
+      );
+      response.headers.forEach((value, key) => {
+        ctx.set(key, value);
+      });
+      const text = await response.text();
+      return ctx.send(text, {
+        status: response.status
+      });
+    };
+    this.get("/", handler);
+    this.post("/", handler);
+    this.get("/*", handler);
+    this.post("/*", handler);
+  }
+}
+class HtmxPlugin {
+  async onInit(app) {
+    app.use(this.middleware());
+  }
+  middleware() {
+    return async (ctx, next) => {
+      Object.defineProperty(ctx, "isHtmx", {
+        get: () => ctx.req.headers.has("hx-request")
+      });
+      Object.defineProperty(ctx, "isHtmxBoosted", {
+        get: () => ctx.req.headers.has("hx-boosted")
+      });
+      ctx.trigger = (event, options) => {
+        let headerName = "HX-Trigger";
+        if (options?.after === "settle") headerName = "HX-Trigger-After-Settle";
+        if (options?.after === "swap") headerName = "HX-Trigger-After-Swap";
+        let value = JSON.stringify(event);
+        if (typeof event === "string") {
+          value = event;
+        } else {
+          value = JSON.stringify(event);
+        }
+        ctx.set(headerName, value);
+      };
+      ctx.pushUrl = (url) => {
+        ctx.set("HX-Push-Url", url === false ? "false" : url);
+      };
+      ctx.htmxRedirect = (url) => {
+        ctx.set("HX-Redirect", url);
+      };
+      ctx.refresh = () => {
+        ctx.set("HX-Refresh", "true");
+      };
+      return next();
+    };
+  }
+}
+function Idempotency(options = {}) {
+  const headerName = options.header || "Idempotency-Key";
+  options.ttl || 24 * 60 * 60 * 1e3;
+  let RecordIdClass;
+  const idempotencyMiddleware = async function IdempotencyMiddleware(ctx, next) {
+    const key = ctx.headers.get(headerName);
+    if (!key) {
+      return next();
+    }
+    try {
+      if (!RecordIdClass) {
+        const mod = await import("surrealdb");
+        RecordIdClass = mod.RecordId;
+      }
+      const stored = await ctx.app.db.select(new RecordIdClass("idempotency", key));
+      if (stored) {
+        const responseHeaders = new Headers(stored.headers);
+        responseHeaders.set("X-Idempotency-Hit", "true");
+        return new Response(stored.body, {
+          status: stored.status,
+          headers: responseHeaders
+        });
+      }
+    } catch (e) {
+      console.error("Idempotency read error:", e);
+    }
+    const result = await next();
+    let response;
+    if (result instanceof Response) {
+      response = result;
+    } else if ((result === null || result === void 0) && ctx[$finalResponse] instanceof Response) {
+      response = ctx[$finalResponse];
+    } else if (result !== null && result !== void 0) {
+      if (typeof result === "object") {
+        response = await ctx.json(result);
+      } else {
+        response = await ctx.text(String(result));
+      }
+    }
+    if (response instanceof Response) {
+      const clone = response.clone();
+      const bodyText = await clone.text();
+      const headers = {};
+      clone.headers.forEach((v, k) => {
+        headers[k] = v;
+      });
+      const toStore = {
+        status: clone.status,
+        headers,
+        body: bodyText,
+        timestamp: Date.now()
+      };
+      try {
+        await ctx.app.db.upsert(new RecordIdClass("idempotency", key), toStore);
+      } catch (e) {
+        console.error("Idempotency write error:", e);
+      }
+      return response;
+    }
+    return result;
+  };
+  idempotencyMiddleware.isBuiltin = true;
+  idempotencyMiddleware.pluginName = "Idempotency";
+  return idempotencyMiddleware;
+}
+class MCPServerPlugin {
+  constructor(options = {}) {
+    this.options = options;
+    options.allowIntrospection ??= true;
+    options.allowToolExecution ??= true;
+    options.path ??= "/mcp";
+    if (!options.path.startsWith("/")) {
+      options.path = "/" + options.path;
+    }
+    options.rootDir ??= process.cwd();
+  }
+  router = new ShokupanRouter();
+  analyzer;
+  onInit(app) {
+    this[$appRoot] = app;
+    this.analyzer = new analyzer_impl.OpenAPIAnalyzer(this.options.rootDir);
+    if (this.options.allowIntrospection) {
+      this.registerTools();
+      this.registerResources();
+      this.registerPrompts();
+    }
+    app.onStart(async () => {
+      app.mount(this.options.path, this.router);
+      this.collectAppMcpItems(app);
+      this.setupRoutes();
+      this.router.metadata = {
+        file: void 0,
+        line: 1,
+        name: "MCPServerPlugin",
+        pluginName: "MCP Server"
+      };
+    });
+  }
+  collectAppMcpItems(app) {
+    const collect = (router) => {
+      if (router.mcpProtocol) {
+        this.router.mcpProtocol.merge(router.mcpProtocol);
+      }
+      router[$childRouters]?.forEach(collect);
+    };
+    collect(app);
+  }
+  setupRoutes() {
+    this.router.get("", (ctx) => {
+      const endpointUrl = `${ctx.protocol}://${ctx.host}${this.options.path}`;
+      const enc = new TextEncoder();
+      return new Response(
+        new ReadableStream({
+          start(controller) {
+            controller.enqueue(enc.encode(`event: endpoint
+data: ${JSON.stringify(endpointUrl)}
+
+`));
+          },
+          cancel() {
+          }
+        }),
+        {
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive"
+          }
+        }
+      );
+    });
+    this.router.post("", async (ctx) => {
+      let parsedBody;
+      try {
+        parsedBody = await ctx.body();
+      } catch (e) {
+        return ctx.json({
+          jsonrpc: "2.0",
+          id: null,
+          error: { code: -32700, message: "Parse error" }
+        }, 400);
+      }
+      const response = await this.router.mcpProtocol.handleMessage(parsedBody);
+      if (response) {
+        return ctx.json(response);
+      }
+      return ctx.text("", 204);
+    });
+  }
+  registerTools() {
+    const ensureExecutionAllowed = () => {
+      if (!this.options.allowToolExecution) {
+        throw new Error("Tool execution is disabled.");
+      }
+    };
+    this.router.tool(
+      "list_endpoints",
+      {},
+      async () => {
+        ensureExecutionAllowed();
+        const { applications } = await this.analyzer.analyze();
+        const endpoints = applications.flatMap(
+          (app) => app.routes.map((r) => ({
+            method: r.method,
+            path: r.path,
+            handler: r.handlerName,
+            summary: r.summary
+          }))
+        );
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(endpoints, null, 2)
+          }]
+        };
+      }
+    );
+    this.router.tool(
+      "get_endpoint_details",
+      {
+        type: "object",
+        properties: {
+          method: { type: "string" },
+          path: { type: "string" }
+        },
+        required: ["method", "path"]
+      },
+      async ({ method, path: path2 }) => {
+        ensureExecutionAllowed();
+        const { applications } = await this.analyzer.analyze();
+        const route = applications.flatMap((app) => app.routes).find((r) => r.method.toUpperCase() === method.toUpperCase() && r.path === path2);
+        if (!route) {
+          return {
+            content: [{ type: "text", text: `Endpoint ${method} ${path2} not found.` }],
+            isError: true
+          };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(route, null, 2)
+          }]
+        };
+      }
+    );
+  }
+  registerResources() {
+    this.router.resource(
+      "mcp://api/openapi.json",
+      {
+        name: "openapi-spec",
+        mimeType: "application/json"
+      },
+      async (uri) => {
+        const { applications } = await this.analyzer.analyze();
+        const endpoints = applications.flatMap(
+          (app) => app.routes.map((r) => ({
+            method: r.method,
+            path: r.path,
+            handler: r.handlerName,
+            summary: r.summary,
+            requestTypes: r.requestTypes,
+            responseType: r.responseType
+          }))
+        );
+        return {
+          contents: [{
+            uri,
+            text: JSON.stringify(endpoints, null, 2)
+          }]
+        };
+      }
+    );
+    this.router.resource(
+      "mcp://api/routes/{method}/{path}/source",
+      {
+        name: "route-source",
+        mimeType: "text/typescript"
+      },
+      async (uri) => {
+        const parts = uri.replace("mcp://", "").split("/");
+        parts[2];
+        throw new Error("Dynamic resource reading not fully implemented in lightweight version yet.");
+      }
+    );
+  }
+  registerPrompts() {
+    this.router.prompt(
+      "generate-client",
+      [
+        { name: "method", required: true },
+        { name: "path", required: true }
+      ],
+      async ({ method, path: path2 }) => {
+        const { applications } = await this.analyzer.analyze();
+        const route = applications.flatMap((app) => app.routes).find((r) => r.method.toUpperCase() === method.toUpperCase() && r.path === path2);
+        if (!route) {
+          return {
+            messages: [{
+              role: "user",
+              content: {
+                type: "text",
+                text: `Start a new task to create a client for ${method} ${path2}. The endpoint was not found in the current analysis.`
+              }
+            }]
+          };
+        }
+        return {
+          messages: [{
+            role: "user",
+            content: {
+              type: "text",
+              text: `Please generate a TypeScript client function for the following endpoint:
+Method: ${route.method}
+Path: ${route.path}
+Summary: ${route.summary || "N/A"}
+Request Types: ${JSON.stringify(route.requestTypes, null, 2)}
+Response Type: ${route.responseType || "unknown"}
+
+Use fetch or axios. Ensure proper typing.`
+            }
+          }]
+        };
+      }
+    );
+  }
+}
 class ScalarPlugin extends ShokupanRouter {
   constructor(pluginOptions = {}) {
     pluginOptions.config ??= {};
@@ -7811,6 +9204,79 @@ class ScalarPlugin extends ShokupanRouter {
     }
   }
 }
+function attachSocketIOBridge(io, app) {
+  io.on("connection", (socket) => {
+    socket.onAny(async (event, ...args) => {
+      if (event === "shokupan:request" || event === "http") {
+        return;
+      }
+      const handler = app.findEvent(event);
+      if (handler) {
+        const data = args[0];
+        const req = new ShokupanRequest({
+          url: `socketio://${app.applicationConfig.hostname || "localhost"}/event/${event}`,
+          method: "POST",
+          headers: new Headers({ "content-type": "application/json" }),
+          body: JSON.stringify(data)
+        });
+        const ctx = new ShokupanContext(req, app.server);
+        ctx[$ws] = socket;
+        ctx.io = io;
+        try {
+          for (let i = 0; i < handler.length; i++) {
+            await handler[i](ctx);
+          }
+        } catch (e) {
+          await app.runHooks("onError", ctx, e);
+          if (app.applicationConfig["websocketErrorHandler"]) {
+            await app.applicationConfig["websocketErrorHandler"](e, ctx);
+          } else {
+            console.error(`Error in event ${event}:`, e);
+          }
+        }
+      }
+    });
+    if (app.applicationConfig["enableHttpBridge"]) {
+      socket.on("shokupan:request", async (payload, callback) => {
+        try {
+          const { method, path: path2, headers, body } = payload;
+          const url = new URL(path2, `http://${app.applicationConfig.hostname || "localhost"}:3000`);
+          const req = new Request(url.toString(), {
+            method,
+            headers,
+            body: typeof body === "object" ? JSON.stringify(body) : body
+          });
+          const res = await app.fetch(req);
+          let resBody = await res.text();
+          try {
+            resBody = JSON.parse(resBody);
+          } catch {
+          }
+          const resHeaders = {};
+          res.headers.forEach((v, k) => resHeaders[k] = v);
+          if (typeof callback === "function") {
+            await callback({
+              status: res.status,
+              headers: resHeaders,
+              body: resBody
+            });
+          } else {
+            socket.emit("shokupan:response", {
+              id: payload.id,
+              status: res.status,
+              headers: resHeaders,
+              body: resBody
+            });
+          }
+        } catch (e) {
+          if (typeof callback === "function") {
+            callback({ status: 500, body: { error: e.message } });
+          }
+        }
+      });
+    }
+  });
+}
 function createLimitStream(maxSize) {
   let size = 0;
   return new TransformStream({
@@ -8453,6 +9919,168 @@ function enableOpenApiValidation(app) {
     precompileValidators(app, spec);
   });
 }
+function isPrivateIP(ip) {
+  const ipv4Patterns = [
+    /^10\./,
+    // 10.0.0.0/8
+    /^172\.(1[6-9]|2[0-9]|3[01])\./,
+    // 172.16.0.0/12
+    /^192\.168\./,
+    // 192.168.0.0/16
+    /^127\./,
+    // 127.0.0.0/8 (loopback)
+    /^169\.254\./,
+    // 169.254.0.0/16 (link-local)
+    /^0\.0\.0\.0$/
+    // 0.0.0.0
+  ];
+  const ipv6Patterns = [
+    /^::1$/,
+    // loopback
+    /^fe80:/,
+    // link-local
+    /^fc00:/,
+    // unique local
+    /^fd00:/
+    // unique local
+  ];
+  for (const pattern of ipv4Patterns) {
+    if (pattern.test(ip)) return true;
+  }
+  for (const pattern of ipv6Patterns) {
+    if (pattern.test(ip.toLowerCase())) return true;
+  }
+  return false;
+}
+function Proxy$1(options) {
+  const targetUrl = new URL(options.target);
+  if (!["http:", "https:"].includes(targetUrl.protocol)) {
+    throw new Error("Invalid proxy target protocol. Only http and https are allowed.");
+  }
+  if (options.allowedHosts && options.allowedHosts.length > 0) {
+    if (!options.allowedHosts.includes(targetUrl.hostname)) {
+      throw new Error(`Target hostname ${targetUrl.hostname} is not in the allowed hosts list.`);
+    }
+  }
+  if (!options.allowPrivateIPs && isPrivateIP(targetUrl.hostname)) {
+    throw new Error("Proxying to private IP addresses is not allowed.");
+  }
+  return async (ctx, next) => {
+    const req = ctx.request;
+    if (options.ws && req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+      const success = ctx.upgrade({
+        data: {
+          handler: {
+            open: (ws) => handleWSOpen(ws, ctx, options, targetUrl),
+            message: (ws, message) => handleWSMessage(ws, message),
+            close: (ws, code, reason) => handleWSClose(ws, code, reason),
+            drain: (ws) => handleWSDrain()
+          }
+        }
+      });
+      if (success) {
+        return void 0;
+      }
+    }
+    let path2 = ctx.url.pathname;
+    if (options.pathRewrite) {
+      path2 = options.pathRewrite(path2);
+    }
+    const url = new URL(path2 + ctx.url.search, targetUrl);
+    if (!["http:", "https:"].includes(url.protocol)) {
+      return ctx.text("Invalid protocol in proxied URL", 400);
+    }
+    const headers = new Headers(req.headers);
+    if (options.changeOrigin) {
+      headers.set("host", targetUrl.host);
+    }
+    if (options.headers) {
+      Object.entries(options.headers).forEach(([key, value]) => headers.set(key, value));
+    }
+    headers.delete("connection");
+    headers.delete("keep-alive");
+    headers.delete("proxy-authenticate");
+    headers.delete("proxy-authorization");
+    headers.delete("te");
+    headers.delete("trailer");
+    headers.delete("transfer-encoding");
+    headers.delete("upgrade");
+    const proxyReq = new Request(url.toString(), {
+      method: req.method,
+      headers,
+      body: req.body,
+      // @ts-ignore - duplex is needed for some node/bun versions for streaming bodies
+      duplex: "half"
+    });
+    const res = await fetch(proxyReq);
+    return new Response(res.body, {
+      status: res.status,
+      statusText: res.statusText,
+      headers: res.headers
+    });
+  };
+}
+const wsMap = /* @__PURE__ */ new WeakMap();
+function handleWSOpen(ws, ctx, options, targetUrl) {
+  let path2 = ctx.url.pathname;
+  if (options.pathRewrite) {
+    path2 = options.pathRewrite(path2);
+  }
+  const url = new URL(path2 + ctx.url.search, targetUrl);
+  url.protocol = targetUrl.protocol.replace("http", "ws");
+  const headers = {};
+  if (options.changeOrigin) {
+    headers["Host"] = targetUrl.host;
+  }
+  ctx.request.headers.forEach((v, k) => {
+    if (!["upgrade", "connection", "sec-websocket-key", "sec-websocket-version", "sec-websocket-extensions"].includes(k.toLowerCase())) {
+      headers[k] = v;
+    }
+  });
+  const upstream = new WebSocket(url.toString());
+  wsMap.set(ws, upstream);
+  const pendingMessages = [];
+  let isConnected = false;
+  upstream.onopen = () => {
+    isConnected = true;
+    while (pendingMessages.length > 0) {
+      const msg = pendingMessages.shift();
+      upstream.send(msg);
+    }
+  };
+  upstream.onmessage = (event) => {
+    ws.send(event.data);
+  };
+  upstream.onclose = (event) => {
+    ws.close(event.code, event.reason);
+  };
+  upstream.onerror = (err) => {
+    console.error("Upstream WebSocket error:", err);
+    ws.close(1011, "Internal Error");
+  };
+  upstream._pendingRequestMessages = pendingMessages;
+  upstream._isConnected = () => isConnected;
+}
+function handleWSMessage(ws, message) {
+  const upstream = wsMap.get(ws);
+  if (!upstream) return;
+  if (upstream._isConnected && upstream._isConnected()) {
+    upstream.send(message);
+  } else {
+    upstream._pendingRequestMessages.push(message);
+  }
+}
+function handleWSClose(ws, code, reason) {
+  const upstream = wsMap.get(ws);
+  if (upstream) {
+    if (upstream.readyState === WebSocket.OPEN) {
+      upstream.close(code, reason);
+    }
+    wsMap.delete(ws);
+  }
+}
+function handleWSDrain(ws) {
+}
 function SecurityHeaders(options = {}) {
   const securityHeadersMiddleware = async function SecurityHeadersMiddleware(ctx, next) {
     const set = (k, v) => ctx.response.set(k, v);
@@ -8665,43 +10293,56 @@ function Session(options) {
       }
       const sessObj = existing;
       Object.defineProperty(sessObj, "id", { value: sessionID, configurable: true });
-      sessObj.save = (cb) => {
-        store.set(sessObj.id, sessObj, cb);
+      sessObj.save = () => {
+        return new Promise((resolve, reject) => {
+          store.set(sessObj.id, sessObj, (err) => {
+            if (err) reject(err);
+            else resolve();
+          });
+        });
       };
-      sessObj.destroy = (cb) => {
-        store.destroy(sessObj.id, (err) => {
-          if (cb) cb(err);
+      sessObj.destroy = () => {
+        return new Promise((resolve, reject) => {
+          store.destroy(sessObj.id, (err) => {
+            if (err) reject(err);
+            else resolve();
+          });
         });
       };
-      sessObj.regenerate = (cb) => {
-        store.destroy(sessObj.id, (err) => {
-          sessionID = generateId(ctx);
-          const keys = Object.keys(sessObj);
-          for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            if (key !== "cookie" && key !== "id" && typeof sessObj[key] !== "function") {
-              delete sessObj[key];
+      sessObj.regenerate = () => {
+        return new Promise((resolve, reject) => {
+          store.destroy(sessObj.id, (err) => {
+            if (err) return reject(err);
+            sessionID = generateId(ctx);
+            const keys = Object.keys(sessObj);
+            for (let i = 0; i < keys.length; i++) {
+              const key = keys[i];
+              if (key !== "cookie" && key !== "id" && typeof sessObj[key] !== "function") {
+                delete sessObj[key];
+              }
             }
-          }
-          Object.defineProperty(sessObj, "id", { value: sessionID, configurable: true });
-          if (cb) cb(err);
+            Object.defineProperty(sessObj, "id", { value: sessionID, configurable: true });
+            resolve();
+          });
         });
       };
       sessObj.undefined = () => {
       };
-      sessObj.reload = (cb) => {
-        store.get(sessObj.id, (err, sess2) => {
-          if (err) return cb(err);
-          if (!sess2) return cb(new Error("Session not found"));
-          const keys = Object.keys(sessObj);
-          for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            if (key !== "cookie" && key !== "id" && typeof sessObj[key] !== "function") {
-              delete sessObj[key];
+      sessObj.reload = () => {
+        return new Promise((resolve, reject) => {
+          store.get(sessObj.id, (err, sess2) => {
+            if (err) return reject(err);
+            if (!sess2) return reject(new Error("Session not found"));
+            const keys = Object.keys(sessObj);
+            for (let i = 0; i < keys.length; i++) {
+              const key = keys[i];
+              if (key !== "cookie" && key !== "id" && typeof sessObj[key] !== "function") {
+                delete sessObj[key];
+              }
             }
-          }
-          Object.assign(sessObj, sess2);
-          cb(null);
+            Object.assign(sessObj, sess2);
+            resolve();
+          });
         });
       };
       sessObj.touch = () => {
@@ -8793,11 +10434,15 @@ exports.$io = $io;
 exports.$isApplication = $isApplication;
 exports.$isMounted = $isMounted;
 exports.$isRouter = $isRouter;
+exports.$mcpPrompts = $mcpPrompts;
+exports.$mcpResources = $mcpResources;
+exports.$mcpTools = $mcpTools;
 exports.$middleware = $middleware;
 exports.$mountPath = $mountPath;
 exports.$parent = $parent;
 exports.$rawBody = $rawBody;
 exports.$requestId = $requestId;
+exports.$resilienceConfig = $resilienceConfig;
 exports.$routeArgs = $routeArgs;
 exports.$routeMatched = $routeMatched;
 exports.$routeMethods = $routeMethods;
@@ -8819,24 +10464,33 @@ exports.Cors = Cors;
 exports.Ctx = Ctx;
 exports.Dashboard = Dashboard;
 exports.Delete = Delete;
+exports.ErrorView = ErrorView;
 exports.Event = Event;
 exports.Get = Get;
 exports.GraphQLApolloPlugin = GraphQLApolloPlugin;
+exports.GraphQLYogaPlugin = GraphQLYogaPlugin;
 exports.HTTPMethods = HTTPMethods;
 exports.Head = Head;
 exports.Headers = Headers$1;
+exports.HtmxPlugin = HtmxPlugin;
+exports.Idempotency = Idempotency;
 exports.Inject = Inject;
 exports.Injectable = Injectable;
+exports.MCPServerPlugin = MCPServerPlugin;
 exports.MemoryStore = MemoryStore;
+exports.OpenTelemetryPlugin = OpenTelemetryPlugin;
 exports.Options = Options;
 exports.Param = Param;
 exports.Patch = Patch;
 exports.Post = Post;
+exports.Prompt = Prompt;
+exports.Proxy = Proxy$1;
 exports.Put = Put;
 exports.Query = Query;
 exports.RateLimit = RateLimit;
 exports.RateLimitMiddleware = RateLimitMiddleware;
 exports.Req = Req;
+exports.Resource = Resource;
 exports.RouteParamType = RouteParamType;
 exports.RouterRegistry = RouterRegistry;
 exports.ScalarPlugin = ScalarPlugin;
@@ -8849,13 +10503,18 @@ exports.ShokupanRequest = ShokupanRequest;
 exports.ShokupanResponse = ShokupanResponse;
 exports.ShokupanRouter = ShokupanRouter;
 exports.Spec = Spec;
+exports.Tool = Tool;
 exports.Use = Use;
 exports.ValidationError = ValidationError;
+exports.attachSocketIOBridge = attachSocketIOBridge;
 exports.compileValidators = compileValidators;
 exports.compose = compose;
 exports.enableOpenApiValidation = enableOpenApiValidation;
 exports.openApiValidator = openApiValidator;
 exports.precompileValidators = precompileValidators;
+exports.serveStatic = serveStatic;
+exports.traceHandler = traceHandler;
+exports.traceMiddleware = traceMiddleware;
 exports.useExpress = useExpress;
 exports.valibot = valibot;
 exports.validate = validate;