mokup 0.0.0 → 0.1.0

package/dist/vite.mjs

@@ -1,10 +1,12 @@
 import { cwd } from 'node:process';
 import chokidar from 'chokidar';
 import { Buffer } from 'node:buffer';
-import { matchRouteTokens, parseRouteTemplate, compareRouteScore } from '@mokup/runtime';
-import { resolve, isAbsolute, join, normalize, extname, relative, dirname, basename } from 'pathe';
+import { Hono } from 'hono';
+import { PatternRouter } from 'hono/router/pattern-router';
+import { resolve, isAbsolute, join, normalize, extname, dirname, relative, basename } from 'pathe';
 import { promises } from 'node:fs';
 import { createRequire } from 'node:module';
+import { compareRouteScore, parseRouteTemplate } from '@mokup/runtime';
 import { pathToFileURL } from 'node:url';
 import { build } from 'esbuild';
 import { parse } from 'jsonc-parser';
@@ -115,25 +117,113 @@ function delay(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
-function extractQuery(parsedUrl) {
-  const query = {};
-  for (const [key, value] of parsedUrl.searchParams.entries()) {
-    const current = query[key];
-    if (typeof current === "undefined") {
-      query[key] = value;
-    } else if (Array.isArray(current)) {
-      current.push(value);
-    } else {
-      query[key] = [current, value];
+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 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 = route.status ?? response.status;
+  if (status === response.status && !hasHeaders) {
+    return response;
+  }
+  return new Response(response.body, { status, headers });
+}
+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;
   }
-  return query;
+  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 = response ?? c.res;
+    if (route.delay && route.delay > 0) {
+      await delay(route.delay);
+    }
+    return applyRouteOverrides(resolved, route);
+  };
+}
+function wrapMiddleware(handler) {
+  return async (c, next) => {
+    const response = await handler(c, next);
+    return response ?? c.res;
+  };
+}
+function createHonoApp(routes) {
+  const app = new Hono({ router: new PatternRouter(), strict: false });
+  for (const route of routes) {
+    const middlewares = route.middlewares?.map((entry) => wrapMiddleware(entry.handle)) ?? [];
+    app.on(
+      route.method,
+      toHonoPath(route),
+      createFinalizeMiddleware(route),
+      ...middlewares,
+      createRouteHandler(route)
+    );
+  }
+  return app;
 }
 async function readRawBody(req) {
-  return new Promise((resolve, reject) => {
+  return await new Promise((resolve, reject) => {
     const chunks = [];
     req.on("data", (chunk) => {
-      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(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) {
@@ -145,121 +235,74 @@ async function readRawBody(req) {
     req.on("error", reject);
   });
 }
-async function readRequestBody(req, parsedUrl) {
-  const query = extractQuery(parsedUrl);
-  const rawBody = await readRawBody(req);
-  if (!rawBody) {
-    return { query, body: void 0, rawBody: void 0 };
-  }
-  const rawText = rawBody.toString("utf8");
-  const contentTypeHeader = req.headers["content-type"];
-  const contentTypeValue = Array.isArray(contentTypeHeader) ? contentTypeHeader[0] ?? "" : contentTypeHeader ?? "";
-  const contentType = contentTypeValue.split(";")[0]?.trim() ?? "";
-  if (contentType === "application/json" || contentType.endsWith("+json")) {
-    try {
-      return { query, body: JSON.parse(rawText), rawBody: rawText };
-    } catch {
-      return { query, body: rawText, rawBody: rawText };
+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);
     }
   }
-  if (contentType === "application/x-www-form-urlencoded") {
-    const params = new URLSearchParams(rawText);
-    const body = Object.fromEntries(params.entries());
-    return { query, body, rawBody: rawText };
-  }
-  return { query, body: rawText, rawBody: rawText };
+  return result;
 }
-function applyHeaders(res, headers) {
-  if (!headers) {
-    return;
-  }
-  for (const [key, value] of Object.entries(headers)) {
-    res.setHeader(key, value);
+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);
 }
-function writeResponse(res, body) {
-  if (typeof body === "undefined") {
-    if (!res.headersSent && res.statusCode === 200) {
-      res.statusCode = 204;
-    }
+async function sendResponse(res, response) {
+  res.statusCode = response.status;
+  response.headers.forEach((value, key) => {
+    res.setHeader(key, value);
+  });
+  if (!response.body) {
     res.end();
     return;
   }
-  if (Buffer.isBuffer(body)) {
-    if (!res.getHeader("Content-Type")) {
-      res.setHeader("Content-Type", "application/octet-stream");
-    }
-    res.end(body);
-    return;
-  }
-  if (typeof body === "string") {
-    if (!res.getHeader("Content-Type")) {
-      res.setHeader("Content-Type", "text/plain; charset=utf-8");
-    }
-    res.end(body);
-    return;
-  }
-  if (!res.getHeader("Content-Type")) {
-    res.setHeader("Content-Type", "application/json; charset=utf-8");
-  }
-  res.end(JSON.stringify(body));
+  const buffer = new Uint8Array(await response.arrayBuffer());
+  res.end(buffer);
 }
-function findMatchingRoute(routes, method, pathname) {
-  for (const route of routes) {
-    if (route.method !== method) {
-      continue;
-    }
-    const matched = matchRouteTokens(route.tokens, pathname);
-    if (matched) {
-      return { route, params: matched.params };
-    }
-  }
-  return null;
+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(getRoutes, logger) {
+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";
-    const matched = findMatchingRoute(getRoutes(), method, pathname);
-    if (!matched) {
+    if (!hasMatch(app, method, pathname)) {
       return next();
     }
+    const startedAt = Date.now();
     try {
-      const { query, body, rawBody } = await readRequestBody(req, parsedUrl);
-      const mockReq = {
-        url: pathname,
-        method,
-        headers: req.headers,
-        query,
-        body,
-        params: matched.params
-      };
-      if (rawBody) {
-        mockReq.rawBody = rawBody;
-      }
-      const ctx = {
-        delay: (ms) => delay(ms),
-        json: (data) => data
-      };
-      const startedAt = Date.now();
-      const responseValue = typeof matched.route.response === "function" ? await matched.route.response(mockReq, res, ctx) : matched.route.response;
+      const response = await app.fetch(await toRequest(req));
       if (res.writableEnded) {
         return;
       }
-      if (matched.route.delay && matched.route.delay > 0) {
-        await delay(matched.route.delay);
-      }
-      applyHeaders(res, matched.route.headers);
-      if (matched.route.status) {
-        res.statusCode = matched.route.status;
-      }
-      writeResponse(res, responseValue);
+      await sendResponse(res, response);
       logger.info(`${method} ${pathname} ${Date.now() - startedAt}ms`);
     } catch (error) {
-      res.statusCode = 500;
-      res.setHeader("Content-Type", "text/plain; charset=utf-8");
+      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);
     }
@@ -286,6 +329,43 @@ function normalizePlaygroundPath(value) {
   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 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 isViteDevServer$1(server) {
+  return !!server && "ws" in server;
+}
 function resolvePlaygroundOptions(playground) {
   if (playground === false) {
     return { enabled: false, path: "/_mokup" };
@@ -312,14 +392,105 @@ function sendFile(res, content, contentType) {
   res.setHeader("Content-Type", contentType);
   res.end(content);
 }
-function toPlaygroundRoute(route) {
+function toPosixPath(value) {
+  return value.replace(/\\/g, "/");
+}
+function normalizePath(value) {
+  return toPosixPath(normalize(value));
+}
+function isAncestor(parent, child) {
+  const normalizedParent = normalizePath(parent).replace(/\/$/, "");
+  const normalizedChild = normalizePath(child);
+  return normalizedChild === normalizedParent || normalizedChild.startsWith(`${normalizedParent}/`);
+}
+function resolveGroupRoot(dirs, serverRoot) {
+  if (!dirs || dirs.length === 0) {
+    return serverRoot ?? cwd();
+  }
+  if (serverRoot) {
+    const normalizedRoot = normalizePath(serverRoot);
+    const canUseRoot = dirs.every((dir) => isAncestor(normalizedRoot, dir));
+    if (canUseRoot) {
+      return normalizedRoot;
+    }
+  }
+  if (dirs.length === 1) {
+    return normalizePath(dirname(dirs[0]));
+  }
+  let common = normalizePath(dirs[0]);
+  for (const dir of dirs.slice(1)) {
+    const normalizedDir = normalizePath(dir);
+    while (common && !isAncestor(common, normalizedDir)) {
+      const parent = normalizePath(dirname(common));
+      if (parent === common) {
+        break;
+      }
+      common = parent;
+    }
+  }
+  if (!common || common === "/") {
+    return serverRoot ?? cwd();
+  }
+  return common;
+}
+function formatRouteFile(file, root) {
+  if (!root) {
+    return toPosixPath(file);
+  }
+  const rel = toPosixPath(relative(root, file));
+  if (!rel || rel.startsWith("..")) {
+    return toPosixPath(file);
+  }
+  return rel;
+}
+function resolveGroups(dirs, root) {
+  const groups = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const dir of dirs) {
+    const normalized = normalizePath(dir);
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    const rel = toPosixPath(relative(root, normalized));
+    const label = rel && !rel.startsWith("..") ? rel : normalized;
+    groups.push({
+      key: normalized,
+      label,
+      path: normalized
+    });
+  }
+  return groups;
+}
+function resolveRouteGroup(routeFile, groups) {
+  if (groups.length === 0) {
+    return void 0;
+  }
+  const normalizedFile = toPosixPath(normalize(routeFile));
+  let matched;
+  for (const group of groups) {
+    if (normalizedFile === group.path || normalizedFile.startsWith(`${group.path}/`)) {
+      if (!matched || group.path.length > matched.path.length) {
+        matched = group;
+      }
+    }
+  }
+  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: route.file,
-    type: typeof route.response === "function" ? "handler" : "static",
+    file: formatRouteFile(route.file, root),
+    type: typeof route.handler === "function" ? "handler" : "static",
     status: route.status,
-    delay: route.delay
+    delay: route.delay,
+    middlewareCount: middlewareSources?.length ?? 0,
+    middlewares: middlewareSources,
+    groupKey: matchedGroup?.key,
+    group: matchedGroup?.label
   };
 }
 function createPlaygroundMiddleware(params) {
@@ -337,11 +508,20 @@ function createPlaygroundMiddleware(params) {
       return next();
     }
     const subPath = pathname.slice(playgroundPath.length);
+    if (subPath === "") {
+      const suffix = url.search ?? "";
+      res.statusCode = 302;
+      res.setHeader("Location", `${playgroundPath}/${suffix}`);
+      res.end();
+      return;
+    }
     if (subPath === "" || subPath === "/" || subPath === "/index.html") {
       try {
         const html = await promises.readFile(indexPath, "utf8");
+        const server = params.getServer?.();
+        const output = isViteDevServer$1(server) ? injectPlaygroundHmr(html, server.config.base ?? "/") : html;
         const contentType = mimeTypes[".html"] ?? "text/html; charset=utf-8";
-        sendFile(res, html, contentType);
+        sendFile(res, output, contentType);
       } catch (error) {
         params.logger.error("Failed to load playground index:", error);
         res.statusCode = 500;
@@ -350,11 +530,16 @@ function createPlaygroundMiddleware(params) {
       return;
     }
     if (subPath === "/routes") {
+      const server = params.getServer?.();
+      const dirs = params.getDirs?.() ?? [];
+      const baseRoot = resolveGroupRoot(dirs, server?.config?.root);
+      const groups = resolveGroups(dirs, baseRoot);
       const routes = params.getRoutes();
       sendJson(res, {
         basePath: playgroundPath,
         count: routes.length,
-        routes: routes.map(toPlaygroundRoute)
+        groups: groups.map((group) => ({ key: group.key, label: group.label })),
+        routes: routes.map((route) => toPlaygroundRoute(route, baseRoot, groups))
       });
       return;
     }
@@ -377,6 +562,267 @@ 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 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);
+  });
+}
+
+const configExtensions = [".ts", ".js", ".mjs", ".cjs"];
+async function loadModule$1(file) {
+  const ext = configExtensions.find((extension) => file.endsWith(extension));
+  if (ext === ".cjs") {
+    const require = createRequire(import.meta.url);
+    delete require.cache[file];
+    return require(file);
+  }
+  if (ext === ".js" || ext === ".mjs") {
+    return import(`${pathToFileURL(file).href}?t=${Date.now()}`);
+  }
+  if (ext === ".ts") {
+    const result = await build({
+      entryPoints: [file],
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      sourcemap: "inline",
+      target: "es2020",
+      write: false
+    });
+    const output = result.outputFiles[0];
+    const code = output?.text ?? "";
+    const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString(
+      "base64"
+    )}`;
+    return import(`${dataUrl}#${Date.now()}`);
+  }
+  return null;
+}
+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);
+    }
+    return asDevServer.ssrLoadModule(file);
+  }
+  return loadModule$1(file);
+}
+function getConfigFileCandidates(dir) {
+  return configExtensions.map((extension) => join(dir, `index.config${extension}`));
+}
+async function findConfigFile(dir, cache) {
+  const cached = cache.get(dir);
+  if (cached !== void 0) {
+    return cached;
+  }
+  for (const candidate of getConfigFileCandidates(dir)) {
+    try {
+      await promises.stat(candidate);
+      cache.set(dir, candidate);
+      return candidate;
+    } catch {
+      continue;
+    }
+  }
+  cache.set(dir, null);
+  return null;
+}
+async function loadConfig(file, server) {
+  const mod = server ? await loadModuleWithVite$1(server, file) : await loadModule$1(file);
+  if (!mod) {
+    return null;
+  }
+  const value = mod?.default ?? mod;
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  return value;
+}
+function normalizeMiddlewares(value, source, logger) {
+  if (!value) {
+    return [];
+  }
+  const list = Array.isArray(value) ? value : [value];
+  const middlewares = [];
+  for (const entry of list) {
+    if (typeof entry !== "function") {
+      logger.warn(`Invalid middleware in ${source}`);
+      continue;
+    }
+    middlewares.push({ handle: entry, source });
+  }
+  return middlewares;
+}
+async function resolveDirectoryConfig(params) {
+  const { file, rootDir, server, logger, configCache, fileCache } = params;
+  const resolvedRoot = normalize(rootDir);
+  const resolvedFileDir = normalize(dirname(file));
+  const chain = [];
+  let current = resolvedFileDir;
+  while (true) {
+    chain.push(current);
+    if (current === resolvedRoot) {
+      break;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  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;
+    }
+    const normalized = normalizeMiddlewares(config.middleware, configPath, logger);
+    if (normalized.length > 0) {
+      merged.middlewares.push(...normalized);
+    }
+  }
+  return merged;
+}
+
 async function walkDir(dir, rootDir, files) {
   const entries = await promises.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
@@ -415,6 +861,9 @@ function isSupportedFile(file) {
   if (file.endsWith(".d.ts")) {
     return false;
   }
+  if (basename(file).startsWith("index.config.")) {
+    return false;
+  }
   const ext = extname(file).toLowerCase();
   return supportedExtensions.has(ext);
 }
@@ -486,7 +935,7 @@ async function loadRules(file, server, logger) {
     }
     return [
       {
-        response: json
+        handler: json
       }
     ];
   }
@@ -501,149 +950,19 @@ async function loadRules(file, server, logger) {
   if (typeof value === "function") {
     return [
       {
-        response: value
+        handler: value
       }
     ];
   }
   return [value];
 }
 
-function resolveMethod(fileMethod, ruleMethod, logger) {
-  if (ruleMethod) {
-    const normalized = normalizeMethod(ruleMethod);
-    if (normalized) {
-      return normalized;
-    }
-    logger.warn(`Unknown method "${ruleMethod}", falling back to file method`);
-  }
-  if (fileMethod) {
-    return fileMethod;
-  }
-  return "GET";
-}
-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);
-  if (!method) {
-    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,
-    tokens: parsed.tokens,
-    score: parsed.score
-  };
-}
-function resolveRule(params) {
-  const method = resolveMethod(params.derivedMethod, params.rule.method, params.logger);
-  if (!method) {
-    params.logger.warn(`Invalid mock method in ${params.file}`);
-    return null;
-  }
-  const template = resolveTemplate(params.rule.url ?? 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,
-    response: params.rule.response
-  };
-  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 scanRoutes(params) {
   const routes = [];
   const seen = /* @__PURE__ */ new Set();
   const files = await collectFiles(params.dirs);
+  const configCache = /* @__PURE__ */ new Map();
+  const fileCache = /* @__PURE__ */ new Map();
   for (const fileInfo of files) {
     if (!isSupportedFile(fileInfo.file)) {
       continue;
@@ -651,6 +970,20 @@ async function scanRoutes(params) {
     if (!matchesFilter(fileInfo.file, params.include, params.exclude)) {
       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);
+    if (config.enabled === false) {
+      continue;
+    }
     const derived = deriveRouteFromFile(fileInfo.file, fileInfo.rootDir, params.logger);
     if (!derived) {
       continue;
@@ -660,8 +993,18 @@ async function scanRoutes(params) {
       if (!rule || typeof rule !== "object") {
         continue;
       }
-      if (typeof rule.response === "undefined") {
-        params.logger.warn(`Skip mock without response: ${fileInfo.file}`);
+      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({
@@ -675,6 +1018,18 @@ async function scanRoutes(params) {
       if (!resolved) {
         continue;
       }
+      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}`);
@@ -686,35 +1041,100 @@ async function scanRoutes(params) {
   return sortRoutes(routes);
 }
 
+function buildRouteSignature(routes) {
+  return routes.map(
+    (route) => [
+      route.method,
+      route.template,
+      route.file,
+      typeof route.handler === "function" ? "handler" : "static",
+      route.status ?? "",
+      route.delay ?? ""
+    ].join("|")
+  ).join("\n");
+}
+function isViteDevServer(server) {
+  return !!server && "ws" in server;
+}
+function normalizeOptions(options) {
+  const list = Array.isArray(options) ? options : [options];
+  return list.length > 0 ? list : [{}];
+}
+function resolvePlaygroundInput(list) {
+  for (const entry of list) {
+    if (typeof entry.playground !== "undefined") {
+      return entry.playground;
+    }
+  }
+  return void 0;
+}
 function createMokupPlugin(options = {}) {
   let root = cwd();
   let routes = [];
+  let app = null;
   let previewWatcher = null;
-  const logger = createLogger(options.log !== false);
-  const watchEnabled = options.watch !== false;
-  const playgroundConfig = resolvePlaygroundOptions(options.playground);
+  let currentServer = null;
+  let lastSignature = null;
+  const optionList = normalizeOptions(options);
+  const logEnabled = optionList.every((entry) => entry.log !== false);
+  const watchEnabled = optionList.every((entry) => entry.watch !== false);
+  const playgroundConfig = resolvePlaygroundOptions(resolvePlaygroundInput(optionList));
+  const logger = createLogger(logEnabled);
+  const resolveAllDirs = () => {
+    const dirs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry of optionList) {
+      for (const dir of resolveDirs(entry.dir, root)) {
+        if (seen.has(dir)) {
+          continue;
+        }
+        seen.add(dir);
+        dirs.push(dir);
+      }
+    }
+    return dirs;
+  };
   const playgroundMiddleware = createPlaygroundMiddleware({
     getRoutes: () => routes,
     config: playgroundConfig,
-    logger
+    logger,
+    getServer: () => currentServer,
+    getDirs: () => resolveAllDirs()
   });
   const refreshRoutes = async (server) => {
-    const dirs = resolveDirs(options.dir, root);
-    const scanParams = {
-      dirs,
-      prefix: options.prefix ?? "",
-      logger
-    };
-    if (options.include) {
-      scanParams.include = options.include;
-    }
-    if (options.exclude) {
-      scanParams.exclude = options.exclude;
+    const collected = [];
+    for (const entry of optionList) {
+      const dirs = resolveDirs(entry.dir, root);
+      const scanParams = {
+        dirs,
+        prefix: entry.prefix ?? "",
+        logger
+      };
+      if (entry.include) {
+        scanParams.include = entry.include;
+      }
+      if (entry.exclude) {
+        scanParams.exclude = entry.exclude;
+      }
+      if (server) {
+        scanParams.server = server;
+      }
+      const scanned = await scanRoutes(scanParams);
+      collected.push(...scanned);
     }
-    if (server) {
-      scanParams.server = server;
+    routes = sortRoutes(collected);
+    app = createHonoApp(routes);
+    const signature = buildRouteSignature(routes);
+    if (isViteDevServer(server) && server.ws) {
+      if (lastSignature && signature !== lastSignature) {
+        server.ws.send({
+          type: "custom",
+          event: "mokup:routes-changed",
+          data: { ts: Date.now() }
+        });
+      }
     }
-    routes = await scanRoutes(scanParams);
+    lastSignature = signature;
   };
   return {
     name: "mokup:vite",
@@ -723,13 +1143,14 @@ function createMokupPlugin(options = {}) {
       root = config.root;
     },
     async configureServer(server) {
+      currentServer = server;
       await refreshRoutes(server);
       server.middlewares.use(playgroundMiddleware);
-      server.middlewares.use(createMiddleware(() => routes, logger));
+      server.middlewares.use(createMiddleware(() => app, logger));
       if (!watchEnabled) {
         return;
       }
-      const dirs = resolveDirs(options.dir, root);
+      const dirs = resolveAllDirs();
       server.watcher.add(dirs);
       const scheduleRefresh = createDebouncer(80, () => refreshRoutes(server));
       server.watcher.on("add", (file) => {
@@ -749,13 +1170,14 @@ function createMokupPlugin(options = {}) {
       });
     },
     async configurePreviewServer(server) {
+      currentServer = server;
       await refreshRoutes(server);
       server.middlewares.use(playgroundMiddleware);
-      server.middlewares.use(createMiddleware(() => routes, logger));
+      server.middlewares.use(createMiddleware(() => app, logger));
       if (!watchEnabled) {
         return;
       }
-      const dirs = resolveDirs(options.dir, root);
+      const dirs = resolveAllDirs();
       previewWatcher = chokidar.watch(dirs, { ignoreInitial: true });
       const scheduleRefresh = createDebouncer(80, () => refreshRoutes(server));
       previewWatcher.on("add", scheduleRefresh);