mokup 0.2.1 → 1.0.0

package/dist/shared/mokup.C6zZ8YEh.mjs

@@ -0,0 +1,1420 @@
+import { Buffer } from 'node:buffer';
+import { Hono, PatternRouter } from '@mokup/shared/hono';
+import { promises } from 'node:fs';
+import { createRequire } from 'node:module';
+import { cwd } from 'node:process';
+import { resolve, isAbsolute, join, normalize, extname, dirname, relative, basename } from '@mokup/shared/pathe';
+import { pathToFileURL } from 'node:url';
+import { build } from '@mokup/shared/esbuild';
+import { parse } from '@mokup/shared/jsonc-parser';
+import { compareRouteScore, parseRouteTemplate } from '@mokup/runtime';
+
+function createLogger(enabled) {
+  return {
+    info: (...args) => {
+      if (enabled) {
+        console.info("[mokup]", ...args);
+      }
+    },
+    warn: (...args) => {
+      if (enabled) {
+        console.warn("[mokup]", ...args);
+      }
+    },
+    error: (...args) => {
+      if (enabled) {
+        console.error("[mokup]", ...args);
+      }
+    }
+  };
+}
+
+const methodSet = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "HEAD"
+]);
+const methodSuffixSet = new Set(
+  Array.from(methodSet, (method) => method.toLowerCase())
+);
+const supportedExtensions = /* @__PURE__ */ new Set([
+  ".json",
+  ".jsonc",
+  ".ts",
+  ".js",
+  ".mjs",
+  ".cjs"
+]);
+
+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 createDebouncer(delayMs, fn) {
+  let timer = null;
+  return () => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      timer = null;
+      fn();
+    }, delayMs);
+  };
+}
+function toPosix(value) {
+  return value.replace(/\\/g, "/");
+}
+function isInDirs(file, dirs) {
+  const normalized = toPosix(file);
+  return dirs.some((dir) => {
+    const normalizedDir = toPosix(dir).replace(/\/$/, "");
+    return normalized === normalizedDir || normalized.startsWith(`${normalizedDir}/`);
+  });
+}
+function testPatterns(patterns, value) {
+  const list = Array.isArray(patterns) ? patterns : [patterns];
+  return list.some((pattern) => pattern.test(value));
+}
+function matchesFilter(file, include, exclude) {
+  const normalized = toPosix(file);
+  if (exclude && testPatterns(exclude, normalized)) {
+    return false;
+  }
+  if (include) {
+    return testPatterns(include, normalized);
+  }
+  return true;
+}
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+function toHonoPath(route) {
+  if (!route.tokens || route.tokens.length === 0) {
+    return "/";
+  }
+  const segments = route.tokens.map((token) => {
+    if (token.type === "static") {
+      return token.value;
+    }
+    if (token.type === "param") {
+      return `:${token.name}`;
+    }
+    if (token.type === "catchall") {
+      return `:${token.name}{.+}`;
+    }
+    return `:${token.name}{.+}?`;
+  });
+  return `/${segments.join("/")}`;
+}
+function isValidStatus(status) {
+  return typeof status === "number" && Number.isFinite(status) && status >= 200 && status <= 599;
+}
+function resolveStatus(routeStatus, responseStatus) {
+  if (isValidStatus(routeStatus)) {
+    return routeStatus;
+  }
+  if (isValidStatus(responseStatus)) {
+    return responseStatus;
+  }
+  return 200;
+}
+function applyRouteOverrides(response, route) {
+  const headers = new Headers(response.headers);
+  const hasHeaders = !!route.headers && Object.keys(route.headers).length > 0;
+  if (route.headers) {
+    for (const [key, value] of Object.entries(route.headers)) {
+      headers.set(key, value);
+    }
+  }
+  const status = resolveStatus(route.status, response.status);
+  if (status === response.status && !hasHeaders) {
+    return response;
+  }
+  return new Response(response.body, { status, headers });
+}
+function 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 = 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 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 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 normalizePlaygroundPath(value) {
+  if (!value) {
+    return "/_mokup";
+  }
+  const normalized = value.startsWith("/") ? value : `/${value}`;
+  return normalized.length > 1 && normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function normalizeBase(base) {
+  if (!base || base === "/") {
+    return "";
+  }
+  return base.endsWith("/") ? base.slice(0, -1) : base;
+}
+function resolvePlaygroundRequestPath(base, playgroundPath) {
+  const normalizedBase = normalizeBase(base);
+  const normalizedPath = normalizePlaygroundPath(playgroundPath);
+  if (!normalizedBase) {
+    return normalizedPath;
+  }
+  if (normalizedPath.startsWith(normalizedBase)) {
+    return normalizedPath;
+  }
+  return `${normalizedBase}${normalizedPath}`;
+}
+function injectPlaygroundHmr(html, base) {
+  if (html.includes("mokup-playground-hmr")) {
+    return html;
+  }
+  const normalizedBase = normalizeBase(base);
+  const clientPath = `${normalizedBase}/@vite/client`;
+  const snippet = [
+    '<script type="module" id="mokup-playground-hmr">',
+    `import('${clientPath}').then(({ createHotContext }) => {`,
+    "  const hot = createHotContext('/@mokup/playground')",
+    "  hot.on('mokup:routes-changed', () => {",
+    "    const api = window.__MOKUP_PLAYGROUND__",
+    "    if (api && typeof api.reloadRoutes === 'function') {",
+    "      api.reloadRoutes()",
+    "      return",
+    "    }",
+    "    window.location.reload()",
+    "  })",
+    "}).catch(() => {})",
+    "<\/script>"
+  ].join("\n");
+  if (html.includes("</body>")) {
+    return html.replace("</body>", `${snippet}
+</body>`);
+  }
+  return `${html}
+${snippet}`;
+}
+function injectPlaygroundSw(html, script) {
+  if (!script) {
+    return html;
+  }
+  if (html.includes("mokup-playground-sw")) {
+    return html;
+  }
+  const snippet = [
+    '<script type="module" id="mokup-playground-sw">',
+    script,
+    "<\/script>"
+  ].join("\n");
+  if (html.includes("</head>")) {
+    return html.replace("</head>", `${snippet}
+</head>`);
+  }
+  if (html.includes("</body>")) {
+    return html.replace("</body>", `${snippet}
+</body>`);
+  }
+  return `${html}
+${snippet}`;
+}
+function isViteDevServer(server) {
+  return !!server && "ws" in server;
+}
+function resolvePlaygroundOptions(playground) {
+  if (playground === false) {
+    return { enabled: false, path: "/_mokup" };
+  }
+  if (playground && typeof playground === "object") {
+    return {
+      enabled: playground.enabled !== false,
+      path: normalizePlaygroundPath(playground.path)
+    };
+  }
+  return { enabled: true, path: "/_mokup" };
+}
+function resolvePlaygroundDist() {
+  const pkgPath = require$1.resolve("@mokup/playground/package.json");
+  return join(pkgPath, "..", "dist");
+}
+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 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: formatRouteFile(route.file, root),
+    type: typeof route.handler === "function" ? "handler" : "static",
+    status: route.status,
+    delay: route.delay,
+    middlewareCount: middlewareSources?.length ?? 0,
+    middlewares: middlewareSources,
+    groupKey: matchedGroup?.key,
+    group: matchedGroup?.label
+  };
+}
+function 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();
+      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))
+      });
+      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 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 [index, entry] of list.entries()) {
+    if (typeof entry !== "function") {
+      logger.warn(`Invalid middleware in ${source}`);
+      continue;
+    }
+    middlewares.push({ handle: entry, source, index });
+  }
+  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) {
+    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 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);
+}
+
+async function loadModule(file) {
+  const ext = extname(file).toLowerCase();
+  if (ext === ".cjs") {
+    const require = createRequire(import.meta.url);
+    delete require.cache[file];
+    return require(file);
+  }
+  if (ext === ".js" || ext === ".mjs") {
+    return import(`${pathToFileURL(file).href}?t=${Date.now()}`);
+  }
+  if (ext === ".ts") {
+    const result = await build({
+      entryPoints: [file],
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      sourcemap: "inline",
+      target: "es2020",
+      write: false
+    });
+    const output = result.outputFiles[0];
+    const code = output?.text ?? "";
+    const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString(
+      "base64"
+    )}`;
+    return import(`${dataUrl}#${Date.now()}`);
+  }
+  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);
+}
+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];
+}
+
+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;
+    }
+    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;
+    }
+    const rules = await loadRules(fileInfo.file, params.server, params.logger);
+    for (const [index, rule] of rules.entries()) {
+      if (!rule || typeof rule !== "object") {
+        continue;
+      }
+      const ruleValue = rule;
+      const unsupportedKeys = ["response", "url", "method"].filter(
+        (key2) => key2 in ruleValue
+      );
+      if (unsupportedKeys.length > 0) {
+        params.logger.warn(
+          `Skip mock with unsupported fields (${unsupportedKeys.join(", ")}): ${fileInfo.file}`
+        );
+        continue;
+      }
+      if (typeof rule.handler === "undefined") {
+        params.logger.warn(`Skip mock without handler: ${fileInfo.file}`);
+        continue;
+      }
+      const resolved = resolveRule({
+        rule,
+        derivedTemplate: derived.template,
+        derivedMethod: derived.method,
+        prefix: params.prefix,
+        file: fileInfo.file,
+        logger: params.logger
+      });
+      if (!resolved) {
+        continue;
+      }
+      resolved.ruleIndex = index;
+      if (config.headers) {
+        resolved.headers = { ...config.headers, ...resolved.headers ?? {} };
+      }
+      if (typeof resolved.status === "undefined" && typeof config.status === "number") {
+        resolved.status = config.status;
+      }
+      if (typeof resolved.delay === "undefined" && typeof config.delay === "number") {
+        resolved.delay = config.delay;
+      }
+      if (config.middlewares.length > 0) {
+        resolved.middlewares = config.middlewares;
+      }
+      const key = `${resolved.method} ${resolved.template}`;
+      if (seen.has(key)) {
+        params.logger.warn(`Duplicate mock route ${key} from ${fileInfo.file}`);
+      }
+      seen.add(key);
+      routes.push(resolved);
+    }
+  }
+  return sortRoutes(routes);
+}
+
+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 toViteImportPath(file, root) {
+  const absolute = isAbsolute(file) ? file : resolve(root, file);
+  const rel = relative(root, absolute);
+  if (!rel.startsWith("..") && !isAbsolute(rel)) {
+    return `/${toPosix(rel)}`;
+  }
+  return `/@fs/${toPosix(absolute)}`;
+}
+function shouldModuleize(handler) {
+  if (typeof handler === "function") {
+    return true;
+  }
+  if (typeof Response !== "undefined" && handler instanceof Response) {
+    return true;
+  }
+  return false;
+}
+function toBinaryBody(handler) {
+  if (handler instanceof ArrayBuffer) {
+    return Buffer.from(new Uint8Array(handler)).toString("base64");
+  }
+  if (handler instanceof Uint8Array) {
+    return Buffer.from(handler).toString("base64");
+  }
+  if (Buffer.isBuffer(handler)) {
+    return handler.toString("base64");
+  }
+  return null;
+}
+function buildManifestResponse(route, moduleId) {
+  if (moduleId) {
+    const response = {
+      type: "module",
+      module: moduleId
+    };
+    if (typeof route.ruleIndex === "number") {
+      response.ruleIndex = route.ruleIndex;
+    }
+    return response;
+  }
+  const handler = route.handler;
+  if (typeof handler === "string") {
+    return {
+      type: "text",
+      body: handler
+    };
+  }
+  const binary = toBinaryBody(handler);
+  if (binary) {
+    return {
+      type: "binary",
+      body: binary,
+      encoding: "base64"
+    };
+  }
+  return {
+    type: "json",
+    body: handler
+  };
+}
+function buildSwScript(params) {
+  const { routes, root } = params;
+  const runtimeImportPath = params.runtimeImportPath ?? "mokup/runtime";
+  const basePaths = params.basePaths ?? [];
+  const resolveModulePath = params.resolveModulePath ?? toViteImportPath;
+  const ruleModules = /* @__PURE__ */ new Map();
+  const middlewareModules = /* @__PURE__ */ new Map();
+  const manifestRoutes = routes.map((route) => {
+    const moduleId = shouldModuleize(route.handler) ? resolveModulePath(route.file, root) : null;
+    if (moduleId) {
+      ruleModules.set(moduleId, moduleId);
+    }
+    const middleware = route.middlewares?.map((entry) => {
+      const modulePath = resolveModulePath(entry.source, root);
+      middlewareModules.set(modulePath, modulePath);
+      return {
+        module: modulePath,
+        ruleIndex: entry.index
+      };
+    });
+    const response = buildManifestResponse(route, moduleId);
+    const manifestRoute = {
+      method: route.method,
+      url: route.template,
+      ...route.tokens ? { tokens: route.tokens } : {},
+      ...route.score ? { score: route.score } : {},
+      ...route.status ? { status: route.status } : {},
+      ...route.headers ? { headers: route.headers } : {},
+      ...route.delay ? { delay: route.delay } : {},
+      ...middleware && middleware.length > 0 ? { middleware } : {},
+      response
+    };
+    return manifestRoute;
+  });
+  const manifest = {
+    version: 1,
+    routes: manifestRoutes
+  };
+  const imports = [
+    `import { createRuntimeApp, handle } from ${JSON.stringify(runtimeImportPath)}`
+  ];
+  const moduleEntries = [];
+  let moduleIndex = 0;
+  for (const id of ruleModules.keys()) {
+    const name = `module${moduleIndex++}`;
+    imports.push(`import * as ${name} from '${id}'`);
+    moduleEntries.push({ id, name, kind: "rule" });
+  }
+  for (const id of middlewareModules.keys()) {
+    const name = `module${moduleIndex++}`;
+    imports.push(`import * as ${name} from '${id}'`);
+    moduleEntries.push({ id, name, kind: "middleware" });
+  }
+  const lines = [];
+  lines.push(...imports, "");
+  lines.push(
+    "const resolveModuleExport = (mod) => mod?.default ?? mod",
+    "",
+    "const toRuntimeRule = (value) => {",
+    "  if (typeof value === 'undefined') {",
+    "    return null",
+    "  }",
+    "  if (typeof value === 'function') {",
+    "    return { response: value }",
+    "  }",
+    "  if (value === null) {",
+    "    return { response: null }",
+    "  }",
+    "  if (typeof value === 'object') {",
+    "    if ('response' in value) {",
+    "      return value",
+    "    }",
+    "    if ('handler' in value) {",
+    "      const handlerRule = value",
+    "      return {",
+    "        response: handlerRule.handler,",
+    "        ...(typeof handlerRule.status === 'number' ? { status: handlerRule.status } : {}),",
+    "        ...(handlerRule.headers ? { headers: handlerRule.headers } : {}),",
+    "        ...(typeof handlerRule.delay === 'number' ? { delay: handlerRule.delay } : {}),",
+    "      }",
+    "    }",
+    "    return { response: value }",
+    "  }",
+    "  return { response: value }",
+    "}",
+    "",
+    "const toRuntimeRules = (value) => {",
+    "  if (typeof value === 'undefined') {",
+    "    return []",
+    "  }",
+    "  if (Array.isArray(value)) {",
+    "    return value.map(toRuntimeRule).filter(Boolean)",
+    "  }",
+    "  const rule = toRuntimeRule(value)",
+    "  return rule ? [rule] : []",
+    "}",
+    ""
+  );
+  lines.push(
+    `const manifest = ${JSON.stringify(manifest, null, 2)}`,
+    ""
+  );
+  if (moduleEntries.length > 0) {
+    lines.push("const moduleMap = {");
+    for (const entry of moduleEntries) {
+      if (entry.kind === "rule") {
+        lines.push(
+          `  ${JSON.stringify(entry.id)}: { default: toRuntimeRules(resolveModuleExport(${entry.name})) },`
+        );
+        continue;
+      }
+      lines.push(
+        `  ${JSON.stringify(entry.id)}: ${entry.name},`
+      );
+    }
+    lines.push("}", "");
+  }
+  const runtimeOptions = moduleEntries.length > 0 ? "{ manifest, moduleMap }" : "{ manifest }";
+  lines.push(
+    `const basePaths = ${JSON.stringify(basePaths)}`,
+    "",
+    "self.addEventListener('install', () => {",
+    "  self.skipWaiting()",
+    "})",
+    "",
+    "self.addEventListener('activate', (event) => {",
+    "  event.waitUntil(self.clients.claim())",
+    "})",
+    "",
+    "const shouldHandle = (request) => {",
+    "  if (!basePaths || basePaths.length === 0) {",
+    "    return true",
+    "  }",
+    "  const pathname = new URL(request.url).pathname",
+    "  return basePaths.some((basePath) => {",
+    "    if (basePath === '/') {",
+    "      return true",
+    "    }",
+    "    return pathname === basePath || pathname.startsWith(basePath + '/')",
+    "  })",
+    "}",
+    "",
+    "const registerHandler = async () => {",
+    `  const app = await createRuntimeApp(${runtimeOptions})`,
+    "  const handler = handle(app)",
+    "  self.addEventListener('fetch', (event) => {",
+    "    if (!shouldHandle(event.request)) {",
+    "      return",
+    "    }",
+    "    handler(event)",
+    "  })",
+    "}",
+    "",
+    "registerHandler().catch((error) => {",
+    "  console.error('[mokup] Failed to build service worker app:', error)",
+    "})",
+    ""
+  );
+  return lines.join("\n");
+}
+
+export { resolveSwConfig as a, resolveSwUnregisterConfig as b, createPlaygroundMiddleware as c, buildSwScript as d, createLogger as e, createMiddleware as f, createDebouncer as g, resolveDirs as h, isInDirs as i, sortRoutes as j, createHonoApp as k, resolvePlaygroundOptions as r, scanRoutes as s, toPosix as t };