mokup 2.0.2 → 2.1.1

package/dist/shared/{mokup.B-yfMz5B.cjs → mokup.To7knvSq.cjs}

@@ -1,37 +1,17 @@
 'use strict';
 
-const node_buffer = require('node:buffer');
-const hono = require('@mokup/shared/hono');
 const node_fs = require('node:fs');
+const pathe = require('@mokup/shared/pathe');
 const node_module = require('node:module');
 const process = require('node:process');
-const pathe = require('@mokup/shared/pathe');
+const node_buffer = require('node:buffer');
+const hono = require('@mokup/shared/hono');
 const node_url = require('node:url');
 const esbuild = require('@mokup/shared/esbuild');
 const jsoncParser = require('@mokup/shared/jsonc-parser');
 const runtime = require('@mokup/runtime');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-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",
@@ -101,20 +81,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);
@@ -133,225 +99,191 @@ 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 = pathe.isAbsolute(file) ? file : pathe.resolve(root, file);
+  const rel = pathe.relative(root, absolute);
+  if (!rel.startsWith("..") && !pathe.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.Hono({ router: new hono.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(node_buffer.Buffer.from(chunk));
-        return;
-      }
-      if (chunk instanceof Uint8Array) {
-        chunks.push(chunk);
-        return;
-      }
-      chunks.push(node_buffer.Buffer.from(String(chunk)));
-    });
-    req.on("end", () => {
-      if (chunks.length === 0) {
-        resolve(null);
-        return;
-      }
-      resolve(node_buffer.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 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/mokup.B-yfMz5B.cjs', document.baseURI).href)));
+const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/mokup.To7knvSq.cjs', document.baseURI).href)));
 const mimeTypes = {
   ".html": "text/html; charset=utf-8",
   ".css": "text/css; charset=utf-8",
@@ -364,96 +296,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 pathe.join(pkgPath, "..", "dist");
@@ -468,6 +310,7 @@ function sendFile(res, content, contentType) {
   res.setHeader("Content-Type", contentType);
   res.end(content);
 }
+
 function toPosixPath(value) {
   return value.replace(/\\/g, "/");
 }
@@ -509,41 +352,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(pathe.relative(root, file));
-  if (!rel || rel.startsWith("..")) {
-    return toPosixPath(file);
-  }
-  return rel;
-}
 function resolveGroups(dirs, root) {
   const groups = [];
   const seen = /* @__PURE__ */ new Set();
@@ -578,63 +386,204 @@ 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(pathe.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 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 && pathe.isAbsolute(source) ? formatRouteFile(source, root) : source;
+    }
+    return formatted;
+  });
+}
+
 function createPlaygroundMiddleware(params) {
   const distDir = resolvePlaygroundDist();
   const playgroundPath = params.config.path;
@@ -718,938 +667,1400 @@ 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(pathe.relative(rootDir, file));
-  const ext = pathe.extname(rel);
-  const withoutExt = rel.slice(0, rel.length - ext.length);
-  const dir = pathe.dirname(withoutExt);
-  const base = pathe.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 : pathe.join(dir, name);
-  const segments = toPosix(joined).split("/");
-  if (segments.at(-1) === "index") {
-    segments.pop();
-  }
-  const template = segments.length === 0 ? "/" : `/${segments.join("/")}`;
-  const parsed = runtime.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 = runtime.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 = runtime.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$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/mokup.B-yfMz5B.cjs', document.baseURI).href)));
-    delete require$1.cache[file];
-    return require$1(file);
-  }
-  if (ext === ".js" || ext === ".mjs") {
-    return import(`${node_url.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 esbuild.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,${node_buffer.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) => pathe.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 node_fs.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 = pathe.normalize(rootDir);
-  const resolvedFileDir = pathe.normalize(pathe.dirname(file));
-  const chain = [];
-  let current = resolvedFileDir;
-  while (true) {
-    chain.push(current);
-    if (current === resolvedRoot) {
-      break;
-    }
-    const parent = pathe.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 node_fs.promises.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.name === "node_modules" || entry.name === ".git") {
-      continue;
-    }
-    const fullPath = pathe.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 node_fs.promises.stat(path);
-    return true;
-  } catch {
-    return false;
+function createHonoApp(routes) {
+  const app = new hono.Hono({ router: new hono.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(node_buffer.Buffer.from(chunk));
+        return;
+      }
+      if (chunk instanceof Uint8Array) {
+        chunks.push(chunk);
+        return;
+      }
+      chunks.push(node_buffer.Buffer.from(String(chunk)));
+    });
+    req.on("end", () => {
+      if (chunks.length === 0) {
+        resolve(null);
+        return;
+      }
+      resolve(node_buffer.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 = pathe.extname(file).toLowerCase();
-  return supportedExtensions.has(ext);
+  return result;
 }
-function isConfigFile(file) {
-  if (file.endsWith(".d.ts")) {
-    return false;
-  }
-  const base = pathe.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 = pathe.extname(file).toLowerCase();
-  return configExtensions.includes(ext);
+  return new Request(url.toString(), init);
 }
-
-async function loadModule(file) {
-  const ext = pathe.extname(file).toLowerCase();
-  if (ext === ".cjs") {
-    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/mokup.B-yfMz5B.cjs', document.baseURI).href)));
-    delete require$1.cache[file];
-    return require$1(file);
-  }
-  if (ext === ".js" || ext === ".mjs") {
-    return import(`${node_url.pathToFileURL(file).href}?t=${Date.now()}`);
-  }
-  if (ext === ".ts") {
-    const result = await esbuild.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,${node_buffer.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 node_fs.promises.readFile(file, "utf8");
-    const errors = [];
-    const data = jsoncParser.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 = pathe.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(pathe.relative(rootDir, file));
+  const ext = pathe.extname(rel);
+  const withoutExt = rel.slice(0, rel.length - ext.length);
+  const dir = pathe.dirname(withoutExt);
+  const base = pathe.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 : pathe.join(dir, name);
+  const segments = toPosix(joined).split("/");
+  if (segments.at(-1) === "index") {
+    segments.pop();
+  }
+  const template = segments.length === 0 ? "/" : `/${segments.join("/")}`;
+  const parsed = runtime.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 = runtime.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 = runtime.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 node_fs.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 = pathe.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 node_fs.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 = pathe.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 = pathe.basename(file);
+  if (!base.startsWith("index.config.")) {
+    return false;
   }
-  return normalized;
+  const ext = pathe.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 = pathe.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/mokup.To7knvSq.cjs', document.baseURI).href))));
+const mokupSourceEntry = pathe.resolve(sourceRoot, "../index.ts");
+const mokupViteSourceEntry = pathe.resolve(sourceRoot, "../vite.ts");
+const hasMokupSourceEntry = node_fs.existsSync(mokupSourceEntry);
+const hasMokupViteSourceEntry = node_fs.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 = pathe.isAbsolute(file) ? file : pathe.resolve(root, file);
-  const rel = pathe.relative(root, absolute);
-  if (!rel.startsWith("..") && !pathe.isAbsolute(rel)) {
-    return `/${toPosix(rel)}`;
+const workspaceResolvePlugin = createWorkspaceResolvePlugin();
+async function loadModule(file) {
+  const ext = pathe.extname(file).toLowerCase();
+  if (ext === ".cjs") {
+    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/mokup.To7knvSq.cjs', document.baseURI).href)));
+    delete require$1.cache[file];
+    return require$1(file);
   }
-  return `/@fs/${toPosix(absolute)}`;
-}
-function shouldModuleize(handler) {
-  if (typeof handler === "function") {
-    return true;
+  if (ext === ".js" || ext === ".mjs") {
+    return import(`${node_url.pathToFileURL(file).href}?t=${Date.now()}`);
   }
-  if (typeof Response !== "undefined" && handler instanceof Response) {
-    return true;
+  if (ext === ".ts") {
+    const result = await esbuild.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,${node_buffer.Buffer.from(code).toString(
+      "base64"
+    )}`;
+    return import(`${dataUrl}#${Date.now()}`);
   }
-  return false;
+  return null;
 }
-function toBinaryBody(handler) {
-  if (handler instanceof ArrayBuffer) {
-    return node_buffer.Buffer.from(new Uint8Array(handler)).toString("base64");
-  }
-  if (handler instanceof Uint8Array) {
-    return node_buffer.Buffer.from(handler).toString("base64");
-  }
-  if (node_buffer.Buffer.isBuffer(handler)) {
-    return 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 null;
+  return loadModule(file);
 }
-function buildManifestResponse(route, moduleId) {
-  if (moduleId) {
-    const response = {
-      type: "module",
-      module: moduleId
-    };
-    if (typeof route.ruleIndex === "number") {
-      response.ruleIndex = route.ruleIndex;
+
+const middlewareSymbol = Symbol.for("mokup.config.middlewares");
+function getConfigFileCandidates(dir) {
+  return configExtensions.map((extension) => pathe.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 node_fs.promises.stat(candidate);
+      cache.set(dir, candidate);
+      return candidate;
+    } catch {
+      continue;
     }
-    return response;
   }
-  const handler = route.handler;
-  if (typeof handler === "string") {
-    return {
-      type: "text",
-      body: handler
-    };
+  cache.set(dir, null);
+  return null;
+}
+async function loadConfig(file, server) {
+  const mod = server ? await loadModuleWithVite(server, file) : await loadModule(file);
+  if (!mod) {
+    return null;
   }
-  const binary = toBinaryBody(handler);
-  if (binary) {
-    return {
-      type: "binary",
-      body: binary,
-      encoding: "base64"
-    };
+  const value = mod?.default ?? mod;
+  if (!value || typeof value !== "object") {
+    return null;
   }
-  return {
-    type: "json",
-    body: handler
-  };
+  return value;
 }
-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);
+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;
     }
-    const middleware = route.middlewares?.map((entry) => {
-      const modulePath = resolveModulePath(entry.source, root);
-      middlewareModules.set(modulePath, modulePath);
-      return {
-        module: modulePath,
-        ruleIndex: entry.index
-      };
+    middlewares.push({
+      handle: entry,
+      source,
+      index,
+      position
     });
-    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" });
+  return middlewares;
+}
+function readMiddlewareMeta(config) {
+  const value = config[middlewareSymbol];
+  if (!value || typeof value !== "object") {
+    return null;
   }
-  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},`
-      );
+  const meta = value;
+  return {
+    pre: Array.isArray(meta.pre) ? meta.pre : [],
+    normal: Array.isArray(meta.normal) ? meta.normal : [],
+    post: Array.isArray(meta.post) ? meta.post : []
+  };
+}
+async function resolveDirectoryConfig(params) {
+  const { file, rootDir, server, logger, configCache, fileCache } = params;
+  const resolvedRoot = pathe.normalize(rootDir);
+  const resolvedFileDir = pathe.normalize(pathe.dirname(file));
+  const chain = [];
+  let current = resolvedFileDir;
+  while (true) {
+    chain.push(current);
+    if (current === resolvedRoot) {
+      break;
     }
-    lines.push("}", "");
+    const parent = pathe.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
   }
-  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");
+  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);
+    }
+  }
+  return {
+    ...merged,
+    middlewares: [...preMiddlewares, ...normalMiddlewares, ...postMiddlewares],
+    configChain,
+    configSources
+  };
+}
+
+async function readJsonFile(file, logger) {
+  try {
+    const content = await node_fs.promises.readFile(file, "utf8");
+    const errors = [];
+    const data = jsoncParser.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 = pathe.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);
 }
 
+exports.buildManifestData = buildManifestData;
 exports.buildSwScript = buildSwScript;
 exports.createDebouncer = createDebouncer;
 exports.createHonoApp = createHonoApp;
-exports.createLogger = createLogger;
 exports.createMiddleware = createMiddleware;
 exports.createPlaygroundMiddleware = createPlaygroundMiddleware;
 exports.isInDirs = isInDirs;