autotel-devtools 22.0.0 → 23.1.0

package/dist/http-gk1xapnA.js

@@ -0,0 +1,3825 @@
+import { i as encodeTraces } from "./wire-2Rmfg6IT.js";
+import { i as asString, o as stringAttr, t as asObject } from "./json-fields-CPjKZ2WH.js";
+import { t as pickRoot } from "./trace-root-EHnvuA7f.js";
+import { a as compileWhere, t as parse } from "./parse-D_RmPPQs.js";
+import { t as getResourceName } from "./resource-utils-B4UVvfnH.js";
+import { createServer } from "node:http";
+import { WebSocket, WebSocketServer } from "ws";
+import { ingestAgentEvents, ingestAgentMetrics } from "autotel-agents";
+import { DatabaseSync } from "node:sqlite";
+import { createHash } from "node:crypto";
+import { gzipSync } from "node:zlib";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import path, { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import protobuf from "protobufjs";
+
+//#region src/server/error-aggregator.ts
+var ErrorAggregator = class {
+	errorGroups = /* @__PURE__ */ new Map();
+	options;
+	constructor(options = {}) {
+		this.options = {
+			maxGroups: options.maxGroups ?? 100,
+			maxAffectedTraces: options.maxAffectedTraces ?? 10,
+			maxAffectedSpans: options.maxAffectedSpans ?? 5,
+			stackFramesForFingerprint: options.stackFramesForFingerprint ?? 5
+		};
+	}
+	/**
+	* Add an error occurrence to the aggregator
+	*/
+	addError(occurrence) {
+		const fingerprint = this.generateFingerprint(occurrence);
+		const existing = this.errorGroups.get(fingerprint);
+		if (existing) {
+			existing.count++;
+			existing.lastSeen = occurrence.timestamp;
+			if (!existing.affectedTraces.includes(occurrence.traceId)) {
+				existing.affectedTraces.push(occurrence.traceId);
+				if (existing.affectedTraces.length > this.options.maxAffectedTraces) existing.affectedTraces.shift();
+			}
+			if (!existing.affectedSpans.includes(occurrence.spanName)) {
+				existing.affectedSpans.push(occurrence.spanName);
+				if (existing.affectedSpans.length > this.options.maxAffectedSpans) existing.affectedSpans.shift();
+			}
+			return existing;
+		}
+		const newGroup = {
+			fingerprint,
+			type: occurrence.error.type,
+			message: occurrence.error.message,
+			stackTrace: this.normalizeStackTrace(occurrence.error.stackTrace),
+			count: 1,
+			firstSeen: occurrence.timestamp,
+			lastSeen: occurrence.timestamp,
+			affectedTraces: [occurrence.traceId],
+			affectedSpans: [occurrence.spanName],
+			service: occurrence.service,
+			attributes: occurrence.attributes
+		};
+		if (this.errorGroups.size >= this.options.maxGroups) this.evictOldestGroup();
+		this.errorGroups.set(fingerprint, newGroup);
+		return newGroup;
+	}
+	/**
+	* Extract errors from a trace and add them to the aggregator
+	*/
+	addErrorsFromTrace(trace) {
+		const addedGroups = [];
+		for (const span of trace.spans) if (span.status.code === "ERROR") {
+			const occurrence = this.extractErrorFromSpan(span, trace);
+			if (occurrence) {
+				const group = this.addError(occurrence);
+				addedGroups.push(group);
+			}
+		}
+		return addedGroups;
+	}
+	/**
+	* Extract error occurrence from a span
+	*/
+	extractErrorFromSpan(span, trace) {
+		const exceptionEvent = span.events?.find((e) => e.name === "exception");
+		const errorType = stringAttr(span.attributes, "exception.type", "error.type") ?? stringAttr(exceptionEvent?.attributes, "exception.type") ?? "Error";
+		const errorMessage = span.status.message || stringAttr(span.attributes, "exception.message", "error.message") || "Unknown error";
+		const stackTrace = stringAttr(span.attributes, "exception.stacktrace", "exception.stack", "error.stack") ?? this.extractStackFromEvents(span);
+		return {
+			traceId: trace.traceId,
+			spanId: span.spanId,
+			spanName: span.name,
+			service: trace.service,
+			timestamp: span.endTime,
+			error: {
+				type: errorType,
+				message: errorMessage,
+				stackTrace,
+				fingerprint: stringAttr(span.attributes, "exception.fingerprint") ?? stringAttr(exceptionEvent?.attributes, "exception.fingerprint")
+			},
+			attributes: this.extractRelevantAttributes(span.attributes)
+		};
+	}
+	/**
+	* Extract stack trace from span events (exception events)
+	*/
+	extractStackFromEvents(span) {
+		if (!span.events) return void 0;
+		const exceptionEvent = span.events.find((e) => e.name === "exception");
+		if (exceptionEvent?.attributes) return stringAttr(exceptionEvent.attributes, "exception.stacktrace", "exception.stack");
+	}
+	/**
+	* Extract relevant attributes for error context
+	*/
+	extractRelevantAttributes(attributes) {
+		const relevant = {};
+		for (const key of [
+			"http.method",
+			"http.url",
+			"http.route",
+			"http.status_code",
+			"db.system",
+			"db.operation",
+			"rpc.method",
+			"rpc.service",
+			"code.function",
+			"code.filepath",
+			"user.id",
+			"operation.name"
+		]) if (key in attributes) relevant[key] = attributes[key];
+		return relevant;
+	}
+	/**
+	* Generate a fingerprint for error grouping
+	*
+	* Uses error type + first N stack frames (normalized)
+	*/
+	generateFingerprint(occurrence) {
+		if (occurrence.error.fingerprint) return occurrence.error.fingerprint;
+		const parts = [occurrence.error.type];
+		if (occurrence.error.stackTrace) {
+			const frames = this.extractStackFrames(occurrence.error.stackTrace, this.options.stackFramesForFingerprint);
+			parts.push(...frames);
+		} else parts.push(this.normalizeMessage(occurrence.error.message));
+		return this.simpleHash(parts.join("|"));
+	}
+	/**
+	* Extract and normalize stack frames from a stack trace
+	*/
+	extractStackFrames(stackTrace, count) {
+		const lines = stackTrace.split("\n");
+		const frames = [];
+		for (const line of lines) {
+			if (frames.length >= count) break;
+			const trimmed = line.trim();
+			const nodeMatch = trimmed.match(/^at\s+(.+?)\s+\((.+?):(\d+):\d+\)$/);
+			if (nodeMatch) {
+				frames.push(`${nodeMatch[1]}@${this.normalizeFilePath(nodeMatch[2])}`);
+				continue;
+			}
+			const anonMatch = trimmed.match(/^at\s+(.+?):(\d+):\d+$/);
+			if (anonMatch) {
+				frames.push(`anonymous@${this.normalizeFilePath(anonMatch[1])}`);
+				continue;
+			}
+			const browserMatch = trimmed.match(/^(.+?)@(.+?):(\d+):\d+$/);
+			if (browserMatch) {
+				frames.push(`${browserMatch[1]}@${this.normalizeFilePath(browserMatch[2])}`);
+				continue;
+			}
+		}
+		return frames;
+	}
+	/**
+	* Normalize file path by removing absolute path prefixes and node_modules paths
+	*/
+	normalizeFilePath(filePath) {
+		const nodeModulesMatch = filePath.match(/node_modules\/(@[^/]+\/[^/]+|[^/]+)/);
+		if (nodeModulesMatch) return `[npm]/${nodeModulesMatch[1]}`;
+		return filePath.replace(/^.*?\/src\//, "src/").replace(/^.*?\/dist\//, "dist/").replace(/^.*?\/lib\//, "lib/").replace(/^file:\/\//, "");
+	}
+	/**
+	* Normalize error message by removing dynamic parts
+	*/
+	normalizeMessage(message) {
+		return message.replaceAll(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, "[UUID]").replaceAll(/\b[0-9a-f]{16,}\b/gi, "[ID]").replaceAll(/\d+/g, "[N]").replaceAll(/"[^"]*"/g, "\"[STR]\"").replaceAll(/'[^']*'/g, "'[STR]'").slice(0, 200);
+	}
+	/**
+	* Normalize stack trace for display
+	*/
+	normalizeStackTrace(stackTrace) {
+		if (!stackTrace) return void 0;
+		return stackTrace.split("\n").slice(0, 10).join("\n");
+	}
+	/**
+	* Simple hash function for fingerprinting
+	*/
+	simpleHash(str) {
+		let hash = 0;
+		for (let i = 0; i < str.length; i++) {
+			const char = str.charCodeAt(i);
+			hash = (hash << 5) - hash + char;
+			hash = hash & hash;
+		}
+		return Math.abs(hash).toString(16).padStart(8, "0");
+	}
+	/**
+	* Evict the oldest error group
+	*/
+	evictOldestGroup() {
+		let oldest = null;
+		for (const [fingerprint, group] of this.errorGroups) if (!oldest || group.lastSeen < oldest.lastSeen) oldest = {
+			fingerprint,
+			lastSeen: group.lastSeen
+		};
+		if (oldest) this.errorGroups.delete(oldest.fingerprint);
+	}
+	/**
+	* Get all error groups, sorted by most recent
+	*/
+	getErrorGroups() {
+		return [...this.errorGroups.values()].sort((a, b) => b.lastSeen - a.lastSeen);
+	}
+	/**
+	* Get error groups sorted by count (most frequent first)
+	*/
+	getErrorGroupsByFrequency() {
+		return [...this.errorGroups.values()].sort((a, b) => b.count - a.count);
+	}
+	/**
+	* Get a specific error group by fingerprint
+	*/
+	getErrorGroup(fingerprint) {
+		return this.errorGroups.get(fingerprint);
+	}
+	/**
+	* Get error groups for a specific service
+	*/
+	getErrorGroupsByService(service) {
+		return this.getErrorGroups().filter((g) => g.service === service);
+	}
+	/**
+	* Get total error count across all groups
+	*/
+	getTotalErrorCount() {
+		let total = 0;
+		for (const group of this.errorGroups.values()) total += group.count;
+		return total;
+	}
+	/**
+	* Get error statistics
+	*/
+	getStats() {
+		const oneHourAgo = Date.now() - 3600 * 1e3;
+		let recentErrors = 0;
+		const typeCount = /* @__PURE__ */ new Map();
+		for (const group of this.errorGroups.values()) {
+			if (group.lastSeen > oneHourAgo) recentErrors += group.count;
+			typeCount.set(group.type, (typeCount.get(group.type) || 0) + group.count);
+		}
+		const topErrorTypes = [...typeCount.entries()].map(([type, count]) => ({
+			type,
+			count
+		})).sort((a, b) => b.count - a.count).slice(0, 5);
+		return {
+			totalGroups: this.errorGroups.size,
+			totalErrors: this.getTotalErrorCount(),
+			recentErrors,
+			topErrorTypes
+		};
+	}
+	/**
+	* Clear all error groups
+	*/
+	clear() {
+		this.errorGroups.clear();
+	}
+	/**
+	* Clear old error groups (not seen in given time window)
+	*/
+	clearOlderThan(maxAgeMs) {
+		const cutoff = Date.now() - maxAgeMs;
+		let cleared = 0;
+		for (const [fingerprint, group] of this.errorGroups) if (group.lastSeen < cutoff) {
+			this.errorGroups.delete(fingerprint);
+			cleared++;
+		}
+		return cleared;
+	}
+};
+
+//#endregion
+//#region src/server/telemetry-limits.ts
+const defaultLimit = 100;
+function parseLimit(value) {
+	if (!value) return void 0;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function resolveTelemetryLimits(args = {}) {
+	const env = args.env ?? process.env;
+	const fallback = args.maxHistory ?? defaultLimit;
+	return {
+		maxTraceCount: args.maxTraceCount ?? parseLimit(env.AUTOTEL_MAX_TRACE_COUNT) ?? fallback,
+		maxLogCount: args.maxLogCount ?? parseLimit(env.AUTOTEL_MAX_LOG_COUNT) ?? fallback
+	};
+}
+function appendWithLimit(items, item, limit) {
+	if (limit <= 0) return [];
+	const next = [...items, item];
+	return next.length > limit ? next.slice(next.length - limit) : next;
+}
+function appendManyWithLimit(items, incoming, limit) {
+	if (limit <= 0 || incoming.length === 0) return limit <= 0 ? [] : items;
+	const next = [...items, ...incoming];
+	return next.length > limit ? next.slice(next.length - limit) : next;
+}
+function applyTelemetryLimits(data, limits) {
+	return {
+		...data,
+		traces: data.traces.slice(-limits.maxTraceCount),
+		logs: data.logs.slice(-limits.maxLogCount)
+	};
+}
+
+//#endregion
+//#region src/server/origin-guard.ts
+const LOOPBACK_IPV6 = /* @__PURE__ */ new Set(["::1", "0:0:0:0:0:0:0:1"]);
+/** True for `localhost`, any `127.x.x.x`, and IPv6 loopback. Case-insensitive. */
+function isLoopbackHostname(hostname) {
+	const h = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+	return h === "localhost" || /^127\./.test(h) || LOOPBACK_IPV6.has(h);
+}
+/** Hostname from a `Host` header (`host`, `host:port`, `[::1]:port`). */
+function hostnameFromHostHeader(host) {
+	const h = host.trim();
+	if (h.startsWith("[")) {
+		const end = h.indexOf("]");
+		return end > 0 ? h.slice(1, end) : h;
+	}
+	const colon = h.indexOf(":");
+	return colon === -1 ? h : h.slice(0, colon);
+}
+/** True when the `Host` header names a loopback host. */
+function hostHeaderIsLoopback(host) {
+	return isLoopbackHostname(hostnameFromHostHeader(host));
+}
+/** True when an `Origin` header names a loopback origin. A malformed or opaque
+*  origin (e.g. the literal `null` from a sandboxed iframe) is treated as
+*  non-loopback. */
+function originIsLoopback(origin) {
+	try {
+		return isLoopbackHostname(new URL(origin).hostname);
+	} catch {
+		return false;
+	}
+}
+/**
+* Decide whether a request to a sensitive (read/mutate) endpoint is allowed.
+* - A present, non-loopback `Origin` is always rejected (cross-origin read).
+* - When `loopbackOnly`, a present, non-loopback `Host` is rejected (DNS
+*   rebinding). Skipped when the receiver is bound to a non-loopback host.
+*/
+function allowSensitiveRequest(headers, loopbackOnly) {
+	const { origin, host } = headers;
+	if (origin && origin.length > 0 && !originIsLoopback(origin)) return false;
+	if (loopbackOnly && host && host.length > 0 && !hostHeaderIsLoopback(host)) return false;
+	return true;
+}
+
+//#endregion
+//#region src/server/metric-reduction.ts
+const DEFAULT_MAX_EXEMPLARS = 32;
+/** Reduce a metric series to a chart-sized result before it crosses the wire. */
+function reduceMetricPoints(points, kind, maxPoints, options = {}) {
+	const maxExemplars = options.maxExemplars ?? DEFAULT_MAX_EXEMPLARS;
+	const limit = Math.max(4, Math.floor(maxPoints));
+	if (points.length <= limit) return capExemplars(points, maxExemplars);
+	if (kind === "histogram" || kind === "exponentialHistogram" || kind === "summary") {
+		if (options.temporality === "cumulative") return sampleCumulativeSnapshots(points, limit, maxExemplars);
+		return mergeDistributionBuckets(points, limit, maxExemplars);
+	}
+	return capExemplars(m4(points, limit), maxExemplars);
+}
+/** Cumulative points are complete snapshots; summing them double-counts. */
+function sampleCumulativeSnapshots(points, limit, maxExemplars) {
+	const bucketSize = Math.ceil(points.length / limit);
+	const snapshots = [];
+	for (let start = 0; start < points.length; start += bucketSize) snapshots.push(points[Math.min(start + bucketSize, points.length) - 1]);
+	return capExemplars(snapshots, maxExemplars);
+}
+/** First/min/max/last sampling preserves spikes and troughs in every time bucket. */
+function m4(points, limit) {
+	const bucketSize = Math.max(1, Math.ceil(points.length / Math.max(1, Math.floor(limit / 4))));
+	const selected = [];
+	for (let start = 0; start < points.length; start += bucketSize) {
+		const bucket = points.slice(start, start + bucketSize);
+		const byValue = [...bucket].sort((a, b) => (a.value ?? 0) - (b.value ?? 0));
+		const candidates = [
+			bucket[0],
+			byValue[0],
+			byValue[byValue.length - 1],
+			bucket[bucket.length - 1]
+		];
+		const unique = /* @__PURE__ */ new Map();
+		for (const point of candidates) unique.set(point.timestamp, point);
+		selected.push(...[...unique.values()].sort((a, b) => a.timestamp - b.timestamp));
+	}
+	return selected.slice(0, limit);
+}
+function mergeDistributionBuckets(points, limit, maxExemplars) {
+	const bucketSize = Math.ceil(points.length / limit);
+	const out = [];
+	let remainingExemplars = maxExemplars;
+	for (let start = 0; start < points.length; start += bucketSize) {
+		const merged = mergePoints(points.slice(start, start + bucketSize), remainingExemplars);
+		remainingExemplars -= merged.exemplars?.length ?? 0;
+		out.push(merged);
+	}
+	return out;
+}
+function mergePoints(points, maxExemplars) {
+	const last = points[points.length - 1];
+	const counts = points.map((point) => point.count ?? 0);
+	const totalCount = counts.reduce((sum, value) => sum + value, 0);
+	const result = {
+		...last,
+		startTimestamp: points[0].startTimestamp,
+		count: totalCount,
+		sum: sumDefined(points.map((point) => point.sum)),
+		min: minDefined(points.map((point) => point.min)),
+		max: maxDefined(points.map((point) => point.max)),
+		exemplars: maxExemplars <= 0 ? [] : points.flatMap((point) => point.exemplars ?? []).slice(-maxExemplars)
+	};
+	if (sameArrays(points.map((point) => point.explicitBounds))) result.bucketCounts = sumArrays(points.map((point) => point.bucketCounts));
+	if (points.every((point) => point.scale === last.scale)) {
+		result.zeroCount = points.reduce((sum, point) => sum + (point.zeroCount ?? 0), 0);
+		result.positive = mergeExponential(points.map((point) => point.positive));
+		result.negative = mergeExponential(points.map((point) => point.negative));
+	}
+	if (last.quantiles) result.quantiles = last.quantiles.map(({ quantile }) => {
+		let weight = 0;
+		let value = 0;
+		for (let index = 0; index < points.length; index++) {
+			const found = points[index].quantiles?.find((item) => item.quantile === quantile);
+			if (!found) continue;
+			const pointWeight = counts[index] || 1;
+			weight += pointWeight;
+			value += found.value * pointWeight;
+		}
+		return {
+			quantile,
+			value: weight === 0 ? 0 : value / weight
+		};
+	});
+	return result;
+}
+function mergeExponential(values) {
+	const buckets = values.filter((value) => value !== void 0);
+	if (buckets.length === 0) return void 0;
+	const start = Math.min(...buckets.map((bucket) => bucket.offset));
+	const end = Math.max(...buckets.map((bucket) => bucket.offset + bucket.bucketCounts.length));
+	const bucketCounts = Array.from({ length: end - start }, () => 0);
+	for (const bucket of buckets) for (let index = 0; index < bucket.bucketCounts.length; index++) bucketCounts[bucket.offset - start + index] += bucket.bucketCounts[index];
+	return {
+		offset: start,
+		bucketCounts
+	};
+}
+function sameArrays(values) {
+	const first = JSON.stringify(values[0]);
+	return values.every((value) => JSON.stringify(value) === first);
+}
+function sumArrays(values) {
+	if (values.some((value) => value === void 0)) return void 0;
+	return values.reduce((sum, value) => value.map((item, index) => item + (sum[index] ?? 0)), []);
+}
+function sumDefined(values) {
+	const found = values.filter((value) => value !== void 0);
+	return found.length === 0 ? void 0 : found.reduce((sum, value) => sum + value, 0);
+}
+function minDefined(values) {
+	const found = values.filter((value) => value !== void 0);
+	return found.length === 0 ? void 0 : Math.min(...found);
+}
+function maxDefined(values) {
+	const found = values.filter((value) => value !== void 0);
+	return found.length === 0 ? void 0 : Math.max(...found);
+}
+function capExemplars(points, max) {
+	let remaining = max;
+	return points.map((point) => {
+		if (!point.exemplars) return point;
+		const exemplars = point.exemplars.slice(0, remaining);
+		remaining -= exemplars.length;
+		return {
+			...point,
+			exemplars
+		};
+	});
+}
+
+//#endregion
+//#region src/widget/timeWindow.ts
+const PRESETS = [
+	{
+		id: "all",
+		label: "All time",
+		durationMs: null
+	},
+	{
+		id: "5m",
+		label: "Last 5m",
+		durationMs: 5 * 6e4
+	},
+	{
+		id: "15m",
+		label: "Last 15m",
+		durationMs: 15 * 6e4
+	},
+	{
+		id: "30m",
+		label: "Last 30m",
+		durationMs: 30 * 6e4
+	},
+	{
+		id: "1h",
+		label: "Last 1h",
+		durationMs: 60 * 6e4
+	},
+	{
+		id: "3h",
+		label: "Last 3h",
+		durationMs: 180 * 6e4
+	},
+	{
+		id: "6h",
+		label: "Last 6h",
+		durationMs: 360 * 6e4
+	},
+	{
+		id: "24h",
+		label: "Last 24h",
+		durationMs: 1440 * 6e4
+	},
+	{
+		id: "7d",
+		label: "Last 7d",
+		durationMs: 10080 * 6e4
+	}
+];
+/**
+* Typed as the preset arm rather than the union: `serializeWindow` compares
+* against `DEFAULT_SELECTION.preset`, which the widened union does not expose.
+*/
+const DEFAULT_SELECTION = {
+	type: "preset",
+	preset: "all"
+};
+const PRESET_BY_ID = new Map(PRESETS.map((p) => [p.id, p]));
+/**
+* Serialize for the URL hash, or `null` when the selection is the default.
+*
+* Omitting the default keeps shared links free of parameters that say nothing.
+*/
+function serializeWindow(selection) {
+	if (selection.type === "preset") return selection.preset === DEFAULT_SELECTION.preset ? null : selection.preset;
+	return `custom:${selection.start}:${selection.end}`;
+}
+
+//#endregion
+//#region src/server/store/store.ts
+/**
+* Telemetry store, backed by `node:sqlite`.
+*
+* `node:sqlite` is in the standard library on Node 24, which this package
+* already requires — so persistence, indexes and a real query engine cost no
+* dependency at all. The store is what lets the viewer hold more than a
+* screenful of telemetry, survive a restart, and answer a query without
+* shipping every span to the browser first.
+*
+* Layout: `traces` holds one row per trace (the list view reads only this), and
+* `spans` holds the detail. `service` is denormalised onto each span row so a
+* span-level filter (`service = api AND duration > 100`) never needs a join.
+*
+* Concurrency: sqlite serialises writes itself and every method here is
+* synchronous, so there is no interleaving to guard. WAL is enabled so a long
+* read cannot block ingest.
+*/
+/**
+* How far either side of a trace the deep-linked window reaches.
+*
+* A window of exactly the trace's own bounds is a correct answer that reads
+* badly: the trace touches both edges with nothing around it. A minute of air
+* shows what else was happening, and gives a zero-duration trace a window with
+* width at all.
+*/
+const DEEP_LINK_PAD_MS = 6e4;
+/**
+* A link back into the viewer, pointing at a trace and optionally one span.
+*
+* **The window is the part that is easy to leave out and expensive to omit.**
+* A link is read later than it is made, by an agent handing one to a person or
+* a person pasting one into an incident channel, and by then the viewer's
+* default range has rolled past the trace. The telemetry is still there and
+* the view is not looking at it, which reads as "the tool lost my data".
+*
+* Serialized with the widget's own `serializeWindow`, and pinned by a test
+* that parses the result with the widget's own `parseNavHash`, so the two ends
+* cannot drift into agreeing on nothing.
+*/
+function traceDeepLink(traceId, bounds, spanId) {
+	const params = new URLSearchParams({
+		tab: "traces",
+		trace: traceId
+	});
+	if (spanId) params.set("span", spanId);
+	params.set("window", serializeWindow({
+		type: "custom",
+		start: Number(bounds.start_time) - DEEP_LINK_PAD_MS,
+		end: Number(bounds.end_time) + DEEP_LINK_PAD_MS
+	}) ?? "");
+	return `/#${params.toString()}`;
+}
+/**
+* Shape of the schema this build knows how to read.
+*
+* Bump it whenever a change to the DDL cannot be reached by the migrations in
+* this file. A `--db` file written by a newer build is refused rather than
+* queried, because the alternative is an opaque "no such column" thrown from
+* whichever query happens to run first.
+*
+* `0` means a file written before this guard existed. Those are adopted and
+* stamped, since the migrations above already cover every shape they can be in.
+*/
+const SCHEMA_VERSION = 1;
+const DEFAULT_MAX_TRACES = 1e5;
+const DEFAULT_MAX_METRIC_POINTS = 5e3;
+const DEFAULT_MAX_LOGS = 1e5;
+const DEFAULT_LIMIT = 100;
+const MAX_QUERY_PAGE_SIZE = 1e3;
+/**
+* Spans scanned per side of a comparison.
+*
+* A cohort is a statistical population, not a page: the fractions are only as
+* honest as the sample, so this is deliberately far larger than a list page.
+*/
+const COHORT_ROW_LIMIT = 2e4;
+/**
+* Query vocabulary for logs.
+*
+* `severity` and `severity_number` are both exposed deliberately: the text is
+* what people read, but "error and above" is a numeric comparison and string
+* ordering cannot express it. Anything not named here is a log attribute.
+*/
+const LOG_SCHEMA = {
+	columns: {
+		service: {
+			column: "service",
+			type: "string"
+		},
+		severity: {
+			column: "severity_text",
+			type: "string"
+		},
+		severity_number: {
+			column: "severity_number",
+			type: "number"
+		},
+		trace_id: {
+			column: "trace_id",
+			type: "string"
+		},
+		span_id: {
+			column: "span_id",
+			type: "string"
+		},
+		body: {
+			column: "body_text",
+			type: "string"
+		}
+	},
+	attributesColumn: "attributes",
+	freeTextColumns: [
+		"body",
+		"service",
+		"severity",
+		"trace_id"
+	],
+	attributeIndex: {
+		table: "attribute_occurrences",
+		signal: "logs",
+		entitySql: "id"
+	}
+};
+/**
+* Query vocabulary for spans.
+*
+* Anything not named here is treated as a span attribute, so every attribute a
+* service emits is queryable without being declared.
+*/
+/**
+* Ties a child row to the span row being filtered.
+*
+* `s` is the alias `queryTraces` gives the spans table, the same coupling
+* `attributeIndex.entitySql` already carries: these are trusted SQL fragments
+* that must stay in step with the FROM clause the store writes. The event and
+* link tests fail if the alias moves, which is what keeps them in step.
+*/
+const SPAN_ROW_JOIN = "rel.trace_id = s.trace_id AND rel.span_id = s.span_id";
+const SPAN_SCHEMA = {
+	columns: {
+		service: {
+			column: "service",
+			type: "string"
+		},
+		name: {
+			column: "name",
+			type: "string"
+		},
+		kind: {
+			column: "kind",
+			type: "string"
+		},
+		duration: {
+			column: "duration",
+			type: "number"
+		},
+		status: {
+			column: "status_code",
+			type: "string"
+		},
+		trace_id: {
+			column: "trace_id",
+			type: "string"
+		},
+		span_id: {
+			column: "span_id",
+			type: "string"
+		},
+		parent_span_id: {
+			column: "parent_span_id",
+			type: "string"
+		}
+	},
+	attributesColumn: "attributes",
+	freeTextColumns: [
+		"name",
+		"service",
+		"trace_id"
+	],
+	attributeIndex: {
+		table: "attribute_occurrences",
+		signal: "traces",
+		entitySql: "(trace_id || ':' || span_id)"
+	},
+	related: {
+		"event.name": {
+			table: "span_events",
+			column: "name",
+			joinSql: SPAN_ROW_JOIN
+		},
+		"link.trace_id": {
+			table: "span_links",
+			column: "linked_trace_id",
+			joinSql: SPAN_ROW_JOIN
+		},
+		"link.span_id": {
+			table: "span_links",
+			column: "linked_span_id",
+			joinSql: SPAN_ROW_JOIN
+		}
+	}
+};
+const METRIC_SCHEMA = {
+	columns: {
+		name: {
+			column: "name",
+			type: "string"
+		},
+		kind: {
+			column: "kind",
+			type: "string"
+		},
+		unit: {
+			column: "unit",
+			type: "string"
+		},
+		description: {
+			column: "description",
+			type: "string"
+		},
+		service: {
+			column: "service",
+			type: "string"
+		}
+	},
+	attributesColumn: "resource",
+	freeTextColumns: [
+		"name",
+		"description",
+		"unit",
+		"service"
+	]
+};
+const SPANS_TABLE_DDL = `
+CREATE TABLE IF NOT EXISTS spans (
+  span_id        TEXT NOT NULL,
+  trace_id       TEXT NOT NULL,
+  parent_span_id TEXT,
+  name           TEXT NOT NULL,
+  kind           TEXT NOT NULL,
+  service        TEXT,
+  start_time     INTEGER NOT NULL,
+  end_time       INTEGER NOT NULL,
+  duration       INTEGER NOT NULL,
+  status_code    TEXT NOT NULL,
+  status_message TEXT,
+  attributes     TEXT NOT NULL DEFAULT '{}',
+  events         TEXT,
+  links          TEXT,
+  scope          TEXT,
+  PRIMARY KEY (trace_id, span_id)
+);
+`;
+const DDL = `
+PRAGMA journal_mode = WAL;
+PRAGMA synchronous = NORMAL;
+
+CREATE TABLE IF NOT EXISTS traces (
+  trace_id       TEXT PRIMARY KEY,
+  correlation_id TEXT,
+  service        TEXT,
+  root_span_id   TEXT,
+  start_time     INTEGER NOT NULL,
+  end_time       INTEGER NOT NULL,
+  duration       INTEGER NOT NULL,
+  status         TEXT NOT NULL,
+  partial        INTEGER NOT NULL DEFAULT 0
+);
+
+${SPANS_TABLE_DDL}
+
+CREATE TABLE IF NOT EXISTS metric_series (
+  series_id     TEXT PRIMARY KEY,
+  name          TEXT NOT NULL,
+  unit          TEXT,
+  description   TEXT,
+  kind          TEXT NOT NULL,
+  temporality   TEXT,
+  monotonic     INTEGER,
+  service       TEXT NOT NULL,
+  scope_name    TEXT,
+  scope_version TEXT,
+  resource      TEXT NOT NULL DEFAULT '{}',
+  attributes    TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS metric_points (
+  series_id       TEXT NOT NULL,
+  timestamp       INTEGER NOT NULL,
+  start_timestamp INTEGER,
+  value           REAL,
+  count           REAL,
+  sum             REAL,
+  min             REAL,
+  max             REAL,
+  bucket_counts   TEXT,
+  explicit_bounds TEXT,
+  exp_scale       INTEGER,
+  zero_count      REAL,
+  zero_threshold  REAL,
+  positive_buckets TEXT,
+  negative_buckets TEXT,
+  quantiles       TEXT,
+  exemplars       TEXT,
+  PRIMARY KEY (series_id, timestamp)
+);
+
+CREATE TABLE IF NOT EXISTS logs (
+  id              TEXT PRIMARY KEY,
+  timestamp       INTEGER NOT NULL,
+  service         TEXT,
+  severity_text   TEXT,
+  severity_number INTEGER,
+  trace_id        TEXT,
+  span_id         TEXT,
+  -- The body as displayed: what free-text search matches against.
+  body_text       TEXT NOT NULL DEFAULT '',
+  -- The body as sent. Structured bodies must survive as structure; a JSON body
+  -- flattened to text is a log nobody can read.
+  body_json       TEXT,
+  attributes      TEXT NOT NULL DEFAULT '{}',
+  resource        TEXT
+);
+
+CREATE TABLE IF NOT EXISTS attribute_values (
+  signal     TEXT NOT NULL,
+  key        TEXT NOT NULL,
+  value_json TEXT NOT NULL,
+  value_text TEXT NOT NULL,
+  seen_count INTEGER NOT NULL DEFAULT 1,
+  last_seen  INTEGER NOT NULL,
+  PRIMARY KEY (signal, key, value_json)
+);
+
+-- Span events and links, normalized so they can be filtered.
+--
+-- The JSON on the span row stays: it is the payload the waterfall renders, and
+-- these two tables are the query index over it, the same split that
+-- attribute_occurrences already makes against the attributes blob. Both are
+-- written and deleted with their span, and backfilled on open for a --db
+-- file written before they existed.
+CREATE TABLE IF NOT EXISTS span_events (
+  trace_id  TEXT NOT NULL,
+  span_id   TEXT NOT NULL,
+  idx       INTEGER NOT NULL,
+  name      TEXT NOT NULL,
+  timestamp INTEGER,
+  PRIMARY KEY (trace_id, span_id, idx)
+);
+
+CREATE TABLE IF NOT EXISTS span_links (
+  trace_id        TEXT NOT NULL,
+  span_id         TEXT NOT NULL,
+  idx             INTEGER NOT NULL,
+  linked_trace_id TEXT NOT NULL,
+  linked_span_id  TEXT NOT NULL,
+  PRIMARY KEY (trace_id, span_id, idx)
+);
+
+CREATE TABLE IF NOT EXISTS attribute_occurrences (
+  signal     TEXT NOT NULL,
+  entity_id  TEXT NOT NULL,
+  key        TEXT NOT NULL,
+  value_json TEXT NOT NULL,
+  PRIMARY KEY (signal, entity_id, key)
+);
+
+CREATE INDEX IF NOT EXISTS idx_traces_start   ON traces(start_time DESC);
+CREATE INDEX IF NOT EXISTS idx_logs_time      ON logs(timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_logs_trace     ON logs(trace_id);
+CREATE INDEX IF NOT EXISTS idx_logs_severity  ON logs(severity_number, timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_series_name    ON metric_series(name);
+CREATE INDEX IF NOT EXISTS idx_points_time    ON metric_points(series_id, timestamp);
+CREATE INDEX IF NOT EXISTS idx_spans_trace    ON spans(trace_id);
+CREATE INDEX IF NOT EXISTS idx_spans_start    ON spans(start_time DESC);
+CREATE INDEX IF NOT EXISTS idx_spans_service  ON spans(service, start_time DESC);
+CREATE INDEX IF NOT EXISTS idx_spans_duration ON spans(duration DESC);
+CREATE INDEX IF NOT EXISTS idx_attribute_value ON attribute_values(signal, value_text, key);
+CREATE INDEX IF NOT EXISTS idx_attribute_equality ON attribute_occurrences(signal, key, value_json, entity_id);
+CREATE INDEX IF NOT EXISTS idx_span_events_name ON span_events(name);
+CREATE INDEX IF NOT EXISTS idx_span_links_target ON span_links(linked_trace_id);
+`;
+var DevtoolsStore = class {
+	db;
+	maxTraces;
+	maxMetricPoints;
+	maxLogs;
+	maxBytes;
+	constructor(options = {}) {
+		this.db = new DatabaseSync(options.path ?? ":memory:");
+		this.maxTraces = options.maxTraces ?? DEFAULT_MAX_TRACES;
+		this.maxMetricPoints = options.maxMetricPoints ?? DEFAULT_MAX_METRIC_POINTS;
+		this.maxLogs = options.maxLogs ?? DEFAULT_MAX_LOGS;
+		this.maxBytes = options.maxBytes ?? (options.path ? 2 * 1024 ** 3 : 512 * 1024 ** 2);
+		this.guardSchemaVersion(options.path);
+		this.migrateSpanIdentity();
+		this.db.exec(DDL);
+		this.migrateMetricFidelity();
+		this.backfillAttributeDictionary();
+		this.backfillSpanChildren();
+		this.registerRegexp();
+		this.db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+	}
+	/** Refuse a file this build cannot read, before any query touches it. */
+	guardSchemaVersion(path) {
+		const found = pragmaNumber(this.db, "user_version");
+		if (found === 0 || found === SCHEMA_VERSION) return;
+		this.db.close();
+		throw new Error(`${path ?? ":memory:"} was written by a different autotel-devtools schema (found version ${found}, this build reads ${SCHEMA_VERSION}). Point --db at another file, or delete this one to start fresh.`);
+	}
+	/** Upgrade databases created before span identity included the trace id. */
+	migrateSpanIdentity() {
+		if (!this.db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'spans'").get()) return;
+		if (this.db.prepare("PRAGMA table_info(spans)").all().filter((column) => Number(column.pk) > 0).sort((left, right) => Number(left.pk) - Number(right.pk)).map((column) => column.name).join(",") === "trace_id,span_id") return;
+		this.db.exec("BEGIN");
+		try {
+			this.db.exec("ALTER TABLE spans RENAME TO spans_legacy_span_id_pk");
+			this.db.exec(SPANS_TABLE_DDL);
+			this.db.exec(`
+        INSERT INTO spans (span_id, trace_id, parent_span_id, name, kind, service,
+                           start_time, end_time, duration, status_code,
+                           status_message, attributes, events, links, scope)
+        SELECT span_id, trace_id, parent_span_id, name, kind, service,
+               start_time, end_time, duration, status_code,
+               status_message, attributes, events, links, scope
+        FROM spans_legacy_span_id_pk
+      `);
+			this.db.exec("DROP TABLE spans_legacy_span_id_pk");
+			this.db.exec("COMMIT");
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+	}
+	/** Add lossless metric fields to databases created by earlier releases. */
+	migrateMetricFidelity() {
+		const hadResource = this.hasColumn("metric_series", "resource");
+		this.addColumnIfMissing("metric_series", "resource", "TEXT NOT NULL DEFAULT '{}'");
+		this.addColumnIfMissing("metric_points", "exp_scale", "INTEGER");
+		this.addColumnIfMissing("metric_points", "zero_count", "REAL");
+		this.addColumnIfMissing("metric_points", "zero_threshold", "REAL");
+		this.addColumnIfMissing("metric_points", "positive_buckets", "TEXT");
+		this.addColumnIfMissing("metric_points", "negative_buckets", "TEXT");
+		if (!hadResource) this.migrateLegacyMetricSeriesIdentity();
+	}
+	hasColumn(table, column) {
+		return this.db.prepare(`PRAGMA table_info(${table})`).all().some((item) => item.name === column);
+	}
+	addColumnIfMissing(table, column, declaration) {
+		if (this.hasColumn(table, column)) return;
+		this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${declaration}`);
+	}
+	migrateLegacyMetricSeriesIdentity() {
+		const rows = this.db.prepare("SELECT * FROM metric_series").all();
+		if (rows.length === 0) return;
+		const updatePoints = this.db.prepare("UPDATE metric_points SET series_id = ? WHERE series_id = ?");
+		const updateSeries = this.db.prepare("UPDATE metric_series SET series_id = ?, resource = ? WHERE series_id = ?");
+		this.db.exec("BEGIN");
+		try {
+			for (const row of rows) {
+				const resource = { "service.name": row.service };
+				const nextId = seriesIdentity({
+					name: row.name,
+					unit: row.unit ?? void 0,
+					kind: row.kind,
+					temporality: row.temporality ?? void 0,
+					monotonic: row.monotonic === null ? void 0 : row.monotonic === 1,
+					service: row.service,
+					scope: row.scope_name ? {
+						name: row.scope_name,
+						version: row.scope_version ?? void 0
+					} : void 0,
+					resource,
+					points: []
+				}, parseJson(row.attributes) ?? {});
+				updatePoints.run(nextId, row.series_id);
+				updateSeries.run(nextId, stableJson(resource), row.series_id);
+			}
+			this.db.exec("COMMIT");
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+	}
+	/**
+	* SQLite parses `REGEXP` but ships no implementation — using it without
+	* registering one is a runtime error, not a syntax error. The language offers
+	* regex matching, so the function has to exist.
+	*
+	* An invalid pattern matches nothing rather than throwing: the user is
+	* probably mid-typing, and a thrown error would blank the whole result list.
+	*/
+	registerRegexp() {
+		this.db.function("regexp", (pattern, value) => {
+			if (value == null) return 0;
+			try {
+				return new RegExp(String(pattern)).test(String(value)) ? 1 : 0;
+			} catch {
+				return 0;
+			}
+		});
+	}
+	ingestTraces(traces) {
+		if (traces.length === 0) return;
+		const upsertTrace = this.db.prepare(`
+      INSERT INTO traces (trace_id, correlation_id, service, root_span_id,
+                          start_time, end_time, duration, status, partial)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(trace_id) DO UPDATE SET
+        -- A trace grows as spans arrive: widen the bounds rather than replacing
+        -- them, so a late span cannot shrink the trace it belongs to.
+        start_time = min(start_time, excluded.start_time),
+        end_time   = max(end_time,   excluded.end_time),
+        duration   = max(end_time,   excluded.end_time) - min(start_time, excluded.start_time),
+        status     = CASE WHEN excluded.status = 'ERROR' THEN 'ERROR' ELSE status END,
+        service    = COALESCE(excluded.service, service),
+        root_span_id = CASE
+          WHEN traces.partial = 1 AND excluded.partial = 0
+            THEN COALESCE(excluded.root_span_id, root_span_id)
+          ELSE COALESCE(root_span_id, excluded.root_span_id)
+        END,
+        -- Once the true root has arrived, a delayed partial replay cannot make
+        -- the stored trace provisional again.
+        partial    = min(partial, excluded.partial)
+    `);
+		const upsertSpan = this.db.prepare(`
+      INSERT INTO spans (span_id, trace_id, parent_span_id, name, kind, service,
+                         start_time, end_time, duration, status_code,
+                         status_message, attributes, events, links, scope)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(trace_id, span_id) DO UPDATE SET
+        name           = excluded.name,
+        end_time       = excluded.end_time,
+        duration       = excluded.duration,
+        status_code    = excluded.status_code,
+        status_message = excluded.status_message,
+        attributes     = excluded.attributes,
+        events         = excluded.events,
+        links          = excluded.links
+    `);
+		const upsertAttribute = this.attributeUpsert();
+		const upsertOccurrence = this.attributeOccurrenceUpsert();
+		const clearOccurrences = this.db.prepare("DELETE FROM attribute_occurrences WHERE signal = 'traces' AND entity_id = ?");
+		const clearEvents = this.db.prepare("DELETE FROM span_events WHERE trace_id = ? AND span_id = ?");
+		const clearLinks = this.db.prepare("DELETE FROM span_links WHERE trace_id = ? AND span_id = ?");
+		const insertEvent = this.db.prepare("INSERT INTO span_events (trace_id, span_id, idx, name, timestamp) VALUES (?, ?, ?, ?, ?)");
+		const insertLink = this.db.prepare("INSERT INTO span_links (trace_id, span_id, idx, linked_trace_id, linked_span_id) VALUES (?, ?, ?, ?, ?)");
+		this.db.exec("BEGIN");
+		try {
+			for (const trace of traces) {
+				upsertTrace.run(trace.traceId, trace.correlationId ?? null, trace.service ?? null, trace.rootSpan?.spanId ?? null, trace.startTime, trace.endTime, trace.duration, trace.status, trace.partial ? 1 : 0);
+				for (const span of trace.spans ?? []) {
+					upsertSpan.run(span.spanId, span.traceId, span.parentSpanId ?? null, span.name, span.kind, spanService(span, trace.service), span.startTime, span.endTime, span.duration, span.status?.code ?? "UNSET", span.status?.message ?? null, JSON.stringify(span.attributes ?? {}), span.events?.length ? JSON.stringify(span.events) : null, span.links?.length ? JSON.stringify(span.links) : null, span.scope ? JSON.stringify(span.scope) : null);
+					const entityId = `${span.traceId}:${span.spanId}`;
+					clearOccurrences.run(entityId);
+					this.indexAttributes(upsertAttribute, upsertOccurrence, "traces", entityId, span.attributes ?? {}, span.startTime);
+					clearEvents.run(span.traceId, span.spanId);
+					span.events?.forEach((event, index) => {
+						insertEvent.run(span.traceId, span.spanId, index, event.name, event.timestamp ?? null);
+					});
+					clearLinks.run(span.traceId, span.spanId);
+					span.links?.forEach((link, index) => {
+						insertLink.run(span.traceId, span.spanId, index, link.traceId, link.spanId);
+					});
+				}
+			}
+			this.db.exec("COMMIT");
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+	}
+	/**
+	* Find traces matching a query.
+	*
+	* The filter runs against *spans* and the results are traces: a trace matches
+	* when any of its spans does. That is what makes `http.status_code = 500`
+	* useful — the attribute is on one span, but the thing you want to open is
+	* the trace containing it.
+	*/
+	queryTraces(args) {
+		const parsed = parse(args.query ?? "");
+		if (!parsed.ok) return {
+			traces: [],
+			nextCursor: null,
+			errors: parsed.errors
+		};
+		const { sql: whereSql, params } = compileWhere(parsed.node, SPAN_SCHEMA);
+		const limit = Math.min(MAX_QUERY_PAGE_SIZE, Math.max(1, args.limit ?? DEFAULT_LIMIT));
+		const clauses = [`s.trace_id = t.trace_id`, whereSql];
+		const queryParams = [...params];
+		if (args.window) {
+			clauses.push("t.start_time >= ? AND t.start_time <= ?");
+			queryParams.push(args.window.start, args.window.end);
+		}
+		const cursor = decodeCursor(args.cursor);
+		if (cursor) {
+			clauses.push("(t.start_time < ? OR (t.start_time = ? AND t.trace_id < ?))");
+			queryParams.push(cursor.startTime, cursor.startTime, cursor.traceId);
+		}
+		const rows = this.db.prepare(`SELECT t.* FROM traces t
+         WHERE EXISTS (SELECT 1 FROM spans s WHERE ${clauses.join(" AND ")})
+         ORDER BY t.start_time DESC, t.trace_id DESC
+         LIMIT ?`).all(...queryParams, limit + 1);
+		const hasMore = rows.length > limit;
+		const page = hasMore ? rows.slice(0, limit) : rows;
+		const last = page[page.length - 1];
+		return {
+			traces: this.hydrateTracePage(page),
+			nextCursor: hasMore && last ? encodeCursor({
+				startTime: Number(last.start_time),
+				traceId: last.trace_id
+			}) : null
+		};
+	}
+	ingestLogs(logs) {
+		if (logs.length === 0) return;
+		const upsert = this.db.prepare(`
+      INSERT INTO logs (id, timestamp, service, severity_text, severity_number,
+                        trace_id, span_id, body_text, body_json, attributes,
+                        resource)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO NOTHING
+    `);
+		const upsertAttribute = this.attributeUpsert();
+		const upsertOccurrence = this.attributeOccurrenceUpsert();
+		this.db.exec("BEGIN");
+		try {
+			for (const log of logs) {
+				const structured = typeof log.body === "object" && log.body !== null;
+				const inserted = upsert.run(log.id, log.timestamp, log.resourceName ?? null, log.severityText ?? null, log.severityNumber ?? null, log.traceId ?? null, log.spanId ?? null, structured ? JSON.stringify(log.body) : String(log.body ?? ""), structured ? JSON.stringify(log.body) : null, JSON.stringify(log.attributes ?? {}), log.resource ? JSON.stringify(log.resource) : null);
+				if (Number(inserted.changes) === 0) continue;
+				this.indexAttributes(upsertAttribute, upsertOccurrence, "logs", log.id, log.attributes ?? {}, log.timestamp);
+			}
+			this.db.exec("COMMIT");
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+	}
+	queryLogs(args) {
+		const parsed = parse(args.query ?? "");
+		if (!parsed.ok) return {
+			logs: [],
+			nextCursor: null,
+			errors: parsed.errors
+		};
+		const { sql: whereSql, params } = compileWhere(parsed.node, LOG_SCHEMA);
+		const limit = Math.min(MAX_QUERY_PAGE_SIZE, Math.max(1, args.limit ?? DEFAULT_LIMIT));
+		const clauses = [whereSql];
+		const queryParams = [...params];
+		if (args.window) {
+			clauses.push("timestamp >= ? AND timestamp <= ?");
+			queryParams.push(args.window.start, args.window.end);
+		}
+		const cursor = decodeCursor(args.cursor);
+		if (cursor) {
+			clauses.push("(timestamp < ? OR (timestamp = ? AND id < ?))");
+			queryParams.push(cursor.startTime, cursor.startTime, cursor.traceId);
+		}
+		const rows = this.db.prepare(`SELECT * FROM logs
+         WHERE ${clauses.join(" AND ")}
+         ORDER BY timestamp DESC, id DESC
+         LIMIT ?`).all(...queryParams, limit + 1);
+		const hasMore = rows.length > limit;
+		const page = hasMore ? rows.slice(0, limit) : rows;
+		const last = page[page.length - 1];
+		return {
+			logs: page.map(hydrateLog),
+			nextCursor: hasMore && last ? encodeCursor({
+				startTime: Number(last.timestamp),
+				traceId: last.id
+			}) : null
+		};
+	}
+	countLogs() {
+		const row = this.db.prepare("SELECT count(*) AS n FROM logs").get();
+		return Number(row.n);
+	}
+	/**
+	* Store metric points, grouped into series.
+	*
+	* One series is one chart line: `(name, kind, unit, service, scope, point
+	* attributes)`. Both directions of getting this wrong are bad — too coarse
+	* and every line collapses into one meaningless average, too fine and one
+	* logical series sprouts a new line on every export — so the identity is a
+	* content hash over exactly those fields, with attribute keys sorted so an
+	* exporter's key ordering cannot split a series in two.
+	*/
+	ingestMetrics(streams) {
+		if (streams.length === 0) return;
+		const upsertSeries = this.db.prepare(`
+      INSERT INTO metric_series (series_id, name, unit, description, kind,
+                                 temporality, monotonic, service, scope_name,
+                                 scope_version, resource, attributes)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(series_id) DO UPDATE SET
+        -- Description and unit can be filled in by a later export; the identity
+        -- fields cannot change without producing a different series_id.
+        description = COALESCE(excluded.description, description),
+        unit        = COALESCE(excluded.unit, unit),
+        temporality = COALESCE(excluded.temporality, temporality)
+    `);
+		const upsertPoint = this.db.prepare(`
+      INSERT INTO metric_points (series_id, timestamp, start_timestamp, value,
+                                 count, sum, min, max, bucket_counts,
+                                 explicit_bounds, exp_scale, zero_count,
+                                 zero_threshold, positive_buckets,
+                                 negative_buckets, quantiles, exemplars)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(series_id, timestamp) DO UPDATE SET
+        value           = excluded.value,
+        count           = excluded.count,
+        sum             = excluded.sum,
+        min             = excluded.min,
+        max             = excluded.max,
+        bucket_counts   = excluded.bucket_counts,
+        explicit_bounds = excluded.explicit_bounds,
+        exp_scale       = excluded.exp_scale,
+        zero_count      = excluded.zero_count,
+        zero_threshold  = excluded.zero_threshold,
+        positive_buckets = excluded.positive_buckets,
+        negative_buckets = excluded.negative_buckets,
+        quantiles       = excluded.quantiles,
+        exemplars       = excluded.exemplars
+    `);
+		this.db.exec("BEGIN");
+		try {
+			for (const stream of streams) for (const point of stream.points) {
+				const seriesId = seriesIdentity(stream, point.attributes);
+				upsertSeries.run(seriesId, stream.name, stream.unit ?? null, stream.description ?? null, stream.kind, stream.temporality ?? null, stream.monotonic === void 0 ? null : stream.monotonic ? 1 : 0, stream.service, stream.scope?.name ?? null, stream.scope?.version ?? null, stableJson(stream.resource), stableJson(point.attributes));
+				upsertPoint.run(seriesId, point.timestamp, point.startTimestamp ?? null, point.value ?? null, point.count ?? null, point.sum ?? null, point.min ?? null, point.max ?? null, point.bucketCounts ? JSON.stringify(point.bucketCounts) : null, point.explicitBounds ? JSON.stringify(point.explicitBounds) : null, point.scale ?? null, point.zeroCount ?? null, point.zeroThreshold ?? null, point.positive ? JSON.stringify(point.positive) : null, point.negative ? JSON.stringify(point.negative) : null, point.quantiles ? JSON.stringify(point.quantiles) : null, point.exemplars ? JSON.stringify(point.exemplars) : null);
+			}
+			this.db.exec("COMMIT");
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+	}
+	/** Every metric name held, for the catalogue the Metrics tab lists. */
+	listMetricNames() {
+		return this.queryMetricCatalog("").metrics;
+	}
+	queryMetricCatalog(query) {
+		const parsed = parse(query);
+		if (!parsed.ok) return {
+			metrics: [],
+			errors: parsed.errors
+		};
+		const compiled = compileWhere(parsed.node, METRIC_SCHEMA);
+		return { metrics: this.db.prepare(`SELECT name, kind, unit, description, count(*) AS series_count
+         FROM metric_series
+         WHERE ${compiled.sql}
+         GROUP BY name, kind
+         ORDER BY name ASC`).all(...compiled.params).map((row) => ({
+			name: row.name,
+			kind: row.kind,
+			unit: row.unit ?? void 0,
+			description: row.description ?? void 0,
+			seriesCount: Number(row.series_count)
+		})) };
+	}
+	/**
+	* The series for one metric, with their points.
+	*
+	* A series whose points all fall outside the window is omitted rather than
+	* returned empty: an empty line in the legend claims data exists where none
+	* does, and the caller cannot tell the two apart.
+	*/
+	queryMetricSeries(args) {
+		const seriesRows = this.db.prepare("SELECT * FROM metric_series WHERE name = ? ORDER BY series_id ASC").all(args.name);
+		const pointsSql = args.window ? `SELECT * FROM metric_points
+         WHERE series_id = ? AND timestamp >= ? AND timestamp <= ?
+         ORDER BY timestamp ASC` : `SELECT * FROM metric_points WHERE series_id = ? ORDER BY timestamp ASC`;
+		const pointsStmt = this.db.prepare(pointsSql);
+		const out = [];
+		for (const row of seriesRows) {
+			const pointRows = args.window ? pointsStmt.all(row.series_id, args.window.start, args.window.end) : pointsStmt.all(row.series_id);
+			if (pointRows.length === 0) continue;
+			out.push({
+				seriesId: row.series_id,
+				name: row.name,
+				unit: row.unit ?? void 0,
+				description: row.description ?? void 0,
+				kind: row.kind,
+				temporality: row.temporality ?? void 0,
+				monotonic: row.monotonic === null ? void 0 : row.monotonic === 1,
+				service: row.service,
+				scope: row.scope_name ? {
+					name: row.scope_name,
+					version: row.scope_version ?? void 0
+				} : void 0,
+				resource: parseJson(row.resource) ?? {},
+				attributes: parseJson(row.attributes) ?? {},
+				points: reduceMetricPoints(pointRows.map(hydratePoint), row.kind, Math.max(4, Math.min(args.maxPoints ?? 2e3, 2e4)), { temporality: row.temporality ?? void 0 })
+			});
+		}
+		return out;
+	}
+	getTrace(traceId) {
+		const row = this.db.prepare("SELECT * FROM traces WHERE trace_id = ?").get(traceId);
+		return row ? this.hydrateTrace(row) : null;
+	}
+	describeTrace(traceId) {
+		const trace = this.db.prepare("SELECT * FROM traces WHERE trace_id = ?").get(traceId);
+		if (!trace) return null;
+		const spans = this.db.prepare(`
+      SELECT span_id, name, service, duration, status_code, attributes
+      FROM spans WHERE trace_id = ? ORDER BY duration DESC
+    `).all(traceId);
+		const operations = /* @__PURE__ */ new Map();
+		const services = /* @__PURE__ */ new Set();
+		const models = /* @__PURE__ */ new Set();
+		let errors = 0;
+		let llmSpans = 0;
+		let totalTokens = 0;
+		for (const span of spans) {
+			operations.set(span.name, (operations.get(span.name) ?? 0) + 1);
+			services.add(span.service ?? "unknown");
+			if (span.status_code === "ERROR") errors++;
+			const attributes = parseJson(span.attributes) ?? {};
+			const model = attributes["gen_ai.response.model"] ?? attributes["gen_ai.request.model"];
+			if (typeof model === "string") {
+				models.add(model);
+				llmSpans++;
+			}
+			const tokens = attributes["gen_ai.usage.total_tokens"] ?? Number(attributes["gen_ai.usage.input_tokens"] ?? 0) + Number(attributes["gen_ai.usage.output_tokens"] ?? 0);
+			totalTokens += Number(tokens) || 0;
+		}
+		return {
+			traceId,
+			serviceName: trace.service ?? "unknown",
+			durationMs: Number(trace.duration),
+			statusCode: trace.status,
+			spanCount: spans.length,
+			errorSpanCount: errors,
+			serviceCount: services.size,
+			llmSpanCount: llmSpans,
+			totalTokens,
+			modelsUsed: [...models].sort(),
+			topOperations: [...operations].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([operation, count]) => ({
+				operation,
+				count
+			})),
+			slowestSpans: spans.slice(0, 5).map((span) => ({
+				spanId: span.span_id,
+				name: span.name,
+				service: span.service ?? "unknown",
+				durationMs: Number(span.duration),
+				deepLink: traceDeepLink(traceId, trace, span.span_id)
+			})),
+			deepLink: traceDeepLink(traceId, trace)
+		};
+	}
+	findSlowest(limit = 10) {
+		return this.db.prepare("SELECT trace_id FROM traces ORDER BY duration DESC LIMIT ?").all(Math.max(1, Math.min(limit, 100))).flatMap((row) => {
+			const projection = this.describeTrace(row.trace_id);
+			return projection ? [projection] : [];
+		});
+	}
+	countSpans() {
+		const row = this.db.prepare("SELECT count(*) AS n FROM spans").get();
+		return Number(row.n);
+	}
+	countTraces() {
+		const row = this.db.prepare("SELECT count(*) AS n FROM traces").get();
+		return Number(row.n);
+	}
+	/**
+	* One row per matching span, for a cohort comparison.
+	*
+	* Attributes plus the first-class columns, because "the slow ones are all
+	* `service=payments`" is exactly the shape of answer wanted and `service` is
+	* a column rather than an attribute. Ids are left out: they take a distinct
+	* value per span, so they can never describe a group, and including them
+	* only gives the ranking noise to wade through.
+	*
+	* Throws on a query that does not parse. Returning an empty cohort instead
+	* would surface as "no difference found", which is a different and much
+	* more misleading answer than "your query is wrong".
+	*/
+	cohortRows(args) {
+		const parsed = parse(args.query ?? "");
+		if (!parsed.ok) throw new Error(`Cohort query did not parse: ${parsed.errors.map((e) => e.message).join("; ")}`);
+		const { sql: whereSql, params } = compileWhere(parsed.node, SPAN_SCHEMA);
+		const clauses = [whereSql];
+		const queryParams = [...params];
+		if (args.window) {
+			clauses.push("s.start_time >= ? AND s.start_time <= ?");
+			queryParams.push(args.window.start, args.window.end);
+		}
+		return this.db.prepare(`SELECT s.service, s.name, s.kind, s.duration, s.status_code, s.attributes
+         FROM spans s
+         WHERE ${clauses.join(" AND ")}
+         ORDER BY s.start_time DESC
+         LIMIT ?`).all(...queryParams, Math.min(args.limit ?? COHORT_ROW_LIMIT, COHORT_ROW_LIMIT)).map((row) => ({
+			...parseJson(row.attributes) ?? {},
+			service: row.service ?? "unknown",
+			name: row.name,
+			kind: row.kind,
+			status: row.status_code
+		}));
+	}
+	/**
+	* What the store has actually seen, for the coverage join.
+	*
+	* Both routes in are counted: the `http.route` attribute a framework
+	* integration sets, and the span name, which is what `trace('name', fn)`
+	* produces and is all a non-HTTP entry point ever has. Counting is cheap
+	* here because `attribute_values` already carries per-value totals.
+	*/
+	observedSpans() {
+		const routeRows = this.db.prepare(`SELECT value_text AS value, seen_count AS count FROM attribute_values
+         WHERE signal = 'traces' AND key = 'http.route'`).all();
+		const nameRows = this.db.prepare("SELECT name, count(*) AS count FROM spans GROUP BY name").all();
+		return {
+			routeCounts: Object.fromEntries(routeRows.map((row) => [row.value, Number(row.count)])),
+			spanNameCounts: Object.fromEntries(nameRows.map((row) => [row.name, Number(row.count)]))
+		};
+	}
+	/** Query fields currently present, for editor completion. */
+	listQueryFields(signal, limit = 200) {
+		const schema = signal === "traces" ? SPAN_SCHEMA : LOG_SCHEMA;
+		const table = signal === "traces" ? "spans" : "logs";
+		const rows = this.db.prepare(`SELECT DISTINCT json_each.key AS key
+         FROM ${table}, json_each(${table}.attributes)
+         WHERE json_valid(${table}.attributes)
+         ORDER BY key ASC
+         LIMIT ?`).all(Math.max(1, Math.min(limit, 500)));
+		return [.../* @__PURE__ */ new Set([...Object.keys(schema.columns), ...rows.map((row) => row.key)])];
+	}
+	/**
+	* Values of one attribute paired with another on the same entity.
+	*
+	* `searchAttributes` matches on value text, which cannot answer "what arms
+	* does this experiment have". Pairing two keys across the same span can, and
+	* that is what turns a pair of cohorts into something the viewer offers
+	* rather than something the reader has to type.
+	*
+	* Rows arrive grouped by `key`, each group's values commonest first, so a
+	* caller can build the groups in one pass and take the two commonest as a
+	* default pair.
+	*
+	* The join runs over `attribute_occurrences`, not the `attribute_values`
+	* dictionary: occurrences are deleted with their span, so retention prunes
+	* them, and they carry the entity a value was seen on, so an arm is only
+	* offered for the experiment it actually ran under. The dictionary can do
+	* neither — it counts values for the lifetime of the database and forgets
+	* which span each came from, which would offer arms belonging to a different
+	* experiment and experiments whose spans are long gone.
+	*/
+	pairedAttributeValues(signal, key, pairedKey, limit = 200) {
+		return this.db.prepare(`
+      SELECT a.value_json AS value_json, b.value_json AS paired_json, count(*) AS count
+      FROM attribute_occurrences a
+      JOIN attribute_occurrences b
+        ON b.signal = a.signal AND b.entity_id = a.entity_id AND b.key = ?
+      WHERE a.signal = ? AND a.key = ?
+      GROUP BY a.value_json, b.value_json
+      ORDER BY value_json ASC, count DESC, paired_json ASC
+      LIMIT ?
+    `).all(pairedKey, signal, key, Math.max(1, Math.min(limit, 500))).map((row) => ({
+			value: JSON.parse(row.value_json),
+			paired: JSON.parse(row.paired_json),
+			count: Number(row.count)
+		}));
+	}
+	searchAttributes(signal, value, limit = 50) {
+		return this.db.prepare(`
+      SELECT key, value_json, seen_count
+      FROM attribute_values
+      WHERE signal = ? AND value_text LIKE ? ESCAPE '\\'
+      ORDER BY seen_count DESC, key ASC
+      LIMIT ?
+    `).all(signal, `%${escapeLike(value)}%`, Math.max(1, Math.min(limit, 200))).map((row) => ({
+			key: row.key,
+			value: parseJson(row.value_json),
+			count: Number(row.seen_count)
+		}));
+	}
+	attributeUpsert() {
+		return this.db.prepare(`
+      INSERT INTO attribute_values (signal, key, value_json, value_text, last_seen)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(signal, key, value_json) DO UPDATE SET
+        seen_count = seen_count + 1,
+        last_seen = max(last_seen, excluded.last_seen)
+    `);
+	}
+	attributeOccurrenceUpsert() {
+		return this.db.prepare(`
+      INSERT INTO attribute_occurrences(signal, entity_id, key, value_json)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(signal, entity_id, key) DO UPDATE SET value_json = excluded.value_json
+    `);
+	}
+	indexAttributes(statement, occurrence, signal, entityId, attributes, timestamp) {
+		for (const [key, value] of Object.entries(attributes)) {
+			const encoded = JSON.stringify(value);
+			statement.run(signal, key, encoded, String(value), timestamp);
+			occurrence.run(signal, entityId, key, encoded);
+		}
+	}
+	/**
+	* Index the events and links already sitting in the span JSON.
+	*
+	* A `--db` file written before these tables existed holds spans whose events
+	* no query can reach. Reading them out of the JSON on open is what makes
+	* `event.name = …` work against telemetry captured yesterday. Keyed on the
+	* table being empty while spans exist, so it runs once rather than on every
+	* open.
+	*/
+	backfillSpanChildren() {
+		const pending = this.db.prepare(`SELECT (SELECT count(*) FROM spans WHERE events IS NOT NULL OR links IS NOT NULL) AS carriers,
+                (SELECT count(*) FROM span_events) AS events,
+                (SELECT count(*) FROM span_links) AS links`).get();
+		if (Number(pending.carriers) === 0) return;
+		if (Number(pending.events) > 0 || Number(pending.links) > 0) return;
+		this.db.exec(`
+      INSERT OR IGNORE INTO span_events(trace_id, span_id, idx, name, timestamp)
+      SELECT spans.trace_id, spans.span_id, json_each.key,
+             json_extract(json_each.value, '$.name'),
+             json_extract(json_each.value, '$.timestamp')
+      FROM spans, json_each(spans.events)
+      WHERE spans.events IS NOT NULL AND json_valid(spans.events)
+        AND json_extract(json_each.value, '$.name') IS NOT NULL;
+      INSERT OR IGNORE INTO span_links(trace_id, span_id, idx, linked_trace_id, linked_span_id)
+      SELECT spans.trace_id, spans.span_id, json_each.key,
+             json_extract(json_each.value, '$.traceId'),
+             json_extract(json_each.value, '$.spanId')
+      FROM spans, json_each(spans.links)
+      WHERE spans.links IS NOT NULL AND json_valid(spans.links)
+        AND json_extract(json_each.value, '$.traceId') IS NOT NULL;
+    `);
+	}
+	backfillAttributeDictionary() {
+		const row = this.db.prepare("SELECT count(*) AS n FROM attribute_values").get();
+		if (Number(row.n) === 0) this.db.exec(`
+      INSERT OR IGNORE INTO attribute_values(signal, key, value_json, value_text, seen_count, last_seen)
+      SELECT 'traces', json_each.key, json_quote(json_each.value), CAST(json_each.value AS TEXT), count(*), max(spans.start_time)
+      FROM spans, json_each(spans.attributes) GROUP BY json_each.key, json_quote(json_each.value);
+      INSERT OR IGNORE INTO attribute_values(signal, key, value_json, value_text, seen_count, last_seen)
+      SELECT 'logs', json_each.key, json_quote(json_each.value), CAST(json_each.value AS TEXT), count(*), max(logs.timestamp)
+      FROM logs, json_each(logs.attributes) GROUP BY json_each.key, json_quote(json_each.value);
+    `);
+		const occurrences = this.db.prepare("SELECT count(*) AS n FROM attribute_occurrences").get();
+		if (Number(occurrences.n) === 0) this.db.exec(`
+      INSERT OR IGNORE INTO attribute_occurrences(signal, entity_id, key, value_json)
+      SELECT 'traces', spans.trace_id || ':' || spans.span_id, json_each.key, json_quote(json_each.value)
+      FROM spans, json_each(spans.attributes);
+      INSERT OR IGNORE INTO attribute_occurrences(signal, entity_id, key, value_json)
+      SELECT 'logs', logs.id, json_each.key, json_quote(json_each.value)
+      FROM logs, json_each(logs.attributes);
+    `);
+	}
+	/**
+	* Prune the oldest traces past the row cap, and their spans with them.
+	*
+	* Spans are deleted in the same transaction as their traces: a pruned trace
+	* that left its spans behind would leave rows that no query can reach and no
+	* later sweep would find, since every sweep starts from `traces`.
+	*/
+	enforceRetention() {
+		this.enforceMetricRetention();
+		this.enforceLogRetention();
+		if (this.maxTraces <= 0) {
+			this.enforceByteRetention();
+			return;
+		}
+		const total = this.countTraces();
+		if (total <= this.maxTraces) {
+			this.enforceByteRetention();
+			return;
+		}
+		const excess = total - this.maxTraces;
+		this.db.exec("BEGIN");
+		try {
+			const doomed = this.db.prepare(`SELECT trace_id FROM traces
+           ORDER BY start_time ASC, trace_id ASC
+           LIMIT ?`).all(excess);
+			const deleteSpans = this.db.prepare("DELETE FROM spans WHERE trace_id = ?");
+			const deleteTrace = this.db.prepare("DELETE FROM traces WHERE trace_id = ?");
+			for (const { trace_id } of doomed) {
+				deleteSpans.run(trace_id);
+				deleteTrace.run(trace_id);
+			}
+			this.db.exec("COMMIT");
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+		this.removeOrphanedAttributes();
+		this.enforceByteRetention();
+	}
+	getStats() {
+		const pageCount = pragmaNumber(this.db, "page_count");
+		const freePages = pragmaNumber(this.db, "freelist_count");
+		const pageSize = pragmaNumber(this.db, "page_size");
+		const metric = this.db.prepare("SELECT count(DISTINCT series_id) AS series, count(*) AS points FROM metric_points").get();
+		return {
+			bytesUsed: Math.max(0, pageCount - freePages) * pageSize,
+			maxBytes: this.maxBytes,
+			traceCount: this.countTraces(),
+			spanCount: this.countSpans(),
+			logCount: this.countLogs(),
+			metricSeriesCount: Number(metric.series),
+			metricPointCount: Number(metric.points)
+		};
+	}
+	enforceByteRetention() {
+		if (this.maxBytes <= 0) return;
+		for (let pass = 0; pass < 100 && this.getStats().bytesUsed > this.maxBytes; pass++) {
+			const before = this.getStats();
+			if (before.traceCount + before.logCount + before.metricPointCount === 0) break;
+			this.db.exec("BEGIN");
+			try {
+				const traceBatch = Math.max(1, Math.ceil(before.traceCount * .05));
+				this.db.prepare(`DELETE FROM spans WHERE trace_id IN (
+          SELECT trace_id FROM traces ORDER BY start_time ASC LIMIT ?
+        )`).run(traceBatch);
+				this.db.prepare(`DELETE FROM traces WHERE trace_id IN (
+          SELECT trace_id FROM traces ORDER BY start_time ASC LIMIT ?
+        )`).run(traceBatch);
+				this.db.prepare(`DELETE FROM logs WHERE id IN (
+          SELECT id FROM logs ORDER BY timestamp ASC LIMIT ?
+        )`).run(Math.max(1, Math.ceil(before.logCount * .05)));
+				this.db.prepare(`DELETE FROM metric_points WHERE rowid IN (
+          SELECT rowid FROM metric_points ORDER BY timestamp ASC LIMIT ?
+        )`).run(Math.max(1, Math.ceil(before.metricPointCount * .05)));
+				this.db.exec(`DELETE FROM metric_series WHERE series_id NOT IN (
+          SELECT DISTINCT series_id FROM metric_points
+        )`);
+				this.db.exec("COMMIT");
+			} catch (error) {
+				this.db.exec("ROLLBACK");
+				throw error;
+			}
+			this.removeOrphanedAttributes();
+		}
+	}
+	/**
+	* Trim each series to its newest `maxMetricPoints`.
+	*
+	* Per series, not globally: a global cap would let one chatty instrument
+	* evict every other series, blanking the quiet chart someone was watching.
+	*/
+	enforceMetricRetention() {
+		if (this.maxMetricPoints <= 0) return;
+		this.db.exec("BEGIN");
+		try {
+			this.db.prepare(`DELETE FROM metric_points
+           WHERE rowid IN (
+             SELECT rowid FROM (
+               SELECT rowid,
+                      row_number() OVER (
+                        PARTITION BY series_id ORDER BY timestamp DESC
+                      ) AS rn
+               FROM metric_points
+             ) WHERE rn > ?
+           )`).run(this.maxMetricPoints);
+			this.db.exec("COMMIT");
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+	}
+	/** Trim the log table to its newest `maxLogs` rows. */
+	enforceLogRetention() {
+		if (this.maxLogs <= 0) return;
+		const total = this.countLogs();
+		if (total <= this.maxLogs) return;
+		this.db.prepare(`DELETE FROM logs WHERE id IN (
+           SELECT id FROM logs ORDER BY timestamp ASC, id ASC LIMIT ?
+         )`).run(total - this.maxLogs);
+		this.removeOrphanedAttributes();
+	}
+	removeOrphanedAttributes() {
+		this.db.exec(`
+      DELETE FROM attribute_occurrences
+      WHERE signal = 'logs' AND entity_id NOT IN (SELECT id FROM logs);
+      DELETE FROM attribute_occurrences
+      WHERE signal = 'traces' AND entity_id NOT IN (
+        SELECT trace_id || ':' || span_id FROM spans
+      );
+      DELETE FROM span_events WHERE trace_id || ':' || span_id NOT IN (
+        SELECT trace_id || ':' || span_id FROM spans
+      );
+      DELETE FROM span_links WHERE trace_id || ':' || span_id NOT IN (
+        SELECT trace_id || ':' || span_id FROM spans
+      );
+    `);
+	}
+	clear() {
+		this.db.exec("DELETE FROM spans; DELETE FROM traces; DELETE FROM logs; DELETE FROM metric_points; DELETE FROM metric_series; DELETE FROM attribute_values; DELETE FROM attribute_occurrences; DELETE FROM span_events; DELETE FROM span_links;");
+	}
+	clearSignal(signal) {
+		if (signal === "traces") this.db.exec("DELETE FROM spans; DELETE FROM traces; DELETE FROM attribute_values WHERE signal = 'traces'; DELETE FROM attribute_occurrences WHERE signal = 'traces'; DELETE FROM span_events; DELETE FROM span_links;");
+		else if (signal === "logs") this.db.exec("DELETE FROM logs; DELETE FROM attribute_values WHERE signal = 'logs'; DELETE FROM attribute_occurrences WHERE signal = 'logs';");
+		else this.db.exec("DELETE FROM metric_points; DELETE FROM metric_series;");
+	}
+	deleteMetric(name) {
+		const ids = this.db.prepare("SELECT series_id FROM metric_series WHERE name = ?").all(name);
+		const removePoints = this.db.prepare("DELETE FROM metric_points WHERE series_id = ?");
+		this.db.exec("BEGIN");
+		try {
+			for (const { series_id: id } of ids) removePoints.run(id);
+			this.db.prepare("DELETE FROM metric_series WHERE name = ?").run(name);
+			this.db.exec("COMMIT");
+			return ids.length;
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+	}
+	deleteTraces(traceIds) {
+		const ids = [...new Set(traceIds)].slice(0, 1e3);
+		const removeSpans = this.db.prepare("DELETE FROM spans WHERE trace_id = ?");
+		const removeTrace = this.db.prepare("DELETE FROM traces WHERE trace_id = ?");
+		let deleted = 0;
+		this.db.exec("BEGIN");
+		try {
+			for (const id of ids) {
+				removeSpans.run(id);
+				deleted += Number(removeTrace.run(id).changes);
+			}
+			this.db.exec("COMMIT");
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+		this.removeOrphanedAttributes();
+		return deleted;
+	}
+	close() {
+		try {
+			this.db.close();
+		} catch {}
+	}
+	/**
+	* Hydrate a page of traces with one span query rather than one per trace.
+	*
+	* A list of 100 traces was 101 statements: the page, then a `SELECT` per
+	* trace. Grouping in memory costs the same rows and one round of planning.
+	* Ordering is `trace_id, start_time` so each group arrives already in the
+	* order a waterfall draws it, which is what the list-hydration test pins.
+	*/
+	hydrateTracePage(rows) {
+		if (rows.length === 0) return [];
+		const placeholders = rows.map(() => "?").join(", ");
+		const spanRows = this.db.prepare(`SELECT * FROM spans WHERE trace_id IN (${placeholders})
+         ORDER BY trace_id ASC, start_time ASC`).all(...rows.map((row) => row.trace_id));
+		const byTrace = /* @__PURE__ */ new Map();
+		for (const spanRow of spanRows) {
+			const list = byTrace.get(spanRow.trace_id);
+			if (list) list.push(hydrateSpan(spanRow));
+			else byTrace.set(spanRow.trace_id, [hydrateSpan(spanRow)]);
+		}
+		return rows.map((row) => this.assembleTrace(row, byTrace.get(row.trace_id) ?? []));
+	}
+	hydrateTrace(row) {
+		const spanRows = this.db.prepare("SELECT * FROM spans WHERE trace_id = ? ORDER BY start_time ASC").all(row.trace_id);
+		return this.assembleTrace(row, spanRows.map(hydrateSpan));
+	}
+	/** The row-to-trace mapping, shared by the single and batched paths. */
+	assembleTrace(row, spans) {
+		return {
+			traceId: row.trace_id,
+			correlationId: row.correlation_id ?? row.trace_id,
+			service: row.service ?? "unknown",
+			spans,
+			rootSpan: spans.find((s) => s.spanId === row.root_span_id) ?? spans[0],
+			startTime: Number(row.start_time),
+			endTime: Number(row.end_time),
+			duration: Number(row.duration),
+			status: row.status,
+			partial: row.partial === 1
+		};
+	}
+};
+function hydrateLog(row) {
+	const structured = row.body_json ? parseJson(row.body_json) : void 0;
+	return {
+		id: row.id,
+		timestamp: Number(row.timestamp),
+		body: structured ?? row.body_text,
+		resourceName: row.service ?? void 0,
+		severityText: row.severity_text ?? void 0,
+		severityNumber: row.severity_number ?? void 0,
+		traceId: row.trace_id ?? void 0,
+		spanId: row.span_id ?? void 0,
+		attributes: parseJson(row.attributes) ?? {},
+		resource: parseJson(row.resource)
+	};
+}
+function hydratePoint(row) {
+	return {
+		timestamp: Number(row.timestamp),
+		startTimestamp: row.start_timestamp === null ? void 0 : Number(row.start_timestamp),
+		attributes: {},
+		value: row.value ?? void 0,
+		count: row.count ?? void 0,
+		sum: row.sum ?? void 0,
+		min: row.min ?? void 0,
+		max: row.max ?? void 0,
+		bucketCounts: parseJson(row.bucket_counts),
+		explicitBounds: parseJson(row.explicit_bounds),
+		scale: row.exp_scale ?? void 0,
+		zeroCount: row.zero_count ?? void 0,
+		zeroThreshold: row.zero_threshold ?? void 0,
+		positive: parseJson(row.positive_buckets),
+		negative: parseJson(row.negative_buckets),
+		quantiles: parseJson(row.quantiles),
+		exemplars: parseJson(row.exemplars)
+	};
+}
+/**
+* Content hash identifying one series.
+*
+* Attribute keys are sorted before hashing so an exporter that emits the same
+* attributes in a different order — which nothing forbids — cannot split one
+* logical series into two chart lines.
+*/
+function seriesIdentity(stream, attributes) {
+	return createHash("sha256").update([
+		stream.name,
+		stream.kind,
+		stream.unit ?? "",
+		stream.service,
+		stream.scope?.name ?? "",
+		stream.scope?.version ?? "",
+		stableJson(stream.resource),
+		stableJson(attributes)
+	].join("\0")).digest("hex").slice(0, 32);
+}
+/** JSON with keys sorted, so equal maps always serialize identically. */
+function stableJson(value) {
+	const sorted = {};
+	for (const key of Object.keys(value).sort()) sorted[key] = value[key];
+	return JSON.stringify(sorted);
+}
+function hydrateSpan(row) {
+	return {
+		spanId: row.span_id,
+		traceId: row.trace_id,
+		parentSpanId: row.parent_span_id ?? void 0,
+		name: row.name,
+		kind: row.kind,
+		startTime: Number(row.start_time),
+		endTime: Number(row.end_time),
+		duration: Number(row.duration),
+		attributes: parseJson(row.attributes) ?? {},
+		status: {
+			code: row.status_code,
+			message: row.status_message ?? void 0
+		},
+		events: parseJson(row.events) ?? [],
+		links: parseJson(row.links) ?? void 0,
+		scope: parseJson(row.scope) ?? void 0
+	};
+}
+/** Prefer the service that produced the span, falling back to its trace root. */
+function spanService(span, traceService) {
+	const service = span.attributes?.["service.name"];
+	return typeof service === "string" && service.length > 0 ? service : traceService ?? null;
+}
+/**
+* Decode stored JSON, tolerating corruption.
+*
+* A single unparseable attribute blob should cost one span its attributes, not
+* fail the whole query — which is what a throw here would do.
+*/
+function parseJson(text) {
+	if (!text) return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+function pragmaNumber(db, name) {
+	const row = db.prepare(`PRAGMA ${name}`).get();
+	return Number(Object.values(row)[0] ?? 0);
+}
+function escapeLike(value) {
+	return value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+}
+function encodeCursor(cursor) {
+	return Buffer.from(`${cursor.startTime}:${cursor.traceId}`).toString("base64url");
+}
+/** Decode a cursor, treating anything malformed as "start from the beginning". */
+function decodeCursor(raw) {
+	if (!raw) return null;
+	try {
+		const text = Buffer.from(raw, "base64url").toString("utf8");
+		const separator = text.indexOf(":");
+		if (separator < 0) return null;
+		const startTime = Number(text.slice(0, separator));
+		const traceId = text.slice(separator + 1);
+		if (!Number.isFinite(startTime) || !traceId) return null;
+		return {
+			startTime,
+			traceId
+		};
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/server/otlp-types.ts
+/**
+* An exporter's payload, read as the envelope it claims to be.
+*
+* SAFETY: this is the one place the receiver trusts the wire. Every field of
+* every envelope above is optional, so a payload that is not what it claims
+* reads back as empty arrays and undefined fields rather than throwing - which
+* is what the callers below rely on when they find no spans to add.
+*/
+function otlpEnvelope(payload) {
+	if (typeof payload !== "object" || payload === null) return void 0;
+	return payload;
+}
+
+//#endregion
+//#region src/server/otlp.ts
+function resolveOtlpValue(v) {
+	if (!v) return void 0;
+	if (v.stringValue !== void 0) return v.stringValue;
+	if (v.boolValue !== void 0) return v.boolValue;
+	if (v.intValue !== void 0) return Number(v.intValue);
+	if (v.doubleValue !== void 0) return v.doubleValue;
+	if (v.bytesValue !== void 0) return v.bytesValue;
+	if (v.arrayValue?.values) return v.arrayValue.values.map(resolveOtlpValue);
+	if (v.kvlistValue?.values) return flattenAttributes(v.kvlistValue.values);
+}
+function flattenAttributes(attrs) {
+	const out = {};
+	if (!attrs) return out;
+	for (const { key, value } of attrs) out[key] = resolveOtlpValue(value);
+	return out;
+}
+/**
+* A log record's body: the text it carried, or the structure it carried when
+* the sender used an OTLP kvlist or array rather than a string.
+*/
+function logBody(body) {
+	const text = asString(body);
+	if (text !== void 0) return text;
+	if (body === void 0 || body === null) return "";
+	const structured = asObject(body);
+	if (!structured) return String(body);
+	return structured;
+}
+/**
+* Attributes handed to the agent layer, whose `Attributes` is OTel's own -
+* scalars and arrays of scalars, nothing nested.
+*
+* SAFETY: a coding agent's metrics and events carry scalar attributes only,
+* so the two shapes agree in practice. A sender that nests one anyway is
+* rendered by the Agents tab as whatever it is rather than being dropped.
+*/
+function agentAttributes(attributes) {
+	return attributes;
+}
+function nanoToMs(nano) {
+	if (!nano) return 0;
+	const ns = BigInt(nano);
+	const ms = ns / 1000000n;
+	const remNs = ns % 1000000n;
+	return Number(ms) + Number(remNs) / 1e6;
+}
+const SPAN_KIND_MAP = /* @__PURE__ */ new Map([
+	[0, "INTERNAL"],
+	[1, "INTERNAL"],
+	[2, "SERVER"],
+	[3, "CLIENT"],
+	[4, "PRODUCER"],
+	[5, "CONSUMER"],
+	["SPAN_KIND_INTERNAL", "INTERNAL"],
+	["SPAN_KIND_SERVER", "SERVER"],
+	["SPAN_KIND_CLIENT", "CLIENT"],
+	["SPAN_KIND_PRODUCER", "PRODUCER"],
+	["SPAN_KIND_CONSUMER", "CONSUMER"]
+]);
+function normalizeHexId(id) {
+	if (!id) return "";
+	if (/^[A-Za-z0-9+/=]+$/.test(id) && !/^[0-9a-f]+$/i.test(id) && (id.length === 12 || id.length === 24 || id.length === 28 || id.length === 44 || id.length === 48)) try {
+		return Buffer.from(id, "base64").toString("hex");
+	} catch {}
+	return id;
+}
+function parseOtlpTraces(payload) {
+	const resourceSpans = otlpEnvelope(payload)?.resourceSpans;
+	if (!resourceSpans || resourceSpans.length === 0) return [];
+	const traceMap = /* @__PURE__ */ new Map();
+	for (const rs of resourceSpans) {
+		const resourceAttrs = flattenAttributes(rs.resource?.attributes);
+		const service = String(resourceAttrs["service.name"] || "unknown");
+		for (const ss of rs.scopeSpans ?? []) {
+			const scope = ss.scope?.name ? {
+				name: ss.scope.name,
+				version: ss.scope.version || void 0
+			} : void 0;
+			for (const span of ss.spans || []) {
+				const traceId = normalizeHexId(span.traceId);
+				if (!traceId) continue;
+				const startMs = nanoToMs(span.startTimeUnixNano);
+				const endMs = nanoToMs(span.endTimeUnixNano);
+				const statusCode = span.status?.code;
+				let status = "UNSET";
+				if (statusCode === 1 || statusCode === "STATUS_CODE_OK") status = "OK";
+				if (statusCode === 2 || statusCode === "STATUS_CODE_ERROR") status = "ERROR";
+				const spanData = {
+					traceId,
+					spanId: normalizeHexId(span.spanId),
+					parentSpanId: normalizeHexId(span.parentSpanId) || void 0,
+					name: span.name || "unknown",
+					kind: SPAN_KIND_MAP.get(span.kind ?? 0) ?? "INTERNAL",
+					startTime: startMs,
+					endTime: endMs,
+					duration: endMs - startMs,
+					attributes: {
+						...resourceAttrs,
+						...flattenAttributes(span.attributes)
+					},
+					status: {
+						code: status,
+						message: span.status?.message
+					},
+					events: (span.events ?? []).map((e) => ({
+						name: e.name || "",
+						timestamp: nanoToMs(e.timeUnixNano),
+						attributes: flattenAttributes(e.attributes)
+					})),
+					links: (span.links ?? []).map((l) => ({
+						traceId: normalizeHexId(l.traceId),
+						spanId: normalizeHexId(l.spanId),
+						attributes: flattenAttributes(l.attributes)
+					})),
+					scope
+				};
+				const existing = traceMap.get(traceId);
+				if (existing) existing.spans.push(spanData);
+				else traceMap.set(traceId, {
+					spans: [spanData],
+					service
+				});
+			}
+		}
+	}
+	const traces = [];
+	for (const [traceId, { spans, service }] of traceMap) {
+		const sorted = spans.sort((a, b) => a.startTime - b.startTime);
+		const { rootSpan, partial } = pickRoot(sorted);
+		const startTime = Math.min(...sorted.map((s) => s.startTime));
+		const endTime = Math.max(...sorted.map((s) => s.endTime));
+		const hasError = sorted.some((s) => s.status.code === "ERROR");
+		const trace = {
+			traceId,
+			correlationId: traceId.slice(0, 16),
+			rootSpan,
+			spans: sorted,
+			startTime,
+			endTime,
+			duration: endTime - startTime,
+			status: hasError ? "ERROR" : "OK",
+			service
+		};
+		if (partial) trace.partial = true;
+		traces.push(trace);
+	}
+	return traces;
+}
+function parseOtlpLogs(payload) {
+	const resourceLogs = otlpEnvelope(payload)?.resourceLogs;
+	if (!resourceLogs) return [];
+	const logs = [];
+	for (const rl of resourceLogs) {
+		const resourceAttrs = flattenAttributes(rl.resource?.attributes);
+		for (const sl of rl.scopeLogs ?? []) for (const rec of sl.logRecords ?? []) {
+			const timestamp = nanoToMs(rec.timeUnixNano || rec.observedTimeUnixNano);
+			const traceId = normalizeHexId(rec.traceId) || void 0;
+			const spanId = normalizeHexId(rec.spanId) || void 0;
+			const body = rec.body ? resolveOtlpValue(rec.body) : "";
+			logs.push({
+				id: `${traceId || "no-trace"}:${spanId || "no-span"}:${timestamp}:${rec.severityNumber || 0}`,
+				traceId,
+				spanId,
+				resourceName: getResourceName(resourceAttrs),
+				severityText: rec.severityText,
+				severityNumber: rec.severityNumber,
+				body: logBody(body),
+				timestamp,
+				attributes: flattenAttributes(rec.attributes),
+				resource: resourceAttrs
+			});
+		}
+	}
+	return logs;
+}
+function countOtlpMetrics(payload) {
+	const resourceMetrics = otlpEnvelope(payload)?.resourceMetrics;
+	if (!resourceMetrics) return 0;
+	let count = 0;
+	for (const rm of resourceMetrics) for (const sm of rm.scopeMetrics ?? []) count += (sm.metrics ?? []).length;
+	return count;
+}
+function extractDataPoints(metric) {
+	const points = [];
+	const numberPoints = metric.sum?.dataPoints ?? metric.gauge?.dataPoints;
+	if (Array.isArray(numberPoints)) for (const dp of numberPoints) {
+		const value = dp.asDouble !== void 0 ? Number(dp.asDouble) : dp.asInt !== void 0 ? Number(dp.asInt) : 0;
+		points.push({
+			value,
+			attributes: agentAttributes(flattenAttributes(dp.attributes)),
+			timestamp: nanoToMs(dp.timeUnixNano || dp.startTimeUnixNano)
+		});
+	}
+	const histPoints = metric.histogram?.dataPoints;
+	if (Array.isArray(histPoints)) for (const dp of histPoints) points.push({
+		value: dp.count !== void 0 ? Number(dp.count) : 0,
+		attributes: agentAttributes(flattenAttributes(dp.attributes)),
+		timestamp: nanoToMs(dp.timeUnixNano || dp.startTimeUnixNano)
+	});
+	return points;
+}
+/**
+* Parse OTLP metrics into structured records with data points + attributes,
+* for the agent layer (and richer metric views). Works for both OTLP/JSON and
+* decoded OTLP/protobuf — they share the same camelCase shape.
+*/
+function readTemporality$1(metric) {
+	const raw = metric.sum?.aggregationTemporality ?? metric.histogram?.aggregationTemporality;
+	if (raw === 2 || raw === "AGGREGATION_TEMPORALITY_CUMULATIVE") return "cumulative";
+	if (raw === 1 || raw === "AGGREGATION_TEMPORALITY_DELTA") return "delta";
+}
+function parseOtlpMetrics(payload) {
+	const resourceMetrics = otlpEnvelope(payload)?.resourceMetrics;
+	if (!resourceMetrics) return [];
+	const records = [];
+	for (const rm of resourceMetrics) {
+		const resource = agentAttributes(flattenAttributes(rm.resource?.attributes));
+		for (const sm of rm.scopeMetrics ?? []) {
+			const scope = sm.scope?.name ? {
+				name: sm.scope.name,
+				version: sm.scope.version || void 0
+			} : void 0;
+			for (const metric of sm.metrics ?? []) records.push({
+				name: metric.name ?? "",
+				unit: metric.unit || void 0,
+				description: metric.description || void 0,
+				temporality: readTemporality$1(metric),
+				dataPoints: extractDataPoints(metric),
+				resource,
+				scope
+			});
+		}
+	}
+	return records;
+}
+/**
+* Parse OTLP logs into `AgentRawEvent`s for the agent layer. Keeps the
+* instrumentation scope and event name (Claude Code emits its events as logs,
+* with the unprefixed name in the `event.name` attribute). Distinct from
+* `parseOtlpLogs`, which feeds the generic Logs tab.
+*/
+function parseOtlpAgentEvents(payload) {
+	const resourceLogs = otlpEnvelope(payload)?.resourceLogs;
+	if (!resourceLogs) return [];
+	const events = [];
+	for (const rl of resourceLogs) {
+		const resource = agentAttributes(flattenAttributes(rl.resource?.attributes));
+		for (const sl of rl.scopeLogs ?? []) {
+			const scope = sl.scope?.name ? {
+				name: sl.scope.name,
+				version: sl.scope.version || void 0
+			} : void 0;
+			for (const rec of sl.logRecords ?? []) {
+				const attributes = agentAttributes(flattenAttributes(rec.attributes));
+				const eventName = rec.eventName || String(attributes["event.name"] ?? "");
+				events.push({
+					eventName,
+					timestamp: nanoToMs(rec.timeUnixNano || rec.observedTimeUnixNano),
+					body: rec.body ? resolveOtlpValue(rec.body) : void 0,
+					attributes,
+					resource,
+					scope
+				});
+			}
+		}
+	}
+	return events;
+}
+async function readJsonBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (chunk) => chunks.push(chunk));
+		req.on("end", () => {
+			try {
+				resolve(JSON.parse(Buffer.concat(chunks).toString()));
+			} catch {
+				reject(/* @__PURE__ */ new Error("Invalid JSON"));
+			}
+		});
+		req.on("error", reject);
+	});
+}
+async function readRawBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (chunk) => chunks.push(chunk));
+		req.on("end", () => resolve(Buffer.concat(chunks)));
+		req.on("error", reject);
+	});
+}
+/**
+* True for OTLP/protobuf bodies. The OpenTelemetry Python/Java/Go SDKs default to
+* `http/protobuf` over OTLP HTTP, sending `application/x-protobuf`; some clients use
+* `application/protobuf`. Anything else (JSON, unset) is treated as OTLP/JSON.
+*/
+function isProtobufContentType(contentType) {
+	if (!contentType) return false;
+	const value = contentType.toLowerCase();
+	return value.includes("application/x-protobuf") || value.includes("application/protobuf");
+}
+/**
+* Below this, gzip costs more than it saves: the header alone is 18 bytes and
+* a small body already fits one segment.
+*/
+const GZIP_MIN_BYTES = 1024;
+/**
+* Send JSON, gzipped when the client accepts it and the body is big enough.
+*
+* A trace payload is mostly repeated keys and near-identical ids and strings,
+* which is the shape deflate handles best: a 4,891-span trace measures 2,078
+* KiB raw against 41 KiB gzipped. Reshaping the payload to dedupe scopes and
+* drop the repeated trace id was measured against this and is not worth doing,
+* since deflate already removes what such a dedupe removes.
+*
+* `res.req` is Node's own back-reference to the request, so the negotiation
+* needs nothing threaded through the twenty-odd call sites.
+*/
+function sendJson(res, status, data) {
+	const body = Buffer.from(JSON.stringify(data), "utf8");
+	if (String(res.req?.headers["accept-encoding"] ?? "").includes("gzip") && body.byteLength >= GZIP_MIN_BYTES) {
+		const packed = gzipSync(body);
+		res.writeHead(status, {
+			"Content-Type": "application/json",
+			"Content-Encoding": "gzip",
+			Vary: "Accept-Encoding",
+			"Content-Length": packed.byteLength
+		});
+		res.end(packed);
+		return;
+	}
+	res.writeHead(status, {
+		"Content-Type": "application/json",
+		Vary: "Accept-Encoding",
+		"Content-Length": body.byteLength
+	});
+	res.end(body);
+}
+
+//#endregion
+//#region src/server/metric-streams.ts
+/** The aggregation arms of a Metric's oneof, in the order we probe them. */
+const ARMS = [
+	["gauge", "gauge"],
+	["sum", "sum"],
+	["histogram", "histogram"],
+	["exponentialHistogram", "exponentialHistogram"],
+	["summary", "summary"]
+];
+function parseOtlpMetricStreams(payload) {
+	const resourceMetrics = otlpEnvelope(payload)?.resourceMetrics;
+	if (!Array.isArray(resourceMetrics)) return [];
+	const streams = [];
+	for (const rm of resourceMetrics) {
+		const resource = flattenAttributes(rm.resource?.attributes);
+		const service = String(resource["service.name"] ?? "unknown");
+		for (const sm of rm.scopeMetrics ?? []) {
+			const scope = sm.scope?.name ? {
+				name: sm.scope.name,
+				version: sm.scope.version || void 0
+			} : void 0;
+			for (const metric of sm.metrics ?? []) {
+				const found = findAggregation(metric);
+				if (!found) continue;
+				const points = (found.aggregation.dataPoints ?? []).map((dp) => readPoint(dp, found.kind));
+				if (points.length === 0) continue;
+				streams.push({
+					name: metric.name ?? "",
+					unit: metric.unit || void 0,
+					description: metric.description || void 0,
+					kind: found.kind,
+					temporality: readTemporality(found.aggregation),
+					monotonic: found.aggregation.isMonotonic,
+					service,
+					scope,
+					resource,
+					points
+				});
+			}
+		}
+	}
+	return streams;
+}
+function findAggregation(metric) {
+	for (const [kind, key] of ARMS) {
+		const aggregation = metric[key];
+		if (aggregation) return {
+			kind,
+			aggregation
+		};
+	}
+}
+function readPoint(dp, kind) {
+	const point = {
+		timestamp: nanoToMs(dp.timeUnixNano || dp.startTimeUnixNano),
+		startTimestamp: dp.startTimeUnixNano ? nanoToMs(dp.startTimeUnixNano) : void 0,
+		attributes: flattenAttributes(dp.attributes)
+	};
+	if (kind === "gauge" || kind === "sum") point.value = readNumber(dp.asDouble) ?? readNumber(dp.asInt) ?? 0;
+	if (kind !== "gauge" && kind !== "sum") {
+		point.count = readNumber(dp.count);
+		point.sum = readNumber(dp.sum);
+		point.min = readNumber(dp.min);
+		point.max = readNumber(dp.max);
+	}
+	if (Array.isArray(dp.bucketCounts)) point.bucketCounts = dp.bucketCounts.map((n) => readNumber(n) ?? 0);
+	if (Array.isArray(dp.explicitBounds)) point.explicitBounds = dp.explicitBounds.map((n) => readNumber(n) ?? 0);
+	if (kind === "exponentialHistogram") {
+		point.scale = readNumber(dp.scale);
+		point.zeroCount = readNumber(dp.zeroCount);
+		point.zeroThreshold = readNumber(dp.zeroThreshold);
+		point.positive = readExponentialBuckets(dp.positive);
+		point.negative = readExponentialBuckets(dp.negative);
+	}
+	if (Array.isArray(dp.quantileValues) && dp.quantileValues.length > 0) point.quantiles = dp.quantileValues.map((q) => ({
+		quantile: q.quantile ?? 0,
+		value: q.value ?? 0
+	}));
+	if (Array.isArray(dp.exemplars) && dp.exemplars.length > 0) point.exemplars = dp.exemplars.map((ex) => ({
+		value: readNumber(ex.asDouble) ?? readNumber(ex.asInt) ?? 0,
+		timestamp: nanoToMs(ex.timeUnixNano),
+		traceId: normalizeHexId(ex.traceId) || void 0,
+		spanId: normalizeHexId(ex.spanId) || void 0
+	}));
+	return point;
+}
+function readExponentialBuckets(buckets) {
+	if (!buckets || !Array.isArray(buckets.bucketCounts)) return void 0;
+	return {
+		offset: buckets.offset ?? 0,
+		bucketCounts: buckets.bucketCounts.map((count) => readNumber(count) ?? 0)
+	};
+}
+/**
+* Read an OTLP number.
+*
+* int64 arrives as a string in OTLP/JSON (it does not survive JSON) and as a
+* number once protobuf is decoded, so both spellings have to work.
+*/
+function readNumber(raw) {
+	if (raw === void 0 || raw === null || raw === "") return void 0;
+	const value = Number(raw);
+	return Number.isFinite(value) ? value : void 0;
+}
+/** 1 = DELTA, 2 = CUMULATIVE; the string enum spelling is handled too. */
+function readTemporality(aggregation) {
+	const raw = aggregation.aggregationTemporality;
+	if (raw === 2 || raw === "AGGREGATION_TEMPORALITY_CUMULATIVE") return "cumulative";
+	if (raw === 1 || raw === "AGGREGATION_TEMPORALITY_DELTA") return "delta";
+}
+
+//#endregion
+//#region src/server/server.ts
+/** How often the store is pruned past its caps. */
+const DEFAULT_RETENTION_INTERVAL_MS = 3e4;
+/**
+* Traces read when aggregating errors.
+*
+* Deliberately large: an error group's count is only right if every occurrence
+* in the window is seen, and a page-sized read would under-report the common
+* failures most — the ones with occurrences past the page boundary.
+*/
+var DevtoolsServer = class {
+	wss;
+	wsPath;
+	loopbackOnly;
+	clients = /* @__PURE__ */ new Set();
+	httpServer;
+	traces = [];
+	logs = [];
+	agentSessions = /* @__PURE__ */ new Map();
+	errorAggregator = new ErrorAggregator();
+	limits;
+	verbose;
+	_port;
+	onData;
+	/**
+	* Durable store. The in-memory `traces`/`logs` arrays above remain the live
+	* tail — what a freshly-connected client is handed and what streams over WS —
+	* while the store answers queries and outlives the process. Both are written
+	* on every ingest; neither is derived from the other.
+	*/
+	store;
+	retentionTimer = null;
+	constructor(options = {}) {
+		this.limits = resolveTelemetryLimits(options);
+		this.verbose = options.verbose ?? false;
+		this._port = options.port ?? 4318;
+		this.onData = options.onData;
+		this.store = new DevtoolsStore({
+			path: options.dbPath,
+			maxTraces: options.maxTraces,
+			maxLogs: options.maxLogs,
+			maxBytes: options.maxDbBytes
+		});
+		this.startRetentionLoop(options.retentionIntervalMs);
+		this.httpServer = options.server ?? createServer();
+		const loopbackOnly = options.host == null || hostHeaderIsLoopback(options.host);
+		this.wsPath = options.path ?? "/ws";
+		this.loopbackOnly = loopbackOnly;
+		this.wss = new WebSocketServer({
+			noServer: true,
+			perMessageDeflate: { threshold: 1024 }
+		});
+		this.attachWebSocket(this.httpServer);
+		this.wss.on("error", (err) => {
+			if (this.httpServer.listening) throw err;
+		});
+		this.wss.on("connection", (ws) => {
+			this.clients.add(ws);
+			this.log(`Client connected (${this.clients.size} total)`);
+			const data = this.getCurrentData();
+			if (data.traces.length > 0 || data.logs.length > 0 || data.errors.length > 0 || (data.agents?.length ?? 0) > 0) ws.send(JSON.stringify(data));
+			ws.on("close", () => {
+				this.clients.delete(ws);
+				this.log(`Client disconnected (${this.clients.size} total)`);
+			});
+		});
+		if (!options.server) {
+			const listening = () => {
+				const addr = this.httpServer.address();
+				if (addr && typeof addr === "object") this._port = addr.port;
+				this.log(`WebSocket server listening on port ${this._port}`);
+			};
+			if (options.host == null) this.httpServer.listen(this._port, listening);
+			else this.httpServer.listen(this._port, options.host, listening);
+		}
+	}
+	get port() {
+		const addr = this.httpServer.address();
+		if (addr && typeof addr === "object") return addr.port;
+		return this._port;
+	}
+	get clientCount() {
+		return this.clients.size;
+	}
+	addTrace(trace) {
+		const existing = this.traces.find((t) => t.traceId === trace.traceId);
+		const merged = existing ?? trace;
+		let newSpans = trace.spans;
+		if (existing) {
+			const existingSpanIds = new Set(existing.spans.map((s) => s.spanId));
+			newSpans = [];
+			for (const span of trace.spans) if (!existingSpanIds.has(span.spanId)) {
+				existing.spans.push(span);
+				newSpans.push(span);
+			}
+			existing.startTime = Math.min(existing.startTime, trace.startTime);
+			existing.endTime = Math.max(existing.endTime, trace.endTime);
+			existing.duration = existing.endTime - existing.startTime;
+			if (trace.status === "ERROR") existing.status = "ERROR";
+			existing.spans.sort((a, b) => a.startTime - b.startTime);
+			const { rootSpan, partial } = pickRoot(existing.spans);
+			existing.rootSpan = rootSpan;
+			if (partial) existing.partial = true;
+			else {
+				delete existing.partial;
+				const rootService = rootSpan.attributes?.["service.name"];
+				if (typeof rootService === "string" && rootService.length > 0) existing.service = rootService;
+			}
+		} else this.traces = appendWithLimit(this.traces, trace, this.limits.maxTraceCount);
+		if (newSpans.length > 0) this.errorAggregator.addErrorsFromTrace({
+			...trace,
+			spans: newSpans
+		});
+		this.store.ingestTraces([merged]);
+		this.broadcast({
+			traces: [merged],
+			logs: [],
+			errors: this.errorAggregator.getErrorGroups()
+		});
+	}
+	addTraces(traces) {
+		for (const trace of traces) this.addTrace(trace);
+	}
+	addLog(log) {
+		this.logs = appendWithLimit(this.logs, log, this.limits.maxLogCount);
+		this.store.ingestLogs([log]);
+		this.broadcast({
+			traces: [],
+			logs: [log],
+			errors: this.errorAggregator.getErrorGroups()
+		});
+	}
+	addLogs(logs) {
+		this.logs = appendManyWithLimit(this.logs, logs, this.limits.maxLogCount);
+		this.store.ingestLogs(logs);
+		this.broadcast({
+			traces: [],
+			logs,
+			errors: this.errorAggregator.getErrorGroups()
+		});
+	}
+	/** Ingest one decoded OTLP request, regardless of its transport. */
+	/**
+	* Serve the live tail on another HTTP listener.
+	*
+	* A loopback bind produces two listeners, one per IP family, because
+	* `localhost` resolves to `::1` on macOS and `127.0.0.1` elsewhere. The HTTP
+	* routes were attached to both from the start and the WebSocket was not, so
+	* the widget connected over one address and silently failed over the other:
+	* telemetry visible, live tail dead, and nothing in the UI saying why.
+	*
+	* Both listeners hand their upgrades to the same `WebSocketServer`, so there
+	* is still one client set and one broadcast.
+	*/
+	attachWebSocket(server) {
+		server.on("upgrade", (req, socket, head) => {
+			if ((req.url ?? "/").split("?")[0] !== this.wsPath) {
+				socket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
+				socket.destroy();
+				return;
+			}
+			if (!allowSensitiveRequest({
+				origin: req.headers.origin,
+				host: req.headers.host
+			}, this.loopbackOnly)) {
+				socket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
+				socket.destroy();
+				return;
+			}
+			this.wss.handleUpgrade(req, socket, head, (ws) => {
+				this.wss.emit("connection", ws, req);
+			});
+		});
+	}
+	ingestOtlp(signal, payload) {
+		if (signal === "traces") {
+			const traces = parseOtlpTraces(payload);
+			this.addTraces(traces);
+			return traces.length;
+		}
+		if (signal === "logs") {
+			const logs = parseOtlpLogs(payload);
+			this.addLogs(logs);
+			this.ingestAgentEvents(parseOtlpAgentEvents(payload));
+			return logs.length;
+		}
+		this.ingestAgentMetrics(parseOtlpMetrics(payload));
+		this.ingestMetricStreams(parseOtlpMetricStreams(payload));
+		return countOtlpMetrics(payload);
+	}
+	/** Fold decoded agent log events into sessions and broadcast the full set. */
+	ingestAgentEvents(records) {
+		if (records.length === 0) return;
+		ingestAgentEvents(this.agentSessions, records);
+		this.broadcastAgents();
+	}
+	/**
+	* Store decoded metric streams for the Metrics tab.
+	*
+	* Separate from `ingestAgentMetrics`: that folds the same OTLP batch into
+	* coding-agent sessions through a counter-shaped model, while this keeps the
+	* full data points — buckets, quantiles, exemplars — that charts need.
+	*/
+	ingestMetricStreams(streams) {
+		if (streams.length === 0) return;
+		this.store.ingestMetrics(streams);
+	}
+	/** Metric catalogue: every metric name held, with its kind and series count. */
+	listMetricNames() {
+		return this.store.listMetricNames();
+	}
+	queryMetricCatalog(query) {
+		return this.store.queryMetricCatalog(query);
+	}
+	/** The series for one metric, with their points. */
+	queryMetricSeries(args) {
+		return this.store.queryMetricSeries(args);
+	}
+	/** Fold decoded agent metric records into sessions and broadcast the full set. */
+	ingestAgentMetrics(records) {
+		if (records.length === 0) return;
+		ingestAgentMetrics(this.agentSessions, records);
+		this.broadcastAgents();
+	}
+	broadcastAgents() {
+		this.broadcast({
+			traces: [],
+			logs: [],
+			errors: this.errorAggregator.getErrorGroups(),
+			agents: [...this.agentSessions.values()]
+		});
+	}
+	/**
+	* Run a query against the durable store.
+	*
+	* Distinct from `getCurrentData()`, which returns the live tail: this reaches
+	* the whole retained history, which is normally far larger than the tail and
+	* is the only way to see anything from before the process restarted.
+	*/
+	queryTraces(args) {
+		return this.store.queryTraces(args);
+	}
+	/** Route and span-name counts, for the instrumentation coverage join. */
+	observedSpans() {
+		return this.store.observedSpans();
+	}
+	/** One row per matching span, as the population for a cohort comparison. */
+	cohortRows(args) {
+		return this.store.cohortRows(args);
+	}
+	/**
+	* Aggregate errors from the store for a window and query.
+	*
+	* A fresh aggregator over whatever the store returns, rather than a second
+	* implementation: the grouping, fingerprinting and sampling rules are the
+	* same ones the live path uses, so the two cannot describe the same failure
+	* differently.
+	*
+	* The live `errorAggregator` stays as it is — it backs the WS full-state
+	* broadcast, which has no window and needs none.
+	*/
+	queryErrors(args) {
+		const aggregator = new ErrorAggregator();
+		const seenCursors = /* @__PURE__ */ new Set();
+		let cursor = args.cursor;
+		do {
+			const result = this.store.queryTraces({
+				...args,
+				cursor
+			});
+			if (result.errors) return {
+				errors: [],
+				errors_parse: result.errors
+			};
+			for (const trace of result.traces) aggregator.addErrorsFromTrace(trace);
+			cursor = result.nextCursor ?? void 0;
+			if (cursor && seenCursors.has(cursor)) break;
+			if (cursor) seenCursors.add(cursor);
+		} while (cursor);
+		return { errors: aggregator.getErrorGroups() };
+	}
+	/** Run a log query against the durable store. */
+	queryLogs(args) {
+		return this.store.queryLogs(args);
+	}
+	listQueryFields(signal) {
+		return this.store.listQueryFields(signal);
+	}
+	pairedAttributeValues(signal, key, pairedKey, limit) {
+		return this.store.pairedAttributeValues(signal, key, pairedKey, limit);
+	}
+	searchAttributes(signal, value, limit) {
+		return this.store.searchAttributes(signal, value, limit);
+	}
+	getStoreStats() {
+		return this.store.getStats();
+	}
+	describeTrace(traceId) {
+		return this.store.describeTrace(traceId);
+	}
+	findSlowestTraces(limit) {
+		return this.store.findSlowest(limit);
+	}
+	/** Prune the store to its retention cap. Safe to call on a timer. */
+	enforceRetention() {
+		this.store.enforceRetention();
+	}
+	/**
+	* Prune periodically for the life of the server.
+	*
+	* `unref` matters: without it this timer alone keeps the Node process alive,
+	* so a CLI that has finished its work would hang instead of exiting. A
+	* failure is logged rather than thrown — an interval callback that throws
+	* takes the process down, and a missed prune is not worth that.
+	*/
+	startRetentionLoop(intervalMs = DEFAULT_RETENTION_INTERVAL_MS) {
+		if (intervalMs <= 0) return;
+		this.retentionTimer = setInterval(() => {
+			try {
+				this.store.enforceRetention();
+			} catch (error) {
+				this.log(`retention failed: ${String(error)}`);
+			}
+		}, intervalMs);
+		this.retentionTimer.unref?.();
+	}
+	getCurrentData() {
+		return {
+			traces: this.traces,
+			logs: this.logs,
+			errors: this.errorAggregator.getErrorGroups(),
+			agents: [...this.agentSessions.values()]
+		};
+	}
+	clearData() {
+		this.traces = [];
+		this.logs = [];
+		this.agentSessions.clear();
+		this.errorAggregator.clear();
+		this.store.clear();
+	}
+	clearSignal(signal) {
+		this.store.clearSignal(signal);
+		if (signal === "traces") {
+			this.traces = [];
+			this.errorAggregator.clear();
+		} else if (signal === "logs") this.logs = [];
+	}
+	deleteMetric(name) {
+		return this.store.deleteMetric(name);
+	}
+	deleteTraces(traceIds) {
+		const ids = new Set(traceIds);
+		this.traces = this.traces.filter((trace) => !ids.has(trace.traceId));
+		const deleted = this.store.deleteTraces(traceIds);
+		this.errorAggregator.clear();
+		let cursor;
+		do {
+			const page = this.store.queryTraces({
+				query: "",
+				limit: 1e3,
+				cursor
+			});
+			for (const trace of page.traces) this.errorAggregator.addErrorsFromTrace(trace);
+			cursor = page.nextCursor ?? void 0;
+		} while (cursor);
+		return deleted;
+	}
+	broadcast(data) {
+		const msg = JSON.stringify(data.traces?.length ? {
+			...data,
+			traces: encodeTraces(data.traces)
+		} : data);
+		for (const client of this.clients) if (client.readyState === WebSocket.OPEN) client.send(msg);
+		if (this.onData) try {
+			this.onData(data);
+		} catch {}
+	}
+	log(message) {
+		if (this.verbose) console.log(`[autotel-devtools] ${message}`);
+	}
+	async close() {
+		if (this.retentionTimer) {
+			clearInterval(this.retentionTimer);
+			this.retentionTimer = null;
+		}
+		for (const client of this.clients) client.close();
+		this.clients.clear();
+		this.wss.close();
+		await new Promise((resolve) => this.httpServer.close(() => resolve()));
+		this.store.close();
+	}
+};
+
+//#endregion
+//#region src/server/otlp-proto.ts
+const COMMON_PROTO = `
+syntax = "proto3";
+package opentelemetry.proto.common.v1;
+
+message AnyValue {
+  oneof value {
+    string string_value = 1;
+    bool bool_value = 2;
+    int64 int_value = 3;
+    double double_value = 4;
+    ArrayValue array_value = 5;
+    KeyValueList kvlist_value = 6;
+    bytes bytes_value = 7;
+  }
+}
+message ArrayValue { repeated AnyValue values = 1; }
+message KeyValueList { repeated KeyValue values = 1; }
+message KeyValue {
+  string key = 1;
+  AnyValue value = 2;
+}
+message InstrumentationScope {
+  string name = 1;
+  string version = 2;
+  repeated KeyValue attributes = 3;
+  uint32 dropped_attributes_count = 4;
+}
+`;
+const RESOURCE_PROTO = `
+syntax = "proto3";
+package opentelemetry.proto.resource.v1;
+
+message Resource {
+  repeated opentelemetry.proto.common.v1.KeyValue attributes = 1;
+  uint32 dropped_attributes_count = 2;
+}
+`;
+const TRACE_PROTO = `
+syntax = "proto3";
+package opentelemetry.proto.trace.v1;
+
+message ResourceSpans {
+  opentelemetry.proto.resource.v1.Resource resource = 1;
+  repeated ScopeSpans scope_spans = 2;
+  string schema_url = 3;
+}
+message ScopeSpans {
+  opentelemetry.proto.common.v1.InstrumentationScope scope = 1;
+  repeated Span spans = 2;
+  string schema_url = 3;
+}
+message Span {
+  bytes trace_id = 1;
+  bytes span_id = 2;
+  string trace_state = 3;
+  bytes parent_span_id = 4;
+  fixed32 flags = 16;
+  string name = 5;
+  SpanKind kind = 6;
+  fixed64 start_time_unix_nano = 7;
+  fixed64 end_time_unix_nano = 8;
+  repeated opentelemetry.proto.common.v1.KeyValue attributes = 9;
+  uint32 dropped_attributes_count = 10;
+  repeated Event events = 11;
+  uint32 dropped_events_count = 12;
+  repeated Link links = 13;
+  uint32 dropped_links_count = 14;
+  Status status = 15;
+
+  enum SpanKind {
+    SPAN_KIND_UNSPECIFIED = 0;
+    SPAN_KIND_INTERNAL = 1;
+    SPAN_KIND_SERVER = 2;
+    SPAN_KIND_CLIENT = 3;
+    SPAN_KIND_PRODUCER = 4;
+    SPAN_KIND_CONSUMER = 5;
+  }
+  message Event {
+    fixed64 time_unix_nano = 1;
+    string name = 2;
+    repeated opentelemetry.proto.common.v1.KeyValue attributes = 3;
+    uint32 dropped_attributes_count = 4;
+  }
+  message Link {
+    bytes trace_id = 1;
+    bytes span_id = 2;
+    string trace_state = 3;
+    repeated opentelemetry.proto.common.v1.KeyValue attributes = 4;
+    uint32 dropped_attributes_count = 5;
+    fixed32 flags = 6;
+  }
+}
+message Status {
+  reserved 1;
+  string message = 2;
+  StatusCode code = 3;
+
+  enum StatusCode {
+    STATUS_CODE_UNSET = 0;
+    STATUS_CODE_OK = 1;
+    STATUS_CODE_ERROR = 2;
+  }
+}
+message ExportTraceServiceRequest {
+  repeated ResourceSpans resource_spans = 1;
+}
+`;
+const LOGS_PROTO = `
+syntax = "proto3";
+package opentelemetry.proto.logs.v1;
+
+enum SeverityNumber {
+  SEVERITY_NUMBER_UNSPECIFIED = 0;
+  SEVERITY_NUMBER_TRACE = 1;
+  SEVERITY_NUMBER_TRACE2 = 2;
+  SEVERITY_NUMBER_TRACE3 = 3;
+  SEVERITY_NUMBER_TRACE4 = 4;
+  SEVERITY_NUMBER_DEBUG = 5;
+  SEVERITY_NUMBER_DEBUG2 = 6;
+  SEVERITY_NUMBER_DEBUG3 = 7;
+  SEVERITY_NUMBER_DEBUG4 = 8;
+  SEVERITY_NUMBER_INFO = 9;
+  SEVERITY_NUMBER_INFO2 = 10;
+  SEVERITY_NUMBER_INFO3 = 11;
+  SEVERITY_NUMBER_INFO4 = 12;
+  SEVERITY_NUMBER_WARN = 13;
+  SEVERITY_NUMBER_WARN2 = 14;
+  SEVERITY_NUMBER_WARN3 = 15;
+  SEVERITY_NUMBER_WARN4 = 16;
+  SEVERITY_NUMBER_ERROR = 17;
+  SEVERITY_NUMBER_ERROR2 = 18;
+  SEVERITY_NUMBER_ERROR3 = 19;
+  SEVERITY_NUMBER_ERROR4 = 20;
+  SEVERITY_NUMBER_FATAL = 21;
+  SEVERITY_NUMBER_FATAL2 = 22;
+  SEVERITY_NUMBER_FATAL3 = 23;
+  SEVERITY_NUMBER_FATAL4 = 24;
+}
+message ResourceLogs {
+  opentelemetry.proto.resource.v1.Resource resource = 1;
+  repeated ScopeLogs scope_logs = 2;
+  string schema_url = 3;
+}
+message ScopeLogs {
+  opentelemetry.proto.common.v1.InstrumentationScope scope = 1;
+  repeated LogRecord log_records = 2;
+  string schema_url = 3;
+}
+message LogRecord {
+  reserved 4;
+  fixed64 time_unix_nano = 1;
+  fixed64 observed_time_unix_nano = 11;
+  SeverityNumber severity_number = 2;
+  string severity_text = 3;
+  opentelemetry.proto.common.v1.AnyValue body = 5;
+  repeated opentelemetry.proto.common.v1.KeyValue attributes = 6;
+  uint32 dropped_attributes_count = 7;
+  fixed32 flags = 8;
+  bytes trace_id = 9;
+  bytes span_id = 10;
+}
+message ExportLogsServiceRequest {
+  repeated ResourceLogs resource_logs = 1;
+}
+`;
+const METRICS_PROTO = `
+syntax = "proto3";
+package opentelemetry.proto.metrics.v1;
+
+enum AggregationTemporality {
+  AGGREGATION_TEMPORALITY_UNSPECIFIED = 0;
+  AGGREGATION_TEMPORALITY_DELTA = 1;
+  AGGREGATION_TEMPORALITY_CUMULATIVE = 2;
+}
+message ResourceMetrics {
+  opentelemetry.proto.resource.v1.Resource resource = 1;
+  repeated ScopeMetrics scope_metrics = 2;
+  string schema_url = 3;
+}
+message ScopeMetrics {
+  opentelemetry.proto.common.v1.InstrumentationScope scope = 1;
+  repeated Metric metrics = 2;
+  string schema_url = 3;
+}
+message Metric {
+  string name = 1;
+  string description = 2;
+  string unit = 3;
+  oneof data {
+    Gauge gauge = 5;
+    Sum sum = 7;
+    Histogram histogram = 9;
+    ExponentialHistogram exponential_histogram = 10;
+    Summary summary = 11;
+  }
+}
+message Gauge {
+  repeated NumberDataPoint data_points = 1;
+}
+message Sum {
+  repeated NumberDataPoint data_points = 1;
+  AggregationTemporality aggregation_temporality = 2;
+  bool is_monotonic = 3;
+}
+message Histogram {
+  repeated HistogramDataPoint data_points = 1;
+  AggregationTemporality aggregation_temporality = 2;
+}
+message ExponentialHistogram {
+  repeated ExponentialHistogramDataPoint data_points = 1;
+  AggregationTemporality aggregation_temporality = 2;
+}
+message Summary {
+  repeated SummaryDataPoint data_points = 1;
+}
+message NumberDataPoint {
+  repeated opentelemetry.proto.common.v1.KeyValue attributes = 7;
+  fixed64 start_time_unix_nano = 2;
+  fixed64 time_unix_nano = 3;
+  oneof value {
+    double as_double = 4;
+    sfixed64 as_int = 6;
+  }
+  repeated Exemplar exemplars = 5;
+  uint32 flags = 8;
+}
+message HistogramDataPoint {
+  repeated opentelemetry.proto.common.v1.KeyValue attributes = 9;
+  fixed64 start_time_unix_nano = 2;
+  fixed64 time_unix_nano = 3;
+  uint64 count = 4;
+  double sum = 5;
+  repeated uint64 bucket_counts = 6;
+  repeated double explicit_bounds = 7;
+  repeated Exemplar exemplars = 8;
+  uint32 flags = 10;
+  double min = 11;
+  double max = 12;
+}
+message ExponentialHistogramDataPoint {
+  repeated opentelemetry.proto.common.v1.KeyValue attributes = 1;
+  fixed64 start_time_unix_nano = 2;
+  fixed64 time_unix_nano = 3;
+  uint64 count = 4;
+  double sum = 5;
+  sint32 scale = 6;
+  uint64 zero_count = 7;
+  Buckets positive = 8;
+  Buckets negative = 9;
+  uint32 flags = 10;
+  repeated Exemplar exemplars = 11;
+  double min = 12;
+  double max = 13;
+  double zero_threshold = 14;
+
+  message Buckets {
+    sint32 offset = 1;
+    repeated uint64 bucket_counts = 2;
+  }
+}
+message SummaryDataPoint {
+  repeated opentelemetry.proto.common.v1.KeyValue attributes = 7;
+  fixed64 start_time_unix_nano = 2;
+  fixed64 time_unix_nano = 3;
+  uint64 count = 4;
+  double sum = 5;
+  repeated ValueAtQuantile quantile_values = 6;
+  uint32 flags = 8;
+
+  message ValueAtQuantile {
+    double quantile = 1;
+    double value = 2;
+  }
+}
+message Exemplar {
+  repeated opentelemetry.proto.common.v1.KeyValue filtered_attributes = 7;
+  fixed64 time_unix_nano = 2;
+  oneof value {
+    double as_double = 3;
+    sfixed64 as_int = 6;
+  }
+  bytes span_id = 4;
+  bytes trace_id = 5;
+}
+message ExportMetricsServiceRequest {
+  repeated ResourceMetrics resource_metrics = 1;
+}
+`;
+const TO_OBJECT_OPTIONS = {
+	longs: String,
+	bytes: String,
+	defaults: false
+};
+let cachedRoot = null;
+function getRoot() {
+	if (cachedRoot) return cachedRoot;
+	const root = new protobuf.Root();
+	for (const source of [
+		COMMON_PROTO,
+		RESOURCE_PROTO,
+		TRACE_PROTO,
+		LOGS_PROTO,
+		METRICS_PROTO
+	]) protobuf.parse(source, root, { keepCase: false });
+	root.resolveAll();
+	cachedRoot = root;
+	return root;
+}
+function decodeRequest(typeName, body) {
+	const messageType = getRoot().lookupType(typeName);
+	const message = messageType.decode(body);
+	return messageType.toObject(message, TO_OBJECT_OPTIONS);
+}
+/** Decode an OTLP/protobuf `ExportTraceServiceRequest` into the OTLP/JSON object shape. */
+function decodeOtlpTraceRequest(body) {
+	return decodeRequest("opentelemetry.proto.trace.v1.ExportTraceServiceRequest", body);
+}
+/** Decode an OTLP/protobuf `ExportLogsServiceRequest` into the OTLP/JSON object shape. */
+function decodeOtlpLogsRequest(body) {
+	return decodeRequest("opentelemetry.proto.logs.v1.ExportLogsServiceRequest", body);
+}
+/** Decode an OTLP/protobuf `ExportMetricsServiceRequest` into the OTLP/JSON object shape. */
+function decodeOtlpMetricsRequest(body) {
+	return decodeRequest("opentelemetry.proto.metrics.v1.ExportMetricsServiceRequest", body);
+}
+
+//#endregion
+//#region src/server/identity.ts
+/** Value of the `x-autotel-devtools` response header and the /healthz `service` field. */
+const DEVTOOLS_IDENTITY = "autotel-devtools";
+/**
+* Probe `host:port` over HTTP and classify what is listening. Used when our
+* requested port is busy: it lets us tell "a stale autotel-devtools is still
+* up" (benign) apart from "a foreign collector owns this port" — the latter is
+* the silent footgun where apps keep exporting OTLP to the busy port and reach
+* the wrong process, so the devtools UI stays empty and the app sees errors.
+*/
+async function probePortHolder(host, port, timeoutMs = 500) {
+	const authority = host.includes(":") ? `[${host}]` : host;
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		const res = await fetch(`http://${authority}:${port}/healthz`, { signal: controller.signal });
+		if (res.headers.get("x-autotel-devtools")) return "autotel-devtools";
+		try {
+			const body = await res.json();
+			if (body && body.service === "autotel-devtools") return "autotel-devtools";
+		} catch {}
+		return "foreign";
+	} catch {
+		return "none";
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
+//#endregion
+//#region src/server/source-file.ts
+/** Refuse to slurp something huge just because a span named it. */
+const MAX_BYTES = 2e6;
+const DISABLED = /* @__PURE__ */ new Set([
+	"false",
+	"0",
+	"off",
+	"no",
+	""
+]);
+/**
+* Decide what `GET /source` may read, from `AUTOTEL_DEVTOOLS_SOURCE_ROOT`.
+*
+* Defaults **on**, at the working directory: devtools is a local tool whose
+* whole point is showing you your own code, and requiring a flag for that would
+* mean nobody ever sees the feature. The blast radius stays small because two
+* other things still hold — the receiver is bound to loopback, and nothing
+* outside this directory is reachable. Set the variable to `false` to turn it
+* off outright.
+*
+* A non-loopback bind (`--host 0.0.0.0`) removes the first of those, and the
+* Origin guard does not replace it: a request with no `Origin` at all — any
+* `curl` on the network — passes. The root holds whatever else lives in the
+* project, `.env` included, so the default flips to **off** there. An explicit
+* root is still honoured: exposing it on purpose is the caller's call.
+*/
+function resolveSourceRoot(configured, cwd, loopbackOnly = true) {
+	if (configured === void 0) return loopbackOnly ? cwd : void 0;
+	if (DISABLED.has(configured.trim().toLowerCase())) return void 0;
+	return configured;
+}
+/**
+* Resolve `requested` against `root`, or return `null` if it escapes.
+*
+* Containment is judged on **real** paths so a symlink inside the root that
+* points outside it is rejected — lexical `..` stripping alone cannot see that.
+* The value returned is the *lexical* resolution, because the real one differs
+* from the caller's path whenever an ancestor is a symlink (on macOS both
+* `/tmp` and `/var` are), and a caller comparing paths should not have to know.
+*/
+function resolveWithinRoot(root, requested) {
+	const lexicalRoot = path.resolve(root);
+	const realRoot = safeRealpath(lexicalRoot);
+	if (realRoot === null) return null;
+	const lexicalTarget = path.resolve(lexicalRoot, requested);
+	const realTarget = safeRealpath(lexicalTarget);
+	if (realTarget === null) return null;
+	if (!isInside(realRoot, realTarget)) return null;
+	return lexicalTarget;
+}
+/** True when `target` is `root` itself or sits beneath it. */
+function isInside(root, target) {
+	if (target === root) return true;
+	return target.startsWith(root.endsWith(path.sep) ? root : root + path.sep);
+}
+function safeRealpath(p) {
+	try {
+		return realpathSync(p);
+	} catch {
+		return null;
+	}
+}
+/**
+* Read `context` lines either side of `line` from a file inside `root`.
+* Returns `null` when the path escapes the root, is not a readable file, or is
+* too large — the caller cannot distinguish those, which is the point.
+*/
+function readSourceWindow(root, requested, line, context) {
+	const resolved = resolveWithinRoot(root, requested);
+	if (resolved === null) return null;
+	let text;
+	try {
+		const stat = statSync(resolved);
+		if (!stat.isFile() || stat.size > MAX_BYTES) return null;
+		text = readFileSync(resolved, "utf8");
+	} catch {
+		return null;
+	}
+	const all = text.split("\n");
+	if (all.at(-1) === "") all.pop();
+	const startLine = Math.max(1, line - context);
+	const endLine = Math.min(all.length, line + context);
+	if (startLine > all.length) return null;
+	return {
+		file: path.relative(path.resolve(root), resolved),
+		line,
+		startLine,
+		lines: all.slice(startLine - 1, endLine)
+	};
+}
+
+//#endregion
+//#region src/server/coverage/coverage.ts
+/**
+* The names a span could plausibly carry for this route.
+*
+* `http.route` is the semconv attribute a framework integration sets. The span
+* *name* is the other route in, and for an HTTP handler the convention is
+* `"{method} {route}"`, which is what `trace()` and every framework middleware
+* produce. A non-HTTP entry point has no method, so its own name is the only
+* thing to match.
+*/
+function candidateNames(route) {
+	if (!route.method) return [route.path];
+	return [`${route.method.toUpperCase()} ${route.path}`];
+}
+function joinCoverage(routes, observed) {
+	const entries = routes.map((route) => {
+		const byRoute = route.method ? 0 : observed.routeCounts[route.path] ?? 0;
+		const byRouteAny = observed.routeCounts[route.path] ?? 0;
+		const byName = candidateNames(route).reduce((total, name) => total + (observed.spanNameCounts[name] ?? 0), 0);
+		const namedAnyMethod = Object.keys(observed.spanNameCounts).some((name) => name.endsWith(` ${route.path}`));
+		const spanCount = byName > 0 ? byName : namedAnyMethod ? 0 : byRoute || byRouteAny;
+		return {
+			...route,
+			seen: spanCount > 0,
+			spanCount
+		};
+	});
+	entries.sort((left, right) => Number(left.seen) - Number(right.seen));
+	return {
+		entries,
+		seenCount: entries.filter((entry) => entry.seen).length,
+		total: entries.length
+	};
+}
+
+//#endregion
+//#region src/server/http.ts
+function sendOtlpError(res, req, e) {
+	sendJson(res, 400, {
+		error: "Invalid OTLP payload",
+		message: e instanceof Error ? e.message : String(e),
+		contentType: req.headers["content-type"] ?? null
+	});
+}
+const PROTOBUF_DECODERS = {
+	traces: decodeOtlpTraceRequest,
+	logs: decodeOtlpLogsRequest,
+	metrics: decodeOtlpMetricsRequest
+};
+async function readOtlpPayload(req, signal) {
+	if (isProtobufContentType(req.headers["content-type"])) return PROTOBUF_DECODERS[signal](await readRawBody(req));
+	return readJsonBody(req);
+}
+function findPackageRoot() {
+	let dir = dirname(fileURLToPath(import.meta.url));
+	for (let i = 0; i < 5; i++) {
+		if (existsSync(resolve(dir, "package.json"))) return dir;
+		dir = dirname(dir);
+	}
+	return dir;
+}
+const DEVTOOLS_FAVICON_SVG = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 64 64\"><rect width=\"64\" height=\"64\" rx=\"14\" fill=\"#0f172a\"/><text x=\"32\" y=\"41\" text-anchor=\"middle\" font-size=\"32\">🛰️</text></svg>";
+/**
+* The title is user-supplied (`--title` / `AUTOTEL_DEVTOOLS_TITLE`) and lands
+* inside `<title>`, where an unescaped `<` would close the element early.
+*/
+function escapeHtml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
+}
+function renderFullpageHtml(title = "autotel-devtools") {
+	return `<!DOCTYPE html><html><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>${escapeHtml(title)}</title><link rel="icon" href="/favicon.svg" type="image/svg+xml"><style>*{margin:0;padding:0;box-sizing:border-box}html,body{height:100%;width:100%;overflow:hidden}</style></head><body><script src="/widget.js?mode=fullpage"><\/script></body></html>`;
+}
+let cachedVersion = null;
+function getVersion() {
+	if (cachedVersion !== null) return cachedVersion;
+	let version = "unknown";
+	try {
+		const pkg = JSON.parse(readFileSync(resolve(findPackageRoot(), "package.json"), "utf8"));
+		if (typeof pkg.version === "string") version = pkg.version;
+	} catch {}
+	cachedVersion = version;
+	return version;
+}
+const widgetJsCache = /* @__PURE__ */ new Map();
+/**
+* The browser bundle for one surface.
+*
+* Two are built: `fullpage.global.js` carries every view, while
+* `widget.global.js` is the reduced set for embedding in someone else's page.
+* Serving the right one is what makes the split worth anything — handing the
+* full bundle to an embedder would ship them the views the split exists to
+* spare them.
+*
+* The full-page bundle falls back to the widget one when it is missing, so a
+* partially-built checkout still serves a working UI rather than a comment.
+*/
+function getWidgetJs(surface) {
+	const cached = widgetJsCache.get(surface);
+	if (cached) return cached;
+	const pkgRoot = findPackageRoot();
+	const candidates = (surface === "fullpage" ? ["fullpage.global.js", "widget.global.js"] : ["widget.global.js"]).flatMap((name) => [resolve(pkgRoot, "dist", name), resolve(pkgRoot, name)]);
+	let contents = null;
+	for (const candidate of candidates) try {
+		contents = readFileSync(candidate, "utf8");
+		break;
+	} catch {}
+	const resolved = contents ?? "// widget bundle not found - run pnpm build first";
+	widgetJsCache.set(surface, resolved);
+	return resolved;
+}
+function attachDevtoolsRoutes(httpServer, devtools, options = {}) {
+	const loopbackOnly = options.loopbackOnly ?? true;
+	const sourceRoot = options.sourceRoot;
+	const fullpageHtml = renderFullpageHtml(options.title);
+	httpServer.on("request", async (req, res) => {
+		if (req.headers.upgrade?.toLowerCase() === "websocket") return;
+		res.setHeader("Access-Control-Allow-Origin", "*");
+		res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+		res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+		res.setHeader("x-autotel-devtools", getVersion());
+		res.setHeader("Access-Control-Expose-Headers", "x-autotel-devtools");
+		if (req.method === "OPTIONS") {
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+		const url = req.url || "/";
+		if (req.method === "GET" && url === "/") {
+			res.writeHead(200, {
+				"Content-Type": "text/html; charset=utf-8",
+				"Content-Length": Buffer.byteLength(fullpageHtml)
+			});
+			res.end(fullpageHtml);
+			return;
+		}
+		if (req.method === "GET" && url.startsWith("/widget.js")) {
+			const js = getWidgetJs(url.includes("mode=fullpage") ? "fullpage" : "widget");
+			res.writeHead(200, {
+				"Content-Type": "application/javascript; charset=utf-8",
+				"Content-Length": Buffer.byteLength(js)
+			});
+			res.end(js);
+			return;
+		}
+		if (req.method === "GET" && (url === "/favicon.svg" || url === "/favicon.ico")) {
+			res.writeHead(200, {
+				"Content-Type": "image/svg+xml; charset=utf-8",
+				"Cache-Control": "public, max-age=86400",
+				"Content-Length": Buffer.byteLength(DEVTOOLS_FAVICON_SVG)
+			});
+			res.end(DEVTOOLS_FAVICON_SVG);
+			return;
+		}
+		if (req.method === "GET" && url.split("?")[0] === "/api/query/attributes") {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			const params = new URL(url, "http://localhost").searchParams;
+			const signal = params.get("signal") === "logs" ? "logs" : "traces";
+			const key = params.get("key");
+			const pair = params.get("pair");
+			if (key !== null && pair !== null) {
+				sendJson(res, 200, { pairs: devtools.pairedAttributeValues(signal, key, pair) });
+				return;
+			}
+			sendJson(res, 200, { attributes: devtools.searchAttributes(signal, params.get("value") ?? "") });
+			return;
+		}
+		if (req.method === "GET" && url.split("?")[0] === "/source") {
+			if (!sourceRoot) {
+				sendJson(res, 404, { error: "Not found" });
+				return;
+			}
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			const query = new URL(url, "http://localhost").searchParams;
+			const file = query.get("file");
+			const line = Number(query.get("line"));
+			const context = Math.min(Math.max(Number(query.get("context") ?? 5) || 0, 0), 50);
+			if (!file || !Number.isInteger(line) || line < 1) {
+				sendJson(res, 400, { error: "file and a positive integer line are required" });
+				return;
+			}
+			const window = readSourceWindow(sourceRoot, file, line, context);
+			if (window === null) {
+				sendJson(res, 404, { error: "Not found" });
+				return;
+			}
+			sendJson(res, 200, { ...window });
+			return;
+		}
+		if (req.method === "GET" && url === "/healthz") {
+			sendJson(res, 200, {
+				ok: true,
+				service: DEVTOOLS_IDENTITY,
+				version: getVersion(),
+				clients: devtools.clientCount
+			});
+			return;
+		}
+		if (req.method === "GET" && url === "/v1/traces") {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			const data = devtools.getCurrentData();
+			sendJson(res, 200, {
+				traces: data.traces,
+				count: data.traces.length
+			});
+			return;
+		}
+		if (req.method === "DELETE" && url === "/v1/traces") {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			devtools.clearData();
+			sendJson(res, 200, { cleared: true });
+			return;
+		}
+		if (req.method === "DELETE" && (url === "/v1/logs" || url === "/v1/metrics")) {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			const signal = url.endsWith("/logs") ? "logs" : "metrics";
+			devtools.clearSignal(signal);
+			sendJson(res, 200, {
+				cleared: true,
+				signal
+			});
+			return;
+		}
+		if (req.method === "DELETE" && url === "/api/traces") {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			const body = await readJsonBody(req);
+			const traceIds = Array.isArray(body.traceIds) ? body.traceIds.filter((id) => typeof id === "string") : [];
+			sendJson(res, 200, { deleted: devtools.deleteTraces(traceIds) });
+			return;
+		}
+		if (req.method === "POST" && url === "/v1/traces") {
+			try {
+				const payload = await readOtlpPayload(req, "traces");
+				sendJson(res, 200, { acceptedTraces: devtools.ingestOtlp("traces", payload) });
+			} catch (e) {
+				sendOtlpError(res, req, e);
+			}
+			return;
+		}
+		if (req.method === "POST" && url === "/v1/logs") {
+			try {
+				const payload = await readOtlpPayload(req, "logs");
+				sendJson(res, 200, { acceptedLogs: devtools.ingestOtlp("logs", payload) });
+			} catch (e) {
+				sendOtlpError(res, req, e);
+			}
+			return;
+		}
+		if (req.method === "POST" && url === "/v1/metrics") {
+			try {
+				const payload = await readOtlpPayload(req, "metrics");
+				sendJson(res, 200, { acceptedMetrics: devtools.ingestOtlp("metrics", payload) });
+			} catch (e) {
+				sendOtlpError(res, req, e);
+			}
+			return;
+		}
+		if (req.method === "GET" && (url === "/api/query/traces/fields" || url === "/api/query/logs/fields")) {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			const signal = url.includes("/logs/") ? "logs" : "traces";
+			sendJson(res, 200, { fields: devtools.listQueryFields(signal) });
+			return;
+		}
+		if (req.method === "POST" && url === "/api/query/traces") {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			try {
+				const body = await readJsonBody(req);
+				const result = devtools.queryTraces({
+					query: body.query ?? "",
+					window: body.window,
+					limit: body.limit,
+					cursor: body.cursor
+				});
+				if (result.errors) {
+					sendJson(res, 400, { errors: result.errors });
+					return;
+				}
+				sendJson(res, 200, {
+					traces: result.traces,
+					nextCursor: result.nextCursor
+				});
+			} catch (e) {
+				sendJson(res, 400, {
+					error: "Invalid query request",
+					message: e instanceof Error ? e.message : String(e)
+				});
+			}
+			return;
+		}
+		if (req.method === "GET" && url === "/api/coverage") {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			if (!sourceRoot) {
+				sendJson(res, 404, {
+					error: "Coverage unavailable",
+					message: "No source root configured, so `autotel.map.json` cannot be located."
+				});
+				return;
+			}
+			const mapPath = resolve(sourceRoot, "autotel.map.json");
+			if (!existsSync(mapPath)) {
+				sendJson(res, 404, {
+					error: "No instrumentation map",
+					message: "Run `npx autotel map` to record this project's entry points, then reload."
+				});
+				return;
+			}
+			try {
+				sendJson(res, 200, joinCoverage(JSON.parse(readFileSync(mapPath, "utf8")).routes ?? [], devtools.observedSpans()));
+			} catch (e) {
+				sendJson(res, 400, {
+					error: "Unreadable instrumentation map",
+					message: e instanceof Error ? e.message : String(e)
+				});
+			}
+			return;
+		}
+		if (req.method === "POST" && url === "/api/analysis/compare") {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			let compareCohorts;
+			try {
+				({compareCohorts} = await import("autotel/analysis"));
+			} catch {
+				sendJson(res, 501, {
+					error: "Comparison unavailable",
+					message: "Install `autotel` alongside autotel-devtools to compare cohorts."
+				});
+				return;
+			}
+			try {
+				const body = await readJsonBody(req);
+				const outlier = devtools.cohortRows({
+					query: body.outlier?.query ?? "",
+					window: body.outlier?.window
+				});
+				const baseline = devtools.cohortRows({
+					query: body.baseline?.query ?? "",
+					window: body.baseline?.window
+				});
+				sendJson(res, 200, {
+					differences: compareCohorts({
+						outlier,
+						baseline,
+						ignoreFields: body.ignoreFields,
+						limit: body.limit
+					}),
+					outlierCount: outlier.length,
+					baselineCount: baseline.length
+				});
+			} catch (e) {
+				sendJson(res, 400, {
+					error: "Invalid comparison request",
+					message: e instanceof Error ? e.message : String(e)
+				});
+			}
+			return;
+		}
+		if (req.method === "POST" && url === "/api/query/logs") {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			try {
+				const body = await readJsonBody(req);
+				const result = devtools.queryLogs({
+					query: body.query ?? "",
+					window: body.window,
+					limit: body.limit,
+					cursor: body.cursor
+				});
+				if (result.errors) {
+					sendJson(res, 400, { errors: result.errors });
+					return;
+				}
+				sendJson(res, 200, {
+					logs: result.logs,
+					nextCursor: result.nextCursor
+				});
+			} catch (e) {
+				sendJson(res, 400, {
+					error: "Invalid query request",
+					message: e instanceof Error ? e.message : String(e)
+				});
+			}
+			return;
+		}
+		if (req.method === "POST" && url === "/api/query/errors") {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			try {
+				const body = await readJsonBody(req);
+				const result = devtools.queryErrors({
+					query: body.query ?? "",
+					window: body.window,
+					limit: body.limit
+				});
+				if (result.errors_parse) {
+					sendJson(res, 400, { errors: result.errors_parse });
+					return;
+				}
+				sendJson(res, 200, { errors: result.errors });
+			} catch (e) {
+				sendJson(res, 400, {
+					error: "Invalid query request",
+					message: e instanceof Error ? e.message : String(e)
+				});
+			}
+			return;
+		}
+		if (req.method === "GET" && url === "/api/metrics") {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			sendJson(res, 200, { metrics: devtools.listMetricNames() });
+			return;
+		}
+		if (req.method === "GET" && url.split("?")[0] === "/api/metrics") {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			const query = new URL(url, "http://localhost").searchParams.get("q") ?? "";
+			const result = devtools.queryMetricCatalog(query);
+			if (result.errors) sendJson(res, 400, { errors: result.errors });
+			else sendJson(res, 200, { metrics: result.metrics });
+			return;
+		}
+		if (req.method === "DELETE" && url.split("?")[0] === "/api/metrics") {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			const name = new URL(url, "http://localhost").searchParams.get("name");
+			if (!name) {
+				sendJson(res, 400, { error: "A metric name is required" });
+				return;
+			}
+			sendJson(res, 200, { deletedSeries: devtools.deleteMetric(name) });
+			return;
+		}
+		if (req.method === "GET" && url === "/api/stats") {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			sendJson(res, 200, devtools.getStoreStats());
+			return;
+		}
+		if (req.method === "GET" && url.split("?")[0] === "/api/traces/slowest") {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			const limit = Number(new URL(url, "http://localhost").searchParams.get("limit") ?? 10);
+			sendJson(res, 200, { traces: devtools.findSlowestTraces(limit) });
+			return;
+		}
+		const summaryMatch = req.method === "GET" && url.match(/^\/api\/traces\/([^/?]+)\/summary$/);
+		if (summaryMatch) {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			const summary = devtools.describeTrace(decodeURIComponent(summaryMatch[1]));
+			if (!summary) sendJson(res, 404, { error: "Trace not found" });
+			else sendJson(res, 200, summary);
+			return;
+		}
+		if (req.method === "POST" && url === "/api/query/metrics") {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			try {
+				const body = await readJsonBody(req);
+				if (!body.name) {
+					sendJson(res, 400, { error: "A metric name is required" });
+					return;
+				}
+				sendJson(res, 200, { series: devtools.queryMetricSeries({
+					name: body.name,
+					window: body.window,
+					maxPoints: body.maxPoints
+				}) });
+			} catch (e) {
+				sendJson(res, 400, {
+					error: "Invalid metrics query",
+					message: e instanceof Error ? e.message : String(e)
+				});
+			}
+			return;
+		}
+		sendJson(res, 404, { error: "Not found" });
+	});
+}
+function createDevtoolsHttpServer(devtools, _options = {}) {
+	const server = createServer();
+	attachDevtoolsRoutes(server, devtools);
+	return server;
+}
+
+//#endregion
+export { ErrorAggregator as C, resolveTelemetryLimits as S, isLoopbackHostname as _, probePortHolder as a, appendWithLimit as b, decodeOtlpTraceRequest as c, parseOtlpLogs as d, parseOtlpTraces as f, hostHeaderIsLoopback as g, allowSensitiveRequest as h, DEVTOOLS_IDENTITY as i, DevtoolsServer as l, SPAN_SCHEMA as m, createDevtoolsHttpServer as n, decodeOtlpLogsRequest as o, DevtoolsStore as p, resolveSourceRoot as r, decodeOtlpMetricsRequest as s, attachDevtoolsRoutes as t, isProtobufContentType as u, originIsLoopback as v, applyTelemetryLimits as x, appendManyWithLimit as y };