@mokup/server 1.1.2 → 1.1.3

package/dist/fetch-server.mjs

@@ -1,277 +1,71 @@
-import process, { cwd } from 'node:process';
-import { Hono, PatternRouter } from '@mokup/shared/hono';
-import { resolve, isAbsolute, relative, join, normalize, extname, dirname, basename } from '@mokup/shared/pathe';
+import { join, normalize, extname, dirname, relative, resolve, isAbsolute, basename } from '@mokup/shared/pathe';
 import { promises } from 'node:fs';
 import { createRequire } from 'node:module';
+import process, { cwd } from 'node:process';
 import { compareRouteScore, parseRouteTemplate } from '@mokup/runtime';
 import { Buffer } from 'node:buffer';
 import { pathToFileURL } from 'node:url';
 import { build } from '@mokup/shared/esbuild';
 import { parse } from '@mokup/shared/jsonc-parser';
+import { Hono, PatternRouter } from '@mokup/shared/hono';
 
-const methodSet = /* @__PURE__ */ new Set([
-  "GET",
-  "POST",
-  "PUT",
-  "PATCH",
-  "DELETE",
-  "OPTIONS",
-  "HEAD"
-]);
-const methodSuffixSet = new Set(
-  Array.from(methodSet, (method) => method.toLowerCase())
-);
-const supportedExtensions = /* @__PURE__ */ new Set([
-  ".json",
-  ".jsonc",
-  ".ts",
-  ".js",
-  ".mjs",
-  ".cjs"
-]);
-const configExtensions = [".ts", ".js", ".mjs", ".cjs"];
-
-function normalizePrefix(prefix) {
-  if (!prefix) {
-    return "";
-  }
-  const normalized = prefix.startsWith("/") ? prefix : `/${prefix}`;
-  return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
-}
-function resolveDirs(dir, root) {
-  const raw = typeof dir === "function" ? dir(root) : dir;
-  const resolved = Array.isArray(raw) ? raw : raw ? [raw] : ["mock"];
-  const normalized = resolved.map(
-    (entry) => isAbsolute(entry) ? entry : resolve(root, entry)
-  );
-  return Array.from(new Set(normalized));
-}
-function createDebouncer(delayMs, fn) {
-  let timer = null;
-  return () => {
-    if (timer) {
-      clearTimeout(timer);
-    }
-    timer = setTimeout(() => {
-      timer = null;
-      fn();
-    }, delayMs);
-  };
-}
-function toPosix(value) {
-  return value.replace(/\\/g, "/");
-}
-function isInDirs(file, dirs) {
-  const normalized = toPosix(file);
-  return dirs.some((dir) => {
-    const normalizedDir = toPosix(dir).replace(/\/$/, "");
-    return normalized === normalizedDir || normalized.startsWith(`${normalizedDir}/`);
-  });
-}
-function testPatterns(patterns, value) {
-  const list = Array.isArray(patterns) ? patterns : [patterns];
-  return list.some((pattern) => pattern.test(value));
-}
-function matchesFilter(file, include, exclude) {
-  const normalized = toPosix(file);
-  if (exclude && testPatterns(exclude, normalized)) {
-    return false;
-  }
-  if (include) {
-    return testPatterns(include, normalized);
-  }
-  return true;
-}
-function normalizeIgnorePrefix(value, fallback = ["."]) {
-  const list = typeof value === "undefined" ? fallback : Array.isArray(value) ? value : [value];
-  return list.filter((entry) => typeof entry === "string" && entry.length > 0);
-}
-function hasIgnoredPrefix(file, rootDir, prefixes) {
-  if (prefixes.length === 0) {
-    return false;
-  }
-  const relativePath = toPosix(relative(rootDir, file));
-  const segments = relativePath.split("/");
-  return segments.some(
-    (segment) => prefixes.some((prefix) => segment.startsWith(prefix))
-  );
-}
-function delay(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-
-function toHonoPath(route) {
-  if (!route.tokens || route.tokens.length === 0) {
-    return "/";
-  }
-  const segments = route.tokens.map((token) => {
-    if (token.type === "static") {
-      return token.value;
-    }
-    if (token.type === "param") {
-      return `:${token.name}`;
-    }
-    if (token.type === "catchall") {
-      return `:${token.name}{.+}`;
-    }
-    return `:${token.name}{.+}?`;
-  });
-  return `/${segments.join("/")}`;
-}
-function isValidStatus(status) {
-  return typeof status === "number" && Number.isFinite(status) && status >= 200 && status <= 599;
-}
-function resolveStatus(routeStatus, responseStatus) {
-  if (isValidStatus(routeStatus)) {
-    return routeStatus;
-  }
-  if (isValidStatus(responseStatus)) {
-    return responseStatus;
-  }
-  return 200;
-}
-function applyRouteOverrides(response, route) {
-  const headers = new Headers(response.headers);
-  const hasHeaders = !!route.headers && Object.keys(route.headers).length > 0;
-  if (route.headers) {
-    for (const [key, value] of Object.entries(route.headers)) {
-      headers.set(key, value);
-    }
-  }
-  const status = resolveStatus(route.status, response.status);
-  if (status === response.status && !hasHeaders) {
-    return response;
-  }
-  return new Response(response.body, { status, headers });
-}
-function resolveResponse(value, fallback) {
-  if (value instanceof Response) {
-    return value;
-  }
-  if (value && typeof value === "object" && "res" in value) {
-    const resolved = value.res;
-    if (resolved instanceof Response) {
-      return resolved;
-    }
-  }
-  return fallback;
-}
-function normalizeHandlerValue(c, value) {
-  if (value instanceof Response) {
-    return value;
-  }
-  if (typeof value === "undefined") {
-    const response = c.body(null);
-    if (response.status === 200) {
-      return new Response(response.body, {
-        status: 204,
-        headers: response.headers
-      });
-    }
-    return response;
-  }
-  if (typeof value === "string") {
-    return c.text(value);
-  }
-  if (value instanceof Uint8Array || value instanceof ArrayBuffer) {
-    if (!c.res.headers.get("content-type")) {
-      c.header("content-type", "application/octet-stream");
-    }
-    const data = value instanceof ArrayBuffer ? new Uint8Array(value) : new Uint8Array(value);
-    return c.body(data);
-  }
-  return c.json(value);
-}
-function createRouteHandler(route) {
-  return async (c) => {
-    const value = typeof route.handler === "function" ? await route.handler(c) : route.handler;
-    return normalizeHandlerValue(c, value);
-  };
-}
-function createFinalizeMiddleware(route, onResponse) {
-  return async (c, next) => {
-    const response = await next();
-    const resolved = resolveResponse(response, c.res);
-    if (route.delay && route.delay > 0) {
-      await delay(route.delay);
-    }
-    const overridden = applyRouteOverrides(resolved, route);
-    c.res = overridden;
-    if (onResponse) {
-      try {
-        const result = onResponse(route, overridden);
-        if (result instanceof Promise) {
-          result.catch(() => void 0);
-        }
-      } catch {
-      }
-    }
-    return overridden;
-  };
-}
-function wrapMiddleware(handler) {
-  return async (c, next) => {
-    const response = await handler(c, next);
-    return resolveResponse(response, c.res);
-  };
-}
-function createHonoApp(routes, options = {}) {
-  const app = new Hono({ router: new PatternRouter(), strict: false });
-  for (const route of routes) {
-    const middlewares = route.middlewares?.map((entry) => wrapMiddleware(entry.handle)) ?? [];
-    app.on(
-      route.method,
-      toHonoPath(route),
-      createFinalizeMiddleware(route, options.onResponse),
-      ...middlewares,
-      createRouteHandler(route)
-    );
+const silentLogger$1 = {
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  },
+  log: () => {
   }
-  return app;
-}
-
-function createLogger(enabled) {
+};
+function createLogger(options = true) {
+  const resolvedOptions = typeof options === "boolean" ? { enabled: options } : options;
+  const enabled = resolvedOptions?.enabled ?? true;
+  if (!enabled) {
+    return silentLogger$1;
+  }
+  const tag = resolvedOptions?.tag ?? "mokup";
+  const prefix = tag ? `[${tag}]` : "";
+  const withTag = (args) => prefix ? [prefix, ...args] : args;
   return {
     info: (...args) => {
-      if (enabled) {
-        console.info("[mokup]", ...args);
+      if (args.length === 0) {
+        return;
       }
+      console.info(...withTag(args));
     },
     warn: (...args) => {
-      if (enabled) {
-        console.warn("[mokup]", ...args);
+      if (args.length === 0) {
+        return;
       }
+      console.warn(...withTag(args));
     },
     error: (...args) => {
-      if (enabled) {
-        console.error("[mokup]", ...args);
+      if (args.length === 0) {
+        return;
+      }
+      console.error(...withTag(args));
+    },
+    log: (...args) => {
+      if (args.length === 0) {
+        return;
       }
+      console.log(...withTag(args));
     }
   };
 }
 
-const mimeTypes = {
-  ".html": "text/html; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".js": "text/javascript; charset=utf-8",
-  ".map": "application/json; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".ico": "image/x-icon"
-};
 function normalizePlaygroundPath(value) {
   if (!value) {
-    return "/_mokup";
+    return "/__mokup";
   }
   const normalized = value.startsWith("/") ? value : `/${value}`;
   return normalized.length > 1 && normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
 }
 function resolvePlaygroundOptions(playground) {
   if (playground === false) {
-    return { enabled: false, path: "/_mokup" };
+    return { enabled: false, path: "/__mokup" };
   }
   if (playground && typeof playground === "object") {
     return {
@@ -279,13 +73,43 @@ function resolvePlaygroundOptions(playground) {
       path: normalizePlaygroundPath(playground.path)
     };
   }
-  return { enabled: true, path: "/_mokup" };
+  return { enabled: true, path: "/__mokup" };
 }
+
+const require$1 = createRequire(import.meta.url);
+const mimeTypes = {
+  ".html": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".ico": "image/x-icon"
+};
 function resolvePlaygroundDist() {
-  const require = createRequire(import.meta.url);
-  const pkgPath = require.resolve("@mokup/playground/package.json");
+  const pkgPath = require$1.resolve("@mokup/playground/package.json");
   return join(pkgPath, "..", "dist");
 }
+async function readPlaygroundIndex(indexPath) {
+  const html = await promises.readFile(indexPath, "utf8");
+  const contentType = mimeTypes[".html"];
+  return new Response(html, { headers: { "Content-Type": contentType } });
+}
+async function readPlaygroundAsset(distDir, relPath) {
+  if (relPath.includes("..")) {
+    return new Response("Invalid path.", { status: 400 });
+  }
+  const normalizedPath = normalize(relPath);
+  const filePath = join(distDir, normalizedPath);
+  const content = await promises.readFile(filePath);
+  const ext = extname(filePath);
+  const contentType = mimeTypes[ext] ?? "application/octet-stream";
+  return new Response(content, { headers: { "Content-Type": contentType } });
+}
+
 function toPosixPath(value) {
   return value.replace(/\\/g, "/");
 }
@@ -327,41 +151,6 @@ function resolveGroupRoot(dirs, serverRoot) {
   }
   return common;
 }
-const disabledReasonSet = /* @__PURE__ */ new Set([
-  "disabled",
-  "disabled-dir",
-  "exclude",
-  "ignore-prefix",
-  "include",
-  "unknown"
-]);
-const ignoredReasonSet = /* @__PURE__ */ new Set([
-  "unsupported",
-  "invalid-route",
-  "unknown"
-]);
-function normalizeDisabledReason(reason) {
-  if (reason && disabledReasonSet.has(reason)) {
-    return reason;
-  }
-  return "unknown";
-}
-function normalizeIgnoredReason(reason) {
-  if (reason && ignoredReasonSet.has(reason)) {
-    return reason;
-  }
-  return "unknown";
-}
-function formatRouteFile(file, root) {
-  if (!root) {
-    return toPosixPath(file);
-  }
-  const rel = toPosixPath(relative(root, file));
-  if (!rel || rel.startsWith("..")) {
-    return toPosixPath(file);
-  }
-  return rel;
-}
 function resolveGroups(dirs, root) {
   const groups = [];
   const seen = /* @__PURE__ */ new Set();
@@ -394,11 +183,54 @@ function resolveRouteGroup(routeFile, groups) {
       }
     }
   }
-  return matched;
+  return matched;
+}
+function formatRouteFile(file, root) {
+  if (!root) {
+    return toPosixPath(file);
+  }
+  const rel = toPosixPath(relative(root, file));
+  if (!rel || rel.startsWith("..")) {
+    return toPosixPath(file);
+  }
+  return rel;
+}
+
+const disabledReasonSet = /* @__PURE__ */ new Set([
+  "disabled",
+  "disabled-dir",
+  "exclude",
+  "ignore-prefix",
+  "include",
+  "unknown"
+]);
+const ignoredReasonSet = /* @__PURE__ */ new Set([
+  "unsupported",
+  "invalid-route",
+  "unknown"
+]);
+function normalizeDisabledReason(reason) {
+  if (reason && disabledReasonSet.has(reason)) {
+    return reason;
+  }
+  return "unknown";
+}
+function normalizeIgnoredReason(reason) {
+  if (reason && ignoredReasonSet.has(reason)) {
+    return reason;
+  }
+  return "unknown";
 }
 function toPlaygroundRoute(route, root, groups) {
   const matchedGroup = resolveRouteGroup(route.file, groups);
-  const middlewareSources = route.middlewares?.map((entry) => formatRouteFile(entry.source, root));
+  const preSources = route.middlewares?.filter((entry) => entry.position === "pre").map((entry) => formatRouteFile(entry.source, root)) ?? [];
+  const postSources = route.middlewares?.filter((entry) => entry.position === "post").map((entry) => formatRouteFile(entry.source, root)) ?? [];
+  const normalSources = route.middlewares?.filter((entry) => entry.position !== "pre" && entry.position !== "post").map((entry) => formatRouteFile(entry.source, root)) ?? [];
+  const combinedSources = [
+    ...preSources,
+    ...normalSources,
+    ...postSources
+  ];
   return {
     method: route.method,
     url: route.template,
@@ -406,8 +238,14 @@ function toPlaygroundRoute(route, root, groups) {
     type: typeof route.handler === "function" ? "handler" : "static",
     status: route.status,
     delay: route.delay,
-    middlewareCount: middlewareSources?.length ?? 0,
-    middlewares: middlewareSources,
+    middlewareCount: combinedSources.length,
+    middlewares: combinedSources,
+    preMiddlewareCount: preSources.length,
+    normalMiddlewareCount: normalSources.length,
+    postMiddlewareCount: postSources.length,
+    preMiddlewares: preSources,
+    normalMiddlewares: normalSources,
+    postMiddlewares: postSources,
     groupKey: matchedGroup?.key,
     group: matchedGroup?.label
   };
@@ -453,6 +291,7 @@ function toPlaygroundConfigFile(entry, root, groups) {
   }
   return configFile;
 }
+
 function registerPlaygroundRoutes(params) {
   if (!params.config.enabled) {
     return;
@@ -462,9 +301,7 @@ function registerPlaygroundRoutes(params) {
   const indexPath = join(distDir, "index.html");
   const serveIndex = async () => {
     try {
-      const html = await promises.readFile(indexPath, "utf8");
-      const contentType = mimeTypes[".html"] ?? "text/html; charset=utf-8";
-      return new Response(html, { headers: { "Content-Type": contentType } });
+      return await readPlaygroundIndex(indexPath);
     } catch (error) {
       params.logger.error("Failed to load playground index:", error);
       return new Response("Playground is not available.", { status: 500 });
@@ -505,22 +342,105 @@ function registerPlaygroundRoutes(params) {
     if (!relPath || relPath === "/") {
       return serveIndex();
     }
-    if (relPath.includes("..")) {
-      return new Response("Invalid path.", { status: 400 });
-    }
-    const normalizedPath = normalize(relPath);
-    const filePath = join(distDir, normalizedPath);
     try {
-      const content = await promises.readFile(filePath);
-      const ext = extname(filePath);
-      const contentType = mimeTypes[ext] ?? "application/octet-stream";
-      return new Response(content, { headers: { "Content-Type": contentType } });
+      return await readPlaygroundAsset(distDir, relPath);
     } catch {
       return c.notFound();
     }
   });
 }
 
+const methodSet = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "HEAD"
+]);
+const methodSuffixSet = new Set(
+  Array.from(methodSet, (method) => method.toLowerCase())
+);
+const supportedExtensions = /* @__PURE__ */ new Set([
+  ".json",
+  ".jsonc",
+  ".ts",
+  ".js",
+  ".mjs",
+  ".cjs"
+]);
+const configExtensions = [".ts", ".js", ".mjs", ".cjs"];
+
+function normalizePrefix(prefix) {
+  if (!prefix) {
+    return "";
+  }
+  const normalized = prefix.startsWith("/") ? prefix : `/${prefix}`;
+  return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function resolveDirs(dir, root) {
+  const raw = typeof dir === "function" ? dir(root) : dir;
+  const resolved = Array.isArray(raw) ? raw : raw ? [raw] : ["mock"];
+  const normalized = resolved.map(
+    (entry) => isAbsolute(entry) ? entry : resolve(root, entry)
+  );
+  return Array.from(new Set(normalized));
+}
+function createDebouncer(delayMs, fn) {
+  let timer = null;
+  return () => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      timer = null;
+      fn();
+    }, delayMs);
+  };
+}
+function toPosix(value) {
+  return value.replace(/\\/g, "/");
+}
+function isInDirs(file, dirs) {
+  const normalized = toPosix(file);
+  return dirs.some((dir) => {
+    const normalizedDir = toPosix(dir).replace(/\/$/, "");
+    return normalized === normalizedDir || normalized.startsWith(`${normalizedDir}/`);
+  });
+}
+function testPatterns(patterns, value) {
+  const list = Array.isArray(patterns) ? patterns : [patterns];
+  return list.some((pattern) => pattern.test(value));
+}
+function matchesFilter(file, include, exclude) {
+  const normalized = toPosix(file);
+  if (exclude && testPatterns(exclude, normalized)) {
+    return false;
+  }
+  if (include) {
+    return testPatterns(include, normalized);
+  }
+  return true;
+}
+function normalizeIgnorePrefix(value, fallback = ["."]) {
+  const list = typeof value === "undefined" ? fallback : Array.isArray(value) ? value : [value];
+  return list.filter((entry) => typeof entry === "string" && entry.length > 0);
+}
+function hasIgnoredPrefix(file, rootDir, prefixes) {
+  if (prefixes.length === 0) {
+    return false;
+  }
+  const relativePath = toPosix(relative(rootDir, file));
+  const segments = relativePath.split("/");
+  return segments.some(
+    (segment) => prefixes.some((prefix) => segment.startsWith(prefix))
+  );
+}
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
 const jsonExtensions = /* @__PURE__ */ new Set([".json", ".jsonc"]);
 function resolveTemplate(template, prefix) {
   const normalized = template.startsWith("/") ? template : `/${template}`;
@@ -673,6 +593,7 @@ async function ensureTsxRegister(logger) {
   return registerPromise;
 }
 
+const middlewareSymbol = Symbol.for("mokup.config.middlewares");
 function isUnknownFileExtensionError$1(error) {
   if (!error || typeof error !== "object") {
     return false;
@@ -759,7 +680,7 @@ async function loadConfig(file, logger) {
   }
   return value;
 }
-function normalizeMiddlewares(value, source, logger) {
+function normalizeMiddlewares(value, source, logger, position) {
   if (!value) {
     return [];
   }
@@ -770,10 +691,27 @@ function normalizeMiddlewares(value, source, logger) {
       logger.warn(`Invalid middleware in ${source}`);
       continue;
     }
-    middlewares.push({ handle: entry, source, index });
+    middlewares.push({
+      handle: entry,
+      source,
+      index,
+      position
+    });
   }
   return middlewares;
 }
+function readMiddlewareMeta(config) {
+  const value = config[middlewareSymbol];
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const meta = value;
+  return {
+    pre: Array.isArray(meta.pre) ? meta.pre : [],
+    normal: Array.isArray(meta.normal) ? meta.normal : [],
+    post: Array.isArray(meta.post) ? meta.post : []
+  };
+}
 async function resolveDirectoryConfig(params) {
   const { file, rootDir, logger, configCache, fileCache } = params;
   const resolvedRoot = normalize(rootDir);
@@ -792,7 +730,10 @@ async function resolveDirectoryConfig(params) {
     current = parent;
   }
   chain.reverse();
-  const merged = { middlewares: [] };
+  const merged = {};
+  const preMiddlewares = [];
+  const normalMiddlewares = [];
+  const postMiddlewares = [];
   for (const dir of chain) {
     const configPath = await findConfigFile(dir, fileCache);
     if (!configPath) {
@@ -828,12 +769,48 @@ async function resolveDirectoryConfig(params) {
     if (typeof config.exclude !== "undefined") {
       merged.exclude = config.exclude;
     }
-    const normalized = normalizeMiddlewares(config.middleware, configPath, logger);
-    if (normalized.length > 0) {
-      merged.middlewares.push(...normalized);
+    const meta = readMiddlewareMeta(config);
+    const normalizedPre = normalizeMiddlewares(
+      meta?.pre,
+      configPath,
+      logger,
+      "pre"
+    );
+    const normalizedNormal = normalizeMiddlewares(
+      meta?.normal,
+      configPath,
+      logger,
+      "normal"
+    );
+    const normalizedLegacy = normalizeMiddlewares(
+      config.middleware,
+      configPath,
+      logger,
+      "normal"
+    );
+    const normalizedPost = normalizeMiddlewares(
+      meta?.post,
+      configPath,
+      logger,
+      "post"
+    );
+    if (normalizedPre.length > 0) {
+      preMiddlewares.push(...normalizedPre);
+    }
+    if (normalizedNormal.length > 0) {
+      normalMiddlewares.push(...normalizedNormal);
+    }
+    if (normalizedLegacy.length > 0) {
+      normalMiddlewares.push(...normalizedLegacy);
+    }
+    if (normalizedPost.length > 0) {
+      postMiddlewares.push(...normalizedPost);
     }
   }
-  return merged;
+  return {
+    ...merged,
+    middlewares: [...preMiddlewares, ...normalMiddlewares, ...postMiddlewares]
+  };
 }
 
 async function walkDir(dir, rootDir, files) {
@@ -1002,6 +979,8 @@ const silentLogger = {
   warn: () => {
   },
   error: () => {
+  },
+  log: () => {
   }
 };
 function resolveSkipRoute(params) {
@@ -1129,55 +1108,228 @@ async function scanRoutes(params) {
           });
           params.onSkip?.(buildSkipInfo(fileInfo.file, "disabled", resolved2));
         }
-        continue;
-      }
-      const ruleValue = rule;
-      const unsupportedKeys = ["response", "url", "method"].filter(
-        (key2) => key2 in ruleValue
-      );
-      if (unsupportedKeys.length > 0) {
-        params.logger.warn(
-          `Skip mock with unsupported fields (${unsupportedKeys.join(", ")}): ${fileInfo.file}`
-        );
-        continue;
-      }
-      if (typeof rule.handler === "undefined") {
-        params.logger.warn(`Skip mock without handler: ${fileInfo.file}`);
-        continue;
-      }
-      const resolved = resolveRule({
-        rule,
-        derivedTemplate: derived.template,
-        derivedMethod: derived.method,
-        prefix: params.prefix,
-        file: fileInfo.file,
-        logger: params.logger
-      });
-      if (!resolved) {
-        continue;
-      }
-      resolved.ruleIndex = index;
-      if (config.headers) {
-        resolved.headers = { ...config.headers, ...resolved.headers ?? {} };
-      }
-      if (typeof resolved.status === "undefined" && typeof config.status === "number") {
-        resolved.status = config.status;
-      }
-      if (typeof resolved.delay === "undefined" && typeof config.delay === "number") {
-        resolved.delay = config.delay;
-      }
-      if (config.middlewares.length > 0) {
-        resolved.middlewares = config.middlewares;
-      }
-      const key = `${resolved.method} ${resolved.template}`;
-      if (seen.has(key)) {
-        params.logger.warn(`Duplicate mock route ${key} from ${fileInfo.file}`);
+        continue;
+      }
+      const ruleValue = rule;
+      const unsupportedKeys = ["response", "url", "method"].filter(
+        (key2) => key2 in ruleValue
+      );
+      if (unsupportedKeys.length > 0) {
+        params.logger.warn(
+          `Skip mock with unsupported fields (${unsupportedKeys.join(", ")}): ${fileInfo.file}`
+        );
+        continue;
+      }
+      if (typeof rule.handler === "undefined") {
+        params.logger.warn(`Skip mock without handler: ${fileInfo.file}`);
+        continue;
+      }
+      const resolved = resolveRule({
+        rule,
+        derivedTemplate: derived.template,
+        derivedMethod: derived.method,
+        prefix: params.prefix,
+        file: fileInfo.file,
+        logger: params.logger
+      });
+      if (!resolved) {
+        continue;
+      }
+      resolved.ruleIndex = index;
+      if (config.headers) {
+        resolved.headers = { ...config.headers, ...resolved.headers ?? {} };
+      }
+      if (typeof resolved.status === "undefined" && typeof config.status === "number") {
+        resolved.status = config.status;
+      }
+      if (typeof resolved.delay === "undefined" && typeof config.delay === "number") {
+        resolved.delay = config.delay;
+      }
+      if (config.middlewares.length > 0) {
+        resolved.middlewares = config.middlewares;
+      }
+      const key = `${resolved.method} ${resolved.template}`;
+      if (seen.has(key)) {
+        params.logger.warn(`Duplicate mock route ${key} from ${fileInfo.file}`);
+      }
+      seen.add(key);
+      routes.push(resolved);
+    }
+  }
+  return sortRoutes(routes);
+}
+
+function toHonoPath(route) {
+  if (!route.tokens || route.tokens.length === 0) {
+    return "/";
+  }
+  const segments = route.tokens.map((token) => {
+    if (token.type === "static") {
+      return token.value;
+    }
+    if (token.type === "param") {
+      return `:${token.name}`;
+    }
+    if (token.type === "catchall") {
+      return `:${token.name}{.+}`;
+    }
+    return `:${token.name}{.+}?`;
+  });
+  return `/${segments.join("/")}`;
+}
+function isValidStatus(status) {
+  return typeof status === "number" && Number.isFinite(status) && status >= 200 && status <= 599;
+}
+function resolveStatus(routeStatus, responseStatus) {
+  if (isValidStatus(routeStatus)) {
+    return routeStatus;
+  }
+  if (isValidStatus(responseStatus)) {
+    return responseStatus;
+  }
+  return 200;
+}
+function applyRouteOverrides(response, route) {
+  const headers = new Headers(response.headers);
+  const hasHeaders = !!route.headers && Object.keys(route.headers).length > 0;
+  if (route.headers) {
+    for (const [key, value] of Object.entries(route.headers)) {
+      headers.set(key, value);
+    }
+  }
+  const status = resolveStatus(route.status, response.status);
+  if (status === response.status && !hasHeaders) {
+    return response;
+  }
+  return new Response(response.body, { status, headers });
+}
+function resolveResponse(value, fallback) {
+  if (value instanceof Response) {
+    return value;
+  }
+  if (value && typeof value === "object" && "res" in value) {
+    const resolved = value.res;
+    if (resolved instanceof Response) {
+      return resolved;
+    }
+  }
+  return fallback;
+}
+function normalizeHandlerValue(c, value) {
+  if (value instanceof Response) {
+    return value;
+  }
+  if (typeof value === "undefined") {
+    const response = c.body(null);
+    if (response.status === 200) {
+      return new Response(response.body, {
+        status: 204,
+        headers: response.headers
+      });
+    }
+    return response;
+  }
+  if (typeof value === "string") {
+    return c.text(value);
+  }
+  if (value instanceof Uint8Array || value instanceof ArrayBuffer) {
+    if (!c.res.headers.get("content-type")) {
+      c.header("content-type", "application/octet-stream");
+    }
+    const data = value instanceof ArrayBuffer ? new Uint8Array(value) : new Uint8Array(value);
+    return c.body(data);
+  }
+  return c.json(value);
+}
+function createRouteHandler(route) {
+  return async (c) => {
+    const value = typeof route.handler === "function" ? await route.handler(c) : route.handler;
+    return normalizeHandlerValue(c, value);
+  };
+}
+function createFinalizeMiddleware(route, onResponse) {
+  return async (c, next) => {
+    const response = await next();
+    const resolved = resolveResponse(response, c.res);
+    if (route.delay && route.delay > 0) {
+      await delay(route.delay);
+    }
+    const overridden = applyRouteOverrides(resolved, route);
+    c.res = overridden;
+    if (onResponse) {
+      try {
+        const result = onResponse(route, overridden);
+        if (result instanceof Promise) {
+          result.catch(() => void 0);
+        }
+      } catch {
       }
-      seen.add(key);
-      routes.push(resolved);
+    }
+    return overridden;
+  };
+}
+function wrapMiddleware(handler) {
+  return async (c, next) => {
+    const response = await handler(c, next);
+    return resolveResponse(response, c.res);
+  };
+}
+function splitRouteMiddlewares(route) {
+  const before = [];
+  const normal = [];
+  const after = [];
+  for (const entry of route.middlewares ?? []) {
+    const wrapped = wrapMiddleware(entry.handle);
+    if (entry.position === "post") {
+      after.push(wrapped);
+    } else if (entry.position === "pre") {
+      before.push(wrapped);
+    } else {
+      normal.push(wrapped);
     }
   }
-  return sortRoutes(routes);
+  return { before, normal, after };
+}
+function createHonoApp(routes, options = {}) {
+  const app = new Hono({ router: new PatternRouter(), strict: false });
+  for (const route of routes) {
+    const { before, normal, after } = splitRouteMiddlewares(route);
+    app.on(
+      route.method,
+      toHonoPath(route),
+      createFinalizeMiddleware(route, options.onResponse),
+      ...before,
+      ...normal,
+      ...after,
+      createRouteHandler(route)
+    );
+  }
+  return app;
+}
+
+function buildFetchServerApp(params) {
+  const app = new Hono({ strict: false });
+  registerPlaygroundRoutes({
+    app,
+    routes: params.routes,
+    disabledRoutes: params.disabledRoutes,
+    ignoredRoutes: params.ignoredRoutes,
+    configFiles: params.configFiles,
+    disabledConfigFiles: params.disabledConfigFiles,
+    dirs: params.dirs,
+    logger: params.logger,
+    config: params.playground,
+    root: params.root
+  });
+  if (params.wsHandler && params.playground.enabled) {
+    app.get(`${params.playground.path}/ws`, params.wsHandler);
+  }
+  if (params.routes.length > 0) {
+    const mockAppOptions = params.onResponse ? { onResponse: params.onResponse } : {};
+    const mockApp = createHonoApp(params.routes, mockAppOptions);
+    app.route("/", mockApp);
+  }
+  return app;
 }
 
 function normalizeEntries(entries) {
@@ -1224,30 +1376,82 @@ function resolveAllDirs(list, root) {
   }
   return dirs;
 }
-function buildApp(params) {
-  const app = new Hono({ strict: false });
-  registerPlaygroundRoutes({
-    app,
-    routes: params.routes,
-    disabledRoutes: params.disabledRoutes,
-    ignoredRoutes: params.ignoredRoutes,
-    configFiles: params.configFiles,
-    disabledConfigFiles: params.disabledConfigFiles,
-    dirs: params.dirs,
-    logger: params.logger,
-    config: params.playground,
-    root: params.root
-  });
-  if (params.wsHandler && params.playground.enabled) {
-    app.get(`${params.playground.path}/ws`, params.wsHandler);
+
+function createPlaygroundWs(playground) {
+  const routeCounts = {};
+  const wsClients = /* @__PURE__ */ new Set();
+  let totalCount = 0;
+  let wsHandler;
+  let injectWebSocket;
+  function getRouteKey(route) {
+    return `${route.method} ${route.template}`;
   }
-  if (params.routes.length > 0) {
-    const mockAppOptions = params.onResponse ? { onResponse: params.onResponse } : {};
-    const mockApp = createHonoApp(params.routes, mockAppOptions);
-    app.route("/", mockApp);
+  function buildSnapshot() {
+    return {
+      type: "snapshot",
+      total: totalCount,
+      perRoute: { ...routeCounts }
+    };
   }
-  return app;
+  function broadcast(payload) {
+    if (wsClients.size === 0) {
+      return;
+    }
+    const message = JSON.stringify(payload);
+    for (const client of wsClients) {
+      try {
+        client.send(message);
+      } catch {
+        wsClients.delete(client);
+      }
+    }
+  }
+  function registerWsClient(client) {
+    wsClients.add(client);
+    try {
+      client.send(JSON.stringify(buildSnapshot()));
+    } catch {
+      wsClients.delete(client);
+    }
+  }
+  function handleRouteResponse(route) {
+    const routeKey = getRouteKey(route);
+    routeCounts[routeKey] = (routeCounts[routeKey] ?? 0) + 1;
+    totalCount += 1;
+    broadcast({ type: "increment", routeKey, total: totalCount });
+  }
+  async function setupPlaygroundWebSocket(app) {
+    if (!playground.enabled) {
+      return;
+    }
+    try {
+      const mod = await import('@hono/node-ws');
+      const { createNodeWebSocket } = mod;
+      const { upgradeWebSocket, injectWebSocket: inject } = createNodeWebSocket({ app });
+      wsHandler = upgradeWebSocket(() => ({
+        onOpen: (_event, ws) => {
+          registerWsClient(ws);
+        },
+        onClose: (_event, ws) => {
+          wsClients.delete(ws);
+        },
+        onMessage: () => {
+        }
+      }));
+      injectWebSocket = (server) => {
+        inject(server);
+      };
+    } catch {
+    }
+  }
+  return {
+    handleRouteResponse,
+    setupPlaygroundWebSocket,
+    getWsHandler: () => wsHandler,
+    getInjectWebSocket: () => injectWebSocket
+  };
 }
+
 async function createDenoWatcher(params) {
   const deno = globalThis.Deno;
   if (!deno?.watchFs) {
@@ -1322,6 +1526,7 @@ async function createWatcher(params) {
   params.logger.warn("Watcher is not available in this runtime; file watching disabled.");
   return null;
 }
+
 async function createFetchServer(options = {}) {
   const normalized = normalizeOptions(options);
   const optionList = normalized.entries;
@@ -1331,78 +1536,13 @@ async function createFetchServer(options = {}) {
   const logger = createLogger(logEnabled);
   const playgroundConfig = resolvePlaygroundOptions(normalized.playground);
   const dirs = resolveAllDirs(optionList, root);
-  const routeCounts = {};
-  const wsClients = /* @__PURE__ */ new Set();
-  let totalCount = 0;
-  let wsHandler;
-  let injectWebSocket;
-  function getRouteKey(route) {
-    return `${route.method} ${route.template}`;
-  }
-  function buildSnapshot() {
-    return {
-      type: "snapshot",
-      total: totalCount,
-      perRoute: { ...routeCounts }
-    };
-  }
-  function broadcast(payload) {
-    if (wsClients.size === 0) {
-      return;
-    }
-    const message = JSON.stringify(payload);
-    for (const client of wsClients) {
-      try {
-        client.send(message);
-      } catch {
-        wsClients.delete(client);
-      }
-    }
-  }
-  function registerWsClient(client) {
-    wsClients.add(client);
-    try {
-      client.send(JSON.stringify(buildSnapshot()));
-    } catch {
-      wsClients.delete(client);
-    }
-  }
-  function handleRouteResponse(route) {
-    const routeKey = getRouteKey(route);
-    routeCounts[routeKey] = (routeCounts[routeKey] ?? 0) + 1;
-    totalCount += 1;
-    broadcast({ type: "increment", routeKey, total: totalCount });
-  }
-  async function setupPlaygroundWebSocket(app2) {
-    if (!playgroundConfig.enabled) {
-      return;
-    }
-    try {
-      const mod = await import('@hono/node-ws');
-      const { createNodeWebSocket } = mod;
-      const { upgradeWebSocket, injectWebSocket: inject } = createNodeWebSocket({ app: app2 });
-      wsHandler = upgradeWebSocket(() => ({
-        onOpen: (_event, ws) => {
-          registerWsClient(ws);
-        },
-        onClose: (_event, ws) => {
-          wsClients.delete(ws);
-        },
-        onMessage: () => {
-        }
-      }));
-      injectWebSocket = (server2) => {
-        inject(server2);
-      };
-    } catch {
-    }
-  }
+  const playgroundWs = createPlaygroundWs(playgroundConfig);
   let routes = [];
   let disabledRoutes = [];
   let ignoredRoutes = [];
   let configFiles = [];
   let disabledConfigFiles = [];
-  let app = buildApp({
+  const appParams = {
     routes,
     disabledRoutes,
     ignoredRoutes,
@@ -1412,9 +1552,13 @@ async function createFetchServer(options = {}) {
     playground: playgroundConfig,
     root,
     logger,
-    onResponse: handleRouteResponse,
-    ...wsHandler ? { wsHandler } : {}
-  });
+    onResponse: playgroundWs.handleRouteResponse
+  };
+  const initialWsHandler = playgroundWs.getWsHandler();
+  if (initialWsHandler) {
+    appParams.wsHandler = initialWsHandler;
+  }
+  let app = buildFetchServerApp(appParams);
   const refreshRoutes = async () => {
     try {
       const collected = [];
@@ -1450,7 +1594,7 @@ async function createFetchServer(options = {}) {
       const resolvedConfigs = Array.from(configMap.values());
       configFiles = resolvedConfigs.filter((entry) => entry.enabled);
       disabledConfigFiles = resolvedConfigs.filter((entry) => !entry.enabled);
-      app = buildApp({
+      const refreshedParams = {
         routes,
         disabledRoutes,
         ignoredRoutes,
@@ -1460,16 +1604,21 @@ async function createFetchServer(options = {}) {
         playground: playgroundConfig,
         root,
         logger,
-        onResponse: handleRouteResponse,
-        ...wsHandler ? { wsHandler } : {}
-      });
+        onResponse: playgroundWs.handleRouteResponse
+      };
+      const refreshedWsHandler = playgroundWs.getWsHandler();
+      if (refreshedWsHandler) {
+        refreshedParams.wsHandler = refreshedWsHandler;
+      }
+      app = buildFetchServerApp(refreshedParams);
       logger.info(`Loaded ${routes.length} mock routes.`);
     } catch (error) {
       logger.error("Failed to scan mock routes:", error);
     }
   };
   await refreshRoutes();
-  await setupPlaygroundWebSocket(app);
+  await playgroundWs.setupPlaygroundWebSocket(app);
+  const wsHandler = playgroundWs.getWsHandler();
   if (wsHandler && playgroundConfig.enabled) {
     app.get(`${playgroundConfig.path}/ws`, wsHandler);
   }
@@ -1486,9 +1635,12 @@ async function createFetchServer(options = {}) {
   const server = {
     fetch,
     refresh: refreshRoutes,
-    getRoutes: () => routes,
-    ...injectWebSocket ? { injectWebSocket } : {}
+    getRoutes: () => routes
   };
+  const injectWebSocket = playgroundWs.getInjectWebSocket();
+  if (injectWebSocket) {
+    server.injectWebSocket = injectWebSocket;
+  }
   if (watcher) {
     server.close = async () => {
       await watcher.close();