@jaredwray/mockhttp 1.4.0 → 1.5.1

package/dist/index.mjs

@@ -0,0 +1,3492 @@
+import process$1 from "node:process";
+import * as fsPromises from "node:fs/promises";
+import path, { join } from "node: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";
+import * as crypto$1 from "node:crypto";
+import crypto, { randomBytes, randomInt, randomUUID, timingSafeEqual } from "node:crypto";
+import { Buffer as Buffer$1 } from "node:buffer";
+import { readFileSync } from "node:fs";
+import { brotliCompressSync, deflateSync, gzipSync } from "node:zlib";
+import { escape } from "html-escaper";
+import { fastifySwaggerUi } from "@fastify/swagger-ui";
+//#region src/certificate.ts
+function encodeLength(length) {
+	if (length < 128) return Buffer.from([length]);
+	const bytes = [];
+	let temp = length;
+	while (temp > 0) {
+		bytes.unshift(temp & 255);
+		temp >>= 8;
+	}
+	return Buffer.from([128 | bytes.length, ...bytes]);
+}
+function encodeTlv(tag, value) {
+	return Buffer.concat([
+		Buffer.from([tag]),
+		encodeLength(value.length),
+		value
+	]);
+}
+function encodeSequence(...elements) {
+	return encodeTlv(48, Buffer.concat(elements));
+}
+function encodeSet(...elements) {
+	return encodeTlv(49, Buffer.concat(elements));
+}
+function encodeInteger(value) {
+	let buf;
+	if (typeof value === "number") if (value === 0) buf = Buffer.from([0]);
+	else {
+		const bytes = [];
+		let temp = value;
+		while (temp > 0) {
+			bytes.unshift(temp & 255);
+			temp >>= 8;
+		}
+		if (bytes[0] & 128) bytes.unshift(0);
+		buf = Buffer.from(bytes);
+	}
+	else if (value.length > 0 && value[0] & 128) buf = Buffer.concat([Buffer.from([0]), value]);
+	else buf = value;
+	return encodeTlv(2, buf);
+}
+function encodeBitString(value) {
+	return encodeTlv(3, Buffer.concat([Buffer.from([0]), value]));
+}
+function encodeOctetString(value) {
+	return encodeTlv(4, value);
+}
+function encodeOid(oid) {
+	const bytes = [];
+	bytes.push(40 * oid[0] + oid[1]);
+	for (let i = 2; i < oid.length; i++) {
+		let component = oid[i];
+		if (component < 128) bytes.push(component);
+		else {
+			const encoded = [];
+			encoded.push(component & 127);
+			component >>= 7;
+			while (component > 0) {
+				encoded.push(component & 127 | 128);
+				component >>= 7;
+			}
+			encoded.reverse();
+			bytes.push(...encoded);
+		}
+	}
+	return encodeTlv(6, Buffer.from(bytes));
+}
+function encodeUtf8String(value) {
+	return encodeTlv(12, Buffer.from(value, "utf8"));
+}
+/**
+* Encode a date as ASN.1 time. Uses UTCTime (tag 0x17) for years 1950-2049
+* and GeneralizedTime (tag 0x18) for years >= 2050, per RFC 5280 Section 4.1.2.5.
+*/
+function encodeTime(date) {
+	const fullYear = date.getUTCFullYear();
+	const timePart = `${pad2(date.getUTCMonth() + 1)}${pad2(date.getUTCDate())}${pad2(date.getUTCHours())}${pad2(date.getUTCMinutes())}${pad2(date.getUTCSeconds())}Z`;
+	if (fullYear >= 2050) {
+		const str = `${fullYear}${timePart}`;
+		return encodeTlv(24, Buffer.from(str, "ascii"));
+	}
+	const str = `${pad2(fullYear % 100)}${timePart}`;
+	return encodeTlv(23, Buffer.from(str, "ascii"));
+}
+function encodeContextSpecific(tag, value) {
+	return encodeTlv(160 | tag, value);
+}
+function pad2(n) {
+	return n.toString().padStart(2, "0");
+}
+const OID_SHA256_WITH_RSA = [
+	1,
+	2,
+	840,
+	113549,
+	1,
+	1,
+	11
+];
+const OID_COMMON_NAME = [
+	2,
+	5,
+	4,
+	3
+];
+const OID_SUBJECT_ALT_NAME = [
+	2,
+	5,
+	29,
+	17
+];
+function buildAlgorithmIdentifier() {
+	return encodeSequence(encodeOid(OID_SHA256_WITH_RSA), encodeTlv(5, Buffer.alloc(0)));
+}
+function buildName(cn) {
+	return encodeSequence(encodeSet(encodeSequence(encodeOid(OID_COMMON_NAME), encodeUtf8String(cn))));
+}
+function buildValidity(notBefore, notAfter) {
+	return encodeSequence(encodeTime(notBefore), encodeTime(notAfter));
+}
+function encodeIpAddress(ip) {
+	if (ip.includes(".")) {
+		const parts = ip.split(".").map(Number);
+		return Buffer.from(parts);
+	}
+	const expanded = expandIpv6(ip);
+	const buf = Buffer.alloc(16);
+	const groups = expanded.split(":");
+	for (let i = 0; i < 8; i++) {
+		const val = Number.parseInt(groups[i], 16);
+		buf.writeUInt16BE(val, i * 2);
+	}
+	return buf;
+}
+function expandIpv6(ip) {
+	if (ip.includes("::")) {
+		const [left, right] = ip.split("::");
+		const leftGroups = left ? left.split(":") : [];
+		const rightGroups = right ? right.split(":") : [];
+		const missing = 8 - leftGroups.length - rightGroups.length;
+		const middle = Array.from({ length: missing }).fill("0000");
+		return [
+			...leftGroups,
+			...middle,
+			...rightGroups
+		].map((g) => g.padStart(4, "0")).join(":");
+	}
+	return ip.split(":").map((g) => g.padStart(4, "0")).join(":");
+}
+function buildSubjectAltNameExtension(altNames) {
+	const names = [];
+	for (const alt of altNames) if (alt.type === "dns") names.push(encodeTlv(130, Buffer.from(alt.value, "ascii")));
+	else names.push(encodeTlv(135, encodeIpAddress(alt.value)));
+	const sanValue = encodeSequence(...names);
+	return encodeSequence(encodeOid(OID_SUBJECT_ALT_NAME), encodeOctetString(sanValue));
+}
+function buildExtensions(altNames) {
+	return encodeContextSpecific(3, encodeSequence(buildSubjectAltNameExtension(altNames)));
+}
+function buildTbsCertificate(serialNumber, issuerCn, notBefore, notAfter, subjectCn, publicKeyDer, altNames) {
+	return encodeSequence(encodeContextSpecific(0, encodeInteger(2)), encodeInteger(serialNumber), buildAlgorithmIdentifier(), buildName(issuerCn), buildValidity(notBefore, notAfter), buildName(subjectCn), publicKeyDer, buildExtensions(altNames));
+}
+function derToPem(der, label) {
+	const base64 = der.toString("base64");
+	const lines = [];
+	for (let i = 0; i < base64.length; i += 64) lines.push(base64.slice(i, i + 64));
+	return `-----BEGIN ${label}-----\n${lines.join("\n")}\n-----END ${label}-----\n`;
+}
+/**
+* Generate a self-signed certificate using only Node.js built-in crypto.
+* Returns PEM-encoded certificate and private key strings.
+*/
+function generateCertificate(options) {
+	const commonName = options?.commonName ?? "localhost";
+	const validityDays = options?.validityDays ?? 365;
+	const keySize = options?.keySize ?? 2048;
+	const altNames = options?.altNames ?? [
+		{
+			type: "dns",
+			value: "localhost"
+		},
+		{
+			type: "ip",
+			value: "127.0.0.1"
+		},
+		{
+			type: "ip",
+			value: "::1"
+		}
+	];
+	const { publicKey, privateKey } = crypto$1.generateKeyPairSync("rsa", {
+		modulusLength: keySize,
+		publicKeyEncoding: {
+			type: "spki",
+			format: "der"
+		},
+		privateKeyEncoding: {
+			type: "pkcs8",
+			format: "pem"
+		}
+	});
+	const notBefore = /* @__PURE__ */ new Date();
+	const notAfter = /* @__PURE__ */ new Date();
+	notAfter.setDate(notAfter.getDate() + validityDays);
+	const serialBytes = crypto$1.randomBytes(16);
+	serialBytes[0] &= 127;
+	let start = 0;
+	/* v8 ignore start -- depends on random data producing leading zeros */
+	while (start < serialBytes.length - 1 && serialBytes[start] === 0) start++;
+	const tbsCertificate = buildTbsCertificate(serialBytes.subarray(start), commonName, notBefore, notAfter, commonName, publicKey, altNames);
+	const signer = crypto$1.createSign("SHA256");
+	signer.update(tbsCertificate);
+	const signature = signer.sign(privateKey);
+	return {
+		cert: derToPem(encodeSequence(tbsCertificate, buildAlgorithmIdentifier(), encodeBitString(signature)), "CERTIFICATE"),
+		key: privateKey
+	};
+}
+/**
+* Generate a self-signed certificate and write PEM files to disk.
+* Returns the same CertificateResult as generateCertificate().
+*/
+async function generateCertificateFiles(options) {
+	const result = generateCertificate(options);
+	await fsPromises.writeFile(options.certPath, result.cert, "utf8");
+	await fsPromises.writeFile(options.keyPath, result.key, "utf8");
+	return result;
+}
+//#endregion
+//#region src/fastify-config.ts
+function getFastifyConfig(logging = true) {
+	return { logger: logging ? { transport: {
+		target: "pino-pretty",
+		options: {
+			colorize: true,
+			translateTime: true,
+			ignore: "pid,hostname",
+			singleLine: true
+		}
+	} } : false };
+}
+//#endregion
+//#region src/routes/anything/index.ts
+const anythingSchema = {
+	description: "Will return anything that you send it",
+	tags: ["Anything"],
+	response: { 200: {
+		type: "object",
+		properties: {
+			args: {
+				type: "object",
+				description: "Route parameters",
+				additionalProperties: true
+			},
+			data: {
+				type: "object",
+				description: "Request body data",
+				additionalProperties: true
+			},
+			files: {
+				type: "object",
+				description: "Uploaded files",
+				additionalProperties: true
+			},
+			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"
+			}
+		},
+		additionalProperties: false
+	} }
+};
+const anythingRoute = (fastify) => {
+	const handler = async (request, reply) => {
+		const response = {
+			args: request.query,
+			data: request.body ?? {},
+			files: request.raw?.files ?? {},
+			form: request.body ?? {},
+			headers: request.headers,
+			json: request.body ?? {},
+			method: request.method,
+			origin: request.headers.origin ?? request.headers.host ?? "",
+			url: request.url
+		};
+		await reply.send(response);
+	};
+	const noValidation = {
+		schema: anythingSchema,
+		validatorCompiler: () => () => true
+	};
+	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);
+};
+//#endregion
+//#region src/routes/auth/basic.ts
+const parseBasic$1 = (header) => {
+	if (!header || typeof header !== "string") return;
+	const spaceIndex = header.indexOf(" ");
+	if (spaceIndex === -1) return;
+	const scheme = header.slice(0, spaceIndex);
+	const value = header.slice(spaceIndex + 1);
+	if (scheme.toLowerCase() !== "basic" || !value) return;
+	try {
+		const decoded = Buffer$1.from(value, "base64").toString("utf8");
+		const idx = decoded.indexOf(":");
+		if (idx === -1) return;
+		const username = decoded.slice(0, idx);
+		const password = decoded.slice(idx + 1);
+		if (username === "") return;
+		return {
+			username,
+			password
+		};
+	} catch {
+		/* v8 ignore next -- @preserve */
+		return;
+	}
+};
+const safeCompare = (a, b) => {
+	if (a.length !== b.length) return false;
+	try {
+		return timingSafeEqual(Buffer$1.from(a, "utf8"), Buffer$1.from(b, "utf8"));
+	} catch {
+		/* v8 ignore next -- @preserve */
+		return false;
+	}
+};
+const 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"]
+		}
+	}
+};
+const basicAuthRoute = (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") {
+			reply.header("WWW-Authenticate", "Basic realm=\"mockhttp\"");
+			return reply.status(401).send({ message: "Unauthorized" });
+		}
+		const parsed = parseBasic$1(request.headers.authorization);
+		if (!parsed || !safeCompare(parsed.username, user) || !safeCompare(parsed.password, passwd)) {
+			reply.header("WWW-Authenticate", "Basic realm=\"mockhttp\"");
+			return reply.status(401).send({ message: "Unauthorized" });
+		}
+		return reply.send({
+			authenticated: true,
+			user
+		});
+	});
+};
+//#endregion
+//#region src/routes/auth/bearer.ts
+const parseBearer = (header) => {
+	if (!header) return;
+	const [scheme, token] = header.split(" ");
+	if (!scheme || scheme.toLowerCase() !== "bearer" || !token) return;
+	return token;
+};
+const 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"]
+		}
+	}
+};
+const bearerAuthRoute = (fastify) => {
+	fastify.get("/bearer", { schema: bearerAuthSchema }, async (request, reply) => {
+		const token = parseBearer(request.headers.authorization);
+		const required = request.query?.required ?? true;
+		if (!token && required) {
+			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
+		});
+	});
+};
+//#endregion
+//#region src/routes/auth/digest.ts
+const makeNonce = () => crypto.randomBytes(16).toString("hex");
+const algorithms = new Set([
+	"MD5",
+	"md5",
+	"SHA-256",
+	"sha-256",
+	"SHA-512",
+	"sha-512"
+]);
+const hashAlg = (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";
+};
+const h = (algo, data) => crypto.createHash(algo).update(data).digest("hex");
+const parseDigest = (header) => {
+	if (!header) return;
+	const spaceIndex = header.indexOf(" ");
+	/* v8 ignore next -- @preserve */
+	if (spaceIndex === -1) return;
+	const scheme = header.slice(0, spaceIndex);
+	const rest = header.slice(spaceIndex + 1);
+	if (!scheme || scheme.toLowerCase() !== "digest" || !rest) return;
+	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();
+		let value = p.slice(equalIndex + 1).trim();
+		if (value.startsWith("\"") && value.endsWith("\"")) value = value.slice(1, -1);
+		out[k] = value;
+	}
+	return out;
+};
+const 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"
+		]
+	}
+};
+const digestAuthRoute = (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) {
+			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) {
+			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) {
+			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) {
+			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) {
+			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) {
+			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
+		});
+	});
+};
+//#endregion
+//#region src/routes/auth/hidden-basic.ts
+const parseBasic = (header) => {
+	if (!header) return;
+	const [scheme, value] = header.split(" ");
+	if (!scheme || scheme.toLowerCase() !== "basic" || !value) return;
+	try {
+		const decoded = Buffer$1.from(value, "base64").toString("utf8");
+		const idx = decoded.indexOf(":");
+		if (idx === -1) return;
+		return {
+			username: decoded.slice(0, idx),
+			password: decoded.slice(idx + 1)
+		};
+	} catch {
+		/* v8 ignore next -- @preserve */
+		return;
+	}
+};
+const 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"]
+	}
+};
+const hiddenBasicAuthRoute = (fastify) => {
+	fastify.get("/hidden-basic-auth/:user/:passwd", { schema: hiddenBasicAuthSchema }, async (request, reply) => {
+		const { user, passwd } = request.params;
+		const parsed = parseBasic(request.headers.authorization);
+		if (!parsed || parsed.username !== user || parsed.password !== passwd) {
+			reply.header("WWW-Authenticate", "Basic realm=\"mockhttp\"");
+			return reply.status(401).send({ message: "Unauthorized" });
+		}
+		return reply.send({
+			authenticated: true,
+			user
+		});
+	});
+};
+//#endregion
+//#region src/routes/cookies/delete.ts
+const cookiesDeleteSchema = {
+	description: "Delete a cookie",
+	tags: ["Cookies"],
+	querystring: {
+		type: "object",
+		properties: { name: { type: "string" } },
+		required: ["name"],
+		additionalProperties: false
+	},
+	response: { 204: { type: "null" } }
+};
+const deleteCookieRoute = (fastify) => {
+	fastify.delete("/cookies", { schema: cookiesDeleteSchema }, async (request, reply) => {
+		const { name } = request.query;
+		reply.clearCookie(name, { path: "/" });
+		return reply.status(204).send();
+	});
+};
+//#endregion
+//#region src/routes/cookies/get.ts
+const getCookiesRouteSchema = {
+	description: "Return cookies from the request",
+	tags: ["Cookies"],
+	response: { 200: {
+		type: "object",
+		properties: { cookies: {
+			type: "object",
+			additionalProperties: { type: "string" }
+		} },
+		required: ["cookies"]
+	} }
+};
+const getCookiesRoute = (fastify) => {
+	fastify.get("/cookies", { schema: getCookiesRouteSchema }, async (request, reply) => {
+		reply.type("application/json");
+		await reply.send({ cookies: request.cookies });
+	});
+};
+//#endregion
+//#region src/routes/cookies/post.ts
+const 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"]
+	} }
+};
+const postCookieRoute = (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();
+	});
+};
+//#endregion
+//#region src/routes/dynamic-data/base64.ts
+const base64Schema = {
+	description: "Decodes base64url-encoded string",
+	tags: ["Dynamic Data"],
+	params: {
+		type: "object",
+		properties: { value: {
+			type: "string",
+			description: "Base64 encoded value to decode"
+		} },
+		required: ["value"]
+	},
+	response: {
+		200: {
+			type: "string",
+			description: "Decoded value"
+		},
+		400: {
+			type: "object",
+			properties: { error: { type: "string" } }
+		}
+	}
+};
+function isValidBase64(str) {
+	if (!/^[A-Za-z0-9+/\-_]*={0,2}$/.test(str)) return false;
+	return str.replace(/=+$/, "").length % 4 !== 1;
+}
+const base64Route = (fastify) => {
+	fastify.get("/base64/:value", { schema: base64Schema }, async (request, reply) => {
+		const { value } = request.params;
+		if (!isValidBase64(value)) return reply.code(400).send({ error: "Incorrect Base64 data" });
+		const normalizedValue = value.replace(/-/g, "+").replace(/_/g, "/");
+		const decoded = Buffer.from(normalizedValue, "base64").toString("utf-8");
+		return reply.header("Content-Type", "text/html; charset=utf-8").send(decoded);
+	});
+};
+//#endregion
+//#region src/routes/dynamic-data/bytes.ts
+const bytesSchema = {
+	description: "Returns n random bytes generated with given seed",
+	tags: ["Dynamic Data"],
+	params: {
+		type: "object",
+		properties: { n: {
+			type: "string",
+			description: "Number of bytes to generate"
+		} },
+		required: ["n"]
+	},
+	querystring: {
+		type: "object",
+		properties: { seed: {
+			type: "string",
+			description: "Seed for random number generation"
+		} }
+	},
+	response: {
+		200: {
+			type: "string",
+			description: "Random binary data"
+		},
+		400: {
+			type: "object",
+			properties: { error: { type: "string" } }
+		}
+	}
+};
+function seededRandom$1(seed) {
+	let state = seed;
+	return () => {
+		state = state * 1103515245 + 12345 & 2147483647;
+		return state / 2147483647;
+	};
+}
+function generateSeededBytes$1(n, seed) {
+	const random = seededRandom$1(seed);
+	const bytes = Buffer.alloc(n);
+	for (let i = 0; i < n; i++) bytes[i] = Math.floor(random() * 256);
+	return bytes;
+}
+const MAX_BYTES$3 = 100 * 1024;
+const bytesRoute = (fastify) => {
+	fastify.get("/bytes/:n", { schema: bytesSchema }, async (request, reply) => {
+		const n = Number.parseInt(request.params.n, 10);
+		if (Number.isNaN(n) || n < 0) return reply.code(400).send({ error: "n must be a non-negative integer" });
+		const limitedN = Math.min(n, MAX_BYTES$3);
+		const seedParam = request.query.seed;
+		let bytes;
+		if (seedParam !== void 0) {
+			const seed = Number.parseInt(seedParam, 10);
+			if (Number.isNaN(seed)) return reply.code(400).send({ error: "seed must be an integer" });
+			bytes = generateSeededBytes$1(limitedN, seed);
+		} else bytes = randomBytes(limitedN);
+		return reply.header("Content-Type", "application/octet-stream").header("Content-Length", bytes.length).send(bytes);
+	});
+};
+//#endregion
+//#region src/routes/dynamic-data/delay.ts
+const delaySchema = {
+	description: "Returns a delayed response (max of 10 seconds)",
+	tags: ["Dynamic Data"],
+	params: {
+		type: "object",
+		properties: { delay: {
+			type: "string",
+			description: "Delay in seconds (max 10)"
+		} },
+		required: ["delay"]
+	},
+	querystring: {
+		type: "object",
+		additionalProperties: true
+	},
+	response: {
+		200: {
+			type: "object",
+			properties: {
+				args: { type: "object" },
+				data: { type: "string" },
+				files: { type: "object" },
+				form: { type: "object" },
+				headers: { type: "object" },
+				origin: { type: "string" },
+				url: { type: "string" }
+			}
+		},
+		400: {
+			type: "object",
+			properties: { error: { type: "string" } }
+		}
+	}
+};
+const MAX_DELAY$1 = 10;
+function sleep$2(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const delayRoute = (fastify) => {
+	const handler = async (request, reply) => {
+		const delay = Number.parseFloat(request.params.delay);
+		if (Number.isNaN(delay) || delay < 0) return reply.code(400).send({ error: "delay must be a non-negative number" });
+		await sleep$2(Math.min(delay, MAX_DELAY$1) * 1e3);
+		const { protocol } = request;
+		/* v8 ignore next -- @preserve */
+		const host = request.headers.host || "localhost";
+		return {
+			args: request.query || {},
+			data: "",
+			files: {},
+			form: {},
+			headers: request.headers,
+			origin: request.ip,
+			url: `${protocol}://${host}${request.url}`
+		};
+	};
+	fastify.get("/delay/:delay", { schema: delaySchema }, handler);
+	fastify.post("/delay/:delay", { schema: delaySchema }, handler);
+	fastify.put("/delay/:delay", { schema: delaySchema }, handler);
+	fastify.patch("/delay/:delay", { schema: delaySchema }, handler);
+	fastify.delete("/delay/:delay", { schema: delaySchema }, handler);
+};
+//#endregion
+//#region src/routes/dynamic-data/drip.ts
+const dripSchema = {
+	description: "Drips data over a duration after an optional initial delay, then (optionally) returns with the given status code",
+	tags: ["Dynamic Data"],
+	querystring: {
+		type: "object",
+		properties: {
+			duration: {
+				type: "string",
+				description: "Duration in seconds over which to drip the data (default: 2)"
+			},
+			numbytes: {
+				type: "string",
+				description: "Number of bytes to send (default: 10)"
+			},
+			code: {
+				type: "string",
+				description: "HTTP status code to return (default: 200)"
+			},
+			delay: {
+				type: "string",
+				description: "Initial delay in seconds before starting (default: 2)"
+			}
+		}
+	},
+	response: {
+		200: {
+			type: "string",
+			description: "Dripped data"
+		},
+		400: {
+			type: "object",
+			properties: { error: { type: "string" } }
+		}
+	}
+};
+function sleep$1(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const DEFAULT_DURATION = 2;
+const DEFAULT_NUMBYTES = 10;
+const DEFAULT_CODE = 200;
+const DEFAULT_DELAY = 2;
+const MAX_DURATION = 10;
+const MAX_DELAY = 10;
+const MAX_BYTES$2 = 10 * 1024 * 1024;
+const dripRoute = (fastify) => {
+	fastify.get("/drip", { schema: dripSchema }, async (request, reply) => {
+		/* v8 ignore next 2 -- @preserve */
+		const duration = request.query.duration ? Number.parseFloat(request.query.duration) : DEFAULT_DURATION;
+		const numbytes = request.query.numbytes ? Number.parseInt(request.query.numbytes, 10) : DEFAULT_NUMBYTES;
+		/* v8 ignore next 2 -- @preserve */
+		const code = request.query.code ? Number.parseInt(request.query.code, 10) : DEFAULT_CODE;
+		/* v8 ignore next 3 -- @preserve */
+		const delay = request.query.delay ? Number.parseFloat(request.query.delay) : DEFAULT_DELAY;
+		if (Number.isNaN(duration) || duration < 0) return reply.code(400).send({ error: "duration must be a non-negative number" });
+		if (Number.isNaN(numbytes) || numbytes < 0) return reply.code(400).send({ error: "numbytes must be a non-negative integer" });
+		if (Number.isNaN(code) || code < 100 || code > 599) return reply.code(400).send({ error: "code must be a valid HTTP status code" });
+		if (Number.isNaN(delay) || delay < 0) return reply.code(400).send({ error: "delay must be a non-negative number" });
+		const actualDuration = Math.min(duration, MAX_DURATION);
+		const actualDelay = Math.min(delay, MAX_DELAY);
+		const actualBytes = Math.min(numbytes, MAX_BYTES$2);
+		if (actualDelay > 0) await sleep$1(actualDelay * 1e3);
+		reply.raw.writeHead(code, {
+			"Content-Type": "application/octet-stream",
+			"Content-Length": actualBytes.toString()
+		});
+		if (actualBytes === 0) {
+			reply.raw.end();
+			return;
+		}
+		const intervalMs = actualBytes > 1 ? actualDuration * 1e3 / (actualBytes - 1) : 0;
+		const byte = Buffer.from("*");
+		for (let i = 0; i < actualBytes; i++) {
+			reply.raw.write(byte);
+			if (i < actualBytes - 1 && intervalMs > 0) await sleep$1(intervalMs);
+		}
+		reply.raw.end();
+	});
+};
+//#endregion
+//#region src/routes/dynamic-data/links.ts
+const linksSchema = {
+	description: "Generate a page containing n links to other pages which do the same",
+	tags: ["Dynamic Data"],
+	params: {
+		type: "object",
+		properties: {
+			n: {
+				type: "string",
+				description: "Number of links to generate"
+			},
+			offset: {
+				type: "string",
+				description: "Starting offset for pagination (default: 0)"
+			}
+		},
+		required: ["n"]
+	},
+	response: {
+		200: {
+			type: "string",
+			description: "HTML page with links"
+		},
+		400: {
+			type: "object",
+			properties: { error: { type: "string" } }
+		}
+	}
+};
+const MAX_LINKS = 200;
+const linksRoute = (fastify) => {
+	fastify.get("/links/:n/:offset?", { schema: linksSchema }, async (request, reply) => {
+		const n = Number.parseInt(request.params.n, 10);
+		const offset = request.params.offset ? Number.parseInt(request.params.offset, 10) : 0;
+		if (Number.isNaN(n) || n < 0) return reply.code(400).send({ error: "n must be a non-negative integer" });
+		if (Number.isNaN(offset) || offset < 0) return reply.code(400).send({ error: "offset must be a non-negative integer" });
+		const limitedN = Math.min(n, MAX_LINKS);
+		const links = [];
+		for (let i = 0; i < limitedN; i++) if (i === offset) links.push(`${i} `);
+		else links.push(`<a href="/links/${limitedN}/${i}">${i}</a> `);
+		const html = `<html>
+<head>
+<title>Links</title>
+</head>
+<body>
+${links.join("")}
+</body>
+</html>`;
+		return reply.header("Content-Type", "text/html; charset=utf-8").send(html);
+	});
+};
+//#endregion
+//#region src/routes/dynamic-data/range.ts
+const rangeSchema = {
+	description: "Streams n random bytes generated, and supports HTTP Range requests",
+	tags: ["Dynamic Data"],
+	params: {
+		type: "object",
+		properties: { numbytes: {
+			type: "string",
+			description: "Number of bytes available"
+		} },
+		required: ["numbytes"]
+	},
+	querystring: {
+		type: "object",
+		properties: { duration: {
+			type: "string",
+			description: "Delay before sending response in seconds"
+		} }
+	},
+	response: {
+		200: {
+			type: "string",
+			description: "Binary data"
+		},
+		206: {
+			type: "string",
+			description: "Partial binary data"
+		},
+		400: {
+			type: "object",
+			properties: { error: { type: "string" } }
+		},
+		416: {
+			type: "object",
+			properties: { error: { type: "string" } }
+		}
+	}
+};
+const MAX_BYTES$1 = 100 * 1024;
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function generateBytes(n) {
+	const alphabet = "abcdefghijklmnopqrstuvwxyz";
+	const bytes = Buffer.alloc(n);
+	for (let i = 0; i < n; i++) bytes[i] = alphabet.charCodeAt(i % 26);
+	return bytes;
+}
+function parseRangeHeader(rangeHeader, totalSize) {
+	const match = rangeHeader.match(/^bytes=(.+)$/);
+	if (!match) return null;
+	const ranges = [];
+	const parts = match[1].split(",");
+	for (const part of parts) {
+		const trimmedPart = part.trim();
+		if (trimmedPart.startsWith("-")) {
+			const suffix = Number.parseInt(trimmedPart.slice(1), 10);
+			/* v8 ignore next -- @preserve */
+			if (Number.isNaN(suffix)) return null;
+			ranges.push({
+				start: Math.max(0, totalSize - suffix),
+				end: totalSize - 1
+			});
+		} else if (trimmedPart.endsWith("-")) {
+			const start = Number.parseInt(trimmedPart.slice(0, -1), 10);
+			/* v8 ignore next -- @preserve */
+			if (Number.isNaN(start)) return null;
+			ranges.push({
+				start,
+				end: totalSize - 1
+			});
+		} else {
+			const [startStr, endStr] = trimmedPart.split("-");
+			const start = Number.parseInt(startStr, 10);
+			const end = Number.parseInt(endStr, 10);
+			/* v8 ignore next -- @preserve */
+			if (Number.isNaN(start) || Number.isNaN(end)) return null;
+			ranges.push({
+				start,
+				end: Math.min(end, totalSize - 1)
+			});
+		}
+	}
+	for (const range of ranges) if (range.start > range.end || range.start >= totalSize) return null;
+	return ranges;
+}
+const rangeRoute = (fastify) => {
+	fastify.get("/range/:numbytes", { schema: rangeSchema }, async (request, reply) => {
+		const numbytes = Number.parseInt(request.params.numbytes, 10);
+		if (Number.isNaN(numbytes) || numbytes < 0) return reply.code(400).send({ error: "numbytes must be a non-negative integer" });
+		const limitedBytes = Math.min(numbytes, MAX_BYTES$1);
+		if (request.query.duration) {
+			const duration = Number.parseFloat(request.query.duration);
+			if (!Number.isNaN(duration) && duration > 0) await sleep(Math.min(duration, 10) * 1e3);
+		}
+		const allBytes = generateBytes(limitedBytes);
+		const rangeHeader = request.headers.range;
+		if (!rangeHeader) return reply.header("Content-Type", "application/octet-stream").header("Content-Length", allBytes.length).header("Accept-Ranges", "bytes").send(allBytes);
+		const ranges = parseRangeHeader(rangeHeader, limitedBytes);
+		if (!ranges || ranges.length === 0) return reply.code(416).header("Content-Range", `bytes */${limitedBytes}`).send({ error: "Range Not Satisfiable" });
+		if (ranges.length === 1) {
+			const range = ranges[0];
+			const chunk = allBytes.subarray(range.start, range.end + 1);
+			return reply.code(206).header("Content-Type", "application/octet-stream").header("Content-Length", chunk.length).header("Accept-Ranges", "bytes").header("Content-Range", `bytes ${range.start}-${range.end}/${limitedBytes}`).send(chunk);
+		}
+		const boundary = "3d6b6a416f9b5";
+		const parts = [];
+		for (const range of ranges) {
+			const chunk = allBytes.subarray(range.start, range.end + 1);
+			const header = `\r\n--${boundary}\r\nContent-Type: application/octet-stream\r\nContent-Range: bytes ${range.start}-${range.end}/${limitedBytes}\r\n\r\n`;
+			parts.push(Buffer.from(header));
+			parts.push(chunk);
+		}
+		parts.push(Buffer.from(`\r\n--${boundary}--\r\n`));
+		const multipartBody = Buffer.concat(parts);
+		return reply.code(206).header("Content-Type", `multipart/byteranges; boundary=${boundary}`).header("Content-Length", multipartBody.length).send(multipartBody);
+	});
+};
+//#endregion
+//#region src/routes/dynamic-data/stream.ts
+const streamSchema = {
+	description: "Stream n JSON responses",
+	tags: ["Dynamic Data"],
+	params: {
+		type: "object",
+		properties: { n: {
+			type: "string",
+			description: "Number of JSON responses to stream (max 100)"
+		} },
+		required: ["n"]
+	},
+	response: {
+		200: {
+			type: "string",
+			description: "Newline-delimited JSON responses"
+		},
+		400: {
+			type: "object",
+			properties: { error: { type: "string" } }
+		}
+	}
+};
+const MAX_LINES = 100;
+const streamRoute = (fastify) => {
+	fastify.get("/stream/:n", { schema: streamSchema }, async (request, reply) => {
+		const n = Number.parseInt(request.params.n, 10);
+		if (Number.isNaN(n) || n < 0) return reply.code(400).send({ error: "n must be a non-negative integer" });
+		const lines = Math.min(n, MAX_LINES);
+		const { protocol } = request;
+		/* v8 ignore next -- @preserve */
+		const host = request.headers.host || "localhost";
+		reply.raw.writeHead(200, {
+			"Content-Type": "application/json",
+			"Transfer-Encoding": "chunked"
+		});
+		for (let i = 0; i < lines; i++) {
+			const data = {
+				id: i,
+				args: request.query || {},
+				headers: request.headers,
+				origin: request.ip,
+				url: `${protocol}://${host}${request.url}`
+			};
+			reply.raw.write(`${JSON.stringify(data)}\n`);
+		}
+		reply.raw.end();
+	});
+};
+//#endregion
+//#region src/routes/dynamic-data/stream-bytes.ts
+const streamBytesSchema = {
+	description: "Streams n random bytes generated with given seed, in chunks of chunk_size per packet",
+	tags: ["Dynamic Data"],
+	params: {
+		type: "object",
+		properties: { n: {
+			type: "string",
+			description: "Number of bytes to stream"
+		} },
+		required: ["n"]
+	},
+	querystring: {
+		type: "object",
+		properties: {
+			seed: {
+				type: "string",
+				description: "Seed for random number generation"
+			},
+			chunk_size: {
+				type: "string",
+				description: "Size of each chunk (default: 10240)"
+			}
+		}
+	},
+	response: {
+		200: {
+			type: "string",
+			description: "Streamed random binary data"
+		},
+		400: {
+			type: "object",
+			properties: { error: { type: "string" } }
+		}
+	}
+};
+function seededRandom(seed) {
+	let state = seed;
+	return () => {
+		state = state * 1103515245 + 12345 & 2147483647;
+		return state / 2147483647;
+	};
+}
+function generateSeededBytes(n, seed) {
+	const random = seededRandom(seed);
+	const bytes = Buffer.alloc(n);
+	for (let i = 0; i < n; i++) bytes[i] = Math.floor(random() * 256);
+	return bytes;
+}
+const MAX_BYTES = 100 * 1024;
+const DEFAULT_CHUNK_SIZE = 10240;
+const streamBytesRoute = (fastify) => {
+	fastify.get("/stream-bytes/:n", { schema: streamBytesSchema }, async (request, reply) => {
+		const n = Number.parseInt(request.params.n, 10);
+		if (Number.isNaN(n) || n < 0) return reply.code(400).send({ error: "n must be a non-negative integer" });
+		const limitedN = Math.min(n, MAX_BYTES);
+		const chunkSize = request.query.chunk_size ? Number.parseInt(request.query.chunk_size, 10) : DEFAULT_CHUNK_SIZE;
+		if (Number.isNaN(chunkSize) || chunkSize <= 0) return reply.code(400).send({ error: "chunk_size must be a positive integer" });
+		const seedParam = request.query.seed;
+		let allBytes;
+		if (seedParam !== void 0) {
+			const seed = Number.parseInt(seedParam, 10);
+			if (Number.isNaN(seed)) return reply.code(400).send({ error: "seed must be an integer" });
+			allBytes = generateSeededBytes(limitedN, seed);
+		} else allBytes = randomBytes(limitedN);
+		reply.raw.writeHead(200, {
+			"Content-Type": "application/octet-stream",
+			"Transfer-Encoding": "chunked"
+		});
+		let offset = 0;
+		while (offset < allBytes.length) {
+			const chunk = allBytes.subarray(offset, offset + chunkSize);
+			reply.raw.write(chunk);
+			offset += chunkSize;
+		}
+		reply.raw.end();
+	});
+};
+//#endregion
+//#region src/routes/dynamic-data/uuid.ts
+const uuidSchema = {
+	description: "Return a UUID4",
+	tags: ["Dynamic Data"],
+	response: { 200: {
+		type: "object",
+		properties: { uuid: {
+			type: "string",
+			format: "uuid"
+		} },
+		required: ["uuid"]
+	} }
+};
+const uuidRoute = (fastify) => {
+	fastify.get("/uuid", { schema: uuidSchema }, async () => ({ uuid: randomUUID() }));
+};
+//#endregion
+//#region src/routes/http-methods/delete.ts
+const 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"]
+	} }
+};
+const deleteRoute = (fastify) => {
+	fastify.delete("/delete", { schema: deleteSchema }, async (request) => ({
+		method: "DELETE",
+		headers: request.headers,
+		body: request.body
+	}));
+};
+//#endregion
+//#region src/routes/http-methods/get.ts
+const 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"
+		]
+	} }
+};
+const getRoute = (fastify) => {
+	fastify.get("/get", { schema: getSchema }, async (request, _reply) => ({
+		method: "GET",
+		headers: request.headers,
+		queryParams: request.query
+	}));
+};
+//#endregion
+//#region src/routes/http-methods/patch.ts
+const 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"
+		]
+	} }
+};
+const patchRoute = (fastify) => {
+	fastify.patch("/patch", { schema: patchSchema }, async (request) => ({
+		method: "PATCH",
+		headers: request.headers,
+		body: request.body
+	}));
+};
+//#endregion
+//#region src/routes/http-methods/post.ts
+const 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"
+		]
+	} }
+};
+const postRoute = (fastify) => {
+	fastify.post("/post", { schema: postSchema }, async (request) => ({
+		method: "POST",
+		headers: request.headers,
+		body: request.body
+	}));
+};
+//#endregion
+//#region src/routes/http-methods/put.ts
+const 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"
+		]
+	} }
+};
+const putRoute = (fastify) => {
+	fastify.put("/put", { schema: putSchema }, async (request) => ({
+		method: "PUT",
+		headers: request.headers,
+		body: request.body
+	}));
+};
+//#endregion
+//#region src/routes/images/index.ts
+const 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"
+	} }
+};
+const jpegSchema = {
+	description: "Returns a JPEG image",
+	tags: ["Images"],
+	response: { 200: {
+		description: "JPEG image",
+		type: "string",
+		format: "binary"
+	} }
+};
+const pngSchema = {
+	description: "Returns a PNG image",
+	tags: ["Images"],
+	response: { 200: {
+		description: "PNG image",
+		type: "string",
+		format: "binary"
+	} }
+};
+const svgSchema = {
+	description: "Returns an SVG image",
+	tags: ["Images"],
+	response: { 200: {
+		description: "SVG image",
+		type: "string",
+		format: "binary"
+	} }
+};
+const webpSchema = {
+	description: "Returns a WEBP image",
+	tags: ["Images"],
+	response: { 200: {
+		description: "WEBP image",
+		type: "string",
+		format: "binary"
+	} }
+};
+const imageRoutes = (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 imageBuffer = readFileSync(join(publicPath, file));
+			reply.type(contentType);
+			return imageBuffer;
+		} catch (error) {
+			/* v8 ignore next -- @preserve */
+			reply.code(500);
+			/* v8 ignore next -- @preserve */
+			return { error: `${error}` };
+		}
+	});
+	fastify.get("/image/jpeg", { schema: jpegSchema }, async (_request, reply) => {
+		try {
+			const imageBuffer = readFileSync(join(publicPath, "logo.jpg"));
+			reply.type("image/jpeg");
+			return imageBuffer;
+		} catch (error) {
+			/* v8 ignore next -- @preserve */
+			reply.code(500);
+			/* v8 ignore next -- @preserve */
+			return { error: `${error}` };
+		}
+	});
+	fastify.get("/image/png", { schema: pngSchema }, async (_request, reply) => {
+		try {
+			const imageBuffer = readFileSync(join(publicPath, "logo.png"));
+			reply.type("image/png");
+			return imageBuffer;
+		} catch (error) {
+			/* v8 ignore next -- @preserve */
+			reply.code(500);
+			/* v8 ignore next -- @preserve */
+			return { error: `${error}` };
+		}
+	});
+	fastify.get("/image/svg", { schema: svgSchema }, async (_request, reply) => {
+		try {
+			const imageBuffer = readFileSync(join(publicPath, "logo.svg"));
+			reply.type("image/svg+xml");
+			return imageBuffer;
+		} catch (error) {
+			/* v8 ignore next -- @preserve */
+			reply.code(500);
+			/* v8 ignore next -- @preserve */
+			return { error: `${error}` };
+		}
+	});
+	fastify.get("/image/webp", { schema: webpSchema }, async (_request, reply) => {
+		try {
+			const imageBuffer = readFileSync(join(publicPath, "logo.webp"));
+			reply.type("image/webp");
+			return imageBuffer;
+		} catch (error) {
+			/* v8 ignore next -- @preserve */
+			reply.code(500);
+			/* v8 ignore next -- @preserve */
+			return { error: `${error}` };
+		}
+	});
+};
+//#endregion
+//#region src/routes/index.ts
+const indexRoute = (fastify) => {
+	fastify.get("/", { schema: { hide: true } }, async (_request, reply) => {
+		await reply.type("text/html").send(`
+	<!doctype html>
+<html>
+  <head>
+    <title>{ mockhttp }</title>
+    <meta charset="utf-8" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1" />
+    <meta name="description" content="MockHttp - A powerful HTTP mock server and httpbin replacement for API testing. Built with Fastify, TypeScript, and Docker support." />
+    <meta name="keywords" content="mock, http, httpbin, testing, api, fastify, docker, typescript, rest, mock-server, api-testing, http-testing, httpbin-alternative" />
+    <meta property="og:title" content="MockHttp - HTTP Mock Server" />
+    <meta property="og:description" content="A powerful HTTP mock server and httpbin replacement for API testing. Built with Fastify, TypeScript, and Docker support." />
+    <meta property="og:type" content="website" />
+    <meta property="og:url" content="https://mockhttp.org" />
+    <meta property="og:image" content="https://mockhttp.org/logo.png" />
+    <meta property="og:site_name" content="MockHttp" />
+    <meta name="twitter:card" content="summary" />
+    <meta name="twitter:title" content="MockHttp - HTTP Mock Server" />
+    <meta name="twitter:description" content="A powerful HTTP mock server and httpbin replacement for API testing." />
+    <meta name="twitter:image" content="https://mockhttp.org/logo.png" />
+      <style>
+      :root {
+  --scalar-custom-header-height: 70px;
+}
+.custom-header {
+  height: var(--scalar-custom-header-height);
+  background-color: var(--scalar-background-1);
+  box-shadow: inset 0 -1px 0 var(--scalar-border-color);
+  color: var(--scalar-color-1);
+  font-size: var(--scalar-font-size-2);
+  padding: 0 18px;
+  position: sticky;
+  justify-content: space-between;
+  top: 0;
+  z-index: 100;
+}
+.custom-header,
+.custom-header nav {
+  display: flex;
+  align-items: center;
+  gap: 18px;
+}
+
+.custom-header img {
+  height: var(--scalar-custom-header-height);
+  object-fit: contain;
+}
+
+.custom-header a:hover {
+  color: var(--scalar-color-2);
+}
+
+.github-corner {
+  fill: var(--scalar-border-color) !important;
+}
+
+      </style>
+  </head>
+  <body>
+  <header class="custom-header scalar-app">
+    <a href="/"><img src="/logo.svg" alt="{ mockhttp }" /></a>
+    <a href="https://github.com/jaredwray/mockhttp" class="github-corner" aria-label="View source on GitHub">
+      <svg width="70" height="70" viewBox="0 0 250 250" style="color:#fff; position: absolute; top: 0; border: 0; right: 0;" aria-hidden="true">
+      <path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path>
+      <path d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2" fill="currentColor" style="transform-origin: 130px 106px;" class="octo-arm"></path>
+      <path d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z" fill="currentColor" class="octo-body"></path></svg></a><style>.github-corner:hover .octo-arm{animation:octocat-wave 560ms ease-in-out}@keyframes octocat-wave{0%,100%{transform:rotate(0)}20%,60%{transform:rotate(-25deg)}40%,80%{transform:rotate(10deg)}}@media (max-width:500px){.github-corner:hover .octo-arm{animation:none}.github-corner .octo-arm{animation:octocat-wave 560ms ease-in-out}}</style>
+  </header>
+
+    <script
+      id="api-reference"
+      data-url="/docs/json"><\/script>
+
+    <script src="/scalar/browser/standalone.js"><\/script>
+  </body>
+</html>
+`);
+	});
+};
+//#endregion
+//#region src/routes/redirects/absolute-redirect.ts
+const 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" } }
+};
+const absoluteRedirectRoute = (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="${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="${url}">${url}</a>.  If not click the link.</p>
+            `;
+		}
+		await reply.header("Location", url).status(302).type("text/html").send(html);
+	});
+};
+//#endregion
+//#region src/routes/redirects/redirect-to.ts
+const 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
+	}
+};
+const redirectToRoute = (fastify) => {
+	const handler = async (request, reply) => {
+		const { url, status_code } = request.query;
+		const statusCode = status_code ? Number(status_code) : 302;
+		await reply.redirect(url, statusCode);
+	};
+	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);
+};
+//#endregion
+//#region src/routes/redirects/relative-redirect.ts
+const 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" } }
+};
+const relativeRedirectRoute = (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="${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="${url}">${url}</a>.  If not click the link.</p>
+            `;
+		}
+		await reply.header("Location", url).status(302).type("text/html").send(html);
+	});
+};
+//#endregion
+//#region src/routes/request-inspection/headers.ts
+const 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"]
+	} }
+};
+const headersRoute = (fastify) => {
+	fastify.get("/headers", { schema: headersSchema }, async (request) => {
+		const { headers } = request;
+		return { headers };
+	});
+};
+//#endregion
+//#region src/routes/request-inspection/ip.ts
+const 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"]
+	} }
+};
+const ipRoute = (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;
+		return { ip: cloudflareIp ?? (typeof forwardedIp === "string" ? forwardedIp.split(",")[0].trim() : remoteIp) };
+	});
+};
+//#endregion
+//#region src/routes/request-inspection/user-agent.ts
+const 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"]
+	} }
+};
+const userAgentRoute = (fastify) => {
+	fastify.get("/user-agent", { schema: userAgentSchema }, async (request) => {
+		return { userAgent: request.headers["user-agent"] };
+	});
+};
+//#endregion
+//#region src/routes/response-formats/index.ts
+const plainSchema = {
+	description: "Returns random plain text content",
+	tags: ["Response Formats"],
+	response: { 200: {
+		type: "string",
+		description: "Random plain text content"
+	} }
+};
+const textSchema = {
+	description: "Returns random text content",
+	tags: ["Response Formats"],
+	response: { 200: {
+		type: "string",
+		description: "Random text content"
+	} }
+};
+const htmlSchema = {
+	description: "Returns random HTML content",
+	tags: ["Response Formats"],
+	response: { 200: {
+		type: "string",
+		description: "Random HTML content"
+	} }
+};
+const xmlSchema = {
+	description: "Returns random XML content",
+	tags: ["Response Formats"],
+	response: { 200: {
+		type: "string",
+		description: "Random XML content"
+	} }
+};
+const jsonSchema = {
+	description: "Returns random JSON content",
+	tags: ["Response Formats"],
+	response: { 200: {
+		type: "object",
+		description: "Random JSON content",
+		additionalProperties: true
+	} }
+};
+const denySchema = {
+	description: "Returns page denied by robots.txt rules",
+	tags: ["Response Formats"],
+	response: { 403: {
+		type: "string",
+		description: "Page denied by robots.txt rules"
+	} }
+};
+const gzipSchema = {
+	description: "Returns GZip-encoded data",
+	tags: ["Response Formats"],
+	response: { 200: {
+		type: "string",
+		description: "GZip-encoded content"
+	} }
+};
+const deflateSchema = {
+	description: "Returns Deflate-encoded data",
+	tags: ["Response Formats"],
+	response: { 200: {
+		type: "string",
+		description: "Deflate-encoded content"
+	} }
+};
+const brotliSchema = {
+	description: "Returns Brotli-encoded data",
+	tags: ["Response Formats"],
+	response: { 200: {
+		type: "string",
+		description: "Brotli-encoded content"
+	} }
+};
+const 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."
+];
+const randomHtmlContent = [
+	`<!DOCTYPE html>
+<html lang="en">
+<head>
+    <title>Sample Page</title>
+</head>
+<body>
+    <h1>Welcome to MockHTTP</h1>
+    <p>This is a sample HTML page with random content.</p>
+</body>
+</html>`,
+	`<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Test Document</title>
+</head>
+<body>
+    <header>
+        <h1>Test Page</h1>
+        <nav>
+            <ul>
+                <li><a href="#">Home</a></li>
+                <li><a href="#">About</a></li>
+                <li><a href="#">Contact</a></li>
+            </ul>
+        </nav>
+    </header>
+    <main>
+        <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit.</p>
+    </main>
+</body>
+</html>`,
+	`<!DOCTYPE html>
+<html lang="en">
+<head>
+    <title>Article Page</title>
+    <style>
+        body { font-family: Arial, sans-serif; }
+        article { max-width: 800px; margin: 0 auto; }
+    </style>
+</head>
+<body>
+    <article>
+        <h1>The Journey Begins</h1>
+        <p>Once upon a time in a digital world...</p>
+        <blockquote>
+            "The only way to do great work is to love what you do."
+        </blockquote>
+    </article>
+</body>
+</html>`,
+	`<!DOCTYPE html>
+<html>
+<head>
+    <title>Form Example</title>
+</head>
+<body>
+    <h2>Contact Form</h2>
+    <form action="/submit" method="post">
+        <label for="name">Name:</label>
+        <input type="text" id="name" name="name" required>
+        <br>
+        <label for="email">Email:</label>
+        <input type="email" id="email" name="email" required>
+        <br>
+        <button type="submit">Submit</button>
+    </form>
+</body>
+</html>`,
+	`<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Responsive Page</title>
+</head>
+<body>
+    <div class="container">
+        <h1>Responsive Design</h1>
+        <p>This page adapts to different screen sizes.</p>
+        <img src="placeholder.jpg" alt="Placeholder" style="max-width: 100%; height: auto;">
+    </div>
+</body>
+</html>`
+];
+const randomXmlContent = [
+	`<?xml version="1.0" encoding="UTF-8"?>
+<root>
+    <message>Hello from MockHTTP</message>
+    <timestamp>${(/* @__PURE__ */ new Date()).toISOString()}</timestamp>
+    <status>success</status>
+</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"?>
+<users>
+    <user id="1">
+        <name>John Doe</name>
+        <email>john@example.com</email>
+        <role>admin</role>
+    </user>
+    <user id="2">
+        <name>Jane Smith</name>
+        <email>jane@example.com</email>
+        <role>user</role>
+    </user>
+</users>`,
+	`<?xml version="1.0" encoding="UTF-8"?>
+<product>
+    <id>12345</id>
+    <name>Wireless Mouse</name>
+    <description>Ergonomic wireless mouse with 3-year battery life</description>
+    <price currency="USD">29.99</price>
+    <stock>150</stock>
+    <category>Electronics</category>
+</product>`,
+	`<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0">
+    <channel>
+        <title>Mock RSS Feed</title>
+        <link>http://example.com/rss</link>
+        <description>Sample RSS feed from MockHTTP</description>
+        <item>
+            <title>First Article</title>
+            <link>http://example.com/article1</link>
+            <description>This is the first article in our feed</description>
+            <pubDate>${(/* @__PURE__ */ new Date()).toUTCString()}</pubDate>
+        </item>
+    </channel>
+</rss>`
+];
+const 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"
+			}
+		]
+	} })
+];
+const responseFormatRoutes = (fastify) => {
+	const plainHandler = async (_request, reply) => {
+		const text = randomTexts[Math.floor(Math.random() * randomTexts.length)];
+		reply.type("text/plain");
+		return text;
+	};
+	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 = async (_request, reply) => {
+		const text = randomTexts[Math.floor(Math.random() * randomTexts.length)];
+		reply.type("text/plain");
+		return text;
+	};
+	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 = async (_request, reply) => {
+		const html = randomHtmlContent[Math.floor(Math.random() * randomHtmlContent.length)];
+		reply.type("text/html");
+		return html;
+	};
+	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 = async (_request, reply) => {
+		const xml = randomXmlContent[Math.floor(Math.random() * randomXmlContent.length)];
+		reply.type("application/xml");
+		return xml;
+	};
+	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 = async (_request, reply) => {
+		const jsonGenerator = randomJsonContent[Math.floor(Math.random() * randomJsonContent.length)];
+		const json = jsonGenerator();
+		reply.type("application/json");
+		return json;
+	};
+	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 = 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>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>403 - Access Denied</title>
+</head>
+<body>
+<h1>403 Forbidden</h1>
+<p>This page is blocked by robots.txt rules.</p>
+<p>User-agent: *<br>Disallow: ${_request.url}</p>
+</body>
+</html>`,
+			`<!DOCTYPE html>
+<html>
+<head>
+<title>403 - Access Denied</title>
+<style>body { font-family: Arial, sans-serif; margin: 40px; }</style>
+</head>
+<body>
+<h2>403 - Access Denied by robots.txt</h2>
+<p>The robots.txt file prevents access to this resource.</p>
+<hr>
+<small>MockHTTP Server</small>
+</body>
+</html>`
+		];
+		const html = denyMessages[Math.floor(Math.random() * denyMessages.length)];
+		reply.code(403);
+		reply.type("text/html");
+		return html;
+	};
+	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 = 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 data = sampleData[Math.floor(Math.random() * sampleData.length)];
+		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 updatedCompressed = gzipSync(JSON.stringify(updatedData));
+			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;
+	};
+	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 = 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: (/* @__PURE__ */ new Date(Date.now() - i * 1e6)).toISOString()
+				})),
+				metadata: {
+					compression: "deflate",
+					count: 50
+				}
+			}
+		];
+		const data = sampleData[Math.floor(Math.random() * sampleData.length)];
+		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 updatedCompressed = deflateSync(JSON.stringify(updatedData));
+			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;
+	};
+	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 = 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: (/* @__PURE__ */ new Date(Date.now() - i * 6e4)).toISOString()
+				})),
+				summary: {
+					compression: "brotli",
+					totalTests: 75,
+					encoding: "br"
+				}
+			} }
+		];
+		const data = sampleData[Math.floor(Math.random() * sampleData.length)];
+		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 updatedCompressed = brotliCompressSync(JSON.stringify(updatedData));
+			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;
+	};
+	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);
+};
+//#endregion
+//#region src/routes/response-inspection/cache.ts
+const 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."
+		}
+	}
+};
+const 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."
+	} }
+};
+const cacheRoutes = (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.`);
+	});
+};
+//#endregion
+//#region src/routes/response-inspection/etag.ts
+const 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."
+		}
+	}
+};
+const etagRoutes = (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.");
+	});
+};
+//#endregion
+//#region src/routes/response-inspection/response-headers.ts
+const 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."
+	} }
+};
+const responseHeadersRoutes = (fastify) => {
+	fastify.get("/response-headers", { schema: responseHeadersSchema }, async (request, reply) => {
+		const queryParameters = request.query;
+		for (const [key, value] of Object.entries(queryParameters)) reply.header(key, escape(value));
+		const cleanedResponse = Object.fromEntries(Object.entries(queryParameters).map(([key, value]) => [key, escape(value)]));
+		await reply.send(cleanedResponse);
+	});
+	fastify.post("/response-headers", { schema: responseHeadersSchema }, async (request, reply) => {
+		const queryParameters = request.query ?? {};
+		const body = request.body ?? {};
+		for (const [key, value] of Object.entries(queryParameters)) reply.header(key, escape(value));
+		for (const [key, value] of Object.entries(body)) reply.header(key, escape(value));
+		const cleanedResponse = Object.fromEntries(Object.entries({
+			...queryParameters,
+			...body
+		}).map(([key, value]) => [key, escape(value)]));
+		await reply.send(cleanedResponse);
+	});
+};
+//#endregion
+//#region src/routes/sitemap.ts
+const sitemapRoute = (fastify) => {
+	fastify.get("/sitemap.xml", { schema: { hide: true } }, async (_request, reply) => {
+		try {
+			const host = _request.headers.host ?? "mockhttp.org";
+			const xml = `<?xml version="1.0" encoding="UTF-8"?>
+                            <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+                                <url>
+                                    <loc>${_request.headers["x-forwarded-proto"]?.includes("https") ? "https" : "http"}://${host}/</loc>
+                                    <changefreq>monthly</changefreq>
+                                    <priority>1.0</priority>
+                                </url>
+                        </urlset>`;
+			await reply.type("text/xml").send(xml);
+		} catch (error) {
+			/* v8 ignore next -- @preserve */
+			fastify.log.error(error);
+			/* v8 ignore next -- @preserve */
+			await reply.status(500).send({ error: "Internal Server Error" });
+		}
+	});
+};
+//#endregion
+//#region src/routes/status-codes/index.ts
+const 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"
+	}
+];
+const 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" } }
+	} }
+};
+const statusCodeRoute = (fastify) => {
+	const handler = 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}` });
+	};
+	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);
+};
+const fastifySwaggerConfig = { openapi: {
+	info: {
+		title: "Mock HTTP API",
+		description: `
+A simple HTTP server that can be used to mock HTTP responses for testing purposes. Inspired by [httpbin](https://httpbin.org/) and built using \`nodejs\` and \`fastify\` with the idea of running it via https://mockhttp.org, via docker \`jaredwray/mockhttp\`, or nodejs \`npm install jaredwray/mockhttp\`.
+
+* [GitHub Repository](https://github.com/jaredwray/mockhttp)
+* [Docker Image](https://hub.docker.com/r/jaredwray/mockhttp)
+* [NPM Package](https://www.npmjs.com/package/jaredwray/mockhttp)
+
+# About mockhttp.org 
+
+[mockhttp.org](https://mockhttp.org) is a free service that runs this codebase and allows you to use it for testing purposes. It is a simple way to mock HTTP responses for testing purposes. Ran via [Cloudflare](https://cloudflare.com) and [Google Cloud Run](https://cloud.google.com/run/) across 7 regions globally and can do millions of requests per second.
+`,
+		version: "1.5.1"
+	},
+	consumes: ["application/json"],
+	produces: ["application/json"]
+} };
+const registerSwaggerUi = async (fastify) => {
+	await fastify.register(fastifySwaggerUi, {
+		routePrefix: "/docs",
+		uiConfig: {
+			docExpansion: "none",
+			deepLinking: false
+		},
+		uiHooks: {
+			onRequest(_request, _reply, next) {
+				next();
+			},
+			preHandler(_request, _reply, next) {
+				next();
+			}
+		},
+		staticCSP: true,
+		transformSpecification: (swaggerObject, _request, _reply) => swaggerObject,
+		transformSpecificationClone: true
+	});
+};
+//#endregion
+//#region src/tap-manager.ts
+/**
+* Manages HTTP response injections for testing and mocking
+*/
+var TapManager = class {
+	_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;
+	}
+	/**
+	* 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)) if (request.headers[key.toLowerCase()] !== 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(".*");
+			return new RegExp(`^${regexPattern}$`).test(urlPath);
+		}
+		return false;
+	}
+};
+//#endregion
+//#region src/mock-http.ts
+var MockHttp = class extends Hookified {
+	_port = 3e3;
+	_host = "0.0.0.0";
+	_autoDetectPort = true;
+	_helmet = true;
+	_apiDocs = true;
+	_logging = true;
+	_httpBin = {
+		httpMethods: true,
+		redirects: true,
+		requestInspection: true,
+		responseInspection: true,
+		responseFormats: true,
+		statusCodes: true,
+		cookies: true,
+		anything: true,
+		auth: true,
+		images: true,
+		dynamicData: true
+	};
+	_rateLimit = {
+		max: 1e3,
+		timeWindow: "1 minute",
+		allowList: ["127.0.0.1", "::1"]
+	};
+	_http2 = false;
+	_http1 = true;
+	_https;
+	_httpsCredentials;
+	_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;
+		if (options?.logging !== void 0) this._logging = options.logging;
+		if (options?.http2 !== void 0) this._http2 = options.http2;
+		if (options?.http1 !== void 0) this._http1 = options.http1;
+		if (options?.https !== void 0) if (options.https === true) this._https = { autoGenerate: true };
+		else if (options.https === false) this._https = void 0;
+		else this._https = options.https;
+	}
+	/**
+	* 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;
+	}
+	/**
+	* Whether to enable logging. Defaults to true.
+	* @default true
+	*/
+	get logging() {
+		return this._logging;
+	}
+	/**
+	* Whether to enable logging. Defaults to true.
+	* @default true
+	*/
+	set logging(logging) {
+		this._logging = logging;
+	}
+	/**
+	* HTTPS configuration. Set to true to auto-generate a self-signed certificate,
+	* or provide an HttpsOptions object with cert/key or auto-generation options.
+	*/
+	get https() {
+		return this._https;
+	}
+	/**
+	* HTTPS configuration. Set to true to auto-generate a self-signed certificate,
+	* or provide an HttpsOptions object with cert/key or auto-generation options.
+	*/
+	set https(value) {
+		if (value === true) this._https = { autoGenerate: true };
+		else if (value === false || value === void 0) this._https = void 0;
+		else this._https = value;
+	}
+	/**
+	* Whether the server is running in HTTPS mode.
+	*/
+	get isHttps() {
+		return this._httpsCredentials !== void 0;
+	}
+	/**
+	* Whether HTTP/2 support is enabled.
+	* @default false
+	*/
+	get http2() {
+		return this._http2;
+	}
+	/**
+	* Whether HTTP/2 support is enabled.
+	* @default false
+	*/
+	set http2(http2) {
+		this._http2 = http2;
+	}
+	/**
+	* Whether to allow HTTP/1.1 fallback when using HTTP/2 with HTTPS.
+	* @default true
+	*/
+	get http1() {
+		return this._http1;
+	}
+	/**
+	* Whether to allow HTTP/1.1 fallback when using HTTP/2 with HTTPS.
+	* @default true
+	*/
+	set http1(http1) {
+		this._http1 = http1;
+	}
+	/**
+	* 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() {
+		this._httpsCredentials = void 0;
+		if (this._https) this._httpsCredentials = await this.resolveHttpsCredentials(this._https);
+		try {
+			/* v8 ignore next -- @preserve */
+			if (this._server) await this._server.close();
+			const fastifyOptions = { ...getFastifyConfig(this._logging) };
+			if (this._http2) fastifyOptions.http2 = true;
+			if (this._httpsCredentials) {
+				const httpsOptions = {
+					key: this._httpsCredentials.key,
+					cert: this._httpsCredentials.cert
+				};
+				if (this._http2) httpsOptions.allowHTTP1 = this._http1;
+				fastifyOptions.https = httpsOptions;
+			}
+			this._server = Fastify(fastifyOptions);
+			this._server.addHook("onRequest", async (request, reply) => {
+				const matchedTap = this._taps.matchRequest(request);
+				if (matchedTap) {
+					const { response, statusCode = 200, headers } = typeof matchedTap.response === "function" ? matchedTap.response(request) : matchedTap.response;
+					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, cookies, anything, auth, images, dynamicData } = this._httpBin;
+			if (httpMethods) await this.registerHttpMethods();
+			if (statusCodes) 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 (dynamicData) await this.registerDynamicDataRoutes();
+			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) {
+			/* v8 ignore next -- @preserve */
+			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) {
+		await (fastifyInstance ?? this._server).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) {
+		await (fastifyInstance ?? this._server).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) {
+		await (fastifyInstance ?? this._server).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) {
+		await (fastifyInstance ?? this._server).register(imageRoutes);
+	}
+	/**
+	* Register the dynamic data routes.
+	* @param fastifyInstance - the server instance to register the routes on.
+	*/
+	async registerDynamicDataRoutes(fastifyInstance) {
+		const fastify = fastifyInstance ?? this._server;
+		await fastify.register(uuidRoute);
+		await fastify.register(bytesRoute);
+		await fastify.register(streamBytesRoute);
+		await fastify.register(delayRoute);
+		await fastify.register(base64Route);
+		await fastify.register(streamRoute);
+		await fastify.register(rangeRoute);
+		await fastify.register(dripRoute);
+		await fastify.register(linksRoute);
+	}
+	async resolveHttpsCredentials(options) {
+		if (options.cert && options.key) return {
+			cert: await this.loadPemValue(options.cert),
+			key: await this.loadPemValue(options.key)
+		};
+		if ((options.cert || options.key) && options.autoGenerate !== true) throw new Error("HTTPS options must include both 'cert' and 'key'. Only one was provided.");
+		if (options.autoGenerate !== false) {
+			const result = generateCertificate(options.certificateOptions);
+			return {
+				cert: result.cert,
+				key: result.key
+			};
+		}
+		throw new Error("HTTPS is enabled but no certificate was provided and autoGenerate is false.");
+	}
+	async loadPemValue(value) {
+		if (value.startsWith("-----")) return value;
+		return fsPromises.readFile(value, "utf8");
+	}
+};
+//#endregion
+//#region src/index.ts
+const start = async () => {
+	const mockHttp = new MockHttp();
+	/* v8 ignore next -- @preserve */
+	if (process$1.env.PORT) mockHttp.port = Number.parseInt(process$1.env.PORT, 10);
+	/* v8 ignore next -- @preserve */
+	if (process$1.env.HOST) mockHttp.host = process$1.env.HOST;
+	/* v8 ignore next -- @preserve */
+	if (process$1.env.LOGGING === "false") mockHttp.logging = false;
+	/* v8 ignore next -- @preserve */
+	if (process$1.env.HTTP2 === "true") mockHttp.http2 = true;
+	await mockHttp.start();
+	return mockHttp;
+};
+/* v8 ignore next -- @preserve */
+if (import.meta.url === `file://${process$1.argv[1]}`) await start();
+//#endregion
+export { MockHttp as default, MockHttp as mockhttp, generateCertificate, generateCertificateFiles, start };