@jaredwray/mockhttp 0.6.0 → 0.7.0

package/dist/index.js

@@ -6,152 +6,13 @@ import process from "process";
 
 // src/mock-http.ts
 import path from "path";
-import fastifyStatic from "@fastify/static";
+import fastifyCookie from "@fastify/cookie";
 import fastifyHelmet from "@fastify/helmet";
+import fastifyStatic from "@fastify/static";
 import { fastifySwagger } from "@fastify/swagger";
-import fastifyCookie from "@fastify/cookie";
+import { detect } from "detect-port";
 import Fastify from "fastify";
 import { Hookified } from "hookified";
-import { detect } from "detect-port";
-
-// src/swagger.ts
-import { fastifySwaggerUi } from "@fastify/swagger-ui";
-
-// package.json
-var package_default = {
-  name: "@jaredwray/mockhttp",
-  version: "0.6.0",
-  description: "Mock Http - Easy way to mock http with httpbin replacement",
-  type: "module",
-  main: "dist/index.js",
-  directories: {
-    test: "test"
-  },
-  scripts: {
-    test: "xo --fix && vitest run --coverage",
-    dev: "xo --fix && tsx src/index.ts --watch",
-    build: "rimraf ./dist && tsup src/index.ts --format esm --dts --clean",
-    "docker:build": "docker build -t jaredwray/mockhttp .",
-    "docker:run": "docker run -p 3000:3000 jaredwray/mockhttp",
-    "docker:push": "docker push jaredwray/mockhttp",
-    "docker:stop": 'docker stop $(docker ps -a -q --filter ancestor=jaredwray/mockhttp --format="{{.ID}}")',
-    "docker:readme": "tsx ./scripts/create-docker-readme.ts",
-    "docker:compose:up": "docker-compose up -d",
-    "docker:compose:down": "docker-compose down",
-    prepare: "pnpm run build",
-    start: "node dist/index.js"
-  },
-  repository: {
-    type: "git",
-    url: "git+https://github.com/jaredwray/mockhttp.git"
-  },
-  keywords: [
-    "mock",
-    "http",
-    "httpbin",
-    "test"
-  ],
-  author: "Jared Wray <me@jaredwray.com>",
-  license: "MIT",
-  bugs: {
-    url: "https://github.com/jaredwray/mockhttp/issues"
-  },
-  homepage: "https://github.com/jaredwray/mockhttp#readme",
-  devDependencies: {
-    "@swc/core": "^1.12.1",
-    "@types/html-escaper": "^3.0.4",
-    "@vitest/coverage-v8": "^3.2.3",
-    rimraf: "^6.0.1",
-    tsup: "^8.5.0",
-    tsx: "^4.20.3",
-    typescript: "^5.8.3",
-    vitest: "^3.2.3",
-    xo: "^1.1.0"
-  },
-  dependencies: {
-    "@fastify/cookie": "^11.0.2",
-    "@fastify/helmet": "^13.0.1",
-    "@fastify/static": "^8.2.0",
-    "@fastify/swagger": "^9.5.1",
-    "@fastify/swagger-ui": "^5.2.3",
-    "@scalar/api-reference": "^1.31.11",
-    "detect-port": "^2.1.0",
-    fastify: "^5.4.0",
-    hookified: "^1.9.1",
-    "html-escaper": "^3.0.3",
-    pino: "^9.7.0",
-    "pino-pretty": "^13.0.0"
-  },
-  files: [
-    "dist",
-    "public",
-    "LICENCE"
-  ],
-  pnpm: {
-    onlyBuiltDependencies: [
-      "@swc/core",
-      "esbuild",
-      "unrs-resolver",
-      "vue-demi"
-    ]
-  },
-  xo: {
-    rules: {
-      "@typescript-eslint/no-unsafe-call": "off",
-      "@typescript-eslint/no-unsafe-assignment": "off"
-    }
-  }
-};
-
-// src/swagger.ts
-var description = `
-A simple HTTP server that can be used to mock HTTP responses for testing purposes. Inspired by [httpbin](https://httpbin.org/) and built using \`nodejs\` and \`fastify\` with the idea of running it via https://mockhttp.org, via docker \`jaredwray/mockhttp\`, or nodejs \`npm install jaredwray/mockhttp\`.
-
-* [GitHub Repository](https://github.com/jaredwray/mockhttp)
-* [Docker Image](https://hub.docker.com/r/jaredwray/mockhttp)
-* [NPM Package](https://www.npmjs.com/package/jaredwray/mockhttp)
-
-# About mockhttp.org 
-
-[mockhttp.org](https://mockhttp.org) is a free service that runs this codebase and allows you to use it for testing purposes. It is a simple way to mock HTTP responses for testing purposes. Ran via [Cloudflare](https://cloudflare.com) and [Google Cloud Run](https://cloud.google.com/run/) across 7 regions globally and can do millions of requests per second.
-`;
-var fastifySwaggerConfig = {
-  openapi: {
-    info: {
-      title: "Mock HTTP API",
-      description,
-      version: package_default.version
-    },
-    consumes: [
-      "application/json"
-    ],
-    produces: [
-      "application/json"
-    ]
-  }
-};
-var registerSwaggerUi = /* @__PURE__ */ __name(async (fastify) => {
-  await fastify.register(fastifySwaggerUi, {
-    routePrefix: "/docs",
-    uiConfig: {
-      docExpansion: "none",
-      deepLinking: false
-    },
-    uiHooks: {
-      /* c8 ignore next 6 */
-      onRequest(_request, _reply, next) {
-        next();
-      },
-      preHandler(_request, _reply, next) {
-        next();
-      }
-    },
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    staticCSP: true,
-    transformSpecification: /* @__PURE__ */ __name((swaggerObject, _request, _reply) => swaggerObject, "transformSpecification"),
-    transformSpecificationClone: true
-  });
-}, "registerSwaggerUi");
 
 // src/fastify-config.ts
 var fastifyConfig = {
@@ -168,949 +29,1017 @@ var fastifyConfig = {
   }
 };
 
