@fedify/cli 2.3.0-dev.1219 → 2.3.0-dev.1273

package/dist/bench/load/generator.js

@@ -0,0 +1,112 @@
+import "@js-temporal/polyfill";
+import { scheduleArrivals } from "./arrival.js";
+import { systemClock } from "./clock.js";
+//#region src/bench/load/generator.ts
+/**
+* Runs a load plan against a send function.
+* @param plan The load plan.
+* @param send The function that performs one send.
+* @param clock The clock (overridable for tests); defaults to the system clock.
+* @returns The recorded samples and run metadata.
+*/
+function runLoad(plan, send, clock = systemClock()) {
+	return plan.load.kind === "open" ? runOpenLoop(plan, plan.load, send, clock) : runClosedLoop(plan, plan.load, send, clock);
+}
+async function runOpenLoop(plan, load, send, clock) {
+	const arrivals = scheduleArrivals({
+		ratePerSec: load.ratePerSec,
+		durationMs: plan.durationMs,
+		arrival: load.arrival,
+		rng: plan.rng
+	});
+	const samples = [];
+	const slots = createSemaphore(load.maxInFlight);
+	let saturated = false;
+	const start = clock.now();
+	const active = /* @__PURE__ */ new Set();
+	for (const offset of arrivals) {
+		await clock.sleepUntil(start + offset);
+		if (await slots.acquire()) saturated = true;
+		const dispatched = dispatch(send, offset, start, plan.warmupMs, clock, samples).finally(() => {
+			slots.release();
+			active.delete(dispatched);
+		});
+		active.add(dispatched);
+	}
+	await Promise.all(active);
+	return {
+		samples,
+		saturated,
+		wallDurationMs: clock.now() - start
+	};
+}
+async function runClosedLoop(plan, load, send, clock) {
+	const samples = [];
+	const slots = createSemaphore(load.maxInFlight);
+	let saturated = false;
+	const start = clock.now();
+	const deadline = start + plan.durationMs;
+	async function worker() {
+		while (clock.now() < deadline) {
+			if (await slots.acquire()) saturated = true;
+			if (clock.now() >= deadline) {
+				slots.release();
+				break;
+			}
+			const offset = clock.now() - start;
+			try {
+				await dispatch(send, offset, start, plan.warmupMs, clock, samples);
+			} finally {
+				slots.release();
+			}
+		}
+	}
+	await Promise.all(Array.from({ length: load.concurrency }, () => worker()));
+	return {
+		samples,
+		saturated,
+		wallDurationMs: clock.now() - start
+	};
+}
+async function dispatch(send, offset, start, warmupMs, clock, samples) {
+	let outcome;
+	try {
+		outcome = await send(offset);
+	} catch (error) {
+		outcome = {
+			ok: false,
+			errorKind: "exception",
+			reason: String(error)
+		};
+	}
+	samples.push({
+		scheduledAtMs: offset,
+		latencyMs: clock.now() - (start + offset),
+		warmup: offset < warmupMs,
+		outcome
+	});
+}
+function createSemaphore(max) {
+	if (max == null) return {
+		acquire: () => Promise.resolve(false),
+		release: () => {}
+	};
+	let count = 0;
+	const queue = [];
+	return {
+		acquire() {
+			if (count < max) {
+				count++;
+				return Promise.resolve(false);
+			}
+			return new Promise((resolve) => queue.push(() => resolve(true)));
+		},
+		release() {
+			const next = queue.shift();
+			if (next != null) next();
+			else count--;
+		}
+	};
+}
+//#endregion
+export { runLoad };

package/dist/bench/metrics/aggregate.js

