@mokup/server 1.1.0 → 1.1.2

package/dist/fetch-server.cjs

@@ -0,0 +1,1507 @@
+'use strict';
+
+const process = require('node:process');
+const hono = require('@mokup/shared/hono');
+const pathe = require('@mokup/shared/pathe');
+const node_fs = require('node:fs');
+const node_module = require('node:module');
+const runtime = require('@mokup/runtime');
+const node_buffer = require('node:buffer');
+const node_url = require('node:url');
+const esbuild = require('@mokup/shared/esbuild');
+const jsoncParser = require('@mokup/shared/jsonc-parser');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+
+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"
+]);
+const configExtensions = [".ts", ".js", ".mjs", ".cjs"];
+
+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) => pathe.isAbsolute(entry) ? entry : pathe.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 normalizeIgnorePrefix(value, fallback = ["."]) {
+  const list = typeof value === "undefined" ? fallback : Array.isArray(value) ? value : [value];
+  return list.filter((entry) => typeof entry === "string" && entry.length > 0);
+}
+function hasIgnoredPrefix(file, rootDir, prefixes) {
+  if (prefixes.length === 0) {
+    return false;
+  }
+  const relativePath = toPosix(pathe.relative(rootDir, file));
+  const segments = relativePath.split("/");
+  return segments.some(
+    (segment) => prefixes.some((prefix) => segment.startsWith(prefix))
+  );
+}
+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 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, onResponse) {
+  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;
+    if (onResponse) {
+      try {
+        const result = onResponse(route, overridden);
+        if (result instanceof Promise) {
+          result.catch(() => void 0);
+        }
+      } catch {
+      }
+    }
+    return overridden;
+  };
+}
+function wrapMiddleware(handler) {
+  return async (c, next) => {
+    const response = await handler(c, next);
+    return resolveResponse(response, c.res);
+  };
+}
+function createHonoApp(routes, options = {}) {
+  const app = new hono.Hono({ router: new hono.PatternRouter(), strict: false });
+  for (const route of routes) {
+    const middlewares = route.middlewares?.map((entry) => wrapMiddleware(entry.handle)) ?? [];
+    app.on(
+      route.method,
+      toHonoPath(route),
+      createFinalizeMiddleware(route, options.onResponse),
+      ...middlewares,
+      createRouteHandler(route)
+    );
+  }
+  return app;
+}
+
+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 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 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 require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('fetch-server.cjs', document.baseURI).href)));
+  const pkgPath = require$1.resolve("@mokup/playground/package.json");
+  return pathe.join(pkgPath, "..", "dist");
+}
+function toPosixPath(value) {
+  return value.replace(/\\/g, "/");
+}
+function normalizePath(value) {
+  return toPosixPath(pathe.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 ?? process.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(pathe.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(pathe.dirname(common));
+      if (parent === common) {
+        break;
+      }
+      common = parent;
+    }
+  }
+  if (!common || common === "/") {
+    return serverRoot ?? process.cwd();
+  }
+  return common;
+}
+const disabledReasonSet = /* @__PURE__ */ new Set([
+  "disabled",
+  "disabled-dir",
+  "exclude",
+  "ignore-prefix",
+  "include",
+  "unknown"
+]);
+const ignoredReasonSet = /* @__PURE__ */ new Set([
+  "unsupported",
+  "invalid-route",
+  "unknown"
+]);
+function normalizeDisabledReason(reason) {
+  if (reason && disabledReasonSet.has(reason)) {
+    return reason;
+  }
+  return "unknown";
+}
+function normalizeIgnoredReason(reason) {
+  if (reason && ignoredReasonSet.has(reason)) {
+    return reason;
+  }
+  return "unknown";
+}
+function formatRouteFile(file, root) {
+  if (!root) {
+    return toPosixPath(file);
+  }
+  const rel = toPosixPath(pathe.relative(root, file));
+  if (!rel || rel.startsWith("..")) {
+    return toPosixPath(file);
+  }
+  return rel;
+}
+function resolveGroups(dirs, root) {
+  const groups = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const dir of dirs) {
+    const normalized = normalizePath(dir);
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    const rel = toPosixPath(pathe.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(pathe.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 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 (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;
+  }
+  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 registerPlaygroundRoutes(params) {
+  if (!params.config.enabled) {
+    return;
+  }
+  const playgroundPath = normalizePlaygroundPath(params.config.path);
+  const distDir = resolvePlaygroundDist();
+  const indexPath = pathe.join(distDir, "index.html");
+  const serveIndex = async () => {
+    try {
+      const html = await node_fs.promises.readFile(indexPath, "utf8");
+      const contentType = mimeTypes[".html"] ?? "text/html; charset=utf-8";
+      return new Response(html, { headers: { "Content-Type": contentType } });
+    } catch (error) {
+      params.logger.error("Failed to load playground index:", error);
+      return new Response("Playground is not available.", { status: 500 });
+    }
+  };
+  params.app.get(playgroundPath, (c) => {
+    try {
+      const pathname = new URL(c.req.raw.url, "http://localhost").pathname;
+      if (pathname.endsWith("/")) {
+        return serveIndex();
+      }
+    } catch {
+    }
+    return c.redirect(`${playgroundPath}/`);
+  });
+  params.app.get(`${playgroundPath}/`, () => serveIndex());
+  params.app.get(`${playgroundPath}/index.html`, () => serveIndex());
+  params.app.get(`${playgroundPath}/routes`, (c) => {
+    const baseRoot = resolveGroupRoot(params.dirs, params.root);
+    const groups = resolveGroups(params.dirs, baseRoot);
+    return c.json({
+      basePath: playgroundPath,
+      root: baseRoot,
+      count: params.routes.length,
+      groups: groups.map((group) => ({ key: group.key, label: group.label })),
+      routes: params.routes.map((route) => toPlaygroundRoute(route, baseRoot, groups)),
+      disabled: (params.disabledRoutes ?? []).map((route) => toPlaygroundDisabledRoute(route, baseRoot, groups)),
+      ignored: (params.ignoredRoutes ?? []).map((route) => toPlaygroundIgnoredRoute(route, baseRoot, groups)),
+      configs: (params.configFiles ?? []).map((entry) => toPlaygroundConfigFile(entry, baseRoot, groups)),
+      disabledConfigs: (params.disabledConfigFiles ?? []).map(
+        (entry) => toPlaygroundConfigFile(entry, baseRoot, groups)
+      )
+    });
+  });
+  params.app.get(`${playgroundPath}/*`, async (c) => {
+    const pathname = c.req.path;
+    const relPath = pathname.slice(playgroundPath.length).replace(/^\/+/, "");
+    if (!relPath || relPath === "/") {
+      return serveIndex();
+    }
+    if (relPath.includes("..")) {
+      return new Response("Invalid path.", { status: 400 });
+    }
+    const normalizedPath = pathe.normalize(relPath);
+    const filePath = pathe.join(distDir, normalizedPath);
+    try {
+      const content = await node_fs.promises.readFile(filePath);
+      const ext = pathe.extname(filePath);
+      const contentType = mimeTypes[ext] ?? "application/octet-stream";
+      return new Response(content, { headers: { "Content-Type": contentType } });
+    } catch {
+      return c.notFound();
+    }
+  });
+}
+
+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(pathe.relative(rootDir, file));
+  const ext = pathe.extname(rel);
+  const withoutExt = rel.slice(0, rel.length - ext.length);
+  const dir = pathe.dirname(withoutExt);
+  const base = pathe.basename(withoutExt);
+  const { name, method } = stripMethodSuffix(base);
+  const resolvedMethod = method ?? (jsonExtensions.has(ext) ? "GET" : void 0);
+  if (!resolvedMethod) {
+    logger.warn(`Skip mock without method suffix: ${file}`);
+    return null;
+  }
+  if (!name) {
+    logger.warn(`Skip mock with empty route name: ${file}`);
+    return null;
+  }
+  const joined = dir === "." ? name : pathe.join(dir, name);
+  const segments = toPosix(joined).split("/");
+  if (segments.at(-1) === "index") {
+    segments.pop();
+  }
+  const template = segments.length === 0 ? "/" : `/${segments.join("/")}`;
+  const parsed = runtime.parseRouteTemplate(template);
+  if (parsed.errors.length > 0) {
+    for (const error of parsed.errors) {
+      logger.warn(`${error} in ${file}`);
+    }
+    return null;
+  }
+  for (const warning of parsed.warnings) {
+    logger.warn(`${warning} in ${file}`);
+  }
+  return {
+    template: parsed.template,
+    method: resolvedMethod,
+    tokens: parsed.tokens,
+    score: parsed.score
+  };
+}
+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 = runtime.parseRouteTemplate(template);
+  if (parsed.errors.length > 0) {
+    for (const error of parsed.errors) {
+      params.logger.warn(`${error} in ${params.file}`);
+    }
+    return null;
+  }
+  for (const warning of parsed.warnings) {
+    params.logger.warn(`${warning} in ${params.file}`);
+  }
+  const route = {
+    file: params.file,
+    template: parsed.template,
+    method,
+    tokens: parsed.tokens,
+    score: parsed.score,
+    handler: params.rule.handler
+  };
+  if (typeof params.rule.status === "number") {
+    route.status = params.rule.status;
+  }
+  if (params.rule.headers) {
+    route.headers = params.rule.headers;
+  }
+  if (typeof params.rule.delay === "number") {
+    route.delay = params.rule.delay;
+  }
+  return route;
+}
+function sortRoutes(routes) {
+  return routes.sort((a, b) => {
+    if (a.method !== b.method) {
+      return a.method.localeCompare(b.method);
+    }
+    const scoreCompare = runtime.compareRouteScore(a.score, b.score);
+    if (scoreCompare !== 0) {
+      return scoreCompare;
+    }
+    return a.template.localeCompare(b.template);
+  });
+}
+
+let registerPromise = null;
+let hasLoggedFailure = false;
+async function ensureTsxRegister(logger) {
+  if (registerPromise) {
+    return registerPromise;
+  }
+  registerPromise = (async () => {
+    try {
+      const mod = await import('tsx/esm/api');
+      const setSourceMapsEnabled = process__default.setSourceMapsEnabled;
+      if (typeof setSourceMapsEnabled === "function") {
+        setSourceMapsEnabled(true);
+      }
+      if (typeof mod.register === "function") {
+        mod.register();
+      }
+      return true;
+    } catch (error) {
+      if (!hasLoggedFailure && logger) {
+        logger.warn(
+          "Failed to register tsx loader; falling back to bundled TS loader.",
+          error
+        );
+        hasLoggedFailure = true;
+      }
+      return false;
+    }
+  })();
+  return registerPromise;
+}
+
+function isUnknownFileExtensionError$1(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const code = error.code;
+  if (code === "ERR_UNKNOWN_FILE_EXTENSION") {
+    return true;
+  }
+  const message = error.message;
+  return typeof message === "string" && message.includes("Unknown file extension");
+}
+async function loadTsModule$1(file, logger) {
+  const cacheBust = Date.now();
+  const fileUrl = `${node_url.pathToFileURL(file).href}?t=${cacheBust}`;
+  const registered = await ensureTsxRegister(logger);
+  if (registered) {
+    try {
+      return await import(fileUrl);
+    } catch (error) {
+      if (!isUnknownFileExtensionError$1(error)) {
+        throw error;
+      }
+    }
+  }
+  const result = await esbuild.build({
+    entryPoints: [file],
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    sourcemap: "inline",
+    target: "es2020",
+    write: false
+  });
+  const output = result.outputFiles[0];
+  const code = output?.text ?? "";
+  const dataUrl = `data:text/javascript;base64,${node_buffer.Buffer.from(code).toString(
+    "base64"
+  )}`;
+  return import(`${dataUrl}#${cacheBust}`);
+}
+async function loadModule$1(file, logger) {
+  const ext = configExtensions.find((extension) => file.endsWith(extension));
+  if (ext === ".cjs") {
+    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('fetch-server.cjs', document.baseURI).href)));
+    delete require$1.cache[file];
+    return require$1(file);
+  }
+  if (ext === ".js" || ext === ".mjs") {
+    return import(`${node_url.pathToFileURL(file).href}?t=${Date.now()}`);
+  }
+  if (ext === ".ts") {
+    return loadTsModule$1(file, logger);
+  }
+  return null;
+}
+function getConfigFileCandidates(dir) {
+  return configExtensions.map((extension) => pathe.join(dir, `index.config${extension}`));
+}
+async function findConfigFile(dir, cache) {
+  const cached = cache.get(dir);
+  if (cached !== void 0) {
+    return cached;
+  }
+  for (const candidate of getConfigFileCandidates(dir)) {
+    try {
+      await node_fs.promises.stat(candidate);
+      cache.set(dir, candidate);
+      return candidate;
+    } catch {
+      continue;
+    }
+  }
+  cache.set(dir, null);
+  return null;
+}
+async function loadConfig(file, logger) {
+  const mod = await loadModule$1(file, logger);
+  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, logger, configCache, fileCache } = params;
+  const resolvedRoot = pathe.normalize(rootDir);
+  const resolvedFileDir = pathe.normalize(pathe.dirname(file));
+  const chain = [];
+  let current = resolvedFileDir;
+  while (true) {
+    chain.push(current);
+    if (current === resolvedRoot) {
+      break;
+    }
+    const parent = pathe.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  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, logger);
+      configCache.set(configPath, config);
+    }
+    if (!config) {
+      logger.warn(`Invalid config in ${configPath}`);
+      continue;
+    }
+    if (config.headers) {
+      merged.headers = { ...merged.headers ?? {}, ...config.headers };
+    }
+    if (typeof config.status === "number") {
+      merged.status = config.status;
+    }
+    if (typeof config.delay === "number") {
+      merged.delay = config.delay;
+    }
+    if (typeof config.enabled === "boolean") {
+      merged.enabled = config.enabled;
+    }
+    if (typeof config.ignorePrefix !== "undefined") {
+      merged.ignorePrefix = config.ignorePrefix;
+    }
+    if (typeof config.include !== "undefined") {
+      merged.include = config.include;
+    }
+    if (typeof config.exclude !== "undefined") {
+      merged.exclude = config.exclude;
+    }
+    const normalized = normalizeMiddlewares(config.middleware, configPath, logger);
+    if (normalized.length > 0) {
+      merged.middlewares.push(...normalized);
+    }
+  }
+  return merged;
+}
+
+async function walkDir(dir, rootDir, files) {
+  const entries = await node_fs.promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === ".git") {
+      continue;
+    }
+    const fullPath = pathe.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkDir(fullPath, rootDir, files);
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push({ file: fullPath, rootDir });
+    }
+  }
+}
+async function exists(path) {
+  try {
+    await node_fs.promises.stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function collectFiles(dirs) {
+  const files = [];
+  for (const dir of dirs) {
+    if (!await exists(dir)) {
+      continue;
+    }
+    await walkDir(dir, dir, files);
+  }
+  return files;
+}
+function isSupportedFile(file) {
+  if (file.endsWith(".d.ts")) {
+    return false;
+  }
+  if (isConfigFile(file)) {
+    return false;
+  }
+  const ext = pathe.extname(file).toLowerCase();
+  return supportedExtensions.has(ext);
+}
+function isConfigFile(file) {
+  if (file.endsWith(".d.ts")) {
+    return false;
+  }
+  const base = pathe.basename(file);
+  if (!base.startsWith("index.config.")) {
+    return false;
+  }
+  const ext = pathe.extname(file).toLowerCase();
+  return configExtensions.includes(ext);
+}
+
+function isUnknownFileExtensionError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const code = error.code;
+  if (code === "ERR_UNKNOWN_FILE_EXTENSION") {
+    return true;
+  }
+  const message = error.message;
+  return typeof message === "string" && message.includes("Unknown file extension");
+}
+async function loadTsModule(file, logger) {
+  const cacheBust = Date.now();
+  const fileUrl = `${node_url.pathToFileURL(file).href}?t=${cacheBust}`;
+  const registered = await ensureTsxRegister(logger);
+  if (registered) {
+    try {
+      return await import(fileUrl);
+    } catch (error) {
+      if (!isUnknownFileExtensionError(error)) {
+        throw error;
+      }
+    }
+  }
+  const result = await esbuild.build({
+    entryPoints: [file],
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    sourcemap: "inline",
+    target: "es2020",
+    write: false
+  });
+  const output = result.outputFiles[0];
+  const code = output?.text ?? "";
+  const dataUrl = `data:text/javascript;base64,${node_buffer.Buffer.from(code).toString(
+    "base64"
+  )}`;
+  return import(`${dataUrl}#${cacheBust}`);
+}
+async function loadModule(file, logger) {
+  const ext = pathe.extname(file).toLowerCase();
+  if (ext === ".cjs") {
+    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('fetch-server.cjs', document.baseURI).href)));
+    delete require$1.cache[file];
+    return require$1(file);
+  }
+  if (ext === ".js" || ext === ".mjs") {
+    return import(`${node_url.pathToFileURL(file).href}?t=${Date.now()}`);
+  }
+  if (ext === ".ts") {
+    return loadTsModule(file, logger);
+  }
+  return null;
+}
+async function readJsonFile(file, logger) {
+  try {
+    const content = await node_fs.promises.readFile(file, "utf8");
+    const errors = [];
+    const data = jsoncParser.parse(content, errors, {
+      allowTrailingComma: true,
+      disallowComments: false
+    });
+    if (errors.length > 0) {
+      logger.warn(`Invalid JSONC in ${file}`);
+      return void 0;
+    }
+    return data;
+  } catch (error) {
+    logger.warn(`Failed to read ${file}: ${String(error)}`);
+    return void 0;
+  }
+}
+async function loadRules(file, logger) {
+  const ext = pathe.extname(file).toLowerCase();
+  if (ext === ".json" || ext === ".jsonc") {
+    const json = await readJsonFile(file, logger);
+    if (typeof json === "undefined") {
+      return [];
+    }
+    return [
+      {
+        handler: json
+      }
+    ];
+  }
+  const mod = await loadModule(file, logger);
+  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: () => {
+  }
+};
+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) {
+  const info = { file, reason };
+  if (resolved) {
+    info.method = resolved.method;
+    info.url = resolved.url;
+  }
+  return info;
+}
+async function scanRoutes(params) {
+  const routes = [];
+  const seen = /* @__PURE__ */ new Set();
+  const files = await collectFiles(params.dirs);
+  const globalIgnorePrefix = normalizeIgnorePrefix(params.ignorePrefix);
+  const configCache = /* @__PURE__ */ new Map();
+  const fileCache = /* @__PURE__ */ new Map();
+  const shouldCollectSkip = typeof params.onSkip === "function";
+  const shouldCollectIgnore = typeof params.onIgnore === "function";
+  const shouldCollectConfig = typeof params.onConfig === "function";
+  for (const fileInfo of files) {
+    if (isConfigFile(fileInfo.file)) {
+      if (shouldCollectConfig) {
+        const config2 = await resolveDirectoryConfig({
+          file: fileInfo.file,
+          rootDir: fileInfo.rootDir,
+          logger: params.logger,
+          configCache,
+          fileCache
+        });
+        params.onConfig?.({ file: fileInfo.file, enabled: config2.enabled !== false });
+      }
+      continue;
+    }
+    const config = await resolveDirectoryConfig({
+      file: fileInfo.file,
+      rootDir: fileInfo.rootDir,
+      logger: params.logger,
+      configCache,
+      fileCache
+    });
+    if (config.enabled === false) {
+      if (shouldCollectSkip && isSupportedFile(fileInfo.file)) {
+        const resolved = resolveSkipRoute({
+          file: fileInfo.file,
+          rootDir: fileInfo.rootDir,
+          prefix: params.prefix
+        });
+        params.onSkip?.(buildSkipInfo(fileInfo.file, "disabled-dir", resolved));
+      }
+      continue;
+    }
+    const effectiveIgnorePrefix = typeof config.ignorePrefix !== "undefined" ? normalizeIgnorePrefix(config.ignorePrefix, []) : globalIgnorePrefix;
+    if (hasIgnoredPrefix(fileInfo.file, fileInfo.rootDir, effectiveIgnorePrefix)) {
+      if (shouldCollectSkip && isSupportedFile(fileInfo.file)) {
+        const resolved = resolveSkipRoute({
+          file: fileInfo.file,
+          rootDir: fileInfo.rootDir,
+          prefix: params.prefix
+        });
+        params.onSkip?.(buildSkipInfo(fileInfo.file, "ignore-prefix", resolved));
+      }
+      continue;
+    }
+    if (!isSupportedFile(fileInfo.file)) {
+      if (shouldCollectIgnore) {
+        params.onIgnore?.({ file: fileInfo.file, reason: "unsupported" });
+      }
+      continue;
+    }
+    const effectiveInclude = typeof config.include !== "undefined" ? config.include : params.include;
+    const effectiveExclude = typeof config.exclude !== "undefined" ? config.exclude : params.exclude;
+    if (!matchesFilter(fileInfo.file, effectiveInclude, effectiveExclude)) {
+      if (shouldCollectSkip) {
+        const resolved = resolveSkipRoute({
+          file: fileInfo.file,
+          rootDir: fileInfo.rootDir,
+          prefix: params.prefix
+        });
+        const reason = effectiveExclude && matchesFilter(fileInfo.file, void 0, effectiveExclude) ? "exclude" : "include";
+        params.onSkip?.(buildSkipInfo(fileInfo.file, reason, resolved));
+      }
+      continue;
+    }
+    const derived = deriveRouteFromFile(fileInfo.file, fileInfo.rootDir, params.logger);
+    if (!derived) {
+      if (shouldCollectIgnore) {
+        params.onIgnore?.({ file: fileInfo.file, reason: "invalid-route" });
+      }
+      continue;
+    }
+    const rules = await loadRules(fileInfo.file, params.logger);
+    for (const [index, rule] of rules.entries()) {
+      if (!rule || typeof rule !== "object") {
+        continue;
+      }
+      if (rule.enabled === false) {
+        if (shouldCollectSkip) {
+          const resolved2 = resolveSkipRoute({
+            file: fileInfo.file,
+            rootDir: fileInfo.rootDir,
+            prefix: params.prefix,
+            derived
+          });
+          params.onSkip?.(buildSkipInfo(fileInfo.file, "disabled", resolved2));
+        }
+        continue;
+      }
+      const ruleValue = rule;
+      const unsupportedKeys = ["response", "url", "method"].filter(
+        (key2) => key2 in ruleValue
+      );
+      if (unsupportedKeys.length > 0) {
+        params.logger.warn(
+          `Skip mock with unsupported fields (${unsupportedKeys.join(", ")}): ${fileInfo.file}`
+        );
+        continue;
+      }
+      if (typeof rule.handler === "undefined") {
+        params.logger.warn(`Skip mock without handler: ${fileInfo.file}`);
+        continue;
+      }
+      const resolved = resolveRule({
+        rule,
+        derivedTemplate: derived.template,
+        derivedMethod: derived.method,
+        prefix: params.prefix,
+        file: fileInfo.file,
+        logger: params.logger
+      });
+      if (!resolved) {
+        continue;
+      }
+      resolved.ruleIndex = index;
+      if (config.headers) {
+        resolved.headers = { ...config.headers, ...resolved.headers ?? {} };
+      }
+      if (typeof resolved.status === "undefined" && typeof config.status === "number") {
+        resolved.status = config.status;
+      }
+      if (typeof resolved.delay === "undefined" && typeof config.delay === "number") {
+        resolved.delay = config.delay;
+      }
+      if (config.middlewares.length > 0) {
+        resolved.middlewares = config.middlewares;
+      }
+      const key = `${resolved.method} ${resolved.template}`;
+      if (seen.has(key)) {
+        params.logger.warn(`Duplicate mock route ${key} from ${fileInfo.file}`);
+      }
+      seen.add(key);
+      routes.push(resolved);
+    }
+  }
+  return sortRoutes(routes);
+}
+
+function normalizeEntries(entries) {
+  const list = Array.isArray(entries) ? entries : entries ? [entries] : [{}];
+  return list.length > 0 ? list : [{}];
+}
+function normalizeOptions(options) {
+  return {
+    entries: normalizeEntries(options.entries),
+    playground: options.playground
+  };
+}
+function resolveFirst(list, getter) {
+  for (const entry of list) {
+    const value = getter(entry);
+    if (typeof value !== "undefined") {
+      return value;
+    }
+  }
+  return void 0;
+}
+function resolveRoot(list) {
+  const explicit = resolveFirst(list, (entry) => entry.root);
+  if (explicit) {
+    return explicit;
+  }
+  const deno = globalThis.Deno;
+  if (deno?.cwd) {
+    return deno.cwd();
+  }
+  return process.cwd();
+}
+function resolveAllDirs(list, root) {
+  const dirs = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of list) {
+    for (const dir of resolveDirs(entry.dir, root)) {
+      if (seen.has(dir)) {
+        continue;
+      }
+      seen.add(dir);
+      dirs.push(dir);
+    }
+  }
+  return dirs;
+}
+function buildApp(params) {
+  const app = new hono.Hono({ strict: false });
+  registerPlaygroundRoutes({
+    app,
+    routes: params.routes,
+    disabledRoutes: params.disabledRoutes,
+    ignoredRoutes: params.ignoredRoutes,
+    configFiles: params.configFiles,
+    disabledConfigFiles: params.disabledConfigFiles,
+    dirs: params.dirs,
+    logger: params.logger,
+    config: params.playground,
+    root: params.root
+  });
+  if (params.wsHandler && params.playground.enabled) {
+    app.get(`${params.playground.path}/ws`, params.wsHandler);
+  }
+  if (params.routes.length > 0) {
+    const mockAppOptions = params.onResponse ? { onResponse: params.onResponse } : {};
+    const mockApp = createHonoApp(params.routes, mockAppOptions);
+    app.route("/", mockApp);
+  }
+  return app;
+}
+async function createDenoWatcher(params) {
+  const deno = globalThis.Deno;
+  if (!deno?.watchFs) {
+    return null;
+  }
+  const watcher = deno.watchFs(params.dirs, { recursive: true });
+  let closed = false;
+  (async () => {
+    try {
+      for await (const event of watcher) {
+        if (closed) {
+          break;
+        }
+        if (event.kind === "access") {
+          continue;
+        }
+        params.onChange();
+      }
+    } catch (error) {
+      if (!closed) {
+        params.logger.warn("Watcher failed:", error);
+      }
+    }
+  })();
+  return {
+    close: async () => {
+      closed = true;
+      watcher.close();
+    }
+  };
+}
+async function createChokidarWatcher(params) {
+  try {
+    const { default: chokidar } = await import('@mokup/shared/chokidar');
+    const watcher = chokidar.watch(params.dirs, { ignoreInitial: true });
+    watcher.on("add", (file) => {
+      if (isInDirs(file, params.dirs)) {
+        params.onChange();
+      }
+    });
+    watcher.on("change", (file) => {
+      if (isInDirs(file, params.dirs)) {
+        params.onChange();
+      }
+    });
+    watcher.on("unlink", (file) => {
+      if (isInDirs(file, params.dirs)) {
+        params.onChange();
+      }
+    });
+    return {
+      close: async () => {
+        await watcher.close();
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+async function createWatcher(params) {
+  if (!params.enabled || params.dirs.length === 0) {
+    return null;
+  }
+  const denoWatcher = await createDenoWatcher(params);
+  if (denoWatcher) {
+    return denoWatcher;
+  }
+  const chokidarWatcher = await createChokidarWatcher(params);
+  if (chokidarWatcher) {
+    return chokidarWatcher;
+  }
+  params.logger.warn("Watcher is not available in this runtime; file watching disabled.");
+  return null;
+}
+async function createFetchServer(options = {}) {
+  const normalized = normalizeOptions(options);
+  const optionList = normalized.entries;
+  const root = resolveRoot(optionList);
+  const logEnabled = optionList.every((entry) => entry.log !== false);
+  const watchEnabled = optionList.every((entry) => entry.watch !== false);
+  const logger = createLogger(logEnabled);
+  const playgroundConfig = resolvePlaygroundOptions(normalized.playground);
+  const dirs = resolveAllDirs(optionList, root);
+  const routeCounts = {};
+  const wsClients = /* @__PURE__ */ new Set();
+  let totalCount = 0;
+  let wsHandler;
+  let injectWebSocket;
+  function getRouteKey(route) {
+    return `${route.method} ${route.template}`;
+  }
+  function buildSnapshot() {
+    return {
+      type: "snapshot",
+      total: totalCount,
+      perRoute: { ...routeCounts }
+    };
+  }
+  function broadcast(payload) {
+    if (wsClients.size === 0) {
+      return;
+    }
+    const message = JSON.stringify(payload);
+    for (const client of wsClients) {
+      try {
+        client.send(message);
+      } catch {
+        wsClients.delete(client);
+      }
+    }
+  }
+  function registerWsClient(client) {
+    wsClients.add(client);
+    try {
+      client.send(JSON.stringify(buildSnapshot()));
+    } catch {
+      wsClients.delete(client);
+    }
+  }
+  function handleRouteResponse(route) {
+    const routeKey = getRouteKey(route);
+    routeCounts[routeKey] = (routeCounts[routeKey] ?? 0) + 1;
+    totalCount += 1;
+    broadcast({ type: "increment", routeKey, total: totalCount });
+  }
+  async function setupPlaygroundWebSocket(app2) {
+    if (!playgroundConfig.enabled) {
+      return;
+    }
+    try {
+      const mod = await import('@hono/node-ws');
+      const { createNodeWebSocket } = mod;
+      const { upgradeWebSocket, injectWebSocket: inject } = createNodeWebSocket({ app: app2 });
+      wsHandler = upgradeWebSocket(() => ({
+        onOpen: (_event, ws) => {
+          registerWsClient(ws);
+        },
+        onClose: (_event, ws) => {
+          wsClients.delete(ws);
+        },
+        onMessage: () => {
+        }
+      }));
+      injectWebSocket = (server2) => {
+        inject(server2);
+      };
+    } catch {
+    }
+  }
+  let routes = [];
+  let disabledRoutes = [];
+  let ignoredRoutes = [];
+  let configFiles = [];
+  let disabledConfigFiles = [];
+  let app = buildApp({
+    routes,
+    disabledRoutes,
+    ignoredRoutes,
+    configFiles,
+    disabledConfigFiles,
+    dirs,
+    playground: playgroundConfig,
+    root,
+    logger,
+    onResponse: handleRouteResponse,
+    ...wsHandler ? { wsHandler } : {}
+  });
+  const refreshRoutes = async () => {
+    try {
+      const collected = [];
+      const collectedDisabled = [];
+      const collectedIgnored = [];
+      const collectedConfigs = [];
+      for (const entry of optionList) {
+        const scanParams = {
+          dirs: resolveDirs(entry.dir, root),
+          prefix: entry.prefix ?? "",
+          logger,
+          onSkip: (info) => collectedDisabled.push(info),
+          onIgnore: (info) => collectedIgnored.push(info),
+          onConfig: (info) => collectedConfigs.push(info)
+        };
+        if (entry.include) {
+          scanParams.include = entry.include;
+        }
+        if (entry.exclude) {
+          scanParams.exclude = entry.exclude;
+        }
+        if (typeof entry.ignorePrefix !== "undefined") {
+          scanParams.ignorePrefix = entry.ignorePrefix;
+        }
+        const scanned = await scanRoutes(scanParams);
+        collected.push(...scanned);
+      }
+      const resolvedRoutes = sortRoutes(collected);
+      routes = resolvedRoutes;
+      disabledRoutes = collectedDisabled;
+      ignoredRoutes = collectedIgnored;
+      const configMap = new Map(collectedConfigs.map((entry) => [entry.file, entry]));
+      const resolvedConfigs = Array.from(configMap.values());
+      configFiles = resolvedConfigs.filter((entry) => entry.enabled);
+      disabledConfigFiles = resolvedConfigs.filter((entry) => !entry.enabled);
+      app = buildApp({
+        routes,
+        disabledRoutes,
+        ignoredRoutes,
+        configFiles,
+        disabledConfigFiles,
+        dirs,
+        playground: playgroundConfig,
+        root,
+        logger,
+        onResponse: handleRouteResponse,
+        ...wsHandler ? { wsHandler } : {}
+      });
+      logger.info(`Loaded ${routes.length} mock routes.`);
+    } catch (error) {
+      logger.error("Failed to scan mock routes:", error);
+    }
+  };
+  await refreshRoutes();
+  await setupPlaygroundWebSocket(app);
+  if (wsHandler && playgroundConfig.enabled) {
+    app.get(`${playgroundConfig.path}/ws`, wsHandler);
+  }
+  const scheduleRefresh = createDebouncer(80, () => {
+    void refreshRoutes();
+  });
+  const watcher = await createWatcher({
+    enabled: watchEnabled,
+    dirs,
+    onChange: scheduleRefresh,
+    logger
+  });
+  const fetch = async (request) => await app.fetch(request);
+  const server = {
+    fetch,
+    refresh: refreshRoutes,
+    getRoutes: () => routes,
+    ...injectWebSocket ? { injectWebSocket } : {}
+  };
+  if (watcher) {
+    server.close = async () => {
+      await watcher.close();
+    };
+  }
+  return server;
+}
+
+exports.createFetchServer = createFetchServer;