-// src/routes/index.ts
-var indexRoute = /* @__PURE__ */ __name((fastify) => {
-  fastify.get("/", {
-    schema: {
-      hide: true
-    }
-  }, async (_request, reply) => {
-    const redocHtml = `
-	<!doctype html>
-<html>
-  <head>
-    <title>{ mockhttp }</title>
-    <meta charset="utf-8" />
-    <meta
-      name="viewport"
-      content="width=device-width, initial-scale=1" />
-      <style>
-      :root {
-  --scalar-custom-header-height: 70px;
-}
-.custom-header {
-  height: var(--scalar-custom-header-height);
-  background-color: var(--scalar-background-1);
-  box-shadow: inset 0 -1px 0 var(--scalar-border-color);
-  color: var(--scalar-color-1);
-  font-size: var(--scalar-font-size-2);
-  padding: 0 18px;
-  position: sticky;
-  justify-content: space-between;
-  top: 0;
-  z-index: 100;
-}
-.custom-header,
-.custom-header nav {
-  display: flex;
-  align-items: center;
-  gap: 18px;
-}
-
-.custom-header img {
-  height: var(--scalar-custom-header-height);
-  object-fit: contain;
-}
-
-.custom-header a:hover {
-  color: var(--scalar-color-2);
-}
-
-.github-corner {
-  fill: var(--scalar-border-color) !important;
-}
-
-      </style>
-  </head>
-  <body>
-  <header class="custom-header scalar-app">
-    <a href="/"><img src="/logo.svg" alt="{ mockhttp }" /></a>
-    <a href="https://github.com/jaredwray/mockhttp" class="github-corner" aria-label="View source on GitHub">
-      <svg width="70" height="70" viewBox="0 0 250 250" style="color:#fff; position: absolute; top: 0; border: 0; right: 0;" aria-hidden="true">
-      <path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path>
-      <path d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2" fill="currentColor" style="transform-origin: 130px 106px;" class="octo-arm"></path>
-      <path d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z" fill="currentColor" class="octo-body"></path></svg></a><style>.github-corner:hover .octo-arm{animation:octocat-wave 560ms ease-in-out}@keyframes octocat-wave{0%,100%{transform:rotate(0)}20%,60%{transform:rotate(-25deg)}40%,80%{transform:rotate(10deg)}}@media (max-width:500px){.github-corner:hover .octo-arm{animation:none}.github-corner .octo-arm{animation:octocat-wave 560ms ease-in-out}}</style>
-  </header>
-
-    <script
-      id="api-reference"
-      data-url="/docs/json"></script>
-
-    <script src="/scalar/browser/standalone.js"></script>
-  </body>
-</html>
-`;
-    await reply.type("text/html").send(redocHtml);
-  });
-}, "indexRoute");
-
-// src/routes/sitemap.ts
-var sitemapRoute = /* @__PURE__ */ __name((fastify) => {
-  fastify.get("/sitemap.xml", {
-    schema: {
-      hide: true
-    }
-  }, async (_request, reply) => {
-    try {
-      const host = _request.headers.host ?? "mockhttp.org";
-      const isSecure = _request.headers["x-forwarded-proto"]?.includes("https");
-      const protocol = isSecure ? "https" : "http";
-      const xml = `<?xml version="1.0" encoding="UTF-8"?>
-                            <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-                                <url>
-                                    <loc>${protocol}://${host}/</loc>
-                                    <changefreq>monthly</changefreq>
-                                    <priority>1.0</priority>
-                                </url>
-                        </urlset>`;
-      await reply.type("text/xml").send(xml);
-    } catch (error) {
-      fastify.log.error(error);
-      await reply.status(500).send({
-        error: "Internal Server Error"
-      });
-    }
-  });
-}, "sitemapRoute");
-
-// src/routes/http-methods/get.ts
-var getSchema = {
-  description: "Returns request information for GET requests",
+// src/routes/anything/index.ts
+var anythingSchema = {
+  description: "Will return anything that you send it",
   tags: [
-    "HTTP Methods"
+    "Anything"
   ],
-  querystring: {
-    type: "object",
-    additionalProperties: true,
-    properties: {},
-    description: "Query parameters sent in the request"
-  },
-  headers: {
-    type: "object",
-    additionalProperties: true,
-    properties: {},
-    description: "Headers sent in the request"
-  },
   response: {
-    // eslint-disable-next-line  @typescript-eslint/naming-convention
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     200: {
       type: "object",
       properties: {
-        method: {
-          type: "string"
-        },
-        headers: {
+        // Echo back all your params under `args`
+        args: {
           type: "object",
-          additionalProperties: {
-            type: "string"
-          }
+          description: "Route parameters",
+          additionalProperties: true
         },
-        queryParams: {
+        // Echo back whatever was in the request.body
+        data: {
           type: "object",
-          additionalProperties: {
-            type: "string"
-          }
-        }
-      },
-      required: [
-        "method",
-        "headers",
-        "queryParams"
-      ]
-    }
-  }
-};
-var getRoute = /* @__PURE__ */ __name((fastify) => {
-  fastify.get("/get", {
-    schema: getSchema
-  }, async (request, _reply) => ({
-    method: "GET",
-    headers: request.headers,
-    queryParams: request.query
-  }));
-}, "getRoute");
-
-// src/routes/http-methods/post.ts
-var postSchema = {
-  description: "Handles a POST request and returns request information",
-  tags: [
-    "HTTP Methods"
-  ],
-  body: {
-    type: "object",
-    additionalProperties: true,
-    description: "The body of the POST request"
-  },
-  response: {
-    // eslint-disable-next-line  @typescript-eslint/naming-convention
-    200: {
-      type: "object",
-      properties: {
-        method: {
-          type: "string"
+          description: "Request body data",
+          additionalProperties: true
+        },
+        // If you’re using fastify-multipart, you’ll get
+        // files via request.files(); this just allows
+        // you to mirror them back
+        files: {
+          type: "object",
+          description: "Uploaded files",
+          additionalProperties: true
+        },
+        // If you parse application/x-www-form-urlencoded
+        // these fields land in request.body too, but you can
+        // mirror them separately if you like
+        form: {
+          type: "object",
+          description: "Form data",
+          additionalProperties: true
         },
         headers: {
           type: "object",
-          additionalProperties: {
-            type: "string"
-          }
+          description: "Request headers",
+          additionalProperties: true
         },
-        body: {
+        json: {
           type: "object",
+          description: "Parsed JSON body",
           additionalProperties: true
+        },
+        method: {
+          type: "string",
+          description: "HTTP method used"
+        },
+        origin: {
+          type: "string",
+          description: "Origin of the request"
+        },
+        url: {
+          type: "string",
+          description: "Request URL"
         }
       },
-      required: [
-        "method",
-        "headers",
-        "body"
-      ]
+      // Don’t allow any other top-level keys in your response
+      additionalProperties: false
     }
   }
 };
-var postRoute = /* @__PURE__ */ __name((fastify) => {
-  fastify.post("/post", {
-    schema: postSchema
-  }, async (request) => ({
-    method: "POST",
-    headers: request.headers,
-    body: request.body
-  }));
-}, "postRoute");
+var anythingRoute = /* @__PURE__ */ __name((fastify) => {
+  const handler = /* @__PURE__ */ __name(async (request, reply) => {
+    const response = {
+      args: request.query,
+      data: request.body ?? {},
+      // biome-ignore lint/suspicious/noExplicitAny: expected
+      files: request.raw?.files ?? {},
+      form: request.body ?? {},
+      headers: request.headers,
+      json: request.body ?? {},
+      method: request.method,
+      origin: request.headers.origin ?? request.headers.host ?? "",
+      url: request.url
+    };
+    await reply.send(response);
+  }, "handler");
+  const noValidation = {
+    schema: anythingSchema,
+    // Skip AJV on *this* route
+    validatorCompiler: /* @__PURE__ */ __name(() => () => true, "validatorCompiler")
+  };
+  fastify.get("/anything", noValidation, handler);
+  fastify.post("/anything", noValidation, handler);
+  fastify.put("/anything", noValidation, handler);
+  fastify.patch("/anything", noValidation, handler);
+  fastify.delete("/anything", noValidation, handler);
+}, "anythingRoute");
 
-// src/routes/http-methods/delete.ts
-var deleteSchema = {
-  description: "Handles a DELETE request and returns request information",
+// src/routes/auth/basic.ts
+import { Buffer as Buffer2 } from "buffer";
+import { timingSafeEqual } from "crypto";
+var parseBasic = /* @__PURE__ */ __name((header) => {
+  if (!header || typeof header !== "string") {
+    return void 0;
+  }
+  const spaceIndex = header.indexOf(" ");
+  if (spaceIndex === -1) {
+    return void 0;
+  }
+  const scheme = header.slice(0, spaceIndex);
+  const value = header.slice(spaceIndex + 1);
+  if (scheme.toLowerCase() !== "basic" || !value) {
+    return void 0;
+  }
+  try {
+    const decoded = Buffer2.from(value, "base64").toString("utf8");
+    const idx = decoded.indexOf(":");
+    if (idx === -1) {
+      return void 0;
+    }
+    const username = decoded.slice(0, idx);
+    const password = decoded.slice(idx + 1);
+    if (username === "") {
+      return void 0;
+    }
+    return {
+      username,
+      password
+    };
+  } catch {
+    return void 0;
+  }
+}, "parseBasic");
+var safeCompare = /* @__PURE__ */ __name((a, b) => {
+  if (a.length !== b.length) {
+    return false;
+  }
+  try {
+    return timingSafeEqual(Buffer2.from(a, "utf8"), Buffer2.from(b, "utf8"));
+  } catch {
+    return false;
+  }
+}, "safeCompare");
+var basicAuthSchema = {
+  description: "HTTP Basic authentication. Succeeds only if the user/pass provided in the path matches the Basic Authorization header.",
   tags: [
-    "HTTP Methods"
+    "Auth"
   ],
-  body: {
+  params: {
     type: "object",
-    additionalProperties: true,
-    description: "The body of the DELETE request"
+    properties: {
+      user: {
+        type: "string"
+      },
+      passwd: {
+        type: "string"
+      }
+    },
+    required: [
+      "user",
+      "passwd"
+    ]
   },
   response: {
     // eslint-disable-next-line  @typescript-eslint/naming-convention
     200: {
       type: "object",
       properties: {
-        method: {
-          type: "string"
+        authenticated: {
+          type: "boolean"
         },
-        headers: {
-          type: "object",
-          additionalProperties: {
-            type: "string"
-          }
-        },
-        body: {
-          type: "object",
-          additionalProperties: true
+        user: {
+          type: "string"
         }
       },
       required: [
-        "method",
-        "headers",
-        "body"
+        "authenticated",
+        "user"
       ]
-    }
-  }
-};
-var deleteRoute = /* @__PURE__ */ __name((fastify) => {
-  fastify.delete("/delete", {
-    schema: deleteSchema
-  }, async (request) => ({
-    method: "DELETE",
-    headers: request.headers,
-    body: request.body
-  }));
-}, "deleteRoute");
-
-// src/routes/http-methods/put.ts
-var putSchema = {
-  description: "Handles a PUT request and returns request information",
-  tags: [
-    "HTTP Methods"
-  ],
-  body: {
-    type: "object",
-    additionalProperties: true,
-    description: "The body of the PUT request"
-  },
-  response: {
+    },
     // eslint-disable-next-line  @typescript-eslint/naming-convention
-    200: {
+    401: {
       type: "object",
       properties: {
-        method: {
+        message: {
           type: "string"
-        },
-        headers: {
-          type: "object",
-          additionalProperties: {
-            type: "string"
-          }
-        },
-        body: {
-          type: "object",
-          additionalProperties: true
         }
       },
       required: [
-        "method",
-        "headers",
-        "body"
+        "message"
       ]
     }
   }
 };
-var putRoute = /* @__PURE__ */ __name((fastify) => {
-  fastify.put("/put", {
-    schema: putSchema
-  }, async (request) => ({
-    method: "PUT",
-    headers: request.headers,
-    body: request.body
-  }));
-}, "putRoute");
+var basicAuthRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/basic-auth/:user/:passwd", {
+    schema: basicAuthSchema
+  }, async (request, reply) => {
+    const { user, passwd } = request.params;
+    if (!user || typeof user !== "string" || typeof passwd !== "string") {
+      void reply.header("WWW-Authenticate", 'Basic realm="mockhttp"');
+      return reply.status(401).send({
+        message: "Unauthorized"
+      });
+    }
+    const parsed = parseBasic(request.headers.authorization);
+    if (!parsed || !safeCompare(parsed.username, user) || !safeCompare(parsed.password, passwd)) {
+      void reply.header("WWW-Authenticate", 'Basic realm="mockhttp"');
+      return reply.status(401).send({
+        message: "Unauthorized"
+      });
+    }
+    return reply.send({
+      authenticated: true,
+      user
+    });
+  });
+}, "basicAuthRoute");
 
-// src/routes/http-methods/patch.ts
-var patchSchema = {
-  description: "Handles a PATCH request and returns request information",
+// src/routes/auth/bearer.ts
+var parseBearer = /* @__PURE__ */ __name((header) => {
+  if (!header) {
+    return void 0;
+  }
+  const [scheme, token] = header.split(" ");
+  if (!scheme || scheme.toLowerCase() !== "bearer" || !token) {
+    return void 0;
+  }
+  return token;
+}, "parseBearer");
+var bearerAuthSchema = {
+  description: "HTTP Bearer authentication. Succeeds if any Bearer token is present unless ?required=true is provided.",
   tags: [
-    "HTTP Methods"
+    "Auth"
   ],
-  body: {
+  querystring: {
     type: "object",
-    additionalProperties: true,
-    description: "The body of the PATCH request"
+    properties: {
+      required: {
+        type: "boolean",
+        default: true
+      }
+    }
   },
   response: {
     // eslint-disable-next-line  @typescript-eslint/naming-convention
     200: {
       type: "object",
       properties: {
-        method: {
-          type: "string"
-        },
-        headers: {
-          type: "object",
-          additionalProperties: {
-            type: "string"
-          }
+        authenticated: {
+          type: "boolean"
         },
-        body: {
-          type: "object",
-          additionalProperties: true
+        token: {
+          type: "string"
         }
       },
       required: [
-        "method",
-        "headers",
-        "body"
+        "authenticated",
+        "token"
+      ]
+    },
+    // eslint-disable-next-line  @typescript-eslint/naming-convention
+    401: {
+      type: "object",
+      properties: {
+        message: {
+          type: "string"
+        }
+      },
+      required: [
+        "message"
       ]
     }
   }
 };
-var patchRoute = /* @__PURE__ */ __name((fastify) => {
-  fastify.patch("/patch", {
-    schema: patchSchema
-  }, async (request) => ({
-    method: "PATCH",
-    headers: request.headers,
-    body: request.body
-  }));
-}, "patchRoute");
+var bearerAuthRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/bearer", {
+    schema: bearerAuthSchema
+  }, async (request, reply) => {
+    const token = parseBearer(request.headers.authorization);
+    const qs = request.query;
+    const required = qs?.required ?? true;
+    if (!token && required) {
+      void reply.header("WWW-Authenticate", "Bearer");
+      return reply.status(401).send({
+        message: "Unauthorized"
+      });
+    }
+    if (!token) {
+      return reply.send({
+        authenticated: false,
+        token: ""
+      });
+    }
+    return reply.send({
+      authenticated: true,
+      token
+    });
+  });
+}, "bearerAuthRoute");
 
-// src/routes/status-codes/index.ts
-import { randomInt } from "crypto";
-var statusCodes = [
-  {
-    code: 100,
-    message: "Continue"
-  },
-  {
-    code: 101,
-    message: "Switching Protocols"
-  },
-  {
-    code: 102,
-    message: "Processing"
-  },
-  {
-    code: 103,
-    message: "Early Hints"
-  },
-  {
-    code: 200,
-    message: "OK"
-  },
-  {
-    code: 201,
-    message: "Created"
-  },
-  {
-    code: 202,
-    message: "Accepted"
-  },
-  {
-    code: 203,
-    message: "Non-Authoritative Information"
-  },
-  {
-    code: 204,
-    message: "No Content"
-  },
-  {
-    code: 205,
-    message: "Reset Content"
-  },
-  {
-    code: 206,
-    message: "Partial Content"
+// src/routes/auth/digest.ts
+import crypto from "crypto";
+var makeNonce = /* @__PURE__ */ __name(() => crypto.randomBytes(16).toString("hex"), "makeNonce");
+var algorithms = /* @__PURE__ */ new Set([
+  "MD5",
+  "md5",
+  "SHA-256",
+  "sha-256",
+  "SHA-512",
+  "sha-512"
+]);
+var hashAlg = /* @__PURE__ */ __name((alg) => {
+  if (!alg) {
+    return "md5";
+  }
+  const a = alg.toLowerCase();
+  if (a === "md5") {
+    return "md5";
+  }
+  if (a === "sha-256") {
+    return "sha256";
+  }
+  if (a === "sha-512") {
+    return "sha512";
+  }
+  return "md5";
+}, "hashAlg");
+var h = /* @__PURE__ */ __name((algo, data) => crypto.createHash(algo).update(data).digest("hex"), "h");
+var parseDigest = /* @__PURE__ */ __name((header) => {
+  if (!header) {
+    return void 0;
+  }
+  const spaceIndex = header.indexOf(" ");
+  if (spaceIndex === -1) {
+    return void 0;
+  }
+  const scheme = header.slice(0, spaceIndex);
+  const rest = header.slice(spaceIndex + 1);
+  if (!scheme || scheme.toLowerCase() !== "digest" || !rest) {
+    return void 0;
+  }
+  const out = {};
+  const parts = [];
+  let current = "";
+  let inQuotes = false;
+  for (const char of rest) {
+    if (char === '"') {
+      inQuotes = !inQuotes;
+      current += char;
+    } else if (char === "," && !inQuotes) {
+      if (current.trim()) {
+        parts.push(current.trim());
+      }
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) {
+    parts.push(current.trim());
+  }
+  if (parts.length === 0) {
+    return out;
+  }
+  for (const p of parts) {
+    const equalIndex = p.indexOf("=");
+    if (equalIndex === -1) {
+      continue;
+    }
+    const k = p.slice(0, equalIndex).trim();
+    const v = p.slice(equalIndex + 1).trim();
+    let value = v;
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1);
+    }
+    out[k] = value;
+  }
+  return out;
+}, "parseDigest");
+var digestAuthSchema = {
+  description: "HTTP Digest authentication. Mirrors httpbin behavior for testing clients.",
+  tags: [
+    "Auth"
+  ],
+  params: {
+    type: "object",
+    properties: {
+      qop: {
+        type: "string"
+      },
+      user: {
+        type: "string"
+      },
+      passwd: {
+        type: "string"
+      },
+      algorithm: {
+        type: "string"
+      },
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      stale_after: {
+        type: "string"
+      }
+    },
+    required: [
+      "qop",
+      "user",
+      "passwd"
+    ]
+  }
+};
+var digestAuthRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/digest-auth/:qop/:user/:passwd", {
+    schema: digestAuthSchema
+  }, async (request, reply) => {
+    const { user, passwd } = request.params;
+    const realm = "mockhttp";
+    const nonce = makeNonce();
+    const auth = parseDigest(request.headers.authorization);
+    if (!auth) {
+      void reply.header("WWW-Authenticate", `Digest realm="${realm}", qop="auth,auth-int", nonce="${nonce}", opaque="${makeNonce()}"`);
+      return reply.status(401).send({
+        message: "Unauthorized"
+      });
+    }
+    if (auth.username !== user) {
+      void reply.header("WWW-Authenticate", `Digest realm="${realm}", qop="auth,auth-int", nonce="${nonce}", opaque="${makeNonce()}"`);
+      return reply.status(401).send({
+        message: "Unauthorized"
+      });
+    }
+    const method = "GET";
+    const uri = auth.uri ?? request.url.replace(/^https?:\/\/[^/]+/, "");
+    const algo = hashAlg(auth.algorithm);
+    const ha1 = h(algo, `${user}:${realm}:${passwd}`);
+    const ha2 = h(algo, `${method}:${uri}`);
+    let expected = "";
+    expected = auth.qop ? h(algo, `${ha1}:${auth.nonce}:${auth.nc}:${auth.cnonce}:${auth.qop}:${ha2}`) : h(algo, `${ha1}:${auth.nonce}:${ha2}`);
+    if (!auth.response || auth.response !== expected) {
+      void reply.header("WWW-Authenticate", `Digest realm="${realm}", qop="auth,auth-int", nonce="${nonce}", opaque="${makeNonce()}"`);
+      return reply.status(401).send({
+        message: "Unauthorized"
+      });
+    }
+    return reply.send({
+      authenticated: true,
+      user
+    });
+  });
+  fastify.get("/digest-auth/:qop/:user/:passwd/:algorithm", {
+    schema: digestAuthSchema
+  }, async (request, reply) => {
+    const { user, passwd, algorithm } = request.params;
+    const realm = "mockhttp";
+    const algoHeader = algorithms.has(String(algorithm)) ? String(algorithm) : "MD5";
+    const nonce = makeNonce();
+    const auth = parseDigest(request.headers.authorization);
+    if (!auth) {
+      void reply.header("WWW-Authenticate", `Digest realm="${realm}", qop="auth,auth-int", algorithm=${algoHeader}, nonce="${nonce}", opaque="${makeNonce()}"`);
+      return reply.status(401).send({
+        message: "Unauthorized"
+      });
+    }
+    if (auth.username !== user) {
+      void reply.header("WWW-Authenticate", `Digest realm="${realm}", qop="auth,auth-int", algorithm=${algoHeader}, nonce="${nonce}", opaque="${makeNonce()}"`);
+      return reply.status(401).send({
+        message: "Unauthorized"
+      });
+    }
+    const method = "GET";
+    const uri = auth.uri ?? request.url.replace(/^https?:\/\/[^/]+/, "");
+    const algo = hashAlg(auth.algorithm ?? algoHeader);
+    const ha1 = h(algo, `${user}:${realm}:${passwd}`);
+    const ha2 = h(algo, `${method}:${uri}`);
+    const expected = auth.qop ? h(algo, `${ha1}:${auth.nonce}:${auth.nc}:${auth.cnonce}:${auth.qop}:${ha2}`) : h(algo, `${ha1}:${auth.nonce}:${ha2}`);
+    if (!auth.response || auth.response !== expected) {
+      void reply.header("WWW-Authenticate", `Digest realm="${realm}", qop="auth,auth-int", algorithm=${algoHeader}, nonce="${nonce}", opaque="${makeNonce()}"`);
+      return reply.status(401).send({
+        message: "Unauthorized"
+      });
+    }
+    return reply.send({
+      authenticated: true,
+      user
+    });
+  });
+}, "digestAuthRoute");
+
+// src/routes/auth/hidden-basic.ts
+import { Buffer as Buffer3 } from "buffer";
+var parseBasic2 = /* @__PURE__ */ __name((header) => {
+  if (!header) {
+    return void 0;
+  }
+  const [scheme, value] = header.split(" ");
+  if (!scheme || scheme.toLowerCase() !== "basic" || !value) {
+    return void 0;
+  }
+  try {
+    const decoded = Buffer3.from(value, "base64").toString("utf8");
+    const idx = decoded.indexOf(":");
+    if (idx === -1) {
+      return void 0;
+    }
+    return {
+      username: decoded.slice(0, idx),
+      password: decoded.slice(idx + 1)
+    };
+  } catch {
+    return void 0;
+  }
+}, "parseBasic");
+var hiddenBasicAuthSchema = {
+  description: "HTTP Basic authentication with docs hidden. Mirrors /basic-auth but hides from schema.",
+  tags: [
+    "Auth"
+  ],
+  hide: true,
+  params: {
+    type: "object",
+    properties: {
+      user: {
+        type: "string"
+      },
+      passwd: {
+        type: "string"
+      }
+    },
+    required: [
+      "user",
+      "passwd"
+    ]
+  }
+};
+var hiddenBasicAuthRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/hidden-basic-auth/:user/:passwd", {
+    schema: hiddenBasicAuthSchema
+  }, async (request, reply) => {
+    const { user, passwd } = request.params;
+    const parsed = parseBasic2(request.headers.authorization);
+    if (!parsed || parsed.username !== user || parsed.password !== passwd) {
+      void reply.header("WWW-Authenticate", 'Basic realm="mockhttp"');
+      return reply.status(401).send({
+        message: "Unauthorized"
+      });
+    }
+    return reply.send({
+      authenticated: true,
+      user
+    });
+  });
+}, "hiddenBasicAuthRoute");
+
+// src/routes/cookies/delete.ts
+var cookiesDeleteSchema = {
+  description: "Delete a cookie",
+  tags: [
+    "Cookies"
+  ],
+  querystring: {
+    type: "object",
+    properties: {
+      name: {
+        type: "string"
+      }
+    },
+    required: [
+      "name"
+    ],
+    additionalProperties: false
   },
-  {
-    code: 207,
-    message: "Multi-Status"
-  },
-  {
-    code: 208,
-    message: "Already Reported"
-  },
-  {
-    code: 226,
-    message: "IM Used"
-  },
-  {
-    code: 300,
-    message: "Multiple Choices"
-  },
-  {
-    code: 301,
-    message: "Moved Permanently"
-  },
-  {
-    code: 302,
-    message: "Found"
-  },
-  {
-    code: 303,
-    message: "See Other"
-  },
-  {
-    code: 304,
-    message: "Not Modified"
-  },
-  {
-    code: 305,
-    message: "Use Proxy"
-  },
-  {
-    code: 306,
-    message: "Switch Proxy"
-  },
-  {
-    code: 307,
-    message: "Temporary Redirect"
-  },
-  {
-    code: 308,
-    message: "Permanent Redirect"
-  },
-  {
-    code: 400,
-    message: "Bad Request"
-  },
-  {
-    code: 401,
-    message: "Unauthorized"
-  },
-  {
-    code: 402,
-    message: "Payment Required"
-  },
-  {
-    code: 403,
-    message: "Forbidden"
-  },
-  {
-    code: 404,
-    message: "Not Found"
-  },
-  {
-    code: 405,
-    message: "Method Not Allowed"
-  },
-  {
-    code: 406,
-    message: "Not Acceptable"
-  },
-  {
-    code: 407,
-    message: "Proxy Authentication Required"
-  },
-  {
-    code: 408,
-    message: "Request Timeout"
-  },
-  {
-    code: 409,
-    message: "Conflict"
-  },
-  {
-    code: 410,
-    message: "Gone"
-  },
-  {
-    code: 411,
-    message: "Length Required"
-  },
-  {
-    code: 412,
-    message: "Precondition Failed"
-  },
-  {
-    code: 413,
-    message: "Payload Too Large"
-  },
-  {
-    code: 414,
-    message: "URI Too Long"
-  },
-  {
-    code: 415,
-    message: "Unsupported Media Type"
-  },
-  {
-    code: 416,
-    message: "Range Not Satisfiable"
-  },
-  {
-    code: 417,
-    message: "Expectation Failed"
-  },
-  {
-    code: 418,
-    message: "I'm a teapot"
-  },
-  {
-    code: 421,
-    message: "Misdirected Request"
-  },
-  {
-    code: 422,
-    message: "Unprocessable Entity"
-  },
-  {
-    code: 423,
-    message: "Locked"
-  },
-  {
-    code: 424,
-    message: "Failed Dependency"
-  },
-  {
-    code: 425,
-    message: "Too Early"
-  },
-  {
-    code: 426,
-    message: "Upgrade Required"
-  },
-  {
-    code: 428,
-    message: "Precondition Required"
-  },
-  {
-    code: 429,
-    message: "Too Many Requests"
-  },
-  {
-    code: 431,
-    message: "Request Header Fields Too Large"
-  },
-  {
-    code: 451,
-    message: "Unavailable For Legal Reasons"
-  },
-  {
-    code: 500,
-    message: "Internal Server Error"
-  },
-  {
-    code: 501,
-    message: "Not Implemented"
-  },
-  {
-    code: 502,
-    message: "Bad Gateway"
-  },
-  {
-    code: 503,
-    message: "Service Unavailable"
-  },
-  {
-    code: 504,
-    message: "Gateway Timeout"
-  },
-  {
-    code: 505,
-    message: "HTTP Version Not Supported"
-  },
-  {
-    code: 506,
-    message: "Variant Also Negotiates"
-  },
-  {
-    code: 507,
-    message: "Insufficient Storage"
-  },
-  {
-    code: 508,
-    message: "Loop Detected"
-  },
-  {
-    code: 510,
-    message: "Not Extended"
-  },
-  {
-    code: 511,
-    message: "Network Authentication Required"
-  }
-];
-var statusSchema = {
-  description: "Return status code or random status code if more than one are given ",
-  tags: [
-    "Status Codes"
-  ],
-  params: {
-    type: "object",
-    properties: {
-      code: {
-        type: "string",
-        description: "HTTP status code to be returned"
-      }
-    }
+  response: {
+    // eslint-disable-next-line  @typescript-eslint/naming-convention
+    204: {
+      type: "null"
+    }
+  }
+};
+var deleteCookieRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.delete("/cookies", {
+    schema: cookiesDeleteSchema
+  }, async (request, reply) => {
+    const { name } = request.query;
+    reply.clearCookie(name, {
+      path: "/"
+    });
+    return reply.status(204).send();
+  });
+}, "deleteCookieRoute");
+
+// src/routes/cookies/get.ts
+var getCookiesRouteSchema = {
+  description: "Return cookies from the request",
+  tags: [
+    "Cookies"
+  ],
+  response: {
+    // eslint-disable-next-line  @typescript-eslint/naming-convention
+    200: {
+      type: "object",
+      properties: {
+        cookies: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        }
+      },
+      required: [
+        "cookies"
+      ]
+    }
+  }
+};
+var getCookiesRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/cookies", {
+    schema: getCookiesRouteSchema
+  }, async (request, reply) => {
+    reply.type("application/json");
+    await reply.send({
+      cookies: request.cookies
+    });
+  });
+}, "getCookiesRoute");
+
+// src/routes/cookies/post.ts
+var postCookieRouteSchema = {
+  description: "Set a cookie",
+  tags: [
+    "Cookies"
+  ],
+  body: {
+    type: "object",
+    properties: {
+      name: {
+        type: "string"
+      },
+      value: {
+        type: "string"
+      },
+      expires: {
+        type: "string",
+        format: "date-time"
+      }
+    },
+    required: [
+      "name",
+      "value"
+    ],
+    additionalProperties: false
   },
   response: {
     // eslint-disable-next-line  @typescript-eslint/naming-convention
     200: {
       type: "object",
       properties: {
-        status: {
-          type: "string"
+        cookies: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
         }
-      }
+      },
+      required: [
+        "cookies"
+      ]
     }
   }
 };
