autotel-devtools 22.0.0 → 23.1.0

package/dist/http-1afd_01N.cjs

@@ -0,0 +1,3991 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const require_wire = require('./wire-CHU1PkMo.cjs');
+const require_json_fields = require('./json-fields-DZFlNqT2.cjs');
+const require_trace_root = require('./trace-root-BMa667jK.cjs');
+const require_parse = require('./parse-BRlosZft.cjs');
+const require_resource_utils = require('./resource-utils-DjHJB6uc.cjs');
+let node_http = require("node:http");
+let ws = require("ws");
+let autotel_agents = require("autotel-agents");
+let node_sqlite = require("node:sqlite");
+let node_crypto = require("node:crypto");
+let node_zlib = require("node:zlib");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_url = require("node:url");
+let protobufjs = require("protobufjs");
+protobufjs = __toESM(protobufjs, 1);
+
+//#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 = require_json_fields.stringAttr(span.attributes, "exception.type", "error.type") ?? require_json_fields.stringAttr(exceptionEvent?.attributes, "exception.type") ?? "Error";
+		const errorMessage = span.status.message || require_json_fields.stringAttr(span.attributes, "exception.message", "error.message") || "Unknown error";
+		const stackTrace = require_json_fields.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: require_json_fields.stringAttr(span.attributes, "exception.fingerprint") ?? require_json_fields.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 require_json_fields.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 node_sqlite.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 = require_parse.parse(args.query ?? "");
+		if (!parsed.ok) return {
+			traces: [],
+			nextCursor: null,
+			errors: parsed.errors
+		};
+		const { sql: whereSql, params } = require_parse.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 = require_parse.parse(args.query ?? "");
+		if (!parsed.ok) return {
+			logs: [],
+			nextCursor: null,
+			errors: parsed.errors
+		};
+		const { sql: whereSql, params } = require_parse.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 = require_parse.parse(query);
+		if (!parsed.ok) return {
+			metrics: [],
+			errors: parsed.errors
+		};
+		const compiled = require_parse.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 = require_parse.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 } = require_parse.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 (0, node_crypto.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 = require_json_fields.asString(body);
+	if (text !== void 0) return text;
+	if (body === void 0 || body === null) return "";
+	const structured = require_json_fields.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 } = require_trace_root.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: require_resource_utils.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 = (0, node_zlib.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 ?? (0, node_http.createServer)();
+		const loopbackOnly = options.host == null || hostHeaderIsLoopback(options.host);
+		this.wsPath = options.path ?? "/ws";
+		this.loopbackOnly = loopbackOnly;
+		this.wss = new ws.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$1) => {
+			this.clients.add(ws$1);
+			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$1.send(JSON.stringify(data));
+			ws$1.on("close", () => {
+				this.clients.delete(ws$1);
+				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 } = require_trace_root.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$2) => {
+				this.wss.emit("connection", ws$2, 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;
+		(0, autotel_agents.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;
+		(0, autotel_agents.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: require_wire.encodeTraces(data.traces)
+		} : data);
+		for (const client of this.clients) if (client.readyState === ws.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 protobufjs.default.Root();
+	for (const source of [
+		COMMON_PROTO,
+		RESOURCE_PROTO,
+		TRACE_PROTO,
+		LOGS_PROTO,
+		METRICS_PROTO
+	]) protobufjs.default.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 = node_path.default.resolve(root);
+	const realRoot = safeRealpath(lexicalRoot);
+	if (realRoot === null) return null;
+	const lexicalTarget = node_path.default.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(node_path.default.sep) ? root : root + node_path.default.sep);
+}
+function safeRealpath(p) {
+	try {
+		return (0, node_fs.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 = (0, node_fs.statSync)(resolved);
+		if (!stat.isFile() || stat.size > MAX_BYTES) return null;
+		text = (0, node_fs.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: node_path.default.relative(node_path.default.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 = (0, node_path.dirname)((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+	for (let i = 0; i < 5; i++) {
+		if ((0, node_fs.existsSync)((0, node_path.resolve)(dir, "package.json"))) return dir;
+		dir = (0, node_path.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((0, node_fs.readFileSync)((0, node_path.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) => [(0, node_path.resolve)(pkgRoot, "dist", name), (0, node_path.resolve)(pkgRoot, name)]);
+	let contents = null;
+	for (const candidate of candidates) try {
+		contents = (0, node_fs.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 = (0, node_path.resolve)(sourceRoot, "autotel.map.json");
+			if (!(0, node_fs.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((0, node_fs.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 = (0, node_http.createServer)();
+	attachDevtoolsRoutes(server, devtools);
+	return server;
+}
+
+//#endregion
+Object.defineProperty(exports, 'DEVTOOLS_IDENTITY', {
+  enumerable: true,
+  get: function () {
+    return DEVTOOLS_IDENTITY;
+  }
+});
+Object.defineProperty(exports, 'DevtoolsServer', {
+  enumerable: true,
+  get: function () {
+    return DevtoolsServer;
+  }
+});
+Object.defineProperty(exports, 'DevtoolsStore', {
+  enumerable: true,
+  get: function () {
+    return DevtoolsStore;
+  }
+});
+Object.defineProperty(exports, 'ErrorAggregator', {
+  enumerable: true,
+  get: function () {
+    return ErrorAggregator;
+  }
+});
+Object.defineProperty(exports, 'SPAN_SCHEMA', {
+  enumerable: true,
+  get: function () {
+    return SPAN_SCHEMA;
+  }
+});
+Object.defineProperty(exports, 'allowSensitiveRequest', {
+  enumerable: true,
+  get: function () {
+    return allowSensitiveRequest;
+  }
+});
+Object.defineProperty(exports, 'appendManyWithLimit', {
+  enumerable: true,
+  get: function () {
+    return appendManyWithLimit;
+  }
+});
+Object.defineProperty(exports, 'appendWithLimit', {
+  enumerable: true,
+  get: function () {
+    return appendWithLimit;
+  }
+});
+Object.defineProperty(exports, 'applyTelemetryLimits', {
+  enumerable: true,
+  get: function () {
+    return applyTelemetryLimits;
+  }
+});
+Object.defineProperty(exports, 'attachDevtoolsRoutes', {
+  enumerable: true,
+  get: function () {
+    return attachDevtoolsRoutes;
+  }
+});
+Object.defineProperty(exports, 'createDevtoolsHttpServer', {
+  enumerable: true,
+  get: function () {
+    return createDevtoolsHttpServer;
+  }
+});
+Object.defineProperty(exports, 'decodeOtlpLogsRequest', {
+  enumerable: true,
+  get: function () {
+    return decodeOtlpLogsRequest;
+  }
+});
+Object.defineProperty(exports, 'decodeOtlpMetricsRequest', {
+  enumerable: true,
+  get: function () {
+    return decodeOtlpMetricsRequest;
+  }
+});
+Object.defineProperty(exports, 'decodeOtlpTraceRequest', {
+  enumerable: true,
+  get: function () {
+    return decodeOtlpTraceRequest;
+  }
+});
+Object.defineProperty(exports, 'hostHeaderIsLoopback', {
+  enumerable: true,
+  get: function () {
+    return hostHeaderIsLoopback;
+  }
+});
+Object.defineProperty(exports, 'isLoopbackHostname', {
+  enumerable: true,
+  get: function () {
+    return isLoopbackHostname;
+  }
+});
+Object.defineProperty(exports, 'isProtobufContentType', {
+  enumerable: true,
+  get: function () {
+    return isProtobufContentType;
+  }
+});
+Object.defineProperty(exports, 'originIsLoopback', {
+  enumerable: true,
+  get: function () {
+    return originIsLoopback;
+  }
+});
+Object.defineProperty(exports, 'parseOtlpLogs', {
+  enumerable: true,
+  get: function () {
+    return parseOtlpLogs;
+  }
+});
+Object.defineProperty(exports, 'parseOtlpTraces', {
+  enumerable: true,
+  get: function () {
+    return parseOtlpTraces;
+  }
+});
+Object.defineProperty(exports, 'probePortHolder', {
+  enumerable: true,
+  get: function () {
+    return probePortHolder;
+  }
+});
+Object.defineProperty(exports, 'resolveSourceRoot', {
+  enumerable: true,
+  get: function () {
+    return resolveSourceRoot;
+  }
+});
+Object.defineProperty(exports, 'resolveTelemetryLimits', {
+  enumerable: true,
+  get: function () {
+    return resolveTelemetryLimits;
+  }
+});