mokup 2.0.2 → 2.1.1

package/dist/shared/{mokup.jeVwRMia.mjs → mokup.ghra3mzH.mjs}

@@ -1,34 +1,14 @@
-import { Buffer } from 'node:buffer';
-import { Hono, PatternRouter } from '@mokup/shared/hono';
-import { promises } from 'node:fs';
+import { promises, existsSync } from 'node:fs';
+import { resolve, isAbsolute, relative, join, dirname, normalize, extname, basename } from '@mokup/shared/pathe';
 import { createRequire } from 'node:module';
 import { cwd } from 'node:process';
-import { resolve, isAbsolute, relative, join, normalize, extname, dirname, basename } from '@mokup/shared/pathe';
-import { pathToFileURL } from 'node:url';
+import { Buffer } from 'node:buffer';
+import { Hono, PatternRouter } from '@mokup/shared/hono';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { build } from '@mokup/shared/esbuild';
 import { parse } from '@mokup/shared/jsonc-parser';
 import { compareRouteScore, parseRouteTemplate } from '@mokup/runtime';
 
-function createLogger(enabled) {
-  return {
-    info: (...args) => {
-      if (enabled) {
-        console.info("[mokup]", ...args);
-      }
-    },
-    warn: (...args) => {
-      if (enabled) {
-        console.warn("[mokup]", ...args);
-      }
-    },
-    error: (...args) => {
-      if (enabled) {
-        console.error("[mokup]", ...args);
-      }
-    }
-  };
-}
-
 const methodSet = /* @__PURE__ */ new Set([
   "GET",
   "POST",
@@ -98,20 +78,6 @@ function isInDirs(file, dirs) {
     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);
@@ -130,222 +96,188 @@ function delay(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
-function toHonoPath(route) {
-  if (!route.tokens || route.tokens.length === 0) {
-    return "/";
+function toViteImportPath(file, root) {
+  const absolute = isAbsolute(file) ? file : resolve(root, file);
+  const rel = relative(root, absolute);
+  if (!rel.startsWith("..") && !isAbsolute(rel)) {
+    return `/${toPosix(rel)}`;
   }
-  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;
+  return `/@fs/${toPosix(absolute)}`;
 }
-function resolveStatus(routeStatus, responseStatus) {
-  if (isValidStatus(routeStatus)) {
-    return routeStatus;
+function shouldModuleize(handler) {
+  if (typeof handler === "function") {
+    return true;
   }
-  if (isValidStatus(responseStatus)) {
-    return responseStatus;
+  if (typeof Response !== "undefined" && handler instanceof Response) {
+    return true;
   }
-  return 200;
+  return false;
 }
-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 BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function getNodeBuffer() {
+  if (typeof globalThis === "undefined") {
+    return null;
   }
-  const status = resolveStatus(route.status, response.status);
-  if (status === response.status && !hasHeaders) {
-    return response;
+  const buffer = globalThis.Buffer;
+  return buffer ?? null;
+}
+function getBtoa() {
+  if (typeof globalThis === "undefined") {
+    return null;
   }
-  return new Response(response.body, { status, headers });
+  const btoaFn = globalThis.btoa;
+  return typeof btoaFn === "function" ? btoaFn : null;
+}
+function encodeBase64(bytes) {
+  const buffer = getNodeBuffer();
+  if (buffer) {
+    return buffer.from(bytes).toString("base64");
+  }
+  const btoaFn = getBtoa();
+  if (btoaFn) {
+    let binary = "";
+    const chunkSize = 32768;
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+      const chunk = bytes.subarray(i, i + chunkSize);
+      binary += String.fromCharCode(...chunk);
+    }
+    return btoaFn(binary);
+  }
+  let output = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i] ?? 0;
+    const b = i + 1 < bytes.length ? bytes[i + 1] ?? 0 : 0;
+    const c = i + 2 < bytes.length ? bytes[i + 2] ?? 0 : 0;
+    const triple = a << 16 | b << 8 | c;
+    output += BASE64_ALPHABET[triple >> 18 & 63];
+    output += BASE64_ALPHABET[triple >> 12 & 63];
+    output += i + 1 < bytes.length ? BASE64_ALPHABET[triple >> 6 & 63] : "=";
+    output += i + 2 < bytes.length ? BASE64_ALPHABET[triple & 63] : "=";
+  }
+  return output;
 }
-function resolveResponse(value, fallback) {
-  if (value instanceof Response) {
-    return value;
+function toBinaryBody(handler) {
+  if (handler instanceof ArrayBuffer) {
+    return encodeBase64(new Uint8Array(handler));
   }
-  if (value && typeof value === "object" && "res" in value) {
-    const resolved = value.res;
-    if (resolved instanceof Response) {
-      return resolved;
-    }
+  if (handler instanceof Uint8Array) {
+    return encodeBase64(handler);
   }
-  return fallback;
+  return null;
 }
-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
-      });
+function buildManifestResponse(route, moduleId) {
+  if (moduleId) {
+    const response = {
+      type: "module",
+      module: moduleId
+    };
+    if (typeof route.ruleIndex === "number") {
+      response.ruleIndex = route.ruleIndex;
     }
     return response;
   }
-  if (typeof value === "string") {
-    return c.text(value);
+  const handler = route.handler;
+  if (typeof handler === "string") {
+    return {
+      type: "text",
+      body: handler
+    };
   }
-  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);
+  const binary = toBinaryBody(handler);
+  if (binary) {
+    return {
+      type: "binary",
+      body: binary,
+      encoding: "base64"
+    };
   }
-  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);
+  return {
+    type: "json",
+    body: handler
   };
 }
-function createFinalizeMiddleware(route) {
-  return async (c, next) => {
-    const response = await next();
-    const resolved = resolveResponse(response, c.res);
-    if (route.delay && route.delay > 0) {
-      await delay(route.delay);
+function buildManifestData(params) {
+  const { routes, root } = params;
+  const resolveModulePath = params.resolveModulePath ?? toViteImportPath;
+  const ruleModules = /* @__PURE__ */ new Map();
+  const middlewareModules = /* @__PURE__ */ new Map();
+  const manifestRoutes = routes.map((route) => {
+    const moduleId = shouldModuleize(route.handler) ? resolveModulePath(route.file, root) : null;
+    if (moduleId && !ruleModules.has(moduleId)) {
+      ruleModules.set(moduleId, { id: moduleId, kind: "rule" });
     }
-    const overridden = applyRouteOverrides(resolved, route);
-    c.res = overridden;
-    return overridden;
+    const middleware = route.middlewares?.map((entry) => {
+      const modulePath = resolveModulePath(entry.source, root);
+      if (!middlewareModules.has(modulePath)) {
+        middlewareModules.set(modulePath, { id: modulePath, kind: "middleware" });
+      }
+      return {
+        module: modulePath,
+        ruleIndex: entry.index
+      };
+    });
+    const response = buildManifestResponse(route, moduleId);
+    const manifestRoute = {
+      method: route.method,
+      url: route.template,
+      ...route.tokens ? { tokens: route.tokens } : {},
+      ...route.score ? { score: route.score } : {},
+      ...route.status ? { status: route.status } : {},
+      ...route.headers ? { headers: route.headers } : {},
+      ...route.delay ? { delay: route.delay } : {},
+      ...middleware && middleware.length > 0 ? { middleware } : {},
+      response
+    };
+    return manifestRoute;
+  });
+  const manifest = {
+    version: 1,
+    routes: manifestRoutes
   };
-}
-function wrapMiddleware(handler) {
-  return async (c, next) => {
-    const response = await handler(c, next);
-    return resolveResponse(response, c.res);
+  return {
+    manifest,
+    modules: [
+      ...ruleModules.values(),
+      ...middlewareModules.values()
+    ]
   };
 }
-function createHonoApp(routes) {
-  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),
-      ...middlewares,
-      createRouteHandler(route)
-    );
+
+function normalizePlaygroundPath(value) {
+  if (!value) {
+    return "/__mokup";
   }
-  return app;
-}
-async function readRawBody(req) {
-  return await new Promise((resolve, reject) => {
-    const chunks = [];
-    req.on("data", (chunk) => {
-      if (typeof chunk === "string") {
-        chunks.push(Buffer.from(chunk));
-        return;
-      }
-      if (chunk instanceof Uint8Array) {
-        chunks.push(chunk);
-        return;
-      }
-      chunks.push(Buffer.from(String(chunk)));
-    });
-    req.on("end", () => {
-      if (chunks.length === 0) {
-        resolve(null);
-        return;
-      }
-      resolve(Buffer.concat(chunks));
-    });
-    req.on("error", reject);
-  });
+  const normalized = value.startsWith("/") ? value : `/${value}`;
+  return normalized.length > 1 && normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
 }
-function buildHeaders(headers) {
-  const result = new Headers();
-  for (const [key, value] of Object.entries(headers)) {
-    if (typeof value === "undefined") {
-      continue;
-    }
-    if (Array.isArray(value)) {
-      result.set(key, value.join(","));
-    } else {
-      result.set(key, value);
-    }
+function normalizeBase(base) {
+  if (!base || base === "/") {
+    return "";
   }
-  return result;
+  return base.endsWith("/") ? base.slice(0, -1) : base;
 }
-async function toRequest(req) {
-  const url = new URL(req.url ?? "/", "http://mokup.local");
-  const method = req.method ?? "GET";
-  const headers = buildHeaders(req.headers);
-  const init = { method, headers };
-  const rawBody = await readRawBody(req);
-  if (rawBody && method !== "GET" && method !== "HEAD") {
-    init.body = rawBody;
+function resolvePlaygroundRequestPath(base, playgroundPath) {
+  const normalizedBase = normalizeBase(base);
+  const normalizedPath = normalizePlaygroundPath(playgroundPath);
+  if (!normalizedBase) {
+    return normalizedPath;
   }
-  return new Request(url.toString(), init);
+  if (normalizedPath.startsWith(normalizedBase)) {
+    return normalizedPath;
+  }
+  return `${normalizedBase}${normalizedPath}`;
 }
-async function sendResponse(res, response) {
-  res.statusCode = response.status;
-  response.headers.forEach((value, key) => {
-    res.setHeader(key, value);
-  });
-  if (!response.body) {
-    res.end();
-    return;
+function resolvePlaygroundOptions(playground) {
+  if (playground === false) {
+    return { enabled: false, path: "/__mokup" };
   }
-  const buffer = new Uint8Array(await response.arrayBuffer());
-  res.end(buffer);
-}
-function hasMatch(app, method, pathname) {
-  const matchMethod = method === "HEAD" ? "GET" : method;
-  const match = app.router.match(matchMethod, pathname);
-  return !!match && match[0].length > 0;
-}
-function createMiddleware(getApp, logger) {
-  return async (req, res, next) => {
-    const app = getApp();
-    if (!app) {
-      return next();
-    }
-    const url = req.url ?? "/";
-    const parsedUrl = new URL(url, "http://mokup.local");
-    const pathname = parsedUrl.pathname;
-    const method = normalizeMethod(req.method) ?? "GET";
-    if (!hasMatch(app, method, pathname)) {
-      return next();
-    }
-    const startedAt = Date.now();
-    try {
-      const response = await app.fetch(await toRequest(req));
-      if (res.writableEnded) {
-        return;
-      }
-      await sendResponse(res, response);
-      logger.info(`${method} ${pathname} ${Date.now() - startedAt}ms`);
-    } catch (error) {
-      if (!res.headersSent) {
-        res.statusCode = 500;
-        res.setHeader("Content-Type", "text/plain; charset=utf-8");
-      }
-      res.end("Mock handler error");
-      logger.error("Mock handler failed:", error);
-    }
-  };
+  if (playground && typeof playground === "object") {
+    return {
+      enabled: playground.enabled !== false,
+      path: normalizePlaygroundPath(playground.path)
+    };
+  }
+  return { enabled: true, path: "/__mokup" };
 }
 
 const require$1 = createRequire(import.meta.url);
@@ -361,96 +293,6 @@ const mimeTypes = {
   ".jpeg": "image/jpeg",
   ".ico": "image/x-icon"
 };
-function normalizePlaygroundPath(value) {
-  if (!value) {
-    return "/_mokup";
-  }
-  const normalized = value.startsWith("/") ? value : `/${value}`;
-  return normalized.length > 1 && normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
-}
-function normalizeBase(base) {
-  if (!base || base === "/") {
-    return "";
-  }
-  return base.endsWith("/") ? base.slice(0, -1) : base;
-}
-function resolvePlaygroundRequestPath(base, playgroundPath) {
-  const normalizedBase = normalizeBase(base);
-  const normalizedPath = normalizePlaygroundPath(playgroundPath);
-  if (!normalizedBase) {
-    return normalizedPath;
-  }
-  if (normalizedPath.startsWith(normalizedBase)) {
-    return normalizedPath;
-  }
-  return `${normalizedBase}${normalizedPath}`;
-}
-function injectPlaygroundHmr(html, base) {
-  if (html.includes("mokup-playground-hmr")) {
-    return html;
-  }
-  const normalizedBase = normalizeBase(base);
-  const clientPath = `${normalizedBase}/@vite/client`;
-  const snippet = [
-    '<script type="module" id="mokup-playground-hmr">',
-    `import('${clientPath}').then(({ createHotContext }) => {`,
-    "  const hot = createHotContext('/@mokup/playground')",
-    "  hot.on('mokup:routes-changed', () => {",
-    "    const api = window.__MOKUP_PLAYGROUND__",
-    "    if (api && typeof api.reloadRoutes === 'function') {",
-    "      api.reloadRoutes()",
-    "      return",
-    "    }",
-    "    window.location.reload()",
-    "  })",
-    "}).catch(() => {})",
-    "<\/script>"
-  ].join("\n");
-  if (html.includes("</body>")) {
-    return html.replace("</body>", `${snippet}
-</body>`);
-  }
-  return `${html}
-${snippet}`;
-}
-function injectPlaygroundSw(html, script) {
-  if (!script) {
-    return html;
-  }
-  if (html.includes("mokup-playground-sw")) {
-    return html;
-  }
-  const snippet = [
-    '<script type="module" id="mokup-playground-sw">',
-    script,
-    "<\/script>"
-  ].join("\n");
-  if (html.includes("</head>")) {
-    return html.replace("</head>", `${snippet}
-</head>`);
-  }
-  if (html.includes("</body>")) {
-    return html.replace("</body>", `${snippet}
-</body>`);
-  }
-  return `${html}
-${snippet}`;
-}
-function isViteDevServer(server) {
-  return !!server && "ws" in server;
-}
-function resolvePlaygroundOptions(playground) {
-  if (playground === false) {
-    return { enabled: false, path: "/_mokup" };
-  }
-  if (playground && typeof playground === "object") {
-    return {
-      enabled: playground.enabled !== false,
-      path: normalizePlaygroundPath(playground.path)
-    };
-  }
-  return { enabled: true, path: "/_mokup" };
-}
 function resolvePlaygroundDist() {
   const pkgPath = require$1.resolve("@mokup/playground/package.json");
   return join(pkgPath, "..", "dist");
@@ -465,6 +307,7 @@ function sendFile(res, content, contentType) {
   res.setHeader("Content-Type", contentType);
   res.end(content);
 }
+
 function toPosixPath(value) {
   return value.replace(/\\/g, "/");
 }
@@ -506,41 +349,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();
@@ -575,64 +383,205 @@ function resolveRouteGroup(routeFile, groups) {
   }
   return matched;
 }
-function toPlaygroundRoute(route, root, groups) {
-  const matchedGroup = resolveRouteGroup(route.file, groups);
-  const middlewareSources = route.middlewares?.map((entry) => formatRouteFile(entry.source, root));
-  return {
-    method: route.method,
-    url: route.template,
-    file: formatRouteFile(route.file, root),
-    type: typeof route.handler === "function" ? "handler" : "static",
-    status: route.status,
-    delay: route.delay,
-    middlewareCount: middlewareSources?.length ?? 0,
-    middlewares: middlewareSources,
-    groupKey: matchedGroup?.key,
-    group: matchedGroup?.label
-  };
-}
-function toPlaygroundDisabledRoute(route, root, groups) {
-  const matchedGroup = resolveRouteGroup(route.file, groups);
-  const disabled = {
-    file: formatRouteFile(route.file, root),
-    reason: normalizeDisabledReason(route.reason)
-  };
-  if (typeof route.method !== "undefined") {
-    disabled.method = route.method;
-  }
-  if (typeof route.url !== "undefined") {
-    disabled.url = route.url;
+function formatRouteFile(file, root) {
+  if (!root) {
+    return toPosixPath(file);
   }
-  if (matchedGroup) {
-    disabled.groupKey = matchedGroup.key;
-    disabled.group = matchedGroup.label;
+  const rel = toPosixPath(relative(root, file));
+  if (!rel || rel.startsWith("..")) {
+    return toPosixPath(file);
   }
-  return disabled;
+  return rel;
 }
-function toPlaygroundIgnoredRoute(route, root, groups) {
-  const matchedGroup = resolveRouteGroup(route.file, groups);
-  const ignored = {
-    file: formatRouteFile(route.file, root),
-    reason: normalizeIgnoredReason(route.reason)
-  };
-  if (matchedGroup) {
-    ignored.groupKey = matchedGroup.key;
-    ignored.group = matchedGroup.label;
+
+function injectPlaygroundHmr(html, base) {
+  if (html.includes("mokup-playground-hmr")) {
+    return html;
   }
-  return ignored;
-}
-function toPlaygroundConfigFile(entry, root, groups) {
-  const matchedGroup = resolveRouteGroup(entry.file, groups);
-  const configFile = {
-    file: formatRouteFile(entry.file, root)
-  };
-  if (matchedGroup) {
-    configFile.groupKey = matchedGroup.key;
-    configFile.group = matchedGroup.label;
+  const normalizedBase = normalizeBase(base);
+  const clientPath = `${normalizedBase}/@vite/client`;
+  const snippet = [
+    '<script type="module" id="mokup-playground-hmr">',
+    `import('${clientPath}').then(({ createHotContext }) => {`,
+    "  const hot = createHotContext('/@mokup/playground')",
+    "  hot.on('mokup:routes-changed', () => {",
+    "    const api = window.__MOKUP_PLAYGROUND__",
+    "    if (api && typeof api.reloadRoutes === 'function') {",
+    "      api.reloadRoutes()",
+    "      return",
+    "    }",
+    "    window.location.reload()",
+    "  })",
+    "}).catch(() => {})",
+    "<\/script>"
+  ].join("\n");
+  if (html.includes("</body>")) {
+    return html.replace("</body>", `${snippet}
+</body>`);
   }
-  return configFile;
+  return `${html}
+${snippet}`;
 }
-function createPlaygroundMiddleware(params) {
+function injectPlaygroundSw(html, script) {
+  if (!script) {
+    return html;
+  }
+  if (html.includes("mokup-playground-sw")) {
+    return html;
+  }
+  const snippet = [
+    '<script type="module" id="mokup-playground-sw">',
+    script,
+    "<\/script>"
+  ].join("\n");
+  if (html.includes("</head>")) {
+    return html.replace("</head>", `${snippet}
+</head>`);
+  }
+  if (html.includes("</body>")) {
+    return html.replace("</body>", `${snippet}
+</body>`);
+  }
+  return `${html}
+${snippet}`;
+}
+function isViteDevServer(server) {
+  return !!server && "ws" in server;
+}
+
+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 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
+  ];
+  const configChain = route.configChain?.map((entry) => formatRouteFile(entry, root)) ?? [];
+  return {
+    method: route.method,
+    url: route.template,
+    file: formatRouteFile(route.file, root),
+    type: typeof route.handler === "function" ? "handler" : "static",
+    status: route.status,
+    delay: route.delay,
+    middlewareCount: combinedSources.length,
+    middlewares: combinedSources,
+    preMiddlewareCount: preSources.length,
+    normalMiddlewareCount: normalSources.length,
+    postMiddlewareCount: postSources.length,
+    preMiddlewares: preSources,
+    normalMiddlewares: normalSources,
+    postMiddlewares: postSources,
+    configChain: configChain.length > 0 ? configChain : void 0,
+    groupKey: matchedGroup?.key,
+    group: matchedGroup?.label
+  };
+}
+function toPlaygroundDisabledRoute(route, root, groups) {
+  const matchedGroup = resolveRouteGroup(route.file, groups);
+  const disabled = {
+    file: formatRouteFile(route.file, root),
+    reason: normalizeDisabledReason(route.reason)
+  };
+  if (typeof route.method !== "undefined") {
+    disabled.method = route.method;
+  }
+  if (typeof route.url !== "undefined") {
+    disabled.url = route.url;
+  }
+  if (route.configChain && route.configChain.length > 0) {
+    disabled.configChain = route.configChain.map((entry) => formatRouteFile(entry, root));
+  }
+  if (route.decisionChain && route.decisionChain.length > 0) {
+    disabled.decisionChain = formatDecisionChain(route.decisionChain, root);
+  }
+  if (route.effectiveConfig && Object.keys(route.effectiveConfig).length > 0) {
+    disabled.effectiveConfig = route.effectiveConfig;
+  }
+  if (matchedGroup) {
+    disabled.groupKey = matchedGroup.key;
+    disabled.group = matchedGroup.label;
+  }
+  return disabled;
+}
+function toPlaygroundIgnoredRoute(route, root, groups) {
+  const matchedGroup = resolveRouteGroup(route.file, groups);
+  const ignored = {
+    file: formatRouteFile(route.file, root),
+    reason: normalizeIgnoredReason(route.reason)
+  };
+  if (matchedGroup) {
+    ignored.groupKey = matchedGroup.key;
+    ignored.group = matchedGroup.label;
+  }
+  if (route.configChain && route.configChain.length > 0) {
+    ignored.configChain = route.configChain.map((entry) => formatRouteFile(entry, root));
+  }
+  if (route.decisionChain && route.decisionChain.length > 0) {
+    ignored.decisionChain = formatDecisionChain(route.decisionChain, root);
+  }
+  if (route.effectiveConfig && Object.keys(route.effectiveConfig).length > 0) {
+    ignored.effectiveConfig = route.effectiveConfig;
+  }
+  return ignored;
+}
+function toPlaygroundConfigFile(entry, root, groups) {
+  const matchedGroup = resolveRouteGroup(entry.file, groups);
+  const configFile = {
+    file: formatRouteFile(entry.file, root)
+  };
+  if (matchedGroup) {
+    configFile.groupKey = matchedGroup.key;
+    configFile.group = matchedGroup.label;
+  }
+  return configFile;
+}
+function formatDecisionChain(chain, root) {
+  return chain.map((entry) => {
+    const formatted = {
+      step: entry.step,
+      result: entry.result
+    };
+    if (typeof entry.detail !== "undefined") {
+      formatted.detail = entry.detail;
+    }
+    if (typeof entry.source !== "undefined") {
+      const source = entry.source;
+      formatted.source = source && isAbsolute(source) ? formatRouteFile(source, root) : source;
+    }
+    return formatted;
+  });
+}
+
+function createPlaygroundMiddleware(params) {
   const distDir = resolvePlaygroundDist();
   const playgroundPath = params.config.path;
   const indexPath = join(distDir, "index.html");
@@ -715,932 +664,1394 @@ function createPlaygroundMiddleware(params) {
   };
 }
 
-const jsonExtensions = /* @__PURE__ */ new Set([".json", ".jsonc"]);
-function resolveTemplate(template, prefix) {
-  const normalized = template.startsWith("/") ? template : `/${template}`;
-  if (!prefix) {
-    return normalized;
+const defaultSwPath = "/mokup-sw.js";
+const defaultSwScope = "/";
+function normalizeSwPath(path) {
+  if (!path) {
+    return defaultSwPath;
   }
-  const normalizedPrefix = normalizePrefix(prefix);
-  if (!normalizedPrefix) {
-    return normalized;
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function normalizeSwScope(scope) {
+  if (!scope) {
+    return defaultSwScope;
   }
-  if (normalized === normalizedPrefix || normalized.startsWith(`${normalizedPrefix}/`)) {
-    return normalized;
+  return scope.startsWith("/") ? scope : `/${scope}`;
+}
+function normalizeBasePath(value) {
+  if (!value) {
+    return "/";
   }
-  if (normalized === "/") {
-    return `${normalizedPrefix}/`;
+  const normalized = value.startsWith("/") ? value : `/${value}`;
+  if (normalized.length > 1 && normalized.endsWith("/")) {
+    return normalized.slice(0, -1);
   }
-  return `${normalizedPrefix}${normalized}`;
+  return normalized;
 }
-function stripMethodSuffix(base) {
-  const segments = base.split(".");
-  const last = segments.at(-1);
-  if (last && methodSuffixSet.has(last.toLowerCase())) {
-    segments.pop();
-    return {
-      name: segments.join("."),
-      method: last.toUpperCase()
-    };
+function resolveSwConfigFromEntries(entries, logger) {
+  let path = defaultSwPath;
+  let scope = defaultSwScope;
+  let register = true;
+  let unregister = false;
+  const basePaths = [];
+  let hasPath = false;
+  let hasScope = false;
+  let hasRegister = false;
+  let hasUnregister = false;
+  for (const entry of entries) {
+    const config = entry.sw;
+    if (config?.path) {
+      const next = normalizeSwPath(config.path);
+      if (!hasPath) {
+        path = next;
+        hasPath = true;
+      } else if (path !== next) {
+        logger.warn(`SW path "${next}" ignored; using "${path}".`);
+      }
+    }
+    if (config?.scope) {
+      const next = normalizeSwScope(config.scope);
+      if (!hasScope) {
+        scope = next;
+        hasScope = true;
+      } else if (scope !== next) {
+        logger.warn(`SW scope "${next}" ignored; using "${scope}".`);
+      }
+    }
+    if (typeof config?.register === "boolean") {
+      if (!hasRegister) {
+        register = config.register;
+        hasRegister = true;
+      } else if (register !== config.register) {
+        logger.warn(
+          `SW register="${String(config.register)}" ignored; using "${String(register)}".`
+        );
+      }
+    }
+    if (typeof config?.unregister === "boolean") {
+      if (!hasUnregister) {
+        unregister = config.unregister;
+        hasUnregister = true;
+      } else if (unregister !== config.unregister) {
+        logger.warn(
+          `SW unregister="${String(config.unregister)}" ignored; using "${String(unregister)}".`
+        );
+      }
+    }
+    if (typeof config?.basePath !== "undefined") {
+      const values = Array.isArray(config.basePath) ? config.basePath : [config.basePath];
+      for (const value of values) {
+        basePaths.push(normalizeBasePath(value));
+      }
+      continue;
+    }
+    const normalizedPrefix = normalizePrefix(entry.prefix ?? "");
+    if (normalizedPrefix) {
+      basePaths.push(normalizedPrefix);
+    }
   }
   return {
-    name: base,
-    method: void 0
+    path,
+    scope,
+    register,
+    unregister,
+    basePaths: Array.from(new Set(basePaths))
   };
 }
-function deriveRouteFromFile(file, rootDir, logger) {
-  const rel = toPosix(relative(rootDir, file));
-  const ext = extname(rel);
-  const withoutExt = rel.slice(0, rel.length - ext.length);
-  const dir = dirname(withoutExt);
-  const base = basename(withoutExt);
-  const { name, method } = stripMethodSuffix(base);
-  const resolvedMethod = method ?? (jsonExtensions.has(ext) ? "GET" : void 0);
-  if (!resolvedMethod) {
-    logger.warn(`Skip mock without method suffix: ${file}`);
-    return null;
-  }
-  if (!name) {
-    logger.warn(`Skip mock with empty route name: ${file}`);
+function resolveSwConfig(options, logger) {
+  const swEntries = options.filter((entry) => entry.mode === "sw");
+  if (swEntries.length === 0) {
     return null;
   }
-  const joined = dir === "." ? name : join(dir, name);
-  const segments = toPosix(joined).split("/");
-  if (segments.at(-1) === "index") {
-    segments.pop();
-  }
-  const template = segments.length === 0 ? "/" : `/${segments.join("/")}`;
-  const parsed = parseRouteTemplate(template);
-  if (parsed.errors.length > 0) {
-    for (const error of parsed.errors) {
-      logger.warn(`${error} in ${file}`);
-    }
-    return null;
-  }
-  for (const warning of parsed.warnings) {
-    logger.warn(`${warning} in ${file}`);
-  }
-  return {
-    template: parsed.template,
-    method: resolvedMethod,
-    tokens: parsed.tokens,
-    score: parsed.score
-  };
+  return resolveSwConfigFromEntries(swEntries, logger);
 }
-function resolveRule(params) {
-  const method = params.derivedMethod;
-  if (!method) {
-    params.logger.warn(`Skip mock without method suffix: ${params.file}`);
-    return null;
+function resolveSwUnregisterConfig(options, logger) {
+  return resolveSwConfigFromEntries(options, logger);
+}
+function buildSwScript(params) {
+  const { routes, root } = params;
+  const runtimeImportPath = params.runtimeImportPath ?? "mokup/runtime";
+  const loggerImportPath = params.loggerImportPath ?? "@mokup/shared/logger";
+  const basePaths = params.basePaths ?? [];
+  const resolveModulePath = params.resolveModulePath ?? toViteImportPath;
+  const { manifest, modules } = buildManifestData({
+    routes,
+    root,
+    resolveModulePath
+  });
+  const imports = [
+    `import { createLogger } from ${JSON.stringify(loggerImportPath)}`,
+    `import { createRuntimeApp, handle } from ${JSON.stringify(runtimeImportPath)}`
+  ];
+  const moduleEntries = [];
+  let moduleIndex = 0;
+  for (const entry of modules) {
+    const name = `module${moduleIndex++}`;
+    imports.push(`import * as ${name} from '${entry.id}'`);
+    moduleEntries.push({ id: entry.id, name, kind: entry.kind });
   }
-  const template = resolveTemplate(params.derivedTemplate, params.prefix);
-  const parsed = parseRouteTemplate(template);
-  if (parsed.errors.length > 0) {
-    for (const error of parsed.errors) {
-      params.logger.warn(`${error} in ${params.file}`);
+  const lines = [];
+  lines.push(...imports, "");
+  lines.push(
+    "const logger = createLogger()",
+    "",
+    "const resolveModuleExport = (mod) => mod?.default ?? mod",
+    "",
+    "const toRuntimeRule = (value) => {",
+    "  if (typeof value === 'undefined') {",
+    "    return null",
+    "  }",
+    "  if (typeof value === 'function') {",
+    "    return { response: value }",
+    "  }",
+    "  if (value === null) {",
+    "    return { response: null }",
+    "  }",
+    "  if (typeof value === 'object') {",
+    "    if ('response' in value) {",
+    "      return value",
+    "    }",
+    "    if ('handler' in value) {",
+    "      const handlerRule = value",
+    "      return {",
+    "        response: handlerRule.handler,",
+    "        ...(typeof handlerRule.status === 'number' ? { status: handlerRule.status } : {}),",
+    "        ...(handlerRule.headers ? { headers: handlerRule.headers } : {}),",
+    "        ...(typeof handlerRule.delay === 'number' ? { delay: handlerRule.delay } : {}),",
+    "      }",
+    "    }",
+    "    return { response: value }",
+    "  }",
+    "  return { response: value }",
+    "}",
+    "",
+    "const toRuntimeRules = (value) => {",
+    "  if (typeof value === 'undefined') {",
+    "    return []",
+    "  }",
+    "  if (Array.isArray(value)) {",
+    "    return value.map(toRuntimeRule).filter(Boolean)",
+    "  }",
+    "  const rule = toRuntimeRule(value)",
+    "  return rule ? [rule] : []",
+    "}",
+    ""
+  );
+  lines.push(
+    `const manifest = ${JSON.stringify(manifest, null, 2)}`,
+    ""
+  );
+  if (moduleEntries.length > 0) {
+    lines.push("const moduleMap = {");
+    for (const entry of moduleEntries) {
+      if (entry.kind === "rule") {
+        lines.push(
+          `  ${JSON.stringify(entry.id)}: { default: toRuntimeRules(resolveModuleExport(${entry.name})) },`
+        );
+        continue;
+      }
+      lines.push(
+        `  ${JSON.stringify(entry.id)}: ${entry.name},`
+      );
     }
-    return null;
-  }
-  for (const warning of parsed.warnings) {
-    params.logger.warn(`${warning} in ${params.file}`);
-  }
-  const route = {
-    file: params.file,
-    template: parsed.template,
-    method,
-    tokens: parsed.tokens,
-    score: parsed.score,
-    handler: params.rule.handler
-  };
-  if (typeof params.rule.status === "number") {
-    route.status = params.rule.status;
-  }
-  if (params.rule.headers) {
-    route.headers = params.rule.headers;
-  }
-  if (typeof params.rule.delay === "number") {
-    route.delay = params.rule.delay;
+    lines.push("}", "");
   }
-  return route;
+  const runtimeOptions = moduleEntries.length > 0 ? "{ manifest, moduleMap }" : "{ manifest }";
+  lines.push(
+    `const basePaths = ${JSON.stringify(basePaths)}`,
+    "",
+    "self.addEventListener('install', () => {",
+    "  self.skipWaiting()",
+    "})",
+    "",
+    "self.addEventListener('activate', (event) => {",
+    "  event.waitUntil(self.clients.claim())",
+    "})",
+    "",
+    "const shouldHandle = (request) => {",
+    "  if (!basePaths || basePaths.length === 0) {",
+    "    return true",
+    "  }",
+    "  const pathname = new URL(request.url).pathname",
+    "  return basePaths.some((basePath) => {",
+    "    if (basePath === '/') {",
+    "      return true",
+    "    }",
+    "    return pathname === basePath || pathname.startsWith(basePath + '/')",
+    "  })",
+    "}",
+    "",
+    "const registerHandler = async () => {",
+    `  const app = await createRuntimeApp(${runtimeOptions})`,
+    "  const handler = handle(app)",
+    "  self.addEventListener('fetch', (event) => {",
+    "    if (!shouldHandle(event.request)) {",
+    "      return",
+    "    }",
+    "    handler(event)",
+    "  })",
+    "}",
+    "",
+    "registerHandler().catch((error) => {",
+    "  logger.error('Failed to build service worker app:', error)",
+    "})",
+    ""
+  );
+  return lines.join("\n");
 }
-function sortRoutes(routes) {
-  return routes.sort((a, b) => {
-    if (a.method !== b.method) {
-      return a.method.localeCompare(b.method);
+
+function toHonoPath(route) {
+  if (!route.tokens || route.tokens.length === 0) {
+    return "/";
+  }
+  const segments = route.tokens.map((token) => {
+    if (token.type === "static") {
+      return token.value;
     }
-    const scoreCompare = compareRouteScore(a.score, b.score);
-    if (scoreCompare !== 0) {
-      return scoreCompare;
+    if (token.type === "param") {
+      return `:${token.name}`;
     }
-    return a.template.localeCompare(b.template);
+    if (token.type === "catchall") {
+      return `:${token.name}{.+}`;
+    }
+    return `:${token.name}{.+}?`;
   });
+  return `/${segments.join("/")}`;
 }
-
-async function loadModule$1(file) {
-  const ext = configExtensions.find((extension) => file.endsWith(extension));
-  if (ext === ".cjs") {
-    const require = createRequire(import.meta.url);
-    delete require.cache[file];
-    return require(file);
-  }
-  if (ext === ".js" || ext === ".mjs") {
-    return import(`${pathToFileURL(file).href}?t=${Date.now()}`);
+function isValidStatus(status) {
+  return typeof status === "number" && Number.isFinite(status) && status >= 200 && status <= 599;
+}
+function resolveStatus(routeStatus, responseStatus) {
+  if (isValidStatus(routeStatus)) {
+    return routeStatus;
   }
-  if (ext === ".ts") {
-    const result = await build({
-      entryPoints: [file],
-      bundle: true,
-      format: "esm",
-      platform: "node",
-      sourcemap: "inline",
-      target: "es2020",
-      write: false
-    });
-    const output = result.outputFiles[0];
-    const code = output?.text ?? "";
-    const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString(
-      "base64"
-    )}`;
-    return import(`${dataUrl}#${Date.now()}`);
+  if (isValidStatus(responseStatus)) {
+    return responseStatus;
   }
-  return null;
+  return 200;
 }
-async function loadModuleWithVite$1(server, file) {
-  const asDevServer = server;
-  if ("ssrLoadModule" in asDevServer) {
-    const moduleNode = asDevServer.moduleGraph.getModuleById(file);
-    if (moduleNode) {
-      asDevServer.moduleGraph.invalidateModule(moduleNode);
+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);
     }
-    return asDevServer.ssrLoadModule(file);
-  }
-  return loadModule$1(file);
-}
-function getConfigFileCandidates(dir) {
-  return configExtensions.map((extension) => join(dir, `index.config${extension}`));
-}
-async function findConfigFile(dir, cache) {
-  const cached = cache.get(dir);
-  if (cached !== void 0) {
-    return cached;
   }
-  for (const candidate of getConfigFileCandidates(dir)) {
-    try {
-      await promises.stat(candidate);
-      cache.set(dir, candidate);
-      return candidate;
-    } catch {
-      continue;
-    }
+  const status = resolveStatus(route.status, response.status);
+  if (status === response.status && !hasHeaders) {
+    return response;
   }
-  cache.set(dir, null);
-  return null;
+  return new Response(response.body, { status, headers });
 }
-async function loadConfig(file, server) {
-  const mod = server ? await loadModuleWithVite$1(server, file) : await loadModule$1(file);
-  if (!mod) {
-    return null;
+function resolveResponse(value, fallback) {
+  if (value instanceof Response) {
+    return value;
   }
-  const value = mod?.default ?? mod;
-  if (!value || typeof value !== "object") {
-    return null;
+  if (value && typeof value === "object" && "res" in value) {
+    const resolved = value.res;
+    if (resolved instanceof Response) {
+      return resolved;
+    }
   }
-  return value;
+  return fallback;
 }
-function normalizeMiddlewares(value, source, logger) {
-  if (!value) {
-    return [];
+function normalizeHandlerValue(c, value) {
+  if (value instanceof Response) {
+    return value;
   }
-  const list = Array.isArray(value) ? value : [value];
-  const middlewares = [];
-  for (const [index, entry] of list.entries()) {
-    if (typeof entry !== "function") {
-      logger.warn(`Invalid middleware in ${source}`);
-      continue;
+  if (typeof value === "undefined") {
+    const response = c.body(null);
+    if (response.status === 200) {
+      return new Response(response.body, {
+        status: 204,
+        headers: response.headers
+      });
     }
-    middlewares.push({ handle: entry, source, index });
+    return response;
   }
-  return middlewares;
-}
-async function resolveDirectoryConfig(params) {
-  const { file, rootDir, server, logger, configCache, fileCache } = params;
-  const resolvedRoot = normalize(rootDir);
-  const resolvedFileDir = normalize(dirname(file));
-  const chain = [];
-  let current = resolvedFileDir;
-  while (true) {
-    chain.push(current);
-    if (current === resolvedRoot) {
-      break;
-    }
-    const parent = dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
+  if (typeof value === "string") {
+    return c.text(value);
   }
-  chain.reverse();
-  const merged = { middlewares: [] };
-  for (const dir of chain) {
-    const configPath = await findConfigFile(dir, fileCache);
-    if (!configPath) {
-      continue;
-    }
-    let config = configCache.get(configPath);
-    if (config === void 0) {
-      config = await loadConfig(configPath, server);
-      configCache.set(configPath, config);
-    }
-    if (!config) {
-      logger.warn(`Invalid config in ${configPath}`);
-      continue;
-    }
-    if (config.headers) {
-      merged.headers = { ...merged.headers ?? {}, ...config.headers };
-    }
-    if (typeof config.status === "number") {
-      merged.status = config.status;
-    }
-    if (typeof config.delay === "number") {
-      merged.delay = config.delay;
-    }
-    if (typeof config.enabled === "boolean") {
-      merged.enabled = config.enabled;
-    }
-    if (typeof config.ignorePrefix !== "undefined") {
-      merged.ignorePrefix = config.ignorePrefix;
-    }
-    if (typeof config.include !== "undefined") {
-      merged.include = config.include;
-    }
-    if (typeof config.exclude !== "undefined") {
-      merged.exclude = config.exclude;
-    }
-    const normalized = normalizeMiddlewares(config.middleware, configPath, logger);
-    if (normalized.length > 0) {
-      merged.middlewares.push(...normalized);
+  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 merged;
+  return c.json(value);
 }
-
-async function walkDir(dir, rootDir, files) {
-  const entries = await promises.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.name === "node_modules" || entry.name === ".git") {
-      continue;
-    }
-    const fullPath = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      await walkDir(fullPath, rootDir, files);
-      continue;
+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) {
+  return async (c, next) => {
+    const response = await next();
+    const resolved = resolveResponse(response, c.res);
+    if (route.delay && route.delay > 0) {
+      await delay(route.delay);
     }
-    if (entry.isFile()) {
-      files.push({ file: fullPath, rootDir });
+    const overridden = applyRouteOverrides(resolved, route);
+    c.res = overridden;
+    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 { before, normal, after };
 }
-async function exists(path) {
-  try {
-    await promises.stat(path);
-    return true;
-  } catch {
-    return false;
+function createHonoApp(routes) {
+  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),
+      ...before,
+      ...normal,
+      ...after,
+      createRouteHandler(route)
+    );
   }
+  return app;
 }
-async function collectFiles(dirs) {
-  const files = [];
-  for (const dir of dirs) {
-    if (!await exists(dir)) {
+async function readRawBody(req) {
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => {
+      if (typeof chunk === "string") {
+        chunks.push(Buffer.from(chunk));
+        return;
+      }
+      if (chunk instanceof Uint8Array) {
+        chunks.push(chunk);
+        return;
+      }
+      chunks.push(Buffer.from(String(chunk)));
+    });
+    req.on("end", () => {
+      if (chunks.length === 0) {
+        resolve(null);
+        return;
+      }
+      resolve(Buffer.concat(chunks));
+    });
+    req.on("error", reject);
+  });
+}
+function buildHeaders(headers) {
+  const result = new Headers();
+  for (const [key, value] of Object.entries(headers)) {
+    if (typeof value === "undefined") {
       continue;
     }
-    await walkDir(dir, dir, files);
-  }
-  return files;
-}
-function isSupportedFile(file) {
-  if (file.endsWith(".d.ts")) {
-    return false;
-  }
-  if (isConfigFile(file)) {
-    return false;
+    if (Array.isArray(value)) {
+      result.set(key, value.join(","));
+    } else {
+      result.set(key, value);
+    }
   }
-  const ext = extname(file).toLowerCase();
-  return supportedExtensions.has(ext);
+  return result;
 }
-function isConfigFile(file) {
-  if (file.endsWith(".d.ts")) {
-    return false;
-  }
-  const base = basename(file);
-  if (!base.startsWith("index.config.")) {
-    return false;
+async function toRequest(req) {
+  const url = new URL(req.url ?? "/", "http://mokup.local");
+  const method = req.method ?? "GET";
+  const headers = buildHeaders(req.headers);
+  const init = { method, headers };
+  const rawBody = await readRawBody(req);
+  if (rawBody && method !== "GET" && method !== "HEAD") {
+    init.body = rawBody;
   }
-  const ext = extname(file).toLowerCase();
-  return configExtensions.includes(ext);
+  return new Request(url.toString(), init);
 }
-
-async function loadModule(file) {
-  const ext = extname(file).toLowerCase();
-  if (ext === ".cjs") {
-    const require = createRequire(import.meta.url);
-    delete require.cache[file];
-    return require(file);
-  }
-  if (ext === ".js" || ext === ".mjs") {
-    return import(`${pathToFileURL(file).href}?t=${Date.now()}`);
-  }
-  if (ext === ".ts") {
-    const result = await build({
-      entryPoints: [file],
-      bundle: true,
-      format: "esm",
-      platform: "node",
-      sourcemap: "inline",
-      target: "es2020",
-      write: false
-    });
-    const output = result.outputFiles[0];
-    const code = output?.text ?? "";
-    const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString(
-      "base64"
-    )}`;
-    return import(`${dataUrl}#${Date.now()}`);
+async function sendResponse(res, response) {
+  res.statusCode = response.status;
+  response.headers.forEach((value, key) => {
+    res.setHeader(key, value);
+  });
+  if (!response.body) {
+    res.end();
+    return;
   }
-  return null;
+  const buffer = new Uint8Array(await response.arrayBuffer());
+  res.end(buffer);
 }
-async function loadModuleWithVite(server, file) {
-  const asDevServer = server;
-  if ("ssrLoadModule" in asDevServer) {
-    const moduleNode = asDevServer.moduleGraph.getModuleById(file);
-    if (moduleNode) {
-      asDevServer.moduleGraph.invalidateModule(moduleNode);
-    }
-    return asDevServer.ssrLoadModule(file);
-  }
-  return loadModule(file);
+function hasMatch(app, method, pathname) {
+  const matchMethod = method === "HEAD" ? "GET" : method;
+  const match = app.router.match(matchMethod, pathname);
+  return !!match && match[0].length > 0;
 }
-async function readJsonFile(file, logger) {
-  try {
-    const content = await promises.readFile(file, "utf8");
-    const errors = [];
-    const data = parse(content, errors, {
-      allowTrailingComma: true,
-      disallowComments: false
-    });
-    if (errors.length > 0) {
-      logger.warn(`Invalid JSONC in ${file}`);
-      return void 0;
+function createMiddleware(getApp, logger) {
+  return async (req, res, next) => {
+    const app = getApp();
+    if (!app) {
+      return next();
     }
-    return data;
-  } catch (error) {
-    logger.warn(`Failed to read ${file}: ${String(error)}`);
-    return void 0;
-  }
-}
-async function loadRules(file, server, logger) {
-  const ext = extname(file).toLowerCase();
-  if (ext === ".json" || ext === ".jsonc") {
-    const json = await readJsonFile(file, logger);
-    if (typeof json === "undefined") {
-      return [];
+    const url = req.url ?? "/";
+    const parsedUrl = new URL(url, "http://mokup.local");
+    const pathname = parsedUrl.pathname;
+    const method = normalizeMethod(req.method) ?? "GET";
+    if (!hasMatch(app, method, pathname)) {
+      return next();
     }
-    return [
-      {
-        handler: json
+    const startedAt = Date.now();
+    try {
+      const response = await app.fetch(await toRequest(req));
+      if (res.writableEnded) {
+        return;
       }
-    ];
+      await sendResponse(res, response);
+      logger.info(`${method} ${pathname} ${Date.now() - startedAt}ms`);
+    } catch (error) {
+      if (!res.headersSent) {
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "text/plain; charset=utf-8");
+      }
+      res.end("Mock handler error");
+      logger.error("Mock handler failed:", error);
+    }
+  };
+}
+
+const jsonExtensions = /* @__PURE__ */ new Set([".json", ".jsonc"]);
+function resolveTemplate(template, prefix) {
+  const normalized = template.startsWith("/") ? template : `/${template}`;
+  if (!prefix) {
+    return normalized;
   }
-  const mod = server ? await loadModuleWithVite(server, file) : await loadModule(file);
-  const value = mod?.default ?? mod;
-  if (!value) {
-    return [];
+  const normalizedPrefix = normalizePrefix(prefix);
+  if (!normalizedPrefix) {
+    return normalized;
   }
-  if (Array.isArray(value)) {
-    return value;
+  if (normalized === normalizedPrefix || normalized.startsWith(`${normalizedPrefix}/`)) {
+    return normalized;
   }
-  if (typeof value === "function") {
-    return [
-      {
-        handler: value
-      }
-    ];
+  if (normalized === "/") {
+    return `${normalizedPrefix}/`;
   }
-  return [value];
+  return `${normalizedPrefix}${normalized}`;
 }
-
-const silentLogger = {
-  info: () => {
-  },
-  warn: () => {
-  },
-  error: () => {
+function stripMethodSuffix(base) {
+  const segments = base.split(".");
+  const last = segments.at(-1);
+  if (last && methodSuffixSet.has(last.toLowerCase())) {
+    segments.pop();
+    return {
+      name: segments.join("."),
+      method: last.toUpperCase()
+    };
   }
-};
-function resolveSkipRoute(params) {
-  const derived = params.derived ?? deriveRouteFromFile(params.file, params.rootDir, silentLogger);
-  if (!derived?.method) {
+  return {
+    name: base,
+    method: void 0
+  };
+}
+function deriveRouteFromFile(file, rootDir, logger) {
+  const rel = toPosix(relative(rootDir, file));
+  const ext = extname(rel);
+  const withoutExt = rel.slice(0, rel.length - ext.length);
+  const dir = dirname(withoutExt);
+  const base = basename(withoutExt);
+  const { name, method } = stripMethodSuffix(base);
+  const resolvedMethod = method ?? (jsonExtensions.has(ext) ? "GET" : void 0);
+  if (!resolvedMethod) {
+    logger.warn(`Skip mock without method suffix: ${file}`);
     return null;
   }
-  const resolved = resolveRule({
-    rule: { handler: null },
-    derivedTemplate: derived.template,
-    derivedMethod: derived.method,
-    prefix: params.prefix,
-    file: params.file,
-    logger: silentLogger
-  });
-  if (!resolved) {
+  if (!name) {
+    logger.warn(`Skip mock with empty route name: ${file}`);
+    return null;
+  }
+  const joined = dir === "." ? name : join(dir, name);
+  const segments = toPosix(joined).split("/");
+  if (segments.at(-1) === "index") {
+    segments.pop();
+  }
+  const template = segments.length === 0 ? "/" : `/${segments.join("/")}`;
+  const parsed = parseRouteTemplate(template);
+  if (parsed.errors.length > 0) {
+    for (const error of parsed.errors) {
+      logger.warn(`${error} in ${file}`);
+    }
     return null;
   }
+  for (const warning of parsed.warnings) {
+    logger.warn(`${warning} in ${file}`);
+  }
   return {
-    method: resolved.method,
-    url: resolved.template
+    template: parsed.template,
+    method: resolvedMethod,
+    tokens: parsed.tokens,
+    score: parsed.score
   };
 }
-function buildSkipInfo(file, reason, resolved) {
-  const info = { file, reason };
-  if (resolved) {
-    info.method = resolved.method;
-    info.url = resolved.url;
+function resolveRule(params) {
+  const method = params.derivedMethod;
+  if (!method) {
+    params.logger.warn(`Skip mock without method suffix: ${params.file}`);
+    return null;
   }
-  return info;
+  const template = resolveTemplate(params.derivedTemplate, params.prefix);
+  const parsed = parseRouteTemplate(template);
+  if (parsed.errors.length > 0) {
+    for (const error of parsed.errors) {
+      params.logger.warn(`${error} in ${params.file}`);
+    }
+    return null;
+  }
+  for (const warning of parsed.warnings) {
+    params.logger.warn(`${warning} in ${params.file}`);
+  }
+  const route = {
+    file: params.file,
+    template: parsed.template,
+    method,
+    tokens: parsed.tokens,
+    score: parsed.score,
+    handler: params.rule.handler
+  };
+  if (typeof params.rule.status === "number") {
+    route.status = params.rule.status;
+  }
+  if (params.rule.headers) {
+    route.headers = params.rule.headers;
+  }
+  if (typeof params.rule.delay === "number") {
+    route.delay = params.rule.delay;
+  }
+  return route;
 }
-async function scanRoutes(params) {
-  const routes = [];
-  const seen = /* @__PURE__ */ new Set();
-  const files = await collectFiles(params.dirs);
-  const globalIgnorePrefix = normalizeIgnorePrefix(params.ignorePrefix);
-  const configCache = /* @__PURE__ */ new Map();
-  const fileCache = /* @__PURE__ */ new Map();
-  const shouldCollectSkip = typeof params.onSkip === "function";
-  const shouldCollectIgnore = typeof params.onIgnore === "function";
-  const shouldCollectConfig = typeof params.onConfig === "function";
-  for (const fileInfo of files) {
-    if (isConfigFile(fileInfo.file)) {
-      if (shouldCollectConfig) {
-        const config2 = await resolveDirectoryConfig({
-          file: fileInfo.file,
-          rootDir: fileInfo.rootDir,
-          server: params.server,
-          logger: params.logger,
-          configCache,
-          fileCache
-        });
-        params.onConfig?.({ file: fileInfo.file, enabled: config2.enabled !== false });
-      }
-      continue;
+function sortRoutes(routes) {
+  return routes.sort((a, b) => {
+    if (a.method !== b.method) {
+      return a.method.localeCompare(b.method);
     }
-    const configParams = {
-      file: fileInfo.file,
-      rootDir: fileInfo.rootDir,
-      logger: params.logger,
-      configCache,
-      fileCache
-    };
-    if (params.server) {
-      configParams.server = params.server;
+    const scoreCompare = compareRouteScore(a.score, b.score);
+    if (scoreCompare !== 0) {
+      return scoreCompare;
     }
-    const config = await resolveDirectoryConfig(configParams);
-    if (config.enabled === false) {
-      if (shouldCollectSkip && isSupportedFile(fileInfo.file)) {
-        const resolved = resolveSkipRoute({
-          file: fileInfo.file,
-          rootDir: fileInfo.rootDir,
-          prefix: params.prefix
-        });
-        params.onSkip?.(buildSkipInfo(fileInfo.file, "disabled-dir", resolved));
-      }
+    return a.template.localeCompare(b.template);
+  });
+}
+
+async function walkDir(dir, rootDir, files) {
+  const entries = await promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === ".git") {
       continue;
     }
-    const effectiveIgnorePrefix = typeof config.ignorePrefix !== "undefined" ? normalizeIgnorePrefix(config.ignorePrefix, []) : globalIgnorePrefix;
-    if (hasIgnoredPrefix(fileInfo.file, fileInfo.rootDir, effectiveIgnorePrefix)) {
-      if (shouldCollectSkip && isSupportedFile(fileInfo.file)) {
-        const resolved = resolveSkipRoute({
-          file: fileInfo.file,
-          rootDir: fileInfo.rootDir,
-          prefix: params.prefix
-        });
-        params.onSkip?.(buildSkipInfo(fileInfo.file, "ignore-prefix", resolved));
-      }
-      continue;
-    }
-    if (!isSupportedFile(fileInfo.file)) {
-      if (shouldCollectIgnore) {
-        params.onIgnore?.({ file: fileInfo.file, reason: "unsupported" });
-      }
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkDir(fullPath, rootDir, files);
       continue;
     }
-    const effectiveInclude = typeof config.include !== "undefined" ? config.include : params.include;
-    const effectiveExclude = typeof config.exclude !== "undefined" ? config.exclude : params.exclude;
-    if (!matchesFilter(fileInfo.file, effectiveInclude, effectiveExclude)) {
-      if (shouldCollectSkip) {
-        const resolved = resolveSkipRoute({
-          file: fileInfo.file,
-          rootDir: fileInfo.rootDir,
-          prefix: params.prefix
-        });
-        const reason = effectiveExclude && matchesFilter(fileInfo.file, void 0, effectiveExclude) ? "exclude" : "include";
-        params.onSkip?.(buildSkipInfo(fileInfo.file, reason, resolved));
-      }
-      continue;
+    if (entry.isFile()) {
+      files.push({ file: fullPath, rootDir });
     }
-    const derived = deriveRouteFromFile(fileInfo.file, fileInfo.rootDir, params.logger);
-    if (!derived) {
-      if (shouldCollectIgnore) {
-        params.onIgnore?.({ file: fileInfo.file, reason: "invalid-route" });
-      }
+  }
+}
+async function exists(path) {
+  try {
+    await promises.stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function collectFiles(dirs) {
+  const files = [];
+  for (const dir of dirs) {
+    if (!await exists(dir)) {
       continue;
     }
-    const rules = await loadRules(fileInfo.file, params.server, params.logger);
-    for (const [index, rule] of rules.entries()) {
-      if (!rule || typeof rule !== "object") {
-        continue;
-      }
-      if (rule.enabled === false) {
-        if (shouldCollectSkip) {
-          const resolved2 = resolveSkipRoute({
-            file: fileInfo.file,
-            rootDir: fileInfo.rootDir,
-            prefix: params.prefix,
-            derived
-          });
-          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}`);
-      }
-      seen.add(key);
-      routes.push(resolved);
-    }
+    await walkDir(dir, dir, files);
   }
-  return sortRoutes(routes);
+  return files;
 }
-
-const defaultSwPath = "/mokup-sw.js";
-const defaultSwScope = "/";
-function normalizeSwPath(path) {
-  if (!path) {
-    return defaultSwPath;
+function isSupportedFile(file) {
+  if (file.endsWith(".d.ts")) {
+    return false;
   }
-  return path.startsWith("/") ? path : `/${path}`;
-}
-function normalizeSwScope(scope) {
-  if (!scope) {
-    return defaultSwScope;
+  if (isConfigFile(file)) {
+    return false;
   }
-  return scope.startsWith("/") ? scope : `/${scope}`;
+  const ext = extname(file).toLowerCase();
+  return supportedExtensions.has(ext);
 }
-function normalizeBasePath(value) {
-  if (!value) {
-    return "/";
+function isConfigFile(file) {
+  if (file.endsWith(".d.ts")) {
+    return false;
   }
-  const normalized = value.startsWith("/") ? value : `/${value}`;
-  if (normalized.length > 1 && normalized.endsWith("/")) {
-    return normalized.slice(0, -1);
+  const base = basename(file);
+  if (!base.startsWith("index.config.")) {
+    return false;
   }
-  return normalized;
+  const ext = extname(file).toLowerCase();
+  return configExtensions.includes(ext);
 }
-function resolveSwConfigFromEntries(entries, logger) {
-  let path = defaultSwPath;
-  let scope = defaultSwScope;
-  let register = true;
-  let unregister = false;
-  const basePaths = [];
-  let hasPath = false;
-  let hasScope = false;
-  let hasRegister = false;
-  let hasUnregister = false;
-  for (const entry of entries) {
-    const config = entry.sw;
-    if (config?.path) {
-      const next = normalizeSwPath(config.path);
-      if (!hasPath) {
-        path = next;
-        hasPath = true;
-      } else if (path !== next) {
-        logger.warn(`SW path "${next}" ignored; using "${path}".`);
-      }
-    }
-    if (config?.scope) {
-      const next = normalizeSwScope(config.scope);
-      if (!hasScope) {
-        scope = next;
-        hasScope = true;
-      } else if (scope !== next) {
-        logger.warn(`SW scope "${next}" ignored; using "${scope}".`);
-      }
-    }
-    if (typeof config?.register === "boolean") {
-      if (!hasRegister) {
-        register = config.register;
-        hasRegister = true;
-      } else if (register !== config.register) {
-        logger.warn(
-          `SW register="${String(config.register)}" ignored; using "${String(register)}".`
-        );
-      }
-    }
-    if (typeof config?.unregister === "boolean") {
-      if (!hasUnregister) {
-        unregister = config.unregister;
-        hasUnregister = true;
-      } else if (unregister !== config.unregister) {
-        logger.warn(
-          `SW unregister="${String(config.unregister)}" ignored; using "${String(unregister)}".`
-        );
+
+const sourceRoot = dirname(fileURLToPath(import.meta.url));
+const mokupSourceEntry = resolve(sourceRoot, "../index.ts");
+const mokupViteSourceEntry = resolve(sourceRoot, "../vite.ts");
+const hasMokupSourceEntry = existsSync(mokupSourceEntry);
+const hasMokupViteSourceEntry = existsSync(mokupViteSourceEntry);
+function createWorkspaceResolvePlugin() {
+  if (!hasMokupSourceEntry && !hasMokupViteSourceEntry) {
+    return null;
+  }
+  return {
+    name: "mokup:resolve-workspace",
+    setup(build) {
+      if (hasMokupSourceEntry) {
+        build.onResolve({ filter: /^mokup$/ }, () => ({ path: mokupSourceEntry }));
       }
-    }
-    if (typeof config?.basePath !== "undefined") {
-      const values = Array.isArray(config.basePath) ? config.basePath : [config.basePath];
-      for (const value of values) {
-        basePaths.push(normalizeBasePath(value));
+      if (hasMokupViteSourceEntry) {
+        build.onResolve({ filter: /^mokup\/vite$/ }, () => ({ path: mokupViteSourceEntry }));
       }
-      continue;
-    }
-    const normalizedPrefix = normalizePrefix(entry.prefix ?? "");
-    if (normalizedPrefix) {
-      basePaths.push(normalizedPrefix);
     }
-  }
-  return {
-    path,
-    scope,
-    register,
-    unregister,
-    basePaths: Array.from(new Set(basePaths))
   };
 }
-function resolveSwConfig(options, logger) {
-  const swEntries = options.filter((entry) => entry.mode === "sw");
-  if (swEntries.length === 0) {
-    return null;
-  }
-  return resolveSwConfigFromEntries(swEntries, logger);
-}
-function resolveSwUnregisterConfig(options, logger) {
-  return resolveSwConfigFromEntries(options, logger);
-}
-function toViteImportPath(file, root) {
-  const absolute = isAbsolute(file) ? file : resolve(root, file);
-  const rel = relative(root, absolute);
-  if (!rel.startsWith("..") && !isAbsolute(rel)) {
-    return `/${toPosix(rel)}`;
+const workspaceResolvePlugin = createWorkspaceResolvePlugin();
+async function loadModule(file) {
+  const ext = extname(file).toLowerCase();
+  if (ext === ".cjs") {
+    const require = createRequire(import.meta.url);
+    delete require.cache[file];
+    return require(file);
   }
-  return `/@fs/${toPosix(absolute)}`;
-}
-function shouldModuleize(handler) {
-  if (typeof handler === "function") {
-    return true;
+  if (ext === ".js" || ext === ".mjs") {
+    return import(`${pathToFileURL(file).href}?t=${Date.now()}`);
   }
-  if (typeof Response !== "undefined" && handler instanceof Response) {
-    return true;
+  if (ext === ".ts") {
+    const result = await build({
+      entryPoints: [file],
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      sourcemap: "inline",
+      target: "es2020",
+      write: false,
+      ...workspaceResolvePlugin ? { plugins: [workspaceResolvePlugin] } : {}
+    });
+    const output = result.outputFiles[0];
+    const code = output?.text ?? "";
+    const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString(
+      "base64"
+    )}`;
+    return import(`${dataUrl}#${Date.now()}`);
   }
-  return false;
+  return null;
 }
-function toBinaryBody(handler) {
-  if (handler instanceof ArrayBuffer) {
-    return Buffer.from(new Uint8Array(handler)).toString("base64");
-  }
-  if (handler instanceof Uint8Array) {
-    return Buffer.from(handler).toString("base64");
+async function loadModuleWithVite(server, file) {
+  const asDevServer = server;
+  if ("ssrLoadModule" in asDevServer) {
+    const moduleNode = asDevServer.moduleGraph.getModuleById(file);
+    if (moduleNode) {
+      asDevServer.moduleGraph.invalidateModule(moduleNode);
+    }
+    return asDevServer.ssrLoadModule(file);
+  }
+  return loadModule(file);
+}
+
+const middlewareSymbol = Symbol.for("mokup.config.middlewares");
+function getConfigFileCandidates(dir) {
+  return configExtensions.map((extension) => join(dir, `index.config${extension}`));
+}
+async function findConfigFile(dir, cache) {
+  const cached = cache.get(dir);
+  if (cached !== void 0) {
+    return cached;
   }
-  if (Buffer.isBuffer(handler)) {
-    return handler.toString("base64");
+  for (const candidate of getConfigFileCandidates(dir)) {
+    try {
+      await promises.stat(candidate);
+      cache.set(dir, candidate);
+      return candidate;
+    } catch {
+      continue;
+    }
   }
+  cache.set(dir, null);
   return null;
 }
-function buildManifestResponse(route, moduleId) {
-  if (moduleId) {
-    const response = {
-      type: "module",
-      module: moduleId
-    };
-    if (typeof route.ruleIndex === "number") {
-      response.ruleIndex = route.ruleIndex;
-    }
-    return response;
+async function loadConfig(file, server) {
+  const mod = server ? await loadModuleWithVite(server, file) : await loadModule(file);
+  if (!mod) {
+    return null;
   }
-  const handler = route.handler;
-  if (typeof handler === "string") {
-    return {
-      type: "text",
-      body: handler
-    };
+  const value = mod?.default ?? mod;
+  if (!value || typeof value !== "object") {
+    return null;
   }
-  const binary = toBinaryBody(handler);
-  if (binary) {
-    return {
-      type: "binary",
-      body: binary,
-      encoding: "base64"
-    };
+  return value;
+}
+function normalizeMiddlewares(value, source, logger, position) {
+  if (!value) {
+    return [];
+  }
+  const list = Array.isArray(value) ? value : [value];
+  const middlewares = [];
+  for (const [index, entry] of list.entries()) {
+    if (typeof entry !== "function") {
+      logger.warn(`Invalid middleware in ${source}`);
+      continue;
+    }
+    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 {
-    type: "json",
-    body: handler
+    pre: Array.isArray(meta.pre) ? meta.pre : [],
+    normal: Array.isArray(meta.normal) ? meta.normal : [],
+    post: Array.isArray(meta.post) ? meta.post : []
   };
 }
-function buildSwScript(params) {
-  const { routes, root } = params;
-  const runtimeImportPath = params.runtimeImportPath ?? "mokup/runtime";
-  const basePaths = params.basePaths ?? [];
-  const resolveModulePath = params.resolveModulePath ?? toViteImportPath;
-  const ruleModules = /* @__PURE__ */ new Map();
-  const middlewareModules = /* @__PURE__ */ new Map();
-  const manifestRoutes = routes.map((route) => {
-    const moduleId = shouldModuleize(route.handler) ? resolveModulePath(route.file, root) : null;
-    if (moduleId) {
-      ruleModules.set(moduleId, moduleId);
+async function resolveDirectoryConfig(params) {
+  const { file, rootDir, server, logger, configCache, fileCache } = params;
+  const resolvedRoot = normalize(rootDir);
+  const resolvedFileDir = normalize(dirname(file));
+  const chain = [];
+  let current = resolvedFileDir;
+  while (true) {
+    chain.push(current);
+    if (current === resolvedRoot) {
+      break;
     }
-    const middleware = route.middlewares?.map((entry) => {
-      const modulePath = resolveModulePath(entry.source, root);
-      middlewareModules.set(modulePath, modulePath);
-      return {
-        module: modulePath,
-        ruleIndex: entry.index
-      };
-    });
-    const response = buildManifestResponse(route, moduleId);
-    const manifestRoute = {
-      method: route.method,
-      url: route.template,
-      ...route.tokens ? { tokens: route.tokens } : {},
-      ...route.score ? { score: route.score } : {},
-      ...route.status ? { status: route.status } : {},
-      ...route.headers ? { headers: route.headers } : {},
-      ...route.delay ? { delay: route.delay } : {},
-      ...middleware && middleware.length > 0 ? { middleware } : {},
-      response
-    };
-    return manifestRoute;
-  });
-  const manifest = {
-    version: 1,
-    routes: manifestRoutes
-  };
-  const imports = [
-    `import { createRuntimeApp, handle } from ${JSON.stringify(runtimeImportPath)}`
-  ];
-  const moduleEntries = [];
-  let moduleIndex = 0;
-  for (const id of ruleModules.keys()) {
-    const name = `module${moduleIndex++}`;
-    imports.push(`import * as ${name} from '${id}'`);
-    moduleEntries.push({ id, name, kind: "rule" });
-  }
-  for (const id of middlewareModules.keys()) {
-    const name = `module${moduleIndex++}`;
-    imports.push(`import * as ${name} from '${id}'`);
-    moduleEntries.push({ id, name, kind: "middleware" });
+    const parent = dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
   }
-  const lines = [];
-  lines.push(...imports, "");
-  lines.push(
-    "const resolveModuleExport = (mod) => mod?.default ?? mod",
-    "",
-    "const toRuntimeRule = (value) => {",
-    "  if (typeof value === 'undefined') {",
-    "    return null",
-    "  }",
-    "  if (typeof value === 'function') {",
-    "    return { response: value }",
-    "  }",
-    "  if (value === null) {",
-    "    return { response: null }",
-    "  }",
-    "  if (typeof value === 'object') {",
-    "    if ('response' in value) {",
-    "      return value",
-    "    }",
-    "    if ('handler' in value) {",
-    "      const handlerRule = value",
-    "      return {",
-    "        response: handlerRule.handler,",
-    "        ...(typeof handlerRule.status === 'number' ? { status: handlerRule.status } : {}),",
-    "        ...(handlerRule.headers ? { headers: handlerRule.headers } : {}),",
-    "        ...(typeof handlerRule.delay === 'number' ? { delay: handlerRule.delay } : {}),",
-    "      }",
-    "    }",
-    "    return { response: value }",
-    "  }",
-    "  return { response: value }",
-    "}",
-    "",
-    "const toRuntimeRules = (value) => {",
-    "  if (typeof value === 'undefined') {",
-    "    return []",
-    "  }",
-    "  if (Array.isArray(value)) {",
-    "    return value.map(toRuntimeRule).filter(Boolean)",
-    "  }",
-    "  const rule = toRuntimeRule(value)",
-    "  return rule ? [rule] : []",
-    "}",
-    ""
-  );
-  lines.push(
-    `const manifest = ${JSON.stringify(manifest, null, 2)}`,
-    ""
-  );
-  if (moduleEntries.length > 0) {
-    lines.push("const moduleMap = {");
-    for (const entry of moduleEntries) {
-      if (entry.kind === "rule") {
-        lines.push(
-          `  ${JSON.stringify(entry.id)}: { default: toRuntimeRules(resolveModuleExport(${entry.name})) },`
-        );
-        continue;
-      }
-      lines.push(
-        `  ${JSON.stringify(entry.id)}: ${entry.name},`
-      );
+  chain.reverse();
+  const merged = {};
+  const preMiddlewares = [];
+  const normalMiddlewares = [];
+  const postMiddlewares = [];
+  const configChain = [];
+  const configSources = {};
+  for (const dir of chain) {
+    const configPath = await findConfigFile(dir, fileCache);
+    if (!configPath) {
+      continue;
+    }
+    let config = configCache.get(configPath);
+    if (config === void 0) {
+      config = await loadConfig(configPath, server);
+      configCache.set(configPath, config);
+    }
+    if (!config) {
+      logger.warn(`Invalid config in ${configPath}`);
+      continue;
+    }
+    configChain.push(configPath);
+    if (config.headers) {
+      merged.headers = { ...merged.headers ?? {}, ...config.headers };
+      configSources.headers = configPath;
+    }
+    if (typeof config.status === "number") {
+      merged.status = config.status;
+      configSources.status = configPath;
+    }
+    if (typeof config.delay === "number") {
+      merged.delay = config.delay;
+      configSources.delay = configPath;
+    }
+    if (typeof config.enabled === "boolean") {
+      merged.enabled = config.enabled;
+      configSources.enabled = configPath;
+    }
+    if (typeof config.ignorePrefix !== "undefined") {
+      merged.ignorePrefix = config.ignorePrefix;
+      configSources.ignorePrefix = configPath;
+    }
+    if (typeof config.include !== "undefined") {
+      merged.include = config.include;
+      configSources.include = configPath;
+    }
+    if (typeof config.exclude !== "undefined") {
+      merged.exclude = config.exclude;
+      configSources.exclude = configPath;
+    }
+    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);
     }
-    lines.push("}", "");
   }
-  const runtimeOptions = moduleEntries.length > 0 ? "{ manifest, moduleMap }" : "{ manifest }";
-  lines.push(
-    `const basePaths = ${JSON.stringify(basePaths)}`,
-    "",
-    "self.addEventListener('install', () => {",
-    "  self.skipWaiting()",
-    "})",
-    "",
-    "self.addEventListener('activate', (event) => {",
-    "  event.waitUntil(self.clients.claim())",
-    "})",
-    "",
-    "const shouldHandle = (request) => {",
-    "  if (!basePaths || basePaths.length === 0) {",
-    "    return true",
-    "  }",
-    "  const pathname = new URL(request.url).pathname",
-    "  return basePaths.some((basePath) => {",
-    "    if (basePath === '/') {",
-    "      return true",
-    "    }",
-    "    return pathname === basePath || pathname.startsWith(basePath + '/')",
-    "  })",
-    "}",
-    "",
-    "const registerHandler = async () => {",
-    `  const app = await createRuntimeApp(${runtimeOptions})`,
-    "  const handler = handle(app)",
-    "  self.addEventListener('fetch', (event) => {",
-    "    if (!shouldHandle(event.request)) {",
-    "      return",
-    "    }",
-    "    handler(event)",
-    "  })",
-    "}",
-    "",
-    "registerHandler().catch((error) => {",
-    "  console.error('[mokup] Failed to build service worker app:', error)",
-    "})",
-    ""
-  );
-  return lines.join("\n");
+  return {
+    ...merged,
+    middlewares: [...preMiddlewares, ...normalMiddlewares, ...postMiddlewares],
+    configChain,
+    configSources
+  };
+}
+
+async function readJsonFile(file, logger) {
+  try {
+    const content = await promises.readFile(file, "utf8");
+    const errors = [];
+    const data = parse(content, errors, {
+      allowTrailingComma: true,
+      disallowComments: false
+    });
+    if (errors.length > 0) {
+      logger.warn(`Invalid JSONC in ${file}`);
+      return void 0;
+    }
+    return data;
+  } catch (error) {
+    logger.warn(`Failed to read ${file}: ${String(error)}`);
+    return void 0;
+  }
+}
+async function loadRules(file, server, logger) {
+  const ext = extname(file).toLowerCase();
+  if (ext === ".json" || ext === ".jsonc") {
+    const json = await readJsonFile(file, logger);
+    if (typeof json === "undefined") {
+      return [];
+    }
+    return [
+      {
+        handler: json
+      }
+    ];
+  }
+  const mod = server ? await loadModuleWithVite(server, file) : await loadModule(file);
+  const value = mod?.default ?? mod;
+  if (!value) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value === "function") {
+    return [
+      {
+        handler: value
+      }
+    ];
+  }
+  return [value];
+}
+
+const silentLogger = {
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  },
+  log: () => {
+  }
+};
+function resolveSkipRoute(params) {
+  const derived = params.derived ?? deriveRouteFromFile(params.file, params.rootDir, silentLogger);
+  if (!derived?.method) {
+    return null;
+  }
+  const resolved = resolveRule({
+    rule: { handler: null },
+    derivedTemplate: derived.template,
+    derivedMethod: derived.method,
+    prefix: params.prefix,
+    file: params.file,
+    logger: silentLogger
+  });
+  if (!resolved) {
+    return null;
+  }
+  return {
+    method: resolved.method,
+    url: resolved.template
+  };
+}
+function buildSkipInfo(file, reason, resolved, configChain, decisionChain, effectiveConfig) {
+  const info = { file, reason };
+  if (resolved) {
+    info.method = resolved.method;
+    info.url = resolved.url;
+  }
+  if (configChain && configChain.length > 0) {
+    info.configChain = configChain;
+  }
+  if (decisionChain && decisionChain.length > 0) {
+    info.decisionChain = decisionChain;
+  }
+  if (effectiveConfig && Object.keys(effectiveConfig).length > 0) {
+    info.effectiveConfig = effectiveConfig;
+  }
+  return info;
+}
+function toFilterStrings(value) {
+  if (!value) {
+    return [];
+  }
+  const list = Array.isArray(value) ? value : [value];
+  return list.filter((entry) => entry instanceof RegExp).map((entry) => entry.toString());
+}
+function toStringList(value) {
+  return value.length === 1 ? value[0] : [...value];
+}
+function formatList(value) {
+  return value.join(", ");
+}
+function testPatterns(patterns, value) {
+  const list = Array.isArray(patterns) ? patterns : [patterns];
+  return list.some((pattern) => pattern.test(value));
+}
+function buildEffectiveConfig(params) {
+  const { config, effectiveInclude, effectiveExclude, effectiveIgnorePrefix } = params;
+  const includeList = toFilterStrings(effectiveInclude);
+  const excludeList = toFilterStrings(effectiveExclude);
+  const effectiveConfig = {};
+  if (config.headers && Object.keys(config.headers).length > 0) {
+    effectiveConfig.headers = config.headers;
+  }
+  if (typeof config.status === "number") {
+    effectiveConfig.status = config.status;
+  }
+  if (typeof config.delay === "number") {
+    effectiveConfig.delay = config.delay;
+  }
+  if (typeof config.enabled !== "undefined") {
+    effectiveConfig.enabled = config.enabled;
+  }
+  if (effectiveIgnorePrefix.length > 0) {
+    effectiveConfig.ignorePrefix = toStringList(effectiveIgnorePrefix);
+  }
+  if (includeList.length > 0) {
+    effectiveConfig.include = toStringList(includeList);
+  }
+  if (excludeList.length > 0) {
+    effectiveConfig.exclude = toStringList(excludeList);
+  }
+  return effectiveConfig;
+}
+
+function pushDecisionStep(chain, entry) {
+  const step = {
+    step: entry.step,
+    result: entry.result
+  };
+  if (typeof entry.source !== "undefined") {
+    step.source = entry.source;
+  }
+  if (typeof entry.detail !== "undefined") {
+    step.detail = entry.detail;
+  }
+  chain.push(step);
+}
+function runRoutePrechecks(params) {
+  const {
+    fileInfo,
+    prefix,
+    config,
+    configChain,
+    globalIgnorePrefix,
+    include,
+    exclude,
+    shouldCollectSkip,
+    shouldCollectIgnore,
+    onSkip,
+    onIgnore
+  } = params;
+  const configSources = config.configSources ?? {};
+  const decisionChain = [];
+  const isConfigEnabled = config.enabled !== false;
+  pushDecisionStep(decisionChain, {
+    step: "config.enabled",
+    result: isConfigEnabled ? "pass" : "fail",
+    source: configSources.enabled,
+    detail: config.enabled === false ? "enabled=false" : typeof config.enabled === "boolean" ? "enabled=true" : "enabled=true (default)"
+  });
+  const effectiveIgnorePrefix = typeof config.ignorePrefix !== "undefined" ? normalizeIgnorePrefix(config.ignorePrefix, []) : globalIgnorePrefix;
+  const effectiveInclude = typeof config.include !== "undefined" ? config.include : include;
+  const effectiveExclude = typeof config.exclude !== "undefined" ? config.exclude : exclude;
+  const effectiveConfigParams = {
+    config,
+    effectiveIgnorePrefix
+  };
+  if (typeof effectiveInclude !== "undefined") {
+    effectiveConfigParams.effectiveInclude = effectiveInclude;
+  }
+  if (typeof effectiveExclude !== "undefined") {
+    effectiveConfigParams.effectiveExclude = effectiveExclude;
+  }
+  const effectiveConfig = buildEffectiveConfig(effectiveConfigParams);
+  const effectiveConfigValue = Object.keys(effectiveConfig).length > 0 ? effectiveConfig : void 0;
+  if (!isConfigEnabled) {
+    if (shouldCollectSkip && isSupportedFile(fileInfo.file)) {
+      const resolved = resolveSkipRoute({
+        file: fileInfo.file,
+        rootDir: fileInfo.rootDir,
+        prefix
+      });
+      onSkip?.(buildSkipInfo(
+        fileInfo.file,
+        "disabled-dir",
+        resolved,
+        configChain,
+        decisionChain,
+        effectiveConfigValue
+      ));
+    }
+    return null;
+  }
+  if (effectiveIgnorePrefix.length > 0) {
+    const ignoredByPrefix = hasIgnoredPrefix(fileInfo.file, fileInfo.rootDir, effectiveIgnorePrefix);
+    pushDecisionStep(decisionChain, {
+      step: "ignore-prefix",
+      result: ignoredByPrefix ? "fail" : "pass",
+      source: configSources.ignorePrefix,
+      detail: `prefixes: ${formatList(effectiveIgnorePrefix)}`
+    });
+    if (ignoredByPrefix) {
+      if (shouldCollectSkip && isSupportedFile(fileInfo.file)) {
+        const resolved = resolveSkipRoute({
+          file: fileInfo.file,
+          rootDir: fileInfo.rootDir,
+          prefix
+        });
+        onSkip?.(buildSkipInfo(
+          fileInfo.file,
+          "ignore-prefix",
+          resolved,
+          configChain,
+          decisionChain,
+          effectiveConfigValue
+        ));
+      }
+      return null;
+    }
+  }
+  const supportedFile = isSupportedFile(fileInfo.file);
+  pushDecisionStep(decisionChain, {
+    step: "file.supported",
+    result: supportedFile ? "pass" : "fail",
+    detail: supportedFile ? void 0 : "unsupported file type"
+  });
+  if (!supportedFile) {
+    if (shouldCollectIgnore) {
+      const ignoreInfo = {
+        file: fileInfo.file,
+        reason: "unsupported",
+        configChain,
+        decisionChain
+      };
+      if (effectiveConfigValue) {
+        ignoreInfo.effectiveConfig = effectiveConfigValue;
+      }
+      onIgnore?.(ignoreInfo);
+    }
+    return null;
+  }
+  const normalizedFile = toPosix(fileInfo.file);
+  if (typeof effectiveExclude !== "undefined") {
+    const excluded = testPatterns(effectiveExclude, normalizedFile);
+    const patterns = toFilterStrings(effectiveExclude);
+    pushDecisionStep(decisionChain, {
+      step: "filter.exclude",
+      result: excluded ? "fail" : "pass",
+      source: configSources.exclude,
+      detail: patterns.length > 0 ? `${excluded ? "matched" : "no match"}: ${patterns.join(", ")}` : void 0
+    });
+    if (excluded) {
+      if (shouldCollectSkip) {
+        const resolved = resolveSkipRoute({
+          file: fileInfo.file,
+          rootDir: fileInfo.rootDir,
+          prefix
+        });
+        onSkip?.(buildSkipInfo(
+          fileInfo.file,
+          "exclude",
+          resolved,
+          configChain,
+          decisionChain,
+          effectiveConfigValue
+        ));
+      }
+      return null;
+    }
+  }
+  if (typeof effectiveInclude !== "undefined") {
+    const included = testPatterns(effectiveInclude, normalizedFile);
+    const patterns = toFilterStrings(effectiveInclude);
+    pushDecisionStep(decisionChain, {
+      step: "filter.include",
+      result: included ? "pass" : "fail",
+      source: configSources.include,
+      detail: patterns.length > 0 ? `${included ? "matched" : "no match"}: ${patterns.join(", ")}` : void 0
+    });
+    if (!included) {
+      if (shouldCollectSkip) {
+        const resolved = resolveSkipRoute({
+          file: fileInfo.file,
+          rootDir: fileInfo.rootDir,
+          prefix
+        });
+        onSkip?.(buildSkipInfo(
+          fileInfo.file,
+          "include",
+          resolved,
+          configChain,
+          decisionChain,
+          effectiveConfigValue
+        ));
+      }
+      return null;
+    }
+  }
+  const result = { decisionChain };
+  if (effectiveConfigValue) {
+    result.effectiveConfigValue = effectiveConfigValue;
+  }
+  return result;
+}
+
+async function scanRoutes(params) {
+  const routes = [];
+  const seen = /* @__PURE__ */ new Set();
+  const files = await collectFiles(params.dirs);
+  const globalIgnorePrefix = normalizeIgnorePrefix(params.ignorePrefix);
+  const configCache = /* @__PURE__ */ new Map();
+  const fileCache = /* @__PURE__ */ new Map();
+  const shouldCollectSkip = typeof params.onSkip === "function";
+  const shouldCollectIgnore = typeof params.onIgnore === "function";
+  const shouldCollectConfig = typeof params.onConfig === "function";
+  for (const fileInfo of files) {
+    if (isConfigFile(fileInfo.file)) {
+      if (shouldCollectConfig) {
+        const configParams2 = {
+          file: fileInfo.file,
+          rootDir: fileInfo.rootDir,
+          logger: params.logger,
+          configCache,
+          fileCache
+        };
+        if (params.server) {
+          configParams2.server = params.server;
+        }
+        const config2 = await resolveDirectoryConfig(configParams2);
+        params.onConfig?.({ file: fileInfo.file, enabled: config2.enabled !== false });
+      }
+      continue;
+    }
+    const configParams = {
+      file: fileInfo.file,
+      rootDir: fileInfo.rootDir,
+      logger: params.logger,
+      configCache,
+      fileCache
+    };
+    if (params.server) {
+      configParams.server = params.server;
+    }
+    const config = await resolveDirectoryConfig(configParams);
+    const configChain = config.configChain ?? [];
+    const precheckParams = {
+      fileInfo,
+      prefix: params.prefix,
+      config,
+      configChain,
+      globalIgnorePrefix,
+      shouldCollectSkip,
+      shouldCollectIgnore
+    };
+    if (params.onSkip) {
+      precheckParams.onSkip = params.onSkip;
+    }
+    if (params.onIgnore) {
+      precheckParams.onIgnore = params.onIgnore;
+    }
+    if (params.include) {
+      precheckParams.include = params.include;
+    }
+    if (params.exclude) {
+      precheckParams.exclude = params.exclude;
+    }
+    const precheck = runRoutePrechecks(precheckParams);
+    if (!precheck) {
+      continue;
+    }
+    const { decisionChain, effectiveConfigValue } = precheck;
+    const derived = deriveRouteFromFile(fileInfo.file, fileInfo.rootDir, params.logger);
+    if (!derived) {
+      if (shouldCollectIgnore) {
+        decisionChain.push({
+          step: "route.derived",
+          result: "fail",
+          source: fileInfo.file,
+          detail: "invalid route name"
+        });
+        const ignoreInfo = {
+          file: fileInfo.file,
+          reason: "invalid-route",
+          configChain,
+          decisionChain
+        };
+        if (effectiveConfigValue) {
+          ignoreInfo.effectiveConfig = effectiveConfigValue;
+        }
+        params.onIgnore?.(ignoreInfo);
+      }
+      continue;
+    }
+    decisionChain.push({
+      step: "route.derived",
+      result: "pass",
+      source: fileInfo.file
+    });
+    const rules = await loadRules(fileInfo.file, params.server, params.logger);
+    for (const [index, rule] of rules.entries()) {
+      if (!rule || typeof rule !== "object") {
+        continue;
+      }
+      if (rule.enabled === false) {
+        if (shouldCollectSkip) {
+          const resolved2 = resolveSkipRoute({
+            file: fileInfo.file,
+            rootDir: fileInfo.rootDir,
+            prefix: params.prefix,
+            derived
+          });
+          const ruleDecisionStep = {
+            step: "rule.enabled",
+            result: "fail",
+            source: fileInfo.file,
+            detail: "enabled=false"
+          };
+          const ruleDecisionChain = [...decisionChain, ruleDecisionStep];
+          params.onSkip?.(buildSkipInfo(
+            fileInfo.file,
+            "disabled",
+            resolved2,
+            configChain,
+            ruleDecisionChain,
+            effectiveConfigValue
+          ));
+        }
+        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 (configChain.length > 0) {
+        resolved.configChain = configChain;
+      }
+      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);
 }
 
-export { resolveSwConfig as a, resolveSwUnregisterConfig as b, createPlaygroundMiddleware as c, buildSwScript as d, createLogger as e, createMiddleware as f, createDebouncer as g, resolveDirs as h, isInDirs as i, sortRoutes as j, createHonoApp as k, resolvePlaygroundOptions as r, scanRoutes as s, toPosix as t };
+export { sortRoutes as a, buildSwScript as b, createHonoApp as c, createDebouncer as d, resolvePlaygroundOptions as e, resolveSwConfig as f, resolveSwUnregisterConfig as g, createPlaygroundMiddleware as h, isInDirs as i, createMiddleware as j, buildManifestData as k, resolveDirs as r, scanRoutes as s, toPosix as t };