-var statusCodeRoute = /* @__PURE__ */ __name((fastify) => {
-  const handler = /* @__PURE__ */ __name(async (request, reply) => {
-    let { code } = request.params;
-    if (!code || !statusCodes.map((status) => status.code).includes(Number(code))) {
-      code = statusCodes[randomInt(0, statusCodes.length)].code.toString();
+var postCookieRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.post("/cookies", {
+    schema: postCookieRouteSchema
+  }, async (request, reply) => {
+    const { name, value, expires } = request.body;
+    if (expires) {
+      const date = new Date(expires);
+      reply.setCookie(name, value, {
+        path: "/",
+        expires: date
+      });
+    } else {
+      reply.setCookie(name, value, {
+        path: "/"
+      });
     }
-    await reply.code(Number(code)).send({
-      status: `Response with status code ${code}`
-    });
-  }, "handler");
-  fastify.get("/status/:code?", {
-    schema: statusSchema
-  }, handler);
-  fastify.post("/status/:code?", {
-    schema: statusSchema
-  }, handler);
-  fastify.put("/status/:code?", {
-    schema: statusSchema
-  }, handler);
-  fastify.patch("/status/:code?", {
-    schema: statusSchema
-  }, handler);
-  fastify.delete("/status/:code?", {
-    schema: statusSchema
-  }, handler);
-}, "statusCodeRoute");
+    return reply.status(200).send();
+  });
+}, "postCookieRoute");
 
