@ls-stack/agent-eval 0.8.0 → 0.10.0

package/dist/{runOrchestration-HaMahl6b.mjs → runOrchestration-DwqX9_T7.mjs}

@@ -105,6 +105,8 @@ function setScopeCacheContext(scope, context) {
 async function runInEvalScope(caseId, fn, options = {}) {
 	const scope = {
 		caseId,
+		idPrefix: options.idPrefix,
+		nextEvalIdCounter: 0,
 		input: options.input,
 		outputs: {},
 		assertionFailures: [],
@@ -114,7 +116,8 @@ async function runInEvalScope(caseId, fn, options = {}) {
 		activeSpanStack: [],
 		recordingStack: [],
 		replayingDepth: 0,
-		cacheContext: options.cacheContext
+		cacheContext: options.cacheContext,
+		caseCacheRefs: []
 	};
 	activeEvalScopeCount++;
 	try {
@@ -137,6 +140,21 @@ async function runInEvalScope(caseId, fn, options = {}) {
 		activeEvalScopeCount--;
 	}
 }
+/**
+* Return the next deterministic ID for the active eval case execution.
+*
+* The runner derives the ID prefix from the eval file, eval id, and case id,
+* then this helper appends a per-scope sequence number. Calls outside an
+* active eval case scope throw so accidental product-code usage is caught
+* immediately.
+*/
+function nextEvalId() {
+	const scope = getCurrentScope();
+	if (!scope) throw new Error("nextEvalId() must be called inside an active eval case");
+	if (scope.idPrefix === void 0) throw new Error("nextEvalId() requires a runner-provided eval id prefix");
+	scope.nextEvalIdCounter++;
+	return `${scope.idPrefix}-${scope.nextEvalIdCounter}`;
+}
 function recordOpIfActive(scope, op) {
 	if (scope.replayingDepth > 0) return;
 	const top = scope.recordingStack.at(-1);
@@ -235,135 +253,1921 @@ function incrementEvalOutput(key, delta) {
 		});
 		return;
 	}
-	if (typeof existing !== "number") {
-		scope.assertionFailures.push(toAssertionFailure$1(`incrementEvalOutput("${key}"): existing value is ${typeof existing}, expected number`));
-		return;
+	if (typeof existing !== "number") {
+		scope.assertionFailures.push(toAssertionFailure$1(`incrementEvalOutput("${key}"): existing value is ${typeof existing}, expected number`));
+		return;
+	}
+	scope.outputs[key] = existing + delta;
+	recordOpIfActive(scope, {
+		kind: "incrementOutput",
+		key,
+		delta
+	});
+}
+/**
+* Assert a condition for the current eval case and throw on failure.
+*
+* Calls made outside `runInEvalScope(...)` are ignored so shared workflow code
+* can safely reuse `evalAssert(...)` when it also runs outside an eval.
+*/
+function evalAssert(condition, message) {
+	if (condition) return;
+	const scope = getCurrentScope();
+	if (!scope) return;
+	const error = new EvalAssertionError(message);
+	scope.assertionFailures.push(toAssertionFailure$1(message, error));
+	throw error;
+}
+//#endregion
+//#region ../sdk/src/cacheKey.ts
+var SerializedCacheKeyValue = class {
+	value;
+	constructor(value) {
+		this.value = value;
+	}
+};
+/**
+* Hash the components of a cache key into a deterministic hex digest.
+*
+* Native `Blob` and `File` values use stable metadata by default. Pass
+* `serializeFileBytes: true` to read them asynchronously and include their byte
+* hash in the key.
+*/
+async function hashCacheKey(input, options = {}) {
+	return hashCacheKeySyncMaterialized(options.serializeFileBytes === true ? await materializeAsyncCacheKeyValue(input) : input);
+}
+/**
+* Synchronously hash cache key components. This supports JSON-like data and
+* in-memory binary values such as `Buffer`, `ArrayBuffer`, and typed arrays,
+* plus stable metadata for native `Blob` and `File` values.
+*/
+function hashCacheKeySync(input) {
+	return hashCacheKeySyncMaterialized(input);
+}
+function hashCacheKeySyncMaterialized(input) {
+	return createHash("sha256").update(getCompositeKey(input, { stringify: stringifyCacheKeyValue })).digest("hex");
+}
+function stringifyCacheKeyValue(value) {
+	if (value instanceof SerializedCacheKeyValue) return value.value;
+	if (Buffer$1.isBuffer(value)) return `$buffer:${hashBytes(value)}`;
+	if (isArrayBuffer(value)) return `$arrayBuffer:${hashBytes(new Uint8Array(value))}`;
+	if (isSharedArrayBuffer(value)) return `$sharedArrayBuffer:${hashBytes(new Uint8Array(value))}`;
+	if (isArrayBufferView(value)) {
+		const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+		return `$${value.constructor.name}:${hashBytes(bytes)}`;
+	}
+	if (isFile$1(value)) return `$file:${getCompositeKey({
+		lastModified: value.lastModified,
+		name: value.name,
+		size: value.size,
+		type: value.type
+	})}`;
+	if (isBlob$1(value)) return `$blob:${getCompositeKey({
+		size: value.size,
+		type: value.type
+	})}`;
+}
+async function materializeAsyncCacheKeyValue(value, refs = /* @__PURE__ */ new WeakSet()) {
+	const serialized = await stringifyAsyncCacheKeyValue(value);
+	if (serialized !== void 0) return new SerializedCacheKeyValue(serialized);
+	if (stringifyCacheKeyValue(value) !== void 0) return value;
+	if (!value || typeof value !== "object") return value;
+	if (Array.isArray(value)) {
+		const items = [];
+		for (const item of value) items.push(await materializeAsyncCacheKeyValue(item, refs));
+		return items;
+	}
+	if (refs.has(value)) throw new Error("Circular reference detected");
+	refs.add(value);
+	const entries = [];
+	for (const [key, entryValue] of Object.entries(value)) entries.push([key, await materializeAsyncCacheKeyValue(entryValue, refs)]);
+	refs.delete(value);
+	return Object.fromEntries(entries);
+}
+async function stringifyAsyncCacheKeyValue(value) {
+	if (isFile$1(value)) return `$file:${getCompositeKey({
+		bytes: await hashBlobBytes(value),
+		lastModified: value.lastModified,
+		name: value.name,
+		size: value.size,
+		type: value.type
+	})}`;
+	if (isBlob$1(value)) return `$blob:${getCompositeKey({
+		bytes: await hashBlobBytes(value),
+		size: value.size,
+		type: value.type
+	})}`;
+}
+async function hashBlobBytes(value) {
+	return hashBytes(new Uint8Array(await value.arrayBuffer()));
+}
+function hashBytes(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function isArrayBuffer(value) {
+	return value instanceof ArrayBuffer;
+}
+function isSharedArrayBuffer(value) {
+	return value instanceof SharedArrayBuffer;
+}
+function isArrayBufferView(value) {
+	return ArrayBuffer.isView(value);
+}
+function isBlob$1(value) {
+	return value instanceof Blob;
+}
+function isFile$1(value) {
+	return value instanceof File;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/seroval@1.5.2/node_modules/seroval/dist/esm/production/index.mjs
+var L$1 = ((i) => (i[i.AggregateError = 1] = "AggregateError", i[i.ArrowFunction = 2] = "ArrowFunction", i[i.ErrorPrototypeStack = 4] = "ErrorPrototypeStack", i[i.ObjectAssign = 8] = "ObjectAssign", i[i.BigIntTypedArray = 16] = "BigIntTypedArray", i[i.RegExp = 32] = "RegExp", i))(L$1 || {});
+var v$1 = Symbol.asyncIterator, mr = Symbol.hasInstance, R = Symbol.isConcatSpreadable, C = Symbol.iterator, pr = Symbol.match, dr = Symbol.matchAll, gr = Symbol.replace, yr = Symbol.search, Nr = Symbol.species, br = Symbol.split, vr = Symbol.toPrimitive, P$1 = Symbol.toStringTag, Cr = Symbol.unscopables, ve = {
+	[v$1]: 0,
+	[mr]: 1,
+	[R]: 2,
+	[C]: 3,
+	[pr]: 4,
+	[dr]: 5,
+	[gr]: 6,
+	[yr]: 7,
+	[Nr]: 8,
+	[br]: 9,
+	[vr]: 10,
+	[P$1]: 11,
+	[Cr]: 12
+}, tt = {
+	0: v$1,
+	1: mr,
+	2: R,
+	3: C,
+	4: pr,
+	5: dr,
+	6: gr,
+	7: yr,
+	8: Nr,
+	9: br,
+	10: vr,
+	11: P$1,
+	12: Cr
+}, o$1 = void 0, ot = {
+	2: !0,
+	3: !1,
+	1: o$1,
+	0: null,
+	4: -0,
+	5: Number.POSITIVE_INFINITY,
+	6: Number.NEGATIVE_INFINITY,
+	7: NaN
+};
+var Ce = {
+	0: "Error",
+	1: "EvalError",
+	2: "RangeError",
+	3: "ReferenceError",
+	4: "SyntaxError",
+	5: "TypeError",
+	6: "URIError"
+}, at = {
+	0: Error,
+	1: EvalError,
+	2: RangeError,
+	3: ReferenceError,
+	4: SyntaxError,
+	5: TypeError,
+	6: URIError
+};
+function c$1(e, r, t, n, a, s, i, u, l, g, S, d) {
+	return {
+		t: e,
+		i: r,
+		s: t,
+		c: n,
+		m: a,
+		p: s,
+		e: i,
+		a: u,
+		f: l,
+		b: g,
+		o: S,
+		l: d
+	};
+}
+function B$1(e) {
+	return c$1(2, o$1, e, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+var J = B$1(2), Z = B$1(3), Ae = B$1(1), Ee = B$1(0), st = B$1(4), it = B$1(5), ut = B$1(6), lt = B$1(7);
+function fn(e) {
+	switch (e) {
+		case "\"": return "\\\"";
+		case "\\": return "\\\\";
+		case `
+`: return "\\n";
+		case "\r": return "\\r";
+		case "\b": return "\\b";
+		case "	": return "\\t";
+		case "\f": return "\\f";
+		case "<": return "\\x3C";
+		case "\u2028": return "\\u2028";
+		case "\u2029": return "\\u2029";
+		default: return o$1;
+	}
+}
+function y$1(e) {
+	let r = "", t = 0, n;
+	for (let a = 0, s = e.length; a < s; a++) n = fn(e[a]), n && (r += e.slice(t, a) + n, t = a + 1);
+	return t === 0 ? r = e : r += e.slice(t), r;
+}
+function Sn(e) {
+	switch (e) {
+		case "\\\\": return "\\";
+		case "\\\"": return "\"";
+		case "\\n": return `
+`;
+		case "\\r": return "\r";
+		case "\\b": return "\b";
+		case "\\t": return "	";
+		case "\\f": return "\f";
+		case "\\x3C": return "<";
+		case "\\u2028": return "\u2028";
+		case "\\u2029": return "\u2029";
+		default: return e;
+	}
+}
+function D$1(e) {
+	return e.replace(/(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g, Sn);
+}
+var U = "__SEROVAL_REFS__";
+var Ar = /* @__PURE__ */ new Map(), j = /* @__PURE__ */ new Map();
+function Er(e) {
+	return Ar.has(e);
+}
+function dn(e) {
+	return j.has(e);
+}
+function ct(e) {
+	if (Er(e)) return Ar.get(e);
+	throw new Re(e);
+}
+function ft(e) {
+	if (dn(e)) return j.get(e);
+	throw new Pe(e);
+}
+typeof globalThis != "undefined" ? Object.defineProperty(globalThis, U, {
+	value: j,
+	configurable: !0,
+	writable: !1,
+	enumerable: !1
+}) : typeof window != "undefined" ? Object.defineProperty(window, U, {
+	value: j,
+	configurable: !0,
+	writable: !1,
+	enumerable: !1
+}) : typeof self != "undefined" ? Object.defineProperty(self, U, {
+	value: j,
+	configurable: !0,
+	writable: !1,
+	enumerable: !1
+}) : typeof global != "undefined" && Object.defineProperty(global, U, {
+	value: j,
+	configurable: !0,
+	writable: !1,
+	enumerable: !1
+});
+function xe(e) {
+	return e instanceof EvalError ? 1 : e instanceof RangeError ? 2 : e instanceof ReferenceError ? 3 : e instanceof SyntaxError ? 4 : e instanceof TypeError ? 5 : e instanceof URIError ? 6 : 0;
+}
+function gn(e) {
+	let r = Ce[xe(e)];
+	return e.name !== r ? { name: e.name } : e.constructor.name !== r ? { name: e.constructor.name } : {};
+}
+function $$1(e, r) {
+	let t = gn(e), n = Object.getOwnPropertyNames(e);
+	for (let a = 0, s = n.length, i; a < s; a++) i = n[a], i !== "name" && i !== "message" && (i === "stack" ? r & 4 && (t = t || {}, t[i] = e[i]) : (t = t || {}, t[i] = e[i]));
+	return t;
+}
+function Oe(e) {
+	return Object.isFrozen(e) ? 3 : Object.isSealed(e) ? 2 : Object.isExtensible(e) ? 0 : 1;
+}
+function Te(e) {
+	switch (e) {
+		case Number.POSITIVE_INFINITY: return it;
+		case Number.NEGATIVE_INFINITY: return ut;
+	}
+	return e !== e ? lt : Object.is(e, -0) ? st : c$1(0, o$1, e, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function X(e) {
+	return c$1(1, o$1, y$1(e), o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function we(e) {
+	return c$1(3, o$1, "" + e, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function mt(e) {
+	return c$1(4, e, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function he(e, r) {
+	let t = r.valueOf();
+	return c$1(5, e, t !== t ? "" : r.toISOString(), o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function ze(e, r) {
+	return c$1(6, e, o$1, y$1(r.source), r.flags, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function pt(e, r) {
+	return c$1(17, e, ve[r], o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function dt(e, r) {
+	return c$1(18, e, y$1(ct(r)), o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function fe$1(e, r, t) {
+	return c$1(25, e, t, y$1(r), o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function _e(e, r, t) {
+	return c$1(9, e, o$1, o$1, o$1, o$1, o$1, t, o$1, o$1, Oe(r), o$1);
+}
+function ke(e, r) {
+	return c$1(21, e, o$1, o$1, o$1, o$1, o$1, o$1, r, o$1, o$1, o$1);
+}
+function De(e, r, t) {
+	return c$1(15, e, o$1, r.constructor.name, o$1, o$1, o$1, o$1, t, r.byteOffset, o$1, r.length);
+}
+function Fe(e, r, t) {
+	return c$1(16, e, o$1, r.constructor.name, o$1, o$1, o$1, o$1, t, r.byteOffset, o$1, r.byteLength);
+}
+function Be(e, r, t) {
+	return c$1(20, e, o$1, o$1, o$1, o$1, o$1, o$1, t, r.byteOffset, o$1, r.byteLength);
+}
+function Ve(e, r, t) {
+	return c$1(13, e, xe(r), o$1, y$1(r.message), t, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function Me(e, r, t) {
+	return c$1(14, e, xe(r), o$1, y$1(r.message), t, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function Le(e, r) {
+	return c$1(7, e, o$1, o$1, o$1, o$1, o$1, r, o$1, o$1, o$1, o$1);
+}
+function Ue(e, r) {
+	return c$1(28, o$1, o$1, o$1, o$1, o$1, o$1, [e, r], o$1, o$1, o$1, o$1);
+}
+function je(e, r) {
+	return c$1(30, o$1, o$1, o$1, o$1, o$1, o$1, [e, r], o$1, o$1, o$1, o$1);
+}
+function Ye(e, r, t) {
+	return c$1(31, e, o$1, o$1, o$1, o$1, o$1, t, r, o$1, o$1, o$1);
+}
+function qe(e, r) {
+	return c$1(32, e, o$1, o$1, o$1, o$1, o$1, o$1, r, o$1, o$1, o$1);
+}
+function We(e, r) {
+	return c$1(33, e, o$1, o$1, o$1, o$1, o$1, o$1, r, o$1, o$1, o$1);
+}
+function Ge(e, r) {
+	return c$1(34, e, o$1, o$1, o$1, o$1, o$1, o$1, r, o$1, o$1, o$1);
+}
+function Ke(e, r, t, n) {
+	return c$1(35, e, t, o$1, o$1, o$1, o$1, r, o$1, o$1, o$1, n);
+}
+var { toString: ys } = Object.prototype;
+var yn = {
+	parsing: 1,
+	serialization: 2,
+	deserialization: 3
+};
+function Nn(e) {
+	return `Seroval Error (step: ${yn[e]})`;
+}
+var bn = (e, r) => Nn(e), Se = class extends Error {
+	constructor(t, n) {
+		super(bn(t, n));
+		this.cause = n;
+	}
+}, z$2 = class extends Se {
+	constructor(r) {
+		super("parsing", r);
+	}
+}, He = class extends Se {
+	constructor(r) {
+		super("deserialization", r);
+	}
+};
+function _(e) {
+	return `Seroval Error (specific: ${e})`;
+}
+var x$1 = class extends Error {
+	constructor(t) {
+		super(_(1));
+		this.value = t;
+	}
+}, w$1 = class extends Error {
+	constructor(r) {
+		super(_(2));
+	}
+}, Q = class extends Error {
+	constructor(r) {
+		super(_(3));
+	}
+}, V = class extends Error {
+	constructor(r) {
+		super(_(4));
+	}
+}, Re = class extends Error {
+	constructor(t) {
+		super(_(5));
+		this.value = t;
+	}
+}, Pe = class extends Error {
+	constructor(r) {
+		super(_(6));
+	}
+}, Je = class extends Error {
+	constructor(r) {
+		super(_(7));
+	}
+}, h$1 = class extends Error {
+	constructor(r) {
+		super(_(8));
+	}
+}, ee = class extends Error {
+	constructor(r) {
+		super(_(9));
+	}
+}, Y$1 = class {
+	constructor(r, t) {
+		this.value = r;
+		this.replacement = t;
+	}
+}, re = () => {
+	let e = {
+		p: 0,
+		s: 0,
+		f: 0
+	};
+	return e.p = new Promise((r, t) => {
+		e.s = r, e.f = t;
+	}), e;
+}, vn = (e, r) => {
+	e.s(r), e.p.s = 1, e.p.v = r;
+}, Cn = (e, r) => {
+	e.f(r), e.p.s = 2, e.p.v = r;
+};
+re.toString();
+vn.toString();
+Cn.toString();
+var Rr = () => {
+	let e = [], r = [], t = !0, n = !1, a = 0, s = (l, g, S) => {
+		for (S = 0; S < a; S++) r[S] && r[S][g](l);
+	}, i = (l, g, S, d) => {
+		for (g = 0, S = e.length; g < S; g++) d = e[g], !t && g === S - 1 ? l[n ? "return" : "throw"](d) : l.next(d);
+	}, u = (l, g) => (t && (g = a++, r[g] = l), i(l), () => {
+		t && (r[g] = r[a], r[a--] = void 0);
+	});
+	return {
+		__SEROVAL_STREAM__: !0,
+		on: (l) => u(l),
+		next: (l) => {
+			t && (e.push(l), s(l, "next"));
+		},
+		throw: (l) => {
+			t && (e.push(l), s(l, "throw"), t = !1, n = !1, r.length = 0);
+		},
+		return: (l) => {
+			t && (e.push(l), s(l, "return"), t = !1, n = !0, r.length = 0);
+		}
+	};
+};
+Rr.toString();
+var Pr = (e) => (r) => () => {
+	let t = 0, n = {
+		[e]: () => n,
+		next: () => {
+			if (t > r.d) return {
+				done: !0,
+				value: void 0
+			};
+			let a = t++, s = r.v[a];
+			if (a === r.t) throw s;
+			return {
+				done: a === r.d,
+				value: s
+			};
+		}
+	};
+	return n;
+};
+Pr.toString();
+var xr = (e, r) => (t) => () => {
+	let n = 0, a = -1, s = !1, i = [], u = [], l = (S = 0, d = u.length) => {
+		for (; S < d; S++) u[S].s({
+			done: !0,
+			value: void 0
+		});
+	};
+	t.on({
+		next: (S) => {
+			let d = u.shift();
+			d && d.s({
+				done: !1,
+				value: S
+			}), i.push(S);
+		},
+		throw: (S) => {
+			let d = u.shift();
+			d && d.f(S), l(), a = i.length, s = !0, i.push(S);
+		},
+		return: (S) => {
+			let d = u.shift();
+			d && d.s({
+				done: !0,
+				value: S
+			}), l(), a = i.length, i.push(S);
+		}
+	});
+	let g = {
+		[e]: () => g,
+		next: () => {
+			if (a === -1) {
+				let K = n++;
+				if (K >= i.length) {
+					let et = r();
+					return u.push(et), et.p;
+				}
+				return {
+					done: !1,
+					value: i[K]
+				};
+			}
+			if (n > a) return {
+				done: !0,
+				value: void 0
+			};
+			let S = n++, d = i[S];
+			if (S !== a) return {
+				done: !1,
+				value: d
+			};
+			if (s) throw d;
+			return {
+				done: !0,
+				value: d
+			};
+		}
+	};
+	return g;
+};
+xr.toString();
+var Or = (e) => {
+	let r = atob(e), t = r.length, n = new Uint8Array(t);
+	for (let a = 0; a < t; a++) n[a] = r.charCodeAt(a);
+	return n.buffer;
+};
+Or.toString();
+function Ze(e) {
+	return "__SEROVAL_SEQUENCE__" in e;
+}
+function Tr(e, r, t) {
+	return {
+		__SEROVAL_SEQUENCE__: !0,
+		v: e,
+		t: r,
+		d: t
+	};
+}
+function $e(e) {
+	let r = [], t = -1, n = -1, a = e[C]();
+	for (;;) try {
+		let s = a.next();
+		if (r.push(s.value), s.done) {
+			n = r.length - 1;
+			break;
+		}
+	} catch (s) {
+		t = r.length, r.push(s);
+	}
+	return Tr(r, t, n);
+}
+var An = Pr(C);
+function It(e) {
+	return An(e);
+}
+var Rt = {}, Pt = {}, xt = {
+	0: {},
+	1: {},
+	2: {},
+	3: {},
+	4: {},
+	5: {}
+};
+function M(e) {
+	return "__SEROVAL_STREAM__" in e;
+}
+function te$1() {
+	return Rr();
+}
+function Xe(e) {
+	let r = te$1(), t = e[v$1]();
+	async function n() {
+		try {
+			let a = await t.next();
+			a.done ? r.return(a.value) : (r.next(a.value), await n());
+		} catch (a) {
+			r.throw(a);
+		}
+	}
+	return n().catch(() => {}), r;
+}
+var En = xr(v$1, re);
+function Tt(e) {
+	return En(e);
+}
+async function wr(e) {
+	try {
+		return [1, await e];
+	} catch (r) {
+		return [0, r];
+	}
+}
+function pe$1(e, r) {
+	return {
+		plugins: r.plugins,
+		mode: e,
+		marked: /* @__PURE__ */ new Set(),
+		features: 63 ^ (r.disabledFeatures || 0),
+		refs: r.refs || /* @__PURE__ */ new Map(),
+		depthLimit: r.depthLimit || 1e3
+	};
+}
+function de(e, r) {
+	e.marked.add(r);
+}
+function hr(e, r) {
+	let t = e.refs.size;
+	return e.refs.set(r, t), t;
+}
+function Qe(e, r) {
+	let t = e.refs.get(r);
+	return t != null ? (de(e, t), {
+		type: 1,
+		value: mt(t)
+	}) : {
+		type: 0,
+		value: hr(e, r)
+	};
+}
+function q$1(e, r) {
+	let t = Qe(e, r);
+	return t.type === 1 ? t : Er(r) ? {
+		type: 2,
+		value: dt(t.value, r)
+	} : t;
+}
+function I(e, r) {
+	let t = q$1(e, r);
+	if (t.type !== 0) return t.value;
+	if (r in ve) return pt(t.value, r);
+	throw new x$1(r);
+}
+function k(e, r) {
+	let t = Qe(e, xt[r]);
+	return t.type === 1 ? t.value : c$1(26, t.value, r, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function er(e) {
+	let r = Qe(e, Rt);
+	return r.type === 1 ? r.value : c$1(27, r.value, o$1, o$1, o$1, o$1, o$1, o$1, I(e, C), o$1, o$1, o$1);
+}
+function rr(e) {
+	let r = Qe(e, Pt);
+	return r.type === 1 ? r.value : c$1(29, r.value, o$1, o$1, o$1, o$1, o$1, [k(e, 1), I(e, v$1)], o$1, o$1, o$1, o$1);
+}
+function tr(e, r, t, n) {
+	return c$1(t ? 11 : 10, e, o$1, o$1, o$1, n, o$1, o$1, o$1, o$1, Oe(r), o$1);
+}
+function nr(e, r, t, n) {
+	return c$1(8, r, o$1, o$1, o$1, o$1, {
+		k: t,
+		v: n
+	}, o$1, k(e, 0), o$1, o$1, o$1);
+}
+function or(e, r, t) {
+	let n = new Uint8Array(t), a = "";
+	for (let s = 0, i = n.length; s < i; s++) a += String.fromCharCode(n[s]);
+	return c$1(19, r, y$1(btoa(a)), o$1, o$1, o$1, o$1, o$1, k(e, 5), o$1, o$1, o$1);
+}
+function ne$1(e, r) {
+	return {
+		base: pe$1(e, r),
+		child: void 0
+	};
+}
+var _r = class {
+	constructor(r, t) {
+		this._p = r;
+		this.depth = t;
+	}
+	parse(r) {
+		return N$1(this._p, this.depth, r);
+	}
+};
+async function Rn(e, r, t) {
+	let n = [];
+	for (let a = 0, s = t.length; a < s; a++) a in t ? n[a] = await N$1(e, r, t[a]) : n[a] = 0;
+	return n;
+}
+async function Pn(e, r, t, n) {
+	return _e(t, n, await Rn(e, r, n));
+}
+async function kr(e, r, t) {
+	let n = Object.entries(t), a = [], s = [];
+	for (let i = 0, u = n.length; i < u; i++) a.push(y$1(n[i][0])), s.push(await N$1(e, r, n[i][1]));
+	return C in t && (a.push(I(e.base, C)), s.push(Ue(er(e.base), await N$1(e, r, $e(t))))), v$1 in t && (a.push(I(e.base, v$1)), s.push(je(rr(e.base), await N$1(e, r, Xe(t))))), P$1 in t && (a.push(I(e.base, P$1)), s.push(X(t[P$1]))), R in t && (a.push(I(e.base, R)), s.push(t[R] ? J : Z)), {
+		k: a,
+		v: s
+	};
+}
+async function zr(e, r, t, n, a) {
+	return tr(t, n, a, await kr(e, r, n));
+}
+async function xn(e, r, t, n) {
+	return ke(t, await N$1(e, r, n.valueOf()));
+}
+async function On(e, r, t, n) {
+	return De(t, n, await N$1(e, r, n.buffer));
+}
+async function Tn(e, r, t, n) {
+	return Fe(t, n, await N$1(e, r, n.buffer));
+}
+async function wn(e, r, t, n) {
+	return Be(t, n, await N$1(e, r, n.buffer));
+}
+async function zt(e, r, t, n) {
+	let a = $$1(n, e.base.features);
+	return Ve(t, n, a ? await kr(e, r, a) : o$1);
+}
+async function hn(e, r, t, n) {
+	let a = $$1(n, e.base.features);
+	return Me(t, n, a ? await kr(e, r, a) : o$1);
+}
+async function zn(e, r, t, n) {
+	let a = [], s = [];
+	for (let [i, u] of n.entries()) a.push(await N$1(e, r, i)), s.push(await N$1(e, r, u));
+	return nr(e.base, t, a, s);
+}
+async function _n(e, r, t, n) {
+	let a = [];
+	for (let s of n.keys()) a.push(await N$1(e, r, s));
+	return Le(t, a);
+}
+async function _t(e, r, t, n) {
+	let a = e.base.plugins;
+	if (a) for (let s = 0, i = a.length; s < i; s++) {
+		let u = a[s];
+		if (u.parse.async && u.test(n)) return fe$1(t, u.tag, await u.parse.async(n, new _r(e, r), { id: t }));
+	}
+	return o$1;
+}
+async function kn(e, r, t, n) {
+	let [a, s] = await wr(n);
+	return c$1(12, t, a, o$1, o$1, o$1, o$1, o$1, await N$1(e, r, s), o$1, o$1, o$1);
+}
+function Dn(e, r, t, n, a) {
+	let s = [], i = t.on({
+		next: (u) => {
+			de(this.base, r), N$1(this, e, u).then((l) => {
+				s.push(qe(r, l));
+			}, (l) => {
+				a(l), i();
+			});
+		},
+		throw: (u) => {
+			de(this.base, r), N$1(this, e, u).then((l) => {
+				s.push(We(r, l)), n(s), i();
+			}, (l) => {
+				a(l), i();
+			});
+		},
+		return: (u) => {
+			de(this.base, r), N$1(this, e, u).then((l) => {
+				s.push(Ge(r, l)), n(s), i();
+			}, (l) => {
+				a(l), i();
+			});
+		}
+	});
+}
+async function Fn(e, r, t, n) {
+	return Ye(t, k(e.base, 4), await new Promise(Dn.bind(e, r, t, n)));
+}
+async function Bn(e, r, t, n) {
+	let a = [];
+	for (let s = 0, i = n.v.length; s < i; s++) a[s] = await N$1(e, r, n.v[s]);
+	return Ke(t, a, n.t, n.d);
+}
+async function Vn(e, r, t, n) {
+	if (Array.isArray(n)) return Pn(e, r, t, n);
+	if (M(n)) return Fn(e, r, t, n);
+	if (Ze(n)) return Bn(e, r, t, n);
+	let a = n.constructor;
+	if (a === Y$1) return N$1(e, r, n.replacement);
+	let s = await _t(e, r, t, n);
+	if (s) return s;
+	switch (a) {
+		case Object: return zr(e, r, t, n, !1);
+		case o$1: return zr(e, r, t, n, !0);
+		case Date: return he(t, n);
+		case Error:
+		case EvalError:
+		case RangeError:
+		case ReferenceError:
+		case SyntaxError:
+		case TypeError:
+		case URIError: return zt(e, r, t, n);
+		case Number:
+		case Boolean:
+		case String:
+		case BigInt: return xn(e, r, t, n);
+		case ArrayBuffer: return or(e.base, t, n);
+		case Int8Array:
+		case Int16Array:
+		case Int32Array:
+		case Uint8Array:
+		case Uint16Array:
+		case Uint32Array:
+		case Uint8ClampedArray:
+		case Float32Array:
+		case Float64Array: return On(e, r, t, n);
+		case DataView: return wn(e, r, t, n);
+		case Map: return zn(e, r, t, n);
+		case Set: return _n(e, r, t, n);
+		default: break;
+	}
+	if (a === Promise || n instanceof Promise) return kn(e, r, t, n);
+	let i = e.base.features;
+	if (i & 32 && a === RegExp) return ze(t, n);
+	if (i & 16) switch (a) {
+		case BigInt64Array:
+		case BigUint64Array: return Tn(e, r, t, n);
+		default: break;
+	}
+	if (i & 1 && typeof AggregateError != "undefined" && (a === AggregateError || n instanceof AggregateError)) return hn(e, r, t, n);
+	if (n instanceof Error) return zt(e, r, t, n);
+	if (C in n || v$1 in n) return zr(e, r, t, n, !!a);
+	throw new x$1(n);
+}
+async function Mn(e, r, t) {
+	let n = q$1(e.base, t);
+	if (n.type !== 0) return n.value;
+	let a = await _t(e, r, n.value, t);
+	if (a) return a;
+	throw new x$1(t);
+}
+async function N$1(e, r, t) {
+	switch (typeof t) {
+		case "boolean": return t ? J : Z;
+		case "undefined": return Ae;
+		case "string": return X(t);
+		case "number": return Te(t);
+		case "bigint": return we(t);
+		case "object":
+			if (t) {
+				let n = q$1(e.base, t);
+				return n.type === 0 ? await Vn(e, r + 1, n.value, t) : n.value;
+			}
+			return Ee;
+		case "symbol": return I(e.base, t);
+		case "function": return Mn(e, r, t);
+		default: throw new x$1(t);
+	}
+}
+async function oe(e, r) {
+	try {
+		return await N$1(e, 0, r);
+	} catch (t) {
+		throw t instanceof z$2 ? t : new z$2(t);
+	}
+}
+var ae = ((t) => (t[t.Vanilla = 1] = "Vanilla", t[t.Cross = 2] = "Cross", t))(ae || {});
+function ni(e) {
+	return e;
+}
+function kt(e, r) {
+	for (let t = 0, n = r.length; t < n; t++) {
+		let a = r[t];
+		e.has(a) || (e.add(a), a.extends && kt(e, a.extends));
+	}
+}
+function A(e) {
+	if (e) {
+		let r = /* @__PURE__ */ new Set();
+		return kt(r, e), [...r];
+	}
+}
+function Dt(e) {
+	switch (e) {
+		case "Int8Array": return Int8Array;
+		case "Int16Array": return Int16Array;
+		case "Int32Array": return Int32Array;
+		case "Uint8Array": return Uint8Array;
+		case "Uint16Array": return Uint16Array;
+		case "Uint32Array": return Uint32Array;
+		case "Uint8ClampedArray": return Uint8ClampedArray;
+		case "Float32Array": return Float32Array;
+		case "Float64Array": return Float64Array;
+		case "BigInt64Array": return BigInt64Array;
+		case "BigUint64Array": return BigUint64Array;
+		default: throw new Je(e);
+	}
+}
+var Ln = 1e6, Un = 1e4, jn = 2e4;
+function Bt(e, r) {
+	switch (r) {
+		case 3: return Object.freeze(e);
+		case 1: return Object.preventExtensions(e);
+		case 2: return Object.seal(e);
+		default: return e;
+	}
+}
+var Yn = 1e3;
+function Vt(e, r) {
+	var t;
+	return {
+		mode: e,
+		plugins: r.plugins,
+		refs: r.refs || /* @__PURE__ */ new Map(),
+		features: (t = r.features) != null ? t : 63 ^ (r.disabledFeatures || 0),
+		depthLimit: r.depthLimit || Yn
+	};
+}
+function Mt(e) {
+	return {
+		mode: 1,
+		base: Vt(1, e),
+		child: o$1,
+		state: { marked: new Set(e.markedRefs) }
+	};
+}
+var Dr = class {
+	constructor(r, t) {
+		this._p = r;
+		this.depth = t;
+	}
+	deserialize(r) {
+		return p$1(this._p, this.depth, r);
+	}
+};
+function Ut(e, r) {
+	if (r < 0 || !Number.isFinite(r) || !Number.isInteger(r)) throw new h$1({
+		t: 4,
+		i: r
+	});
+	if (e.refs.has(r)) throw new Error("Conflicted ref id: " + r);
+}
+function qn(e, r, t) {
+	return Ut(e.base, r), e.state.marked.has(r) && e.base.refs.set(r, t), t;
+}
+function Wn(e, r, t) {
+	return Ut(e.base, r), e.base.refs.set(r, t), t;
+}
+function b(e, r, t) {
+	return e.mode === 1 ? qn(e, r, t) : Wn(e, r, t);
+}
+function Fr(e, r, t) {
+	if (Object.hasOwn(r, t)) return r[t];
+	throw new h$1(e);
+}
+function Gn(e, r) {
+	return b(e, r.i, ft(D$1(r.s)));
+}
+function Kn(e, r, t) {
+	let n = t.a, a = n.length, s = b(e, t.i, new Array(a));
+	for (let i = 0, u; i < a; i++) u = n[i], u && (s[i] = p$1(e, r, u));
+	return Bt(s, t.o), s;
+}
+function Hn(e) {
+	switch (e) {
+		case "constructor":
+		case "__proto__":
+		case "prototype":
+		case "__defineGetter__":
+		case "__defineSetter__":
+		case "__lookupGetter__":
+		case "__lookupSetter__": return !1;
+		default: return !0;
+	}
+}
+function Jn(e) {
+	switch (e) {
+		case v$1:
+		case R:
+		case P$1:
+		case C: return !0;
+		default: return !1;
+	}
+}
+function Ft(e, r, t) {
+	Hn(r) ? e[r] = t : Object.defineProperty(e, r, {
+		value: t,
+		configurable: !0,
+		enumerable: !0,
+		writable: !0
+	});
+}
+function Zn(e, r, t, n, a) {
+	if (typeof n == "string") Ft(t, D$1(n), p$1(e, r, a));
+	else {
+		let s = p$1(e, r, n);
+		switch (typeof s) {
+			case "string":
+				Ft(t, s, p$1(e, r, a));
+				break;
+			case "symbol":
+				Jn(s) && (t[s] = p$1(e, r, a));
+				break;
+			default: throw new h$1(n);
+		}
+	}
+}
+function jt(e, r, t, n) {
+	let a = t.k;
+	if (a.length > 0) for (let i = 0, u = t.v, l = a.length; i < l; i++) Zn(e, r, n, a[i], u[i]);
+	return n;
+}
+function $n(e, r, t) {
+	let n = b(e, t.i, t.t === 10 ? {} : Object.create(null));
+	return jt(e, r, t.p, n), Bt(n, t.o), n;
+}
+function Xn(e, r) {
+	return b(e, r.i, new Date(r.s));
+}
+function Qn(e, r) {
+	if (e.base.features & 32) {
+		let t = D$1(r.c);
+		if (t.length > jn) throw new h$1(r);
+		return b(e, r.i, new RegExp(t, r.m));
+	}
+	throw new w$1(r);
+}
+function eo(e, r, t) {
+	let n = b(e, t.i, /* @__PURE__ */ new Set());
+	for (let a = 0, s = t.a, i = s.length; a < i; a++) n.add(p$1(e, r, s[a]));
+	return n;
+}
+function ro(e, r, t) {
+	let n = b(e, t.i, /* @__PURE__ */ new Map());
+	for (let a = 0, s = t.e.k, i = t.e.v, u = s.length; a < u; a++) n.set(p$1(e, r, s[a]), p$1(e, r, i[a]));
+	return n;
+}
+function to(e, r) {
+	if (r.s.length > Ln) throw new h$1(r);
+	return b(e, r.i, Or(D$1(r.s)));
+}
+function no(e, r, t) {
+	var u;
+	let n = Dt(t.c), a = p$1(e, r, t.f), s = (u = t.b) != null ? u : 0;
+	if (s < 0 || s > a.byteLength) throw new h$1(t);
+	return b(e, t.i, new n(a, s, t.l));
+}
+function oo(e, r, t) {
+	var i;
+	let n = p$1(e, r, t.f), a = (i = t.b) != null ? i : 0;
+	if (a < 0 || a > n.byteLength) throw new h$1(t);
+	return b(e, t.i, new DataView(n, a, t.l));
+}
+function Yt(e, r, t, n) {
+	if (t.p) {
+		let a = jt(e, r, t.p, {});
+		Object.defineProperties(n, Object.getOwnPropertyDescriptors(a));
+	}
+	return n;
+}
+function ao(e, r, t) {
+	return Yt(e, r, t, b(e, t.i, new AggregateError([], D$1(t.m))));
+}
+function so(e, r, t) {
+	let n = Fr(t, at, t.s);
+	return Yt(e, r, t, b(e, t.i, new n(D$1(t.m))));
+}
+function io(e, r, t) {
+	let n = re(), a = b(e, t.i, n.p), s = p$1(e, r, t.f);
+	return t.s ? n.s(s) : n.f(s), a;
+}
+function uo(e, r, t) {
+	return b(e, t.i, Object(p$1(e, r, t.f)));
+}
+function lo(e, r, t) {
+	let n = e.base.plugins;
+	if (n) {
+		let a = D$1(t.c);
+		for (let s = 0, i = n.length; s < i; s++) {
+			let u = n[s];
+			if (u.tag === a) return b(e, t.i, u.deserialize(t.s, new Dr(e, r), { id: t.i }));
+		}
+	}
+	throw new Q(t.c);
+}
+function co(e, r) {
+	return b(e, r.i, b(e, r.s, re()).p);
+}
+function fo(e, r, t) {
+	let n = e.base.refs.get(t.i);
+	if (n) return n.s(p$1(e, r, t.a[1])), o$1;
+	throw new V("Promise");
+}
+function So(e, r, t) {
+	let n = e.base.refs.get(t.i);
+	if (n) return n.f(p$1(e, r, t.a[1])), o$1;
+	throw new V("Promise");
+}
+function mo(e, r, t) {
+	p$1(e, r, t.a[0]);
+	return It(p$1(e, r, t.a[1]));
+}
+function po(e, r, t) {
+	p$1(e, r, t.a[0]);
+	return Tt(p$1(e, r, t.a[1]));
+}
+function go(e, r, t) {
+	let n = b(e, t.i, te$1()), a = t.a, s = a.length;
+	if (s) for (let i = 0; i < s; i++) p$1(e, r, a[i]);
+	return n;
+}
+function yo(e, r, t) {
+	let n = e.base.refs.get(t.i);
+	if (n && M(n)) return n.next(p$1(e, r, t.f)), o$1;
+	throw new V("Stream");
+}
+function No(e, r, t) {
+	let n = e.base.refs.get(t.i);
+	if (n && M(n)) return n.throw(p$1(e, r, t.f)), o$1;
+	throw new V("Stream");
+}
+function bo(e, r, t) {
+	let n = e.base.refs.get(t.i);
+	if (n && M(n)) return n.return(p$1(e, r, t.f)), o$1;
+	throw new V("Stream");
+}
+function vo(e, r, t) {
+	return p$1(e, r, t.f), o$1;
+}
+function Co(e, r, t) {
+	return p$1(e, r, t.a[1]), o$1;
+}
+function Ao(e, r, t) {
+	let n = b(e, t.i, Tr([], t.s, t.l));
+	for (let a = 0, s = t.a.length; a < s; a++) n.v[a] = p$1(e, r, t.a[a]);
+	return n;
+}
+function p$1(e, r, t) {
+	if (r > e.base.depthLimit) throw new ee(e.base.depthLimit);
+	switch (r += 1, t.t) {
+		case 2: return Fr(t, ot, t.s);
+		case 0: return Number(t.s);
+		case 1: return D$1(String(t.s));
+		case 3:
+			if (String(t.s).length > Un) throw new h$1(t);
+			return BigInt(t.s);
+		case 4: return e.base.refs.get(t.i);
+		case 18: return Gn(e, t);
+		case 9: return Kn(e, r, t);
+		case 10:
+		case 11: return $n(e, r, t);
+		case 5: return Xn(e, t);
+		case 6: return Qn(e, t);
+		case 7: return eo(e, r, t);
+		case 8: return ro(e, r, t);
+		case 19: return to(e, t);
+		case 16:
+		case 15: return no(e, r, t);
+		case 20: return oo(e, r, t);
+		case 14: return ao(e, r, t);
+		case 13: return so(e, r, t);
+		case 12: return io(e, r, t);
+		case 17: return Fr(t, tt, t.s);
+		case 21: return uo(e, r, t);
+		case 25: return lo(e, r, t);
+		case 22: return co(e, t);
+		case 23: return fo(e, r, t);
+		case 24: return So(e, r, t);
+		case 28: return mo(e, r, t);
+		case 30: return po(e, r, t);
+		case 31: return go(e, r, t);
+		case 32: return yo(e, r, t);
+		case 33: return No(e, r, t);
+		case 34: return bo(e, r, t);
+		case 27: return vo(e, r, t);
+		case 29: return Co(e, r, t);
+		case 35: return Ao(e, r, t);
+		default: throw new w$1(t);
+	}
+}
+function ar(e, r) {
+	try {
+		return p$1(e, 0, r);
+	} catch (t) {
+		throw new He(t);
+	}
+}
+var Eo = () => T, Io = Eo.toString();
+/=>/.test(Io);
+async function Au(e, r = {}) {
+	let n = ne$1(1, {
+		plugins: A(r.plugins),
+		disabledFeatures: r.disabledFeatures
+	});
+	return {
+		t: await oe(n, e),
+		f: n.base.features,
+		m: Array.from(n.base.marked)
+	};
+}
+function Iu(e, r = {}) {
+	var i;
+	let t = A(r.plugins), n = r.disabledFeatures || 0, a = (i = e.f) != null ? i : 63;
+	return ar(Mt({
+		plugins: t,
+		markedRefs: e.m,
+		features: a & ~n,
+		disabledFeatures: n
+	}), e.t);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/seroval-plugins@1.5.2_seroval@1.5.2/node_modules/seroval-plugins/dist/esm/production/web.mjs
+var u = (e) => {
+	let r = new AbortController(), a = r.abort.bind(r);
+	return e.then(a, a), r;
+};
+function E(e) {
+	e(this.reason);
+}
+function D(e) {
+	this.addEventListener("abort", E.bind(this, e), { once: !0 });
+}
+function c(e) {
+	return new Promise(D.bind(e));
+}
+var i = {}, O = ni({
+	tag: "seroval-plugins/web/AbortSignal",
+	extends: [ni({
+		tag: "seroval-plugins/web/AbortControllerFactoryPlugin",
+		test(e) {
+			return e === i;
+		},
+		parse: {
+			sync() {
+				return i;
+			},
+			async async() {
+				return await Promise.resolve(i);
+			},
+			stream() {
+				return i;
+			}
+		},
+		serialize() {
+			return u.toString();
+		},
+		deserialize() {
+			return u;
+		}
+	})],
+	test(e) {
+		return typeof AbortSignal == "undefined" ? !1 : e instanceof AbortSignal;
+	},
+	parse: {
+		sync(e, r) {
+			return e.aborted ? { reason: r.parse(e.reason) } : {};
+		},
+		async async(e, r) {
+			if (e.aborted) return { reason: await r.parse(e.reason) };
+			let a = await c(e);
+			return { reason: await r.parse(a) };
+		},
+		stream(e, r) {
+			if (e.aborted) return { reason: r.parse(e.reason) };
+			let a = c(e);
+			return {
+				factory: r.parse(i),
+				controller: r.parse(a)
+			};
+		}
+	},
+	serialize(e, r) {
+		return e.reason ? "AbortSignal.abort(" + r.serialize(e.reason) + ")" : e.controller && e.factory ? "(" + r.serialize(e.factory) + ")(" + r.serialize(e.controller) + ").signal" : "(new AbortController).signal";
+	},
+	deserialize(e, r) {
+		return e.reason ? AbortSignal.abort(r.deserialize(e.reason)) : e.controller ? u(r.deserialize(e.controller)).signal : new AbortController().signal;
+	}
+});
+var B = ni({
+	tag: "seroval-plugins/web/Blob",
+	test(e) {
+		return typeof Blob == "undefined" ? !1 : e instanceof Blob;
+	},
+	parse: { async async(e, r) {
+		return {
+			type: await r.parse(e.type),
+			buffer: await r.parse(await e.arrayBuffer())
+		};
+	} },
+	serialize(e, r) {
+		return "new Blob([" + r.serialize(e.buffer) + "],{type:" + r.serialize(e.type) + "})";
+	},
+	deserialize(e, r) {
+		return new Blob([r.deserialize(e.buffer)], { type: r.deserialize(e.type) });
+	}
+});
+function d(e) {
+	return {
+		detail: e.detail,
+		bubbles: e.bubbles,
+		cancelable: e.cancelable,
+		composed: e.composed
+	};
+}
+var L = ni({
+	tag: "seroval-plugins/web/CustomEvent",
+	test(e) {
+		return typeof CustomEvent == "undefined" ? !1 : e instanceof CustomEvent;
+	},
+	parse: {
+		sync(e, r) {
+			return {
+				type: r.parse(e.type),
+				options: r.parse(d(e))
+			};
+		},
+		async async(e, r) {
+			return {
+				type: await r.parse(e.type),
+				options: await r.parse(d(e))
+			};
+		},
+		stream(e, r) {
+			return {
+				type: r.parse(e.type),
+				options: r.parse(d(e))
+			};
+		}
+	},
+	serialize(e, r) {
+		return "new CustomEvent(" + r.serialize(e.type) + "," + r.serialize(e.options) + ")";
+	},
+	deserialize(e, r) {
+		return new CustomEvent(r.deserialize(e.type), r.deserialize(e.options));
+	}
+});
+var q = ni({
+	tag: "seroval-plugins/web/DOMException",
+	test(e) {
+		return typeof DOMException == "undefined" ? !1 : e instanceof DOMException;
+	},
+	parse: {
+		sync(e, r) {
+			return {
+				name: r.parse(e.name),
+				message: r.parse(e.message)
+			};
+		},
+		async async(e, r) {
+			return {
+				name: await r.parse(e.name),
+				message: await r.parse(e.message)
+			};
+		},
+		stream(e, r) {
+			return {
+				name: r.parse(e.name),
+				message: r.parse(e.message)
+			};
+		}
+	},
+	serialize(e, r) {
+		return "new DOMException(" + r.serialize(e.message) + "," + r.serialize(e.name) + ")";
+	},
+	deserialize(e, r) {
+		return new DOMException(r.deserialize(e.message), r.deserialize(e.name));
+	}
+});
+function f(e) {
+	return {
+		bubbles: e.bubbles,
+		cancelable: e.cancelable,
+		composed: e.composed
+	};
+}
+var Y = ni({
+	tag: "seroval-plugins/web/Event",
+	test(e) {
+		return typeof Event == "undefined" ? !1 : e instanceof Event;
+	},
+	parse: {
+		sync(e, r) {
+			return {
+				type: r.parse(e.type),
+				options: r.parse(f(e))
+			};
+		},
+		async async(e, r) {
+			return {
+				type: await r.parse(e.type),
+				options: await r.parse(f(e))
+			};
+		},
+		stream(e, r) {
+			return {
+				type: r.parse(e.type),
+				options: r.parse(f(e))
+			};
+		}
+	},
+	serialize(e, r) {
+		return "new Event(" + r.serialize(e.type) + "," + r.serialize(e.options) + ")";
+	},
+	deserialize(e, r) {
+		return new Event(r.deserialize(e.type), r.deserialize(e.options));
+	}
+});
+var m = ni({
+	tag: "seroval-plugins/web/File",
+	test(e) {
+		return typeof File == "undefined" ? !1 : e instanceof File;
+	},
+	parse: { async async(e, r) {
+		return {
+			name: await r.parse(e.name),
+			options: await r.parse({
+				type: e.type,
+				lastModified: e.lastModified
+			}),
+			buffer: await r.parse(await e.arrayBuffer())
+		};
+	} },
+	serialize(e, r) {
+		return "new File([" + r.serialize(e.buffer) + "]," + r.serialize(e.name) + "," + r.serialize(e.options) + ")";
+	},
+	deserialize(e, r) {
+		return new File([r.deserialize(e.buffer)], r.deserialize(e.name), r.deserialize(e.options));
+	}
+});
+function y(e) {
+	let r = [];
+	return e.forEach((a, t) => {
+		r.push([t, a]);
+	}), r;
+}
+var o = {}, v = (e, r = new FormData(), a = 0, t = e.length, s) => {
+	for (; a < t; a++) s = e[a], r.append(s[0], s[1]);
+	return r;
+}, K = ni({
+	tag: "seroval-plugins/web/FormData",
+	extends: [m, ni({
+		tag: "seroval-plugins/web/FormDataFactory",
+		test(e) {
+			return e === o;
+		},
+		parse: {
+			sync() {
+				return o;
+			},
+			async async() {
+				return await Promise.resolve(o);
+			},
+			stream() {
+				return o;
+			}
+		},
+		serialize() {
+			return v.toString();
+		},
+		deserialize() {
+			return o;
+		}
+	})],
+	test(e) {
+		return typeof FormData == "undefined" ? !1 : e instanceof FormData;
+	},
+	parse: {
+		sync(e, r) {
+			return {
+				factory: r.parse(o),
+				entries: r.parse(y(e))
+			};
+		},
+		async async(e, r) {
+			return {
+				factory: await r.parse(o),
+				entries: await r.parse(y(e))
+			};
+		},
+		stream(e, r) {
+			return {
+				factory: r.parse(o),
+				entries: r.parse(y(e))
+			};
+		}
+	},
+	serialize(e, r) {
+		return "(" + r.serialize(e.factory) + ")(" + r.serialize(e.entries) + ")";
+	},
+	deserialize(e, r) {
+		return v(r.deserialize(e.entries));
+	}
+});
+function g(e) {
+	let r = [];
+	return e.forEach((a, t) => {
+		r.push([t, a]);
+	}), r;
+}
+var l = ni({
+	tag: "seroval-plugins/web/Headers",
+	test(e) {
+		return typeof Headers == "undefined" ? !1 : e instanceof Headers;
+	},
+	parse: {
+		sync(e, r) {
+			return { value: r.parse(g(e)) };
+		},
+		async async(e, r) {
+			return { value: await r.parse(g(e)) };
+		},
+		stream(e, r) {
+			return { value: r.parse(g(e)) };
+		}
+	},
+	serialize(e, r) {
+		return "new Headers(" + r.serialize(e.value) + ")";
+	},
+	deserialize(e, r) {
+		return new Headers(r.deserialize(e.value));
+	}
+});
+var $ = ni({
+	tag: "seroval-plugins/web/ImageData",
+	test(e) {
+		return typeof ImageData == "undefined" ? !1 : e instanceof ImageData;
+	},
+	parse: {
+		sync(e, r) {
+			return {
+				data: r.parse(e.data),
+				width: r.parse(e.width),
+				height: r.parse(e.height),
+				options: r.parse({ colorSpace: e.colorSpace })
+			};
+		},
+		async async(e, r) {
+			return {
+				data: await r.parse(e.data),
+				width: await r.parse(e.width),
+				height: await r.parse(e.height),
+				options: await r.parse({ colorSpace: e.colorSpace })
+			};
+		},
+		stream(e, r) {
+			return {
+				data: r.parse(e.data),
+				width: r.parse(e.width),
+				height: r.parse(e.height),
+				options: r.parse({ colorSpace: e.colorSpace })
+			};
+		}
+	},
+	serialize(e, r) {
+		return "new ImageData(" + r.serialize(e.data) + "," + r.serialize(e.width) + "," + r.serialize(e.height) + "," + r.serialize(e.options) + ")";
+	},
+	deserialize(e, r) {
+		return new ImageData(r.deserialize(e.data), r.deserialize(e.width), r.deserialize(e.height), r.deserialize(e.options));
+	}
+});
+var n = {}, P = (e) => new ReadableStream({ start: (r) => {
+	e.on({
+		next: (a) => {
+			try {
+				r.enqueue(a);
+			} catch (t) {}
+		},
+		throw: (a) => {
+			r.error(a);
+		},
+		return: () => {
+			try {
+				r.close();
+			} catch (a) {}
+		}
+	});
+} }), x = ni({
+	tag: "seroval-plugins/web/ReadableStreamFactory",
+	test(e) {
+		return e === n;
+	},
+	parse: {
+		sync() {
+			return n;
+		},
+		async async() {
+			return await Promise.resolve(n);
+		},
+		stream() {
+			return n;
+		}
+	},
+	serialize() {
+		return P.toString();
+	},
+	deserialize() {
+		return n;
+	}
+});
+function w(e) {
+	let r = te$1(), a = e.getReader();
+	async function t() {
+		try {
+			let s = await a.read();
+			s.done ? r.return(s.value) : (r.next(s.value), await t());
+		} catch (s) {
+			r.throw(s);
+		}
+	}
+	return t().catch(() => {}), r;
+}
+var p = ni({
+	tag: "seroval/plugins/web/ReadableStream",
+	extends: [x],
+	test(e) {
+		return typeof ReadableStream == "undefined" ? !1 : e instanceof ReadableStream;
+	},
+	parse: {
+		sync(e, r) {
+			return {
+				factory: r.parse(n),
+				stream: r.parse(te$1())
+			};
+		},
+		async async(e, r) {
+			return {
+				factory: await r.parse(n),
+				stream: await r.parse(w(e))
+			};
+		},
+		stream(e, r) {
+			return {
+				factory: r.parse(n),
+				stream: r.parse(w(e))
+			};
+		}
+	},
+	serialize(e, r) {
+		return "(" + r.serialize(e.factory) + ")(" + r.serialize(e.stream) + ")";
+	},
+	deserialize(e, r) {
+		return P(r.deserialize(e.stream));
+	}
+});
+function N(e, r) {
+	return {
+		body: r,
+		cache: e.cache,
+		credentials: e.credentials,
+		headers: e.headers,
+		integrity: e.integrity,
+		keepalive: e.keepalive,
+		method: e.method,
+		mode: e.mode,
+		redirect: e.redirect,
+		referrer: e.referrer,
+		referrerPolicy: e.referrerPolicy
+	};
+}
+var te = ni({
+	tag: "seroval-plugins/web/Request",
+	extends: [p, l],
+	test(e) {
+		return typeof Request == "undefined" ? !1 : e instanceof Request;
+	},
+	parse: {
+		async async(e, r) {
+			return {
+				url: await r.parse(e.url),
+				options: await r.parse(N(e, e.body && !e.bodyUsed ? await e.clone().arrayBuffer() : null))
+			};
+		},
+		stream(e, r) {
+			return {
+				url: r.parse(e.url),
+				options: r.parse(N(e, e.body && !e.bodyUsed ? e.clone().body : null))
+			};
+		}
+	},
+	serialize(e, r) {
+		return "new Request(" + r.serialize(e.url) + "," + r.serialize(e.options) + ")";
+	},
+	deserialize(e, r) {
+		return new Request(r.deserialize(e.url), r.deserialize(e.options));
+	}
+});
+function h(e) {
+	return {
+		headers: e.headers,
+		status: e.status,
+		statusText: e.statusText
+	};
+}
+var ne = ni({
+	tag: "seroval-plugins/web/Response",
+	extends: [p, l],
+	test(e) {
+		return typeof Response == "undefined" ? !1 : e instanceof Response;
+	},
+	parse: {
+		async async(e, r) {
+			return {
+				body: await r.parse(e.body && !e.bodyUsed ? await e.clone().arrayBuffer() : null),
+				options: await r.parse(h(e))
+			};
+		},
+		stream(e, r) {
+			return {
+				body: r.parse(e.body && !e.bodyUsed ? e.clone().body : null),
+				options: r.parse(h(e))
+			};
+		}
+	},
+	serialize(e, r) {
+		return "new Response(" + r.serialize(e.body) + "," + r.serialize(e.options) + ")";
+	},
+	deserialize(e, r) {
+		return new Response(r.deserialize(e.body), r.deserialize(e.options));
+	}
+});
+var pe = ni({
+	tag: "seroval-plugins/web/URL",
+	test(e) {
+		return typeof URL == "undefined" ? !1 : e instanceof URL;
+	},
+	parse: {
+		sync(e, r) {
+			return { value: r.parse(e.href) };
+		},
+		async async(e, r) {
+			return { value: await r.parse(e.href) };
+		},
+		stream(e, r) {
+			return { value: r.parse(e.href) };
+		}
+	},
+	serialize(e, r) {
+		return "new URL(" + r.serialize(e.value) + ")";
+	},
+	deserialize(e, r) {
+		return new URL(r.deserialize(e.value));
 	}
-	scope.outputs[key] = existing + delta;
-	recordOpIfActive(scope, {
-		kind: "incrementOutput",
-		key,
-		delta
-	});
-}
-/**
-* Assert a condition for the current eval case and throw on failure.
-*
-* Calls made outside `runInEvalScope(...)` are ignored so shared workflow code
-* can safely reuse `evalAssert(...)` when it also runs outside an eval.
-*/
-function evalAssert(condition, message) {
-	if (condition) return;
-	const scope = getCurrentScope();
-	if (!scope) return;
-	const error = new EvalAssertionError(message);
-	scope.assertionFailures.push(toAssertionFailure$1(message, error));
-	throw error;
-}
-//#endregion
-//#region ../sdk/src/cacheKey.ts
-var SerializedCacheKeyValue = class {
-	value;
-	constructor(value) {
-		this.value = value;
+});
+var fe = ni({
+	tag: "seroval-plugins/web/URLSearchParams",
+	test(e) {
+		return typeof URLSearchParams == "undefined" ? !1 : e instanceof URLSearchParams;
+	},
+	parse: {
+		sync(e, r) {
+			return { value: r.parse(e.toString()) };
+		},
+		async async(e, r) {
+			return { value: await r.parse(e.toString()) };
+		},
+		stream(e, r) {
+			return { value: r.parse(e.toString()) };
+		}
+	},
+	serialize(e, r) {
+		return "new URLSearchParams(" + r.serialize(e.value) + ")";
+	},
+	deserialize(e, r) {
+		return new URLSearchParams(r.deserialize(e.value));
 	}
-};
-/**
-* Hash the components of a cache key into a deterministic hex digest.
-*
-* Native `Blob` and `File` values are read asynchronously and hashed by
-* content. Use `hashCacheKeySync` only when the key contains no async values.
-*/
-async function hashCacheKey(input) {
-	return hashCacheKeySyncMaterialized(await materializeAsyncCacheKeyValue(input));
+});
+//#endregion
+//#region ../sdk/src/cacheSerialization.ts
+const serializedCacheValueMarker = "__agentEvalsCacheSerialization";
+const serializedCacheValueVersion = "seroval-web-v1";
+const serovalWebPlugins = [
+	O,
+	B,
+	L,
+	q,
+	Y,
+	m,
+	K,
+	l,
+	$,
+	p,
+	te,
+	ne,
+	pe,
+	fe
+];
+function isRecordLike$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-/**
-* Synchronously hash cache key components. This supports JSON-like data and
-* in-memory binary values such as `Buffer`, `ArrayBuffer`, and typed arrays,
-* but cannot content-hash native `Blob` or `File` values.
-*/
-function hashCacheKeySync(input) {
-	return hashCacheKeySyncMaterialized(input);
+function isSerializedCacheValue(value) {
+	return isRecordLike$2(value) && value[serializedCacheValueMarker] === serializedCacheValueVersion;
 }
-function hashCacheKeySyncMaterialized(input) {
-	return createHash("sha256").update(getCompositeKey(input, { stringify: stringifyCacheKeyValue })).digest("hex");
+/** Serialize one cached value with Seroval plus the Web API plugin set. */
+async function serializeCacheValue(value) {
+	return {
+		[serializedCacheValueMarker]: serializedCacheValueVersion,
+		value: await Au(value, { plugins: serovalWebPlugins })
+	};
 }
-function stringifyCacheKeyValue(value) {
-	if (value instanceof SerializedCacheKeyValue) return value.value;
-	if (Buffer$1.isBuffer(value)) return `$buffer:${hashBytes(value)}`;
-	if (isArrayBuffer(value)) return `$arrayBuffer:${hashBytes(new Uint8Array(value))}`;
-	if (isSharedArrayBuffer(value)) return `$sharedArrayBuffer:${hashBytes(new Uint8Array(value))}`;
-	if (isArrayBufferView(value)) {
-		const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-		return `$${value.constructor.name}:${hashBytes(bytes)}`;
-	}
-	if (isFile$1(value)) return `$file:${getCompositeKey({
-		lastModified: value.lastModified,
-		name: value.name,
-		size: value.size,
-		type: value.type
-	})}`;
-	if (isBlob$1(value)) return `$blob:${getCompositeKey({
-		size: value.size,
-		type: value.type
-	})}`;
+/** Revive one cached value, while preserving legacy JSON-round-tripped data. */
+function deserializeCacheValue(value) {
+	if (!isSerializedCacheValue(value)) return value;
+	return Iu(value.value, { plugins: serovalWebPlugins });
 }
-async function materializeAsyncCacheKeyValue(value, refs = /* @__PURE__ */ new WeakSet()) {
-	const serialized = await stringifyAsyncCacheKeyValue(value);
-	if (serialized !== void 0) return new SerializedCacheKeyValue(serialized);
-	if (stringifyCacheKeyValue(value) !== void 0) return value;
-	if (!value || typeof value !== "object") return value;
-	if (Array.isArray(value)) {
-		const items = [];
-		for (const item of value) items.push(await materializeAsyncCacheKeyValue(item, refs));
-		return items;
-	}
-	if (refs.has(value)) throw new Error("Circular reference detected");
-	refs.add(value);
+/** Clone one value through the same Seroval path used for persisted cache data. */
+async function cloneCacheValue(value) {
+	return deserializeCacheValue(await serializeCacheValue(value));
+}
+async function serializeRecordValues(record) {
 	const entries = [];
-	for (const [key, entryValue] of Object.entries(value)) entries.push([key, await materializeAsyncCacheKeyValue(entryValue, refs)]);
-	refs.delete(value);
+	for (const [key, value] of Object.entries(record)) entries.push([key, await serializeCacheValue(value)]);
 	return Object.fromEntries(entries);
 }
-async function stringifyAsyncCacheKeyValue(value) {
-	if (isFile$1(value)) return `$file:${getCompositeKey({
-		bytes: await hashBlobBytes(value),
-		lastModified: value.lastModified,
-		name: value.name,
-		size: value.size,
-		type: value.type
-	})}`;
-	if (isBlob$1(value)) return `$blob:${getCompositeKey({
-		bytes: await hashBlobBytes(value),
-		size: value.size,
-		type: value.type
-	})}`;
-}
-async function hashBlobBytes(value) {
-	return hashBytes(new Uint8Array(await value.arrayBuffer()));
-}
-function hashBytes(value) {
-	return createHash("sha256").update(value).digest("hex");
+function deserializeRecordValues(record) {
+	return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, deserializeCacheValue(value)]));
 }
-function isArrayBuffer(value) {
-	return value instanceof ArrayBuffer;
+async function serializeCacheRecordingOp(op) {
+	switch (op.kind) {
+		case "setOutput":
+		case "appendOutput": return {
+			...op,
+			value: await serializeCacheValue(op.value)
+		};
+		case "mergeOutput": return {
+			...op,
+			patch: await serializeRecordValues(op.patch)
+		};
+		case "incrementOutput": return op;
+		case "checkpoint": return {
+			...op,
+			data: await serializeCacheValue(op.data)
+		};
+		case "subSpan": return {
+			...op,
+			span: await serializeCacheSpan(op.span)
+		};
+	}
 }
-function isSharedArrayBuffer(value) {
-	return value instanceof SharedArrayBuffer;
+function deserializeCacheRecordingOp(op) {
+	switch (op.kind) {
+		case "setOutput":
+		case "appendOutput": return {
+			...op,
+			value: deserializeCacheValue(op.value)
+		};
+		case "mergeOutput": return {
+			...op,
+			patch: deserializeRecordValues(op.patch)
+		};
+		case "incrementOutput": return op;
+		case "checkpoint": return {
+			...op,
+			data: deserializeCacheValue(op.data)
+		};
+		case "subSpan": return {
+			...op,
+			span: deserializeCacheSpan(op.span)
+		};
+	}
 }
-function isArrayBufferView(value) {
-	return ArrayBuffer.isView(value);
+async function serializeCacheSpan(span) {
+	return {
+		...span,
+		attributes: span.attributes === void 0 ? void 0 : await serializeRecordValues(span.attributes),
+		children: await Promise.all(span.children.map(serializeCacheSpan))
+	};
 }
-function isBlob$1(value) {
-	return value instanceof Blob;
+function deserializeCacheSpan(span) {
+	return {
+		...span,
+		attributes: span.attributes === void 0 ? void 0 : deserializeRecordValues(span.attributes),
+		children: span.children.map(deserializeCacheSpan)
+	};
 }
-function isFile$1(value) {
-	return value instanceof File;
+/** Serialize all rich values captured in a cache recording before persistence. */
+async function serializeCacheRecording(recording) {
+	return {
+		...recording,
+		returnValue: await serializeCacheValue(recording.returnValue),
+		finalAttributes: await serializeRecordValues(recording.finalAttributes),
+		ops: await Promise.all(recording.ops.map(serializeCacheRecordingOp))
+	};
 }
-function toJsonSafe(value) {
-	if (value === void 0) return void 0;
-	const text = JSON.stringify(value);
-	return JSON.parse(text);
+/** Revive all rich values captured in a cache recording after lookup. */
+function deserializeCacheRecording(recording) {
+	return {
+		...recording,
+		returnValue: deserializeCacheValue(recording.returnValue),
+		finalAttributes: deserializeRecordValues(recording.finalAttributes),
+		ops: recording.ops.map(deserializeCacheRecordingOp)
+	};
 }
 //#endregion
 //#region ../sdk/src/cacheRecording.ts
@@ -388,8 +2192,8 @@ function stripCacheAttributes(attributes) {
 	for (const [key, value] of Object.entries(attributes)) if (!key.startsWith("cache.")) result[key] = value;
 	return result;
 }
-function snapshotNonCacheAttributes(span) {
-	const snapshot = toJsonSafe(stripCacheAttributes(span?.attributes));
+async function snapshotNonCacheAttributes(span) {
+	const snapshot = await cloneCacheValue(stripCacheAttributes(span?.attributes));
 	return isRecordLike$1(snapshot) ? snapshot : {};
 }
 function diffNonCacheAttributes(before, after) {
@@ -410,6 +2214,19 @@ function appendCacheRef(span, ref) {
 	const existing = span.attributes?.["cache.refs"];
 	mergeSpanAttributes$1(span, { "cache.refs": [...Array.isArray(existing) ? copyArray(existing) : [], ref] });
 }
+/**
+* Record a cache ref against the active span when present, or against the
+* case scope's `caseCacheRefs` bucket when the call originated from outside
+* any `traceSpan(...)` body. Without this, spanless refs would be silently
+* dropped and never surface in the trace or case detail.
+*/
+function recordCacheRef(scope, span, ref) {
+	if (span !== void 0) {
+		appendCacheRef(span, ref);
+		return;
+	}
+	scope.caseCacheRefs.push(ref);
+}
 function serializeSubSpanTree(scope, spanId) {
 	const original = scope.spans.find((s) => s.id === spanId);
 	if (!original) return {
@@ -522,7 +2339,7 @@ const errorCoreFields = new Set([
 	"stack",
 	"capturedAt"
 ]);
-function isRecord$2(value) {
+function isRecord$4(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function formatUnknownErrorMessage(error) {
@@ -550,7 +2367,7 @@ function normalizeTraceError(error, capturedAt = void 0) {
 		stack: error.stack,
 		capturedAt
 	};
-	if (isRecord$2(error)) {
+	if (isRecord$4(error)) {
 		const extraFields = getErrorExtraFields(error);
 		const name = typeof error.name === "string" ? error.name : void 0;
 		const stack = typeof error.stack === "string" ? error.stack : void 0;
@@ -575,7 +2392,7 @@ function normalizeTraceWarnings(warningOrWarnings, additionalWarnings, capturedA
 	return (additionalWarnings.length > 0 ? [warningOrWarnings, ...additionalWarnings] : Array.isArray(warningOrWarnings) ? warningOrWarnings : [warningOrWarnings]).map((warning) => normalizeTraceError(warning, capturedAt));
 }
 function isCaptureEvalSpanErrorOptions(value) {
-	if (!isRecord$2(value)) return false;
+	if (!isRecord$4(value)) return false;
 	const keys = Object.keys(value);
 	if (keys.length === 0) return false;
 	if (!keys.every((key) => key === "level")) return false;
@@ -630,14 +2447,14 @@ function createTraceCache(generateSpanId) {
 			namespace,
 			codeFingerprint: cacheCtx.codeFingerprint,
 			key: info.key
-		});
+		}, { serializeFileBytes: info.serializeFileBytes === true });
 		const activeSpan = scope.activeSpanStack.at(-1);
 		if (cacheCtx.mode === "use") {
 			const hit = await cacheCtx.adapter.lookup(namespace, keyHash);
 			if (hit) {
 				const storedAt = hit.storedAt;
 				const age = Date.now() - new Date(storedAt).getTime();
-				appendCacheRef(activeSpan, {
+				recordCacheRef(scope, activeSpan, {
 					type: "value",
 					name: info.name,
 					namespace,
@@ -646,31 +2463,32 @@ function createTraceCache(generateSpanId) {
 					storedAt,
 					age
 				});
-				replayRecording(scope, activeSpan, hit.recording, { generateSpanId });
-				return hit.recording.returnValue;
+				const recording = deserializeCacheRecording(hit.recording);
+				replayRecording(scope, activeSpan, recording, { generateSpanId });
+				return recording.returnValue;
 			}
-			appendCacheRef(activeSpan, {
+			recordCacheRef(scope, activeSpan, {
 				type: "value",
 				name: info.name,
 				namespace,
 				key: keyHash,
 				status: "miss"
 			});
-		} else if (cacheCtx.mode === "refresh") appendCacheRef(activeSpan, {
+		} else if (cacheCtx.mode === "refresh") recordCacheRef(scope, activeSpan, {
 			type: "value",
 			name: info.name,
 			namespace,
 			key: keyHash,
 			status: "refresh"
 		});
-		else appendCacheRef(activeSpan, {
+		else recordCacheRef(scope, activeSpan, {
 			type: "value",
 			name: info.name,
 			namespace,
 			key: keyHash,
 			status: "bypass"
 		});
-		const beforeAttributes = snapshotNonCacheAttributes(activeSpan);
+		const beforeAttributes = await snapshotNonCacheAttributes(activeSpan);
 		const frame = {
 			baseSpanIndex: scope.spans.length,
 			replayParentSpanId: activeSpan?.id ?? null,
@@ -685,9 +2503,9 @@ function createTraceCache(generateSpanId) {
 		}
 		appendSubSpanOps(scope, frame);
 		if (cacheCtx.mode !== "bypass") {
-			const finalAttributes = diffNonCacheAttributes(beforeAttributes, snapshotNonCacheAttributes(activeSpan));
+			const finalAttributes = diffNonCacheAttributes(beforeAttributes, await snapshotNonCacheAttributes(activeSpan));
 			const recording = {
-				returnValue: toJsonSafe(bodyResult),
+				returnValue: bodyResult,
 				finalAttributes,
 				ops: frame.ops
 			};
@@ -699,7 +2517,7 @@ function createTraceCache(generateSpanId) {
 				operationName: info.name,
 				storedAt: (/* @__PURE__ */ new Date()).toISOString(),
 				codeFingerprint: cacheCtx.codeFingerprint,
-				recording
+				recording: await serializeCacheRecording(recording)
 			});
 		}
 		return bodyResult;
@@ -1060,7 +2878,7 @@ async function traceSpan(info, fn) {
 				namespace,
 				codeFingerprint: ctx.codeFingerprint,
 				key: cacheOpts.key
-			});
+			}, { serializeFileBytes: cacheOpts.serializeFileBytes === true });
 			mergeSpanAttributes(spanRecord, {
 				"cache.key": keyHash,
 				"cache.namespace": namespace
@@ -1074,10 +2892,11 @@ async function traceSpan(info, fn) {
 						"cache.storedAt": storedAt,
 						"cache.age": Date.now() - new Date(storedAt).getTime()
 					});
-					replayRecording(scope, spanRecord, hit.recording, { generateSpanId });
-					spanRecord.status = hit.recording.finalStatus ?? (hasSpanError(spanRecord) ? "error" : "ok");
+					const recording = deserializeCacheRecording(hit.recording);
+					replayRecording(scope, spanRecord, recording, { generateSpanId });
+					spanRecord.status = recording.finalStatus ?? (hasSpanError(spanRecord) ? "error" : "ok");
 					spanRecord.endedAt = (/* @__PURE__ */ new Date()).toISOString();
-					return hit.recording.returnValue;
+					return recording.returnValue;
 				}
 				mergeSpanAttributes(spanRecord, { "cache.status": "miss" });
 			} else if (ctx.mode === "refresh") mergeSpanAttributes(spanRecord, { "cache.status": "refresh" });
@@ -1098,7 +2917,7 @@ async function traceSpan(info, fn) {
 			finishSpanWithoutThrownError(spanRecord);
 			if (ctx.mode !== "bypass") {
 				const recording = {
-					returnValue: toJsonSafe(bodyResult),
+					returnValue: bodyResult,
 					finalAttributes: stripCacheAttributes(spanRecord.attributes),
 					finalStatus: spanRecord.status,
 					finalError: spanRecord.error,
@@ -1117,7 +2936,7 @@ async function traceSpan(info, fn) {
 					spanKind: info.kind,
 					storedAt: (/* @__PURE__ */ new Date()).toISOString(),
 					codeFingerprint: ctx.codeFingerprint,
-					recording
+					recording: await serializeCacheRecording(recording)
 				};
 				await ctx.adapter.write(entry);
 			}
@@ -1386,12 +3205,163 @@ const traceSpanSchema = z.object({
 		"ok",
 		"error",
 		"cancelled"
-	]),
-	attributes: z.record(z.string(), z.unknown()).optional(),
-	error: traceSpanErrorSchema.optional(),
-	errors: z.array(traceSpanErrorSchema).optional(),
-	warning: traceSpanWarningSchema.optional(),
-	warnings: z.array(traceSpanWarningSchema).optional()
+	]),
+	attributes: z.record(z.string(), z.unknown()).optional(),
+	error: traceSpanErrorSchema.optional(),
+	errors: z.array(traceSpanErrorSchema).optional(),
+	warning: traceSpanWarningSchema.optional(),
+	warnings: z.array(traceSpanWarningSchema).optional()
+});
+//#endregion
+//#region ../shared/src/schemas/cache.ts
+/**
+* Mode that controls how the cache is consulted for a given run.
+*
+* - `use`: read cache on hit, write on miss. Default.
+* - `bypass`: never read, never write.
+* - `refresh`: never read, always write (forces re-execution and overwrites).
+*/
+const cacheModeSchema = z.enum([
+	"use",
+	"bypass",
+	"refresh"
+]);
+/** Options accepted by an `evalTracer.span` call to opt the span into caching. */
+const spanCacheOptionsSchema = z.object({
+	/** Arbitrary JSON-safe value used to derive the cache key. */
+	key: z.unknown(),
+	/** Override the default namespace (`${evalId}__${spanName}`). */
+	namespace: z.string().optional(),
+	/**
+	* Include native `Blob`/`File` bytes in the cache key. By default only stable
+	* metadata (`type`, `size`, plus `name`/`lastModified` for `File`) is used.
+	*/
+	serializeFileBytes: z.boolean().optional()
+});
+/** Category of operation stored in the eval cache. */
+const cacheOperationTypeSchema = z.enum(["span", "value"]);
+/** Status of a cache lookup recorded on a span or case scope. */
+const cacheStatusSchema = z.enum([
+	"hit",
+	"miss",
+	"refresh",
+	"bypass"
+]);
+/**
+* Reference to a value-cache lookup performed via `evalTracer.cache(...)`.
+*
+* Refs are appended to the active span's `cache.refs` attribute when the call
+* happens inside a `traceSpan(...)` body, or to the case scope's
+* `caseCacheRefs` bucket when the call is made directly from the case body.
+*/
+const traceCacheRefSchema = z.object({
+	type: z.literal("value"),
+	name: z.string(),
+	namespace: z.string(),
+	key: z.string(),
+	status: cacheStatusSchema,
+	storedAt: z.string().optional(),
+	age: z.number().optional()
+});
+/** Summary of a single persisted cache entry, used by list/delete endpoints. */
+const cacheListItemSchema = z.object({
+	key: z.string(),
+	namespace: z.string(),
+	operationType: cacheOperationTypeSchema,
+	operationName: z.string(),
+	spanName: z.string().optional(),
+	spanKind: traceSpanKindSchema.optional(),
+	storedAt: z.string(),
+	codeFingerprint: z.string(),
+	sizeBytes: z.number()
+});
+/** Zod schema for `SerializedCacheSpan`, defined lazily for recursion. */
+const serializedCacheSpanSchema = z.object({
+	kind: traceSpanKindSchema,
+	name: z.string(),
+	attributes: z.record(z.string(), z.unknown()).optional(),
+	status: z.enum([
+		"running",
+		"ok",
+		"error",
+		"cancelled"
+	]),
+	error: traceSpanErrorSchema.optional(),
+	errors: z.array(traceSpanErrorSchema).optional(),
+	warning: traceSpanWarningSchema.optional(),
+	warnings: z.array(traceSpanWarningSchema).optional()
+}).extend({ children: z.lazy(() => z.array(serializedCacheSpanSchema)) });
+/**
+* One captured operation performed while a cached span's body executed.
+*
+* Operations are replayed in order against a fresh scope on cache hit to
+* reproduce the observable effects of the original run.
+*/
+const cacheRecordingOpSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("setOutput"),
+		key: z.string(),
+		value: z.unknown()
+	}),
+	z.object({
+		kind: z.literal("appendOutput"),
+		key: z.string(),
+		value: z.unknown()
+	}),
+	z.object({
+		kind: z.literal("mergeOutput"),
+		key: z.string(),
+		patch: z.record(z.string(), z.unknown())
+	}),
+	z.object({
+		kind: z.literal("incrementOutput"),
+		key: z.string(),
+		delta: z.number()
+	}),
+	z.object({
+		kind: z.literal("checkpoint"),
+		name: z.string(),
+		data: z.unknown()
+	}),
+	z.object({
+		kind: z.literal("subSpan"),
+		span: serializedCacheSpanSchema
+	})
+]);
+/** Captured observable effects + return value of a cached span body. */
+const cacheRecordingSchema = z.object({
+	returnValue: z.unknown(),
+	finalAttributes: z.record(z.string(), z.unknown()),
+	finalStatus: z.enum([
+		"running",
+		"ok",
+		"error",
+		"cancelled"
+	]).optional(),
+	finalError: traceSpanErrorSchema.optional(),
+	finalErrors: z.array(traceSpanErrorSchema).optional(),
+	finalWarning: traceSpanWarningSchema.optional(),
+	finalWarnings: z.array(traceSpanWarningSchema).optional(),
+	ops: z.array(cacheRecordingOpSchema)
+});
+/** Persisted cache file containing metadata and a recording. */
+const cacheEntrySchema = z.object({
+	version: z.literal(1),
+	key: z.string(),
+	namespace: z.string(),
+	operationType: cacheOperationTypeSchema.optional(),
+	operationName: z.string().optional(),
+	spanName: z.string().optional(),
+	spanKind: traceSpanKindSchema.optional(),
+	storedAt: z.string(),
+	codeFingerprint: z.string(),
+	recording: cacheRecordingSchema
+});
+/** Persisted per-owner cache file containing multiple cache entries. */
+const cacheFileSchema = z.object({
+	version: z.literal(1),
+	owner: z.string(),
+	entries: z.record(z.string(), cacheEntrySchema)
 });
 //#endregion
 //#region ../shared/src/schemas/chart.ts
@@ -1629,135 +3599,149 @@ const caseDetailSchema = z.object({
 		stack: z.string().optional()
 	}).nullable(),
 	/** Winning trial index for the persisted case detail. */
-	trial: z.number()
+	trial: z.number(),
+	/**
+	* Value-cache refs recorded by `evalTracer.cache(...)` calls made directly
+	* from the case body (with no surrounding `traceSpan`). Span-bound refs are
+	* stored on each owning span's `cache.refs` attribute instead.
+	*/
+	cacheRefs: z.array(traceCacheRefSchema).default([])
 });
 //#endregion
-//#region ../shared/src/schemas/cache.ts
+//#region ../shared/src/schemas/config.ts
+/** Strategy used to collapse repeated trials into one stored case result. */
+const trialSelectionModeSchema = z.enum(["lowestScore", "median"]);
+/** Render formats supported by an LLM-call metric in the UI. */
+const llmCallMetricFormatSchema = z.enum([
+	"string",
+	"number",
+	"duration",
+	"json",
+	"boolean"
+]);
+/** Where an LLM-call metric is rendered inside the LLM calls tab. */
+const llmCallMetricPlacementSchema = z.enum(["header", "body"]);
 /**
-* Mode that controls how the cache is consulted for a given run.
+* Schema for a single user-defined metric attached to LLM call rows.
 *
-* - `use`: read cache on hit, write on miss. Default.
-* - `bypass`: never read, never write.
-* - `refresh`: never read, always write (forces re-execution and overwrites).
+* Each metric reads `path` from the span's `attributes` and renders the value
+* with the configured `format` and `numberFormat`. `placements` controls
+* whether the metric appears as a chip on the collapsed row header, as a row
+* inside the expanded body, or both. Defaults to `['body']` when omitted.
 */
-const cacheModeSchema = z.enum([
-	"use",
-	"bypass",
-	"refresh"
-]);
-/** Options accepted by an `evalTracer.span` call to opt the span into caching. */
-const spanCacheOptionsSchema = z.object({
-	/** Arbitrary JSON-safe value used to derive the cache key. */
-	key: z.unknown(),
-	/** Override the default namespace (`${evalId}__${spanName}`). */
-	namespace: z.string().optional()
+const llmCallMetricSchema = z.object({
+	/** Display label for the metric row or header chip. */
+	label: z.string().min(1),
+	/**
+	* Optional hover tooltip shown on the metric. Useful when `label` is a
+	* compact abbreviation (e.g. `'t/s'`) and the full meaning needs to be
+	* surfaced on hover (e.g. `'Tokens per second'`).
+	*/
+	tooltip: z.string().min(1).optional(),
+	/** Dot-path inside `span.attributes` used to read the value. */
+	path: z.string().min(1),
+	/** Render hint applied to the resolved value. Defaults to `'string'`. */
+	format: llmCallMetricFormatSchema.optional(),
+	/** Number presentation options applied when `format: 'number'`. */
+	numberFormat: numberDisplayOptionsSchema.optional(),
+	/**
+	* Where the metric should appear in the LLM calls tab. Defaults to
+	* `['body']` so metrics surface inside the expanded detail view only.
+	*/
+	placements: z.array(llmCallMetricPlacementSchema).nonempty().optional()
 });
-/** Category of operation stored in the eval cache. */
-const cacheOperationTypeSchema = z.enum(["span", "value"]);
-/** Summary of a single persisted cache entry, used by list/delete endpoints. */
-const cacheListItemSchema = z.object({
-	key: z.string(),
-	namespace: z.string(),
-	operationType: cacheOperationTypeSchema,
-	operationName: z.string(),
-	spanName: z.string().optional(),
-	spanKind: traceSpanKindSchema.optional(),
-	storedAt: z.string(),
-	codeFingerprint: z.string(),
-	sizeBytes: z.number()
+/** Schema for the global LLM calls config block in `agent-evals.config.ts`. */
+const llmCallsConfigSchema = z.object({
+	/** Span kinds treated as LLM calls. Defaults to `['llm']`. */
+	kinds: z.array(z.string().min(1)).optional(),
+	/**
+	* Attribute paths used to extract structured per-call fields. Each entry is
+	* a dot-path inside `span.attributes`. Missing paths fall back to the
+	* built-in defaults (e.g. `usage.inputTokens`, `costUsd`).
+	*
+	* Per-token-type cost paths (`inputCost`, `outputCost`, `cachedInputCost`,
+	* `reasoningCost`) feed the cost breakdown table in the expanded row.
+	* Record them as USD numbers alongside `costUsd` in your span attributes.
+	*/
+	attributes: z.object({
+		model: z.string().optional(),
+		provider: z.string().optional(),
+		inputTokens: z.string().optional(),
+		outputTokens: z.string().optional(),
+		cachedInputTokens: z.string().optional(),
+		cacheCreationInputTokens: z.string().optional(),
+		reasoningTokens: z.string().optional(),
+		totalTokens: z.string().optional(),
+		cost: z.string().optional(),
+		inputCost: z.string().optional(),
+		outputCost: z.string().optional(),
+		cachedInputCost: z.string().optional(),
+		cacheCreationInputCost: z.string().optional(),
+		reasoningCost: z.string().optional(),
+		steps: z.string().optional(),
+		finishReason: z.string().optional(),
+		input: z.string().optional(),
+		output: z.string().optional(),
+		reasoning: z.string().optional(),
+		toolCalls: z.string().optional()
+	}).optional(),
+	/** Custom user-defined metrics surfaced on each LLM call. */
+	metrics: z.array(llmCallMetricSchema).optional()
 });
-/** Zod schema for `SerializedCacheSpan`, defined lazily for recursion. */
-const serializedCacheSpanSchema = z.object({
-	kind: traceSpanKindSchema,
-	name: z.string(),
-	attributes: z.record(z.string(), z.unknown()).optional(),
-	status: z.enum([
-		"running",
-		"ok",
-		"error",
-		"cancelled"
-	]),
-	error: traceSpanErrorSchema.optional(),
-	errors: z.array(traceSpanErrorSchema).optional(),
-	warning: traceSpanWarningSchema.optional(),
-	warnings: z.array(traceSpanWarningSchema).optional()
-}).extend({ children: z.lazy(() => z.array(serializedCacheSpanSchema)) });
+/** Default LLM-calls config the UI uses before the workspace fetch resolves. */
+const DEFAULT_LLM_CALLS_CONFIG = {
+	kinds: ["llm"],
+	attributes: {
+		model: "model",
+		provider: "provider",
+		inputTokens: "usage.inputTokens",
+		outputTokens: "usage.outputTokens",
+		cachedInputTokens: "usage.cachedInputTokens",
+		cacheCreationInputTokens: "usage.cacheCreationInputTokens",
+		reasoningTokens: "usage.reasoningTokens",
+		totalTokens: "usage.totalTokens",
+		cost: "costUsd",
+		inputCost: "cost.inputUsd",
+		outputCost: "cost.outputUsd",
+		cachedInputCost: "cost.cachedInputUsd",
+		cacheCreationInputCost: "cost.cacheCreationInputUsd",
+		reasoningCost: "cost.reasoningUsd",
+		steps: "steps",
+		finishReason: "finishReason",
+		input: "input",
+		output: "output",
+		reasoning: "reasoning",
+		toolCalls: "toolCalls"
+	},
+	metrics: []
+};
 /**
-* One captured operation performed while a cached span's body executed.
+* Resolve the user-authored LLM-calls config to a fully-defaulted shape used
+* by the UI to derive the LLM calls tab.
 *
-* Operations are replayed in order against a fresh scope on cache hit to
-* reproduce the observable effects of the original run.
+* - Missing or empty `kinds` falls back to `['llm']`.
+* - Missing `attributes.<field>` falls back to the corresponding default
+*   attribute path.
+* - Missing `metrics[].format` defaults to `'string'`.
+* - Missing `metrics[].placements` defaults to `['body']`.
 */
-const cacheRecordingOpSchema = z.discriminatedUnion("kind", [
-	z.object({
-		kind: z.literal("setOutput"),
-		key: z.string(),
-		value: z.unknown()
-	}),
-	z.object({
-		kind: z.literal("appendOutput"),
-		key: z.string(),
-		value: z.unknown()
-	}),
-	z.object({
-		kind: z.literal("mergeOutput"),
-		key: z.string(),
-		patch: z.record(z.string(), z.unknown())
-	}),
-	z.object({
-		kind: z.literal("incrementOutput"),
-		key: z.string(),
-		delta: z.number()
-	}),
-	z.object({
-		kind: z.literal("checkpoint"),
-		name: z.string(),
-		data: z.unknown()
-	}),
-	z.object({
-		kind: z.literal("subSpan"),
-		span: serializedCacheSpanSchema
-	})
-]);
-/** Captured observable effects + return value of a cached span body. */
-const cacheRecordingSchema = z.object({
-	returnValue: z.unknown(),
-	finalAttributes: z.record(z.string(), z.unknown()),
-	finalStatus: z.enum([
-		"running",
-		"ok",
-		"error",
-		"cancelled"
-	]).optional(),
-	finalError: traceSpanErrorSchema.optional(),
-	finalErrors: z.array(traceSpanErrorSchema).optional(),
-	finalWarning: traceSpanWarningSchema.optional(),
-	finalWarnings: z.array(traceSpanWarningSchema).optional(),
-	ops: z.array(cacheRecordingOpSchema)
-});
-/** Persisted cache file containing metadata and a recording. */
-const cacheEntrySchema = z.object({
-	version: z.literal(1),
-	key: z.string(),
-	namespace: z.string(),
-	operationType: cacheOperationTypeSchema.optional(),
-	operationName: z.string().optional(),
-	spanName: z.string().optional(),
-	spanKind: traceSpanKindSchema.optional(),
-	storedAt: z.string(),
-	codeFingerprint: z.string(),
-	recording: cacheRecordingSchema
-});
-/** Persisted per-owner cache file containing multiple cache entries. */
-const cacheFileSchema = z.object({
-	version: z.literal(1),
-	owner: z.string(),
-	entries: z.record(z.string(), cacheEntrySchema)
-});
-//#endregion
-//#region ../shared/src/schemas/config.ts
-/** Strategy used to collapse repeated trials into one stored case result. */
-const trialSelectionModeSchema = z.enum(["lowestScore", "median"]);
+function resolveLlmCallsConfig(input) {
+	return {
+		kinds: input?.kinds && input.kinds.length > 0 ? [...input.kinds] : [...DEFAULT_LLM_CALLS_CONFIG.kinds],
+		attributes: {
+			...DEFAULT_LLM_CALLS_CONFIG.attributes,
+			...input?.attributes
+		},
+		metrics: (input?.metrics ?? []).map((m) => ({
+			label: m.label,
+			tooltip: m.tooltip,
+			path: m.path,
+			format: m.format ?? "string",
+			numberFormat: m.numberFormat,
+			placements: m.placements ? [...m.placements] : ["body"]
+		}))
+	};
+}
 /** Zod schema for validating `agent-evals.config.ts` input. */
 const agentEvalsConfigSchema = z.object({
 	workspaceRoot: z.string().optional(),
@@ -1767,9 +3751,12 @@ const agentEvalsConfigSchema = z.object({
 	concurrency: z.number().optional(),
 	staleAfterDays: z.number().optional(),
 	traceDisplay: traceDisplayInputConfigSchema.optional(),
+	llmCalls: llmCallsConfigSchema.optional(),
 	cache: z.object({
 		enabled: z.boolean().optional(),
 		dir: z.string().optional(),
+		maxEntriesPerNamespace: z.preprocess((value) => typeof value === "number" && Number.isFinite(value) ? value : void 0, z.number().optional()),
+		maxEntriesByNamespace: z.record(z.string(), z.number()).optional(),
 		maxEntriesPerEval: z.preprocess((value) => typeof value === "number" && Number.isFinite(value) ? value : void 0, z.number().optional())
 	}).optional()
 });
@@ -1966,6 +3953,240 @@ function getEvalTitle(evalLike) {
 	if (evalLike.title !== void 0) return evalLike.title;
 	return humanizeEvalId(evalLike.id);
 }
+//#endregion
+//#region ../shared/src/utils/getNestedAttribute.ts
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* Read a value from `source` by walking a dot-separated path.
+*
+* Returns `undefined` when any segment of the path is missing or when an
+* intermediate value is not a plain object. Used by trace-attribute display,
+* the LLM calls extractor, and any consumer that needs to look up nested
+* properties from a span's `attributes` record.
+*/
+function getNestedAttribute(value, path) {
+	const parts = path.split(".");
+	let current = value;
+	for (const part of parts) {
+		if (!isRecord$3(current) || !(part in current)) return;
+		current = current[part];
+	}
+	return current;
+}
+//#endregion
+//#region ../shared/src/utils/extractLlmCalls.ts
+function readNumber$1(attributes, path) {
+	const raw = getNestedAttribute(attributes, path);
+	return typeof raw === "number" && Number.isFinite(raw) ? raw : null;
+}
+function readString$1(attributes, path) {
+	const raw = getNestedAttribute(attributes, path);
+	return typeof raw === "string" && raw.length > 0 ? raw : null;
+}
+function computeLatencyMs(span) {
+	if (span.endedAt === null) return null;
+	const started = Date.parse(span.startedAt);
+	const ended = Date.parse(span.endedAt);
+	if (!Number.isFinite(started) || !Number.isFinite(ended)) return null;
+	const delta = ended - started;
+	return delta >= 0 ? delta : null;
+}
+function computeTotalTokens({ declared, input, output, cached, cacheCreation }) {
+	if (declared !== null) return declared;
+	if (input === null && output === null && cached === null && cacheCreation === null) return null;
+	return (input ?? 0) + (output ?? 0) + (cached ?? 0) + (cacheCreation ?? 0);
+}
+function readSteps(attributes, path) {
+	const raw = getNestedAttribute(attributes, path);
+	if (Array.isArray(raw)) return {
+		stepCount: raw.length,
+		stepDetails: raw
+	};
+	if (typeof raw === "number" && Number.isFinite(raw)) return {
+		stepCount: raw,
+		stepDetails: null
+	};
+	return {
+		stepCount: null,
+		stepDetails: null
+	};
+}
+function collectWarnings(span) {
+	const out = [];
+	if (span.warning) out.push(span.warning);
+	if (span.warnings) out.push(...span.warnings);
+	return out;
+}
+function pickError(span) {
+	if (span.error) return span.error;
+	if (span.errors && span.errors.length > 0) return span.errors[0] ?? null;
+	return null;
+}
+/**
+* Filter `spans` down to LLM calls and project each one to the structured
+* shape consumed by the LLM calls tab.
+*
+* Spans whose `kind` is not in `config.kinds` are dropped. Structured fields
+* (`model`, token counts, cost, etc.) are read via `getNestedAttribute` from
+* the configured paths, with safe coercion to `string | null` / `number |
+* null`. `totalTokens` falls back to a sum of input + output + cached when no
+* explicit total attribute is present. The `steps` attribute path may resolve
+* to either a number (rendered as the inference-round count) or an array of
+* per-step detail objects (rendered as a Steps section in the body, with
+* `stepCount` derived from the array length). `latencyMs` is `null` while the
+* span is still running. User-defined `metrics` whose path resolves to
+* `undefined` are dropped, but `null`, `0`, and `false` are preserved as
+* legitimate values worth displaying. Original span order is preserved so the
+* LLM calls tab matches the ordering in the Trace tab.
+*/
+function extractLlmCalls(spans, config) {
+	const kindSet = new Set(config.kinds);
+	const result = [];
+	for (const span of spans) {
+		if (!kindSet.has(span.kind)) continue;
+		const attrs = span.attributes;
+		const inputTokens = readNumber$1(attrs, config.attributes.inputTokens);
+		const outputTokens = readNumber$1(attrs, config.attributes.outputTokens);
+		const cachedInputTokens = readNumber$1(attrs, config.attributes.cachedInputTokens);
+		const cacheCreationInputTokens = readNumber$1(attrs, config.attributes.cacheCreationInputTokens);
+		const reasoningTokens = readNumber$1(attrs, config.attributes.reasoningTokens);
+		const declaredTotalTokens = readNumber$1(attrs, config.attributes.totalTokens);
+		const metrics = [];
+		for (const metric of config.metrics) {
+			const rawValue = getNestedAttribute(attrs, metric.path);
+			if (rawValue === void 0) continue;
+			metrics.push({
+				label: metric.label,
+				tooltip: metric.tooltip,
+				rawValue,
+				format: metric.format,
+				numberFormat: metric.numberFormat,
+				placements: metric.placements
+			});
+		}
+		result.push({
+			id: span.id,
+			name: span.name,
+			kind: span.kind,
+			status: span.status,
+			model: readString$1(attrs, config.attributes.model),
+			provider: readString$1(attrs, config.attributes.provider),
+			inputTokens,
+			outputTokens,
+			cachedInputTokens,
+			cacheCreationInputTokens,
+			reasoningTokens,
+			totalTokens: computeTotalTokens({
+				declared: declaredTotalTokens,
+				input: inputTokens,
+				output: outputTokens,
+				cached: cachedInputTokens,
+				cacheCreation: cacheCreationInputTokens
+			}),
+			costUsd: readNumber$1(attrs, config.attributes.cost),
+			inputCostUsd: readNumber$1(attrs, config.attributes.inputCost),
+			outputCostUsd: readNumber$1(attrs, config.attributes.outputCost),
+			cachedInputCostUsd: readNumber$1(attrs, config.attributes.cachedInputCost),
+			cacheCreationInputCostUsd: readNumber$1(attrs, config.attributes.cacheCreationInputCost),
+			reasoningCostUsd: readNumber$1(attrs, config.attributes.reasoningCost),
+			...readSteps(attrs, config.attributes.steps),
+			finishReason: readString$1(attrs, config.attributes.finishReason),
+			latencyMs: computeLatencyMs(span),
+			input: getNestedAttribute(attrs, config.attributes.input),
+			output: getNestedAttribute(attrs, config.attributes.output),
+			reasoning: getNestedAttribute(attrs, config.attributes.reasoning),
+			toolCalls: getNestedAttribute(attrs, config.attributes.toolCalls),
+			metrics,
+			warnings: collectWarnings(span),
+			error: pickError(span)
+		});
+	}
+	return result;
+}
+//#endregion
+//#region ../shared/src/utils/extractCacheHits.ts
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(attributes, key) {
+	if (!isRecord$2(attributes)) return void 0;
+	const value = attributes[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readNumber(attributes, key) {
+	if (!isRecord$2(attributes)) return void 0;
+	const value = attributes[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readArray(attributes, key) {
+	if (!isRecord$2(attributes)) return [];
+	const value = attributes[key];
+	return Array.isArray(value) ? value : [];
+}
+/**
+* Collect every `status === 'hit'` cache event recorded for a case run.
+*
+* Walks `spans` for span-level cache hits (`attributes['cache.status'] ===
+* 'hit'`) and per-span value-cache refs (`attributes['cache.refs']`), then
+* appends spanless value-cache refs persisted on the case scope. Non-hit
+* statuses (`miss`/`refresh`/`bypass`) are skipped — they remain visible
+* inline in the Trace tab.
+*/
+function extractCacheHits(spans, caseCacheRefs) {
+	const entries = [];
+	for (const span of spans) {
+		if (readString(span.attributes, "cache.status") === "hit") {
+			const key = readString(span.attributes, "cache.key");
+			const namespace = readString(span.attributes, "cache.namespace");
+			if (key !== void 0 && namespace !== void 0) entries.push({
+				id: span.id,
+				source: "span",
+				origin: "span",
+				name: span.name,
+				namespace,
+				key,
+				storedAt: readString(span.attributes, "cache.storedAt"),
+				age: readNumber(span.attributes, "cache.age"),
+				spanId: span.id
+			});
+		}
+		const rawRefs = readArray(span.attributes, "cache.refs");
+		for (const [index, rawRef] of rawRefs.entries()) {
+			const parsed = traceCacheRefSchema.safeParse(rawRef);
+			if (!parsed.success) continue;
+			const ref = parsed.data;
+			if (ref.status !== "hit") continue;
+			entries.push({
+				id: `${span.id}:value:${String(index)}`,
+				source: "value",
+				origin: "span",
+				name: ref.name,
+				namespace: ref.namespace,
+				key: ref.key,
+				storedAt: ref.storedAt,
+				age: ref.age,
+				spanId: span.id
+			});
+		}
+	}
+	for (const [index, ref] of caseCacheRefs.entries()) {
+		if (ref.status !== "hit") continue;
+		entries.push({
+			id: `case:value:${String(index)}`,
+			source: "value",
+			origin: "caseRoot",
+			name: ref.name,
+			namespace: ref.namespace,
+			key: ref.key,
+			storedAt: ref.storedAt,
+			age: ref.age,
+			spanId: void 0
+		});
+	}
+	return entries;
+}
 z.enum([
 	"discovery.updated",
 	"run.started",
@@ -2009,17 +4230,17 @@ const createRunRequestSchema = z.object({
 const updateManualScoreRequestSchema = z.object({ value: z.number().min(0).max(1).nullable() });
 //#endregion
 //#region ../runner/src/cacheStore.ts
-const defaultMaxEntriesPerEval = 100;
+const defaultMaxEntriesPerNamespace = 100;
 /**
 * Create a filesystem-backed cache adapter rooted at `<workspaceRoot>/<dir>`.
 *
-* Cache entries are grouped into one inspectable JSON file per eval/cache
-* owner. Writes use a short-lived lock directory plus `<name>.tmp` + atomic
+* Cache entries are grouped into one inspectable JSON file per cache owner.
+* Writes use a short-lived lock directory plus `<name>.tmp` + atomic
 * `rename` to avoid partial reads and lost updates under concurrent access.
 */
 function createFsCacheStore(options) {
 	const cacheDir = resolve(options.workspaceRoot, options.dir ?? ".agent-evals/cache");
-	const maxEntriesPerEval = normalizeMaxEntries(options.maxEntriesPerEval);
+	const defaultMaxEntries = normalizeMaxEntries(options.maxEntriesPerNamespace);
 	return {
 		dir() {
 			return cacheDir;
@@ -2038,7 +4259,7 @@ function createFsCacheStore(options) {
 					entries: pruneEntries({
 						...(await readCacheFile(cacheDir, owner))?.entries ?? {},
 						[entry.key]: entry
-					}, maxEntriesPerEval, entry.key)
+					}, entry.namespace, maxEntriesForNamespace(entry.namespace, defaultMaxEntries, options.maxEntriesByNamespace), entry.key)
 				});
 			});
 		},
@@ -2142,10 +4363,14 @@ function createBufferedCacheStore(backingStore) {
 		}
 	};
 }
-function normalizeMaxEntries(value) {
-	if (value === void 0 || !Number.isFinite(value) || value <= 0) return defaultMaxEntriesPerEval;
+function normalizeMaxEntries(value, fallback = defaultMaxEntriesPerNamespace) {
+	if (value === void 0 || !Number.isFinite(value) || value <= 0) return fallback;
 	return Math.floor(value);
 }
+function maxEntriesForNamespace(namespace, defaultMaxEntries, maxEntriesByNamespace) {
+	const namespaceMaxEntries = maxEntriesByNamespace?.[namespace];
+	return namespaceMaxEntries === void 0 ? defaultMaxEntries : normalizeMaxEntries(namespaceMaxEntries, defaultMaxEntries);
+}
 function ownerFromNamespace(namespace) {
 	const [owner] = namespace.split("__");
 	return owner === void 0 || owner.length === 0 ? namespace : owner;
@@ -2186,16 +4411,16 @@ async function writeCacheFile(cacheDir, cacheFile) {
 	await writeFile(tmpPath, JSON.stringify(cacheFile, null, 2));
 	await rename(tmpPath, filePath);
 }
-function pruneEntries(entries, maxEntries, protectedKey) {
-	const sorted = Object.values(entries).toSorted((a, b) => a.storedAt < b.storedAt ? 1 : -1);
+function pruneEntries(entries, namespace, maxEntries, protectedKey) {
+	const sorted = Object.values(entries).filter((entry) => entry.namespace === namespace).toSorted((a, b) => a.storedAt < b.storedAt ? 1 : -1);
 	const kept = /* @__PURE__ */ new Map();
 	const protectedEntry = entries[protectedKey];
-	if (protectedEntry !== void 0) kept.set(protectedEntry.key, protectedEntry);
+	if (protectedEntry?.namespace === namespace) kept.set(protectedEntry.key, protectedEntry);
 	for (const entry of sorted) {
 		if (kept.size >= maxEntries) break;
 		kept.set(entry.key, entry);
 	}
-	return Object.fromEntries([...kept.values()].toSorted((a, b) => a.key < b.key ? -1 : 1).map((entry) => [entry.key, entry]));
+	return Object.fromEntries(Object.values(entries).filter((entry) => entry.namespace !== namespace || kept.has(entry.key)).toSorted((a, b) => a.key < b.key ? -1 : 1).map((entry) => [entry.key, entry]));
 }
 async function withCacheFileLock(filePath, fn) {
 	const lockPath = `${filePath}.lock`;
@@ -2908,15 +5133,6 @@ async function runWithModuleIsolation(context, fn) {
 function isRecord$1(value) {
 	return typeof value === "object" && value !== null;
 }
-function getNestedAttribute(value, path) {
-	const parts = path.split(".");
-	let current = value;
-	for (const part of parts) {
-		if (!isRecord$1(current) || !(part in current)) return;
-		current = current[part];
-	}
-	return current;
-}
 function mergeNestedAttribute(value, path, attributeValue) {
 	const root = value === void 0 ? {} : { ...value };
 	const parts = path.split(".");
@@ -2987,14 +5203,35 @@ function resolveRunnableEvalCases(params) {
 		input: {}
 	}];
 }
+function toStableIdSegment(value) {
+	const segment = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+	return segment.length > 0 ? segment : "id";
+}
+function buildScopedEvalIdPrefix(params) {
+	const fileIdentity = relative(params.workspaceRoot, params.evalFilePath).replaceAll("\\", "/");
+	return [
+		toStableIdSegment(params.evalId),
+		toStableIdSegment(fileIdentity),
+		toStableIdSegment(params.caseId)
+	].join("-");
+}
 async function callWithUnknownResult(fn, args) {
 	return await Reflect.apply(fn, void 0, args);
 }
 async function runCase(params) {
-	const { evalDef, evalId, evalCase, globalTraceDisplay, trial, startTime, cacheAdapter, cacheMode, codeFingerprint, moduleIsolation, artifactDir, runId } = params;
+	const { evalDef, evalId, evalCase, globalTraceDisplay, trial, startTime, cacheAdapter, cacheMode, codeFingerprint, moduleIsolation, evalFilePath, workspaceRoot, artifactDir, runId } = params;
+	const scopedIdPrefix = buildScopedEvalIdPrefix({
+		evalId,
+		evalFilePath,
+		caseId: evalCase.id,
+		workspaceRoot
+	});
 	const { scope, error: executeError } = await runInEvalScope(evalCase.id, async () => {
 		const execute = async () => {
-			await Reflect.apply(evalDef.execute, evalDef, [{ input: evalCase.input }]);
+			await Reflect.apply(evalDef.execute, evalDef, [{
+				input: evalCase.input,
+				setOutput: setEvalOutput
+			}]);
 		};
 		if (moduleIsolation === void 0) {
 			await execute();
@@ -3003,6 +5240,7 @@ async function runCase(params) {
 		await runWithModuleIsolation(moduleIsolation, execute);
 	}, {
 		input: evalCase.input,
+		idPrefix: scopedIdPrefix,
 		cacheContext: cacheAdapter ? {
 			adapter: cacheAdapter,
 			mode: cacheMode,
@@ -3047,6 +5285,7 @@ async function runCase(params) {
 			return await runWithModuleIsolation(moduleIsolation, computeScore);
 		}, {
 			input: evalCase.input,
+			idPrefix: `${scopedIdPrefix}-score-${toStableIdSegment(key)}`,
 			cacheContext: cacheAdapter ? {
 				adapter: cacheAdapter,
 				mode: cacheMode,
@@ -3126,7 +5365,8 @@ async function runCase(params) {
 		columns,
 		assertionFailures: scope.assertionFailures,
 		error: errorInfo,
-		trial
+		trial,
+		cacheRefs: scope.caseCacheRefs
 	};
 	if (Object.keys(scoringTraces).length > 0) caseDetail.scoringTraces = scoringTraces;
 	return {
@@ -3373,6 +5613,8 @@ async function executeRun({ runState, request, runDir, config, evals, cacheStore
 											cacheMode,
 											codeFingerprint,
 											moduleIsolation,
+											evalFilePath,
+											workspaceRoot,
 											artifactDir: join(runDir, "artifacts"),
 											runId: runState.manifest.id
 										});
@@ -3514,4 +5756,4 @@ function toLastRunStatus(status) {
 	return status === "pending" ? null : status;
 }
 //#endregion
-export { evalChartAxisSchema as $, runManifestSchema as A, evalTracer as At, cacheRecordingSchema as B, mergeEvalOutput as Bt, updateManualScoreRequestSchema as C, numberDisplayOptionsSchema as Ct, deriveScopedSummaryFromCases as D, buildTraceTree as Dt, getEvalDisplayStatus as E, z$1 as Et, cacheFileSchema as F, evalAssert as Ft, caseRowSchema as G, defineEval as Gt, spanCacheOptionsSchema as H, setEvalOutput as Ht, cacheListItemSchema as I, getCurrentScope as It, evalStatItemSchema as J, evalFreshnessStatusSchema as K, getEvalRegistry as Kt, cacheModeSchema as L, getEvalCaseInput as Lt, agentEvalsConfigSchema as M, hashCacheKeySync as Mt, trialSelectionModeSchema as N, EvalAssertionError as Nt, deriveStatusFromCaseRows as O, captureEvalSpanError as Ot, cacheEntrySchema as P, appendToEvalOutput as Pt, evalChartAggregateSchema as Q, cacheOperationTypeSchema as R, incrementEvalOutput as Rt, createRunRequestSchema as S, jsonCellSchema as St, getEvalTitle as T, runArtifactRefSchema as Tt, assertionFailureSchema as U, setScopeCacheContext as Ut, serializedCacheSpanSchema as V, runInEvalScope as Vt, caseDetailSchema as W, repoFile as Wt, evalSummarySchema as X, evalStatsConfigSchema as Y, scoreTraceSchema as Z, loadEvalModule as _, cellValueSchema as _t, loadPersistedRunSnapshot as a, evalChartTypeSchema as at, normalizeScoreDef as b, columnKindSchema as bt, persistCaseDetail as c, traceAttributeDisplayInputSchema as ct, recomputePersistedCaseStatus as d, traceDisplayConfigSchema as dt, evalChartBuiltinMetricSchema as et, runTouchesEval as f, traceDisplayInputConfigSchema as ft, setLatestRunInfoMap as g, traceSpanWarningSchema as gt, getTargetEvalIds as h, traceSpanSchema as ht, getLatestRunInfos as i, evalChartTooltipExtraSchema as it, runSummarySchema as j, hashCacheKey as jt, deriveStatusFromChildStatuses as k, evalSpan as kt, persistRunState as l, traceAttributeDisplayPlacementSchema as lt, buildEvalSummary as m, traceSpanKindSchema as mt, generateRunId as n, evalChartConfigSchema as nt, loadPersistedRunSnapshots as o, evalChartsConfigSchema as ot, resolveArtifactPath as p, traceSpanErrorSchema as pt, evalStatAggregateSchema as q, getLastRunStatuses as r, evalChartMetricSchema as rt, nextShortIdFromSnapshots as s, traceAttributeDisplayFormatSchema as st, executeRun as t, evalChartColorSchema as tt, recomputeEvalStatusesInRuns as u, traceAttributeDisplaySchema as ut, loadConfig as v, columnDefSchema as vt, sseEnvelopeSchema as w, repoFileRefSchema as wt, createFsCacheStore as x, fileRefSchema as xt, buildDeclaredColumnDefs as y, columnFormatSchema as yt, cacheRecordingOpSchema as z, isInEvalScope as zt };
+export { evalChartAxisSchema as $, runInEvalScope as $t, deriveScopedSummaryFromCases as A, columnFormatSchema as At, llmCallsConfigSchema as B, evalSpan as Bt, updateManualScoreRequestSchema as C, traceDisplayInputConfigSchema as Ct, getNestedAttribute as D, traceSpanWarningSchema as Dt, extractLlmCalls as E, traceSpanSchema as Et, DEFAULT_LLM_CALLS_CONFIG as F, repoFileRefSchema as Ft, caseRowSchema as G, appendToEvalOutput as Gt, trialSelectionModeSchema as H, hashCacheKey as Ht, agentEvalsConfigSchema as I, runArtifactRefSchema as It, evalStatItemSchema as J, getEvalCaseInput as Jt, evalFreshnessStatusSchema as K, evalAssert as Kt, llmCallMetricFormatSchema as L, z$1 as Lt, deriveStatusFromChildStatuses as M, fileRefSchema as Mt, runManifestSchema as N, jsonCellSchema as Nt, getEvalTitle as O, cellValueSchema as Ot, runSummarySchema as P, numberDisplayOptionsSchema as Pt, evalChartAggregateSchema as Q, nextEvalId as Qt, llmCallMetricPlacementSchema as R, buildTraceTree as Rt, createRunRequestSchema as S, traceDisplayConfigSchema as St, extractCacheHits as T, traceSpanKindSchema as Tt, assertionFailureSchema as U, hashCacheKeySync as Ut, resolveLlmCallsConfig as V, evalTracer as Vt, caseDetailSchema as W, EvalAssertionError as Wt, evalSummarySchema as X, isInEvalScope as Xt, evalStatsConfigSchema as Y, incrementEvalOutput as Yt, scoreTraceSchema as Z, mergeEvalOutput as Zt, loadEvalModule as _, traceCacheRefSchema as _t, loadPersistedRunSnapshot as a, evalChartTypeSchema as at, normalizeScoreDef as b, traceAttributeDisplayPlacementSchema as bt, persistCaseDetail as c, cacheFileSchema as ct, recomputePersistedCaseStatus as d, cacheOperationTypeSchema as dt, setEvalOutput as en, evalChartBuiltinMetricSchema as et, runTouchesEval as f, cacheRecordingOpSchema as ft, setLatestRunInfoMap as g, spanCacheOptionsSchema as gt, getTargetEvalIds as h, serializedCacheSpanSchema as ht, getLatestRunInfos as i, getEvalRegistry as in, evalChartTooltipExtraSchema as it, deriveStatusFromCaseRows as j, columnKindSchema as jt, getEvalDisplayStatus as k, columnDefSchema as kt, persistRunState as l, cacheListItemSchema as lt, buildEvalSummary as m, cacheStatusSchema as mt, generateRunId as n, repoFile as nn, evalChartConfigSchema as nt, loadPersistedRunSnapshots as o, evalChartsConfigSchema as ot, resolveArtifactPath as p, cacheRecordingSchema as pt, evalStatAggregateSchema as q, getCurrentScope as qt, getLastRunStatuses as r, defineEval as rn, evalChartMetricSchema as rt, nextShortIdFromSnapshots as s, cacheEntrySchema as st, executeRun as t, setScopeCacheContext as tn, evalChartColorSchema as tt, recomputeEvalStatusesInRuns as u, cacheModeSchema as ut, loadConfig as v, traceAttributeDisplayFormatSchema as vt, sseEnvelopeSchema as w, traceSpanErrorSchema as wt, createFsCacheStore as x, traceAttributeDisplaySchema as xt, buildDeclaredColumnDefs as y, traceAttributeDisplayInputSchema as yt, llmCallMetricSchema as z, captureEvalSpanError as zt };