@jaredwray/mockhttp 1.0.1 → 1.1.0

package/dist/index.js

@@ -1,4 +1,1142 @@
-var $e=Object.defineProperty;var r=(s,e)=>$e(s,"name",{value:e,configurable:!0});import I from"process";import qe from"path";import pt from"@fastify/cookie";import ht from"@fastify/helmet";import _e from"@fastify/static";import{fastifySwagger as mt}from"@fastify/swagger";import{detect as ut}from"detect-port";import He from"fastify";import{Hookified as lt}from"hookified";var ce={logger:{transport:{target:"pino-pretty",options:{colorize:!0,translateTime:!0,ignore:"pid,hostname",singleLine:!0}}}};var De={description:"Will return anything that you send it",tags:["Anything"],response:{200:{type:"object",properties:{args:{type:"object",description:"Route parameters",additionalProperties:!0},data:{type:"object",description:"Request body data",additionalProperties:!0},files:{type:"object",description:"Uploaded files",additionalProperties:!0},form:{type:"object",description:"Form data",additionalProperties:!0},headers:{type:"object",description:"Request headers",additionalProperties:!0},json:{type:"object",description:"Parsed JSON body",additionalProperties:!0},method:{type:"string",description:"HTTP method used"},origin:{type:"string",description:"Origin of the request"},url:{type:"string",description:"Request URL"}},additionalProperties:!1}}},de=r(s=>{let e=r(async(o,a)=>{let i={args:o.query,data:o.body??{},files:o.raw?.files??{},form:o.body??{},headers:o.headers,json:o.body??{},method:o.method,origin:o.headers.origin??o.headers.host??"",url:o.url};await a.send(i)},"handler"),t={schema:De,validatorCompiler:r(()=>()=>!0,"validatorCompiler")};s.get("/anything",t,e),s.post("/anything",t,e),s.put("/anything",t,e),s.patch("/anything",t,e),s.delete("/anything",t,e)},"anythingRoute");import{Buffer as U}from"buffer";import{timingSafeEqual as Me}from"crypto";var Ae=r(s=>{if(!s||typeof s!="string")return;let e=s.indexOf(" ");if(e===-1)return;let t=s.slice(0,e),o=s.slice(e+1);if(!(t.toLowerCase()!=="basic"||!o))try{let a=U.from(o,"base64").toString("utf8"),i=a.indexOf(":");if(i===-1)return;let n=a.slice(0,i),d=a.slice(i+1);return n===""?void 0:{username:n,password:d}}catch{return}},"parseBasic"),pe=r((s,e)=>{if(s.length!==e.length)return!1;try{return Me(U.from(s,"utf8"),U.from(e,"utf8"))}catch{return!1}},"safeCompare"),Ie={description:"HTTP Basic authentication. Succeeds only if the user/pass provided in the path matches the Basic Authorization header.",tags:["Auth"],params:{type:"object",properties:{user:{type:"string"},passwd:{type:"string"}},required:["user","passwd"]},response:{200:{type:"object",properties:{authenticated:{type:"boolean"},user:{type:"string"}},required:["authenticated","user"]},401:{type:"object",properties:{message:{type:"string"}},required:["message"]}}},E=r(s=>{s.get("/basic-auth/:user/:passwd",{schema:Ie},async(e,t)=>{let{user:o,passwd:a}=e.params;if(!o||typeof o!="string"||typeof a!="string")return t.header("WWW-Authenticate",'Basic realm="mockhttp"'),t.status(401).send({message:"Unauthorized"});let i=Ae(e.headers.authorization);return!i||!pe(i.username,o)||!pe(i.password,a)?(t.header("WWW-Authenticate",'Basic realm="mockhttp"'),t.status(401).send({message:"Unauthorized"})):t.send({authenticated:!0,user:o})})},"basicAuthRoute");var ze=r(s=>{if(!s)return;let[e,t]=s.split(" ");if(!(!e||e.toLowerCase()!=="bearer"||!t))return t},"parseBearer"),Le={description:"HTTP Bearer authentication. Succeeds if any Bearer token is present unless ?required=true is provided.",tags:["Auth"],querystring:{type:"object",properties:{required:{type:"boolean",default:!0}}},response:{200:{type:"object",properties:{authenticated:{type:"boolean"},token:{type:"string"}},required:["authenticated","token"]},401:{type:"object",properties:{message:{type:"string"}},required:["message"]}}},O=r(s=>{s.get("/bearer",{schema:Le},async(e,t)=>{let o=ze(e.headers.authorization),i=e.query?.required??!0;return!o&&i?(t.header("WWW-Authenticate","Bearer"),t.status(401).send({message:"Unauthorized"})):o?t.send({authenticated:!0,token:o}):t.send({authenticated:!1,token:""})})},"bearerAuthRoute");import le from"crypto";var w=r(()=>le.randomBytes(16).toString("hex"),"makeNonce"),Ue=new Set(["MD5","md5","SHA-256","sha-256","SHA-512","sha-512"]),he=r(s=>{if(!s)return"md5";let e=s.toLowerCase();return e==="md5"?"md5":e==="sha-256"?"sha256":e==="sha-512"?"sha512":"md5"},"hashAlg"),x=r((s,e)=>le.createHash(s).update(e).digest("hex"),"h"),me=r(s=>{if(!s)return;let e=s.indexOf(" ");if(e===-1)return;let t=s.slice(0,e),o=s.slice(e+1);if(!t||t.toLowerCase()!=="digest"||!o)return;let a={},i=[],n="",d=!1;for(let g of o)g==='"'?(d=!d,n+=g):g===","&&!d?(n.trim()&&i.push(n.trim()),n=""):n+=g;if(n.trim()&&i.push(n.trim()),i.length===0)return a;for(let g of i){let h=g.indexOf("=");if(h===-1)continue;let l=g.slice(0,h).trim(),p=g.slice(h+1).trim();p.startsWith('"')&&p.endsWith('"')&&(p=p.slice(1,-1)),a[l]=p}return a},"parseDigest"),ue={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"},stale_after:{type:"string"}},required:["qop","user","passwd"]}},B=r(s=>{s.get("/digest-auth/:qop/:user/:passwd",{schema:ue},async(e,t)=>{let{user:o,passwd:a}=e.params,i="mockhttp",n=w(),d=me(e.headers.authorization);if(!d)return t.header("WWW-Authenticate",`Digest realm="${i}", qop="auth,auth-int", nonce="${n}", opaque="${w()}"`),t.status(401).send({message:"Unauthorized"});if(d.username!==o)return t.header("WWW-Authenticate",`Digest realm="${i}", qop="auth,auth-int", nonce="${n}", opaque="${w()}"`),t.status(401).send({message:"Unauthorized"});let g="GET",h=d.uri??e.url.replace(/^https?:\/\/[^/]+/,""),l=he(d.algorithm),c=x(l,`${o}:${i}:${a}`),p=x(l,`${g}:${h}`),u="";return u=d.qop?x(l,`${c}:${d.nonce}:${d.nc}:${d.cnonce}:${d.qop}:${p}`):x(l,`${c}:${d.nonce}:${p}`),!d.response||d.response!==u?(t.header("WWW-Authenticate",`Digest realm="${i}", qop="auth,auth-int", nonce="${n}", opaque="${w()}"`),t.status(401).send({message:"Unauthorized"})):t.send({authenticated:!0,user:o})}),s.get("/digest-auth/:qop/:user/:passwd/:algorithm",{schema:ue},async(e,t)=>{let{user:o,passwd:a,algorithm:i}=e.params,n="mockhttp",d=Ue.has(String(i))?String(i):"MD5",g=w(),h=me(e.headers.authorization);if(!h)return t.header("WWW-Authenticate",`Digest realm="${n}", qop="auth,auth-int", algorithm=${d}, nonce="${g}", opaque="${w()}"`),t.status(401).send({message:"Unauthorized"});if(h.username!==o)return t.header("WWW-Authenticate",`Digest realm="${n}", qop="auth,auth-int", algorithm=${d}, nonce="${g}", opaque="${w()}"`),t.status(401).send({message:"Unauthorized"});let l="GET",c=h.uri??e.url.replace(/^https?:\/\/[^/]+/,""),p=he(h.algorithm??d),u=x(p,`${o}:${n}:${a}`),m=x(p,`${l}:${c}`),y=h.qop?x(p,`${u}:${h.nonce}:${h.nc}:${h.cnonce}:${h.qop}:${m}`):x(p,`${u}:${h.nonce}:${m}`);return!h.response||h.response!==y?(t.header("WWW-Authenticate",`Digest realm="${n}", qop="auth,auth-int", algorithm=${d}, nonce="${g}", opaque="${w()}"`),t.status(401).send({message:"Unauthorized"})):t.send({authenticated:!0,user:o})})},"digestAuthRoute");import{Buffer as Ee}from"buffer";var Oe=r(s=>{if(!s)return;let[e,t]=s.split(" ");if(!(!e||e.toLowerCase()!=="basic"||!t))try{let o=Ee.from(t,"base64").toString("utf8"),a=o.indexOf(":");return a===-1?void 0:{username:o.slice(0,a),password:o.slice(a+1)}}catch{return}},"parseBasic"),Be={description:"HTTP Basic authentication with docs hidden. Mirrors /basic-auth but hides from schema.",tags:["Auth"],hide:!0,params:{type:"object",properties:{user:{type:"string"},passwd:{type:"string"}},required:["user","passwd"]}},F=r(s=>{s.get("/hidden-basic-auth/:user/:passwd",{schema:Be},async(e,t)=>{let{user:o,passwd:a}=e.params,i=Oe(e.headers.authorization);return!i||i.username!==o||i.password!==a?(t.header("WWW-Authenticate",'Basic realm="mockhttp"'),t.status(401).send({message:"Unauthorized"})):t.send({authenticated:!0,user:o})})},"hiddenBasicAuthRoute");var Fe={description:"Delete a cookie",tags:["Cookies"],querystring:{type:"object",properties:{name:{type:"string"}},required:["name"],additionalProperties:!1},response:{204:{type:"null"}}},W=r(s=>{s.delete("/cookies",{schema:Fe},async(e,t)=>{let{name:o}=e.query;return t.clearCookie(o,{path:"/"}),t.status(204).send()})},"deleteCookieRoute");var We={description:"Return cookies from the request",tags:["Cookies"],response:{200:{type:"object",properties:{cookies:{type:"object",additionalProperties:{type:"string"}}},required:["cookies"]}}},N=r(s=>{s.get("/cookies",{schema:We},async(e,t)=>{t.type("application/json"),await t.send({cookies:e.cookies})})},"getCookiesRoute");var Ne={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:!1},response:{200:{type:"object",properties:{cookies:{type:"object",additionalProperties:{type:"string"}}},required:["cookies"]}}},G=r(s=>{s.post("/cookies",{schema:Ne},async(e,t)=>{let{name:o,value:a,expires:i}=e.body;if(i){let n=new Date(i);t.setCookie(o,a,{path:"/",expires:n})}else t.setCookie(o,a,{path:"/"});return t.status(200).send()})},"postCookieRoute");var Ge={description:"Handles a DELETE request and returns request information",tags:["HTTP Methods"],response:{200:{type:"object",properties:{method:{type:"string"},headers:{type:"object",additionalProperties:{type:"string"}},body:{oneOf:[{type:"object",additionalProperties:!0},{type:"string"},{type:"null"}]}},required:["method","headers"]}}},J=r(s=>{s.delete("/delete",{schema:Ge},async e=>({method:"DELETE",headers:e.headers,body:e.body}))},"deleteRoute");var Je={description:"Returns request information for GET requests",tags:["HTTP Methods"],querystring:{type:"object",additionalProperties:!0,properties:{},description:"Query parameters sent in the request"},headers:{type:"object",additionalProperties:!0,properties:{},description:"Headers sent in the request"},response:{200:{type:"object",properties:{method:{type:"string"},headers:{type:"object",additionalProperties:{type:"string"}},queryParams:{type:"object",additionalProperties:{type:"string"}}},required:["method","headers","queryParams"]}}},Y=r(s=>{s.get("/get",{schema:Je},async(e,t)=>({method:"GET",headers:e.headers,queryParams:e.query}))},"getRoute");var Ye={description:"Handles a PATCH request and returns request information",tags:["HTTP Methods"],body:{type:"object",additionalProperties:!0,description:"The body of the PATCH request"},response:{200:{type:"object",properties:{method:{type:"string"},headers:{type:"object",additionalProperties:{type:"string"}},body:{type:"object",additionalProperties:!0}},required:["method","headers","body"]}}},Z=r(s=>{s.patch("/patch",{schema:Ye},async e=>({method:"PATCH",headers:e.headers,body:e.body}))},"patchRoute");var Ze={description:"Handles a POST request and returns request information",tags:["HTTP Methods"],body:{type:"object",additionalProperties:!0,description:"The body of the POST request"},response:{200:{type:"object",properties:{method:{type:"string"},headers:{type:"object",additionalProperties:{type:"string"}},body:{type:"object",additionalProperties:!0}},required:["method","headers","body"]}}},V=r(s=>{s.post("/post",{schema:Ze},async e=>({method:"POST",headers:e.headers,body:e.body}))},"postRoute");var Ve={description:"Handles a PUT request and returns request information",tags:["HTTP Methods"],body:{type:"object",additionalProperties:!0,description:"The body of the PUT request"},response:{200:{type:"object",properties:{method:{type:"string"},headers:{type:"object",additionalProperties:{type:"string"}},body:{type:"object",additionalProperties:!0}},required:["method","headers","body"]}}},X=r(s=>{s.put("/put",{schema:Ve},async e=>({method:"PUT",headers:e.headers,body:e.body}))},"putRoute");var ge=r(s=>{s.get("/",{schema:{hide:!0}},async(e,t)=>{await t.type("text/html").send(`
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/index.ts
+import process2 from "process";
+
+// src/mock-http.ts
+import path from "path";
+import fastifyCookie from "@fastify/cookie";
+import fastifyHelmet from "@fastify/helmet";
+import fastifyRateLimit from "@fastify/rate-limit";
+import fastifyStatic from "@fastify/static";
+import { fastifySwagger } from "@fastify/swagger";
+import { detect } from "detect-port";
+import Fastify from "fastify";
+import { Hookified } from "hookified";
+
+// src/fastify-config.ts
+var fastifyConfig = {
+  logger: {
+    transport: {
+      target: "pino-pretty",
+      options: {
+        colorize: true,
+        translateTime: true,
+        ignore: "pid,hostname",
+        singleLine: true
+      }
+    }
+  }
+};
+
+// src/routes/anything/index.ts
+var anythingSchema = {
+  description: "Will return anything that you send it",
+  tags: [
+    "Anything"
+  ],
+  response: {
+    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"
+        }
+      },
+      // Don’t allow any other top-level keys in your response
+      additionalProperties: false
+    }
+  }
+};
+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
+    /* v8 ignore next -- @preserve */
+    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/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: [
+    "Auth"
+  ],
+  params: {
+    type: "object",
+    properties: {
+      user: {
+        type: "string"
+      },
+      passwd: {
+        type: "string"
+      }
+    },
+    required: [
+      "user",
+      "passwd"
+    ]
+  },
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        authenticated: {
+          type: "boolean"
+        },
+        user: {
+          type: "string"
+        }
+      },
+      required: [
+        "authenticated",
+        "user"
+      ]
+    },
+    401: {
+      type: "object",
+      properties: {
+        message: {
+          type: "string"
+        }
+      },
+      required: [
+        "message"
+      ]
+    }
+  }
+};
+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/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: [
+    "Auth"
+  ],
+  querystring: {
+    type: "object",
+    properties: {
+      required: {
+        type: "boolean",
+        default: true
+      }
+    }
+  },
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        authenticated: {
+          type: "boolean"
+        },
+        token: {
+          type: "string"
+        }
+      },
+      required: [
+        "authenticated",
+        "token"
+      ]
+    },
+    401: {
+      type: "object",
+      properties: {
+        message: {
+          type: "string"
+        }
+      },
+      required: [
+        "message"
+      ]
+    }
+  }
+};
+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/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"
+      },
+      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
+  },
+  response: {
+    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: {
+    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: {
+    200: {
+      type: "object",
+      properties: {
+        cookies: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        }
+      },
+      required: [
+        "cookies"
+      ]
+    }
+  }
+};
+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();
+  });
+}, "postCookieRoute");
+
+// src/routes/http-methods/delete.ts
+var deleteSchema = {
+  description: "Handles a DELETE request and returns request information",
+  tags: [
+    "HTTP Methods"
+  ],
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        method: {
+          type: "string"
+        },
+        headers: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        },
+        body: {
+          oneOf: [
+            {
+              type: "object",
+              additionalProperties: true
+            },
+            {
+              type: "string"
+            },
+            {
+              type: "null"
+            }
+          ]
+        }
+      },
+      required: [
+        "method",
+        "headers"
+      ]
+    }
+  }
+};
+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/get.ts
+var getSchema = {
+  description: "Returns request information for GET requests",
+  tags: [
+    "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: {
+    200: {
+      type: "object",
+      properties: {
+        method: {
+          type: "string"
+        },
+        headers: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        },
+        queryParams: {
+          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/patch.ts
+var patchSchema = {
+  description: "Handles a PATCH request and returns request information",
+  tags: [
+    "HTTP Methods"
+  ],
+  body: {
+    type: "object",
+    additionalProperties: true,
+    description: "The body of the PATCH request"
+  },
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        method: {
+          type: "string"
+        },
+        headers: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        },
+        body: {
+          type: "object",
+          additionalProperties: true
+        }
+      },
+      required: [
+        "method",
+        "headers",
+        "body"
+      ]
+    }
+  }
+};
+var patchRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.patch("/patch", {
+    schema: patchSchema
+  }, async (request) => ({
+    method: "PATCH",
+    headers: request.headers,
+    body: request.body
+  }));
+}, "patchRoute");
+
+// 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: {
+    200: {
+      type: "object",
+      properties: {
+        method: {
+          type: "string"
+        },
+        headers: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        },
+        body: {
+          type: "object",
+          additionalProperties: true
+        }
+      },
+      required: [
+        "method",
+        "headers",
+        "body"
+      ]
+    }
+  }
+};
+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: [
+    "HTTP Methods"
+  ],
+  body: {
+    type: "object",
+    additionalProperties: true,
+    description: "The body of the PUT request"
+  },
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        method: {
+          type: "string"
+        },
+        headers: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        },
+        body: {
+          type: "object",
+          additionalProperties: true
+        }
+      },
+      required: [
+        "method",
+        "headers",
+        "body"
+      ]
+    }
+  }
+};
+var putRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.put("/put", {
+    schema: putSchema
+  }, async (request) => ({
+    method: "PUT",
+    headers: request.headers,
+    body: request.body
+  }));
+}, "putRoute");
+
+// src/routes/images/index.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+var imageSchema = {
+  description: "Returns an image based on Accept header (supports jpeg, png, svg, webp)",
+  tags: [
+    "Images"
+  ],
+  headers: {
+    type: "object",
+    properties: {
+      accept: {
+        type: "string",
+        description: "Accept header for content negotiation"
+      }
+    }
+  },
+  response: {
+    200: {
+      description: "Image file",
+      type: "string",
+      format: "binary"
+    }
+  }
+};
+var jpegSchema = {
+  description: "Returns a JPEG image",
+  tags: [
+    "Images"
+  ],
+  response: {
+    200: {
+      description: "JPEG image",
+      type: "string",
+      format: "binary"
+    }
+  }
+};
+var pngSchema = {
+  description: "Returns a PNG image",
+  tags: [
+    "Images"
+  ],
+  response: {
+    200: {
+      description: "PNG image",
+      type: "string",
+      format: "binary"
+    }
+  }
+};
+var svgSchema = {
+  description: "Returns an SVG image",
+  tags: [
+    "Images"
+  ],
+  response: {
+    200: {
+      description: "SVG image",
+      type: "string",
+      format: "binary"
+    }
+  }
+};
+var webpSchema = {
+  description: "Returns a WEBP image",
+  tags: [
+    "Images"
+  ],
+  response: {
+    200: {
+      description: "WEBP image",
+      type: "string",
+      format: "binary"
+    }
+  }
+};
+var imageRoutes = /* @__PURE__ */ __name((fastify) => {
+  const publicPath = join(process.cwd(), "public");
+  fastify.get("/image", {
+    schema: imageSchema
+  }, async (request, reply) => {
+    const accept = request.headers.accept || "";
+    let file = "logo.png";
+    let contentType = "image/png";
+    if (accept.includes("image/jpeg") || accept.includes("image/jpg")) {
+      file = "logo.jpg";
+      contentType = "image/jpeg";
+    } else if (accept.includes("image/svg+xml") || accept.includes("image/svg")) {
+      file = "logo.svg";
+      contentType = "image/svg+xml";
+    } else if (accept.includes("image/webp")) {
+      file = "logo.webp";
+      contentType = "image/webp";
+    } else if (accept.includes("image/png")) {
+      file = "logo.png";
+      contentType = "image/png";
+    }
+    try {
+      const imagePath = join(publicPath, file);
+      const imageBuffer = readFileSync(imagePath);
+      reply.type(contentType);
+      return imageBuffer;
+    } catch (error) {
+      reply.code(500);
+      return {
+        error: `${error}`
+      };
+    }
+  });
+  fastify.get("/image/jpeg", {
+    schema: jpegSchema
+  }, async (_request, reply) => {
+    try {
+      const imagePath = join(publicPath, "logo.jpg");
+      const imageBuffer = readFileSync(imagePath);
+      reply.type("image/jpeg");
+      return imageBuffer;
+    } catch (error) {
+      reply.code(500);
+      return {
+        error: `${error}`
+      };
+    }
+  });
+  fastify.get("/image/png", {
+    schema: pngSchema
+  }, async (_request, reply) => {
+    try {
+      const imagePath = join(publicPath, "logo.png");
+      const imageBuffer = readFileSync(imagePath);
+      reply.type("image/png");
+      return imageBuffer;
+    } catch (error) {
+      reply.code(500);
+      return {
+        error: `${error}`
+      };
+    }
+  });
+  fastify.get("/image/svg", {
+    schema: svgSchema
+  }, async (_request, reply) => {
+    try {
+      const imagePath = join(publicPath, "logo.svg");
+      const imageBuffer = readFileSync(imagePath);
+      reply.type("image/svg+xml");
+      return imageBuffer;
+    } catch (error) {
+      reply.code(500);
+      return {
+        error: `${error}`
+      };
+    }
+  });
+  fastify.get("/image/webp", {
+    schema: webpSchema
+  }, async (_request, reply) => {
+    try {
+      const imagePath = join(publicPath, "logo.webp");
+      const imageBuffer = readFileSync(imagePath);
+      reply.type("image/webp");
+      return imageBuffer;
+    } catch (error) {
+      reply.code(500);
+      return {
+        error: `${error}`
+      };
+    }
+  });
+}, "imageRoutes");
+
+// src/routes/index.ts
+var indexRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/", {
+    schema: {
+      hide: true
+    }
+  }, async (_request, reply) => {
+    const redocHtml = `
 	<!doctype html>
 <html>
   <head>
@@ -62,23 +1200,405 @@ var $e=Object.defineProperty;var r=(s,e)=>$e(s,"name",{value:e,configurable:!0})
     <script src="/scalar/browser/standalone.js"></script>
   </body>
 </html>
-`)})},"indexRoute");var Xe={tags:["Redirects"],description:"Redirects the request to the target URL using an absolute URL",params:{type:"object",properties:{value:{type:"integer",minimum:1}},required:["value"]},headers:{type:"object",properties:{host:{type:"string"}},required:["host"]},response:{302:{type:"string"}}},K=r(s=>{s.get("/absolute-redirect/:value",{schema:Xe},async(e,t)=>{let{value:o}=e.params,{host:a}=e.headers,{protocol:i}=e,n=`${i}://${a}/get`,d=`
+`;
+    await reply.type("text/html").send(redocHtml);
+  });
+}, "indexRoute");
+
+// src/routes/redirects/absolute-redirect.ts
+var absoluteRedirectSchema = {
+  tags: [
+    "Redirects"
+  ],
+  description: "Redirects the request to the target URL using an absolute URL",
+  params: {
+    type: "object",
+    properties: {
+      value: {
+        type: "integer",
+        minimum: 1
+      }
+    },
+    required: [
+      "value"
+    ]
+  },
+  headers: {
+    type: "object",
+    properties: {
+      host: {
+        type: "string"
+      }
+    },
+    required: [
+      "host"
+    ]
+  },
+  response: {
+    302: {
+      type: "string"
+    }
+  }
+};
+var absoluteRedirectRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/absolute-redirect/:value", {
+    schema: absoluteRedirectSchema
+  }, async (request, reply) => {
+    const { value } = request.params;
+    const { host } = request.headers;
+    const { protocol } = request;
+    let url = `${protocol}://${host}/get`;
+    let html = `
         <title>Redirecting...</title>
         <h1>Redirecting...</h1>
-        <p>You should be redirected automatically to target URL: <a href="${n}">${n}</a>.  If not click the link.</p>
-        `;o>1&&(n=`${i}://${a}/absolute-redirect/${o-1}`,d=`
+        <p>You should be redirected automatically to target URL: <a href="${url}">${url}</a>.  If not click the link.</p>
+        `;
+    if (value > 1) {
+      url = `${protocol}://${host}/absolute-redirect/${value - 1}`;
+      html = `
             <title>Redirecting...</title>
             <h1>Redirecting...</h1>
-            <p>You should be redirected automatically to target URL: <a href="${n}">${n}</a>.  If not click the link.</p>
-            `),await t.header("Location",n).status(302).type("text/html").send(d)})},"absoluteRedirectRoute");var T={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"},status_code:{type:"string",pattern:"^[1-5][0-9][0-9]$",description:"The HTTP status code to use for redirection"}},required:["url"],additionalProperties:!1}},Q=r(s=>{let e=r(async(t,o)=>{let{url:a,status_code:i}=t.query,n=i?Number(i):302;await o.redirect(a,n)},"handler");s.get("/redirect-to",{schema:T},e),s.post("/redirect-to",{schema:T},e),s.put("/redirect-to",{schema:T},e),s.patch("/redirect-to",{schema:T},e),s.delete("/redirect-to",{schema:T},e)},"redirectToRoute");var Ke={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:{302:{type:"string"}}},ee=r(s=>{s.get("/relative-redirect/:value",{schema:Ke},async(e,t)=>{let{value:o}=e.params,a="/get",i=`
+            <p>You should be redirected automatically to target URL: <a href="${url}">${url}</a>.  If not click the link.</p>
+            `;
+    }
+    await reply.header("Location", url).status(302).type("text/html").send(html);
+  });
+}, "absoluteRedirectRoute");
+
+// 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"
+      },
+      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/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: {
+    302: {
+      type: "string"
+    }
+  }
+};
+var relativeRedirectRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/relative-redirect/:value", {
+    schema: relativeRedirectSchema
+  }, async (request, reply) => {
+    const { value } = request.params;
+    let url = "/get";
+    let html = `
         <title>Redirecting...</title>
         <h1>Redirecting...</h1>
-        <p>You should be redirected automatically to target URL: <a href="${a}">${a}</a>.  If not click the link.</p>
-        `;o>1&&(a=`/relative-redirect/${o-1}`,i=`
+        <p>You should be redirected automatically to target URL: <a href="${url}">${url}</a>.  If not click the link.</p>
+        `;
+    if (value > 1) {
+      url = `/relative-redirect/${value - 1}`;
+      html = `
             <title>Redirecting...</title>
             <h1>Redirecting...</h1>
-            <p>You should be redirected automatically to target URL: <a href="${a}">${a}</a>.  If not click the link.</p>
-            `),await t.header("Location",a).status(302).type("text/html").send(i)})},"relativeRedirectRoute");var Qe={description:"Returns all headers of the client request",tags:["Request Inspection"],response:{200:{type:"object",properties:{headers:{type:"object",additionalProperties:{type:"string"},description:"All headers of the client request"}},required:["headers"]}}},te=r(s=>{s.get("/headers",{schema:Qe},async e=>{let{headers:t}=e;return{headers:t}})},"headersRoute");var et={description:"Returns the IP address of the client",tags:["Request Inspection"],response:{200:{type:"object",properties:{ip:{type:"string",description:"The IP address of the client"}},required:["ip"]}}},se=r(s=>{s.get("/ip",{schema:et},async e=>{let t=e.headers["cf-connecting-ip"],o=e.headers["x-forwarded-for"],a=e.ip;return{ip:t??(typeof o=="string"?o.split(",")[0].trim():a)}})},"ipRoute");var tt={description:"Returns the User-Agent header of the client request",tags:["Request Inspection"],response:{200:{type:"object",properties:{userAgent:{type:"string",description:"The User-Agent header of the client request"}},required:["userAgent"]}}},oe=r(s=>{s.get("/user-agent",{schema:tt},async e=>({userAgent:e.headers["user-agent"]}))},"userAgentRoute");import{brotliCompressSync as fe,deflateSync as ye,gzipSync as be}from"zlib";var S={description:"Returns random plain text content",tags:["Response Formats"],response:{200:{type:"string",description:"Random plain text content"}}},j={description:"Returns random text content",tags:["Response Formats"],response:{200:{type:"string",description:"Random text content"}}},C={description:"Returns random HTML content",tags:["Response Formats"],response:{200:{type:"string",description:"Random HTML content"}}},P={description:"Returns random XML content",tags:["Response Formats"],response:{200:{type:"string",description:"Random XML content"}}},q={description:"Returns random JSON content",tags:["Response Formats"],response:{200:{type:"object",description:"Random JSON content",additionalProperties:!0}}},_={description:"Returns page denied by robots.txt rules",tags:["Response Formats"],response:{403:{type:"string",description:"Page denied by robots.txt rules"}}},H={description:"Returns GZip-encoded data",tags:["Response Formats"],response:{200:{type:"string",description:"GZip-encoded content"}}},$={description:"Returns Deflate-encoded data",tags:["Response Formats"],response:{200:{type:"string",description:"Deflate-encoded content"}}},D={description:"Returns Brotli-encoded data",tags:["Response Formats"],response:{200:{type:"string",description:"Brotli-encoded content"}}},z=["The quick brown fox jumps over the lazy dog.","Lorem ipsum dolor sit amet, consectetur adipiscing elit.","To be or not to be, that is the question.","All work and no play makes Jack a dull boy.","The only way to do great work is to love what you do.","In the beginning was the Word, and the Word was with God.","Once upon a time in a galaxy far, far away...","It was the best of times, it was the worst of times.","The journey of a thousand miles begins with a single step.","Knowledge is power. France is bacon."],Re=[`<!DOCTYPE html>
+            <p>You should be redirected automatically to target URL: <a href="${url}">${url}</a>.  If not click the link.</p>
+            `;
+    }
+    await reply.header("Location", url).status(302).type("text/html").send(html);
+  });
+}, "relativeRedirectRoute");
+
+// src/routes/request-inspection/headers.ts
+var headersSchema = {
+  description: "Returns all headers of the client request",
+  tags: [
+    "Request Inspection"
+  ],
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        headers: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          },
+          description: "All headers of the client request"
+        }
+      },
+      required: [
+        "headers"
+      ]
+    }
+  }
+};
+var headersRoute = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/headers", {
+    schema: headersSchema
+  }, async (request) => {
+    const { headers } = request;
+    return {
+      headers
+    };
+  });
+}, "headersRoute");
+
+// src/routes/request-inspection/ip.ts
+var ipSchema = {
+  description: "Returns the IP address of the client",
+  tags: [
+    "Request Inspection"
+  ],
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        ip: {
+          type: "string",
+          description: "The IP address of the client"
+        }
+      },
+      required: [
+        "ip"
+      ]
+    }
+  }
+};
+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");
+
+// src/routes/request-inspection/user-agent.ts
+var userAgentSchema = {
+  description: "Returns the User-Agent header of the client request",
+  tags: [
+    "Request Inspection"
+  ],
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        userAgent: {
+          type: "string",
+          description: "The User-Agent header of the client request"
+        }
+      },
+      required: [
+        "userAgent"
+      ]
+    }
+  }
+};
+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-formats/index.ts
+import { brotliCompressSync, deflateSync, gzipSync } from "zlib";
+var plainSchema = {
+  description: "Returns random plain text content",
+  tags: [
+    "Response Formats"
+  ],
+  response: {
+    200: {
+      type: "string",
+      description: "Random plain text content"
+    }
+  }
+};
+var textSchema = {
+  description: "Returns random text content",
+  tags: [
+    "Response Formats"
+  ],
+  response: {
+    200: {
+      type: "string",
+      description: "Random text content"
+    }
+  }
+};
+var htmlSchema = {
+  description: "Returns random HTML content",
+  tags: [
+    "Response Formats"
+  ],
+  response: {
+    200: {
+      type: "string",
+      description: "Random HTML content"
+    }
+  }
+};
+var xmlSchema = {
+  description: "Returns random XML content",
+  tags: [
+    "Response Formats"
+  ],
+  response: {
+    200: {
+      type: "string",
+      description: "Random XML content"
+    }
+  }
+};
+var jsonSchema = {
+  description: "Returns random JSON content",
+  tags: [
+    "Response Formats"
+  ],
+  response: {
+    200: {
+      type: "object",
+      description: "Random JSON content",
+      additionalProperties: true
+    }
+  }
+};
+var denySchema = {
+  description: "Returns page denied by robots.txt rules",
+  tags: [
+    "Response Formats"
+  ],
+  response: {
+    403: {
+      type: "string",
+      description: "Page denied by robots.txt rules"
+    }
+  }
+};
+var gzipSchema = {
+  description: "Returns GZip-encoded data",
+  tags: [
+    "Response Formats"
+  ],
+  response: {
+    200: {
+      type: "string",
+      description: "GZip-encoded content"
+    }
+  }
+};
+var deflateSchema = {
+  description: "Returns Deflate-encoded data",
+  tags: [
+    "Response Formats"
+  ],
+  response: {
+    200: {
+      type: "string",
+      description: "Deflate-encoded content"
+    }
+  }
+};
+var brotliSchema = {
+  description: "Returns Brotli-encoded data",
+  tags: [
+    "Response Formats"
+  ],
+  response: {
+    200: {
+      type: "string",
+      description: "Brotli-encoded content"
+    }
+  }
+};
+var randomTexts = [
+  "The quick brown fox jumps over the lazy dog.",
+  "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
+  "To be or not to be, that is the question.",
+  "All work and no play makes Jack a dull boy.",
+  "The only way to do great work is to love what you do.",
+  "In the beginning was the Word, and the Word was with God.",
+  "Once upon a time in a galaxy far, far away...",
+  "It was the best of times, it was the worst of times.",
+  "The journey of a thousand miles begins with a single step.",
+  "Knowledge is power. France is bacon."
+];
+var randomHtmlContent = [
+  `<!DOCTYPE html>
 <html lang="en">
 <head>
     <title>Sample Page</title>
@@ -87,7 +1607,8 @@ var $e=Object.defineProperty;var r=(s,e)=>$e(s,"name",{value:e,configurable:!0})
     <h1>Welcome to MockHTTP</h1>
     <p>This is a sample HTML page with random content.</p>
 </body>
-</html>`,`<!DOCTYPE html>
+</html>`,
+  `<!DOCTYPE html>
 <html>
 <head>
     <meta charset="UTF-8">
@@ -108,7 +1629,8 @@ var $e=Object.defineProperty;var r=(s,e)=>$e(s,"name",{value:e,configurable:!0})
         <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit.</p>
     </main>
 </body>
-</html>`,`<!DOCTYPE html>
+</html>`,
+  `<!DOCTYPE html>
 <html lang="en">
 <head>
     <title>Article Page</title>
@@ -126,7 +1648,8 @@ var $e=Object.defineProperty;var r=(s,e)=>$e(s,"name",{value:e,configurable:!0})
         </blockquote>
     </article>
 </body>
-</html>`,`<!DOCTYPE html>
+</html>`,
+  `<!DOCTYPE html>
 <html>
 <head>
     <title>Form Example</title>
@@ -143,7 +1666,8 @@ var $e=Object.defineProperty;var r=(s,e)=>$e(s,"name",{value:e,configurable:!0})
         <button type="submit">Submit</button>
     </form>
 </body>
-</html>`,`<!DOCTYPE html>
+</html>`,
+  `<!DOCTYPE html>
 <html lang="en">
 <head>
     <meta charset="UTF-8">
@@ -157,19 +1681,24 @@ var $e=Object.defineProperty;var r=(s,e)=>$e(s,"name",{value:e,configurable:!0})
         <img src="placeholder.jpg" alt="Placeholder" style="max-width: 100%; height: auto;">
     </div>
 </body>
-</html>`],we=[`<?xml version="1.0" encoding="UTF-8"?>
+</html>`
+];
+var randomXmlContent = [
+  `<?xml version="1.0" encoding="UTF-8"?>
 <root>
     <message>Hello from MockHTTP</message>
-    <timestamp>${new Date().toISOString()}</timestamp>
+    <timestamp>${(/* @__PURE__ */ new Date()).toISOString()}</timestamp>
     <status>success</status>
-</root>`,`<?xml version="1.0" encoding="UTF-8"?>
+</root>`,
+  `<?xml version="1.0" encoding="UTF-8"?>
 <book>
     <title>The Great Gatsby</title>
     <author>F. Scott Fitzgerald</author>
     <year>1925</year>
     <publisher>Charles Scribner's Sons</publisher>
     <isbn>978-0-7432-7356-5</isbn>
-</book>`,`<?xml version="1.0" encoding="UTF-8"?>
+</book>`,
+  `<?xml version="1.0" encoding="UTF-8"?>
 <users>
     <user id="1">
         <name>John Doe</name>
@@ -181,7 +1710,8 @@ var $e=Object.defineProperty;var r=(s,e)=>$e(s,"name",{value:e,configurable:!0})
         <email>jane@example.com</email>
         <role>user</role>
     </user>
-</users>`,`<?xml version="1.0" encoding="UTF-8"?>
+</users>`,
+  `<?xml version="1.0" encoding="UTF-8"?>
 <product>
     <id>12345</id>
     <name>Wireless Mouse</name>
@@ -189,7 +1719,8 @@ var $e=Object.defineProperty;var r=(s,e)=>$e(s,"name",{value:e,configurable:!0})
     <price currency="USD">29.99</price>
     <stock>150</stock>
     <category>Electronics</category>
-</product>`,`<?xml version="1.0" encoding="UTF-8"?>
+</product>`,
+  `<?xml version="1.0" encoding="UTF-8"?>
 <rss version="2.0">
     <channel>
         <title>Mock RSS Feed</title>
@@ -199,17 +1730,210 @@ var $e=Object.defineProperty;var r=(s,e)=>$e(s,"name",{value:e,configurable:!0})
             <title>First Article</title>
             <link>http://example.com/article1</link>
             <description>This is the first article in our feed</description>
-            <pubDate>${new Date().toUTCString()}</pubDate>
+            <pubDate>${(/* @__PURE__ */ new Date()).toUTCString()}</pubDate>
         </item>
     </channel>
-</rss>`],xe=[()=>({message:"Hello from MockHTTP",timestamp:new Date().toISOString(),status:"success",code:200}),()=>({user:{id:1,name:"John Doe",email:"john@example.com",role:"admin",createdAt:"2024-01-15T10:30:00Z"},permissions:["read","write","delete"]}),()=>({products:[{id:101,name:"Laptop",price:999.99,stock:50},{id:102,name:"Mouse",price:29.99,stock:200}],total:2,page:1}),()=>({config:{theme:"dark",language:"en",notifications:{email:!0,push:!1,sms:!1},privacy:{profile:"public",activity:"friends"}}}),()=>({metrics:{cpu:45.2,memory:78.5,disk:62.3,network:{inbound:"1.2MB/s",outbound:"0.8MB/s"},uptime:"15 days",services:[{name:"api",status:"healthy"},{name:"database",status:"healthy"},{name:"cache",status:"warning"}]}})],ke=r(s=>{let e=r(async(l,c)=>{let p=Math.floor(Math.random()*z.length),u=z[p];return c.type("text/plain"),u},"plainHandler");s.get("/plain",{schema:S},e),s.post("/plain",{schema:S},e),s.put("/plain",{schema:S},e),s.patch("/plain",{schema:S},e),s.delete("/plain",{schema:S},e);let t=r(async(l,c)=>{let p=Math.floor(Math.random()*z.length),u=z[p];return c.type("text/plain"),u},"textHandler");s.get("/text",{schema:j},t),s.post("/text",{schema:j},t),s.put("/text",{schema:j},t),s.patch("/text",{schema:j},t),s.delete("/text",{schema:j},t);let o=r(async(l,c)=>{let p=Math.floor(Math.random()*Re.length),u=Re[p];return c.type("text/html"),u},"htmlHandler");s.get("/html",{schema:C},o),s.post("/html",{schema:C},o),s.put("/html",{schema:C},o),s.patch("/html",{schema:C},o),s.delete("/html",{schema:C},o);let a=r(async(l,c)=>{let p=Math.floor(Math.random()*we.length),u=we[p];return c.type("application/xml"),u},"xmlHandler");s.get("/xml",{schema:P},a),s.post("/xml",{schema:P},a),s.put("/xml",{schema:P},a),s.patch("/xml",{schema:P},a),s.delete("/xml",{schema:P},a);let i=r(async(l,c)=>{let p=Math.floor(Math.random()*xe.length),u=xe[p],m=u();return c.type("application/json"),m},"jsonHandler");s.get("/json",{schema:q},i),s.post("/json",{schema:q},i),s.put("/json",{schema:q},i),s.patch("/json",{schema:q},i),s.delete("/json",{schema:q},i);let n=r(async(l,c)=>{let p=[`<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
+</rss>`
+];
+var randomJsonContent = [
+  () => ({
+    message: "Hello from MockHTTP",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "success",
+    code: 200
+  }),
+  () => ({
+    user: {
+      id: 1,
+      name: "John Doe",
+      email: "john@example.com",
+      role: "admin",
+      createdAt: "2024-01-15T10:30:00Z"
+    },
+    permissions: [
+      "read",
+      "write",
+      "delete"
+    ]
+  }),
+  () => ({
+    products: [
+      {
+        id: 101,
+        name: "Laptop",
+        price: 999.99,
+        stock: 50
+      },
+      {
+        id: 102,
+        name: "Mouse",
+        price: 29.99,
+        stock: 200
+      }
+    ],
+    total: 2,
+    page: 1
+  }),
+  () => ({
+    config: {
+      theme: "dark",
+      language: "en",
+      notifications: {
+        email: true,
+        push: false,
+        sms: false
+      },
+      privacy: {
+        profile: "public",
+        activity: "friends"
+      }
+    }
+  }),
+  () => ({
+    metrics: {
+      cpu: 45.2,
+      memory: 78.5,
+      disk: 62.3,
+      network: {
+        inbound: "1.2MB/s",
+        outbound: "0.8MB/s"
+      },
+      uptime: "15 days",
+      services: [
+        {
+          name: "api",
+          status: "healthy"
+        },
+        {
+          name: "database",
+          status: "healthy"
+        },
+        {
+          name: "cache",
+          status: "warning"
+        }
+      ]
+    }
+  })
+];
+var responseFormatRoutes = /* @__PURE__ */ __name((fastify) => {
+  const plainHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const randomIndex = Math.floor(Math.random() * randomTexts.length);
+    const text = randomTexts[randomIndex];
+    reply.type("text/plain");
+    return text;
+  }, "plainHandler");
+  fastify.get("/plain", {
+    schema: plainSchema
+  }, plainHandler);
+  fastify.post("/plain", {
+    schema: plainSchema
+  }, plainHandler);
+  fastify.put("/plain", {
+    schema: plainSchema
+  }, plainHandler);
+  fastify.patch("/plain", {
+    schema: plainSchema
+  }, plainHandler);
+  fastify.delete("/plain", {
+    schema: plainSchema
+  }, plainHandler);
+  const textHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const randomIndex = Math.floor(Math.random() * randomTexts.length);
+    const text = randomTexts[randomIndex];
+    reply.type("text/plain");
+    return text;
+  }, "textHandler");
+  fastify.get("/text", {
+    schema: textSchema
+  }, textHandler);
+  fastify.post("/text", {
+    schema: textSchema
+  }, textHandler);
+  fastify.put("/text", {
+    schema: textSchema
+  }, textHandler);
+  fastify.patch("/text", {
+    schema: textSchema
+  }, textHandler);
+  fastify.delete("/text", {
+    schema: textSchema
+  }, textHandler);
+  const htmlHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const randomIndex = Math.floor(Math.random() * randomHtmlContent.length);
+    const html = randomHtmlContent[randomIndex];
+    reply.type("text/html");
+    return html;
+  }, "htmlHandler");
+  fastify.get("/html", {
+    schema: htmlSchema
+  }, htmlHandler);
+  fastify.post("/html", {
+    schema: htmlSchema
+  }, htmlHandler);
+  fastify.put("/html", {
+    schema: htmlSchema
+  }, htmlHandler);
+  fastify.patch("/html", {
+    schema: htmlSchema
+  }, htmlHandler);
+  fastify.delete("/html", {
+    schema: htmlSchema
+  }, htmlHandler);
+  const xmlHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const randomIndex = Math.floor(Math.random() * randomXmlContent.length);
+    const xml = randomXmlContent[randomIndex];
+    reply.type("application/xml");
+    return xml;
+  }, "xmlHandler");
+  fastify.get("/xml", {
+    schema: xmlSchema
+  }, xmlHandler);
+  fastify.post("/xml", {
+    schema: xmlSchema
+  }, xmlHandler);
+  fastify.put("/xml", {
+    schema: xmlSchema
+  }, xmlHandler);
+  fastify.patch("/xml", {
+    schema: xmlSchema
+  }, xmlHandler);
+  fastify.delete("/xml", {
+    schema: xmlSchema
+  }, xmlHandler);
+  const jsonHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const randomIndex = Math.floor(Math.random() * randomJsonContent.length);
+    const jsonGenerator = randomJsonContent[randomIndex];
+    const json = jsonGenerator();
+    reply.type("application/json");
+    return json;
+  }, "jsonHandler");
+  fastify.get("/json", {
+    schema: jsonSchema
+  }, jsonHandler);
+  fastify.post("/json", {
+    schema: jsonSchema
+  }, jsonHandler);
+  fastify.put("/json", {
+    schema: jsonSchema
+  }, jsonHandler);
+  fastify.patch("/json", {
+    schema: jsonSchema
+  }, jsonHandler);
+  fastify.delete("/json", {
+    schema: jsonSchema
+  }, jsonHandler);
+  const denyHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const denyMessages = [
+      `<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
 <html><head>
 <title>403 Forbidden</title>
 </head><body>
 <h1>Forbidden</h1>
 <p>Access denied by robots.txt rules.</p>
 <p>The requested resource is disallowed by robots.txt.</p>
-</body></html>`,`<!DOCTYPE html>
+</body></html>`,
+      `<!DOCTYPE html>
 <html lang="en">
 <head>
 <meta charset="UTF-8">
@@ -218,9 +1942,10 @@ var $e=Object.defineProperty;var r=(s,e)=>$e(s,"name",{value:e,configurable:!0})
 <body>
 <h1>403 Forbidden</h1>
 <p>This page is blocked by robots.txt rules.</p>
-<p>User-agent: *<br>Disallow: ${l.url}</p>
+<p>User-agent: *<br>Disallow: ${_request.url}</p>
 </body>
-</html>`,`<!DOCTYPE html>
+</html>`,
+      `<!DOCTYPE html>
 <html>
 <head>
 <title>403 - Access Denied</title>
@@ -232,14 +1957,854 @@ var $e=Object.defineProperty;var r=(s,e)=>$e(s,"name",{value:e,configurable:!0})
 <hr>
 <small>MockHTTP Server</small>
 </body>
-</html>`],u=Math.floor(Math.random()*p.length),m=p[u];return c.code(403),c.type("text/html"),m},"denyHandler");s.get("/deny",{schema:_},n),s.post("/deny",{schema:_},n),s.put("/deny",{schema:_},n),s.patch("/deny",{schema:_},n),s.delete("/deny",{schema:_},n);let d=r(async(l,c)=>{let p=[{message:"This is GZip compressed data from MockHTTP",timestamp:new Date().toISOString(),compression:"gzip",originalSize:0,compressedSize:0},{title:"Sample Document",content:"Lorem ipsum dolor sit amet, consectetur adipiscing elit. ".repeat(50),metadata:{author:"MockHTTP Server",format:"gzip",version:"1.0"}},{data:Array.from({length:100},(R,f)=>({id:f+1,value:`Item ${f+1}`,description:`This is item number ${f+1} in the dataset`})),info:"Large dataset compressed with GZip"}],u=Math.floor(Math.random()*p.length),m=p[u],y=JSON.stringify(m);m.originalSize!==void 0&&(m.originalSize=Buffer.byteLength(y));let b=be(y);if(m.compressedSize!==void 0){let R={...m,compressedSize:b.length},f=JSON.stringify(R),v=be(f);return c.header("Content-Encoding","gzip"),c.header("Content-Type","application/json"),c.type("application/octet-stream"),v}return c.header("Content-Encoding","gzip"),c.header("Content-Type","application/json"),c.type("application/octet-stream"),b},"gzipHandler");s.get("/gzip",{schema:H},d),s.post("/gzip",{schema:H},d),s.put("/gzip",{schema:H},d),s.patch("/gzip",{schema:H},d),s.delete("/gzip",{schema:H},d);let g=r(async(l,c)=>{let p=[{message:"This is Deflate compressed data from MockHTTP",timestamp:new Date().toISOString(),compression:"deflate",originalSize:0,compressedSize:0},{title:"Deflate Compressed Document",content:"The deflate algorithm is used for compression. ".repeat(40),details:{algorithm:"DEFLATE",method:"zlib deflate",server:"MockHTTP"}},{items:Array.from({length:50},(R,f)=>({index:f,name:`Entry ${f}`,data:`This is test data for entry number ${f}`,timestamp:new Date(Date.now()-f*1e6).toISOString()})),metadata:{compression:"deflate",count:50}}],u=Math.floor(Math.random()*p.length),m=p[u],y=JSON.stringify(m);m.originalSize!==void 0&&(m.originalSize=Buffer.byteLength(y));let b=ye(y);if(m.compressedSize!==void 0){let R={...m,compressedSize:b.length},f=JSON.stringify(R),v=ye(f);return c.header("Content-Encoding","deflate"),c.header("Content-Type","application/json"),c.type("application/octet-stream"),v}return c.header("Content-Encoding","deflate"),c.header("Content-Type","application/json"),c.type("application/octet-stream"),b},"deflateHandler");s.get("/deflate",{schema:$},g),s.post("/deflate",{schema:$},g),s.put("/deflate",{schema:$},g),s.patch("/deflate",{schema:$},g),s.delete("/deflate",{schema:$},g);let h=r(async(l,c)=>{let p=[{message:"This is Brotli compressed data from MockHTTP",timestamp:new Date().toISOString(),compression:"br",algorithm:"Brotli",originalSize:0,compressedSize:0},{title:"Brotli Compression Example",description:"Brotli is a generic-purpose lossless compression algorithm that compresses data using a combination of a modern variant of the LZ77 algorithm, Huffman coding and 2nd order context modeling.",content:"Brotli compression typically achieves 20-26% better compression ratios than gzip. ".repeat(10),metadata:{encoding:"br",quality:11,server:"MockHTTP"}},{benchmark:{title:"Compression Benchmark Data",results:Array.from({length:75},(R,f)=>({id:`test-${f}`,name:`Benchmark Test ${f}`,value:Math.random()*1e3,unit:"ms",timestamp:new Date(Date.now()-f*6e4).toISOString()})),summary:{compression:"brotli",totalTests:75,encoding:"br"}}}],u=Math.floor(Math.random()*p.length),m=p[u],y=JSON.stringify(m);m.originalSize!==void 0&&(m.originalSize=Buffer.byteLength(y));let b=fe(y);if(m.compressedSize!==void 0){let R={...m,compressedSize:b.length},f=JSON.stringify(R),v=fe(f);return c.header("Content-Encoding","br"),c.header("Content-Type","application/json"),c.type("application/octet-stream"),v}return c.header("Content-Encoding","br"),c.header("Content-Type","application/json"),c.type("application/octet-stream"),b},"brotliHandler");s.get("/brotli",{schema:D},h),s.post("/brotli",{schema:D},h),s.put("/brotli",{schema:D},h),s.patch("/brotli",{schema:D},h),s.delete("/brotli",{schema:D},h)},"responseFormatRoutes");var st={description:"Handles cache validation and retrieval.",tags:["Response Inspection"],response:{200:{type:"string",description:"The cached content or resource."},304:{type:"null",description:"Indicates the resource has not been modified."}}},ot={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:{200:{type:"string",description:"Confirmation message for setting cache."}}},re=r(s=>{s.get("/cache",{schema:st},async(e,t)=>{let o=e.headers["if-modified-since"],a=e.headers["if-none-match"];if(o??a){await t.status(304).send();return}await t.send("Cache content or resource response here.")}),s.get("/cache/:value",{schema:ot},async(e,t)=>{let{value:o}=e.params;await t.header("Cache-Control",`max-age=${o}`).send(`Cache-Control set for ${o} seconds.`)})},"cacheRoutes");var rt={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:{200:{type:"string",description:"Resource content for matching ETag."},304:{type:"null",description:"Indicates the resource has not been modified."},412:{type:"null",description:"Indicates a precondition failed due to mismatched ETag."}}},ae=r(s=>{s.get("/etag/:etag",{schema:rt},async(e,t)=>{let{etag:o}=e.params,a=e.headers["if-none-match"],i=e.headers["if-match"];if(a===o){await t.status(304).send();return}if(i&&i!==o){await t.status(412).send();return}await t.header("ETag",o).send("Resource content for matching ETag.")})},"etagRoutes");import{escape as M}from"html-escaper";var ve={description:"Returns a set of response headers based on the query string.",tags:["Response Inspection"],querystring:{type:"object",additionalProperties:!0,description:"Freeform query string parameters to be added as response headers."},response:{200:{type:"object",additionalProperties:!0,description:"Response headers as per query string parameters."}}},ie=r(s=>{s.get("/response-headers",{schema:ve},async(e,t)=>{let o=e.query;for(let[i,n]of Object.entries(o))t.header(i,M(n));let a=Object.fromEntries(Object.entries(o).map(([i,n])=>[i,M(n)]));await t.send(a)}),s.post("/response-headers",{schema:ve},async(e,t)=>{let o=e.query??{},a=e.body??{};for(let[n,d]of Object.entries(o))t.header(n,M(d));for(let[n,d]of Object.entries(a))t.header(n,M(d));let i=Object.fromEntries(Object.entries({...o,...a}).map(([n,d])=>[n,M(d)]));await t.send(i)})},"responseHeadersRoutes");var Te=r(s=>{s.get("/sitemap.xml",{schema:{hide:!0}},async(e,t)=>{try{let o=e.headers.host??"mockhttp.org",n=`<?xml version="1.0" encoding="UTF-8"?>
+</html>`
+    ];
+    const randomIndex = Math.floor(Math.random() * denyMessages.length);
+    const html = denyMessages[randomIndex];
+    reply.code(403);
+    reply.type("text/html");
+    return html;
+  }, "denyHandler");
+  fastify.get("/deny", {
+    schema: denySchema
+  }, denyHandler);
+  fastify.post("/deny", {
+    schema: denySchema
+  }, denyHandler);
+  fastify.put("/deny", {
+    schema: denySchema
+  }, denyHandler);
+  fastify.patch("/deny", {
+    schema: denySchema
+  }, denyHandler);
+  fastify.delete("/deny", {
+    schema: denySchema
+  }, denyHandler);
+  const gzipHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const sampleData = [
+      {
+        message: "This is GZip compressed data from MockHTTP",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        compression: "gzip",
+        originalSize: 0,
+        compressedSize: 0
+      },
+      {
+        title: "Sample Document",
+        content: "Lorem ipsum dolor sit amet, consectetur adipiscing elit. ".repeat(50),
+        metadata: {
+          author: "MockHTTP Server",
+          format: "gzip",
+          version: "1.0"
+        }
+      },
+      {
+        data: Array.from({
+          length: 100
+        }, (_, i) => ({
+          id: i + 1,
+          value: `Item ${i + 1}`,
+          description: `This is item number ${i + 1} in the dataset`
+        })),
+        info: "Large dataset compressed with GZip"
+      }
+    ];
+    const randomIndex = Math.floor(Math.random() * sampleData.length);
+    const data = sampleData[randomIndex];
+    const jsonString = JSON.stringify(data);
+    if (data.originalSize !== void 0) {
+      data.originalSize = Buffer.byteLength(jsonString);
+    }
+    const compressed = gzipSync(jsonString);
+    if (data.compressedSize !== void 0) {
+      const updatedData = {
+        ...data,
+        compressedSize: compressed.length
+      };
+      const updatedJsonString = JSON.stringify(updatedData);
+      const updatedCompressed = gzipSync(updatedJsonString);
+      reply.header("Content-Encoding", "gzip");
+      reply.header("Content-Type", "application/json");
+      reply.type("application/octet-stream");
+      return updatedCompressed;
+    }
+    reply.header("Content-Encoding", "gzip");
+    reply.header("Content-Type", "application/json");
+    reply.type("application/octet-stream");
+    return compressed;
+  }, "gzipHandler");
+  fastify.get("/gzip", {
+    schema: gzipSchema
+  }, gzipHandler);
+  fastify.post("/gzip", {
+    schema: gzipSchema
+  }, gzipHandler);
+  fastify.put("/gzip", {
+    schema: gzipSchema
+  }, gzipHandler);
+  fastify.patch("/gzip", {
+    schema: gzipSchema
+  }, gzipHandler);
+  fastify.delete("/gzip", {
+    schema: gzipSchema
+  }, gzipHandler);
+  const deflateHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const sampleData = [
+      {
+        message: "This is Deflate compressed data from MockHTTP",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        compression: "deflate",
+        originalSize: 0,
+        compressedSize: 0
+      },
+      {
+        title: "Deflate Compressed Document",
+        content: "The deflate algorithm is used for compression. ".repeat(40),
+        details: {
+          algorithm: "DEFLATE",
+          method: "zlib deflate",
+          server: "MockHTTP"
+        }
+      },
+      {
+        items: Array.from({
+          length: 50
+        }, (_, i) => ({
+          index: i,
+          name: `Entry ${i}`,
+          data: `This is test data for entry number ${i}`,
+          timestamp: new Date(Date.now() - i * 1e6).toISOString()
+        })),
+        metadata: {
+          compression: "deflate",
+          count: 50
+        }
+      }
+    ];
+    const randomIndex = Math.floor(Math.random() * sampleData.length);
+    const data = sampleData[randomIndex];
+    const jsonString = JSON.stringify(data);
+    if (data.originalSize !== void 0) {
+      data.originalSize = Buffer.byteLength(jsonString);
+    }
+    const compressed = deflateSync(jsonString);
+    if (data.compressedSize !== void 0) {
+      const updatedData = {
+        ...data,
+        compressedSize: compressed.length
+      };
+      const updatedJsonString = JSON.stringify(updatedData);
+      const updatedCompressed = deflateSync(updatedJsonString);
+      reply.header("Content-Encoding", "deflate");
+      reply.header("Content-Type", "application/json");
+      reply.type("application/octet-stream");
+      return updatedCompressed;
+    }
+    reply.header("Content-Encoding", "deflate");
+    reply.header("Content-Type", "application/json");
+    reply.type("application/octet-stream");
+    return compressed;
+  }, "deflateHandler");
+  fastify.get("/deflate", {
+    schema: deflateSchema
+  }, deflateHandler);
+  fastify.post("/deflate", {
+    schema: deflateSchema
+  }, deflateHandler);
+  fastify.put("/deflate", {
+    schema: deflateSchema
+  }, deflateHandler);
+  fastify.patch("/deflate", {
+    schema: deflateSchema
+  }, deflateHandler);
+  fastify.delete("/deflate", {
+    schema: deflateSchema
+  }, deflateHandler);
+  const brotliHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const sampleData = [
+      {
+        message: "This is Brotli compressed data from MockHTTP",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        compression: "br",
+        algorithm: "Brotli",
+        originalSize: 0,
+        compressedSize: 0
+      },
+      {
+        title: "Brotli Compression Example",
+        description: "Brotli is a generic-purpose lossless compression algorithm that compresses data using a combination of a modern variant of the LZ77 algorithm, Huffman coding and 2nd order context modeling.",
+        content: "Brotli compression typically achieves 20-26% better compression ratios than gzip. ".repeat(10),
+        metadata: {
+          encoding: "br",
+          quality: 11,
+          server: "MockHTTP"
+        }
+      },
+      {
+        benchmark: {
+          title: "Compression Benchmark Data",
+          results: Array.from({
+            length: 75
+          }, (_, i) => ({
+            id: `test-${i}`,
+            name: `Benchmark Test ${i}`,
+            value: Math.random() * 1e3,
+            unit: "ms",
+            timestamp: new Date(Date.now() - i * 6e4).toISOString()
+          })),
+          summary: {
+            compression: "brotli",
+            totalTests: 75,
+            encoding: "br"
+          }
+        }
+      }
+    ];
+    const randomIndex = Math.floor(Math.random() * sampleData.length);
+    const data = sampleData[randomIndex];
+    const jsonString = JSON.stringify(data);
+    if (data.originalSize !== void 0) {
+      data.originalSize = Buffer.byteLength(jsonString);
+    }
+    const compressed = brotliCompressSync(jsonString);
+    if (data.compressedSize !== void 0) {
+      const updatedData = {
+        ...data,
+        compressedSize: compressed.length
+      };
+      const updatedJsonString = JSON.stringify(updatedData);
+      const updatedCompressed = brotliCompressSync(updatedJsonString);
+      reply.header("Content-Encoding", "br");
+      reply.header("Content-Type", "application/json");
+      reply.type("application/octet-stream");
+      return updatedCompressed;
+    }
+    reply.header("Content-Encoding", "br");
+    reply.header("Content-Type", "application/json");
+    reply.type("application/octet-stream");
+    return compressed;
+  }, "brotliHandler");
+  fastify.get("/brotli", {
+    schema: brotliSchema
+  }, brotliHandler);
+  fastify.post("/brotli", {
+    schema: brotliSchema
+  }, brotliHandler);
+  fastify.put("/brotli", {
+    schema: brotliSchema
+  }, brotliHandler);
+  fastify.patch("/brotli", {
+    schema: brotliSchema
+  }, brotliHandler);
+  fastify.delete("/brotli", {
+    schema: brotliSchema
+  }, brotliHandler);
+}, "responseFormatRoutes");
+
+// src/routes/response-inspection/cache.ts
+var cacheGetSchema = {
+  description: "Handles cache validation and retrieval.",
+  tags: [
+    "Response Inspection"
+  ],
+  response: {
+    200: {
+      type: "string",
+      description: "The cached content or resource."
+    },
+    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: {
+    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: {
+    200: {
+      type: "string",
+      description: "Resource content for matching ETag."
+    },
+    304: {
+      type: "null",
+      description: "Indicates the resource has not been modified."
+    },
+    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: {
+    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>${e.headers["x-forwarded-proto"]?.includes("https")?"https":"http"}://${o}/</loc>
+                                    <loc>${protocol}://${host}/</loc>
                                     <changefreq>monthly</changefreq>
                                     <priority>1.0</priority>
                                 </url>
-                        </urlset>`;await t.type("text/xml").send(n)}catch(o){s.log.error(o),await t.status(500).send({error:"Internal Server Error"})}})},"sitemapRoute");import{randomInt as at}from"crypto";var ne=[{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"}],A={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:{200:{type:"object",properties:{status:{type:"string"}}}}},Se=r(s=>{let e=r(async(t,o)=>{let{code:a}=t.params;(!a||!ne.map(i=>i.code).includes(Number(a)))&&(a=ne[at(0,ne.length)].code.toString()),await o.code(Number(a)).send({status:`Response with status code ${a}`})},"handler");s.get("/status/:code?",{schema:A},e),s.post("/status/:code?",{schema:A},e),s.put("/status/:code?",{schema:A},e),s.patch("/status/:code?",{schema:A},e),s.delete("/status/:code?",{schema:A},e)},"statusCodeRoute");import{fastifySwaggerUi as nt}from"@fastify/swagger-ui";var je={name:"@jaredwray/mockhttp",version:"1.0.1",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 --minify","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.5","@swc/core":"^1.13.5","@types/html-escaper":"^3.0.4","@vitest/coverage-v8":"^3.2.4",rimraf:"^6.0.1",tsup:"^8.5.0",tsx:"^4.20.6",typescript:"^5.9.3",vitest:"^3.2.4"},dependencies:{"@fastify/cookie":"^11.0.2","@fastify/helmet":"^13.0.2","@fastify/static":"^8.2.0","@fastify/swagger":"^9.5.2","@fastify/swagger-ui":"^5.2.3","@scalar/api-reference":"^1.37.0","detect-port":"^2.1.0",fastify:"^5.6.1",hookified:"^1.12.1","html-escaper":"^3.0.3",pino:"^10.0.0","pino-pretty":"^13.1.1"},files:["dist","public","LICENCE"],pnpm:{onlyBuiltDependencies:["@swc/core","unrs-resolver","vue-demi"]}};var ct=`
+                        </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: [
+    "Status Codes"
+  ],
+  params: {
+    type: "object",
+    properties: {
+      code: {
+        type: "string",
+        description: "HTTP status code to be returned"
+      }
+    }
+  },
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        status: {
+          type: "string"
+        }
+      }
+    }
+  }
+};
+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();
+    }
+    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");
+
+// src/swagger.ts
+import { fastifySwaggerUi } from "@fastify/swagger-ui";
+
+// package.json
+var package_default = {
+  name: "@jaredwray/mockhttp",
+  version: "1.1.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",
+    "testing",
+    "api",
+    "fastify",
+    "docker",
+    "typescript",
+    "rest",
+    "mock-server",
+    "api-testing",
+    "development",
+    "http-testing",
+    "httpbin-alternative",
+    "endpoints"
+  ],
+  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.3.5",
+    "@swc/core": "^1.15.1",
+    "@types/html-escaper": "^3.0.4",
+    "@vitest/coverage-v8": "^4.0.8",
+    rimraf: "^6.1.0",
+    tsup: "^8.5.0",
+    tsx: "^4.20.6",
+    typescript: "^5.9.3",
+    vitest: "^4.0.8"
+  },
+  dependencies: {
+    "@fastify/cookie": "^11.0.2",
+    "@fastify/helmet": "^13.0.2",
+    "@fastify/rate-limit": "^10.3.0",
+    "@fastify/static": "^8.3.0",
+    "@fastify/swagger": "^9.6.0",
+    "@fastify/swagger-ui": "^5.2.3",
+    "@scalar/api-reference": "^1.39.3",
+    "detect-port": "^2.1.0",
+    fastify: "^5.6.2",
+    hookified: "^1.13.0",
+    "html-escaper": "^3.0.3",
+    pino: "^10.1.0",
+    "pino-pretty": "^13.1.2"
+  },
+  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)
@@ -249,4 +2814,607 @@ A simple HTTP server that can be used to mock HTTP responses for testing purpose
 # 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.
-`,Ce={openapi:{info:{title:"Mock HTTP API",description:ct,version:je.version},consumes:["application/json"],produces:["application/json"]}},Pe=r(async s=>{await s.register(nt,{routePrefix:"/docs",uiConfig:{docExpansion:"none",deepLinking:!1},uiHooks:{onRequest(e,t,o){o()},preHandler(e,t,o){o()}},staticCSP:!0,transformSpecification:r((e,t,o)=>e,"transformSpecification"),transformSpecificationClone:!0})},"registerSwaggerUi");import{randomUUID as dt}from"crypto";var L=class{static{r(this,"TapManager")}_injections;constructor(){this._injections=new Map}get injections(){return this._injections}get hasInjections(){return this._injections.size>0}inject(e,t){let o=dt(),a={id:o,response:e,matcher:t};return this._injections.set(o,a),a}removeInjection(e){let t=typeof e=="string"?e:e.id;return this._injections.delete(t)}matchRequest(e){for(let t of this._injections.values())if(this.requestMatches(e,t.matcher))return t}clear(){this._injections.clear()}requestMatches(e,t){if(!t)return!0;if(t.url&&!this.urlMatches(e.url,t.url)||t.hostname&&e.hostname!==t.hostname||t.method&&e.method.toUpperCase()!==t.method.toUpperCase())return!1;if(t.headers){for(let[o,a]of Object.entries(t.headers))if(e.headers[o.toLowerCase()]!==a)return!1}return!0}urlMatches(e,t){let o=e.split("?")[0];if(t===o)return!0;if(t.includes("*")){let a=t.split("*").map(n=>n.replaceAll(/[.*+?^${}()|[\]\\]/g,"\\$&")).join(".*");return new RegExp(`^${a}$`).test(o)}return!1}};var k=class extends lt{static{r(this,"MockHttp")}_port=3e3;_host="0.0.0.0";_autoDetectPort=!0;_helmet=!0;_apiDocs=!0;_httpBin={httpMethods:!0,redirects:!0,requestInspection:!0,responseInspection:!0,responseFormats:!0,statusCodes:!0,cookies:!0,anything:!0,auth:!0};_server=He();_taps=new L;constructor(e){super(e?.hookOptions),e?.port&&(this._port=e.port),e?.host&&(this._host=e.host),e?.helmet!==void 0&&(this._helmet=e.helmet),e?.apiDocs!==void 0&&(this._apiDocs=e.apiDocs),e?.httpBin!==void 0&&(this._httpBin=e.httpBin)}get port(){return this._port}set port(e){this._port=e}get host(){return this._host}set host(e){this._host=e}get autoDetectPort(){return this._autoDetectPort}set autoDetectPort(e){this._autoDetectPort=e}get helmet(){return this._helmet}set helmet(e){this._helmet=e}get apiDocs(){return this._apiDocs}set apiDocs(e){this._apiDocs=e}get httpBin(){return this._httpBin}set httpBin(e){this._httpBin=e}get server(){return this._server}set server(e){this._server=e}get taps(){return this._taps}set taps(e){this._taps=e}async start(){try{this._server&&await this._server.close(),this._server=He(ce),this._server.addHook("onRequest",async(l,c)=>{let p=this._taps.matchRequest(l);if(p){let u=typeof p.response=="function"?p.response(l):p.response,{response:m,statusCode:y=200,headers:b}=u;if(c.code(y),b)for(let[R,f]of Object.entries(b))c.header(R,f);return c.send(m)}}),await this._server.register(_e,{root:qe.resolve("./node_modules/@scalar/api-reference/dist"),prefix:"/scalar"}),await this.server.register(_e,{root:qe.resolve("./public"),decorateReply:!1}),await this._server.register(Te),this._helmet&&await this._server.register(ht),this._apiDocs&&await this.registerApiDocs();let{httpMethods:e,redirects:t,requestInspection:o,responseInspection:a,responseFormats:i,statusCodes:n,cookies:d,anything:g,auth:h}=this._httpBin;if(e&&await this.registerHttpMethods(),n&&await this.registerStatusCodeRoutes(),o&&await this.registerRequestInspectionRoutes(),a&&await this.registerResponseInspectionRoutes(),i&&await this.registerResponseFormatRoutes(),t&&await this.registerRedirectRoutes(),d&&await this.registerCookieRoutes(),g&&await this.registerAnythingRoutes(),h&&await this.registerAuthRoutes(),this._autoDetectPort){let l=this._port;this._port=await this.detectPort(),l!==this._port&&this._server.log.info(`Port ${l} is in use, detected next available port: ${this._port}`)}await this._server.listen({port:this._port,host:this._host})}catch(e){this._server.log.error(e)}}async close(){await this._server.close()}async detectPort(){let{port:e}=this;return ut(e)}async registerApiDocs(e){let t=e??this._server;await t.register(mt,Ce),await Pe(t),await t.register(ge)}async registerHttpMethods(e){let t=e??this._server;await t.register(Y),await t.register(V),await t.register(J),await t.register(X),await t.register(Z)}async registerStatusCodeRoutes(e){await(e??this._server).register(Se)}async registerRequestInspectionRoutes(e){let t=e??this._server;await t.register(se),await t.register(te),await t.register(oe)}async registerResponseInspectionRoutes(e){let t=e??this._server;await t.register(re),await t.register(ae),await t.register(ie)}async registerResponseFormatRoutes(e){await(e??this._server).register(ke)}async registerRedirectRoutes(e){let t=e??this._server;await t.register(K),await t.register(ee),await t.register(Q)}async registerCookieRoutes(e){let t=e??this._server;await t.register(pt),await t.register(N),await t.register(G),await t.register(W)}async registerAnythingRoutes(e){await(e??this._server).register(de)}async registerAuthRoutes(e){let t=e??this._server;await t.register(E),await t.register(F),await t.register(O),await t.register(B)}};var gt=r(async()=>{let s=new k;return I.env.PORT&&(s.port=Number.parseInt(I.env.PORT,10)),I.env.HOST&&(s.host=I.env.HOST),await s.start(),s},"start");import.meta.url===`file://${I.argv[1]}`&&await gt();export{k as default,k as mockhttp,gt as start};
+`;
+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: {
+      /* v8 ignore next -- @preserve */
+      onRequest(_request, _reply, next) {
+        next();
+      },
+      /* v8 ignore next -- @preserve */
+      preHandler(_request, _reply, next) {
+        next();
+      }
+    },
+    staticCSP: true,
+    /* v8 ignore next -- @preserve */
+    transformSpecification: /* @__PURE__ */ __name((swaggerObject, _request, _reply) => swaggerObject, "transformSpecification"),
+    transformSpecificationClone: true
+  });
+}, "registerSwaggerUi");
+
+// src/tap-manager.ts
+import { randomUUID } from "crypto";
+var TapManager = class {
+  static {
+    __name(this, "TapManager");
+  }
+  _injections;
+  constructor() {
+    this._injections = /* @__PURE__ */ new Map();
+  }
+  /**
+  * Get all active injection taps
+  */
+  get injections() {
+    return this._injections;
+  }
+  /**
+  * Check if there are any active injections
+  */
+  get hasInjections() {
+    return this._injections.size > 0;
+  }
+  /**
+  * Inject a custom response for requests matching the given criteria
+  * @param response - The response configuration or a function that returns it
+  * @param matcher - Optional criteria to match requests
+  * @returns A tap object that can be used to remove the injection
+  */
+  inject(response, matcher) {
+    const id = randomUUID();
+    const tap = {
+      id,
+      response,
+      matcher
+    };
+    this._injections.set(id, tap);
+    return tap;
+  }
+  /**
+  * Remove an injection by its tap object or ID
+  * @param tapOrId - The tap object or tap ID to remove
+  * @returns true if the injection was removed, false if it wasn't found
+  */
+  removeInjection(tapOrId) {
+    const id = typeof tapOrId === "string" ? tapOrId : tapOrId.id;
+    return this._injections.delete(id);
+  }
+  /**
+  * Find the first injection that matches the given request
+  * @param request - The Fastify request object
+  * @returns The matching injection tap, or undefined if no match
+  */
+  matchRequest(request) {
+    for (const tap of this._injections.values()) {
+      if (this.requestMatches(request, tap.matcher)) {
+        return tap;
+      }
+    }
+    return void 0;
+  }
+  /**
+  * Clear all injections
+  */
+  clear() {
+    this._injections.clear();
+  }
+  /**
+  * Check if a request matches the given matcher criteria
+  * @param request - The Fastify request object
+  * @param matcher - The matcher criteria (undefined matches all requests)
+  * @returns true if the request matches
+  */
+  requestMatches(request, matcher) {
+    if (!matcher) {
+      return true;
+    }
+    if (matcher.url) {
+      if (!this.urlMatches(request.url, matcher.url)) {
+        return false;
+      }
+    }
+    if (matcher.hostname) {
+      if (request.hostname !== matcher.hostname) {
+        return false;
+      }
+    }
+    if (matcher.method) {
+      if (request.method.toUpperCase() !== matcher.method.toUpperCase()) {
+        return false;
+      }
+    }
+    if (matcher.headers) {
+      for (const [key, value] of Object.entries(matcher.headers)) {
+        const requestHeader = request.headers[key.toLowerCase()];
+        if (requestHeader !== value) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  /**
+  * Check if a URL matches a pattern (supports wildcards with *)
+  * @param url - The URL to test
+  * @param pattern - The pattern to match against
+  * @returns true if the URL matches the pattern
+  */
+  urlMatches(url, pattern) {
+    const urlPath = url.split("?")[0];
+    if (pattern === urlPath) {
+      return true;
+    }
+    if (pattern.includes("*")) {
+      const regexPattern = pattern.split("*").map((part) => part.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+      const regex = new RegExp(`^${regexPattern}$`);
+      return regex.test(urlPath);
+    }
+    return false;
+  }
+};
+
+// src/mock-http.ts
+var MockHttp = class extends Hookified {
+  static {
+    __name(this, "MockHttp");
+  }
+  _port = 3e3;
+  _host = "0.0.0.0";
+  _autoDetectPort = true;
+  _helmet = true;
+  _apiDocs = true;
+  _httpBin = {
+    httpMethods: true,
+    redirects: true,
+    requestInspection: true,
+    responseInspection: true,
+    responseFormats: true,
+    statusCodes: true,
+    cookies: true,
+    anything: true,
+    auth: true,
+    images: true
+  };
+  _rateLimit = {
+    max: 1e3,
+    timeWindow: "1 minute",
+    allowList: [
+      "127.0.0.1",
+      "::1"
+    ]
+  };
+  _server = Fastify();
+  _taps = new TapManager();
+  constructor(options) {
+    super(options?.hookOptions);
+    if (options?.port) {
+      this._port = options.port;
+    }
+    if (options?.host) {
+      this._host = options.host;
+    }
+    if (options?.helmet !== void 0) {
+      this._helmet = options.helmet;
+    }
+    if (options?.apiDocs !== void 0) {
+      this._apiDocs = options.apiDocs;
+    }
+    if (options?.httpBin !== void 0) {
+      this._httpBin = options.httpBin;
+    }
+    if (options?.rateLimit !== void 0) {
+      if (options.rateLimit === false) {
+        this._rateLimit = void 0;
+      } else {
+        this._rateLimit = options.rateLimit;
+      }
+    }
+  }
+  /**
+  * The port to listen on. If not provided, defaults to 3000 and detects the next available port if in use.
+  * @default 3000
+  */
+  get port() {
+    return this._port;
+  }
+  /**
+  * The port to listen on. If not provided, defaults to 3000 and detects the next available port if in use.
+  * @default 3000
+  */
+  set port(port) {
+    this._port = port;
+  }
+  /**
+  * The host to listen on. If not provided, defaults to 'localhost'.
+  * @default 'localhost'
+  */
+  get host() {
+    return this._host;
+  }
+  /**
+  * The host to listen on. If not provided, defaults to 'localhost'.
+  * @default 'localhost'
+  */
+  set host(host) {
+    this._host = host;
+  }
+  /**
+  * Whether to automatically detect the next available port if the provided port is in use. Defaults to true.
+  * @default true
+  */
+  get autoDetectPort() {
+    return this._autoDetectPort;
+  }
+  /**
+  * Whether to automatically detect the next available port if the provided port is in use. Defaults to true.
+  * @default true
+  */
+  set autoDetectPort(autoDetectPort) {
+    this._autoDetectPort = autoDetectPort;
+  }
+  /**
+  * Whether to use Helmet for security headers. Defaults to true.
+  * @default true
+  */
+  get helmet() {
+    return this._helmet;
+  }
+  /**
+  * Whether to use Helmet for security headers. Defaults to true.
+  * @default true
+  */
+  set helmet(helmet) {
+    this._helmet = helmet;
+  }
+  /**
+  * Whether to use Swagger for API documentation. Defaults to true.
+  * @default true
+  */
+  get apiDocs() {
+    return this._apiDocs;
+  }
+  /**
+  * Whether to use Swagger for API documentation. Defaults to true.
+  * @default true
+  */
+  set apiDocs(apiDocs) {
+    this._apiDocs = apiDocs;
+  }
+  /**
+  * HTTP Bin options. Defaults to all enabled.
+  */
+  get httpBin() {
+    return this._httpBin;
+  }
+  /**
+  * HTTP Bin options. Defaults to all enabled.
+  */
+  set httpBin(httpBinary) {
+    this._httpBin = httpBinary;
+  }
+  /**
+  * Rate limiting options. Defaults to 1000 requests per minute (localhost excluded).
+  * Set to undefined to disable rate limiting, or provide custom options to configure.
+  * @default { max: 1000, timeWindow: "1 minute", allowList: ["127.0.0.1", "::1"] }
+  */
+  get rateLimit() {
+    return this._rateLimit;
+  }
+  /**
+  * Rate limiting options. Defaults to 1000 requests per minute (localhost excluded).
+  * Set to undefined to disable rate limiting, or provide custom options to configure.
+  *
+  * Note: Changing this property requires restarting the server (close() then start()) for changes to take effect.
+  * @default { max: 1000, timeWindow: "1 minute", allowList: ["127.0.0.1", "::1"] }
+  */
+  set rateLimit(rateLimit) {
+    this._rateLimit = rateLimit;
+  }
+  /**
+  * The Fastify server instance.
+  */
+  get server() {
+    return this._server;
+  }
+  /**
+  * The Fastify server instance.
+  */
+  set server(server) {
+    this._server = server;
+  }
+  /**
+  * The TapManager instance for managing injection taps.
+  */
+  get taps() {
+    return this._taps;
+  }
+  /**
+  * The TapManager instance for managing injection taps.
+  */
+  set taps(taps) {
+    this._taps = taps;
+  }
+  /**
+  * Start the Fastify server. If the server is already running, it will be closed and restarted.
+  */
+  async start() {
+    try {
+      if (this._server) {
+        await this._server.close();
+      }
+      this._server = Fastify(fastifyConfig);
+      this._server.addHook("onRequest", async (request, reply) => {
+        const matchedTap = this._taps.matchRequest(request);
+        if (matchedTap) {
+          const injectionResponse = typeof matchedTap.response === "function" ? matchedTap.response(request) : matchedTap.response;
+          const { response, statusCode = 200, headers } = injectionResponse;
+          reply.code(statusCode);
+          if (headers) {
+            for (const [key, value] of Object.entries(headers)) {
+              reply.header(key, value);
+            }
+          }
+          return reply.send(response);
+        }
+      });
+      await this._server.register(fastifyStatic, {
+        root: path.resolve("./node_modules/@scalar/api-reference/dist"),
+        prefix: "/scalar"
+      });
+      await this.server.register(fastifyStatic, {
+        root: path.resolve("./public"),
+        decorateReply: false
+      });
+      await this._server.register(sitemapRoute);
+      if (this._helmet) {
+        await this._server.register(fastifyHelmet, {
+          contentSecurityPolicy: {
+            directives: {
+              defaultSrc: [
+                "'self'"
+              ],
+              scriptSrc: [
+                "'self'",
+                "'unsafe-inline'",
+                "'wasm-unsafe-eval'"
+              ],
+              styleSrc: [
+                "'self'",
+                "'unsafe-inline'"
+              ],
+              imgSrc: [
+                "'self'",
+                "data:",
+                "https:"
+              ],
+              fontSrc: [
+                "'self'",
+                "data:"
+              ],
+              connectSrc: [
+                "'self'"
+              ],
+              frameSrc: [
+                "'self'"
+              ],
+              objectSrc: [
+                "'none'"
+              ],
+              upgradeInsecureRequests: []
+            }
+          }
+        });
+      }
+      if (this._rateLimit) {
+        await this._server.register(fastifyRateLimit, this._rateLimit);
+      }
+      if (this._apiDocs) {
+        await this.registerApiDocs();
+      }
+      const { httpMethods, redirects, requestInspection, responseInspection, responseFormats, statusCodes: statusCodes2, cookies, anything, auth, images } = this._httpBin;
+      if (httpMethods) {
+        await this.registerHttpMethods();
+      }
+      if (statusCodes2) {
+        await this.registerStatusCodeRoutes();
+      }
+      if (requestInspection) {
+        await this.registerRequestInspectionRoutes();
+      }
+      if (responseInspection) {
+        await this.registerResponseInspectionRoutes();
+      }
+      if (responseFormats) {
+        await this.registerResponseFormatRoutes();
+      }
+      if (redirects) {
+        await this.registerRedirectRoutes();
+      }
+      if (cookies) {
+        await this.registerCookieRoutes();
+      }
+      if (anything) {
+        await this.registerAnythingRoutes();
+      }
+      if (auth) {
+        await this.registerAuthRoutes();
+      }
+      if (images) {
+        await this.registerImageRoutes();
+      }
+      if (this._autoDetectPort) {
+        const originalPort = this._port;
+        this._port = await this.detectPort();
+        if (originalPort !== this._port) {
+          this._server.log.info(`Port ${originalPort} is in use, detected next available port: ${this._port}`);
+        }
+      }
+      await this._server.listen({
+        port: this._port,
+        host: this._host
+      });
+    } catch (error) {
+      this._server.log.error(error);
+    }
+  }
+  /**
+  * Close the Fastify server.
+  */
+  async close() {
+    await this._server.close();
+  }
+  /**
+  * Detect the next available port to run on.
+  * @returns The port that is available to run on
+  */
+  async detectPort() {
+    const { port } = this;
+    return detect(port);
+  }
+  /**
+  * This will register the API documentation routes including openapi and swagger ui.
+  * @param fastifyInstance - the server instance to register the routes on.
+  */
+  async registerApiDocs(fastifyInstance) {
+    const fastify = fastifyInstance ?? this._server;
+    await fastify.register(fastifySwagger, fastifySwaggerConfig);
+    await registerSwaggerUi(fastify);
+    await fastify.register(indexRoute);
+  }
+  /**
+  * Register the HTTP methods routes.
+  * @param fastifyInstance - the server instance to register the routes on.
+  */
+  async registerHttpMethods(fastifyInstance) {
+    const fastify = fastifyInstance ?? this._server;
+    await fastify.register(getRoute);
+    await fastify.register(postRoute);
+    await fastify.register(deleteRoute);
+    await fastify.register(putRoute);
+    await fastify.register(patchRoute);
+  }
+  /**
+  * Register the status code routes.
+  * @param fastifyInstance - the server instance to register the routes on.
+  */
+  async registerStatusCodeRoutes(fastifyInstance) {
+    const fastify = fastifyInstance ?? this._server;
+    await fastify.register(statusCodeRoute);
+  }
+  /**
+  * Register the request inspection routes.
+  * @param fastifyInstance - the server instance to register the routes on.
+  */
+  async registerRequestInspectionRoutes(fastifyInstance) {
+    const fastify = fastifyInstance ?? this._server;
+    await fastify.register(ipRoute);
+    await fastify.register(headersRoute);
+    await fastify.register(userAgentRoute);
+  }
+  /**
+  * Register the response inspection routes.
+  * @param fastifyInstance - the server instance to register the routes on.
+  */
+  async registerResponseInspectionRoutes(fastifyInstance) {
+    const fastify = fastifyInstance ?? this._server;
+    await fastify.register(cacheRoutes);
+    await fastify.register(etagRoutes);
+    await fastify.register(responseHeadersRoutes);
+  }
+  async registerResponseFormatRoutes(fastifyInstance) {
+    const fastify = fastifyInstance ?? this._server;
+    await fastify.register(responseFormatRoutes);
+  }
+  /**
+  * Register the redirect routes.
+  * @param fastifyInstance - the server instance to register the routes on.
+  */
+  async registerRedirectRoutes(fastifyInstance) {
+    const fastify = fastifyInstance ?? this._server;
+    await fastify.register(absoluteRedirectRoute);
+    await fastify.register(relativeRedirectRoute);
+    await fastify.register(redirectToRoute);
+  }
+  /**
+  * Register the cookie routes.
+  * @param fastifyInstance - the server instance to register the routes on.
+  */
+  async registerCookieRoutes(fastifyInstance) {
+    const fastify = fastifyInstance ?? this._server;
+    await fastify.register(fastifyCookie);
+    await fastify.register(getCookiesRoute);
+    await fastify.register(postCookieRoute);
+    await fastify.register(deleteCookieRoute);
+  }
+  /**
+  * Register the anything routes.
+  * @param fastifyInstance - the server instance to register the routes on.
+  */
+  async registerAnythingRoutes(fastifyInstance) {
+    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);
+  }
+  /**
+  * Register the image routes.
+  * @param fastifyInstance - the server instance to register the routes on.
+  */
+  async registerImageRoutes(fastifyInstance) {
+    const fastify = fastifyInstance ?? this._server;
+    await fastify.register(imageRoutes);
+  }
+};
+
+// src/index.ts
+var start = /* @__PURE__ */ __name(async () => {
+  const mockHttp = new MockHttp();
+  if (process2.env.PORT) {
+    mockHttp.port = Number.parseInt(process2.env.PORT, 10);
+  }
+  if (process2.env.HOST) {
+    mockHttp.host = process2.env.HOST;
+  }
+  await mockHttp.start();
+  return mockHttp;
+}, "start");
+if (import.meta.url === `file://${process2.argv[1]}`) {
+  await start();
+}
+export {
+  MockHttp as default,
+  MockHttp as mockhttp,
+  start
+};
+/* v8 ignore next -- @preserve */