-// src/routes/request-inspection/ip.ts
-var ipSchema = {
-  description: "Returns the IP address of the client",
+// src/routes/http-methods/delete.ts
+var deleteSchema = {
+  description: "Handles a DELETE request and returns request information",
   tags: [
-    "Request Inspection"
+    "HTTP Methods"
   ],
+  body: {
+    type: "object",
+    additionalProperties: true,
+    description: "The body of the DELETE request"
+  },
   response: {
     // eslint-disable-next-line  @typescript-eslint/naming-convention
     200: {
       type: "object",
       properties: {
-        ip: {
-          type: "string",
-          description: "The IP address of the client"
+        method: {
+          type: "string"
+        },
+        headers: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        },
+        body: {
+          type: "object",
+          additionalProperties: true
         }
       },
       required: [
-        "ip"
+        "method",
+        "headers",
+        "body"
       ]
     }
   }
 };
-var ipRoute = /* @__PURE__ */ __name((fastify) => {
-  fastify.get("/ip", {
-    schema: ipSchema
-  }, async (request) => {
-    const cloudflareIp = request.headers["cf-connecting-ip"];
-    const forwardedIp = request.headers["x-forwarded-for"];
-    const remoteIp = request.ip;
-    const ip = cloudflareIp ?? (typeof forwardedIp === "string" ? forwardedIp.split(",")[0].trim() : remoteIp);
-    return {
-      ip
-    };
-  });
-}, "ipRoute");
+var deleteRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.delete("/delete", {
+    schema: deleteSchema
+  }, async (request) => ({
+    method: "DELETE",
+    headers: request.headers,
+    body: request.body
+  }));
+}, "deleteRoute");
 
-// src/routes/request-inspection/headers.ts
-var headersSchema = {
-  description: "Returns all headers of the client request",
+// src/routes/http-methods/get.ts
+var getSchema = {
+  description: "Returns request information for GET requests",
   tags: [
-    "Request Inspection"
+    "HTTP Methods"
   ],
+  querystring: {
+    type: "object",
+    additionalProperties: true,
+    properties: {},
+    description: "Query parameters sent in the request"
+  },
+  headers: {
+    type: "object",
+    additionalProperties: true,
+    properties: {},
+    description: "Headers sent in the request"
+  },
   response: {
     // eslint-disable-next-line  @typescript-eslint/naming-convention
     200: {
       type: "object",
       properties: {
+        method: {
+          type: "string"
+        },
         headers: {
           type: "object",
           additionalProperties: {
             type: "string"
-          },
-          description: "All headers of the client request"
+          }
+        },
+        queryParams: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
         }
       },
       required: [
-        "headers"
+        "method",
+        "headers",
+        "queryParams"
       ]
     }
   }
 };
