mokup 2.3.0 → 2.3.2

package/dist/shared/mokup.C-hwskJ_.mjs

@@ -1,1790 +0,0 @@
-import { promises, existsSync } from 'node:fs';
-import { resolve, isAbsolute, join, normalize, extname, relative, dirname, basename } from '@mokup/shared/pathe';
-import { createRequire } from 'node:module';
-import { resolveRouteGroup, formatRouteFile, resolveGroupRoot, resolveGroups } from '@mokup/shared/playground-grouping';
-import { m as methodSet, t as toViteImportPath, b as buildManifestData, a as methodSuffixSet, c as configExtensions, s as supportedExtensions } from './mokup.Iqw32OxC.mjs';
-import { Buffer } from 'node:buffer';
-import { Hono, PatternRouter } from '@mokup/shared/hono';
-import { delay } from '@mokup/shared/timing';
-import { toPosix, hasIgnoredPrefix } from '@mokup/shared/path-utils';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { build } from '@mokup/shared/esbuild';
-import { parse } from '@mokup/shared/jsonc-parser';
-import { compareRouteScore, parseRouteTemplate } from '@mokup/runtime';
-
-function normalizeMethod(method) {
-  if (!method) {
-    return void 0;
-  }
-  const normalized = method.toUpperCase();
-  if (methodSet.has(normalized)) {
-    return normalized;
-  }
-  return void 0;
-}
-function normalizePrefix(prefix) {
-  if (!prefix) {
-    return "";
-  }
-  const normalized = prefix.startsWith("/") ? prefix : `/${prefix}`;
-  return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
-}
-function resolveDirs(dir, root) {
-  const raw = typeof dir === "function" ? dir(root) : dir;
-  const resolved = Array.isArray(raw) ? raw : raw ? [raw] : ["mock"];
-  const normalized = resolved.map(
-    (entry) => isAbsolute(entry) ? entry : resolve(root, entry)
-  );
-  return Array.from(new Set(normalized));
-}
-function normalizeIgnorePrefix(value, fallback = ["."]) {
-  const list = typeof value === "undefined" ? fallback : Array.isArray(value) ? value : [value];
-  return list.filter((entry) => typeof entry === "string" && entry.length > 0);
-}
-
-const require$1 = createRequire(import.meta.url);
-const mimeTypes = {
-  ".html": "text/html; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".js": "text/javascript; charset=utf-8",
-  ".map": "application/json; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".ico": "image/x-icon"
-};
-function resolvePlaygroundDist() {
-  const pkgPath = require$1.resolve("@mokup/playground/package.json");
-  return join(pkgPath, "..", "dist");
-}
-function sendJson(res, data, statusCode = 200) {
-  res.statusCode = statusCode;
-  res.setHeader("Content-Type", "application/json; charset=utf-8");
-  res.end(JSON.stringify(data, null, 2));
-}
-function sendFile(res, content, contentType) {
-  res.statusCode = 200;
-  res.setHeader("Content-Type", contentType);
-  res.end(content);
-}
-
-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 resolvePlaygroundOptions(playground) {
-  if (playground === false) {
-    return { enabled: false, path: "/__mokup", build: false };
-  }
-  if (playground && typeof playground === "object") {
-    return {
-      enabled: playground.enabled !== false,
-      path: normalizePlaygroundPath(playground.path),
-      build: playground.build === true
-    };
-  }
-  return { enabled: true, path: "/__mokup", build: false };
-}
-
-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()",
-    "      if (typeof api.notifyHotReload === 'function') {",
-    "        api.notifyHotReload()",
-    "      }",
-    "      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;
-}
-
-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 formatDecisionChain(chain, root) {
-  return chain.map((entry) => {
-    const formatted = {
-      step: entry.step,
-      result: entry.result
-    };
-    if (typeof entry.detail !== "undefined") {
-      formatted.detail = entry.detail;
-    }
-    if (typeof entry.source !== "undefined") {
-      const source = entry.source;
-      formatted.source = source && isAbsolute(source) ? formatRouteFile(source, root) : source;
-    }
-    return formatted;
-  });
-}
-function 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 createPlaygroundMiddleware(params) {
-  const distDir = resolvePlaygroundDist();
-  const playgroundPath = params.config.path;
-  const indexPath = join(distDir, "index.html");
-  return async (req, res, next) => {
-    if (!params.config.enabled) {
-      return next();
-    }
-    const server = params.getServer?.();
-    const requestPath = resolvePlaygroundRequestPath(server?.config?.base ?? "/", playgroundPath);
-    const requestUrl = req.url ?? "/";
-    const url = new URL(requestUrl, "http://mokup.local");
-    const pathname = url.pathname;
-    const matchedPath = pathname.startsWith(requestPath) ? requestPath : pathname.startsWith(playgroundPath) ? playgroundPath : null;
-    if (!matchedPath) {
-      return next();
-    }
-    const subPath = pathname.slice(matchedPath.length);
-    if (subPath === "") {
-      const suffix = url.search ?? "";
-      res.statusCode = 302;
-      res.setHeader("Location", `${matchedPath}/${suffix}`);
-      res.end();
-      return;
-    }
-    if (subPath === "" || subPath === "/" || subPath === "/index.html") {
-      try {
-        const html = await promises.readFile(indexPath, "utf8");
-        let output = html;
-        if (isViteDevServer(server)) {
-          output = injectPlaygroundHmr(output, server.config.base ?? "/");
-          output = injectPlaygroundSw(output, params.getSwScript?.());
-        }
-        const contentType = mimeTypes[".html"] ?? "text/html; charset=utf-8";
-        sendFile(res, output, contentType);
-      } catch (error) {
-        params.logger.error("Failed to load playground index:", error);
-        res.statusCode = 500;
-        res.end("Playground is not available.");
-      }
-      return;
-    }
-    if (subPath === "/routes") {
-      const dirs = params.getDirs?.() ?? [];
-      const baseRoot = resolveGroupRoot(dirs, server?.config?.root);
-      const groups = resolveGroups(dirs, baseRoot);
-      const routes = params.getRoutes();
-      const disabledRoutes = params.getDisabledRoutes?.() ?? [];
-      const ignoredRoutes = params.getIgnoredRoutes?.() ?? [];
-      const configFiles = params.getConfigFiles?.() ?? [];
-      const disabledConfigFiles = params.getDisabledConfigFiles?.() ?? [];
-      sendJson(res, {
-        basePath: matchedPath,
-        root: baseRoot,
-        count: routes.length,
-        groups: groups.map((group) => ({ key: group.key, label: group.label })),
-        routes: routes.map((route) => toPlaygroundRoute(route, baseRoot, groups)),
-        disabled: disabledRoutes.map((route) => toPlaygroundDisabledRoute(route, baseRoot, groups)),
-        ignored: ignoredRoutes.map((route) => toPlaygroundIgnoredRoute(route, baseRoot, groups)),
-        configs: configFiles.map((entry) => toPlaygroundConfigFile(entry, baseRoot, groups)),
-        disabledConfigs: disabledConfigFiles.map((entry) => toPlaygroundConfigFile(entry, baseRoot, groups))
-      });
-      return;
-    }
-    const relPath = subPath.replace(/^\/+/, "");
-    if (relPath.includes("..")) {
-      res.statusCode = 400;
-      res.end("Invalid path.");
-      return;
-    }
-    const normalizedPath = normalize(relPath);
-    const filePath = join(distDir, normalizedPath);
-    try {
-      const content = await promises.readFile(filePath);
-      const ext = extname(filePath);
-      const contentType = mimeTypes[ext] ?? "application/octet-stream";
-      sendFile(res, content, contentType);
-    } catch {
-      return next();
-    }
-  };
-}
-
-const defaultSwPath = "/mokup-sw.js";
-const defaultSwScope = "/";
-function normalizeSwPath(path) {
-  if (!path) {
-    return defaultSwPath;
-  }
-  return path.startsWith("/") ? path : `/${path}`;
-}
-function normalizeSwScope(scope) {
-  if (!scope) {
-    return defaultSwScope;
-  }
-  return scope.startsWith("/") ? scope : `/${scope}`;
-}
-function normalizeBasePath(value) {
-  if (!value) {
-    return "/";
-  }
-  const normalized = value.startsWith("/") ? value : `/${value}`;
-  if (normalized.length > 1 && normalized.endsWith("/")) {
-    return normalized.slice(0, -1);
-  }
-  return normalized;
-}
-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 {
-    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 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 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},`
-      );
-    }
-    lines.push("}", "");
-  }
-  const runtimeOptions = moduleEntries.length > 0 ? "{ manifest, moduleMap }" : "{ manifest }";
-  lines.push(
-    `const basePaths = ${JSON.stringify(basePaths)}`,
-    "",
-    "self.addEventListener('install', () => {",
-    "  self.skipWaiting()",
-    "})",
-    "",
-    "self.addEventListener('activate', (event) => {",
-    "  event.waitUntil(self.clients.claim())",
-    "})",
-    "",
-    "const shouldHandle = (request) => {",
-    "  if (!basePaths || basePaths.length === 0) {",
-    "    return true",
-    "  }",
-    "  const pathname = new URL(request.url).pathname",
-    "  return basePaths.some((basePath) => {",
-    "    if (basePath === '/') {",
-    "      return true",
-    "    }",
-    "    return pathname === basePath || pathname.startsWith(basePath + '/')",
-    "  })",
-    "}",
-    "",
-    "const registerHandler = async () => {",
-    `  const app = await createRuntimeApp(${runtimeOptions})`,
-    "  const handler = handle(app)",
-    "  self.addEventListener('fetch', (event) => {",
-    "    if (!shouldHandle(event.request)) {",
-    "      return",
-    "    }",
-    "    handler(event)",
-    "  })",
-    "}",
-    "",
-    "registerHandler().catch((error) => {",
-    "  logger.error('Failed to build service worker app:', error)",
-    "})",
-    ""
-  );
-  return lines.join("\n");
-}
-
-function toHonoPath(route) {
-  if (!route.tokens || route.tokens.length === 0) {
-    return "/";
-  }
-  const segments = route.tokens.map((token) => {
-    if (token.type === "static") {
-      return token.value;
-    }
-    if (token.type === "param") {
-      return `:${token.name}`;
-    }
-    if (token.type === "catchall") {
-      return `:${token.name}{.+}`;
-    }
-    return `:${token.name}{.+}?`;
-  });
-  return `/${segments.join("/")}`;
-}
-function isValidStatus(status) {
-  return typeof status === "number" && Number.isFinite(status) && status >= 200 && status <= 599;
-}
-function resolveStatus(routeStatus, responseStatus) {
-  if (isValidStatus(routeStatus)) {
-    return routeStatus;
-  }
-  if (isValidStatus(responseStatus)) {
-    return responseStatus;
-  }
-  return 200;
-}
-function applyRouteOverrides(response, route) {
-  const headers = new Headers(response.headers);
-  const hasHeaders = !!route.headers && Object.keys(route.headers).length > 0;
-  if (route.headers) {
-    for (const [key, value] of Object.entries(route.headers)) {
-      headers.set(key, value);
-    }
-  }
-  const status = resolveStatus(route.status, response.status);
-  if (status === response.status && !hasHeaders) {
-    return response;
-  }
-  return new Response(response.body, { status, headers });
-}
-function resolveResponse(value, fallback) {
-  if (value instanceof Response) {
-    return value;
-  }
-  if (value && typeof value === "object" && "res" in value) {
-    const resolved = value.res;
-    if (resolved instanceof Response) {
-      return resolved;
-    }
-  }
-  return fallback;
-}
-function normalizeHandlerValue(c, value) {
-  if (value instanceof Response) {
-    return value;
-  }
-  if (typeof value === "undefined") {
-    const response = c.body(null);
-    if (response.status === 200) {
-      return new Response(response.body, {
-        status: 204,
-        headers: response.headers
-      });
-    }
-    return response;
-  }
-  if (typeof value === "string") {
-    return c.text(value);
-  }
-  if (value instanceof Uint8Array || value instanceof ArrayBuffer) {
-    if (!c.res.headers.get("content-type")) {
-      c.header("content-type", "application/octet-stream");
-    }
-    const data = value instanceof ArrayBuffer ? new Uint8Array(value) : new Uint8Array(value);
-    return c.body(data);
-  }
-  return c.json(value);
-}
-function createRouteHandler(route) {
-  return async (c) => {
-    const value = typeof route.handler === "function" ? await route.handler(c) : route.handler;
-    return normalizeHandlerValue(c, value);
-  };
-}
-function createFinalizeMiddleware(route) {
-  return async (c, next) => {
-    const response = await next();
-    const resolved = resolveResponse(response, c.res);
-    if (route.delay && route.delay > 0) {
-      await delay(route.delay);
-    }
-    const overridden = applyRouteOverrides(resolved, route);
-    c.res = overridden;
-    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 };
-}
-function createHonoApp(routes) {
-  const app = new Hono({ router: new PatternRouter(), strict: false });
-  for (const route of routes) {
-    const { before, normal, after } = splitRouteMiddlewares(route);
-    app.on(
-      route.method,
-      toHonoPath(route),
-      createFinalizeMiddleware(route),
-      ...before,
-      ...normal,
-      ...after,
-      createRouteHandler(route)
-    );
-  }
-  return app;
-}
-async function readRawBody(req) {
-  return await new Promise((resolve, reject) => {
-    const chunks = [];
-    req.on("data", (chunk) => {
-      if (typeof chunk === "string") {
-        chunks.push(Buffer.from(chunk));
-        return;
-      }
-      if (chunk instanceof Uint8Array) {
-        chunks.push(chunk);
-        return;
-      }
-      chunks.push(Buffer.from(String(chunk)));
-    });
-    req.on("end", () => {
-      if (chunks.length === 0) {
-        resolve(null);
-        return;
-      }
-      resolve(Buffer.concat(chunks));
-    });
-    req.on("error", reject);
-  });
-}
-function buildHeaders(headers) {
-  const result = new Headers();
-  for (const [key, value] of Object.entries(headers)) {
-    if (typeof value === "undefined") {
-      continue;
-    }
-    if (Array.isArray(value)) {
-      result.set(key, value.join(","));
-    } else {
-      result.set(key, value);
-    }
-  }
-  return result;
-}
-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;
-  }
-  return new Request(url.toString(), init);
-}
-async function sendResponse(res, response) {
-  res.statusCode = response.status;
-  response.headers.forEach((value, key) => {
-    res.setHeader(key, value);
-  });
-  if (!response.body) {
-    res.end();
-    return;
-  }
-  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);
-    }
-  };
-}
-
-const jsonExtensions = /* @__PURE__ */ new Set([".json", ".jsonc"]);
-function resolveTemplate(template, prefix) {
-  const normalized = template.startsWith("/") ? template : `/${template}`;
-  if (!prefix) {
-    return normalized;
-  }
-  const normalizedPrefix = normalizePrefix(prefix);
-  if (!normalizedPrefix) {
-    return normalized;
-  }
-  if (normalized === normalizedPrefix || normalized.startsWith(`${normalizedPrefix}/`)) {
-    return normalized;
-  }
-  if (normalized === "/") {
-    return `${normalizedPrefix}/`;
-  }
-  return `${normalizedPrefix}${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()
-    };
-  }
-  return {
-    name: base,
-    method: void 0
-  };
-}
-function deriveRouteFromFile(file, rootDir, logger) {
-  const rel = toPosix(relative(rootDir, file));
-  const ext = extname(rel);
-  const withoutExt = rel.slice(0, rel.length - ext.length);
-  const dir = dirname(withoutExt);
-  const base = basename(withoutExt);
-  const { name, method } = stripMethodSuffix(base);
-  const resolvedMethod = method ?? (jsonExtensions.has(ext) ? "GET" : void 0);
-  if (!resolvedMethod) {
-    logger.warn(`Skip mock without method suffix: ${file}`);
-    return null;
-  }
-  if (!name) {
-    logger.warn(`Skip mock with empty route name: ${file}`);
-    return null;
-  }
-  const joined = dir === "." ? name : join(dir, name);
-  const segments = toPosix(joined).split("/");
-  if (segments.at(-1) === "index") {
-    segments.pop();
-  }
-  const template = segments.length === 0 ? "/" : `/${segments.join("/")}`;
-  const parsed = parseRouteTemplate(template);
-  if (parsed.errors.length > 0) {
-    for (const error of parsed.errors) {
-      logger.warn(`${error} in ${file}`);
-    }
-    return null;
-  }
-  for (const warning of parsed.warnings) {
-    logger.warn(`${warning} in ${file}`);
-  }
-  return {
-    template: parsed.template,
-    method: resolvedMethod,
-    tokens: parsed.tokens,
-    score: parsed.score
-  };
-}
-function resolveRule(params) {
-  const method = params.derivedMethod;
-  if (!method) {
-    params.logger.warn(`Skip mock without method suffix: ${params.file}`);
-    return null;
-  }
-  const template = resolveTemplate(params.derivedTemplate, params.prefix);
-  const parsed = parseRouteTemplate(template);
-  if (parsed.errors.length > 0) {
-    for (const error of parsed.errors) {
-      params.logger.warn(`${error} in ${params.file}`);
-    }
-    return null;
-  }
-  for (const warning of parsed.warnings) {
-    params.logger.warn(`${warning} in ${params.file}`);
-  }
-  const route = {
-    file: params.file,
-    template: parsed.template,
-    method,
-    tokens: parsed.tokens,
-    score: parsed.score,
-    handler: params.rule.handler
-  };
-  if (typeof params.rule.status === "number") {
-    route.status = params.rule.status;
-  }
-  if (params.rule.headers) {
-    route.headers = params.rule.headers;
-  }
-  if (typeof params.rule.delay === "number") {
-    route.delay = params.rule.delay;
-  }
-  return route;
-}
-function sortRoutes(routes) {
-  return routes.sort((a, b) => {
-    if (a.method !== b.method) {
-      return a.method.localeCompare(b.method);
-    }
-    const scoreCompare = compareRouteScore(a.score, b.score);
-    if (scoreCompare !== 0) {
-      return scoreCompare;
-    }
-    return a.template.localeCompare(b.template);
-  });
-}
-
-async function walkDir(dir, rootDir, files) {
-  const entries = await promises.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.name === "node_modules" || entry.name === ".git") {
-      continue;
-    }
-    const fullPath = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      await walkDir(fullPath, rootDir, files);
-      continue;
-    }
-    if (entry.isFile()) {
-      files.push({ file: fullPath, rootDir });
-    }
-  }
-}
-async function exists(path) {
-  try {
-    await promises.stat(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function collectFiles(dirs) {
-  const files = [];
-  for (const dir of dirs) {
-    if (!await exists(dir)) {
-      continue;
-    }
-    await walkDir(dir, dir, files);
-  }
-  return files;
-}
-function isConfigFile(file) {
-  if (file.endsWith(".d.ts")) {
-    return false;
-  }
-  const base = basename(file);
-  if (!base.startsWith("index.config.")) {
-    return false;
-  }
-  const ext = extname(file).toLowerCase();
-  return configExtensions.includes(ext);
-}
-function isSupportedFile(file) {
-  if (file.endsWith(".d.ts")) {
-    return false;
-  }
-  if (isConfigFile(file)) {
-    return false;
-  }
-  const ext = extname(file).toLowerCase();
-  return supportedExtensions.has(ext);
-}
-
-const sourceRoot = dirname(fileURLToPath(import.meta.url));
-function resolveWorkspaceEntry(candidates) {
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  return null;
-}
-const mokupSourceEntry = resolveWorkspaceEntry([
-  resolve(sourceRoot, "../index.ts"),
-  resolve(sourceRoot, "../../src/index.ts")
-]);
-const mokupViteSourceEntry = resolveWorkspaceEntry([
-  resolve(sourceRoot, "../vite.ts"),
-  resolve(sourceRoot, "../../src/vite.ts")
-]);
-function createWorkspaceResolvePlugin() {
-  if (!mokupSourceEntry && !mokupViteSourceEntry) {
-    return null;
-  }
-  return {
-    name: "mokup:resolve-workspace",
-    setup(build) {
-      if (mokupSourceEntry) {
-        build.onResolve({ filter: /^mokup$/ }, () => ({ path: mokupSourceEntry }));
-      }
-      if (mokupViteSourceEntry) {
-        build.onResolve({ filter: /^mokup\/vite$/ }, () => ({ path: mokupViteSourceEntry }));
-      }
-    }
-  };
-}
-const workspaceResolvePlugin = createWorkspaceResolvePlugin();
-async function loadModule(file) {
-  const ext = extname(file).toLowerCase();
-  if (ext === ".cjs") {
-    const require = createRequire(import.meta.url);
-    delete require.cache[file];
-    return require(file);
-  }
-  if (ext === ".js" || ext === ".mjs") {
-    return import(`${pathToFileURL(file).href}?t=${Date.now()}`);
-  }
-  if (ext === ".ts") {
-    const result = await build({
-      entryPoints: [file],
-      bundle: true,
-      format: "esm",
-      platform: "node",
-      sourcemap: "inline",
-      target: "es2020",
-      write: false,
-      ...workspaceResolvePlugin ? { plugins: [workspaceResolvePlugin] } : {}
-    });
-    const output = result.outputFiles[0];
-    const code = output?.text ?? "";
-    const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString(
-      "base64"
-    )}`;
-    return import(`${dataUrl}#${Date.now()}`);
-  }
-  return null;
-}
-async function loadModuleWithVite(server, file) {
-  const asDevServer = server;
-  if ("ssrLoadModule" in asDevServer) {
-    const moduleNode = asDevServer.moduleGraph.getModuleById(file);
-    if (moduleNode) {
-      asDevServer.moduleGraph.invalidateModule(moduleNode);
-    }
-    return asDevServer.ssrLoadModule(file);
-  }
-  return loadModule(file);
-}
-
-const middlewareSymbol = Symbol.for("mokup.config.middlewares");
-function getConfigFileCandidates(dir) {
-  return configExtensions.map((extension) => join(dir, `index.config${extension}`));
-}
-async function findConfigFile(dir, cache) {
-  const cached = cache.get(dir);
-  if (cached !== void 0) {
-    return cached;
-  }
-  for (const candidate of getConfigFileCandidates(dir)) {
-    try {
-      await promises.stat(candidate);
-      cache.set(dir, candidate);
-      return candidate;
-    } catch {
-      continue;
-    }
-  }
-  cache.set(dir, null);
-  return null;
-}
-async function loadConfig(file, server) {
-  const mod = server ? await loadModuleWithVite(server, file) : await loadModule(file);
-  if (!mod) {
-    return null;
-  }
-  const raw = mod?.default ?? mod;
-  const value = isPromise(raw) ? await raw : raw;
-  if (!value || typeof value !== "object") {
-    return null;
-  }
-  return value;
-}
-function isPromise(value) {
-  return !!value && typeof value.then === "function";
-}
-function normalizeMiddlewares(value, source, logger, position) {
-  if (!value) {
-    return [];
-  }
-  const list = Array.isArray(value) ? value : [value];
-  const middlewares = [];
-  for (const [index, entry] of list.entries()) {
-    if (typeof entry !== "function") {
-      logger.warn(`Invalid middleware in ${source}`);
-      continue;
-    }
-    middlewares.push({
-      handle: entry,
-      source,
-      index,
-      position
-    });
-  }
-  return middlewares;
-}
-function readMiddlewareMeta(config) {
-  const value = config[middlewareSymbol];
-  if (!value || typeof value !== "object") {
-    return null;
-  }
-  const meta = value;
-  return {
-    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 = normalize(rootDir);
-  const resolvedFileDir = normalize(dirname(file));
-  const chain = [];
-  let current = resolvedFileDir;
-  while (true) {
-    chain.push(current);
-    if (current === resolvedRoot) {
-      break;
-    }
-    const parent = dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
-  }
-  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 promises.readFile(file, "utf8");
-    const errors = [];
-    const data = parse(content, errors, {
-      allowTrailingComma: true,
-      disallowComments: false
-    });
-    if (errors.length > 0) {
-      logger.warn(`Invalid JSONC in ${file}`);
-      return void 0;
-    }
-    return data;
-  } catch (error) {
-    logger.warn(`Failed to read ${file}: ${String(error)}`);
-    return void 0;
-  }
-}
-async function loadRules(file, server, logger) {
-  const ext = extname(file).toLowerCase();
-  if (ext === ".json" || ext === ".jsonc") {
-    const json = await readJsonFile(file, logger);
-    if (typeof json === "undefined") {
-      return [];
-    }
-    return [
-      {
-        handler: json
-      }
-    ];
-  }
-  const mod = server ? await loadModuleWithVite(server, file) : await loadModule(file);
-  const value = mod?.default ?? mod;
-  if (!value) {
-    return [];
-  }
-  if (Array.isArray(value)) {
-    return value;
-  }
-  if (typeof value === "function") {
-    return [
-      {
-        handler: value
-      }
-    ];
-  }
-  return [value];
-}
-
-const silentLogger = {
-  info: () => {
-  },
-  warn: () => {
-  },
-  error: () => {
-  },
-  log: () => {
-  }
-};
-function resolveSkipRoute(params) {
-  const derived = params.derived ?? deriveRouteFromFile(params.file, params.rootDir, silentLogger);
-  if (!derived?.method) {
-    return null;
-  }
-  const resolved = resolveRule({
-    rule: { handler: null },
-    derivedTemplate: derived.template,
-    derivedMethod: derived.method,
-    prefix: params.prefix,
-    file: params.file,
-    logger: silentLogger
-  });
-  if (!resolved) {
-    return null;
-  }
-  return {
-    method: resolved.method,
-    url: resolved.template
-  };
-}
-function buildSkipInfo(file, reason, resolved, configChain, decisionChain, effectiveConfig) {
-  const info = { file, reason };
-  if (resolved) {
-    info.method = resolved.method;
-    info.url = resolved.url;
-  }
-  if (configChain && configChain.length > 0) {
-    info.configChain = configChain;
-  }
-  if (decisionChain && decisionChain.length > 0) {
-    info.decisionChain = decisionChain;
-  }
-  if (effectiveConfig && Object.keys(effectiveConfig).length > 0) {
-    info.effectiveConfig = effectiveConfig;
-  }
-  return info;
-}
-function toFilterStrings(value) {
-  if (!value) {
-    return [];
-  }
-  const list = Array.isArray(value) ? value : [value];
-  return list.filter((entry) => entry instanceof RegExp).map((entry) => entry.toString());
-}
-function toStringList(value) {
-  return value.length === 1 ? value[0] : [...value];
-}
-function formatList(value) {
-  return value.join(", ");
-}
-function testPatterns(patterns, value) {
-  const list = Array.isArray(patterns) ? patterns : [patterns];
-  return list.some((pattern) => pattern.test(value));
-}
-function buildEffectiveConfig(params) {
-  const { config, effectiveInclude, effectiveExclude, effectiveIgnorePrefix } = params;
-  const includeList = toFilterStrings(effectiveInclude);
-  const excludeList = toFilterStrings(effectiveExclude);
-  const effectiveConfig = {};
-  if (config.headers && Object.keys(config.headers).length > 0) {
-    effectiveConfig.headers = config.headers;
-  }
-  if (typeof config.status === "number") {
-    effectiveConfig.status = config.status;
-  }
-  if (typeof config.delay === "number") {
-    effectiveConfig.delay = config.delay;
-  }
-  if (typeof config.enabled !== "undefined") {
-    effectiveConfig.enabled = config.enabled;
-  }
-  if (effectiveIgnorePrefix.length > 0) {
-    effectiveConfig.ignorePrefix = toStringList(effectiveIgnorePrefix);
-  }
-  if (includeList.length > 0) {
-    effectiveConfig.include = toStringList(includeList);
-  }
-  if (excludeList.length > 0) {
-    effectiveConfig.exclude = toStringList(excludeList);
-  }
-  return effectiveConfig;
-}
-
-function pushDecisionStep(chain, entry) {
-  const step = {
-    step: entry.step,
-    result: entry.result
-  };
-  if (typeof entry.source !== "undefined") {
-    step.source = entry.source;
-  }
-  if (typeof entry.detail !== "undefined") {
-    step.detail = entry.detail;
-  }
-  chain.push(step);
-}
-function runRoutePrechecks(params) {
-  const {
-    fileInfo,
-    prefix,
-    config,
-    configChain,
-    globalIgnorePrefix,
-    include,
-    exclude,
-    shouldCollectSkip,
-    shouldCollectIgnore,
-    onSkip,
-    onIgnore
-  } = params;
-  const configSources = config.configSources ?? {};
-  const decisionChain = [];
-  const isConfigEnabled = config.enabled !== false;
-  pushDecisionStep(decisionChain, {
-    step: "config.enabled",
-    result: isConfigEnabled ? "pass" : "fail",
-    source: configSources.enabled,
-    detail: config.enabled === false ? "enabled=false" : typeof config.enabled === "boolean" ? "enabled=true" : "enabled=true (default)"
-  });
-  const effectiveIgnorePrefix = typeof config.ignorePrefix !== "undefined" ? normalizeIgnorePrefix(config.ignorePrefix, []) : globalIgnorePrefix;
-  const effectiveInclude = typeof config.include !== "undefined" ? config.include : include;
-  const effectiveExclude = typeof config.exclude !== "undefined" ? config.exclude : exclude;
-  const effectiveConfigParams = {
-    config,
-    effectiveIgnorePrefix
-  };
-  if (typeof effectiveInclude !== "undefined") {
-    effectiveConfigParams.effectiveInclude = effectiveInclude;
-  }
-  if (typeof effectiveExclude !== "undefined") {
-    effectiveConfigParams.effectiveExclude = effectiveExclude;
-  }
-  const effectiveConfig = buildEffectiveConfig(effectiveConfigParams);
-  const effectiveConfigValue = Object.keys(effectiveConfig).length > 0 ? effectiveConfig : void 0;
-  if (!isConfigEnabled) {
-    if (shouldCollectSkip && isSupportedFile(fileInfo.file)) {
-      const resolved = resolveSkipRoute({
-        file: fileInfo.file,
-        rootDir: fileInfo.rootDir,
-        prefix
-      });
-      onSkip?.(buildSkipInfo(
-        fileInfo.file,
-        "disabled-dir",
-        resolved,
-        configChain,
-        decisionChain,
-        effectiveConfigValue
-      ));
-    }
-    return null;
-  }
-  if (effectiveIgnorePrefix.length > 0) {
-    const ignoredByPrefix = hasIgnoredPrefix(fileInfo.file, fileInfo.rootDir, effectiveIgnorePrefix);
-    pushDecisionStep(decisionChain, {
-      step: "ignore-prefix",
-      result: ignoredByPrefix ? "fail" : "pass",
-      source: configSources.ignorePrefix,
-      detail: `prefixes: ${formatList(effectiveIgnorePrefix)}`
-    });
-    if (ignoredByPrefix) {
-      if (shouldCollectSkip && isSupportedFile(fileInfo.file)) {
-        const resolved = resolveSkipRoute({
-          file: fileInfo.file,
-          rootDir: fileInfo.rootDir,
-          prefix
-        });
-        onSkip?.(buildSkipInfo(
-          fileInfo.file,
-          "ignore-prefix",
-          resolved,
-          configChain,
-          decisionChain,
-          effectiveConfigValue
-        ));
-      }
-      return null;
-    }
-  }
-  const supportedFile = isSupportedFile(fileInfo.file);
-  pushDecisionStep(decisionChain, {
-    step: "file.supported",
-    result: supportedFile ? "pass" : "fail",
-    detail: supportedFile ? void 0 : "unsupported file type"
-  });
-  if (!supportedFile) {
-    if (shouldCollectIgnore) {
-      const ignoreInfo = {
-        file: fileInfo.file,
-        reason: "unsupported",
-        configChain,
-        decisionChain
-      };
-      if (effectiveConfigValue) {
-        ignoreInfo.effectiveConfig = effectiveConfigValue;
-      }
-      onIgnore?.(ignoreInfo);
-    }
-    return null;
-  }
-  const normalizedFile = toPosix(fileInfo.file);
-  if (typeof effectiveExclude !== "undefined") {
-    const excluded = testPatterns(effectiveExclude, normalizedFile);
-    const patterns = toFilterStrings(effectiveExclude);
-    pushDecisionStep(decisionChain, {
-      step: "filter.exclude",
-      result: excluded ? "fail" : "pass",
-      source: configSources.exclude,
-      detail: patterns.length > 0 ? `${excluded ? "matched" : "no match"}: ${patterns.join(", ")}` : void 0
-    });
-    if (excluded) {
-      if (shouldCollectSkip) {
-        const resolved = resolveSkipRoute({
-          file: fileInfo.file,
-          rootDir: fileInfo.rootDir,
-          prefix
-        });
-        onSkip?.(buildSkipInfo(
-          fileInfo.file,
-          "exclude",
-          resolved,
-          configChain,
-          decisionChain,
-          effectiveConfigValue
-        ));
-      }
-      return null;
-    }
-  }
-  if (typeof effectiveInclude !== "undefined") {
-    const included = testPatterns(effectiveInclude, normalizedFile);
-    const patterns = toFilterStrings(effectiveInclude);
-    pushDecisionStep(decisionChain, {
-      step: "filter.include",
-      result: included ? "pass" : "fail",
-      source: configSources.include,
-      detail: patterns.length > 0 ? `${included ? "matched" : "no match"}: ${patterns.join(", ")}` : void 0
-    });
-    if (!included) {
-      if (shouldCollectSkip) {
-        const resolved = resolveSkipRoute({
-          file: fileInfo.file,
-          rootDir: fileInfo.rootDir,
-          prefix
-        });
-        onSkip?.(buildSkipInfo(
-          fileInfo.file,
-          "include",
-          resolved,
-          configChain,
-          decisionChain,
-          effectiveConfigValue
-        ));
-      }
-      return null;
-    }
-  }
-  const result = { decisionChain };
-  if (effectiveConfigValue) {
-    result.effectiveConfigValue = effectiveConfigValue;
-  }
-  return result;
-}
-
-async function scanRoutes(params) {
-  const routes = [];
-  const seen = /* @__PURE__ */ new Set();
-  const files = await collectFiles(params.dirs);
-  const globalIgnorePrefix = normalizeIgnorePrefix(params.ignorePrefix);
-  const configCache = /* @__PURE__ */ new Map();
-  const fileCache = /* @__PURE__ */ new Map();
-  const shouldCollectSkip = typeof params.onSkip === "function";
-  const shouldCollectIgnore = typeof params.onIgnore === "function";
-  const shouldCollectConfig = typeof params.onConfig === "function";
-  for (const fileInfo of files) {
-    if (isConfigFile(fileInfo.file)) {
-      if (shouldCollectConfig) {
-        const configParams2 = {
-          file: fileInfo.file,
-          rootDir: fileInfo.rootDir,
-          logger: params.logger,
-          configCache,
-          fileCache
-        };
-        if (params.server) {
-          configParams2.server = params.server;
-        }
-        const config2 = await resolveDirectoryConfig(configParams2);
-        params.onConfig?.({ file: fileInfo.file, enabled: config2.enabled !== false });
-      }
-      continue;
-    }
-    const configParams = {
-      file: fileInfo.file,
-      rootDir: fileInfo.rootDir,
-      logger: params.logger,
-      configCache,
-      fileCache
-    };
-    if (params.server) {
-      configParams.server = params.server;
-    }
-    const config = await resolveDirectoryConfig(configParams);
-    const configChain = config.configChain ?? [];
-    const precheckParams = {
-      fileInfo,
-      prefix: params.prefix,
-      config,
-      configChain,
-      globalIgnorePrefix,
-      shouldCollectSkip,
-      shouldCollectIgnore
-    };
-    if (params.onSkip) {
-      precheckParams.onSkip = params.onSkip;
-    }
-    if (params.onIgnore) {
-      precheckParams.onIgnore = params.onIgnore;
-    }
-    if (params.include) {
-      precheckParams.include = params.include;
-    }
-    if (params.exclude) {
-      precheckParams.exclude = params.exclude;
-    }
-    const precheck = runRoutePrechecks(precheckParams);
-    if (!precheck) {
-      continue;
-    }
-    const { decisionChain, effectiveConfigValue } = precheck;
-    const derived = deriveRouteFromFile(fileInfo.file, fileInfo.rootDir, params.logger);
-    if (!derived) {
-      if (shouldCollectIgnore) {
-        decisionChain.push({
-          step: "route.derived",
-          result: "fail",
-          source: fileInfo.file,
-          detail: "invalid route name"
-        });
-        const ignoreInfo = {
-          file: fileInfo.file,
-          reason: "invalid-route",
-          configChain,
-          decisionChain
-        };
-        if (effectiveConfigValue) {
-          ignoreInfo.effectiveConfig = effectiveConfigValue;
-        }
-        params.onIgnore?.(ignoreInfo);
-      }
-      continue;
-    }
-    decisionChain.push({
-      step: "route.derived",
-      result: "pass",
-      source: fileInfo.file
-    });
-    const rules = await loadRules(fileInfo.file, params.server, params.logger);
-    for (const [index, rule] of rules.entries()) {
-      if (!rule || typeof rule !== "object") {
-        continue;
-      }
-      if (rule.enabled === false) {
-        if (shouldCollectSkip) {
-          const resolved2 = resolveSkipRoute({
-            file: fileInfo.file,
-            rootDir: fileInfo.rootDir,
-            prefix: params.prefix,
-            derived
-          });
-          const ruleDecisionStep = {
-            step: "rule.enabled",
-            result: "fail",
-            source: fileInfo.file,
-            detail: "enabled=false"
-          };
-          const ruleDecisionChain = [...decisionChain, ruleDecisionStep];
-          params.onSkip?.(buildSkipInfo(
-            fileInfo.file,
-            "disabled",
-            resolved2,
-            configChain,
-            ruleDecisionChain,
-            effectiveConfigValue
-          ));
-        }
-        continue;
-      }
-      const ruleValue = rule;
-      const unsupportedKeys = ["response", "url", "method"].filter(
-        (key2) => key2 in ruleValue
-      );
-      if (unsupportedKeys.length > 0) {
-        params.logger.warn(
-          `Skip mock with unsupported fields (${unsupportedKeys.join(", ")}): ${fileInfo.file}`
-        );
-        continue;
-      }
-      if (typeof rule.handler === "undefined") {
-        params.logger.warn(`Skip mock without handler: ${fileInfo.file}`);
-        continue;
-      }
-      const resolved = resolveRule({
-        rule,
-        derivedTemplate: derived.template,
-        derivedMethod: derived.method,
-        prefix: params.prefix,
-        file: fileInfo.file,
-        logger: params.logger
-      });
-      if (!resolved) {
-        continue;
-      }
-      resolved.ruleIndex = index;
-      if (configChain.length > 0) {
-        resolved.configChain = configChain;
-      }
-      if (config.headers) {
-        resolved.headers = { ...config.headers, ...resolved.headers ?? {} };
-      }
-      if (typeof resolved.status === "undefined" && typeof config.status === "number") {
-        resolved.status = config.status;
-      }
-      if (typeof resolved.delay === "undefined" && typeof config.delay === "number") {
-        resolved.delay = config.delay;
-      }
-      if (config.middlewares.length > 0) {
-        resolved.middlewares = config.middlewares;
-      }
-      const key = `${resolved.method} ${resolved.template}`;
-      if (seen.has(key)) {
-        params.logger.warn(`Duplicate mock route ${key} from ${fileInfo.file}`);
-      }
-      seen.add(key);
-      routes.push(resolved);
-    }
-  }
-  return sortRoutes(routes);
-}
-
-export { sortRoutes as a, buildSwScript as b, createHonoApp as c, resolvePlaygroundOptions as d, resolveSwConfig as e, resolveSwUnregisterConfig as f, createPlaygroundMiddleware as g, createMiddleware as h, resolvePlaygroundDist as i, injectPlaygroundSw as j, resolvePlaygroundRequestPath as k, toPlaygroundIgnoredRoute as l, toPlaygroundDisabledRoute as m, normalizePlaygroundPath as n, toPlaygroundRoute as o, resolveDirs as r, scanRoutes as s, toPlaygroundConfigFile as t };