@tangle-network/agent-eval 0.138.0 → 0.139.0

package/dist/store-otlp-BenKynPE.js

@@ -1,1688 +0,0 @@
-import { a as LimitExceededError, c as ValidationError, n as CaptureIntegrityError, o as NotFoundError, t as AgentEvalError } from "./errors-D-LKuDhb.js";
-import { INPUT_VALUE, LLM_MODEL_ATTR_KEYS, OUTPUT_VALUE, SPAN_KIND_ATTR_KEYS, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS } from "./trace-attributes.js";
-import { z } from "zod";
-import { readFile, stat } from "node:fs/promises";
-import { RE2JS } from "re2js";
-//#region src/trace/otlp-attributes.ts
-/** Canonical OpenInference-over-OTLP attribute vocabulary used at the trace boundary. */
-const TOOL_SPAN_ATTRIBUTE_KEYS = [
-	TOOL_NAME,
-	TOOL_ARGS_CAPTURED,
-	TOOL_LATENCY_MS,
-	INPUT_VALUE,
-	OUTPUT_VALUE
-];
-const EXPLICIT_SPAN_ROLES = /* @__PURE__ */ new Set([
-	"AGENT",
-	"CHAIN",
-	"EVALUATOR",
-	"GUARDRAIL",
-	"LLM",
-	"SPAN",
-	"TOOL"
-]);
-/**
-* Classify a span once for both measurement and error accounting.
-* An explicit OpenInference kind wins; untyped spans use the same tool and
-* model signals in online and offline intake.
-*/
-function classifyOtlpSpanRole(input) {
-	const explicitKind = input.kind ?? firstStringAttribute(input.attributes, SPAN_KIND_ATTR_KEYS);
-	if (explicitKind) {
-		const normalized = explicitKind.toUpperCase();
-		if (EXPLICIT_SPAN_ROLES.has(normalized)) return normalized;
-	}
-	if (firstStringAttribute(input.attributes, TOOL_NAME_ATTR_KEYS) !== void 0 || /^(?:function|tool)[.:/]/i.test(input.name)) return "TOOL";
-	const spanType = input.attributes["span.type"];
-	if (typeof spanType === "string" && spanType.toLowerCase() === "llm_request" || /(?:^|[.:/_-])(?:chat[._-]?completions?|llm)(?:$|[.:/_-])/i.test(input.name) || firstStringAttribute(input.attributes, LLM_MODEL_ATTR_KEYS) !== void 0 || typeof input.attributes["gen_ai.operation.name"] === "string") return "LLM";
-	return "UNKNOWN";
-}
-function isOtlpModelCall(input) {
-	return classifyOtlpSpanRole(input) === "LLM";
-}
-function toolSpanOtlpAttributes(span) {
-	const argsCaptured = span.argsCaptured !== false;
-	const attributes = {
-		[TOOL_NAME]: span.toolName,
-		[TOOL_ARGS_CAPTURED]: argsCaptured
-	};
-	if (span.latencyMs !== void 0) attributes[TOOL_LATENCY_MS] = span.latencyMs;
-	if (argsCaptured) attributes[INPUT_VALUE] = stringifyTraceValue(span.args);
-	if (span.result !== void 0) attributes[OUTPUT_VALUE] = stringifyTraceValue(span.result);
-	return attributes;
-}
-function applyToolSpanOtlpAttributes(attributes, span) {
-	for (const key of TOOL_SPAN_ATTRIBUTE_KEYS) delete attributes[key];
-	Object.assign(attributes, toolSpanOtlpAttributes(span));
-}
-function traceSpanKindToOpenInferenceKind(kind) {
-	switch (kind) {
-		case "llm": return "LLM";
-		case "tool": return "TOOL";
-		case "retrieval": return "CHAIN";
-		case "judge": return "EVALUATOR";
-		case "sandbox": return "CHAIN";
-		case "agent": return "AGENT";
-		default: return "SPAN";
-	}
-}
-function firstStringAttribute(attributes, keys) {
-	for (const key of keys) {
-		const value = attributes[key];
-		if (typeof value === "string" && value.length > 0) return value;
-	}
-}
-function stringifyTraceValue(value) {
-	if (value === void 0) return "null";
-	if (typeof value === "string") return value;
-	try {
-		return JSON.stringify(value) ?? String(value);
-	} catch {
-		return String(value);
-	}
-}
-//#endregion
-//#region src/trace-analyst/otlp-span.ts
-/**
-* Canonical OTLP-flat-line readers shared by every consumer of the
-* OTLP-JSONL wire shape (one OTLP span per line; the form
-* `flattenOtlpExportToNdjson` produces and the form AppWorld / HALO
-* emit via their OpenInference OTLP exporter).
-*
-* `OtlpFileTraceStore` indexes spans with these; `otlpToRunRecords`
-* aggregates spans into `RunRecord`s with the same readers. One parser,
-* one vocabulary — a divergence between the analyst's view of a trace and
-* the RunRecord projected from it is a class of bug this consolidation
-* removes by construction.
-*
-* Vocabulary. The readers understand BOTH dialects that appear in the
-* wild:
-*   - the substrate's own `llm.*` / `tool.*` / `span.kind` attributes
-*     (`flattenSpanAttributes` in `trace/otel.ts`), and
-*   - the OpenInference / inference-export attributes AppWorld / HALO
-*     emit (`openinference.span.kind`, `inference.observation_kind`,
-*     `inference.llm.input_tokens`, `llm.token_count.prompt`, …).
-*
-* Pure, no I/O.
-*/
-/**
-* Project one parsed OTLP-JSONL object to `ProjectedOtlpSpan`, or `null`
-* when the line is missing the mandatory `trace_id` + `span_id`.
-*/
-function projectOtlpFlatLine(raw) {
-	const trace_id = stringField(raw, "trace_id") ?? stringField(raw, "traceId");
-	const span_id = stringField(raw, "span_id") ?? stringField(raw, "spanId");
-	if (!trace_id || !span_id) return null;
-	const parent_id = normalizeParentSpanId(trace_id, span_id, stringField(raw, "parent_span_id") ?? stringField(raw, "parentSpanId") ?? null);
-	const name = stringField(raw, "name") ?? "unknown";
-	const start_time = stringField(raw, "start_time") ?? stringField(raw, "startTime") ?? "";
-	const end_time = stringField(raw, "end_time") ?? stringField(raw, "endTime") ?? start_time;
-	const status = readOtlpStatus(raw);
-	const attributes = extractOtlpAttributes(raw);
-	const service_name = asString(attributes["service.name"]) ?? asString(attributes["resource.attributes.service.name"]) ?? null;
-	const agent_name = asString(attributes["agent.name"]) ?? asString(attributes["inference.agent.name"]) ?? asString(attributes["inference.agent_name"]) ?? null;
-	const model_name = firstStringAttr(attributes, LLM_MODEL_ATTR_KEYS);
-	const tool_name = firstStringAttr(attributes, TOOL_NAME_ATTR_KEYS);
-	const kind = inferOtlpKind(attributes);
-	let duration_ms = 0;
-	if (start_time && end_time) {
-		const a = spanEpochMillis(start_time);
-		const b = spanEpochMillis(end_time);
-		if (a !== null && b !== null) duration_ms = Math.max(0, b - a);
-	}
-	return {
-		trace_id,
-		span_id,
-		parent_span_id: parent_id && parent_id.length > 0 ? parent_id : null,
-		name,
-		kind,
-		start_time,
-		end_time,
-		duration_ms,
-		status: status.code,
-		status_message: status.message,
-		service_name,
-		agent_name,
-		model_name,
-		tool_name,
-		attributes
-	};
-}
-function normalizeParentSpanId(traceId, spanId, parentId) {
-	if (!parentId) return null;
-	const prefix = `${traceId}:`;
-	return spanId.startsWith(prefix) && !parentId.startsWith(prefix) ? `${prefix}${parentId}` : parentId;
-}
-function readOtlpStatus(raw) {
-	const status = raw.status;
-	if (status && typeof status === "object" && !Array.isArray(status)) {
-		const codeRaw = status.code;
-		const code = codeRaw === "STATUS_CODE_OK" || codeRaw === "OK" ? "OK" : codeRaw === "STATUS_CODE_ERROR" || codeRaw === "ERROR" ? "ERROR" : "UNSET";
-		const messageRaw = status.message;
-		return {
-			code,
-			message: typeof messageRaw === "string" && messageRaw.length > 0 ? messageRaw : void 0
-		};
-	}
-	return {
-		code: "UNSET",
-		message: void 0
-	};
-}
-function inferOtlpKind(attrs) {
-	const opik = firstStringAttr(attrs, SPAN_KIND_ATTR_KEYS);
-	if (opik) {
-		const upper = opik.toUpperCase();
-		if (upper === "AGENT" || upper === "LLM" || upper === "TOOL" || upper === "CHAIN" || upper === "EVALUATOR" || upper === "GUARDRAIL" || upper === "SPAN") return upper;
-	}
-	return "UNKNOWN";
-}
-/**
-* Flatten OTLP `attributes` + `resource.attributes` into a single
-* dotted-key map. Span attributes override resource attributes when keys
-* overlap. Nested objects/arrays are preserved as-is.
-*/
-function extractOtlpAttributes(raw) {
-	const out = {};
-	const resource = raw.resource;
-	if (resource && typeof resource === "object" && !Array.isArray(resource)) {
-		const ra = resource.attributes;
-		if (ra && typeof ra === "object" && !Array.isArray(ra)) for (const [k, v] of Object.entries(ra)) out[k] = v;
-	}
-	const spanAttrs = raw.attributes;
-	if (spanAttrs && typeof spanAttrs === "object" && !Array.isArray(spanAttrs)) for (const [k, v] of Object.entries(spanAttrs)) out[k] = v;
-	return out;
-}
-function stringField(raw, key) {
-	const v = raw[key];
-	return typeof v === "string" ? v : void 0;
-}
-function asString(v) {
-	return typeof v === "string" && v.length > 0 ? v : null;
-}
-/** First non-empty string value across a list of candidate attribute keys. */
-function firstStringAttr(attrs, keys) {
-	for (const k of keys) {
-		const s = asString(attrs[k]);
-		if (s !== null) return s;
-	}
-	return null;
-}
-/**
-* Parse a span timestamp to epoch millis, or null when empty/unparseable. The
-* OTLP readers accept BOTH ISO-8601 and epoch-millis-string dialects, so raw
-* string comparison (`<`, `localeCompare`) mis-orders across dialects and
-* `Date.parse` returns NaN for a bare epoch-millis string.
-*/
-function spanEpochMillis(ts) {
-	if (!ts) return null;
-	if (/^\d+$/.test(ts)) return Number(ts);
-	const n = Date.parse(ts);
-	return Number.isNaN(n) ? null : n;
-}
-/**
-* Order comparator for span timestamps across mixed ISO/epoch dialects.
-* Unparseable timestamps sort as epoch 0 (earliest), never NaN (which would
-* make the sort non-deterministic).
-*/
-function compareSpanTime(a, b) {
-	return (spanEpochMillis(a) ?? 0) - (spanEpochMillis(b) ?? 0);
-}
-//#endregion
-//#region src/trace-analyst/errors.ts
-/** Invalid trace-tool arguments, including malformed filters and regexes. */
-var TraceAnalysisValidationError = class extends ValidationError {};
-/** A trace read cannot fit within a documented count or byte limit. */
-var TraceAnalysisLimitError = class extends LimitExceededError {
-	operation;
-	actual;
-	limit;
-	constructor(operation, actual, limit, message) {
-		super(message ?? `${operation} produced ${actual}, over the limit of ${limit}`);
-		this.operation = operation;
-		this.actual = actual;
-		this.limit = limit;
-	}
-};
-/** A supplied store returned a shape that violates the trace read contract. */
-var TraceAnalysisStoreContractError = class extends AgentEvalError {
-	operation;
-	constructor(operation, message, options) {
-		super("backend_integrity", `${operation}: ${message}`, options);
-		this.operation = operation;
-	}
-};
-var TraceFileMissingError = class extends NotFoundError {
-	path;
-	constructor(path) {
-		super(`trace file not found: ${path}`);
-		this.path = path;
-	}
-};
-var TraceFileTooLargeError = class extends TraceAnalysisLimitError {
-	path;
-	size_bytes;
-	max_bytes;
-	constructor(path, size_bytes, max_bytes) {
-		super("OtlpFileTraceStore.readBuffer", size_bytes, max_bytes, `trace file ${path} is ${size_bytes} bytes, over the ${max_bytes}-byte limit; raise OtlpFileTraceStoreOptions.maxFileBytes or pre-split the file`);
-		this.path = path;
-		this.size_bytes = size_bytes;
-		this.max_bytes = max_bytes;
-	}
-};
-var TraceFileMalformedError = class extends CaptureIntegrityError {
-	path;
-	line_number;
-	byte_offset;
-	constructor(path, line_number, byte_offset, cause) {
-		super(`malformed trace row in ${path} at line ${line_number}, byte ${byte_offset}`, { cause });
-		this.path = path;
-		this.line_number = line_number;
-		this.byte_offset = byte_offset;
-	}
-};
-var TraceNotFoundError = class extends NotFoundError {
-	trace_id;
-	constructor(trace_id) {
-		super(`trace not found: ${trace_id}`);
-		this.trace_id = trace_id;
-	}
-};
-var SpanNotFoundError = class extends NotFoundError {
-	trace_id;
-	span_id;
-	constructor(trace_id, span_id) {
-		super(`span ${span_id} not found in trace ${trace_id}`);
-		this.trace_id = trace_id;
-		this.span_id = span_id;
-	}
-};
-//#endregion
-//#region src/trace-analyst/shared-abortable-task.ts
-function createSharedAbortableTask(factory) {
-	const controller = new AbortController();
-	const task = {
-		controller,
-		promise: factory(controller.signal),
-		consumers: 0,
-		settled: false
-	};
-	task.promise.then(() => {
-		task.settled = true;
-	}, () => {
-		task.settled = true;
-	});
-	return task;
-}
-function waitForSharedTask(task, signal) {
-	signal?.throwIfAborted();
-	task.consumers += 1;
-	return new Promise((resolve, reject) => {
-		let finished = false;
-		const finish = (callback) => {
-			if (finished) return;
-			finished = true;
-			signal?.removeEventListener("abort", onAbort);
-			task.consumers -= 1;
-			callback();
-		};
-		const onAbort = () => {
-			finish(() => {
-				reject(signal?.reason);
-				if (!task.settled && task.consumers === 0) task.controller.abort(signal?.reason);
-			});
-		};
-		signal?.addEventListener("abort", onAbort, { once: true });
-		task.promise.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
-		if (signal?.aborted) onAbort();
-	});
-}
-//#endregion
-//#region src/trace-analyst/store-contract.ts
-const TRACE_ANALYSIS_LIMITS = {
-	sampleTraceIds: 20,
-	queryTraces: 200,
-	viewSpans: 100,
-	searchMatches: 500,
-	filterValues: 100,
-	identifierCharacters: 256,
-	regexCharacters: 4096,
-	minimumTextBudget: 64
-};
-//#endregion
-//#region src/trace-analyst/types.ts
-const DEFAULT_TRACE_ANALYST_BUDGETS = {
-	perCallByteCeiling: 15e4,
-	perAttributeViewBudget: 4096,
-	perAttributeSpanBudget: 16384,
-	perMatchTextBudget: 1024
-};
-/** Marker substituted in place of truncated string payloads. Callers
-*  parsing tool output can detect it deterministically. */
-const TRACE_ANALYST_TRUNCATION_MARKER_PREFIX = "[trace-analyst truncated:";
-//#endregion
-//#region src/trace-analyst/store-bounds.ts
-function resolveTraceBudgets(overrides) {
-	const budgets = {
-		...DEFAULT_TRACE_ANALYST_BUDGETS,
-		...overrides
-	};
-	validateInteger(budgets.perCallByteCeiling, "perCallByteCeiling", 1);
-	for (const name of [
-		"perAttributeViewBudget",
-		"perAttributeSpanBudget",
-		"perMatchTextBudget"
-	]) validateInteger(budgets[name], name, TRACE_ANALYSIS_LIMITS.minimumTextBudget);
-	return budgets;
-}
-function boundOverview(result, byteCeiling) {
-	if (result.sample_trace_ids.length > result.total_traces) throw contractError("getOverview", "sample_trace_ids contains more entries than total_traces");
-	if (result.errors.trace_count > result.total_traces) throw contractError("getOverview", "errors.trace_count exceeds total_traces");
-	return withinByteCeiling("getOverview", result, byteCeiling);
-}
-function boundTracePage(result, input, byteCeiling) {
-	if (result.traces.length > input.limit) throw contractError("queryTraces", `store returned ${result.traces.length} traces for limit ${input.limit}`);
-	if (result.total < input.offset + result.traces.length) throw contractError("queryTraces", `total ${result.total} is smaller than the returned page ending at ${input.offset + result.traces.length}`);
-	if (result.has_more !== input.offset + result.traces.length < result.total) throw contractError("queryTraces", "has_more does not match the returned page position and total");
-	if (result.has_more && result.traces.length === 0) throw contractError("queryTraces", "store reported more traces without returning any progress");
-	const traces = [];
-	for (const trace of result.traces) {
-		if (encodedBytes("queryTraces", {
-			traces: [...traces, trace],
-			total: result.total,
-			has_more: true
-		}) > byteCeiling) break;
-		traces.push(trace);
-	}
-	if (result.traces.length > 0 && traces.length === 0) throw responseItemTooLarge("queryTraces", {
-		traces: [result.traces[0]],
-		total: result.total,
-		has_more: true
-	}, byteCeiling);
-	return withinByteCeiling("queryTraces", {
-		traces,
-		total: result.total,
-		has_more: result.has_more || traces.length < result.traces.length
-	}, byteCeiling);
-}
-function boundTraceView(result, expectedTraceId, perAttributeCap, byteCeiling) {
-	requireEqual("viewTrace", "trace_id", result.trace_id, expectedTraceId);
-	if (result.oversized) return withinByteCeiling("viewTrace", result, byteCeiling);
-	const spans = result.spans.map((span) => {
-		requireEqual("viewTrace", "span.trace_id", span.trace_id, expectedTraceId);
-		return truncateSpanAttributes("viewTrace", span, perAttributeCap).span;
-	});
-	const full = {
-		trace_id: expectedTraceId,
-		spans
-	};
-	if (encodedBytes("viewTrace", full) <= byteCeiling) return full;
-	return withinByteCeiling("viewTrace", {
-		trace_id: expectedTraceId,
-		oversized: oversizedFromSpans(spans)
-	}, byteCeiling);
-}
-function boundSpansView(result, expectedTraceId, requested, existingSpanIds, perAttributeCap, byteCeiling) {
-	requireEqual("viewSpans", "trace_id", result.trace_id, expectedTraceId);
-	const requestedSet = new Set(requested);
-	const missing = checkedAccountingIds("missing_span_ids", result.missing_span_ids, requestedSet);
-	const omitted = checkedAccountingIds("omitted_span_ids", result.omitted_span_ids, requestedSet);
-	const missingSet = new Set(missing);
-	const omittedSet = new Set(omitted);
-	const expectedMissing = requested.filter((id) => !existingSpanIds.has(id));
-	if (expectedMissing.length !== missing.length || expectedMissing.some((id) => !missingSet.has(id))) throw contractError("viewSpans", "missing_span_ids does not match the store existence checks");
-	if (result.has_more !== omitted.length > 0) throw contractError("viewSpans", "has_more must be true exactly when omitted_span_ids is non-empty");
-	if (result.spans.length === 0 && requested.some((id) => existingSpanIds.has(id) && omittedSet.has(id))) throw contractError("viewSpans", "store omitted every existing requested span instead of returning progress or throwing a size error");
-	const projected = /* @__PURE__ */ new Map();
-	for (const span of result.spans) {
-		requireEqual("viewSpans", "span.trace_id", span.trace_id, expectedTraceId);
-		if (!requestedSet.has(span.span_id)) throw contractError("viewSpans", `store returned unrequested span ${JSON.stringify(span.span_id)}`);
-		if (missingSet.has(span.span_id) || omittedSet.has(span.span_id)) throw contractError("viewSpans", `span ${JSON.stringify(span.span_id)} is both returned and unavailable`);
-		if (projected.has(span.span_id)) throw contractError("viewSpans", `store returned duplicate span ${JSON.stringify(span.span_id)}`);
-		projected.set(span.span_id, truncateSpanAttributes("viewSpans", span, perAttributeCap));
-	}
-	for (const id of requested) if (!missingSet.has(id) && !omittedSet.has(id) && !projected.has(id)) throw contractError("viewSpans", `store did not account for requested span ${JSON.stringify(id)}`);
-	const spans = [];
-	let addedTruncations = 0;
-	const build = () => ({
-		trace_id: expectedTraceId,
-		spans,
-		missing_span_ids: requested.filter((id) => missingSet.has(id)),
-		omitted_span_ids: requested.filter((id) => omittedSet.has(id)),
-		has_more: omittedSet.size > 0,
-		truncated_attribute_count: result.truncated_attribute_count + addedTruncations
-	});
-	withinByteCeiling("viewSpans", build(), byteCeiling);
-	for (const id of requested) {
-		const item = projected.get(id);
-		if (!item) continue;
-		spans.push(item.span);
-		omittedSet.delete(id);
-		addedTruncations += item.truncations;
-		if (encodedBytes("viewSpans", build()) <= byteCeiling) continue;
-		spans.pop();
-		omittedSet.add(id);
-		addedTruncations -= item.truncations;
-	}
-	if (projected.size > 0 && spans.length === 0) {
-		const first = projected.values().next().value;
-		if (first) throw responseItemTooLarge("viewSpans", {
-			trace_id: expectedTraceId,
-			spans: [first.span],
-			missing_span_ids: [],
-			omitted_span_ids: [],
-			has_more: false,
-			truncated_attribute_count: result.truncated_attribute_count + first.truncations
-		}, byteCeiling);
-	}
-	return withinByteCeiling("viewSpans", build(), byteCeiling);
-}
-function boundTraceSearch(result, expectedTraceId, maxMatches, budgets) {
-	requireEqual("searchTrace", "trace_id", result.trace_id, expectedTraceId);
-	return {
-		trace_id: expectedTraceId,
-		...boundSearchHits("searchTrace", result, maxMatches, budgets, (hit) => {
-			requireEqual("searchTrace", "hit.trace_id", hit.trace_id, expectedTraceId);
-		})
-	};
-}
-function boundSpanSearch(result, expectedTraceId, expectedSpanId, maxMatches, budgets) {
-	requireEqual("searchSpan", "trace_id", result.trace_id, expectedTraceId);
-	requireEqual("searchSpan", "span_id", result.span_id, expectedSpanId);
-	return {
-		trace_id: expectedTraceId,
-		span_id: expectedSpanId,
-		...boundSearchHits("searchSpan", result, maxMatches, budgets, (hit) => {
-			requireEqual("searchSpan", "hit.trace_id", hit.trace_id, expectedTraceId);
-			requireEqual("searchSpan", "hit.span_id", hit.span_id, expectedSpanId);
-		})
-	};
-}
-function boundSearchHits(operation, result, maxMatches, budgets, validateHit) {
-	if (result.hits.length > maxMatches) throw contractError(operation, `store returned ${result.hits.length} hits for max_matches ${maxMatches}`);
-	if (result.has_more && result.hits.length === 0) throw contractError(operation, "store reported more matches without returning any progress");
-	const hits = [];
-	for (const raw of result.hits) {
-		validateHit(raw);
-		const hit = truncateMatchRecord(raw, budgets.perMatchTextBudget);
-		if (encodedBytes(operation, {
-			hits: [...hits, hit],
-			has_more: true
-		}) > budgets.perCallByteCeiling) break;
-		hits.push(hit);
-	}
-	if (result.hits.length > 0 && hits.length === 0) throw responseItemTooLarge(operation, {
-		hits: [truncateMatchRecord(result.hits[0], budgets.perMatchTextBudget)],
-		has_more: true
-	}, budgets.perCallByteCeiling);
-	return withinByteCeiling(operation, {
-		hits,
-		has_more: result.has_more || hits.length < result.hits.length
-	}, budgets.perCallByteCeiling);
-}
-function checkedAccountingIds(label, ids, requested) {
-	const seen = /* @__PURE__ */ new Set();
-	for (const id of ids) {
-		if (!requested.has(id)) throw contractError("viewSpans", `${label} contains unrequested id ${JSON.stringify(id)}`);
-		if (seen.has(id)) throw contractError("viewSpans", `${label} contains duplicate id ${JSON.stringify(id)}`);
-		seen.add(id);
-	}
-	return [...ids];
-}
-function truncateMatchRecord(record, cap) {
-	return {
-		...record,
-		span_name: truncateForBudget(record.span_name, cap),
-		attribute_path: truncateForBudget(record.attribute_path, cap),
-		matched_text: truncateForBudget(record.matched_text, cap),
-		context_before: truncateForBudget(record.context_before, cap),
-		context_after: truncateForBudget(record.context_after, cap)
-	};
-}
-function truncateSpanAttributes(operation, span, cap) {
-	const attributes = {};
-	let truncations = 0;
-	for (const [key, value] of Object.entries(span.attributes)) {
-		if (typeof value === "string") {
-			const truncated = truncateForBudget(value, cap);
-			if (truncated !== value) truncations += 1;
-			attributes[key] = truncated;
-			continue;
-		}
-		if (value !== null && typeof value === "object") {
-			let json;
-			try {
-				json = JSON.stringify(value);
-			} catch (cause) {
-				throw new TraceAnalysisStoreContractError(operation, `span attribute ${JSON.stringify(key)} is not JSON-serializable`, { cause });
-			}
-			const truncated = truncateForBudget(json, cap);
-			if (truncated !== json) {
-				truncations += 1;
-				attributes[key] = truncated;
-			} else attributes[key] = value;
-			continue;
-		}
-		attributes[key] = value;
-	}
-	return {
-		span: {
-			...span,
-			attributes
-		},
-		truncations
-	};
-}
-function oversizedFromSpans(spans) {
-	const names = /* @__PURE__ */ new Map();
-	let maxBytes = 0;
-	let errors = 0;
-	for (const span of spans) {
-		names.set(span.name, (names.get(span.name) ?? 0) + 1);
-		maxBytes = Math.max(maxBytes, encodedBytes("viewTrace", span));
-		if (span.status === "ERROR") errors += 1;
-	}
-	return {
-		span_count: spans.length,
-		top_span_names: [...names.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 20),
-		span_response_bytes_max: maxBytes,
-		error_span_count: errors
-	};
-}
-function compileSearchRegex(pattern) {
-	if (typeof pattern !== "string" || pattern.length === 0) throw new TraceAnalysisValidationError("regex_pattern must be a non-empty string");
-	let source = pattern;
-	let flags = RE2JS.MULTILINE;
-	if (source.startsWith("(?i)")) {
-		source = source.slice(4);
-		flags |= RE2JS.CASE_INSENSITIVE;
-	}
-	try {
-		return RE2JS.compile(source, flags);
-	} catch (cause) {
-		throw new TraceAnalysisValidationError(`regex_pattern is invalid: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
-	}
-}
-function truncateForBudget(value, byteCap) {
-	validateInteger(byteCap, "byteCap", TRACE_ANALYSIS_LIMITS.minimumTextBudget);
-	const original = Buffer.byteLength(value, "utf8");
-	if (original <= byteCap) return value;
-	const marker = `\n[trace-analyst truncated: original ${original} bytes]`;
-	const contentCap = byteCap - Buffer.byteLength(marker, "utf8");
-	let cut = Math.max(0, Math.floor(value.length * contentCap / original));
-	while (cut > 0 && Buffer.byteLength(value.slice(0, cut), "utf8") > contentCap) cut -= 1;
-	return `${value.slice(0, cut)}${marker}`;
-}
-function validateInteger(value, label, minimum, maximum = Number.MAX_SAFE_INTEGER) {
-	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum || value > maximum) throw new TraceAnalysisValidationError(`${label} must be an integer ${minimum}..${maximum}, got ${String(value)}`);
-	return value;
-}
-function requireEqual(operation, label, actual, expected) {
-	if (actual !== expected) throw contractError(operation, `${label} ${JSON.stringify(actual)} does not match ${JSON.stringify(expected)}`);
-}
-function encodedBytes(operation, value) {
-	try {
-		const encoded = JSON.stringify(value);
-		if (encoded === void 0) throw new TypeError("JSON.stringify returned undefined");
-		return Buffer.byteLength(encoded, "utf8");
-	} catch (cause) {
-		if (cause instanceof TraceAnalysisStoreContractError) throw cause;
-		throw new TraceAnalysisStoreContractError(operation, "store result is not JSON-serializable", { cause });
-	}
-}
-function withinByteCeiling(operation, value, ceiling) {
-	const actual = encodedBytes(operation, value);
-	if (actual > ceiling) throw new TraceAnalysisLimitError(operation, actual, ceiling, `${operation} metadata requires ${actual} bytes, over the ${ceiling}-byte response limit`);
-	return value;
-}
-function responseItemTooLarge(operation, value, ceiling) {
-	return new TraceAnalysisLimitError(operation, encodedBytes(operation, value), ceiling, `${operation} cannot fit one result item in the ${ceiling}-byte response limit`);
-}
-function contractError(operation, message) {
-	return new TraceAnalysisStoreContractError(operation, message);
-}
-//#endregion
-//#region src/trace-analyst/store-schemas.ts
-const identifier = z.string().min(1).max(TRACE_ANALYSIS_LIMITS.identifierCharacters);
-const timestamp = z.iso.datetime({ offset: true });
-const nonNegativeInteger = z.number().int().nonnegative();
-const nonNegativeNumber = z.number().nonnegative();
-const nullableString = z.string().nullable();
-const nullableIdentifier = identifier.nullable();
-const stringArray = z.array(z.string());
-const filterValues = z.array(identifier).max(TRACE_ANALYSIS_LIMITS.filterValues);
-const traceFiltersSchema = z.object({
-	has_errors: z.boolean().optional(),
-	service_names: filterValues.optional(),
-	agent_names: filterValues.optional(),
-	model_names: filterValues.optional(),
-	tool_names: filterValues.optional(),
-	start_time_after: timestamp.optional(),
-	start_time_before: timestamp.optional(),
-	regex_pattern: z.string().min(1).max(TRACE_ANALYSIS_LIMITS.regexCharacters).optional()
-}).strict();
-const byteCap = z.number().int().min(TRACE_ANALYSIS_LIMITS.minimumTextBudget);
-const searchPattern = z.string().min(1).max(TRACE_ANALYSIS_LIMITS.regexCharacters);
-const traceStoreInputSchemas = {
-	hasTrace: z.object({ trace_id: identifier }).strict(),
-	hasSpans: z.object({
-		trace_id: identifier,
-		span_ids: z.array(identifier).min(1).max(TRACE_ANALYSIS_LIMITS.viewSpans)
-	}).strict(),
-	getOverview: z.object({ filters: traceFiltersSchema.optional() }).strict(),
-	queryTraces: z.object({
-		filters: traceFiltersSchema.optional(),
-		limit: z.number().int().min(1).max(TRACE_ANALYSIS_LIMITS.queryTraces),
-		offset: z.number().int().nonnegative().optional()
-	}).strict(),
-	countTraces: z.object({ filters: traceFiltersSchema.optional() }).strict(),
-	viewTrace: z.object({
-		trace_id: identifier,
-		per_attribute_byte_cap: byteCap.optional()
-	}).strict(),
-	viewSpans: z.object({
-		trace_id: identifier,
-		span_ids: z.array(identifier).min(1).max(TRACE_ANALYSIS_LIMITS.viewSpans),
-		per_attribute_byte_cap: byteCap.optional()
-	}).strict(),
-	searchTrace: z.object({
-		trace_id: identifier,
-		regex_pattern: searchPattern,
-		max_matches: z.number().int().min(1).max(TRACE_ANALYSIS_LIMITS.searchMatches).default(50)
-	}).strict(),
-	searchSpan: z.object({
-		trace_id: identifier,
-		span_id: identifier,
-		regex_pattern: searchPattern,
-		max_matches: z.number().int().min(1).max(TRACE_ANALYSIS_LIMITS.searchMatches).default(50)
-	}).strict()
-};
-const spanKind = z.enum([
-	"AGENT",
-	"LLM",
-	"TOOL",
-	"CHAIN",
-	"EVALUATOR",
-	"GUARDRAIL",
-	"SPAN",
-	"UNKNOWN"
-]);
-const spanStatus = z.enum([
-	"OK",
-	"ERROR",
-	"UNSET"
-]);
-const traceSpan = z.object({
-	trace_id: identifier,
-	span_id: identifier,
-	parent_span_id: nullableIdentifier,
-	name: z.string(),
-	kind: spanKind,
-	start_time: timestamp,
-	end_time: timestamp,
-	duration_ms: nonNegativeNumber,
-	status: spanStatus,
-	status_message: z.string().optional(),
-	service_name: nullableString,
-	agent_name: nullableString,
-	model_name: nullableString,
-	tool_name: nullableString,
-	attributes: z.record(z.string(), z.json())
-}).strict();
-const traceSummary = z.object({
-	trace_id: identifier,
-	service_name: nullableString,
-	agent_name: nullableString,
-	span_count: nonNegativeInteger,
-	has_errors: z.boolean(),
-	start_time: timestamp,
-	end_time: timestamp,
-	duration_ms: nonNegativeNumber,
-	raw_jsonl_bytes: nonNegativeInteger,
-	models: stringArray,
-	tools: stringArray
-}).strict();
-const errorCluster = z.object({
-	signature: z.string(),
-	status_message_sample: z.string(),
-	span_name: nullableString,
-	tool_name: nullableString,
-	trace_count: nonNegativeInteger,
-	span_count: nonNegativeInteger,
-	prevalence: z.number().min(0).max(1),
-	exemplar_trace_ids: z.array(identifier),
-	exemplar_span_ids: z.array(identifier)
-}).strict();
-const overview = z.object({
-	total_traces: nonNegativeInteger,
-	raw_jsonl_bytes: nonNegativeInteger,
-	services: stringArray,
-	agents: stringArray,
-	models: stringArray,
-	tool_names: stringArray,
-	sample_trace_ids: z.array(identifier).max(TRACE_ANALYSIS_LIMITS.sampleTraceIds),
-	errors: z.object({
-		trace_count: nonNegativeInteger,
-		span_count: nonNegativeInteger
-	}).strict(),
-	error_clusters: z.array(errorCluster),
-	time_range: z.object({
-		earliest: timestamp,
-		latest: timestamp
-	}).strict().nullable()
-}).strict();
-const tracePage = z.object({
-	traces: z.array(traceSummary),
-	total: nonNegativeInteger,
-	has_more: z.boolean()
-}).strict();
-const oversizedTrace = z.object({
-	span_count: nonNegativeInteger,
-	top_span_names: z.array(z.tuple([z.string(), nonNegativeInteger])).max(20),
-	span_response_bytes_max: nonNegativeInteger,
-	error_span_count: nonNegativeInteger
-}).strict();
-const traceView = z.object({
-	trace_id: identifier,
-	spans: z.array(traceSpan).optional(),
-	oversized: oversizedTrace.optional()
-}).strict().refine((value) => value.spans === void 0 !== (value.oversized === void 0), { message: "exactly one of spans or oversized is required" });
-const spansView = z.object({
-	trace_id: identifier,
-	spans: z.array(traceSpan),
-	missing_span_ids: z.array(identifier),
-	omitted_span_ids: z.array(identifier),
-	has_more: z.boolean(),
-	truncated_attribute_count: nonNegativeInteger
-}).strict();
-const matchRecord = z.object({
-	trace_id: identifier,
-	span_id: identifier,
-	span_name: z.string(),
-	span_kind: spanKind,
-	attribute_path: z.string(),
-	matched_text: z.string(),
-	context_before: z.string(),
-	context_after: z.string(),
-	match_offset: nonNegativeInteger
-}).strict();
-const traceSearch = z.object({
-	trace_id: identifier,
-	hits: z.array(matchRecord),
-	has_more: z.boolean()
-}).strict();
-const spanSearch = traceSearch.extend({ span_id: identifier }).strict();
-const traceStoreOutputSchemas = {
-	hasTrace: z.boolean(),
-	hasSpans: z.array(identifier).max(TRACE_ANALYSIS_LIMITS.viewSpans),
-	getOverview: overview,
-	queryTraces: tracePage,
-	countTraces: nonNegativeInteger,
-	viewTrace: traceView,
-	viewSpans: spansView,
-	searchTrace: traceSearch,
-	searchSpan: spanSearch
-};
-function parseTraceInput(operation, schema, value) {
-	try {
-		return schema.parse(value);
-	} catch (cause) {
-		throw new TraceAnalysisValidationError(`${operation}: invalid arguments: ${cause instanceof z.ZodError ? z.prettifyError(cause) : String(cause)}`, { cause });
-	}
-}
-function parseStoreOutput(operation, schema, value) {
-	try {
-		return schema.parse(value);
-	} catch (cause) {
-		throw new TraceAnalysisStoreContractError(operation, `invalid store result: ${cause instanceof z.ZodError ? z.prettifyError(cause) : String(cause)}`, { cause });
-	}
-}
-function toTraceJsonSchema(schema) {
-	return z.toJSONSchema(schema, { target: "draft-7" });
-}
-//#endregion
-//#region src/trace-analyst/store-boundary.ts
-/** Apply the public validation, cancellation, not-found, and size rules to any adapter. */
-function createBoundedTraceAnalysisStore(source, options = {}) {
-	const budgets = resolveTraceBudgets(options.budgets);
-	return {
-		async hasTrace(traceId, context) {
-			throwIfAborted(context);
-			const { trace_id } = parseTraceInput("hasTrace", traceStoreInputSchemas.hasTrace, { trace_id: traceId });
-			const result = await source.hasTrace(trace_id, context);
-			throwIfAborted(context);
-			return parseStoreOutput("hasTrace", traceStoreOutputSchemas.hasTrace, result);
-		},
-		async hasSpans(input, context) {
-			throwIfAborted(context);
-			const parsed = parseTraceInput("hasSpans", traceStoreInputSchemas.hasSpans, input);
-			assertUniqueIds(parsed.span_ids, "hasSpans.span_ids");
-			const result = await source.hasSpans(parsed, context);
-			throwIfAborted(context);
-			return validateExistingSpanIds(parseStoreOutput("hasSpans", traceStoreOutputSchemas.hasSpans, result), parsed.span_ids);
-		},
-		async getOverview(filters, context) {
-			throwIfAborted(context);
-			const input = parseTraceInput("getOverview", traceStoreInputSchemas.getOverview, { filters });
-			const result = await source.getOverview(input.filters, context);
-			throwIfAborted(context);
-			return boundOverview(parseStoreOutput("getOverview", traceStoreOutputSchemas.getOverview, result), budgets.perCallByteCeiling);
-		},
-		async queryTraces(input, context) {
-			throwIfAborted(context);
-			const parsed = parseTraceInput("queryTraces", traceStoreInputSchemas.queryTraces, input);
-			const offset = parsed.offset ?? 0;
-			const result = await source.queryTraces({
-				...parsed,
-				offset
-			}, context);
-			throwIfAborted(context);
-			return boundTracePage(parseStoreOutput("queryTraces", traceStoreOutputSchemas.queryTraces, result), {
-				limit: parsed.limit,
-				offset
-			}, budgets.perCallByteCeiling);
-		},
-		async countTraces(filters, context) {
-			throwIfAborted(context);
-			const input = parseTraceInput("countTraces", traceStoreInputSchemas.countTraces, { filters });
-			const result = await source.countTraces(input.filters, context);
-			throwIfAborted(context);
-			return parseStoreOutput("countTraces", traceStoreOutputSchemas.countTraces, result);
-		},
-		async viewTrace(input, context) {
-			throwIfAborted(context);
-			const parsed = parseTraceInput("viewTrace", traceStoreInputSchemas.viewTrace, input);
-			await requireTrace(source, parsed.trace_id, context);
-			const perAttributeCap = parsed.per_attribute_byte_cap ?? budgets.perAttributeViewBudget;
-			const result = await source.viewTrace({
-				...parsed,
-				per_attribute_byte_cap: perAttributeCap
-			}, context);
-			throwIfAborted(context);
-			return boundTraceView(parseStoreOutput("viewTrace", traceStoreOutputSchemas.viewTrace, result), parsed.trace_id, perAttributeCap, budgets.perCallByteCeiling);
-		},
-		async viewSpans(input, context) {
-			throwIfAborted(context);
-			const parsed = parseTraceInput("viewSpans", traceStoreInputSchemas.viewSpans, input);
-			assertUniqueIds(parsed.span_ids, "viewSpans.span_ids");
-			await requireTrace(source, parsed.trace_id, context);
-			const existingSpanIds = new Set(validateExistingSpanIds(parseStoreOutput("hasSpans", traceStoreOutputSchemas.hasSpans, await source.hasSpans({
-				trace_id: parsed.trace_id,
-				span_ids: parsed.span_ids
-			}, context)), parsed.span_ids));
-			throwIfAborted(context);
-			const perAttributeCap = parsed.per_attribute_byte_cap ?? budgets.perAttributeSpanBudget;
-			const result = await source.viewSpans({
-				...parsed,
-				per_attribute_byte_cap: perAttributeCap
-			}, context);
-			throwIfAborted(context);
-			return boundSpansView(parseStoreOutput("viewSpans", traceStoreOutputSchemas.viewSpans, result), parsed.trace_id, parsed.span_ids, existingSpanIds, perAttributeCap, budgets.perCallByteCeiling);
-		},
-		async searchTrace(input, context) {
-			throwIfAborted(context);
-			const parsed = parseTraceInput("searchTrace", traceStoreInputSchemas.searchTrace, input);
-			compileSearchRegex(parsed.regex_pattern);
-			await requireTrace(source, parsed.trace_id, context);
-			const result = await source.searchTrace(parsed, context);
-			throwIfAborted(context);
-			return boundTraceSearch(parseStoreOutput("searchTrace", traceStoreOutputSchemas.searchTrace, result), parsed.trace_id, parsed.max_matches, budgets);
-		},
-		async searchSpan(input, context) {
-			throwIfAborted(context);
-			const parsed = parseTraceInput("searchSpan", traceStoreInputSchemas.searchSpan, input);
-			compileSearchRegex(parsed.regex_pattern);
-			await requireTrace(source, parsed.trace_id, context);
-			await requireSpan(source, parsed.trace_id, parsed.span_id, context);
-			const result = await source.searchSpan(parsed, context);
-			throwIfAborted(context);
-			return boundSpanSearch(parseStoreOutput("searchSpan", traceStoreOutputSchemas.searchSpan, result), parsed.trace_id, parsed.span_id, parsed.max_matches, budgets);
-		}
-	};
-}
-async function requireTrace(source, traceId, context) {
-	throwIfAborted(context);
-	const exists = await source.hasTrace(traceId, context);
-	throwIfAborted(context);
-	if (!parseStoreOutput("hasTrace", traceStoreOutputSchemas.hasTrace, exists)) throw new TraceNotFoundError(traceId);
-}
-async function requireSpan(source, traceId, spanId, context) {
-	throwIfAborted(context);
-	const existing = await source.hasSpans({
-		trace_id: traceId,
-		span_ids: [spanId]
-	}, context);
-	throwIfAborted(context);
-	if (validateExistingSpanIds(parseStoreOutput("hasSpans", traceStoreOutputSchemas.hasSpans, existing), [spanId]).length === 0) throw new SpanNotFoundError(traceId, spanId);
-}
-function validateExistingSpanIds(found, requested) {
-	const requestedSet = new Set(requested);
-	const seen = /* @__PURE__ */ new Set();
-	for (const id of found) {
-		if (!requestedSet.has(id)) throw new TraceAnalysisStoreContractError("hasSpans", `hasSpans returned unrequested span id ${JSON.stringify(id)}`);
-		if (seen.has(id)) throw new TraceAnalysisStoreContractError("hasSpans", `hasSpans returned duplicate span id ${JSON.stringify(id)}`);
-		seen.add(id);
-	}
-	return [...found];
-}
-function assertUniqueIds(ids, label) {
-	if (new Set(ids).size !== ids.length) throw new TraceAnalysisValidationError(`${label} must not contain duplicates`);
-}
-function throwIfAborted(context) {
-	context?.signal?.throwIfAborted();
-}
-//#endregion
-//#region src/trace-analyst/store-otlp.ts
-/**
-* `OtlpFileTraceStore` — read-only OTLP-JSONL trace store for the
-* trace-analyst.
-*
-* Wire shape. Each line of the input file is one OTLP-shaped span. The
-* store understands flattened OTLP JSONL plus the OpenInference vocab.
-* We project upstream's full
-* span shape down to `TraceAnalystSpan` lazily — full materialisation
-* only happens for the spans the agent actually requests.
-*
-* Indexing. On first read the store builds an in-memory index keyed
-* by `trace_id` carrying:
-*   - byte offsets + lengths for each span line (for surgical reads
-*     without re-parsing the whole file)
-*   - a `TraceAnalystTraceSummary` rollup
-*   - sets of services / agents / models / tools / has_errors
-*   - byte size of the trace's JSONL slab
-*
-* Memory bound. The index keeps span metadata only — names, kinds,
-* offsets, status. Attribute payloads stay on disk until requested.
-* For a 50MB JSONL with 50k spans, the index is ~5MB.
-*
-* Concurrency. The store builds the index once on first read and
-* caches it. Subsequent reads reuse the index. The file is opened on
-* each read; we never hold a long-lived FD.
-*/
-/** Lines indexed between event-loop yields. Bounded synchronous work per
-*  tick keeps the index build from starving other tasks on large files
-*  while staying coarse enough that the yields are cheap. */
-const INDEX_YIELD_LINES = 5e3;
-const SCAN_YIELD_ITEMS = 500;
-/** Hand control back to the event loop without busy-waiting. */
-function yieldToEventLoop() {
-	return new Promise((resolve) => setImmediate(resolve));
-}
-async function scanCheckpoint(signal, item) {
-	signal?.throwIfAborted();
-	if (item > 0 && item % SCAN_YIELD_ITEMS === 0) {
-		await yieldToEventLoop();
-		signal?.throwIfAborted();
-	}
-}
-/** Default ceiling for {@link OtlpFileTraceStoreOptions.maxFileBytes}. */
-const DEFAULT_MAX_TRACE_FILE_BYTES = 256 * 1024 * 1024;
-var BufferedOtlpTraceStore = class {
-	perAttributeViewBudget;
-	perAttributeSpanBudget;
-	perCallByteCeiling;
-	perMatchTextBudget;
-	indexValue;
-	indexTask;
-	bufferValue;
-	bufferTask;
-	constructor(opts) {
-		this.perAttributeViewBudget = validateInteger(opts.perAttributeViewBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perAttributeViewBudget, "perAttributeViewBudget", TRACE_ANALYSIS_LIMITS.minimumTextBudget);
-		this.perAttributeSpanBudget = validateInteger(opts.perAttributeSpanBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perAttributeSpanBudget, "perAttributeSpanBudget", TRACE_ANALYSIS_LIMITS.minimumTextBudget);
-		this.perCallByteCeiling = validateInteger(opts.perCallByteCeiling ?? DEFAULT_TRACE_ANALYST_BUDGETS.perCallByteCeiling, "perCallByteCeiling", 1);
-		this.perMatchTextBudget = validateInteger(opts.perMatchTextBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perMatchTextBudget, "perMatchTextBudget", TRACE_ANALYSIS_LIMITS.minimumTextBudget);
-	}
-	async hasTrace(trace_id, context) {
-		context?.signal?.throwIfAborted();
-		const idx = await this.index(context);
-		context?.signal?.throwIfAborted();
-		return idx.byTrace.has(trace_id);
-	}
-	async hasSpans(opts, context) {
-		context?.signal?.throwIfAborted();
-		const trace = (await this.index(context)).byTrace.get(opts.trace_id);
-		if (!trace) return [];
-		const requested = new Set(opts.span_ids);
-		const found = [];
-		for (let index = 0; index < trace.spans.length; index += 1) {
-			await scanCheckpoint(context?.signal, index);
-			const spanId = trace.spans[index].span_id;
-			if (requested.has(spanId)) found.push(spanId);
-		}
-		return found;
-	}
-	async getOverview(filters, context) {
-		const idx = await this.index(context);
-		const matched = await this.matchedTraces(idx, filters, context);
-		const services = /* @__PURE__ */ new Set();
-		const agents = /* @__PURE__ */ new Set();
-		const models = /* @__PURE__ */ new Set();
-		const tools = /* @__PURE__ */ new Set();
-		let rawBytes = 0;
-		let earliest = null;
-		let latest = null;
-		let errorTraceCount = 0;
-		let errorSpanCount = 0;
-		const clusters = /* @__PURE__ */ new Map();
-		let traceIndex = 0;
-		for (const t of matched) {
-			await scanCheckpoint(context?.signal, traceIndex++);
-			if (t.service_name) services.add(t.service_name);
-			if (t.agent_name) agents.add(t.agent_name);
-			for (const m of t.models) models.add(m);
-			for (const tn of t.tools) tools.add(tn);
-			rawBytes += t.raw_jsonl_bytes;
-			if (!earliest || compareSpanTime(t.start_time, earliest) < 0) earliest = t.start_time;
-			if (!latest || compareSpanTime(t.end_time, latest) > 0) latest = t.end_time;
-			if (t.has_errors) {
-				errorTraceCount += 1;
-				let spanIndex = 0;
-				for (const s of t.spans) {
-					await scanCheckpoint(context?.signal, spanIndex++);
-					if (s.status !== "ERROR") continue;
-					errorSpanCount += 1;
-					accumulateErrorCluster(clusters, t.trace_id, s);
-				}
-			}
-		}
-		const sample_trace_ids = matched.slice(0, 20).map((t) => t.trace_id);
-		return {
-			total_traces: matched.length,
-			raw_jsonl_bytes: rawBytes,
-			services: [...services].sort(),
-			agents: [...agents].sort(),
-			models: [...models].sort(),
-			tool_names: [...tools].sort(),
-			sample_trace_ids,
-			errors: {
-				trace_count: errorTraceCount,
-				span_count: errorSpanCount
-			},
-			error_clusters: finalizeErrorClusters(clusters, errorTraceCount),
-			time_range: earliest && latest ? {
-				earliest,
-				latest
-			} : null
-		};
-	}
-	async queryTraces(opts, context) {
-		const limit = validateInteger(opts.limit, "queryTraces.limit", 1, TRACE_ANALYSIS_LIMITS.queryTraces);
-		const offset = validateInteger(opts.offset ?? 0, "queryTraces.offset", 0);
-		const idx = await this.index(context);
-		const matched = await this.matchedTraces(idx, opts.filters, context);
-		const slice = matched.slice(offset, offset + limit);
-		return {
-			traces: slice.map((t) => this.toSummary(t)),
-			total: matched.length,
-			has_more: offset + slice.length < matched.length
-		};
-	}
-	async countTraces(filters, context) {
-		const idx = await this.index(context);
-		return (await this.matchedTraces(idx, filters, context)).length;
-	}
-	async viewTrace(opts, context) {
-		context?.signal?.throwIfAborted();
-		const trace = (await this.index(context)).byTrace.get(opts.trace_id);
-		if (!trace) throw new TraceNotFoundError(opts.trace_id);
-		const cap = validateInteger(opts.per_attribute_byte_cap ?? this.perAttributeViewBudget, "viewTrace.per_attribute_byte_cap", 1);
-		const buf = await this.buffer(context);
-		const spans = [];
-		let runningBytes = 0;
-		let span_response_bytes_max = 0;
-		const counter = { value: 0 };
-		let spanIndex = 0;
-		for (const s of trace.spans) {
-			await scanCheckpoint(context?.signal, spanIndex++);
-			const projected = this.projectSpan(buf, trace.trace_id, s, cap, counter);
-			const bytes = Buffer.byteLength(JSON.stringify(projected), "utf8");
-			span_response_bytes_max = Math.max(span_response_bytes_max, bytes);
-			runningBytes += bytes;
-			if (runningBytes > this.perCallByteCeiling) return {
-				trace_id: trace.trace_id,
-				oversized: this.buildOversizedSummary(trace, span_response_bytes_max)
-			};
-			spans.push(projected);
-		}
-		return {
-			trace_id: trace.trace_id,
-			spans
-		};
-	}
-	async viewSpans(opts, context) {
-		context?.signal?.throwIfAborted();
-		const trace = (await this.index(context)).byTrace.get(opts.trace_id);
-		if (!trace) throw new TraceNotFoundError(opts.trace_id);
-		if (opts.span_ids.length < 1 || opts.span_ids.length > TRACE_ANALYSIS_LIMITS.viewSpans) throw new TraceAnalysisValidationError(`viewSpans.span_ids must contain 1..${TRACE_ANALYSIS_LIMITS.viewSpans} ids, got ${opts.span_ids.length}`);
-		const cap = validateInteger(opts.per_attribute_byte_cap ?? this.perAttributeSpanBudget, "viewSpans.per_attribute_byte_cap", 1);
-		const requested = [...new Set(opts.span_ids)];
-		const wantSet = new Set(requested);
-		const foundById = /* @__PURE__ */ new Map();
-		for (let index = 0; index < trace.spans.length; index += 1) {
-			await scanCheckpoint(context?.signal, index);
-			const span = trace.spans[index];
-			if (wantSet.has(span.span_id)) foundById.set(span.span_id, span);
-		}
-		const missing = requested.filter((id) => !foundById.has(id));
-		const buf = await this.buffer(context);
-		const spans = [];
-		let truncatedAttributeCount = 0;
-		const omitted = new Set(requested.filter((id) => foundById.has(id)));
-		const buildResult = () => ({
-			trace_id: trace.trace_id,
-			spans,
-			missing_span_ids: missing,
-			omitted_span_ids: requested.filter((id) => omitted.has(id)),
-			has_more: omitted.size > 0,
-			truncated_attribute_count: truncatedAttributeCount
-		});
-		const metadataBytes = Buffer.byteLength(JSON.stringify(buildResult()), "utf8");
-		if (metadataBytes > this.perCallByteCeiling) throw new TraceAnalysisLimitError("viewSpans", metadataBytes, this.perCallByteCeiling, `viewSpans accounting requires ${metadataBytes} bytes, over the ${this.perCallByteCeiling}-byte response limit`);
-		let spanIndex = 0;
-		let smallestRejectedBytes = Number.POSITIVE_INFINITY;
-		for (const id of requested) {
-			await scanCheckpoint(context?.signal, spanIndex++);
-			const s = foundById.get(id);
-			if (!s) continue;
-			const counter = { value: 0 };
-			const projected = this.projectSpan(buf, trace.trace_id, s, cap, counter);
-			spans.push(projected);
-			omitted.delete(id);
-			truncatedAttributeCount += counter.value;
-			const responseBytes = Buffer.byteLength(JSON.stringify(buildResult()), "utf8");
-			if (responseBytes <= this.perCallByteCeiling) continue;
-			smallestRejectedBytes = Math.min(smallestRejectedBytes, responseBytes);
-			if (requested.length === 1) throw new TraceAnalysisLimitError("viewSpans", responseBytes, this.perCallByteCeiling, `viewSpans cannot fit span ${JSON.stringify(id)} in the ${this.perCallByteCeiling}-byte response limit`);
-			spans.pop();
-			omitted.add(id);
-			truncatedAttributeCount -= counter.value;
-		}
-		if (foundById.size > 0 && spans.length === 0) throw new TraceAnalysisLimitError("viewSpans", smallestRejectedBytes, this.perCallByteCeiling, `viewSpans cannot fit one requested span in the ${this.perCallByteCeiling}-byte response limit`);
-		return buildResult();
-	}
-	async searchTrace(opts, context) {
-		const max_matches = validateInteger(opts.max_matches ?? 50, "searchTrace.max_matches", 1, TRACE_ANALYSIS_LIMITS.searchMatches);
-		const trace = (await this.index(context)).byTrace.get(opts.trace_id);
-		if (!trace) throw new TraceNotFoundError(opts.trace_id);
-		const re = compileSearchRegex(opts.regex_pattern);
-		const buf = await this.buffer(context);
-		const hits = [];
-		let hasMore = false;
-		let spanIndex = 0;
-		for (const s of trace.spans) {
-			await scanCheckpoint(context?.signal, spanIndex++);
-			const remaining = max_matches - hits.length;
-			const localHits = await this.scanSpanForMatches(buf, trace.trace_id, s, re, this.perMatchTextBudget, remaining, context);
-			for (const h of localHits.records) {
-				if (hits.length >= max_matches) break;
-				hits.push(h);
-			}
-			if (localHits.hasMore) {
-				hasMore = true;
-				break;
-			}
-		}
-		return {
-			trace_id: trace.trace_id,
-			hits,
-			has_more: hasMore
-		};
-	}
-	async searchSpan(opts, context) {
-		const max_matches = validateInteger(opts.max_matches ?? 50, "searchSpan.max_matches", 1, TRACE_ANALYSIS_LIMITS.searchMatches);
-		const trace = (await this.index(context)).byTrace.get(opts.trace_id);
-		if (!trace) throw new TraceNotFoundError(opts.trace_id);
-		let span;
-		for (let index = 0; index < trace.spans.length; index += 1) {
-			await scanCheckpoint(context?.signal, index);
-			const candidate = trace.spans[index];
-			if (candidate.span_id === opts.span_id) {
-				span = candidate;
-				break;
-			}
-		}
-		if (!span) throw new SpanNotFoundError(opts.trace_id, opts.span_id);
-		const re = compileSearchRegex(opts.regex_pattern);
-		const buf = await this.buffer(context);
-		const localHits = await this.scanSpanForMatches(buf, trace.trace_id, span, re, this.perMatchTextBudget, max_matches, context);
-		return {
-			trace_id: trace.trace_id,
-			span_id: span.span_id,
-			hits: localHits.records,
-			has_more: localHits.hasMore
-		};
-	}
-	/** Force the index to materialise. Useful to amortise startup cost
-	*  before the first agent call. */
-	async ensureIndexed(context) {
-		await this.index(context);
-	}
-	async buffer(context) {
-		context?.signal?.throwIfAborted();
-		if (this.bufferValue) return this.bufferValue;
-		if (!this.bufferTask) {
-			const task = createSharedAbortableTask((signal) => this.readBuffer(signal));
-			this.bufferTask = task;
-			task.promise.then((value) => {
-				this.bufferValue = value;
-				if (this.bufferTask === task) this.bufferTask = void 0;
-			}, () => {
-				if (this.bufferTask === task) this.bufferTask = void 0;
-			});
-		}
-		return waitForSharedTask(this.bufferTask, context?.signal);
-	}
-	async index(context) {
-		context?.signal?.throwIfAborted();
-		if (this.indexValue) return this.indexValue;
-		if (!this.indexTask) {
-			const task = createSharedAbortableTask((signal) => this.buildIndex(signal));
-			this.indexTask = task;
-			task.promise.then((value) => {
-				this.indexValue = value;
-				if (this.indexTask === task) this.indexTask = void 0;
-			}, () => {
-				if (this.indexTask === task) this.indexTask = void 0;
-			});
-		}
-		return waitForSharedTask(this.indexTask, context?.signal);
-	}
-	async buildIndex(signal) {
-		const buf = await this.buffer({ signal });
-		signal?.throwIfAborted();
-		const byTrace = /* @__PURE__ */ new Map();
-		let cursor = 0;
-		let lineNumber = 0;
-		let sinceYield = 0;
-		while (cursor < buf.length) {
-			lineNumber += 1;
-			if (++sinceYield >= INDEX_YIELD_LINES) {
-				sinceYield = 0;
-				await yieldToEventLoop();
-				signal?.throwIfAborted();
-			}
-			const newlineIndex = buf.indexOf(10, cursor);
-			const lineEnd = newlineIndex === -1 ? buf.length : newlineIndex;
-			const lineLength = lineEnd - cursor;
-			if (lineLength === 0) {
-				cursor = lineEnd + 1;
-				continue;
-			}
-			const lineSlice = buf.subarray(cursor, lineEnd).toString("utf8");
-			const lineOffset = cursor;
-			cursor = lineEnd + 1;
-			let parsed;
-			try {
-				parsed = JSON.parse(lineSlice);
-			} catch (cause) {
-				throw new TraceFileMalformedError(this.sourcePath(), lineNumber, lineOffset, cause);
-			}
-			if (!parsed || typeof parsed !== "object") throw new TraceFileMalformedError(this.sourcePath(), lineNumber, lineOffset);
-			const span = projectOtlpFlatLine(parsed);
-			if (!span) throw new TraceFileMalformedError(this.sourcePath(), lineNumber, lineOffset);
-			let entry = byTrace.get(span.trace_id);
-			if (!entry) {
-				entry = {
-					trace_id: span.trace_id,
-					service_name: span.service_name,
-					agent_name: span.agent_name,
-					span_count: 0,
-					has_errors: false,
-					start_time: span.start_time,
-					end_time: span.end_time,
-					duration_ms: 0,
-					raw_jsonl_bytes: 0,
-					models: /* @__PURE__ */ new Set(),
-					tools: /* @__PURE__ */ new Set(),
-					spans: []
-				};
-				byTrace.set(span.trace_id, entry);
-			} else {
-				if (!entry.service_name && span.service_name) entry.service_name = span.service_name;
-				if (!entry.agent_name && span.agent_name) entry.agent_name = span.agent_name;
-			}
-			const indexEntry = {
-				span_id: span.span_id,
-				parent_span_id: span.parent_span_id,
-				name: span.name,
-				kind: span.kind,
-				start_time: span.start_time,
-				end_time: span.end_time,
-				duration_ms: span.duration_ms,
-				status: span.status,
-				status_message: span.status_message,
-				service_name: span.service_name,
-				agent_name: span.agent_name,
-				model_name: span.model_name,
-				tool_name: span.tool_name,
-				line_byte_offset: lineOffset,
-				line_byte_length: lineLength
-			};
-			entry.spans.push(indexEntry);
-			entry.span_count += 1;
-			entry.raw_jsonl_bytes += lineLength + 1;
-			if (span.status === "ERROR") entry.has_errors = true;
-			if (compareSpanTime(span.start_time, entry.start_time) < 0) entry.start_time = span.start_time;
-			if (compareSpanTime(span.end_time, entry.end_time) > 0) entry.end_time = span.end_time;
-			if (span.model_name) entry.models.add(span.model_name);
-			if (span.tool_name) entry.tools.add(span.tool_name);
-		}
-		let totalRawBytes = 0;
-		for (const t of byTrace.values()) {
-			signal?.throwIfAborted();
-			totalRawBytes += t.raw_jsonl_bytes;
-			t.spans.sort((a, b) => compareSpanTime(a.start_time, b.start_time) || a.line_byte_offset - b.line_byte_offset);
-			const startMs = spanEpochMillis(t.start_time);
-			const endMs = spanEpochMillis(t.end_time);
-			t.duration_ms = startMs === null || endMs === null ? 0 : Math.max(0, endMs - startMs);
-		}
-		const sortedTraceIds = [...byTrace.keys()].sort();
-		signal?.throwIfAborted();
-		return {
-			byTrace,
-			totalRawBytes,
-			sortedTraceIds
-		};
-	}
-	async matchedTraces(idx, filters, context) {
-		context?.signal?.throwIfAborted();
-		const traces = [];
-		for (let index = 0; index < idx.sortedTraceIds.length; index += 1) {
-			await scanCheckpoint(context?.signal, index);
-			const trace = idx.byTrace.get(idx.sortedTraceIds[index]);
-			if (trace) traces.push(trace);
-		}
-		if (!filters) return traces;
-		const indexedFiltered = [];
-		for (let index = 0; index < traces.length; index += 1) {
-			await scanCheckpoint(context?.signal, index);
-			const t = traces[index];
-			if (filters.has_errors !== void 0 && t.has_errors !== filters.has_errors) continue;
-			if (filters.service_names && filters.service_names.length > 0) {
-				if (!t.service_name || !filters.service_names.includes(t.service_name)) continue;
-			}
-			if (filters.agent_names && filters.agent_names.length > 0) {
-				if (!t.agent_name || !filters.agent_names.includes(t.agent_name)) continue;
-			}
-			if (filters.model_names && filters.model_names.length > 0) {
-				if (![...t.models].some((m) => filters.model_names.includes(m))) continue;
-			}
-			if (filters.tool_names && filters.tool_names.length > 0) {
-				if (![...t.tools].some((tn) => filters.tool_names.includes(tn))) continue;
-			}
-			if (filters.start_time_after && t.start_time < filters.start_time_after) continue;
-			if (filters.start_time_before && t.start_time > filters.start_time_before) continue;
-			indexedFiltered.push(t);
-		}
-		if (!filters.regex_pattern) return indexedFiltered;
-		const re = compileSearchRegex(filters.regex_pattern);
-		const buf = await this.buffer(context);
-		const out = [];
-		let traceIndex = 0;
-		for (const t of indexedFiltered) {
-			await scanCheckpoint(context?.signal, traceIndex++);
-			let matched = false;
-			let spanIndex = 0;
-			for (const s of t.spans) {
-				await scanCheckpoint(context?.signal, spanIndex++);
-				const slice = buf.subarray(s.line_byte_offset, s.line_byte_offset + s.line_byte_length);
-				if (re.test(slice.toString("utf8"))) {
-					matched = true;
-					break;
-				}
-			}
-			if (matched) out.push(t);
-		}
-		return out;
-	}
-	toSummary(t) {
-		return {
-			trace_id: t.trace_id,
-			service_name: t.service_name,
-			agent_name: t.agent_name,
-			span_count: t.span_count,
-			has_errors: t.has_errors,
-			start_time: t.start_time,
-			end_time: t.end_time,
-			duration_ms: t.duration_ms,
-			raw_jsonl_bytes: t.raw_jsonl_bytes,
-			models: [...t.models].sort(),
-			tools: [...t.tools].sort()
-		};
-	}
-	projectSpan(buf, trace_id, s, perAttrCap, counter) {
-		const slice = buf.subarray(s.line_byte_offset, s.line_byte_offset + s.line_byte_length).toString("utf8");
-		let raw = {};
-		try {
-			const parsed = JSON.parse(slice);
-			if (parsed && typeof parsed === "object") raw = parsed;
-		} catch {}
-		const attrs = extractOtlpAttributes(raw);
-		const projected = {};
-		for (const [k, v] of Object.entries(attrs)) if (typeof v === "string") {
-			const trunc = truncateForBudget(v, perAttrCap);
-			if (trunc !== v) counter.value += 1;
-			projected[k] = trunc;
-		} else if (Array.isArray(v) || v && typeof v === "object") {
-			const json = JSON.stringify(v);
-			const trunc = truncateForBudget(json, perAttrCap);
-			if (trunc !== json) {
-				counter.value += 1;
-				projected[k] = trunc;
-			} else projected[k] = v;
-		} else projected[k] = v;
-		return {
-			trace_id,
-			span_id: s.span_id,
-			parent_span_id: s.parent_span_id,
-			name: s.name,
-			kind: s.kind,
-			start_time: s.start_time,
-			end_time: s.end_time,
-			duration_ms: s.duration_ms,
-			status: s.status,
-			status_message: s.status_message,
-			service_name: s.service_name,
-			agent_name: s.agent_name,
-			model_name: s.model_name,
-			tool_name: s.tool_name,
-			attributes: projected
-		};
-	}
-	buildOversizedSummary(t, span_response_bytes_max) {
-		const counts = /* @__PURE__ */ new Map();
-		let errorCount = 0;
-		for (const s of t.spans) {
-			counts.set(s.name, (counts.get(s.name) ?? 0) + 1);
-			if (s.status === "ERROR") errorCount += 1;
-		}
-		const top = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 20);
-		return {
-			span_count: t.span_count,
-			top_span_names: top,
-			span_response_bytes_max,
-			error_span_count: errorCount
-		};
-	}
-	async scanSpanForMatches(buf, trace_id, s, re, textBudget, recordCap, context) {
-		const slice = buf.subarray(s.line_byte_offset, s.line_byte_offset + s.line_byte_length).toString("utf8");
-		const records = [];
-		let hasMore = false;
-		let matchIndex = 0;
-		for (const match of re.matchAll(slice)) {
-			await scanCheckpoint(context?.signal, matchIndex++);
-			if (records.length >= recordCap) {
-				hasMore = true;
-				break;
-			}
-			const offset = match.index ?? 0;
-			const before = slice.slice(Math.max(0, offset - textBudget / 2), offset);
-			const after = slice.slice(offset + match[0].length, offset + match[0].length + Math.floor(textBudget / 2));
-			records.push({
-				trace_id,
-				span_id: s.span_id,
-				span_name: s.name,
-				span_kind: s.kind,
-				attribute_path: bestAttributePathForOffset(slice, offset) ?? "span.raw",
-				matched_text: truncateForBudget(match[0], textBudget),
-				context_before: truncateForBudget(before, textBudget),
-				context_after: truncateForBudget(after, textBudget),
-				match_offset: offset
-			});
-		}
-		return {
-			records,
-			hasMore
-		};
-	}
-};
-var OtlpFileTraceStore = class extends BufferedOtlpTraceStore {
-	path;
-	maxFileBytes;
-	constructor(opts) {
-		super(opts);
-		this.path = opts.path;
-		this.maxFileBytes = validateInteger(opts.maxFileBytes ?? 268435456, "maxFileBytes", 1);
-	}
-	/** Stat-then-read so an oversized file fails loud before allocating the
-	*  source buffer. Missing files remain distinct from malformed traces. */
-	async readBuffer(signal) {
-		signal?.throwIfAborted();
-		let stats;
-		try {
-			stats = await stat(this.path);
-		} catch (err) {
-			if (err?.code === "ENOENT") throw new TraceFileMissingError(this.path);
-			throw err;
-		}
-		if (stats.size > this.maxFileBytes) throw new TraceFileTooLargeError(this.path, stats.size, this.maxFileBytes);
-		signal?.throwIfAborted();
-		return readFile(this.path, { signal });
-	}
-	sourcePath() {
-		return this.path;
-	}
-};
-var OtlpBufferTraceStore = class extends BufferedOtlpTraceStore {
-	source;
-	constructor(source, opts) {
-		super(opts);
-		this.source = source;
-	}
-	async readBuffer(signal) {
-		signal?.throwIfAborted();
-		return this.source;
-	}
-	sourcePath() {
-		return "<memory>";
-	}
-};
-/** Build the bounded trace store directly from OpenInference JSONL text. */
-function otlpTextToTraceAnalysisStore(text, opts = {}) {
-	if (!text.trim()) throw new CaptureIntegrityError("OTLP trace text must not be empty");
-	return new OtlpBufferTraceStore(Buffer.from(text, "utf8"), opts);
-}
-function createOtlpBufferTraceStore(source, options = {}) {
-	return new OtlpBufferTraceStore(source, options);
-}
-/** A `"` at `idx` is a real JSON delimiter only when the run of `\`
-*  immediately preceding it is even-length; an odd run means the quote
-*  is escaped (`\"`) and is part of a string value, not a boundary. */
-function isUnescapedQuote(slice, idx) {
-	if (slice[idx] !== "\"") return false;
-	let backslashes = 0;
-	let b = idx - 1;
-	while (b >= 0 && slice[b] === "\\") {
-		backslashes += 1;
-		b -= 1;
-	}
-	return backslashes % 2 === 0;
-}
-/** Scan backwards from `from` (inclusive) for the nearest UNescaped `"`.
-*  Returns its index, or -1 when none is found. */
-function prevUnescapedQuote(slice, from) {
-	for (let i = from; i >= 0; i -= 1) if (slice[i] === "\"" && isUnescapedQuote(slice, i)) return i;
-	return -1;
-}
-/**
-* Best-effort: locate the JSON path for the substring at `offset` in
-* a single span's JSONL slice. The slice is '...,"key":"value..."' — we
-* walk back from `offset` to the value-opening quote, past the `:`, to
-* the key's closing then opening quote, skipping `\"`-escaped quotes that
-* live inside string values. Returns `null` when the offset doesn't fall
-* inside a recognisable string field.
-*/
-function bestAttributePathForOffset(slice, offset) {
-	const valueQuote = prevUnescapedQuote(slice, Math.min(offset, slice.length - 1));
-	if (valueQuote < 1) return null;
-	let j = valueQuote - 1;
-	while (j >= 0 && slice[j] !== ":") j -= 1;
-	if (j < 1) return null;
-	const keyClose = prevUnescapedQuote(slice, j - 1);
-	if (keyClose < 1) return null;
-	const keyOpen = prevUnescapedQuote(slice, keyClose - 1);
-	if (keyOpen < 0) return null;
-	return slice.slice(keyOpen + 1, keyClose);
-}
-const ERROR_CLUSTER_EXEMPLARS = 5;
-/** Collapse volatile tokens so semantically identical failures share a key:
-*  hex/uuid ids → <id>, numbers → #, quoted/abs paths → <path>, durations →
-*  <dur>, whitespace collapsed. Empty/absent messages fall back to the span
-*  name so a no-message error still forms a real cluster. */
-function normalizeErrorSignature(message, spanName) {
-	const raw = (message ?? "").trim();
-	return (raw.length > 0 ? raw : `(${spanName || "error"} — no message)`).replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, "<id>").replace(/\b[0-9a-f]{12,}\b/gi, "<id>").replace(/(?:\/[\w.\-@]+){2,}/g, "<path>").replace(/\b\d+(?:\.\d+)?(ms|s|m|h|kb|mb|gb)?\b/gi, (_m, u) => u ? `#${u}` : "#").replace(/\s+/g, " ").trim();
-}
-function bump(map, key) {
-	if (!key) return;
-	map.set(key, (map.get(key) ?? 0) + 1);
-}
-function topKey(map) {
-	let best = null;
-	let bestN = 0;
-	for (const [k, n] of map) if (n > bestN) {
-		best = k;
-		bestN = n;
-	}
-	return best;
-}
-function accumulateErrorCluster(clusters, traceId, span) {
-	const signature = normalizeErrorSignature(span.status_message, span.name);
-	let acc = clusters.get(signature);
-	if (!acc) {
-		acc = {
-			signature,
-			sample: span.status_message ?? span.name ?? "",
-			traceIds: /* @__PURE__ */ new Set(),
-			spanIds: [],
-			spanCount: 0,
-			spanNames: /* @__PURE__ */ new Map(),
-			toolNames: /* @__PURE__ */ new Map()
-		};
-		clusters.set(signature, acc);
-	}
-	acc.traceIds.add(traceId);
-	acc.spanCount += 1;
-	if (acc.spanIds.length < ERROR_CLUSTER_EXEMPLARS && !acc.spanIds.includes(span.span_id)) acc.spanIds.push(span.span_id);
-	bump(acc.spanNames, span.name);
-	bump(acc.toolNames, span.tool_name);
-}
-function finalizeErrorClusters(clusters, errorTraceCount) {
-	const out = [...clusters.values()].map((acc) => ({
-		signature: acc.signature,
-		status_message_sample: acc.sample,
-		span_name: topKey(acc.spanNames),
-		tool_name: topKey(acc.toolNames),
-		trace_count: acc.traceIds.size,
-		span_count: acc.spanCount,
-		prevalence: errorTraceCount > 0 ? acc.traceIds.size / errorTraceCount : 0,
-		exemplar_trace_ids: [...acc.traceIds].slice(0, ERROR_CLUSTER_EXEMPLARS),
-		exemplar_span_ids: acc.spanIds.slice(0, ERROR_CLUSTER_EXEMPLARS)
-	}));
-	out.sort((a, b) => b.trace_count - a.trace_count || b.span_count - a.span_count);
-	return out;
-}
-//#endregion
-export { classifyOtlpSpanRole as A, firstStringAttr as C, spanEpochMillis as D, readOtlpStatus as E, traceSpanKindToOpenInferenceKind as M, stringField as O, extractOtlpAttributes as S, projectOtlpFlatLine as T, TraceFileMissingError as _, createBoundedTraceAnalysisStore as a, asString as b, traceStoreInputSchemas as c, TRACE_ANALYSIS_LIMITS as d, SpanNotFoundError as f, TraceFileMalformedError as g, TraceAnalysisValidationError as h, otlpTextToTraceAnalysisStore as i, isOtlpModelCall as j, applyToolSpanOtlpAttributes as k, DEFAULT_TRACE_ANALYST_BUDGETS as l, TraceAnalysisStoreContractError as m, OtlpFileTraceStore as n, parseTraceInput as o, TraceAnalysisLimitError as p, createOtlpBufferTraceStore as r, toTraceJsonSchema as s, DEFAULT_MAX_TRACE_FILE_BYTES as t, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX as u, TraceFileTooLargeError as v, inferOtlpKind as w, compareSpanTime as x, TraceNotFoundError as y };
-
-//# sourceMappingURL=store-otlp-BenKynPE.js.map