-var headersRoute = /* @__PURE__ */ __name((fastify) => {
-  fastify.get("/headers", {
-    schema: headersSchema
-  }, async (request) => {
-    const { headers } = request;
-    return {
-      headers
-    };
-  });
-}, "headersRoute");
+var getRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/get", {
+    schema: getSchema
+  }, async (request, _reply) => ({
+    method: "GET",
+    headers: request.headers,
+    queryParams: request.query
+  }));
+}, "getRoute");
 
-// src/routes/request-inspection/user-agent.ts
-var userAgentSchema = {
-  description: "Returns the User-Agent header of the client request",
+// src/routes/http-methods/patch.ts
+var patchSchema = {
+  description: "Handles a PATCH request and returns request information",
   tags: [
-    "Request Inspection"
+    "HTTP Methods"
   ],
+  body: {
+    type: "object",
+    additionalProperties: true,
+    description: "The body of the PATCH request"
+  },
   response: {
     // eslint-disable-next-line  @typescript-eslint/naming-convention
     200: {
       type: "object",
       properties: {
-        userAgent: {
-          type: "string",
-          description: "The User-Agent header of the client request"
+        method: {
+          type: "string"
+        },
+        headers: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        },
+        body: {
+          type: "object",
+          additionalProperties: true
         }
       },
       required: [
-        "userAgent"
+        "method",
+        "headers",
+        "body"
       ]
     }
   }
 };
-var userAgentRoute = /* @__PURE__ */ __name((fastify) => {
-  fastify.get("/user-agent", {
-    schema: userAgentSchema
-  }, async (request) => {
-    const userAgent = request.headers["user-agent"];
-    return {
-      userAgent
-    };
-  });
-}, "userAgentRoute");
+var patchRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.patch("/patch", {
+    schema: patchSchema
+  }, async (request) => ({
+    method: "PATCH",
+    headers: request.headers,
+    body: request.body
+  }));
+}, "patchRoute");
 
-// src/routes/response-inspection/cache.ts
-var cacheGetSchema = {
-  description: "Handles cache validation and retrieval.",
+// src/routes/http-methods/post.ts
+var postSchema = {
+  description: "Handles a POST request and returns request information",
   tags: [
-    "Response Inspection"
+    "HTTP Methods"
   ],
+  body: {
+    type: "object",
+    additionalProperties: true,
+    description: "The body of the POST request"
+  },
   response: {
-    // eslint-disable-next-line @typescript-eslint/naming-convention
+    // eslint-disable-next-line  @typescript-eslint/naming-convention
     200: {
-      type: "string",
-      description: "The cached content or resource."
-    },
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    304: {
-      type: "null",
-      description: "Indicates the resource has not been modified."
+      type: "object",
+      properties: {
+        method: {
+          type: "string"
+        },
+        headers: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        },
+        body: {
+          type: "object",
+          additionalProperties: true
+        }
+      },
+      required: [
+        "method",
+        "headers",
+        "body"
+      ]
     }
   }
 };
-var cacheSetSchema = {
-  description: "Sets a Cache-Control header for n seconds.",
+var postRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.post("/post", {
+    schema: postSchema
+  }, async (request) => ({
+    method: "POST",
+    headers: request.headers,
+    body: request.body
+  }));
+}, "postRoute");
+
+// src/routes/http-methods/put.ts
+var putSchema = {
+  description: "Handles a PUT request and returns request information",
   tags: [
-    "Response Inspection"
+    "HTTP Methods"
   ],
-  params: {
+  body: {
     type: "object",
-    properties: {
-      value: {
-        type: "integer",
-        description: "Number of seconds to cache the resource."
-      }
-    },
-    required: [
-      "value"
-    ]
+    additionalProperties: true,
+    description: "The body of the PUT request"
   },
   response: {
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    200: {
-      type: "string",
-      description: "Confirmation message for setting cache."
-    }
-  }
-};
-var cacheRoutes = /* @__PURE__ */ __name((fastify) => {
-  fastify.get("/cache", {
-    schema: cacheGetSchema
-  }, async (request, reply) => {
-    const ifModifiedSince = request.headers["if-modified-since"];
-    const ifNoneMatch = request.headers["if-none-match"];
-    if (ifModifiedSince ?? ifNoneMatch) {
-      await reply.status(304).send();
-      return;
-    }
-    await reply.send("Cache content or resource response here.");
-  });
-  fastify.get("/cache/:value", {
-    schema: cacheSetSchema
-  }, async (request, reply) => {
-    const { value } = request.params;
-    await reply.header("Cache-Control", `max-age=${value}`).send(`Cache-Control set for ${value} seconds.`);
-  });
-}, "cacheRoutes");
-
-// src/routes/response-inspection/etag.ts
-var etagSchema = {
-  description: "Handles ETag-based conditional requests.",
-  tags: [
-    "Response Inspection"
-  ],
-  params: {
-    type: "object",
-    properties: {
-      etag: {
-        type: "string",
-        description: "The ETag value for the resource."
-      }
-    },
-    required: [
-      "etag"
-    ]
-  },
-  response: {
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    200: {
-      type: "string",
-      description: "Resource content for matching ETag."
-    },
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    304: {
-      type: "null",
-      description: "Indicates the resource has not been modified."
-    },
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    412: {
-      type: "null",
-      description: "Indicates a precondition failed due to mismatched ETag."
-    }
-  }
-};
-var etagRoutes = /* @__PURE__ */ __name((fastify) => {
-  fastify.get("/etag/:etag", {
-    schema: etagSchema
-  }, async (request, reply) => {
-    const { etag } = request.params;
-    const ifNoneMatch = request.headers["if-none-match"];
-    const ifMatch = request.headers["if-match"];
-    if (ifNoneMatch === etag) {
-      await reply.status(304).send();
-      return;
-    }
-    if (ifMatch && ifMatch !== etag) {
-      await reply.status(412).send();
-      return;
-    }
-    await reply.header("ETag", etag).send("Resource content for matching ETag.");
-  });
-}, "etagRoutes");
-
-// src/routes/response-inspection/response-headers.ts
-import { escape } from "html-escaper";
-var responseHeadersSchema = {
-  description: "Returns a set of response headers based on the query string.",
-  tags: [
-    "Response Inspection"
-  ],
-  querystring: {
-    type: "object",
-    additionalProperties: true,
-    description: "Freeform query string parameters to be added as response headers."
-  },
-  response: {
-    // eslint-disable-next-line @typescript-eslint/naming-convention
+    // eslint-disable-next-line  @typescript-eslint/naming-convention
     200: {
       type: "object",
-      additionalProperties: true,
-      description: "Response headers as per query string parameters."
+      properties: {
+        method: {
+          type: "string"
+        },
+        headers: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        },
+        body: {
+          type: "object",
+          additionalProperties: true
+        }
+      },
+      required: [
+        "method",
+        "headers",
+        "body"
+      ]
     }
   }
 };
-var responseHeadersRoutes = /* @__PURE__ */ __name((fastify) => {
-  fastify.get("/response-headers", {
-    schema: responseHeadersSchema
-  }, async (request, reply) => {
-    const queryParameters = request.query;
-    for (const [key, value] of Object.entries(queryParameters)) {
-      reply.header(key, escape(value));
-    }
-    const cleanedResponse = Object.fromEntries(Object.entries(queryParameters).map(([key, value]) => [
-      key,
-      escape(value)
-    ]));
-    await reply.send(cleanedResponse);
-  });
-  fastify.post("/response-headers", {
-    schema: responseHeadersSchema
-  }, async (request, reply) => {
-    const queryParameters = request.query ?? {};
-    const body = request.body ?? {};
-    for (const [key, value] of Object.entries(queryParameters)) {
-      reply.header(key, escape(value));
-    }
-    for (const [key, value] of Object.entries(body)) {
-      reply.header(key, escape(value));
+var putRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.put("/put", {
+    schema: putSchema
+  }, async (request) => ({
+    method: "PUT",
+    headers: request.headers,
+    body: request.body
+  }));
+}, "putRoute");
+
+// src/routes/index.ts
+var indexRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/", {
+    schema: {
+      hide: true
     }
-    const cleanedResponse = Object.fromEntries(Object.entries({
-      ...queryParameters,
-      ...body
-    }).map(([key, value]) => [
-      key,
-      escape(value)
-    ]));
-    await reply.send(cleanedResponse);
+  }, async (_request, reply) => {
+    const redocHtml = `
+	<!doctype html>
+<html>
+  <head>
+    <title>{ mockhttp }</title>
+    <meta charset="utf-8" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1" />
+      <style>
+      :root {
+  --scalar-custom-header-height: 70px;
+}
+.custom-header {
+  height: var(--scalar-custom-header-height);
+  background-color: var(--scalar-background-1);
+  box-shadow: inset 0 -1px 0 var(--scalar-border-color);
+  color: var(--scalar-color-1);
+  font-size: var(--scalar-font-size-2);
+  padding: 0 18px;
+  position: sticky;
+  justify-content: space-between;
+  top: 0;
+  z-index: 100;
+}
+.custom-header,
+.custom-header nav {
+  display: flex;
+  align-items: center;
+  gap: 18px;
+}
+
+.custom-header img {
+  height: var(--scalar-custom-header-height);
+  object-fit: contain;
+}
+
+.custom-header a:hover {
+  color: var(--scalar-color-2);
+}
+
+.github-corner {
+  fill: var(--scalar-border-color) !important;
+}
+
+      </style>
+  </head>
+  <body>
+  <header class="custom-header scalar-app">
+    <a href="/"><img src="/logo.svg" alt="{ mockhttp }" /></a>
+    <a href="https://github.com/jaredwray/mockhttp" class="github-corner" aria-label="View source on GitHub">
+      <svg width="70" height="70" viewBox="0 0 250 250" style="color:#fff; position: absolute; top: 0; border: 0; right: 0;" aria-hidden="true">
+      <path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path>
+      <path d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2" fill="currentColor" style="transform-origin: 130px 106px;" class="octo-arm"></path>
+      <path d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z" fill="currentColor" class="octo-body"></path></svg></a><style>.github-corner:hover .octo-arm{animation:octocat-wave 560ms ease-in-out}@keyframes octocat-wave{0%,100%{transform:rotate(0)}20%,60%{transform:rotate(-25deg)}40%,80%{transform:rotate(10deg)}}@media (max-width:500px){.github-corner:hover .octo-arm{animation:none}.github-corner .octo-arm{animation:octocat-wave 560ms ease-in-out}}</style>
+  </header>
+
+    <script
+      id="api-reference"
+      data-url="/docs/json"></script>
+
+    <script src="/scalar/browser/standalone.js"></script>
+  </body>
+</html>
+`;
+    await reply.type("text/html").send(redocHtml);
   });
-}, "responseHeadersRoutes");
+}, "indexRoute");
 
 // src/routes/redirects/absolute-redirect.ts
 var absoluteRedirectSchema = {
@@ -1173,35 +1102,85 @@ var absoluteRedirectRoute = /* @__PURE__ */ __name((fastify) => {
   });
 }, "absoluteRedirectRoute");
 