@@ -0,0 +1,64 @@
+import "@js-temporal/polyfill";
+import { LogLinearHistogram } from "./histogram.js";
+//#region src/bench/metrics/aggregate.ts
+/**
+* Aggregates samples into the client side of a scenario measurement (the
+* `server` field is left `null` for the runner to fill from the stats endpoint).
+* @param samples The raw samples from the load generator.
+* @param options Aggregation options.
+* @returns The client-side scenario measurement.
+*/
+function aggregateSamples(samples, options) {
+	const measured = samples.filter((s) => !s.warmup);
+	const histogram = new LogLinearHistogram();
+	const errorCounts = /* @__PURE__ */ new Map();
+	let ok = 0;
+	for (const sample of measured) {
+		histogram.record(sample.latencyMs);
+		if (sample.outcome.ok) ok++;
+		else bucketError(errorCounts, sample);
+	}
+	const total = measured.length;
+	const requests = {
+		total,
+		ok,
+		failed: total - ok,
+		successRate: total === 0 ? 1 : ok / total
+	};
+	const windowSec = Math.max(options.measuredWindowMs, 1) / 1e3;
+	const client = { latencyMs: {
+		p50: histogram.percentile(50),
+		p95: histogram.percentile(95),
+		p99: histogram.percentile(99),
+		mean: histogram.mean,
+		max: histogram.max
+	} };
+	const errors = [...errorCounts.values()].sort((a, b) => b.count - a.count);
+	return {
+		requests,
+		throughputPerSec: total / windowSec,
+		client,
+		server: null,
+		errors,
+		...options.includeHistogram ? { histogram: histogram.toJSON() } : {}
+	};
+}
+function bucketError(buckets, sample) {
+	const { status, errorKind, reason } = sample.outcome;
+	const kind = errorKind ?? (status != null ? "http" : "error");
+	const reasonText = reason ?? (status != null ? `status_${status}` : "error");
+	const key = `${kind}|${status ?? ""}|${reasonText}`;
+	const existing = buckets.get(key);
+	if (existing != null) buckets.set(key, {
+		...existing,
+		count: existing.count + 1
+	});
+	else buckets.set(key, {
+		kind,
+		...status != null ? { status } : {},
+		reason: reasonText,
+		count: 1
+	});
+}
+//#endregion
+export { aggregateSamples };

package/dist/bench/metrics/histogram.js

