dripfeed 0.1.0

package/dist/runner-Dc1JRBps.cjs

@@ -0,0 +1,758 @@
+let node_fs_promises = require("node:fs/promises");
+let c12 = require("c12");
+let zod = require("zod");
+//#region src/core/types.ts
+/** Check if an HTTP status code represents a successful response */
+const isSuccess = (status) => status !== null && status >= 200 && status < 400;
+//#endregion
+//#region src/adapters/reporters/console.ts
+const GREEN = "\x1B[32m";
+const RED = "\x1B[31m";
+const DIM = "\x1B[2m";
+const BOLD = "\x1B[1m";
+const RESET = "\x1B[0m";
+const CYAN = "\x1B[36m";
+const YELLOW = "\x1B[33m";
+const pad = (s, len) => s.padEnd(len);
+const rpad = (s, len) => s.padStart(len);
+const createConsoleReporter = () => {
+	let requestNum = 0;
+	return {
+		onRequest(result, counts) {
+			requestNum++;
+			const ok = isSuccess(result.status);
+			const icon = ok ? `${GREEN}\u2713${RESET}` : `${RED}\u2717${RESET}`;
+			const num = rpad(`#${requestNum}`, 6);
+			const name = pad(result.endpoint, 24);
+			const status = result.status ? ok ? `${GREEN}${result.status}${RESET}` : `${RED}${result.status}${RESET}` : `${RED}ERR${RESET}`;
+			const duration = rpad(`${result.duration_ms}ms`, 8);
+			const total = counts.ok + counts.fail;
+			const pct = total > 0 ? (counts.ok / total * 100).toFixed(1) : "100.0";
+			const summary = `${DIM}ok:${counts.ok} fail:${counts.fail} (${pct}%)${RESET}`;
+			process.stdout.write(`${icon} ${num} ${name} ${status} ${duration} | ${summary}\n`);
+			if (!ok && result.error) process.stdout.write(`  ${DIM}${result.error}${RESET}\n`);
+		},
+		onComplete(stats) {
+			const divider = `${DIM}${"─".repeat(70)}${RESET}`;
+			process.stdout.write(`\n${divider}\n`);
+			process.stdout.write(`${BOLD}Soak Test Summary${RESET}\n`);
+			process.stdout.write(`${divider}\n\n`);
+			process.stdout.write(`  Duration:    ${stats.duration_s}s\n`);
+			process.stdout.write(`  Requests:    ${stats.total_requests}\n`);
+			process.stdout.write(`  Success:     ${GREEN}${stats.success_count}${RESET}  Failures: ${stats.failure_count > 0 ? RED : ""}${stats.failure_count}${RESET}\n`);
+			process.stdout.write(`  Uptime:      ${stats.uptime_pct}%\n\n`);
+			process.stdout.write(`  ${CYAN}Latency${RESET}\n`);
+			process.stdout.write(`  min: ${stats.latency.min}ms  avg: ${stats.latency.avg}ms  `);
+			process.stdout.write(`p50: ${stats.latency.p50}ms  p95: ${stats.latency.p95}ms  `);
+			process.stdout.write(`p99: ${stats.latency.p99}ms  max: ${stats.latency.max}ms\n\n`);
+			if (stats.endpoints.length > 0) {
+				process.stdout.write(`  ${CYAN}Endpoints${RESET}\n`);
+				for (const ep of stats.endpoints) {
+					const errPart = ep.error_count > 0 ? `  ${RED}${ep.error_count} errors${RESET}` : "";
+					process.stdout.write(`  ${pad(ep.name, 24)} ${rpad(String(ep.requests), 5)} reqs  avg: ${rpad(String(ep.avg_ms), 5)}ms  p95: ${rpad(String(ep.p95_ms), 5)}ms${errPart}\n`);
+				}
+				process.stdout.write("\n");
+			}
+			if (stats.errors.length > 0) {
+				process.stdout.write(`  ${RED}Errors${RESET}\n`);
+				for (const err of stats.errors.slice(0, 10)) {
+					const status = err.status ?? "NET";
+					process.stdout.write(`  ${pad(err.endpoint, 24)} ${YELLOW}${status}${RESET} x${err.count}\n`);
+				}
+				process.stdout.write("\n");
+			}
+			if (stats.thresholds) {
+				process.stdout.write(`  ${CYAN}Thresholds${RESET}\n`);
+				for (const t of stats.thresholds) {
+					const icon = t.passed ? `${GREEN}\u2713${RESET}` : `${RED}\u2717${RESET}`;
+					process.stdout.write(`  ${icon} ${pad(t.name, 12)} target: ${pad(t.target, 12)} actual: ${t.actual}\n`);
+				}
+				if (!stats.thresholds.every((t) => t.passed)) process.stdout.write(`\n  ${RED}${BOLD}THRESHOLDS FAILED${RESET}\n`);
+				process.stdout.write("\n");
+			}
+		}
+	};
+};
+//#endregion
+//#region src/adapters/reporters/json.ts
+const createJsonReporter = (outputPath) => ({
+	onRequest() {},
+	onComplete(stats) {
+		const json = JSON.stringify(stats, null, 2);
+		if (outputPath) (0, node_fs_promises.writeFile)(outputPath, json).catch((err) => {
+			process.stderr.write(`[dripfeed] Failed to write report to ${outputPath}: ${err.message}\n`);
+		});
+		else process.stdout.write(`${json}\n`);
+	}
+});
+//#endregion
+//#region src/adapters/reporters/markdown.ts
+const generateMarkdown = (stats) => {
+	const lines = [
+		"# Soak Test Report",
+		"",
+		"## Summary",
+		"",
+		`| Metric | Value |`,
+		`|--------|-------|`,
+		`| Duration | ${stats.duration_s}s |`,
+		`| Total Requests | ${stats.total_requests} |`,
+		`| Success | ${stats.success_count} |`,
+		`| Failures | ${stats.failure_count} |`,
+		`| Uptime | ${stats.uptime_pct}% |`,
+		"",
+		"## Latency",
+		"",
+		"| Metric | Value |",
+		"|--------|-------|",
+		`| Min | ${stats.latency.min}ms |`,
+		`| Avg | ${stats.latency.avg}ms |`,
+		`| P50 | ${stats.latency.p50}ms |`,
+		`| P95 | ${stats.latency.p95}ms |`,
+		`| P99 | ${stats.latency.p99}ms |`,
+		`| Max | ${stats.latency.max}ms |`,
+		""
+	];
+	if (stats.endpoints.length > 0) {
+		lines.push("## Endpoints", "", "| Endpoint | Requests | Avg | P95 | Errors |", "|----------|----------|-----|-----|--------|");
+		for (const ep of stats.endpoints) lines.push(`| ${ep.name} | ${ep.requests} | ${ep.avg_ms}ms | ${ep.p95_ms}ms | ${ep.error_count} |`);
+		lines.push("");
+	}
+	if (stats.errors.length > 0) {
+		lines.push("## Errors", "", "| Endpoint | Status | Count |", "|----------|--------|-------|");
+		for (const err of stats.errors) lines.push(`| ${err.endpoint} | ${err.status ?? "Network"} | ${err.count} |`);
+		lines.push("");
+	}
+	if (stats.thresholds) {
+		lines.push("## Thresholds", "", "| Check | Target | Actual | Result |", "|-------|--------|--------|--------|");
+		for (const t of stats.thresholds) {
+			const icon = t.passed ? "PASS" : "FAIL";
+			lines.push(`| ${t.name} | ${t.target} | ${t.actual} | ${icon} |`);
+		}
+		lines.push("");
+	}
+	return lines.join("\n");
+};
+const createMarkdownReporter = (outputPath) => ({
+	onRequest() {},
+	onComplete(stats) {
+		const md = generateMarkdown(stats);
+		if (outputPath) (0, node_fs_promises.writeFile)(outputPath, md).catch((err) => {
+			process.stderr.write(`[dripfeed] Failed to write report to ${outputPath}: ${err.message}\n`);
+		});
+		else process.stdout.write(`${md}\n`);
+	}
+});
+//#endregion
+//#region src/adapters/storage/json.ts
+const FLUSH_INTERVAL = 10;
+const createJsonStorage = (filePath) => {
+	let buffer = [];
+	let flushed = [];
+	const flush = async () => {
+		if (buffer.length === 0) return;
+		flushed = [...flushed, ...buffer];
+		buffer = [];
+		await (0, node_fs_promises.writeFile)(filePath, JSON.stringify(flushed, null, 2));
+	};
+	return {
+		init: async () => {
+			try {
+				const data = await (0, node_fs_promises.readFile)(filePath, "utf-8");
+				flushed = JSON.parse(data);
+			} catch {
+				flushed = [];
+			}
+		},
+		record: async (result) => {
+			buffer.push(result);
+			if (buffer.length >= FLUSH_INTERVAL) await flush();
+		},
+		getAll: async () => [...flushed, ...buffer],
+		close: async () => {
+			await flush();
+		}
+	};
+};
+//#endregion
+//#region src/adapters/storage/memory.ts
+const createMemoryStorage = () => {
+	const results = [];
+	return {
+		init: async () => {},
+		record: async (result) => {
+			results.push(result);
+		},
+		getAll: async () => [...results],
+		close: async () => {}
+	};
+};
+//#endregion
+//#region src/utils/runtime.ts
+const isBun = typeof globalThis !== "undefined" && "Bun" in globalThis;
+const isDeno = typeof globalThis !== "undefined" && "Deno" in globalThis;
+const isNode = !isBun && !isDeno;
+//#endregion
+//#region src/adapters/storage/sqlite.ts
+const CREATE_TABLE = `
+CREATE TABLE IF NOT EXISTS results (
+	id INTEGER PRIMARY KEY AUTOINCREMENT,
+	timestamp TEXT NOT NULL,
+	endpoint TEXT NOT NULL,
+	method TEXT NOT NULL,
+	url TEXT NOT NULL,
+	status INTEGER,
+	duration_ms REAL NOT NULL,
+	response_body TEXT,
+	error TEXT
+)`;
+const INSERT = `
+INSERT INTO results (timestamp, endpoint, method, url, status, duration_ms, response_body, error)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?)`;
+const openBunSqlite = async (path) => {
+	const { Database } = await import("bun:sqlite");
+	const db = new Database(path);
+	db.exec("PRAGMA journal_mode = WAL");
+	return {
+		exec: (sql) => db.exec(sql),
+		prepare: (sql) => {
+			const stmt = db.prepare(sql);
+			return {
+				run: (...params) => stmt.run(...params),
+				all: (...params) => stmt.all(...params)
+			};
+		},
+		close: () => db.close()
+	};
+};
+const openBetterSqlite = async (path) => {
+	let mod;
+	try {
+		mod = await import("better-sqlite3");
+	} catch {
+		throw new Error("SQLite storage requires \"better-sqlite3\" on Node.js. Install it:\n  npm install better-sqlite3\nOr use storage: \"json\" in your dripfeed config.");
+	}
+	const db = mod.default(path);
+	db.exec("PRAGMA journal_mode = WAL");
+	return {
+		exec: (sql) => db.exec(sql),
+		prepare: (sql) => {
+			const stmt = db.prepare(sql);
+			return {
+				run: (...params) => stmt.run(...params),
+				all: (...params) => stmt.all(...params)
+			};
+		},
+		close: () => db.close()
+	};
+};
+const createSqliteStorage = (dbPath) => {
+	let db = null;
+	let insertStmt = null;
+	return {
+		init: async () => {
+			db = isBun ? await openBunSqlite(dbPath) : await openBetterSqlite(dbPath);
+			db.exec(CREATE_TABLE);
+			insertStmt = db.prepare(INSERT);
+		},
+		record: async (result) => {
+			insertStmt?.run(result.timestamp, result.endpoint, result.method, result.url, result.status, result.duration_ms, result.response_body, result.error);
+		},
+		getAll: async () => {
+			return (db?.prepare("SELECT * FROM results ORDER BY id").all() ?? []).map((row) => ({
+				timestamp: row.timestamp,
+				endpoint: row.endpoint,
+				method: row.method,
+				url: row.url,
+				status: row.status,
+				duration_ms: row.duration_ms,
+				response_body: row.response_body,
+				error: row.error
+			}));
+		},
+		close: async () => {
+			db?.close();
+		}
+	};
+};
+//#endregion
+//#region src/adapters/storage/index.ts
+const createStorage = (config) => {
+	switch (config.storage ?? "sqlite") {
+		case "memory": return createMemoryStorage();
+		case "json": return createJsonStorage(config.db ?? "dripfeed-results.json");
+		case "sqlite": return createSqliteStorage(config.db ?? "dripfeed-results.db");
+	}
+};
+//#endregion
+//#region src/core/config.ts
+const endpointSchema = zod.z.object({
+	name: zod.z.string(),
+	url: zod.z.string().url(),
+	method: zod.z.string().default("GET"),
+	headers: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+	body: zod.z.unknown().optional(),
+	timeout: zod.z.string().optional(),
+	weight: zod.z.number().positive().default(1)
+});
+const thresholdSchema = zod.z.object({
+	error_rate: zod.z.string().optional(),
+	p50: zod.z.string().optional(),
+	p95: zod.z.string().optional(),
+	p99: zod.z.string().optional(),
+	max: zod.z.string().optional()
+});
+const configSchema = zod.z.object({
+	interval: zod.z.string().default("3s"),
+	duration: zod.z.string().optional(),
+	timeout: zod.z.string().default("30s"),
+	storage: zod.z.enum([
+		"sqlite",
+		"json",
+		"memory"
+	]).default("sqlite"),
+	db: zod.z.string().optional(),
+	rotation: zod.z.enum([
+		"weighted-random",
+		"round-robin",
+		"sequential"
+	]).default("weighted-random"),
+	headers: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+	endpoints: zod.z.array(endpointSchema).min(1, "At least one endpoint is required"),
+	thresholds: thresholdSchema.optional()
+});
+/** Parse and validate a raw config object into a fully-typed ParsedConfig with defaults applied.
+*  Use this when creating a soak test programmatically without a config file. */
+const parseConfig = (raw) => configSchema.parse(raw);
+const interpolateEnv = (value) => {
+	if (typeof value === "string") return value.replace(/\$\{(\w+)\}/g, (_, key) => {
+		const val = process.env[key];
+		if (val === void 0) process.stderr.write(`[dripfeed] Warning: environment variable "${key}" is not set\n`);
+		return val ?? "";
+	});
+	if (Array.isArray(value)) return value.map(interpolateEnv);
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, interpolateEnv(v)]));
+	return value;
+};
+const loadDripfeedConfig = async (overrides) => {
+	const { config } = await (0, c12.loadConfig)({ name: "dripfeed" });
+	const interpolated = interpolateEnv({
+		...config,
+		...overrides
+	});
+	return configSchema.parse(interpolated);
+};
+//#endregion
+//#region src/utils/duration.ts
+const UNITS = {
+	ms: 1,
+	s: 1e3,
+	m: 6e4,
+	h: 36e5,
+	d: 864e5
+};
+const DURATION_RE = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/;
+const parseDuration = (input) => {
+	const match = input.trim().match(DURATION_RE);
+	if (!match) throw new Error(`Invalid duration: "${input}". Expected format: "3s", "10m", "2h"`);
+	const value = Number.parseFloat(match[1] ?? "0");
+	const unit = UNITS[match[2] ?? "ms"] ?? 1;
+	return Math.round(value * unit);
+};
+//#endregion
+//#region src/utils/http.ts
+const timedFetch = async (endpoint, globalHeaders, timeout = "30s") => {
+	const timeoutMs = parseDuration(endpoint.timeout ?? timeout);
+	const headers = {
+		...globalHeaders,
+		...endpoint.headers
+	};
+	const method = endpoint.method ?? "GET";
+	const url = endpoint.url;
+	const start = performance.now();
+	try {
+		const response = await fetch(url, {
+			method,
+			headers,
+			body: endpoint.body ? JSON.stringify(endpoint.body) : void 0,
+			signal: AbortSignal.timeout(timeoutMs),
+			redirect: "follow"
+		});
+		const durationMs = Math.round(performance.now() - start);
+		const body = response.status >= 400 ? await response.text().catch(() => null) : null;
+		return {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			endpoint: endpoint.name,
+			method,
+			url,
+			status: response.status,
+			duration_ms: durationMs,
+			response_body: body,
+			error: null
+		};
+	} catch (err) {
+		const durationMs = Math.round(performance.now() - start);
+		const message = err instanceof Error ? err.message : String(err);
+		return {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			endpoint: endpoint.name,
+			method,
+			url,
+			status: null,
+			duration_ms: durationMs,
+			response_body: null,
+			error: message
+		};
+	}
+};
+//#endregion
+//#region src/utils/stats.ts
+const percentile = (sorted, p) => {
+	if (sorted.length === 0) return 0;
+	const idx = p / 100 * (sorted.length - 1);
+	const lower = Math.floor(idx);
+	const upper = Math.ceil(idx);
+	const lowerVal = sorted[lower] ?? 0;
+	const upperVal = sorted[upper] ?? 0;
+	if (lower === upper) return lowerVal;
+	return lowerVal + (upperVal - lowerVal) * (idx - lower);
+};
+const computeLatency = (durations) => {
+	if (durations.length === 0) return {
+		min: 0,
+		avg: 0,
+		p50: 0,
+		p95: 0,
+		p99: 0,
+		max: 0
+	};
+	const sorted = [...durations].sort((a, b) => a - b);
+	const sum = sorted.reduce((a, b) => a + b, 0);
+	return {
+		min: sorted[0] ?? 0,
+		avg: Math.round(sum / sorted.length),
+		p50: Math.round(percentile(sorted, 50)),
+		p95: Math.round(percentile(sorted, 95)),
+		p99: Math.round(percentile(sorted, 99)),
+		max: sorted.at(-1) ?? 0
+	};
+};
+const computeEndpointStats = (results) => {
+	const byEndpoint = /* @__PURE__ */ new Map();
+	for (const r of results) {
+		const list = byEndpoint.get(r.endpoint) ?? [];
+		list.push(r);
+		byEndpoint.set(r.endpoint, list);
+	}
+	return [...byEndpoint.entries()].map(([name, items]) => {
+		const durations = items.map((r) => r.duration_ms);
+		const sorted = [...durations].sort((a, b) => a - b);
+		const sum = durations.reduce((a, b) => a + b, 0);
+		return {
+			name,
+			requests: items.length,
+			avg_ms: Math.round(sum / items.length),
+			p95_ms: Math.round(percentile(sorted, 95)),
+			error_count: items.filter((r) => !isSuccess(r.status)).length
+		};
+	});
+};
+const computeErrors = (results) => {
+	const key = (r) => `${r.endpoint}:${r.status}`;
+	const groups = /* @__PURE__ */ new Map();
+	for (const r of results) {
+		if (isSuccess(r.status)) continue;
+		const k = key(r);
+		const existing = groups.get(k);
+		if (existing) existing.count++;
+		else groups.set(k, {
+			endpoint: r.endpoint,
+			status: r.status,
+			count: 1,
+			sample_body: r.response_body
+		});
+	}
+	return [...groups.values()].sort((a, b) => b.count - a.count);
+};
+const parseThresholdValue = (s) => {
+	const cleaned = s.replace(/[<>=%\s]/g, "");
+	if (cleaned.endsWith("ms")) return Number.parseFloat(cleaned);
+	if (cleaned.endsWith("s")) return Number.parseFloat(cleaned) * 1e3;
+	return Number.parseFloat(cleaned);
+};
+const evaluateThresholds = (thresholds, latency, errorRate) => {
+	const results = [];
+	if (thresholds.error_rate) {
+		const target = parseThresholdValue(thresholds.error_rate);
+		results.push({
+			name: "error_rate",
+			target: thresholds.error_rate,
+			actual: `${errorRate.toFixed(2)}%`,
+			passed: errorRate < target
+		});
+	}
+	for (const [configKey, statKey] of [
+		["p50", "p50"],
+		["p95", "p95"],
+		["p99", "p99"],
+		["max", "max"]
+	]) {
+		const threshold = thresholds[configKey];
+		if (!threshold) continue;
+		const targetMs = parseDuration(threshold.replace(/[<>\s]/g, ""));
+		results.push({
+			name: configKey,
+			target: threshold,
+			actual: `${latency[statKey]}ms`,
+			passed: latency[statKey] < targetMs
+		});
+	}
+	return results;
+};
+const computeStats = (results, startTime, thresholds, endTime) => {
+	const durationS = Math.round(((endTime ?? /* @__PURE__ */ new Date()).getTime() - startTime.getTime()) / 1e3);
+	const latency = computeLatency(results.map((r) => r.duration_ms));
+	const successCount = results.filter((r) => isSuccess(r.status)).length;
+	const failureCount = results.length - successCount;
+	const uptimePct = results.length > 0 ? successCount / results.length * 100 : 100;
+	const statusCodes = {};
+	for (const r of results) if (r.status !== null) statusCodes[r.status] = (statusCodes[r.status] ?? 0) + 1;
+	const errorRate = results.length > 0 ? failureCount / results.length * 100 : 0;
+	return {
+		duration_s: durationS,
+		total_requests: results.length,
+		success_count: successCount,
+		failure_count: failureCount,
+		uptime_pct: Math.round(uptimePct * 100) / 100,
+		latency,
+		status_codes: statusCodes,
+		endpoints: computeEndpointStats(results),
+		errors: computeErrors(results),
+		thresholds: thresholds ? evaluateThresholds(thresholds, latency, errorRate) : void 0
+	};
+};
+//#endregion
+//#region src/core/runner.ts
+const createWeightedRandom = () => {
+	return (endpoints) => {
+		const totalWeight = endpoints.reduce((sum, ep) => sum + (ep.weight ?? 1), 0);
+		let rand = Math.random() * totalWeight;
+		for (const ep of endpoints) {
+			rand -= ep.weight ?? 1;
+			if (rand <= 0) return ep;
+		}
+		return endpoints[endpoints.length - 1];
+	};
+};
+const createRoundRobin = () => {
+	let idx = -1;
+	return (endpoints) => {
+		idx = (idx + 1) % endpoints.length;
+		return endpoints[idx];
+	};
+};
+const createPicker = (rotation) => {
+	switch (rotation) {
+		case "round-robin":
+		case "sequential": return createRoundRobin();
+		default: return createWeightedRandom();
+	}
+};
+const toEndpoints = (config) => config.endpoints.map((ep) => ({
+	name: ep.name,
+	url: ep.url,
+	method: ep.method,
+	headers: ep.headers,
+	body: ep.body,
+	timeout: ep.timeout,
+	weight: ep.weight
+}));
+const createSoakTest = (config, reporters = []) => {
+	const storage = createStorage(config);
+	const endpoints = toEndpoints(config);
+	const globalHeaders = config.headers;
+	const pick = createPicker(config.rotation);
+	const intervalMs = Math.max(100, parseDuration(config.interval));
+	let timer = null;
+	let startTime = null;
+	let okCount = 0;
+	let failCount = 0;
+	let running = false;
+	const tick = async () => {
+		if (!running) return;
+		const result = await timedFetch(pick(endpoints), globalHeaders, config.timeout);
+		if (!running) return;
+		await storage.record(result);
+		isSuccess(result.status) ? okCount++ : failCount++;
+		for (const reporter of reporters) reporter.onRequest(result, {
+			ok: okCount,
+			fail: failCount
+		});
+	};
+	const getStats = async () => {
+		return computeStats(await storage.getAll(), startTime ?? /* @__PURE__ */ new Date(), config.thresholds);
+	};
+	const safeTick = () => {
+		tick().catch((err) => {
+			process.stderr.write(`[dripfeed] tick error: ${err instanceof Error ? err.message : err}\n`);
+		});
+	};
+	const start = async () => {
+		if (running) return;
+		running = true;
+		await storage.init();
+		startTime = /* @__PURE__ */ new Date();
+		safeTick();
+		timer = setInterval(safeTick, intervalMs);
+	};
+	const stop = async () => {
+		running = false;
+		if (timer) {
+			clearInterval(timer);
+			timer = null;
+		}
+		const stats = await getStats();
+		for (const reporter of reporters) reporter.onComplete(stats);
+		await storage.close();
+		return stats;
+	};
+	const run = async (opts) => {
+		const durationStr = opts?.duration ?? config.duration;
+		await start();
+		if (durationStr) {
+			const durationMs = parseDuration(durationStr);
+			await new Promise((resolve) => {
+				setTimeout(() => resolve(), durationMs);
+			});
+		} else await new Promise((resolve) => {
+			const handler = () => {
+				process.removeListener("SIGINT", handler);
+				process.removeListener("SIGTERM", handler);
+				resolve();
+			};
+			process.on("SIGINT", handler);
+			process.on("SIGTERM", handler);
+		});
+		return stop();
+	};
+	return {
+		start,
+		stop,
+		run
+	};
+};
+//#endregion
+Object.defineProperty(exports, "computeStats", {
+	enumerable: true,
+	get: function() {
+		return computeStats;
+	}
+});
+Object.defineProperty(exports, "configSchema", {
+	enumerable: true,
+	get: function() {
+		return configSchema;
+	}
+});
+Object.defineProperty(exports, "createConsoleReporter", {
+	enumerable: true,
+	get: function() {
+		return createConsoleReporter;
+	}
+});
+Object.defineProperty(exports, "createJsonReporter", {
+	enumerable: true,
+	get: function() {
+		return createJsonReporter;
+	}
+});
+Object.defineProperty(exports, "createJsonStorage", {
+	enumerable: true,
+	get: function() {
+		return createJsonStorage;
+	}
+});
+Object.defineProperty(exports, "createMarkdownReporter", {
+	enumerable: true,
+	get: function() {
+		return createMarkdownReporter;
+	}
+});
+Object.defineProperty(exports, "createMemoryStorage", {
+	enumerable: true,
+	get: function() {
+		return createMemoryStorage;
+	}
+});
+Object.defineProperty(exports, "createSoakTest", {
+	enumerable: true,
+	get: function() {
+		return createSoakTest;
+	}
+});
+Object.defineProperty(exports, "createSqliteStorage", {
+	enumerable: true,
+	get: function() {
+		return createSqliteStorage;
+	}
+});
+Object.defineProperty(exports, "createStorage", {
+	enumerable: true,
+	get: function() {
+		return createStorage;
+	}
+});
+Object.defineProperty(exports, "isBun", {
+	enumerable: true,
+	get: function() {
+		return isBun;
+	}
+});
+Object.defineProperty(exports, "isDeno", {
+	enumerable: true,
+	get: function() {
+		return isDeno;
+	}
+});
+Object.defineProperty(exports, "isNode", {
+	enumerable: true,
+	get: function() {
+		return isNode;
+	}
+});
+Object.defineProperty(exports, "isSuccess", {
+	enumerable: true,
+	get: function() {
+		return isSuccess;
+	}
+});
+Object.defineProperty(exports, "loadDripfeedConfig", {
+	enumerable: true,
+	get: function() {
+		return loadDripfeedConfig;
+	}
+});
+Object.defineProperty(exports, "parseConfig", {
+	enumerable: true,
+	get: function() {
+		return parseConfig;
+	}
+});
+Object.defineProperty(exports, "parseDuration", {
+	enumerable: true,
+	get: function() {
+		return parseDuration;
+	}
+});
+Object.defineProperty(exports, "percentile", {
+	enumerable: true,
+	get: function() {
+		return percentile;
+	}
+});
+Object.defineProperty(exports, "timedFetch", {
+	enumerable: true,
+	get: function() {
+		return timedFetch;
+	}
+});