-// src/routes/redirects/relative-redirect.ts
-var relativeRedirectSchema = {
+// src/routes/redirects/redirect-to.ts
+var redirectToSchema = {
   tags: [
     "Redirects"
   ],
-  description: "Redirects the request to the target URL using an relative URL",
-  params: {
-    type: "object",
-    properties: {
-      value: {
-        type: "integer",
-        minimum: 1
-      }
-    },
-    required: [
-      "value"
-    ]
-  },
-  headers: {
+  description: "Redirects the request to the target URL",
+  querystring: {
     type: "object",
     properties: {
-      host: {
-        type: "string"
+      url: {
+        type: "string",
+        format: "uri",
+        description: "The URL to redirect to"
+      },
+      // eslint-disable-next-line  @typescript-eslint/naming-convention
+      status_code: {
+        type: "string",
+        pattern: "^[1-5][0-9][0-9]$",
+        description: "The HTTP status code to use for redirection"
       }
     },
     required: [
-      "host"
-    ]
-  },
+      "url"
+    ],
+    additionalProperties: false
+  }
+};
+var redirectToRoute = /* @__PURE__ */ __name((fastify) => {
+  const handler = /* @__PURE__ */ __name(async (request, reply) => {
+    const { url, status_code } = request.query;
+    const statusCode = status_code ? Number(status_code) : 302;
+    await reply.redirect(url, statusCode);
+  }, "handler");
+  fastify.get("/redirect-to", {
+    schema: redirectToSchema
+  }, handler);
+  fastify.post("/redirect-to", {
+    schema: redirectToSchema
+  }, handler);
+  fastify.put("/redirect-to", {
+    schema: redirectToSchema
+  }, handler);
+  fastify.patch("/redirect-to", {
+    schema: redirectToSchema
+  }, handler);
+  fastify.delete("/redirect-to", {
+    schema: redirectToSchema
+  }, handler);
+}, "redirectToRoute");
+
+// src/routes/redirects/relative-redirect.ts
+var relativeRedirectSchema = {
+  tags: [
+    "Redirects"
+  ],
+  description: "Redirects the request to the target URL using an relative URL",
+  params: {
+    type: "object",
+    properties: {
+      value: {
+        type: "integer",
+        minimum: 1
+      }
+    },
+    required: [
+      "value"
+    ]
+  },
+  headers: {
+    type: "object",
+    properties: {
+      host: {
+        type: "string"
+      }
+    },
+    required: [
+      "host"
+    ]
+  },
   response: {
     // eslint-disable-next-line  @typescript-eslint/naming-convention
     302: {
@@ -1232,285 +1211,758 @@ var relativeRedirectRoute = /* @__PURE__ */ __name((fastify) => {
   });
 }, "relativeRedirectRoute");
 
-// src/routes/redirects/redirect-to.ts
-var redirectToSchema = {
-  tags: [
-    "Redirects"
-  ],
-  description: "Redirects the request to the target URL",
-  querystring: {
-    type: "object",
-    properties: {
-      url: {
-        type: "string",
-        format: "uri",
-        description: "The URL to redirect to"
-      },
-      // eslint-disable-next-line  @typescript-eslint/naming-convention
-      status_code: {
-        type: "string",
-        pattern: "^[1-5][0-9][0-9]$",
-        description: "The HTTP status code to use for redirection"
-      }
-    },
-    required: [
-      "url"
-    ],
-    additionalProperties: false
-  }
-};
-var redirectToRoute = /* @__PURE__ */ __name((fastify) => {
-  const handler = /* @__PURE__ */ __name(async (request, reply) => {
-    const { url, status_code } = request.query;
-    const statusCode = status_code ? Number(status_code) : 302;
-    await reply.redirect(url, statusCode);
-  }, "handler");
-  fastify.get("/redirect-to", {
-    schema: redirectToSchema
-  }, handler);
-  fastify.post("/redirect-to", {
-    schema: redirectToSchema
-  }, handler);
-  fastify.put("/redirect-to", {
-    schema: redirectToSchema
-  }, handler);
-  fastify.patch("/redirect-to", {
-    schema: redirectToSchema
-  }, handler);
-  fastify.delete("/redirect-to", {
-    schema: redirectToSchema
-  }, handler);
-}, "redirectToRoute");
-
-// src/routes/cookies/get.ts
-var getCookiesRouteSchema = {
-  description: "Return cookies from the request",
+// src/routes/request-inspection/headers.ts
+var headersSchema = {
+  description: "Returns all headers of the client request",
   tags: [
-    "Cookies"
+    "Request Inspection"
   ],
   response: {
     // eslint-disable-next-line  @typescript-eslint/naming-convention
     200: {
       type: "object",
       properties: {
-        cookies: {
+        headers: {
           type: "object",
           additionalProperties: {
             type: "string"
-          }
+          },
+          description: "All headers of the client request"
         }
       },
       required: [
-        "cookies"
+        "headers"
       ]
     }
   }
 };
-var getCookiesRoute = /* @__PURE__ */ __name((fastify) => {
-  fastify.get("/cookies", {
-    schema: getCookiesRouteSchema
-  }, async (request, reply) => {
-    reply.type("application/json");
-    await reply.send({
-      cookies: request.cookies
-    });
+var headersRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/headers", {
+    schema: headersSchema
+  }, async (request) => {
+    const { headers } = request;
+    return {
+      headers
+    };
   });
-}, "getCookiesRoute");
+}, "headersRoute");
 
-// src/routes/cookies/post.ts
-var postCookieRouteSchema = {
-  description: "Set a cookie",
+// src/routes/request-inspection/ip.ts
+var ipSchema = {
+  description: "Returns the IP address of the client",
   tags: [
-    "Cookies"
+    "Request Inspection"
   ],
-  body: {
-    type: "object",
-    properties: {
-      name: {
-        type: "string"
-      },
-      value: {
-        type: "string"
-      },
-      expires: {
-        type: "string",
-        format: "date-time"
-      }
-    },
-    required: [
-      "name",
-      "value"
-    ],
-    additionalProperties: false
-  },
   response: {
     // eslint-disable-next-line  @typescript-eslint/naming-convention
     200: {
       type: "object",
       properties: {
-        cookies: {
-          type: "object",
-          additionalProperties: {
-            type: "string"
-          }
+        ip: {
+          type: "string",
+          description: "The IP address of the client"
         }
       },
       required: [
-        "cookies"
+        "ip"
       ]
     }
   }
 };
-var postCookieRoute = /* @__PURE__ */ __name((fastify) => {
-  fastify.post("/cookies", {
-    schema: postCookieRouteSchema
-  }, async (request, reply) => {
-    const { name, value, expires } = request.body;
-    if (expires) {
-      const date = new Date(expires);
-      reply.setCookie(name, value, {
-        path: "/",
-        expires: date
-      });
-    } else {
-      reply.setCookie(name, value, {
-        path: "/"
-      });
-    }
-    return reply.status(200).send();
+var ipRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/ip", {
+    schema: ipSchema
+  }, async (request) => {
+    const cloudflareIp = request.headers["cf-connecting-ip"];
+    const forwardedIp = request.headers["x-forwarded-for"];
+    const remoteIp = request.ip;
+    const ip = cloudflareIp ?? (typeof forwardedIp === "string" ? forwardedIp.split(",")[0].trim() : remoteIp);
+    return {
+      ip
+    };
   });
-}, "postCookieRoute");
+}, "ipRoute");
 
-// src/routes/cookies/delete.ts
-var cookiesDeleteSchema = {
-  description: "Delete a cookie",
+// src/routes/request-inspection/user-agent.ts
+var userAgentSchema = {
+  description: "Returns the User-Agent header of the client request",
   tags: [
-    "Cookies"
+    "Request Inspection"
   ],
-  querystring: {
-    type: "object",
-    properties: {
-      name: {
-        type: "string"
-      }
-    },
-    required: [
-      "name"
-    ],
-    additionalProperties: false
-  },
   response: {
     // eslint-disable-next-line  @typescript-eslint/naming-convention
-    204: {
-      type: "null"
+    200: {
+      type: "object",
+      properties: {
+        userAgent: {
+          type: "string",
+          description: "The User-Agent header of the client request"
+        }
+      },
+      required: [
+        "userAgent"
+      ]
     }
   }
 };
-var deleteCookieRoute = /* @__PURE__ */ __name((fastify) => {
-  fastify.delete("/cookies", {
-    schema: cookiesDeleteSchema
-  }, async (request, reply) => {
-    const { name } = request.query;
-    reply.clearCookie(name, {
-      path: "/"
-    });
-    return reply.status(204).send();
-  });
-}, "deleteCookieRoute");
-
-// src/routes/anything/index.ts
-var anythingSchema = {
-  description: "Will return anything that you send it",
+var userAgentRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/user-agent", {
+    schema: userAgentSchema
+  }, async (request) => {
+    const userAgent = request.headers["user-agent"];
+    return {
+      userAgent
+    };
+  });
+}, "userAgentRoute");
+
+// src/routes/response-inspection/cache.ts
+var cacheGetSchema = {
+  description: "Handles cache validation and retrieval.",
+  tags: [
+    "Response Inspection"
+  ],
+  response: {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    200: {
+      type: "string",
+      description: "The cached content or resource."
+    },
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    304: {
+      type: "null",
+      description: "Indicates the resource has not been modified."
+    }
+  }
+};
+var cacheSetSchema = {
+  description: "Sets a Cache-Control header for n seconds.",
+  tags: [
+    "Response Inspection"
+  ],
+  params: {
+    type: "object",
+    properties: {
+      value: {
+        type: "integer",
+        description: "Number of seconds to cache the resource."
+      }
+    },
+    required: [
+      "value"
+    ]
+  },
+  response: {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    200: {
+      type: "string",
+      description: "Confirmation message for setting cache."
+    }
+  }
+};
+var cacheRoutes = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/cache", {
+    schema: cacheGetSchema
+  }, async (request, reply) => {
+    const ifModifiedSince = request.headers["if-modified-since"];
+    const ifNoneMatch = request.headers["if-none-match"];
+    if (ifModifiedSince ?? ifNoneMatch) {
+      await reply.status(304).send();
+      return;
+    }
+    await reply.send("Cache content or resource response here.");
+  });
+  fastify.get("/cache/:value", {
+    schema: cacheSetSchema
+  }, async (request, reply) => {
+    const { value } = request.params;
+    await reply.header("Cache-Control", `max-age=${value}`).send(`Cache-Control set for ${value} seconds.`);
+  });
+}, "cacheRoutes");
+
+// src/routes/response-inspection/etag.ts
+var etagSchema = {
+  description: "Handles ETag-based conditional requests.",
+  tags: [
+    "Response Inspection"
+  ],
+  params: {
+    type: "object",
+    properties: {
+      etag: {
+        type: "string",
+        description: "The ETag value for the resource."
+      }
+    },
+    required: [
+      "etag"
+    ]
+  },
+  response: {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    200: {
+      type: "string",
+      description: "Resource content for matching ETag."
+    },
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    304: {
+      type: "null",
+      description: "Indicates the resource has not been modified."
+    },
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    412: {
+      type: "null",
+      description: "Indicates a precondition failed due to mismatched ETag."
+    }
+  }
+};
+var etagRoutes = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/etag/:etag", {
+    schema: etagSchema
+  }, async (request, reply) => {
+    const { etag } = request.params;
+    const ifNoneMatch = request.headers["if-none-match"];
+    const ifMatch = request.headers["if-match"];
+    if (ifNoneMatch === etag) {
+      await reply.status(304).send();
+      return;
+    }
+    if (ifMatch && ifMatch !== etag) {
+      await reply.status(412).send();
+      return;
+    }
+    await reply.header("ETag", etag).send("Resource content for matching ETag.");
+  });
+}, "etagRoutes");
+
+// src/routes/response-inspection/response-headers.ts
+import { escape as escapeHtml } from "html-escaper";
+var responseHeadersSchema = {
+  description: "Returns a set of response headers based on the query string.",
+  tags: [
+    "Response Inspection"
+  ],
+  querystring: {
+    type: "object",
+    additionalProperties: true,
+    description: "Freeform query string parameters to be added as response headers."
+  },
+  response: {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    200: {
+      type: "object",
+      additionalProperties: true,
+      description: "Response headers as per query string parameters."
+    }
+  }
+};
+var responseHeadersRoutes = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/response-headers", {
+    schema: responseHeadersSchema
+  }, async (request, reply) => {
+    const queryParameters = request.query;
+    for (const [key, value] of Object.entries(queryParameters)) {
+      reply.header(key, escapeHtml(value));
+    }
+    const cleanedResponse = Object.fromEntries(Object.entries(queryParameters).map(([key, value]) => [
+      key,
+      escapeHtml(value)
+    ]));
+    await reply.send(cleanedResponse);
+  });
+  fastify.post("/response-headers", {
+    schema: responseHeadersSchema
+  }, async (request, reply) => {
+    const queryParameters = request.query ?? {};
+    const body = request.body ?? {};
+    for (const [key, value] of Object.entries(queryParameters)) {
+      reply.header(key, escapeHtml(value));
+    }
+    for (const [key, value] of Object.entries(body)) {
+      reply.header(key, escapeHtml(value));
+    }
+    const cleanedResponse = Object.fromEntries(Object.entries({
+      ...queryParameters,
+      ...body
+    }).map(([key, value]) => [
+      key,
+      escapeHtml(value)
+    ]));
+    await reply.send(cleanedResponse);
+  });
+}, "responseHeadersRoutes");
+
+// src/routes/sitemap.ts
+var sitemapRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/sitemap.xml", {
+    schema: {
+      hide: true
+    }
+  }, async (_request, reply) => {
+    try {
+      const host = _request.headers.host ?? "mockhttp.org";
+      const isSecure = _request.headers["x-forwarded-proto"]?.includes("https");
+      const protocol = isSecure ? "https" : "http";
+      const xml = `<?xml version="1.0" encoding="UTF-8"?>
+                            <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+                                <url>
+                                    <loc>${protocol}://${host}/</loc>
+                                    <changefreq>monthly</changefreq>
+                                    <priority>1.0</priority>
+                                </url>
+                        </urlset>`;
+      await reply.type("text/xml").send(xml);
+    } catch (error) {
+      fastify.log.error(error);
+      await reply.status(500).send({
+        error: "Internal Server Error"
+      });
+    }
+  });
+}, "sitemapRoute");
+
+// src/routes/status-codes/index.ts
+import { randomInt } from "crypto";
+var statusCodes = [
+  {
+    code: 100,
+    message: "Continue"
+  },
+  {
+    code: 101,
+    message: "Switching Protocols"
+  },
+  {
+    code: 102,
+    message: "Processing"
+  },
+  {
+    code: 103,
+    message: "Early Hints"
+  },
+  {
+    code: 200,
+    message: "OK"
+  },
+  {
+    code: 201,
+    message: "Created"
+  },
+  {
+    code: 202,
+    message: "Accepted"
+  },
+  {
+    code: 203,
+    message: "Non-Authoritative Information"
+  },
+  {
+    code: 204,
+    message: "No Content"
+  },
+  {
+    code: 205,
+    message: "Reset Content"
+  },
+  {
+    code: 206,
+    message: "Partial Content"
+  },
+  {
+    code: 207,
+    message: "Multi-Status"
+  },
+  {
+    code: 208,
+    message: "Already Reported"
+  },
+  {
+    code: 226,
+    message: "IM Used"
+  },
+  {
+    code: 300,
+    message: "Multiple Choices"
+  },
+  {
+    code: 301,
+    message: "Moved Permanently"
+  },
+  {
+    code: 302,
+    message: "Found"
+  },
+  {
+    code: 303,
+    message: "See Other"
+  },
+  {
+    code: 304,
+    message: "Not Modified"
+  },
+  {
+    code: 305,
+    message: "Use Proxy"
+  },
+  {
+    code: 306,
+    message: "Switch Proxy"
+  },
+  {
+    code: 307,
+    message: "Temporary Redirect"
+  },
+  {
+    code: 308,
+    message: "Permanent Redirect"
+  },
+  {
+    code: 400,
+    message: "Bad Request"
+  },
+  {
+    code: 401,
+    message: "Unauthorized"
+  },
+  {
+    code: 402,
+    message: "Payment Required"
+  },
+  {
+    code: 403,
+    message: "Forbidden"
+  },
+  {
+    code: 404,
+    message: "Not Found"
+  },
+  {
+    code: 405,
+    message: "Method Not Allowed"
+  },
+  {
+    code: 406,
+    message: "Not Acceptable"
+  },
+  {
+    code: 407,
+    message: "Proxy Authentication Required"
+  },
+  {
+    code: 408,
+    message: "Request Timeout"
+  },
+  {
+    code: 409,
+    message: "Conflict"
+  },
+  {
+    code: 410,
+    message: "Gone"
+  },
+  {
+    code: 411,
+    message: "Length Required"
+  },
+  {
+    code: 412,
+    message: "Precondition Failed"
+  },
+  {
+    code: 413,
+    message: "Payload Too Large"
+  },
+  {
+    code: 414,
+    message: "URI Too Long"
+  },
+  {
+    code: 415,
+    message: "Unsupported Media Type"
+  },
+  {
+    code: 416,
+    message: "Range Not Satisfiable"
+  },
+  {
+    code: 417,
+    message: "Expectation Failed"
+  },
+  {
+    code: 418,
+    message: "I'm a teapot"
+  },
+  {
+    code: 421,
+    message: "Misdirected Request"
+  },
+  {
+    code: 422,
+    message: "Unprocessable Entity"
+  },
+  {
+    code: 423,
+    message: "Locked"
+  },
+  {
+    code: 424,
+    message: "Failed Dependency"
+  },
+  {
+    code: 425,
+    message: "Too Early"
+  },
+  {
+    code: 426,
+    message: "Upgrade Required"
+  },
+  {
+    code: 428,
+    message: "Precondition Required"
+  },
+  {
+    code: 429,
+    message: "Too Many Requests"
+  },
+  {
+    code: 431,
+    message: "Request Header Fields Too Large"
+  },
+  {
+    code: 451,
+    message: "Unavailable For Legal Reasons"
+  },
+  {
+    code: 500,
+    message: "Internal Server Error"
+  },
+  {
+    code: 501,
+    message: "Not Implemented"
+  },
+  {
+    code: 502,
+    message: "Bad Gateway"
+  },
+  {
+    code: 503,
+    message: "Service Unavailable"
+  },
+  {
+    code: 504,
+    message: "Gateway Timeout"
+  },
+  {
+    code: 505,
+    message: "HTTP Version Not Supported"
+  },
+  {
+    code: 506,
+    message: "Variant Also Negotiates"
+  },
+  {
+    code: 507,
+    message: "Insufficient Storage"
+  },
+  {
+    code: 508,
+    message: "Loop Detected"
+  },
+  {
+    code: 510,
+    message: "Not Extended"
+  },
+  {
+    code: 511,
+    message: "Network Authentication Required"
+  }
+];
+var statusSchema = {
+  description: "Return status code or random status code if more than one are given ",
   tags: [
-    "Anything"
+    "Status Codes"
   ],
+  params: {
+    type: "object",
+    properties: {
+      code: {
+        type: "string",
+        description: "HTTP status code to be returned"
+      }
+    }
+  },
   response: {
-    // eslint-disable-next-line @typescript-eslint/naming-convention
+    // eslint-disable-next-line  @typescript-eslint/naming-convention
     200: {
       type: "object",
       properties: {
-        // Echo back all your params under `args`
-        args: {
-          type: "object",
-          description: "Route parameters",
-          additionalProperties: true
-        },
-        // Echo back whatever was in the request.body
-        data: {
-          type: "object",
-          description: "Request body data",
-          additionalProperties: true
-        },
-        // If you’re using fastify-multipart, you’ll get
-        // files via request.files(); this just allows
-        // you to mirror them back
-        files: {
-          type: "object",
-          description: "Uploaded files",
-          additionalProperties: true
-        },
-        // If you parse application/x-www-form-urlencoded
-        // these fields land in request.body too, but you can
-        // mirror them separately if you like
-        form: {
-          type: "object",
-          description: "Form data",
-          additionalProperties: true
-        },
-        headers: {
-          type: "object",
-          description: "Request headers",
-          additionalProperties: true
-        },
-        json: {
-          type: "object",
-          description: "Parsed JSON body",
-          additionalProperties: true
-        },
-        method: {
-          type: "string",
-          description: "HTTP method used"
-        },
-        origin: {
-          type: "string",
-          description: "Origin of the request"
-        },
-        url: {
-          type: "string",
-          description: "Request URL"
+        status: {
+          type: "string"
         }
-      },
-      // Don’t allow any other top-level keys in your response
-      additionalProperties: false
+      }
     }
   }
 };