@@ -0,0 +1,141 @@
+import "@js-temporal/polyfill";
+/**
+* A sparse log-linear histogram.
+* @since 2.3.0
+*/
+var LogLinearHistogram = class LogLinearHistogram {
+	subBucketCount;
+	#buckets = /* @__PURE__ */ new Map();
+	#count = 0;
+	#zeroCount = 0;
+	#sum = 0;
+	#min = Number.POSITIVE_INFINITY;
+	#max = Number.NEGATIVE_INFINITY;
+	constructor(options = {}) {
+		const subBucketCount = options.subBucketCount ?? 128;
+		if (!Number.isInteger(subBucketCount) || subBucketCount < 1) throw new RangeError(`subBucketCount must be a positive integer; got ${subBucketCount}.`);
+		this.subBucketCount = subBucketCount;
+	}
+	/** The total number of recorded samples, including zeros. */
+	get count() {
+		return this.#count;
+	}
+	/** The smallest recorded value, or `0` when the histogram is empty. */
+	get min() {
+		return this.#count === 0 ? 0 : this.#min;
+	}
+	/** The largest recorded value, or `0` when the histogram is empty. */
+	get max() {
+		return this.#count === 0 ? 0 : this.#max;
+	}
+	/** The arithmetic mean of all recorded values, or `0` when empty. */
+	get mean() {
+		return this.#count === 0 ? 0 : this.#sum / this.#count;
+	}
+	/** The exact sum of all recorded values. */
+	get sum() {
+		return this.#sum;
+	}
+	/**
+	* Records a single sample.
+	* @param value The value to record.  Non-finite values are ignored; any
+	*              non-positive value (negatives, `0`, and `-0`) is normalized to
+	*              `0` and recorded in the zero bucket, since latency samples are
+	*              never negative.
+	*/
+	record(value) {
+		if (!Number.isFinite(value)) return;
+		const v = value <= 0 ? 0 : value;
+		this.#count++;
+		this.#sum += v;
+		if (v < this.#min) this.#min = v;
+		if (v > this.#max) this.#max = v;
+		if (v === 0) {
+			this.#zeroCount++;
+			return;
+		}
+		const index = this.#indexOf(v);
+		this.#buckets.set(index, (this.#buckets.get(index) ?? 0) + 1);
+	}
+	/**
+	* Computes an estimated percentile.
+	* @param p The percentile to compute, between 0 and 100 inclusive.
+	* @returns The estimated value at the given percentile, or `0` when the
+	*          histogram is empty.
+	*/
+	percentile(p) {
+		if (this.#count === 0) return 0;
+		if (p <= 0) return this.#min;
+		if (p >= 100) return this.#max;
+		const target = Math.ceil(p / 100 * this.#count);
+		let accumulated = this.#zeroCount;
+		if (accumulated >= target) return 0;
+		const indices = [...this.#buckets.keys()].sort((a, b) => a - b);
+		for (const index of indices) {
+			accumulated += this.#buckets.get(index);
+			if (accumulated >= target) return this.#clamp(this.#representativeValue(index));
+		}
+		return this.#max;
+	}
+	/**
+	* Merges another histogram into this one.  Both histograms must use the same
+	* {@link LogLinearHistogram.subBucketCount}.
+	* @param other The histogram to merge in.
+	*/
+	merge(other) {
+		if (other.subBucketCount !== this.subBucketCount) throw new TypeError(`Cannot merge histograms with different subBucketCount (${this.subBucketCount} vs ${other.subBucketCount}).`);
+		if (other.#count === 0) return;
+		for (const [index, count] of other.#buckets) this.#buckets.set(index, (this.#buckets.get(index) ?? 0) + count);
+		this.#count += other.#count;
+		this.#zeroCount += other.#zeroCount;
+		this.#sum += other.#sum;
+		if (other.#min < this.#min) this.#min = other.#min;
+		if (other.#max > this.#max) this.#max = other.#max;
+	}
+	/** Serializes the histogram to a plain JSON-compatible object. */
+	toJSON() {
+		const indices = [...this.#buckets.keys()].sort((a, b) => a - b);
+		return {
+			version: 1,
+			subBucketCount: this.subBucketCount,
+			count: this.#count,
+			zeroCount: this.#zeroCount,
+			min: this.min,
+			max: this.max,
+			sum: this.#sum,
+			indices,
+			counts: indices.map((index) => this.#buckets.get(index))
+		};
+	}
+	/** Reconstructs a histogram from its serialized form. */
+	static fromJSON(json) {
+		if (json.indices.length !== json.counts.length) throw new TypeError("Serialized histogram indices and counts must have equal length.");
+		const histogram = new LogLinearHistogram({ subBucketCount: json.subBucketCount });
+		for (let i = 0; i < json.indices.length; i++) histogram.#buckets.set(json.indices[i], json.counts[i]);
+		histogram.#count = json.count;
+		histogram.#zeroCount = json.zeroCount;
+		histogram.#sum = json.sum;
+		histogram.#min = json.count === 0 ? Number.POSITIVE_INFINITY : json.min;
+		histogram.#max = json.count === 0 ? Number.NEGATIVE_INFINITY : json.max;
+		return histogram;
+	}
+	#indexOf(value) {
+		const octave = Math.floor(Math.log2(value));
+		let sub = Math.floor((value / 2 ** octave - 1) * this.subBucketCount);
+		if (sub < 0) sub = 0;
+		else if (sub >= this.subBucketCount) sub = this.subBucketCount - 1;
+		return octave * this.subBucketCount + sub;
+	}
+	#representativeValue(index) {
+		const octave = Math.floor(index / this.subBucketCount);
+		const sub = index - octave * this.subBucketCount;
+		return 2 ** octave * (1 + (sub + .5) / this.subBucketCount);
+	}
+	#clamp(value) {
+		if (value < this.#min) return this.#min;
+		if (value > this.#max) return this.#max;
+		return value;
+	}
+};
+//#endregion
+export { LogLinearHistogram };

package/dist/bench/metrics/stats-client.js

@@ -0,0 +1,154 @@
+import "@js-temporal/polyfill";
+import { STATS_PATH } from "../discovery/probe.js";
+//#region src/bench/metrics/stats-client.ts
+/**
+* Reading server-side metrics from the cooperative `stats` endpoint.
+*
+* The endpoint returns a JSON projection of the target's OpenTelemetry meters
+* (see *@fedify/fedify*'s benchmark module).  This module projects the relevant
+* instruments — signature verification latency and queue depth — into the
+* report's `server` section, marked distinct from client-measured numbers.
+*
+* The server reader is cumulative and has no reset, so a single snapshot covers
+* the target's whole lifetime.  To scope server numbers to one scenario's
+* measured window, callers take a {@link ServerSnapshot} baseline at the window
+* start and another at the end, {@link diffSnapshots} the two, and project the
+* difference with {@link snapshotToMetrics}.
+* @since 2.3.0
+* @module
+*/
+/**
+* Parses a `stats` snapshot into raw server instruments.  A successful parse
+* always yields a snapshot, even when it carries no relevant instruments (both
+* fields `null`); `null` is reserved for an unparseable snapshot, so callers can
+* tell "available but empty" apart from "unavailable".
+* @param snapshot The parsed `stats` JSON.
+* @returns The raw server snapshot, or `null` if it could not be parsed.
+*/
+function parseServerSnapshot(snapshot) {
+	try {
+		const metrics = flattenMetrics(snapshot);
+		const sig = metrics.find((m) => m.dataPointType === "histogram" && (m.name ?? "").includes("signature.verification"));
+		const signature = sig == null ? null : mergeHistogram(sig.dataPoints);
+		let queueDepthMax = null;
+		const depth = metrics.find((m) => m.name === "fedify.queue.depth");
+		if (depth != null && Array.isArray(depth.dataPoints)) {
+			const values = depth.dataPoints.map((p) => p.value).filter(isFiniteNumber);
+			if (values.length > 0) queueDepthMax = Math.max(...values);
+		}
+		return {
+			signature,
+			queueDepthMax
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Subtracts a baseline snapshot from an end snapshot, yielding the instruments
+* accumulated between the two (the measured window).  Signature histogram
+* counts are diffed bucket by bucket; the queue depth is a gauge, not a
+* cumulative count, so the end value is kept as-is.  Callers that cannot obtain
+* both snapshots should not call this (and should report no server metrics)
+* rather than passing a stand-in, since a missing baseline cannot be diffed.
+* @param baseline The snapshot taken at the measured-window start.
+* @param end The snapshot taken at the measured-window end.
+* @returns The windowed snapshot.
+*/
+function diffSnapshots(baseline, end) {
+	return {
+		signature: diffHistogram(baseline.signature, end.signature),
+		queueDepthMax: end.queueDepthMax
+	};
+}
+/**
+* Projects a raw server snapshot into the report's server metrics, or `null`
+* when it carries no usable measurement.
+* @param snapshot The raw (optionally diffed) server snapshot.
+* @returns The projected server metrics, or `null`.
+*/
+function snapshotToMetrics(snapshot) {
+	if (snapshot == null) return null;
+	const result = {};
+	if (snapshot.signature != null) {
+		if (snapshot.signature.counts.reduce((sum, n) => sum + n, 0) > 0) result.signatureVerificationMs = { overall: {
+			p50: histogramPercentile(snapshot.signature, 50),
+			p95: histogramPercentile(snapshot.signature, 95),
+			p99: histogramPercentile(snapshot.signature, 99)
+		} };
+	}
+	if (snapshot.queueDepthMax != null) result.queue = { depthMax: snapshot.queueDepthMax };
+	return Object.keys(result).length > 0 ? result : null;
+}
+/**
+* Fetches and parses the target's raw server snapshot.
+* @param target The target base URL.
+* @param fetchImpl The fetch implementation (overridable for tests).
+* @returns The raw server snapshot, or `null` if unavailable.
+*/
+async function fetchServerSnapshot(target, fetchImpl = fetch) {
+	try {
+		const response = await fetchImpl(new URL(STATS_PATH, target), { redirect: "manual" });
+		if (!response.ok) return null;
+		return parseServerSnapshot(await response.json());
+	} catch {
+		return null;
+	}
+}
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function flattenMetrics(snapshot) {
+	return (Array.isArray(snapshot?.scopeMetrics) ? snapshot.scopeMetrics : []).flatMap((scope) => {
+		const metrics = scope?.metrics;
+		return Array.isArray(metrics) ? metrics.filter((m) => m != null) : [];
+	});
+}
+function mergeHistogram(dataPoints) {
+	if (!Array.isArray(dataPoints)) return null;
+	let boundaries = null;
+	let counts = null;
+	for (const point of dataPoints) {
+		const value = point?.value;
+		if (typeof value !== "object" || value == null) continue;
+		const b = value.buckets?.boundaries;
+		const c = value.buckets?.counts;
+		if (!Array.isArray(b) || !Array.isArray(c)) continue;
+		if (!b.every(isFiniteNumber) || !c.every(isFiniteNumber)) continue;
+		if (boundaries == null) {
+			boundaries = [...b];
+			counts = [...c];
+		} else if (counts != null && counts.length === c.length && boundaries.length === b.length && boundaries.every((v, i) => v === b[i])) for (let i = 0; i < c.length; i++) counts[i] += c[i];
+	}
+	return boundaries != null && counts != null ? {
+		boundaries,
+		counts
+	} : null;
+}
+function diffHistogram(baseline, end) {
+	if (end == null) return null;
+	if (baseline == null) return end;
+	if (!histogramsCompatible(baseline, end)) return null;
+	const counts = end.counts.map((count, i) => Math.max(0, count - baseline.counts[i]));
+	return {
+		boundaries: end.boundaries,
+		counts
+	};
+}
+function histogramsCompatible(a, b) {
+	return a.boundaries.length === b.boundaries.length && a.counts.length === b.counts.length && a.boundaries.every((boundary, i) => boundary === b.boundaries[i]);
+}
+function histogramPercentile(histogram, p) {
+	const { boundaries, counts } = histogram;
+	const total = counts.reduce((sum, n) => sum + n, 0);
+	if (total === 0) return 0;
+	const target = Math.ceil(p / 100 * total);
+	let accumulated = 0;
+	for (let i = 0; i < counts.length; i++) {
+		accumulated += counts[i];
+		if (accumulated >= target) return i < boundaries.length ? boundaries[i] : boundaries[boundaries.length - 1] ?? 0;
+	}
+	return boundaries[boundaries.length - 1] ?? 0;
+}
+//#endregion
+export { diffSnapshots, fetchServerSnapshot, snapshotToMetrics };

package/dist/bench/mod.js

@@ -0,0 +1,4 @@
+import "@js-temporal/polyfill";
+import "./action.js";
+import "./command.js";
+export {};

package/dist/bench/render/format.js

@@ -0,0 +1,46 @@
+import "@js-temporal/polyfill";
+//#region src/bench/render/format.ts
+const OP_SYMBOLS = {
+	lt: "<",
+	lte: "<=",
+	gt: ">",
+	gte: ">=",
+	eq: "=="
+};
+/** Returns the symbolic form of a comparison operator. */
+function opSymbol(op) {
+	return OP_SYMBOLS[op];
+}
+/** Formats a number with grouping and at most three fractional digits. */
+function formatNumber(value) {
+	if (!Number.isFinite(value)) return String(value);
+	return (Math.round(value * 1e3) / 1e3).toLocaleString("en-US", { maximumFractionDigits: 3 });
+}
+/** Formats a ratio (0..1) as a percentage with at most two fractional digits. */
+function formatPercent(ratio) {
+	return `${(Math.round(ratio * 1e6) / 1e4).toLocaleString("en-US", { maximumFractionDigits: 2 })}%`;
+}
+/**
+* Formats a normalized threshold back into its human-friendly unit.
+* @param threshold The normalized numeric threshold.
+* @param unit The threshold's unit (`"ms"`, `"%"`, `"/s"`, or `null`).
+*/
+function formatThreshold(threshold, unit) {
+	switch (unit) {
+		case "%": return formatPercent(threshold);
+		case "ms": return `${formatNumber(threshold)}ms`;
+		case "/s": return `${formatNumber(threshold)}/s`;
+		default: return formatNumber(threshold);
+	}
+}
+/**
+* Formats a measured value using the unit of the assertion it is compared to.
+* @param actual The measured value, or `null` if unmeasured.
+* @param unit The assertion's unit.
+*/
+function formatActual(actual, unit) {
+	if (actual == null) return "n/a";
+	return formatThreshold(actual, unit);
+}
+//#endregion
+export { formatActual, formatNumber, formatPercent, formatThreshold, opSymbol };

package/dist/bench/render/index.js

@@ -0,0 +1,20 @@
+import "@js-temporal/polyfill";
+import { renderJson } from "./json.js";
+import { renderMarkdown } from "./markdown.js";
+import { renderText } from "./text.js";
+//#region src/bench/render/index.ts
+/**
+* Renders a report in the requested format.
+* @param report The report to render.
+* @param format The output format.
+* @returns The rendered text.
+*/
+function renderReport(report, format) {
+	switch (format) {
+		case "json": return renderJson(report);
+		case "markdown": return renderMarkdown(report);
+		case "text": return renderText(report);
+	}
+}
+//#endregion
+export { renderReport };

package/dist/bench/render/json.js

@@ -0,0 +1,12 @@
+import "@js-temporal/polyfill";
+//#region src/bench/render/json.ts
+/**
+* Renders a report as pretty-printed canonical JSON.
+* @param report The report to render.
+* @returns The JSON text, with a trailing newline.
+*/
+function renderJson(report) {
+	return `${JSON.stringify(report, null, 2)}\n`;
+}
+//#endregion
+export { renderJson };

package/dist/bench/render/markdown.js

@@ -0,0 +1,62 @@
+import "@js-temporal/polyfill";
+import { metricDisplayUnit } from "../result/expect/metrics.js";
+import { formatActual, formatNumber, formatPercent, formatThreshold, opSymbol } from "./format.js";
+//#region src/bench/render/markdown.ts
+/**
+* The Markdown renderer, suited to a GitHub Actions job summary or a PR
+* comment.  It is derived from the same report model as the text and JSON
+* forms.
+* @since 2.3.0
+* @module
+*/
+/**
+* Renders a report as Markdown.
+* @param report The report to render.
+* @returns The Markdown text.
+*/
+function renderMarkdown(report) {
+	const lines = [];
+	lines.push("# Fedify benchmark report", "");
+	lines.push(`**Result:** ${report.passed ? "✅ PASS" : "❌ FAIL"}`, "");
+	lines.push(`- **Target:** \`${report.target.url}\` (${report.target.statsAvailable ? "stats available" : "no stats"})`);
+	lines.push(`- **Environment:** ${report.environment.runtime} ${report.environment.runtimeVersion}, ${report.environment.os}, ${report.environment.cpuCount} CPUs`);
+	lines.push(`- **Config:** \`${report.suite.configHash}\``, "");
+	for (const scenario of report.scenarios) lines.push(...renderScenario(scenario), "");
+	return lines.join("\n");
+}
+function renderScenario(scenario) {
+	const lines = [];
+	lines.push(`## ${scenario.name} (${scenario.type}) ${scenario.passed ? "✅" : "❌"}`, "");
+	lines.push("| Metric | Value |", "| --- | --- |");
+	const r = scenario.requests;
+	lines.push(`| Requests | ${formatNumber(r.total)} |`);
+	lines.push(`| Success rate | ${formatPercent(r.successRate)} |`);
+	lines.push(`| Throughput | ${formatNumber(scenario.throughputPerSec)}/s |`);
+	const l = scenario.client.latencyMs;
+	lines.push(`| Latency p50 | ${formatNumber(l.p50)}ms |`);
+	lines.push(`| Latency p95 | ${formatNumber(l.p95)}ms |`);
+	lines.push(`| Latency p99 | ${formatNumber(l.p99)}ms |`);
+	const sig = scenario.server?.signatureVerificationMs?.overall;
+	if (sig?.p95 != null) lines.push(`| Signature verification p95 (server) | ${formatNumber(sig.p95)}ms |`);
+	const queue = scenario.server?.queue;
+	if (queue?.drainMs?.p95 != null) lines.push(`| Queue drain p95 (server) | ${formatNumber(queue.drainMs.p95)}ms |`);
+	if (queue?.depthMax != null) lines.push(`| Queue depth max (server) | ${formatNumber(queue.depthMax)} |`);
+	if (scenario.errors.length > 0) {
+		lines.push("", "| Error | Count |", "| --- | --- |");
+		for (const error of scenario.errors) {
+			const code = error.status == null ? error.kind : String(error.status);
+			lines.push(`| ${code} ${error.reason} | ${formatNumber(error.count)} |`);
+		}
+	}
+	if (scenario.expectations.length > 0) {
+		lines.push("", "| Expectation | Actual | Result |", "| --- | --- | --- |");
+		for (const e of scenario.expectations) {
+			const tag = e.pass ? "✅" : e.severity === "warn" ? "⚠️" : "❌";
+			const unit = metricDisplayUnit(e.metric);
+			lines.push(`| \`${e.metric} ${opSymbol(e.op)} ${formatThreshold(e.threshold, e.unit ?? unit)}\` | ${formatActual(e.actual, unit)} | ${tag} |`);
+		}
+	}
+	return lines;
+}
+//#endregion
+export { renderMarkdown };