-var anythingRoute = /* @__PURE__ */ __name((fastify) => {
+var statusCodeRoute = /* @__PURE__ */ __name((fastify) => {
   const handler = /* @__PURE__ */ __name(async (request, reply) => {
-    const response = {
-      args: request.query,
-      data: request.body ?? {},
-      files: request.raw?.files ?? {},
-      form: request.body ?? {},
-      headers: request.headers,
-      json: request.body ?? {},
-      method: request.method,
-      origin: request.headers.origin ?? request.headers.host ?? "",
-      url: request.url
-    };
-    await reply.send(response);
+    let { code } = request.params;
+    if (!code || !statusCodes.map((status) => status.code).includes(Number(code))) {
+      code = statusCodes[randomInt(0, statusCodes.length)].code.toString();
+    }
+    await reply.code(Number(code)).send({
+      status: `Response with status code ${code}`
+    });
   }, "handler");
-  const noValidation = {
-    schema: anythingSchema,
-    // Skip AJV on *this* route
-    validatorCompiler: /* @__PURE__ */ __name(() => () => true, "validatorCompiler")
-  };
-  fastify.get("/anything", noValidation, handler);
-  fastify.post("/anything", noValidation, handler);
-  fastify.put("/anything", noValidation, handler);
-  fastify.patch("/anything", noValidation, handler);
-  fastify.delete("/anything", noValidation, handler);
-}, "anythingRoute");
+  fastify.get("/status/:code?", {
+    schema: statusSchema
+  }, handler);
+  fastify.post("/status/:code?", {
+    schema: statusSchema
+  }, handler);
+  fastify.put("/status/:code?", {
+    schema: statusSchema
+  }, handler);
+  fastify.patch("/status/:code?", {
+    schema: statusSchema
+  }, handler);
+  fastify.delete("/status/:code?", {
+    schema: statusSchema
+  }, handler);
+}, "statusCodeRoute");
+
+// src/swagger.ts
+import { fastifySwaggerUi } from "@fastify/swagger-ui";
+
+// package.json
+var package_default = {
+  name: "@jaredwray/mockhttp",
+  version: "0.7.0",
+  description: "Mock Http - Easy way to mock http with httpbin replacement",
+  type: "module",
+  main: "dist/index.js",
+  directories: {
+    test: "test"
+  },
+  scripts: {
+    lint: "biome check --write --error-on-warnings",
+    test: "pnpm lint && vitest run --coverage",
+    "test:ci": "biome check --error-on-warnings && vitest run --coverage",
+    dev: "pnpm lint && tsx src/index.ts --watch",
+    build: "rimraf ./dist && tsup src/index.ts --format esm --dts --clean",
+    "docker:build": "docker build -t jaredwray/mockhttp .",
+    "docker:run": "docker run -p 3000:3000 jaredwray/mockhttp",
+    "docker:push": "docker push jaredwray/mockhttp",
+    "docker:stop": 'docker stop $(docker ps -a -q --filter ancestor=jaredwray/mockhttp --format="{{.ID}}")',
+    "docker:readme": "tsx ./scripts/create-docker-readme.ts",
+    "docker:compose:up": "docker-compose up -d",
+    "docker:compose:down": "docker-compose down",
+    prepare: "pnpm run build",
+    start: "node dist/index.js"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/jaredwray/mockhttp.git"
+  },
+  keywords: [
+    "mock",
+    "http",
+    "httpbin",
+    "test"
+  ],
+  author: "Jared Wray <me@jaredwray.com>",
+  license: "MIT",
+  bugs: {
+    url: "https://github.com/jaredwray/mockhttp/issues"
+  },
+  homepage: "https://github.com/jaredwray/mockhttp#readme",
+  devDependencies: {
+    "@biomejs/biome": "^2.2.2",
+    "@swc/core": "^1.13.4",
+    "@types/html-escaper": "^3.0.4",
+    "@vitest/coverage-v8": "^3.2.4",
+    rimraf: "^6.0.1",
+    tsup: "^8.5.0",
+    tsx: "^4.20.4",
+    typescript: "^5.9.2",
+    vitest: "^3.2.4"
+  },
+  dependencies: {
+    "@fastify/cookie": "^11.0.2",
+    "@fastify/helmet": "^13.0.1",
+    "@fastify/static": "^8.2.0",
+    "@fastify/swagger": "^9.5.1",
+    "@fastify/swagger-ui": "^5.2.3",
+    "@scalar/api-reference": "^1.34.4",
+    "detect-port": "^2.1.0",
+    fastify: "^5.5.0",
+    hookified: "^1.12.0",
+    "html-escaper": "^3.0.3",
+    pino: "^9.9.0",
+    "pino-pretty": "^13.1.1"
+  },
+  files: [
+    "dist",
+    "public",
+    "LICENCE"
+  ],
+  pnpm: {
+    onlyBuiltDependencies: [
+      "@swc/core",
+      "unrs-resolver",
+      "vue-demi"
+    ]
+  }
+};
+
+// src/swagger.ts
+var description = `
+A simple HTTP server that can be used to mock HTTP responses for testing purposes. Inspired by [httpbin](https://httpbin.org/) and built using \`nodejs\` and \`fastify\` with the idea of running it via https://mockhttp.org, via docker \`jaredwray/mockhttp\`, or nodejs \`npm install jaredwray/mockhttp\`.
+
+* [GitHub Repository](https://github.com/jaredwray/mockhttp)
+* [Docker Image](https://hub.docker.com/r/jaredwray/mockhttp)
+* [NPM Package](https://www.npmjs.com/package/jaredwray/mockhttp)
+
+# About mockhttp.org 
+
+[mockhttp.org](https://mockhttp.org) is a free service that runs this codebase and allows you to use it for testing purposes. It is a simple way to mock HTTP responses for testing purposes. Ran via [Cloudflare](https://cloudflare.com) and [Google Cloud Run](https://cloud.google.com/run/) across 7 regions globally and can do millions of requests per second.
+`;
+var fastifySwaggerConfig = {
+  openapi: {
+    info: {
+      title: "Mock HTTP API",
+      description,
+      version: package_default.version
+    },
+    consumes: [
+      "application/json"
+    ],
+    produces: [
+      "application/json"
+    ]
+  }
+};
+var registerSwaggerUi = /* @__PURE__ */ __name(async (fastify) => {
+  await fastify.register(fastifySwaggerUi, {
+    routePrefix: "/docs",
+    uiConfig: {
+      docExpansion: "none",
+      deepLinking: false
+    },
+    uiHooks: {
+      /* c8 ignore next 6 */
+      onRequest(_request, _reply, next) {
+        next();
+      },
+      preHandler(_request, _reply, next) {
+        next();
+      }
+    },
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    staticCSP: true,
+    transformSpecification: /* @__PURE__ */ __name((swaggerObject, _request, _reply) => swaggerObject, "transformSpecification"),
+    transformSpecificationClone: true
+  });
+}, "registerSwaggerUi");
 
 // src/mock-http.ts
 var MockHttp = class extends Hookified {
@@ -1529,7 +1981,8 @@ var MockHttp = class extends Hookified {
     responseInspection: true,
     statusCodes: true,
     cookies: true,
-    anything: true
+    anything: true,
+    auth: true
   };
   // eslint-disable-next-line new-cap
   _server = Fastify();
@@ -1669,7 +2122,7 @@ var MockHttp = class extends Hookified {
       if (this._apiDocs) {
         await this.registerApiDocs();
       }
-      const { httpMethods, redirects, requestInspection, responseInspection, statusCodes: statusCodes2, cookies, anything } = this._httpBin;
+      const { httpMethods, redirects, requestInspection, responseInspection, statusCodes: statusCodes2, cookies, anything, auth } = this._httpBin;
       if (httpMethods) {
         await this.registerHttpMethods();
       }
@@ -1691,6 +2144,9 @@ var MockHttp = class extends Hookified {
       if (anything) {
         await this.registerAnythingRoutes();
       }
+      if (auth) {
+        await this.registerAuthRoutes();
+      }
       if (this._autoDetectPort) {
         const originalPort = this._port;
         this._port = await this.detectPort();
@@ -1799,6 +2255,17 @@ var MockHttp = class extends Hookified {
     const fastify = fastifyInstance ?? this._server;
     await fastify.register(anythingRoute);
   }
+  /**
+  * Register the auth routes.
+  * @param fastifyInstance - the server instance to register the routes on.
+  */
+  async registerAuthRoutes(fastifyInstance) {
+    const fastify = fastifyInstance ?? this._server;
+    await fastify.register(basicAuthRoute);
+    await fastify.register(hiddenBasicAuthRoute);
+    await fastify.register(bearerAuthRoute);
+    await fastify.register(digestAuthRoute);
+  }
 };
 
 // src/index.ts
@@ -1813,7 +2280,9 @@ var start = /* @__PURE__ */ __name(async () => {
   await mockHttp.start();
   return mockHttp;
 }, "start");
-await start();
+if (import.meta.url === `file://${process.argv[1]}`) {
+  await start();
+}
 export {
   MockHttp as default,
   MockHttp as mockhttp,