@meridianlabs/log-viewer 0.3.247 → 0.3.248

package/lib/index.js

@@ -3,7 +3,6 @@ import React3, { Children, Component, Fragment, Suspense, createContext, createE
 import * as ReactDOM from "react-dom";
 import xo, { createPortal, flushSync } from "react-dom";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
-import markdownitMathjax3 from "markdown-it-mathjax3";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -23274,6 +23273,7 @@ var ExtendedFindContext = createContext(null);
 var ExtendedFindProvider = ({ children }) => {
 	const virtualLists = useRef(/* @__PURE__ */ new Map());
 	const matchCounters = useRef(/* @__PURE__ */ new Map());
+	const matchCountersVersion = useRef(0);
 	const contextValue = {
 		extendedFindTerm: useCallback(async (term, direction) => {
 			for (const [, searchFn] of virtualLists.current) if (await new Promise((resolve) => {
@@ -23311,10 +23311,13 @@ var ExtendedFindProvider = ({ children }) => {
 		}, []),
 		registerMatchCounter: useCallback((id, countFn) => {
 			matchCounters.current.set(id, countFn);
+			matchCountersVersion.current++;
 			return () => {
 				matchCounters.current.delete(id);
+				matchCountersVersion.current++;
 			};
-		}, [])
+		}, []),
+		getMatchCountersVersion: useCallback(() => matchCountersVersion.current, [])
 	};
 	return /* @__PURE__ */ jsx(ExtendedFindContext.Provider, {
 		value: contextValue,
@@ -23465,7 +23468,7 @@ function isRegExp$1(value) {
 }
 //#endregion
 //#region ../../node_modules/.pnpm/arquero@8.0.3/node_modules/arquero/src/util/is-object.js
-function isObject$1(value) {
+function isObject$2(value) {
 	return value === Object(value);
 }
 //#endregion
@@ -23479,7 +23482,7 @@ function isObject$1(value) {
 * @return {boolean} True if equal, false if not.
 */
 function equal(a, b) {
-	return a == null || b == null || a !== a || b !== b ? false : a === b ? true : isDate(a) || isDate(b) ? +a === +b : isRegExp$1(a) && isRegExp$1(b) ? a + "" === b + "" : isObject$1(a) && isObject$1(b) ? deepEqual(a, b) : false;
+	return a == null || b == null || a !== a || b !== b ? false : a === b ? true : isDate(a) || isDate(b) ? +a === +b : isRegExp$1(a) && isRegExp$1(b) ? a + "" === b + "" : isObject$2(a) && isObject$2(b) ? deepEqual(a, b) : false;
 }
 function deepEqual(a, b) {
 	if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) return false;
@@ -23774,7 +23777,7 @@ var date_exports = /* @__PURE__ */ __exportAll({
 	milliseconds: () => milliseconds,
 	minutes: () => minutes,
 	month: () => month,
-	now: () => now,
+	now: () => now$1,
 	quarter: () => quarter,
 	seconds: () => seconds,
 	timestamp: () => timestamp$2,
@@ -23833,7 +23836,7 @@ function format_utcdate(date, shorten) {
 * 1970 Universal Coordinated Time (UTC).
 * @return {number} The timestamp for now.
 */
-function now() {
+function now$1() {
 	return Date.now();
 }
 /**
@@ -24165,7 +24168,7 @@ var math_exports = /* @__PURE__ */ __exportAll({
 	is_finite: () => is_finite,
 	is_nan: () => is_nan,
 	least: () => least,
-	log: () => log$7,
+	log: () => log$8,
 	log10: () => log10,
 	log1p: () => log1p,
 	log2: () => log2,
@@ -24305,7 +24308,7 @@ function least(...values) {
 * @param {number} value The input number value.
 * @return {number} The base-e log value.
 */
-function log$7(value) {
+function log$8(value) {
 	return Math.log(value);
 }
 /**
@@ -24944,16 +24947,16 @@ function bins(min, max, maxbins = 15, nice = true, minstep = 0, step) {
 }
 //#endregion
 //#region ../../node_modules/.pnpm/arquero@8.0.3/node_modules/arquero/src/util/key-function.js
-function key$5(value) {
+function key$6(value) {
 	const type = typeof value;
-	return type === "string" ? `"${value}"` : type !== "object" || !value ? value : isDate(value) ? +value : isArray$2(value) || isTypedArray(value) ? `[${value.map(key$5)}]` : isRegExp$1(value) ? value + "" : objectKey(value);
+	return type === "string" ? `"${value}"` : type !== "object" || !value ? value : isDate(value) ? +value : isArray$2(value) || isTypedArray(value) ? `[${value.map(key$6)}]` : isRegExp$1(value) ? value + "" : objectKey(value);
 }
 function objectKey(value) {
 	let s = "{";
 	let i = -1;
 	for (const k in value) {
 		if (++i > 0) s += ",";
-		s += `"${k}":${key$5(value[k])}`;
+		s += `"${k}":${key$6(value[k])}`;
 	}
 	s += "}";
 	return s;
@@ -24970,7 +24973,7 @@ function distinctMap() {
 			return Array.from(map.values(), (_) => _.v);
 		},
 		increment(v) {
-			const k = key$5(v);
+			const k = key$6(v);
 			const e = map.get(k);
 			e ? ++e.n : map.set(k, {
 				v,
@@ -24978,7 +24981,7 @@ function distinctMap() {
 			});
 		},
 		decrement(v) {
-			const k = key$5(v);
+			const k = key$6(v);
 			const e = map.get(k);
 			e.n === 1 ? map.delete(k) : --e.n;
 		},
@@ -26937,10 +26940,10 @@ function nextLineBreak(code, from, end) {
 var nonASCIIwhitespace = /[\u1680\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
 var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
 var ref = Object.prototype;
-var hasOwnProperty$1 = ref.hasOwnProperty;
+var hasOwnProperty$2 = ref.hasOwnProperty;
 var toString$1 = ref.toString;
 var hasOwn = Object.hasOwn || (function(obj, propName) {
-	return hasOwnProperty$1.call(obj, propName);
+	return hasOwnProperty$2.call(obj, propName);
 });
 var isArray$1 = Array.isArray || (function(obj) {
 	return toString$1.call(obj) === "[object Array]";
@@ -31545,6 +31548,16 @@ var clearDocumentSelection = () => {
 	}
 };
 /**
+* The focused element, pierced through shadow roots. document.activeElement
+* only returns the shadow host, so walk down to the real focused element
+* (e.g. the textarea inside a <vscode-textarea>).
+*/
+function deepActiveElement() {
+	let active = document.activeElement;
+	while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement;
+	return active;
+}
+/**
 * True if the element accepts text input (input/textarea/select/contentEditable).
 * Use to skip global keyboard handlers when focus is in a form field.
 */
@@ -33475,7 +33488,7 @@ function throttle(func, wait, options = {}) {
 * Creates a debounced version of a function that delays invoking the function
 * until after `wait` milliseconds have passed since the last time it was invoked.
 */
-function debounce$2(func, wait, options = {}) {
+function debounce$3(func, wait, options = {}) {
 	let timeout = null;
 	let args;
 	let result;
@@ -37824,7 +37837,7 @@ function _class(obj) {
 function isString(obj) {
 	return _class(obj) === "[object String]";
 }
-function isObject(obj) {
+function isObject$1(obj) {
 	return _class(obj) === "[object Object]";
 }
 function isRegExp(obj) {
@@ -37916,7 +37929,7 @@ function compile(self) {
 			link: null
 		};
 		self.__compiled__[name] = compiled;
-		if (isObject(val)) {
+		if (isObject$1(val)) {
 			if (isRegExp(val.validate)) compiled.validate = createValidator(val.validate);
 			else if (isFunction$2(val.validate)) compiled.validate = val.validate;
 			else schemaError(name, val);
@@ -39123,6 +39136,18 @@ MarkdownIt.prototype.renderInline = function(src, env) {
 * Pure functions for the markdown rendering pipeline.
 * Extracted for testability (no CSS/React imports).
 */
+var mathjaxPluginPromise = null;
+var getMathjaxPlugin = () => {
+	if (!mathjaxPluginPromise) {
+		const loading = import("markdown-it-mathjax3").then((m) => m.default);
+		loading.catch(() => {
+			if (mathjaxPluginPromise === loading) mathjaxPluginPromise = null;
+		});
+		mathjaxPluginPromise = loading;
+	}
+	return mathjaxPluginPromise;
+};
+var hasMathContent = (text) => text.includes("$") || text.includes("\\(") || text.includes("\\[");
 var mdInstanceCache = {};
 var defaultMarkdownRenderer = "full";
 /** Unescape HTML entities within math token content before MathJax processing.
@@ -39130,15 +39155,17 @@ var defaultMarkdownRenderer = "full";
 var unescapeHtmlForMath = (content) => {
 	return content.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&apos;/g, "'").replace(/&quot;/g, "\"");
 };
-var getMarkdownInstance = (renderer) => {
-	const cached = mdInstanceCache[renderer];
+var getMarkdownInstance = async (renderer, contentHasMath) => {
+	const useMath = (renderer === "full" || renderer === "fragment") && !!contentHasMath;
+	const cacheKey = `${renderer}:${useMath ? "1" : "0"}`;
+	const cached = mdInstanceCache[cacheKey];
 	if (cached) return cached;
 	if (renderer === "textOnly") {
 		const md = new MarkdownIt("zero", {
 			breaks: true,
 			html: false
 		}).enable(["emphasis", "newline"]);
-		mdInstanceCache[renderer] = md;
+		mdInstanceCache[cacheKey] = md;
 		return md;
 	}
 	const md = new MarkdownIt({
@@ -39158,8 +39185,9 @@ var getMarkdownInstance = (renderer) => {
 		if (!href) return escapedLabel;
 		return `<a href="${md.utils.escapeHtml(href)}" target="_blank" rel="noopener noreferrer">${escapedLabel}</a>`;
 	};
-	if (renderer === "full" || renderer === "fragment") {
-		md.use(markdownitMathjax3);
+	if (useMath) {
+		const mathjaxPlugin = await getMathjaxPlugin();
+		md.use(mathjaxPlugin);
 		const origInline = md.renderer.rules.math_inline;
 		const origBlock = md.renderer.rules.math_block;
 		if (origInline) md.renderer.rules.math_inline = (tokens, idx, options, env, self) => {
@@ -39173,7 +39201,7 @@ var getMarkdownInstance = (renderer) => {
 			return origBlock(tokens, idx, options, env, self);
 		};
 	}
-	mdInstanceCache[renderer] = md;
+	mdInstanceCache[cacheKey] = md;
 	return md;
 };
 var escapeHtmlCharacters$1 = (content) => {
@@ -39262,20 +39290,20 @@ function unescapeCodeHtmlEntities(str) {
 		return starttag + content.replace(/&(?:amp|lt|gt|quot|#39|#x2F|#x5C|#96);/g, (entity) => htmlEntities[entity] || entity) + endtag;
 	});
 }
-var renderFullPipelineMarkdown = (markdown, renderer) => {
+var renderFullPipelineMarkdown = async (markdown, renderer) => {
 	const preparedForMarkdown = restoreBackslashesForLatex(protectMarkdown(preRenderText(escapeHtmlCharacters$1(protectBackslashesInLatex(markdown)))));
 	let html = preparedForMarkdown;
 	try {
-		html = getMarkdownInstance(renderer).render(preparedForMarkdown);
+		html = (await getMarkdownInstance(renderer, hasMathContent(markdown))).render(preparedForMarkdown);
 	} catch (ex) {
 		console.log("Unable to markdown render content");
 		console.error(ex);
 	}
 	return unescapeSupHtmlEntities(unescapeCodeHtmlEntities(unprotectMarkdown(html)));
 };
-var renderTextOnlyMarkdown = (markdown) => {
+var renderTextOnlyMarkdown = async (markdown) => {
 	try {
-		return getMarkdownInstance("textOnly").render(markdown);
+		return (await getMarkdownInstance("textOnly")).render(markdown);
 	} catch (ex) {
 		console.log("Unable to markdown render content");
 		console.error(ex);
@@ -39365,7 +39393,7 @@ var booleanToString = unapply(Boolean.prototype.toString);
 var bigintToString = typeof BigInt === "undefined" ? null : unapply(BigInt.prototype.toString);
 var symbolToString = typeof Symbol === "undefined" ? null : unapply(Symbol.prototype.toString);
 var objectHasOwnProperty = unapply(Object.prototype.hasOwnProperty);
-var objectToString = unapply(Object.prototype.toString);
+var objectToString$1 = unapply(Object.prototype.toString);
 var regExpTest = unapply(RegExp.prototype.test);
 var typeErrorCreate = unconstruct(TypeError);
 /**
@@ -39460,19 +39488,19 @@ function stringifyValue(value) {
 		case "boolean": return booleanToString(value);
 		case "bigint": return bigintToString ? bigintToString(value) : "0";
 		case "symbol": return symbolToString ? symbolToString(value) : "Symbol()";
-		case "undefined": return objectToString(value);
+		case "undefined": return objectToString$1(value);
 		case "function":
 		case "object": {
-			if (value === null) return objectToString(value);
+			if (value === null) return objectToString$1(value);
 			const valueAsRecord = value;
 			const valueToString = lookupGetter(valueAsRecord, "toString");
 			if (typeof valueToString === "function") {
 				const stringified = valueToString(valueAsRecord);
-				return typeof stringified === "string" ? stringified : objectToString(stringified);
+				return typeof stringified === "string" ? stringified : objectToString$1(stringified);
 			}
-			return objectToString(value);
+			return objectToString$1(value);
 		}
-		default: return objectToString(value);
+		default: return objectToString$1(value);
 	}
 }
 /**
@@ -41609,8 +41637,8 @@ var MarkdownDivComponent = forwardRef(({ markdown, renderer, style, className, p
 	useEffect(() => {
 		if (cachedHtml) {
 			const finalHtml = applyPostProcess(cachedHtml);
-			if (renderedHtml !== finalHtml) startTransition(() => {
-				setRenderedHtml(finalHtml);
+			startTransition(() => {
+				setRenderedHtml((prev) => prev === finalHtml ? prev : finalHtml);
 			});
 			return;
 		}
@@ -41623,9 +41651,8 @@ var MarkdownDivComponent = forwardRef(({ markdown, renderer, style, className, p
 			}
 			const sanitizedResult = sanitizeRenderedHtml(result);
 			renderCache.set(cacheKey, sanitizedResult);
-			const finalHtml = applyPostProcess(sanitizedResult);
 			startTransition(() => {
-				setRenderedHtml(finalHtml);
+				setRenderedHtml(applyPostProcess(sanitizedResult));
 			});
 		}).catch((error) => {
 			console.error("Markdown rendering error:", error);
@@ -41637,7 +41664,6 @@ var MarkdownDivComponent = forwardRef(({ markdown, renderer, style, className, p
 		markdown,
 		rendererName,
 		cachedHtml,
-		renderedHtml,
 		cacheKey,
 		applyPostProcess
 	]);
@@ -41662,6 +41688,7 @@ var MarkdownRenderQueue = class {
 	}
 	enqueue(task) {
 		let cancelled = false;
+		let queueTask;
 		const promise = new Promise((resolve, reject) => {
 			const wrappedTask = async () => {
 				if (cancelled) return;
@@ -41672,7 +41699,7 @@ var MarkdownRenderQueue = class {
 					if (!cancelled) reject(error instanceof Error ? error : new Error(String(error)));
 				}
 			};
-			const queueTask = {
+			queueTask = {
 				task: wrappedTask,
 				cancelled: false
 			};
@@ -41681,8 +41708,7 @@ var MarkdownRenderQueue = class {
 		});
 		const cancel = () => {
 			cancelled = true;
-			const index = this.queue.findIndex((t) => !t.cancelled);
-			if (index !== -1 && this.queue[index]) this.queue[index].cancelled = true;
+			if (queueTask) queueTask.cancelled = true;
 		};
 		return {
 			promise,
@@ -42891,7 +42917,7 @@ function orderModifiers(modifiers) {
 }
 //#endregion
 //#region ../../node_modules/.pnpm/@popperjs+core@2.11.8/node_modules/@popperjs/core/lib/utils/debounce.js
-function debounce$1(fn) {
+function debounce$2(fn) {
 	var pending;
 	return function() {
 		if (!pending) pending = new Promise(function(resolve) {
@@ -42995,7 +43021,7 @@ function popperGenerator(generatorOptions) {
 					}) || state;
 				}
 			},
-			update: debounce$1(function() {
+			update: debounce$2(function() {
 				return new Promise(function(resolve) {
 					instance.forceUpdate();
 					resolve(state);
@@ -43961,6 +43987,433 @@ function useMapAsyncData(input, transform, errorTransform) {
 	]);
 }
 //#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_freeGlobal.js
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_root.js
+/** Detect free variable `self`. */
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+/** Used as a reference to the global object. */
+var root$5 = freeGlobal || freeSelf || Function("return this")();
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_Symbol.js
+/** Built-in value references. */
+var Symbol$1 = root$5.Symbol;
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_getRawTag.js
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+/** Used to check objects for own properties. */
+var hasOwnProperty$1 = objectProto.hasOwnProperty;
+/**
+* Used to resolve the
+* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+* of values.
+*/
+var nativeObjectToString$1 = objectProto.toString;
+/** Built-in value references. */
+var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : void 0;
+/**
+* A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+*
+* @private
+* @param {*} value The value to query.
+* @returns {string} Returns the raw `toStringTag`.
+*/
+function getRawTag(value) {
+	var isOwn = hasOwnProperty$1.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+	try {
+		value[symToStringTag$1] = void 0;
+		var unmasked = true;
+	} catch (e) {}
+	var result = nativeObjectToString$1.call(value);
+	if (unmasked) if (isOwn) value[symToStringTag$1] = tag;
+	else delete value[symToStringTag$1];
+	return result;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_objectToString.js
+/**
+* Used to resolve the
+* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+* of values.
+*/
+var nativeObjectToString = Object.prototype.toString;
+/**
+* Converts `value` to a string using `Object.prototype.toString`.
+*
+* @private
+* @param {*} value The value to convert.
+* @returns {string} Returns the converted string.
+*/
+function objectToString(value) {
+	return nativeObjectToString.call(value);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseGetTag.js
+/** `Object#toString` result references. */
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+/** Built-in value references. */
+var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : void 0;
+/**
+* The base implementation of `getTag` without fallbacks for buggy environments.
+*
+* @private
+* @param {*} value The value to query.
+* @returns {string} Returns the `toStringTag`.
+*/
+function baseGetTag(value) {
+	if (value == null) return value === void 0 ? undefinedTag : nullTag;
+	return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isObjectLike.js
+/**
+* Checks if `value` is object-like. A value is object-like if it's not `null`
+* and has a `typeof` result of "object".
+*
+* @static
+* @memberOf _
+* @since 4.0.0
+* @category Lang
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+* @example
+*
+* _.isObjectLike({});
+* // => true
+*
+* _.isObjectLike([1, 2, 3]);
+* // => true
+*
+* _.isObjectLike(_.noop);
+* // => false
+*
+* _.isObjectLike(null);
+* // => false
+*/
+function isObjectLike(value) {
+	return value != null && typeof value == "object";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isSymbol.js
+/** `Object#toString` result references. */
+var symbolTag = "[object Symbol]";
+/**
+* Checks if `value` is classified as a `Symbol` primitive or object.
+*
+* @static
+* @memberOf _
+* @since 4.0.0
+* @category Lang
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+* @example
+*
+* _.isSymbol(Symbol.iterator);
+* // => true
+*
+* _.isSymbol('abc');
+* // => false
+*/
+function isSymbol(value) {
+	return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_trimmedEndIndex.js
+/** Used to match a single whitespace character. */
+var reWhitespace = /\s/;
+/**
+* Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
+* character of `string`.
+*
+* @private
+* @param {string} string The string to inspect.
+* @returns {number} Returns the index of the last non-whitespace character.
+*/
+function trimmedEndIndex(string) {
+	var index = string.length;
+	while (index-- && reWhitespace.test(string.charAt(index)));
+	return index;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseTrim.js
+/** Used to match leading whitespace. */
+var reTrimStart = /^\s+/;
+/**
+* The base implementation of `_.trim`.
+*
+* @private
+* @param {string} string The string to trim.
+* @returns {string} Returns the trimmed string.
+*/
+function baseTrim(string) {
+	return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isObject.js
+/**
+* Checks if `value` is the
+* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+*
+* @static
+* @memberOf _
+* @since 0.1.0
+* @category Lang
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is an object, else `false`.
+* @example
+*
+* _.isObject({});
+* // => true
+*
+* _.isObject([1, 2, 3]);
+* // => true
+*
+* _.isObject(_.noop);
+* // => true
+*
+* _.isObject(null);
+* // => false
+*/
+function isObject(value) {
+	var type = typeof value;
+	return value != null && (type == "object" || type == "function");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/toNumber.js
+/** Used as references for various `Number` constants. */
+var NAN = NaN;
+/** Used to detect bad signed hexadecimal string values. */
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+/** Used to detect binary string values. */
+var reIsBinary = /^0b[01]+$/i;
+/** Used to detect octal string values. */
+var reIsOctal = /^0o[0-7]+$/i;
+/** Built-in method references without a dependency on `root`. */
+var freeParseInt = parseInt;
+/**
+* Converts `value` to a number.
+*
+* @static
+* @memberOf _
+* @since 4.0.0
+* @category Lang
+* @param {*} value The value to process.
+* @returns {number} Returns the number.
+* @example
+*
+* _.toNumber(3.2);
+* // => 3.2
+*
+* _.toNumber(Number.MIN_VALUE);
+* // => 5e-324
+*
+* _.toNumber(Infinity);
+* // => Infinity
+*
+* _.toNumber('3.2');
+* // => 3.2
+*/
+function toNumber(value) {
+	if (typeof value == "number") return value;
+	if (isSymbol(value)) return NAN;
+	if (isObject(value)) {
+		var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+		value = isObject(other) ? other + "" : other;
+	}
+	if (typeof value != "string") return value === 0 ? value : +value;
+	value = baseTrim(value);
+	var isBinary = reIsBinary.test(value);
+	return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/now.js
+/**
+* Gets the timestamp of the number of milliseconds that have elapsed since
+* the Unix epoch (1 January 1970 00:00:00 UTC).
+*
+* @static
+* @memberOf _
+* @since 2.4.0
+* @category Date
+* @returns {number} Returns the timestamp.
+* @example
+*
+* _.defer(function(stamp) {
+*   console.log(_.now() - stamp);
+* }, _.now());
+* // => Logs the number of milliseconds it took for the deferred invocation.
+*/
+var now = function() {
+	return root$5.Date.now();
+};
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/debounce.js
+/** Error message constants. */
+var FUNC_ERROR_TEXT = "Expected a function";
+var nativeMax = Math.max, nativeMin = Math.min;
+/**
+* Creates a debounced function that delays invoking `func` until after `wait`
+* milliseconds have elapsed since the last time the debounced function was
+* invoked. The debounced function comes with a `cancel` method to cancel
+* delayed `func` invocations and a `flush` method to immediately invoke them.
+* Provide `options` to indicate whether `func` should be invoked on the
+* leading and/or trailing edge of the `wait` timeout. The `func` is invoked
+* with the last arguments provided to the debounced function. Subsequent
+* calls to the debounced function return the result of the last `func`
+* invocation.
+*
+* **Note:** If `leading` and `trailing` options are `true`, `func` is
+* invoked on the trailing edge of the timeout only if the debounced function
+* is invoked more than once during the `wait` timeout.
+*
+* If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+* until to the next tick, similar to `setTimeout` with a timeout of `0`.
+*
+* See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+* for details over the differences between `_.debounce` and `_.throttle`.
+*
+* @static
+* @memberOf _
+* @since 0.1.0
+* @category Function
+* @param {Function} func The function to debounce.
+* @param {number} [wait=0] The number of milliseconds to delay.
+* @param {Object} [options={}] The options object.
+* @param {boolean} [options.leading=false]
+*  Specify invoking on the leading edge of the timeout.
+* @param {number} [options.maxWait]
+*  The maximum time `func` is allowed to be delayed before it's invoked.
+* @param {boolean} [options.trailing=true]
+*  Specify invoking on the trailing edge of the timeout.
+* @returns {Function} Returns the new debounced function.
+* @example
+*
+* // Avoid costly calculations while the window size is in flux.
+* jQuery(window).on('resize', _.debounce(calculateLayout, 150));
+*
+* // Invoke `sendMail` when clicked, debouncing subsequent calls.
+* jQuery(element).on('click', _.debounce(sendMail, 300, {
+*   'leading': true,
+*   'trailing': false
+* }));
+*
+* // Ensure `batchLog` is invoked once after 1 second of debounced calls.
+* var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
+* var source = new EventSource('/stream');
+* jQuery(source).on('message', debounced);
+*
+* // Cancel the trailing debounced invocation.
+* jQuery(window).on('popstate', debounced.cancel);
+*/
+function debounce$1(func, wait, options) {
+	var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+	if (typeof func != "function") throw new TypeError(FUNC_ERROR_TEXT);
+	wait = toNumber(wait) || 0;
+	if (isObject(options)) {
+		leading = !!options.leading;
+		maxing = "maxWait" in options;
+		maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+		trailing = "trailing" in options ? !!options.trailing : trailing;
+	}
+	function invokeFunc(time) {
+		var args = lastArgs, thisArg = lastThis;
+		lastArgs = lastThis = void 0;
+		lastInvokeTime = time;
+		result = func.apply(thisArg, args);
+		return result;
+	}
+	function leadingEdge(time) {
+		lastInvokeTime = time;
+		timerId = setTimeout(timerExpired, wait);
+		return leading ? invokeFunc(time) : result;
+	}
+	function remainingWait(time) {
+		var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
+		return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+	}
+	function shouldInvoke(time) {
+		var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+		return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+	}
+	function timerExpired() {
+		var time = now();
+		if (shouldInvoke(time)) return trailingEdge(time);
+		timerId = setTimeout(timerExpired, remainingWait(time));
+	}
+	function trailingEdge(time) {
+		timerId = void 0;
+		if (trailing && lastArgs) return invokeFunc(time);
+		lastArgs = lastThis = void 0;
+		return result;
+	}
+	function cancel() {
+		if (timerId !== void 0) clearTimeout(timerId);
+		lastInvokeTime = 0;
+		lastArgs = lastCallTime = lastThis = timerId = void 0;
+	}
+	function flush() {
+		return timerId === void 0 ? result : trailingEdge(now());
+	}
+	function debounced() {
+		var time = now(), isInvoking = shouldInvoke(time);
+		lastArgs = arguments;
+		lastThis = this;
+		lastCallTime = time;
+		if (isInvoking) {
+			if (timerId === void 0) return leadingEdge(lastCallTime);
+			if (maxing) {
+				clearTimeout(timerId);
+				timerId = setTimeout(timerExpired, wait);
+				return invokeFunc(lastCallTime);
+			}
+		}
+		if (timerId === void 0) timerId = setTimeout(timerExpired, wait);
+		return result;
+	}
+	debounced.cancel = cancel;
+	debounced.flush = flush;
+	return debounced;
+}
+//#endregion
+//#region ../../packages/react/src/hooks/useDebouncedCallback.ts
+/**
+* Creates a debounced version of a callback that always calls the latest version.
+*
+* Unlike `useMemo(() => debounce(fn), [])`, this hook ensures the debounced function
+* always invokes the most recent callback, eliminating the need for refs to access
+* current state values.
+*
+* @param callback - The function to debounce. Can close over current state/props.
+* @param delay - Debounce delay in milliseconds
+* @returns A stable debounced function that calls the latest callback
+*
+* @example
+* const debouncedSave = useDebouncedCallback(() => {
+*   // Access current state directly - no refs needed
+*   if (!workingCase) return;
+*   mutation.mutate({ data: workingCase });
+* }, 600);
+*/
+function useDebouncedCallback(callback, delay) {
+	const callbackRef = useRef(callback);
+	useLayoutEffect(() => {
+		callbackRef.current = callback;
+	});
+	const debouncedFn = useMemo(() => debounce$1((...args) => {
+		callbackRef.current(...args);
+	}, delay), [delay]);
+	useEffect(() => {
+		return () => {
+			debouncedFn.cancel();
+		};
+	}, [debouncedFn]);
+	return debouncedFn;
+}
+//#endregion
 //#region ../../packages/react/src/hooks/useAsyncDataFromQuery.ts
 /**
 * Custom hook that retrieves data using `useQuery` from the `@tanstack/react-query`
@@ -44288,7 +44741,7 @@ var useCollapsibleIds = (key) => {
 };
 //#endregion
 //#region ../../packages/react/src/hooks/useStatefulScrollPosition.ts
-var log$6 = createLogger("scrolling");
+var log$7 = createLogger("scrolling");
 function useStatefulScrollPosition(elementRef, elementKey, delay = 1e3, scrollable = true) {
 	const [scrollPosition, setScrollPosition] = useProperty("scrollPosition", elementKey);
 	const scrollPositionRef = useRef(scrollPosition);
@@ -44297,10 +44750,10 @@ function useStatefulScrollPosition(elementRef, elementKey, delay = 1e3, scrollab
 	}, [scrollPosition]);
 	const handleScrollInner = useCallback((e) => {
 		const position = e.target.scrollTop;
-		log$6.debug(`Storing scroll position`, elementKey, position);
+		log$7.debug(`Storing scroll position`, elementKey, position);
 		setScrollPosition(position);
 	}, [elementKey, setScrollPosition]);
-	const handleScroll = useMemo(() => debounce$2(handleScrollInner, delay), [handleScrollInner, delay]);
+	const handleScroll = useMemo(() => debounce$3(handleScrollInner, delay), [handleScrollInner, delay]);
 	const restoreScrollPosition = useCallback(() => {
 		const element = elementRef.current;
 		const savedPosition = scrollPositionRef.current;
@@ -44314,15 +44767,15 @@ function useStatefulScrollPosition(elementRef, elementKey, delay = 1e3, scrollab
 	useEffect(() => {
 		const element = elementRef.current;
 		if (!element || !scrollable) return;
-		log$6.debug(`Restore Scroll Hook`, elementKey);
+		log$7.debug(`Restore Scroll Hook`, elementKey);
 		const savedPosition = scrollPositionRef.current;
 		if (savedPosition !== void 0) {
-			log$6.debug(`Restoring scroll position`, savedPosition);
+			log$7.debug(`Restoring scroll position`, savedPosition);
 			const tryRestoreScroll = () => {
 				if (element.scrollHeight > element.clientHeight) {
 					if (element.scrollTop !== savedPosition) {
 						element.scrollTop = savedPosition;
-						log$6.debug(`Scroll position restored to ${savedPosition}`);
+						log$7.debug(`Scroll position restored to ${savedPosition}`);
 					}
 					return true;
 				}
@@ -44333,7 +44786,7 @@ function useStatefulScrollPosition(elementRef, elementKey, delay = 1e3, scrollab
 				const maxAttempts = 20;
 				const pollForRender = () => {
 					if (tryRestoreScroll() || attempts >= maxAttempts) {
-						if (attempts >= maxAttempts) log$6.debug(`Failed to restore scroll after ${maxAttempts} attempts`);
+						if (attempts >= maxAttempts) log$7.debug(`Failed to restore scroll after ${maxAttempts} attempts`);
 						return;
 					}
 					attempts++;
@@ -44343,10 +44796,10 @@ function useStatefulScrollPosition(elementRef, elementKey, delay = 1e3, scrollab
 			}
 		}
 		if (element.addEventListener) element.addEventListener("scroll", handleScroll);
-		else log$6.warn("Element has no way to add event listener", element);
+		else log$7.warn("Element has no way to add event listener", element);
 		return () => {
 			if (element.removeEventListener) element.removeEventListener("scroll", handleScroll);
-			else log$6.warn("Element has no way to remove event listener", element);
+			else log$7.warn("Element has no way to remove event listener", element);
 		};
 	}, [
 		elementKey,
@@ -44543,7 +44996,7 @@ function useListKeyboardNavigation({ listHandle, scrollRef, itemCount }) {
 			const isUp = event.key === "ArrowUp" && hasModifier || event.key === "Home" && hasModifier;
 			const isDown = event.key === "ArrowDown" && hasModifier || event.key === "End" && hasModifier;
 			if (!isUp && !isDown) return;
-			if (isEditableTarget(document.activeElement)) return;
+			if (isEditableTarget(deepActiveElement())) return;
 			event.preventDefault();
 			event.stopImmediatePropagation();
 			const handle = listHandle.current;
@@ -44878,6 +45331,56 @@ var ToolDropdownButton = forwardRef(({ label, icon, className, items, dropdownAl
 	})] }), document.body)] });
 });
 ToolDropdownButton.displayName = "ToolDropdownButton";
+var NavPills_module_default = {
+	visible: "_visible_tm52u_1",
+	hidden: "_hidden_tm52u_5",
+	pills: "_pills_tm52u_9",
+	pill: "_pill_tm52u_9"
+};
+//#endregion
+//#region ../../packages/react/src/components/NavPills.tsx
+var NavPills = ({ id, children }) => {
+	const [activeItem, setActiveItem] = useProperty(id, "active", { defaultValue: children ? children?.[0]?.props["title"] : "" });
+	if (!activeItem || !children) return;
+	const navPills = children.map((nav, idx) => {
+		return /* @__PURE__ */ jsx(NavPill, {
+			title: typeof nav === "object" ? nav["props"]?.title || `Tab ${idx}` : `Tab ${idx}`,
+			activeItem,
+			setActiveItem
+		}, `nav-pill-contents-${idx}`);
+	});
+	const navBodies = children.map((child, idx) => {
+		return /* @__PURE__ */ jsx("div", {
+			className: child["props"]?.title === activeItem ? NavPills_module_default.visible : NavPills_module_default.hidden,
+			children: child
+		}, `nav-pill-container-${idx}`);
+	});
+	return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("ul", {
+		className: clsx("nav", "nav-pills", NavPills_module_default.pills),
+		role: "tablist",
+		"aria-orientation": "horizontal",
+		children: navPills
+	}), navBodies] });
+};
+var NavPill = ({ title, activeItem, setActiveItem, children }) => {
+	const active = activeItem === title;
+	const handleClick = useCallback((e) => {
+		const target = e.currentTarget.dataset.target;
+		if (target) setActiveItem(target);
+	}, [setActiveItem]);
+	return /* @__PURE__ */ jsxs("li", {
+		className: "nav-item",
+		children: [/* @__PURE__ */ jsx("button", {
+			type: "button",
+			role: "tab",
+			"aria-selected": active,
+			className: clsx("nav-link", "text-style-label", active ? "active " : "", NavPills_module_default.pill),
+			"data-target": title,
+			onClick: handleClick,
+			children: title
+		}), children]
+	});
+};
 var TabSet_module_default = {
 	tabs: "_tabs_1792l_1",
 	tabContents: "_tabContents_1792l_5",
@@ -45324,6 +45827,503 @@ var useComponentNavigation = () => {
 	if (!navigation) throw new Error("useComponentNavigation must be used within a ComponentNavigationProvider");
 	return navigation;
 };
+//#endregion
+//#region ../../packages/react/src/components/findBandDom.ts
+/**
+* Finds the nearest scrollable ancestor with enough overflow to benefit from
+* programmatic scrolling.
+*/
+function findScrollableParent(element, options) {
+	const minBuffer = options?.minScrollBuffer ?? 100;
+	let current = element instanceof HTMLElement ? element : element?.parentElement;
+	while (current && current !== document.body) {
+		const style = getComputedStyle(current);
+		if ((style.overflowY === "auto" || style.overflowY === "scroll") && current.scrollHeight > current.clientHeight + minBuffer) return current;
+		current = current.parentElement;
+	}
+	return null;
+}
+/**
+* Centers the selected text range rather than its containing element, which
+* keeps matches in large elements such as code blocks correctly positioned.
+*/
+function scrollRangeToCenter(range, options) {
+	const { behavior = "auto", fallbackToScrollIntoView = true } = options ?? {};
+	const rects = range.getClientRects();
+	if (rects.length === 0) return;
+	const selectionRect = rects[0];
+	if (selectionRect === void 0) return;
+	const scrollableParent = findScrollableParent(range.startContainer.parentElement);
+	if (scrollableParent) {
+		const parentRect = scrollableParent.getBoundingClientRect();
+		const targetScrollTop = selectionRect.top - parentRect.top + scrollableParent.scrollTop - scrollableParent.clientHeight / 2;
+		scrollableParent.scrollTo({
+			top: Math.max(0, targetScrollTop),
+			behavior
+		});
+	} else if (fallbackToScrollIntoView) range.startContainer.parentElement?.scrollIntoView({
+		behavior,
+		block: "center"
+	});
+}
+//#endregion
+//#region ../../packages/react/src/components/FindBandUI.tsx
+var FindBandUI = ({ onClose, onNext, onPrevious, onKeyDown, onChange, onBeforeInput, value, matchCount, matchIndex, noResults = false, disableNav, inputRef: externalRef }) => {
+	const icons = useComponentIcons();
+	const internalRef = useRef(null);
+	const inputRef = externalRef ?? internalRef;
+	const inputProps = {
+		type: "text",
+		placeholder: "Find",
+		onKeyDown,
+		onBeforeInput,
+		onChange
+	};
+	if (value !== void 0) inputProps.value = value;
+	const hasCount = matchCount !== void 0 && matchIndex !== void 0;
+	const showStatus = noResults || hasCount && matchCount > 0;
+	const statusText = !noResults && hasCount && matchCount > 0 ? `${matchIndex + 1} of ${matchCount}` : "No results";
+	return /* @__PURE__ */ jsxs("div", {
+		"data-unsearchable": "true",
+		className: clsx("findBand"),
+		children: [
+			/* @__PURE__ */ jsx("input", {
+				ref: inputRef,
+				...inputProps
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: clsx("findBand-match-count", noResults && "findBand-no-results"),
+				style: { visibility: showStatus ? "visible" : "hidden" },
+				children: statusText
+			}),
+			/* @__PURE__ */ jsx("button", {
+				type: "button",
+				title: "Previous match",
+				className: "btn prev",
+				onClick: onPrevious,
+				disabled: disableNav,
+				children: /* @__PURE__ */ jsx("i", { className: icons.arrowUp })
+			}),
+			/* @__PURE__ */ jsx("button", {
+				type: "button",
+				title: "Next match",
+				className: "btn next",
+				onClick: onNext,
+				disabled: disableNav,
+				children: /* @__PURE__ */ jsx("i", { className: icons.arrowDown })
+			}),
+			/* @__PURE__ */ jsx("button", {
+				type: "button",
+				title: "Close",
+				className: "btn close",
+				onClick: onClose,
+				children: /* @__PURE__ */ jsx("i", { className: icons.close })
+			})
+		]
+	});
+};
+//#endregion
+//#region ../../packages/react/src/components/findShortcuts.ts
+function isFindShortcut(e) {
+	return (e.ctrlKey || e.metaKey) && !e.shiftKey && e.key.toLowerCase() === "f";
+}
+function isFindNextShortcut(e) {
+	return (e.ctrlKey || e.metaKey) && e.key.toLowerCase() === "g";
+}
+//#endregion
+//#region ../../packages/react/src/components/FindBand.tsx
+var findConfig = {
+	caseSensitive: false,
+	wrapAround: false,
+	wholeWord: false,
+	searchInFrames: false,
+	showDialog: false
+};
+var FindBand = ({ onClose, debounceMs = 100 }) => {
+	const searchBoxRef = useRef(null);
+	const { extendedFindTerm, countAllMatches, getMatchCountersVersion } = useExtendedFind();
+	const setFindTarget = useFindTargetSetter();
+	const lastFoundItem = useRef(null);
+	const currentSearchTerm = useRef("");
+	const needsCursorRestoreRef = useRef(false);
+	const scrollTimeoutRef = useRef(null);
+	const focusTimeoutRef = useRef(null);
+	const searchIdRef = useRef(0);
+	const cachedCount = useRef({
+		term: "",
+		version: -1,
+		count: 0
+	});
+	const lastNoResult = useRef(null);
+	const [matchCount, setMatchCount] = useState(null);
+	const [currentMatchIndex, setCurrentMatchIndex] = useState(0);
+	const [noResults, setNoResults] = useState(false);
+	const handleSearch = useCallback(async (back = false, skipKnownMiss = false) => {
+		const thisSearchId = ++searchIdRef.current;
+		const searchTerm = searchBoxRef.current?.value ?? "";
+		if (!searchTerm) {
+			setMatchCount(null);
+			setCurrentMatchIndex(0);
+			setNoResults(false);
+			setFindTarget(null);
+			return;
+		}
+		const countersVersion = getMatchCountersVersion();
+		if (skipKnownMiss && lastNoResult.current && lastNoResult.current.version === countersVersion && searchTerm.startsWith(lastNoResult.current.term)) {
+			setMatchCount(null);
+			setNoResults(true);
+			return;
+		}
+		const termChanged = currentSearchTerm.current !== searchTerm;
+		if (termChanged) {
+			lastFoundItem.current = null;
+			currentSearchTerm.current = searchTerm;
+			setCurrentMatchIndex(0);
+		}
+		let total;
+		if (cachedCount.current.term === searchTerm && cachedCount.current.version === countersVersion) total = cachedCount.current.count;
+		else {
+			total = countAllMatches(searchTerm);
+			cachedCount.current = {
+				term: searchTerm,
+				version: countersVersion,
+				count: total
+			};
+		}
+		setMatchCount(total > 0 ? total : null);
+		const focusedElement = document.activeElement;
+		const selection = window.getSelection();
+		let savedRange = null;
+		if (selection && selection.rangeCount > 0) savedRange = selection.getRangeAt(0).cloneRange();
+		const savedScrollParent = savedRange ? findScrollableParent(savedRange.startContainer.parentElement) : null;
+		const savedScrollTop = savedScrollParent?.scrollTop ?? 0;
+		const result = await findExtendedInDOM(searchTerm, back, lastFoundItem.current, extendedFindTerm);
+		if (searchIdRef.current !== thisSearchId) return;
+		setNoResults(!result);
+		lastNoResult.current = result ? null : {
+			term: searchTerm,
+			version: countersVersion
+		};
+		if (!result && savedRange) {
+			const sel = window.getSelection();
+			if (sel) {
+				sel.removeAllRanges();
+				sel.addRange(savedRange);
+			}
+			if (savedScrollParent) savedScrollParent.scrollTop = savedScrollTop;
+		}
+		if (result) {
+			const selection = window.getSelection();
+			if (selection && selection.rangeCount > 0) {
+				const range = selection.getRangeAt(0);
+				const parentElement = range.startContainer.parentElement || range.commonAncestorContainer;
+				const isNewMatch = !isLastFoundItem(range, lastFoundItem.current);
+				lastFoundItem.current = {
+					text: range.toString(),
+					offset: range.startOffset,
+					parentElement
+				};
+				if (termChanged) setFindTarget({
+					term: searchTerm,
+					eventId: ""
+				});
+				if (isNewMatch) setCurrentMatchIndex((prev) => {
+					if (back) return prev <= 1 ? total : prev - 1;
+					else return prev >= total ? 1 : prev + 1;
+				});
+				if (scrollTimeoutRef.current !== null) window.clearTimeout(scrollTimeoutRef.current);
+				scrollTimeoutRef.current = window.setTimeout(() => {
+					scrollRangeToCenter(range);
+				}, 100);
+			}
+		}
+		focusedElement?.focus();
+	}, [
+		setFindTarget,
+		extendedFindTerm,
+		countAllMatches,
+		getMatchCountersVersion
+	]);
+	useEffect(() => {
+		focusTimeoutRef.current = window.setTimeout(() => {
+			searchBoxRef.current?.focus();
+			searchBoxRef.current?.select();
+		}, 10);
+		const focusTimeout = focusTimeoutRef.current;
+		return () => {
+			if (scrollTimeoutRef.current !== null) window.clearTimeout(scrollTimeoutRef.current);
+			if (focusTimeout !== null) window.clearTimeout(focusTimeout);
+			setFindTarget(null);
+		};
+	}, [setFindTarget]);
+	const handleKeyDown = useCallback((e) => {
+		if (e.key === "Escape") onClose();
+		else if (e.key === "Enter") handleSearch(e.shiftKey);
+		else if (isFindNextShortcut(e)) {
+			e.preventDefault();
+			handleSearch(e.shiftKey);
+		} else if (isFindShortcut(e)) {
+			searchBoxRef.current?.focus();
+			searchBoxRef.current?.select();
+		}
+	}, [onClose, handleSearch]);
+	const findPrevious = useCallback(() => {
+		handleSearch(true);
+	}, [handleSearch]);
+	const findNext = useCallback(() => {
+		handleSearch(false);
+	}, [handleSearch]);
+	const restoreCursor = useCallback(() => {
+		if (!needsCursorRestoreRef.current) return;
+		needsCursorRestoreRef.current = false;
+		const input = searchBoxRef.current;
+		if (input) {
+			const len = input.value.length;
+			input.setSelectionRange(len, len);
+		}
+	}, []);
+	const handleInputChange = useDebouncedCallback(useCallback(async () => {
+		if (!searchBoxRef.current) return;
+		await handleSearch(false, true);
+		needsCursorRestoreRef.current = true;
+	}, [handleSearch]), debounceMs);
+	const restoreCursorIfNeeded = useCallback(() => {
+		const input = searchBoxRef.current;
+		if (!input) return;
+		if (input.selectionStart === 0 && input.selectionEnd === 0 && input.value.length > 0) restoreCursor();
+		else needsCursorRestoreRef.current = false;
+	}, [restoreCursor]);
+	const handleBeforeInput = useCallback(() => {
+		restoreCursorIfNeeded();
+	}, [restoreCursorIfNeeded]);
+	useEffect(() => {
+		const handleGlobalKeyDown = (e) => {
+			if (e.key === "F3") {
+				e.preventDefault();
+				handleSearch(e.shiftKey);
+				return;
+			}
+			if (isFindShortcut(e)) {
+				e.preventDefault();
+				e.stopPropagation();
+				searchBoxRef.current?.focus();
+				searchBoxRef.current?.select();
+				return;
+			}
+			if (isFindNextShortcut(e)) {
+				e.preventDefault();
+				e.stopPropagation();
+				handleSearch(e.shiftKey);
+				return;
+			}
+			if (e.ctrlKey || e.metaKey || e.altKey) return;
+			if (e.key.length !== 1 && e.key !== "Backspace" && e.key !== "Delete") return;
+			const input = searchBoxRef.current;
+			if (!input) return;
+			if (document.activeElement !== input) {
+				if (isEditableTarget(deepActiveElement())) return;
+				restoreCursor();
+				input.focus();
+			} else restoreCursorIfNeeded();
+		};
+		document.addEventListener("keydown", handleGlobalKeyDown, true);
+		return () => {
+			document.removeEventListener("keydown", handleGlobalKeyDown, true);
+		};
+	}, [
+		handleSearch,
+		restoreCursor,
+		restoreCursorIfNeeded
+	]);
+	return /* @__PURE__ */ jsx(FindBandUI, {
+		inputRef: searchBoxRef,
+		onClose,
+		onNext: findNext,
+		onPrevious: findPrevious,
+		onKeyDown: handleKeyDown,
+		onBeforeInput: handleBeforeInput,
+		onChange: handleInputChange,
+		noResults,
+		matchCount: matchCount ?? void 0,
+		matchIndex: matchCount !== null && matchCount > 0 ? currentMatchIndex - 1 : void 0
+	});
+};
+function windowFind(searchTerm, back) {
+	return window.find?.(searchTerm, findConfig.caseSensitive, back, findConfig.wrapAround, findConfig.wholeWord, findConfig.searchInFrames, findConfig.showDialog) ?? false;
+}
+function positionSelectionForWrap(back) {
+	if (!back) return;
+	const sel = window.getSelection();
+	if (sel) {
+		const range = document.createRange();
+		range.selectNodeContents(document.body);
+		range.collapse(false);
+		sel.removeAllRanges();
+		sel.addRange(range);
+	}
+}
+async function findExtendedInDOM(searchTerm, back, lastFoundItem, extendedFindTerm) {
+	let result = false;
+	let hasTriedExtendedSearch = false;
+	let extendedSearchSucceeded = false;
+	const maxAttempts = 25;
+	for (let attempts = 0; attempts < maxAttempts; attempts++) {
+		result = windowFind(searchTerm, back);
+		if (result) {
+			const selection = window.getSelection();
+			if (selection && selection.rangeCount > 0) {
+				const range = selection.getRangeAt(0);
+				const isUnsearchable = inUnsearchableElement(range);
+				const isSameAsLast = isLastFoundItem(range, lastFoundItem);
+				if (!isUnsearchable && !isSameAsLast) break;
+				if (isSameAsLast) {
+					if (!hasTriedExtendedSearch) {
+						hasTriedExtendedSearch = true;
+						window.getSelection()?.removeAllRanges();
+						if (await extendedFindTerm(searchTerm, back ? "backward" : "forward")) {
+							extendedSearchSucceeded = true;
+							await waitForTextInDOM(searchTerm);
+							continue;
+						}
+					}
+					if (extendedSearchSucceeded) {
+						const sel = window.getSelection();
+						if (sel?.rangeCount) sel.getRangeAt(0).collapse(!back);
+					} else {
+						window.getSelection()?.removeAllRanges();
+						positionSelectionForWrap(back);
+					}
+					result = windowFind(searchTerm, back);
+					if (result) {
+						const sel = window.getSelection();
+						if (sel && sel.rangeCount > 0) {
+							if (inUnsearchableElement(sel.getRangeAt(0))) continue;
+						}
+					}
+					break;
+				}
+			}
+		} else if (!hasTriedExtendedSearch) {
+			hasTriedExtendedSearch = true;
+			window.getSelection()?.removeAllRanges();
+			if (await extendedFindTerm(searchTerm, back ? "backward" : "forward")) {
+				extendedSearchSucceeded = true;
+				await waitForTextInDOM(searchTerm);
+				continue;
+			}
+			positionSelectionForWrap(back);
+			result = windowFind(searchTerm, back);
+			if (result) {
+				const sel = window.getSelection();
+				if (sel && sel.rangeCount > 0) {
+					if (inUnsearchableElement(sel.getRangeAt(0))) continue;
+				}
+			}
+			break;
+		} else break;
+	}
+	if (result) {
+		const sel = window.getSelection();
+		if (sel?.rangeCount && inUnsearchableElement(sel.getRangeAt(0))) {
+			sel.removeAllRanges();
+			result = false;
+		}
+	}
+	return result;
+}
+function isLastFoundItem(range, lastFoundItem) {
+	if (!lastFoundItem) return false;
+	const currentText = range.toString();
+	const currentOffset = range.startOffset;
+	const currentParentElement = range.startContainer.parentElement || range.commonAncestorContainer;
+	return currentText === lastFoundItem.text && currentOffset === lastFoundItem.offset && currentParentElement === lastFoundItem.parentElement;
+}
+function inUnsearchableElement(range) {
+	let element = selectionParentElement(range);
+	let isUnsearchable = false;
+	while (element) {
+		if (element.hasAttribute("data-unsearchable") || getComputedStyle(element).userSelect === "none") {
+			isUnsearchable = true;
+			break;
+		}
+		element = element.parentElement;
+	}
+	return isUnsearchable;
+}
+function selectionParentElement(range) {
+	let element = null;
+	if (range.startContainer.nodeType === Node.ELEMENT_NODE) element = range.startContainer;
+	else element = range.startContainer.parentElement;
+	if (!element && range.commonAncestorContainer.nodeType === Node.ELEMENT_NODE) element = range.commonAncestorContainer;
+	else if (!element && range.commonAncestorContainer.parentElement) element = range.commonAncestorContainer.parentElement;
+	return element;
+}
+/**
+* Polls until the search term appears in a searchable (non-unsearchable) DOM
+* text node. After Virtuoso scrolls a virtual list item into view, the
+* onContentReady callback may fire before the content is actually rendered,
+* especially for large scroll distances. This ensures we wait for the text
+* to be present before calling window.find().
+*/
+function waitForTextInDOM(searchTerm, timeoutMs = 2e3) {
+	const lowerTerm = searchTerm.toLowerCase();
+	const isTextInSearchableDOM = () => {
+		const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT, { acceptNode: (node) => {
+			let el = node.parentElement;
+			while (el) {
+				if (el.hasAttribute("data-unsearchable")) return NodeFilter.FILTER_REJECT;
+				el = el.parentElement;
+			}
+			return NodeFilter.FILTER_ACCEPT;
+		} });
+		while (walker.nextNode()) if (walker.currentNode.textContent?.toLowerCase().includes(lowerTerm)) return true;
+		return false;
+	};
+	return new Promise((resolve) => {
+		const interval = 50;
+		let elapsed = 0;
+		const check = () => {
+			if (isTextInSearchableDOM()) {
+				resolve(true);
+				return;
+			}
+			elapsed += interval;
+			if (elapsed >= timeoutMs) {
+				resolve(false);
+				return;
+			}
+			setTimeout(check, interval);
+		};
+		check();
+	});
+}
+//#endregion
+//#region ../../packages/react/src/components/useFindBandShortcut.ts
+/**
+* Global Ctrl/Cmd+F shortcut companion to `FindBand`: opens the band
+* (blocking the browser's own find dialog) and optionally closes it on
+* Escape. Pass stable callbacks — they are effect dependencies.
+*/
+function useFindBandShortcut(onOpen, options) {
+	const { onClose, isOpen = false, enabled = true } = options ?? {};
+	useEffect(() => {
+		if (!enabled) return;
+		const handleKeyDown = (e) => {
+			if (isFindShortcut(e)) {
+				e.preventDefault();
+				e.stopPropagation();
+				onOpen();
+			} else if (e.key === "Escape" && isOpen && onClose) onClose();
+		};
+		document.addEventListener("keydown", handleKeyDown, true);
+		return () => document.removeEventListener("keydown", handleKeyDown, true);
+	}, [
+		enabled,
+		onOpen,
+		onClose,
+		isOpen
+	]);
+}
 var MarkdownDivWithReferences_module_default = { cite: "_cite_1t1bm_1" };
 //#endregion
 //#region ../../packages/react/src/components/MarkdownDivWithReferences.tsx
@@ -45645,6 +46645,165 @@ var TreeNode$2 = memo(({ name, value, defaultExpanded = false }) => {
 });
 TreeNode$2.displayName = "TreeNode";
 //#endregion
+//#region ../../packages/inspect-common/src/utils/expandEvents.ts
+/**
+* Expand range-encoded refs against a pool.
+* Each ref is [start, endExclusive] → pool.slice(start, endExclusive).
+*/
+function expandRefs$1(refs, pool) {
+	return refs.flatMap(([start, end]) => pool.slice(start, end));
+}
+function isModelEvent(event) {
+	return event.event === "model";
+}
+/**
+* Expand condensed ModelEvent input/call refs back to inline data.
+*
+* Pure function — returns a new array; input is not mutated.
+* Non-ModelEvents and ModelEvents without refs pass through unchanged.
+*/
+function expandEvents(events, eventsData) {
+	if (!eventsData) return events;
+	const { messages, calls } = eventsData;
+	const hasMessages = messages.length > 0;
+	const hasCalls = calls.length > 0;
+	if (!hasMessages && !hasCalls) return events;
+	return events.map((event) => {
+		if (!isModelEvent(event)) return event;
+		let changed = false;
+		let input = event.input;
+		let call = event.call;
+		if (event.input_refs != null && hasMessages) {
+			input = expandRefs$1(event.input_refs, messages);
+			changed = true;
+		}
+		if (call?.call_refs != null && hasCalls) {
+			const key = call.call_key ?? "messages";
+			const expandedMsgs = expandRefs$1(call.call_refs, calls);
+			call = {
+				...call,
+				request: {
+					...call.request,
+					[key]: expandedMsgs
+				},
+				call_refs: null,
+				call_key: null
+			};
+			changed = true;
+		}
+		return changed ? {
+			...event,
+			input,
+			input_refs: null,
+			call
+		} : event;
+	});
+}
+//#endregion
+//#region ../../packages/inspect-common/src/utils/inputString.ts
+/**
+* Gets a string for a sample input.
+*/
+var inputString = (input) => {
+	if (typeof input === "string") return [input];
+	else return input.map((inp) => {
+		if (typeof inp === "string") return inp;
+		else {
+			const content = inp.content;
+			if (typeof content === "string") return content;
+			else return content.map((con) => {
+				if (con.type === "text") return con.text;
+				else return "";
+			}).join("\n");
+		}
+	});
+};
+//#endregion
+//#region ../../packages/inspect-common/src/utils/modelFallbacks.ts
+/**
+* Total generate calls served via fallback across a sample's rollup.
+*/
+var totalModelFallbacks = (fallbacks) => (fallbacks ?? []).reduce((sum, f) => sum + (f.count ?? 1), 0);
+/**
+* One "requested → served (×N)" line per fallback rollup entry.
+*/
+var modelFallbackLines = (fallbacks) => (fallbacks ?? []).map((f) => `${f.model} → ${f.fallback_model}${(f.count ?? 1) > 1 ? ` (×${f.count})` : ""}`);
+//#endregion
+//#region src/client/utils/derive.ts
+var deriveLogFields = (header) => {
+	let total_tokens;
+	if (header.stats?.model_usage) {
+		total_tokens = 0;
+		for (const usage of Object.values(header.stats.model_usage)) total_tokens += usage.total_tokens;
+	}
+	let duration;
+	if (header.stats?.started_at && header.stats?.completed_at) {
+		const start = new Date(header.stats.started_at).getTime();
+		const end = new Date(header.stats.completed_at).getTime();
+		if (start && end && end > start) duration = (end - start) / 1e3;
+	}
+	const taskArgsSource = header.eval.task_args_passed ?? header.eval.task_args;
+	let task_args;
+	if (taskArgsSource) {
+		const entries = Object.entries(taskArgsSource);
+		if (entries.length > 0) task_args = entries.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ");
+	}
+	let percent_completed;
+	const total = header.results?.total_samples;
+	const completed = header.results?.completed_samples;
+	if (total && total > 0 && completed !== void 0) percent_completed = completed / total * 100;
+	const sample_limits = header.sampleLimits.length > 0 ? header.sampleLimits.join(", ") : void 0;
+	let scores;
+	if (header.results?.scores) {
+		for (const evalScore of header.results.scores) if (evalScore.metrics) for (const [metricName, metric] of Object.entries(evalScore.metrics)) {
+			scores ??= {};
+			(scores[evalScore.name] ??= {})[metricName] = metric.value;
+		}
+	}
+	return {
+		total_tokens,
+		duration,
+		task_args,
+		percent_completed,
+		sample_limits,
+		scores
+	};
+};
+/** The sample facts baked onto the stored `LogHeader` by `toLogHeader` —
+*  persisted derivation like the fields above, so it lives under
+*  `DERIVE_VERSION` with them. */
+var deriveSampleFacts = (summaries) => {
+	const limits = /* @__PURE__ */ new Set();
+	let errorCount = 0;
+	for (const sample of summaries) {
+		if (sample.error) errorCount += 1;
+		if (sample.limit) limits.add(sample.limit);
+	}
+	return {
+		sampleCount: summaries.length,
+		sampleErrorCount: errorCount,
+		sampleLimits: [...limits].sort()
+	};
+};
+/** A sample's total token spend across models (undefined before any usage).
+*  The single home for this sum — the stored `derived.tokens` column and
+*  read-time consumers (filter variables, sample rows) must agree. */
+var totalSampleTokens = (modelUsage) => modelUsage ? Object.values(modelUsage).reduce((sum, u) => sum + (u.total_tokens ?? 0), 0) : void 0;
+var deriveSampleFields = (summary) => {
+	let scores;
+	if (summary.scores) {
+		scores = {};
+		for (const [scoreName, score] of Object.entries(summary.scores)) scores[scoreName] = score.value;
+	}
+	return {
+		tokens: totalSampleTokens(summary.model_usage),
+		input: summary.input !== void 0 ? inputString(summary.input).join("\n") : "",
+		target: arrayToString(summary.target ?? ""),
+		fallbacks: totalModelFallbacks(summary.model_fallbacks) || void 0,
+		scores
+	};
+};
+//#endregion
 //#region src/client/utils/type-utils.ts
 var kDepthOrder = {
 	listed: 0,
@@ -45671,27 +46830,31 @@ var previewTier = (preview) => ({
 	primary_metric: preview.primary_metric
 });
 /** The detailed-tier attributes: the flat columns re-derived from the header
-*  plus the header itself. */
+*  plus the header itself and the derived listing columns. */
 var detailTier = (header) => ({
 	...previewTier(toLogPreview(header)),
 	depth: "detailed",
-	header
+	header,
+	derived: deriveLogFields(header)
 });
 /** Split a details payload into its stored header form: everything but the
 *  sample summaries, plus the sample facts derived from them. */
 var toLogHeader = (details) => {
 	const { sampleSummaries, ...header } = details;
-	const limits = /* @__PURE__ */ new Set();
-	let errorCount = 0;
-	for (const sample of sampleSummaries) {
-		if (sample.error) errorCount += 1;
-		if (sample.limit) limits.add(sample.limit);
-	}
 	return {
 		...header,
-		sampleCount: sampleSummaries.length,
-		sampleErrorCount: errorCount,
-		sampleLimits: [...limits].sort()
+		...deriveSampleFacts(sampleSummaries)
+	};
+};
+var prepareLogDetails = (details) => {
+	const header = toLogHeader(details);
+	return {
+		header,
+		patch: detailTier(header),
+		summaries: details.sampleSummaries.map((summary) => ({
+			summary,
+			derived: deriveSampleFields(summary)
+		}))
 	};
 };
 var toLogPreview = (header) => {
@@ -46153,7 +47316,7 @@ var FetchEngine = class {
 		this.stop();
 		this._deps = deps;
 		if (!deps.database) return;
-		const rows = await deps.database.readLogs();
+		const rows = await deps.database.readLogs({ prefix: deps.logDir });
 		if (!rows) return;
 		deps.sink.seedRows(rows);
 		this._handles = rows;
@@ -46456,10 +47619,11 @@ var FetchEngine = class {
 		}
 	}
 	async updateDbStats() {
-		const database = this._deps?.database;
-		if (!database?.opened()) return;
+		const deps = this._deps;
+		const database = deps?.database;
+		if (deps === void 0 || !database?.opened()) return;
 		try {
-			const stats = await database.getCacheStats();
+			const stats = await database.getCacheStats({ prefix: deps.logDir });
 			this.setStatus({ dbStats: {
 				logCount: stats.logFiles,
 				previewCount: stats.logSummaries,
@@ -50296,26 +51460,29 @@ var fromLogRecord = (record) => {
 		name: file_path
 	};
 };
-function resolveDBName(databaseHandle) {
-	return `InspectAI_${databaseHandle.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
-}
+var DB_VERSION = 1301;
+var DB_NAME = "InspectAI";
+/** The boundary-safe prefix for scoping `file_path` queries to a dir:
+*  `/logs/important` must not match `/logs/important-2`. */
+var scopePrefix = (dir) => dir.endsWith("/") ? dir : `${dir}/`;
 var AppDatabase = class extends Dexie {
 	logs;
 	sample_summaries;
+	sync_scopes;
 	/**
 	* Check if an existing database needs to be recreated due to version mismatch.
 	* Returns true if the database should be deleted and recreated.
 	*/
-	static async checkVersionMismatch(databaseHandle) {
-		const dbName = resolveDBName(databaseHandle);
+	static async checkVersionMismatch() {
+		const dbName = DB_NAME;
 		try {
 			if (!await Dexie.exists(dbName)) return false;
 			const tempDb = new Dexie(dbName);
 			await tempDb.open();
 			const currentVersion = tempDb.verno;
 			tempDb.close();
-			if (currentVersion !== 12) {
-				console.log(`Database version mismatch (found v${currentVersion}, expected v12)`);
+			if (currentVersion !== DB_VERSION) {
+				console.log(`Database version mismatch (found v${currentVersion}, expected v${DB_VERSION})`);
 				return true;
 			}
 			return false;
@@ -50323,52 +51490,61 @@ var AppDatabase = class extends Dexie {
 			return false;
 		}
 	}
-	constructor(databaseHandle) {
-		super(resolveDBName(databaseHandle));
-		this.version(12).stores({
-			logs: "++id, &file_path, mtime, task, task_id, depth, cached_at",
+	constructor() {
+		super(DB_NAME);
+		this.version(DB_VERSION).stores({
+			logs: "++id, &file_path, mtime, task, task_id, depth, cached_at, [depth+file_path]",
 			sample_summaries: "[file_path+id+epoch], file_path, summary.completed_at",
+			sync_scopes: "prefix",
 			log_previews: null,
 			log_details: null,
 			log_fetch_state: null
-		}).upgrade((tx) => Promise.all(["logs", "sample_summaries"].map((table) => tx.table(table).clear())));
+		}).upgrade((tx) => Promise.all([
+			"logs",
+			"sample_summaries",
+			"sync_scopes"
+		].map((table) => tx.table(table).clear())));
 	}
 };
+/**
+* Delete pre-unification per-dir databases (`InspectAI_<sanitized dir>`).
+* Best-effort: `indexedDB.databases()` is not universally available and a
+* database held open by another (older) tab may survive until it closes.
+*/
+var deleteLegacyDatabases = async () => {
+	try {
+		const databases = await indexedDB.databases();
+		await Promise.all(databases.map((info) => info.name).filter((name) => !!name?.startsWith(`${DB_NAME}_`)).map((name) => Dexie.delete(name).catch(() => {})));
+	} catch {}
+};
 //#endregion
 //#region src/client/database/manager.ts
-var log$5 = createLogger("DatabaseManager");
+var log$6 = createLogger("DatabaseManager");
 /**
-* Manages database instances for different log directories.
-* Each instance of this class manages a single database connection.
+* Manages the (single, per-origin) database connection. Log dirs are query
+* scopes over the unified database, not separate databases.
 */
 var DatabaseManager = class {
 	database = null;
-	databaseHandle = null;
-	/**
-	* Opens a database for the specified log directory.
-	* If already connected to this directory, returns the existing connection.
-	* If connected to a different directory, closes the current connection first.
-	*/
-	async openDatabase(databaseHandle) {
-		if (this.databaseHandle === databaseHandle && this.database) return this.database;
-		log$5.debug(`Opening database for log directory: ${databaseHandle}`);
-		if (this.database && this.databaseHandle !== databaseHandle) await this.close();
-		if (await AppDatabase.checkVersionMismatch(databaseHandle)) {
-			log$5.info(`Recreating database due to version mismatch for: ${databaseHandle}`);
-			const dbName = `InspectAI_${databaseHandle.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
-			await Dexie.delete(dbName);
-			log$5.debug(`Deleted old database: ${dbName}`);
-		}
-		this.database = new AppDatabase(databaseHandle);
-		this.databaseHandle = databaseHandle;
+	/**
+	* Open the database, returning the existing connection when already open.
+	*/
+	async openDatabase() {
+		if (this.database) return this.database;
+		if (await AppDatabase.checkVersionMismatch()) {
+			log$6.info("Recreating database due to version mismatch");
+			await Dexie.delete(DB_NAME);
+			log$6.debug(`Deleted old database: ${DB_NAME}`);
+		}
+		this.database = new AppDatabase();
 		try {
 			await this.database.open();
-			log$5.debug(`Successfully opened database for: ${databaseHandle}`);
+			log$6.debug("Successfully opened database");
+			deleteLegacyDatabases();
 			return this.database;
 		} catch (error) {
-			log$5.error(`Failed to open database for ${databaseHandle}:`, error);
+			log$6.error("Failed to open database:", error);
 			this.database = null;
-			this.databaseHandle = null;
 			throw error;
 		}
 	}
@@ -50380,21 +51556,13 @@ var DatabaseManager = class {
 		return this.database;
 	}
 	/**
-	* Get the current log directory.
-	* Returns null if no database is open.
-	*/
-	getDatabaseHandle() {
-		return this.databaseHandle;
-	}
-	/**
 	* Close the current database connection.
 	*/
 	close() {
 		if (this.database) {
-			log$5.debug(`Closing database for: ${this.databaseHandle}`);
+			log$6.debug("Closing database");
 			this.database.close();
 			this.database = null;
-			this.databaseHandle = null;
 		}
 		return Promise.resolve();
 	}
@@ -50402,21 +51570,12 @@ var DatabaseManager = class {
 	* Check if a database is currently open.
 	*/
 	isOpen() {
-		return this.database !== null && this.databaseHandle !== null;
-	}
-	/**
-	* Get database info for debugging.
-	*/
-	getInfo() {
-		return {
-			databaseHandle: this.databaseHandle,
-			isOpen: this.isOpen()
-		};
+		return this.database !== null;
 	}
 };
 //#endregion
 //#region src/client/database/service.ts
-var log$4 = createLogger("DatabaseService");
+var log$5 = createLogger("DatabaseService");
 var newRow$1 = (handle) => ({
 	...handle,
 	depth: "listed",
@@ -50446,10 +51605,10 @@ var DatabaseService = class {
 		return this.manager.getDatabase() !== null;
 	}
 	/**
-	* Open a database for the specified log directory.
+	* Open the (unified) database.
 	*/
-	async openDatabase(databaseHandle) {
-		await this.manager.openDatabase(databaseHandle);
+	async openDatabase() {
+		await this.manager.openDatabase();
 	}
 	/**
 	* Close the current database connection.
@@ -50458,12 +51617,6 @@ var DatabaseService = class {
 		await this.manager.close();
 	}
 	/**
-	* Get the current log directory.
-	*/
-	getDatabaseHandle() {
-		return this.manager.getDatabaseHandle();
-	}
-	/**
 	* Upsert the listing identity tier: new files get fresh listed-depth rows;
 	* known files update identity fields only (depth, content, and retrieval
 	* facts are preserved).
@@ -50471,7 +51624,7 @@ var DatabaseService = class {
 	async writeLogs(handles) {
 		const db = this.getDb();
 		const now = (/* @__PURE__ */ new Date()).toISOString();
-		const existingRecords = await db.logs.toArray();
+		const existingRecords = await db.logs.where("file_path").anyOf(handles.map((handle) => handle.name)).toArray();
 		const existingByPath = new Map(existingRecords.map((record) => [record.file_path, record]));
 		const records = handles.map((handle) => {
 			const existing = existingByPath.get(handle.name);
@@ -50483,25 +51636,25 @@ var DatabaseService = class {
 				cached_at: now
 			} : toLogRecord(newRow$1(handle), void 0, now);
 		});
-		log$4.debug(`Upserting ${records.length} log rows (identity tier)`);
+		log$5.debug(`Upserting ${records.length} log rows (identity tier)`);
 		await db.logs.bulkPut(records);
 	}
-	async readLogs() {
+	async readLogs(scope) {
 		try {
 			if (!this.opened()) {
-				log$4.debug("Database not open");
+				log$5.debug("Database not open");
 				return null;
 			}
-			const records = await this.getDb().logs.toArray();
+			const records = await this.getDb().logs.where("file_path").startsWith(scopePrefix(scope.prefix)).toArray();
 			records.sort((a, b) => {
 				if (a.mtime != null && b.mtime != null) return b.mtime - a.mtime;
 				if (a.id != null && b.id != null) return a.id - b.id;
 				return 0;
 			});
-			log$4.debug(`Retrieved ${records.length} log rows`);
+			log$5.debug(`Retrieved ${records.length} log rows`);
 			return records.map(fromLogRecord);
 		} catch (error) {
-			log$4.error("Error retrieving log rows:", error);
+			log$5.error("Error retrieving log rows:", error);
 			return null;
 		}
 	}
@@ -50510,7 +51663,7 @@ var DatabaseService = class {
 			const record = await this.getDb().logs.where("file_path").equals(filePath).first();
 			return record ? fromLogRecord(record) : null;
 		} catch (error) {
-			log$4.error(`Error retrieving log row for ${filePath}:`, error);
+			log$5.error(`Error retrieving log row for ${filePath}:`, error);
 			return null;
 		}
 	}
@@ -50521,7 +51674,7 @@ var DatabaseService = class {
 			for (const record of records) result[record.file_path] = fromLogRecord(record);
 			return result;
 		} catch (error) {
-			log$4.error("Error retrieving log rows:", error);
+			log$5.error("Error retrieving log rows:", error);
 			return {};
 		}
 	}
@@ -50549,39 +51702,41 @@ var DatabaseService = class {
 		await db.logs.bulkPut(records);
 	}
 	async writeLogPreviews(previews) {
-		log$4.debug(`Upserting ${Object.keys(previews).length} log rows (previewed tier)`);
+		log$5.debug(`Upserting ${Object.keys(previews).length} log rows (previewed tier)`);
 		await this.mergeRows(Object.fromEntries(Object.entries(previews).map(([file, preview]) => [file, previewTier(preview)])));
 	}
 	/**
-	* Ingest details payloads: merge the detailed tier into each log row and
-	* replace the file's sample summary rows, in one transaction per call so a
-	* reader never sees a header whose summary rows are from an older
-	* ingestion.
+	* Ingest prepared details payloads (`prepareLogDetails` — the seam
+	* normalizes once for both stores): merge the detailed tier into each log
+	* row and replace the file's sample summary rows, in one transaction per
+	* call so a reader never sees a header whose summary rows are from an
+	* older ingestion.
 	*/
 	async writeLogDetails(details) {
 		const db = this.getDb();
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		const entries = Object.entries(details);
-		log$4.debug(`Ingesting ${entries.length} log details (split)`);
+		log$5.debug(`Ingesting ${entries.length} log details (split)`);
 		await db.transaction("rw", db.logs, db.sample_summaries, async () => {
-			await this.mergeRows(Object.fromEntries(entries.map(([file, payload]) => [file, detailTier(toLogHeader(payload))])));
+			await this.mergeRows(Object.fromEntries(entries.map(([file, { patch }]) => [file, patch])));
 			const files = entries.map(([filePath]) => filePath);
 			await db.sample_summaries.where("file_path").anyOf(files).delete();
-			await db.sample_summaries.bulkPut(entries.flatMap(([filePath, payload]) => payload.sampleSummaries.map((summary) => ({
+			await db.sample_summaries.bulkPut(entries.flatMap(([filePath, { summaries }]) => summaries.map(({ summary, derived }) => ({
 				file_path: filePath,
 				id: summary.id,
 				epoch: summary.epoch,
 				summary,
+				derived,
 				cached_at: now
 			}))));
 		});
 	}
 	async readSampleSummaries(scope) {
 		const db = this.getDb();
-		return ("file" in scope ? db.sample_summaries.where("file_path").equals(scope.file) : db.sample_summaries.where("file_path").startsWith(scope.prefix)).toArray();
+		return ("file" in scope ? db.sample_summaries.where("file_path").equals(scope.file) : db.sample_summaries.where("file_path").startsWith(scopePrefix(scope.prefix))).toArray();
 	}
 	async writeFetchStates(states) {
-		log$4.debug(`Merging retrieval facts into ${Object.keys(states).length} log rows`);
+		log$5.debug(`Merging retrieval facts into ${Object.keys(states).length} log rows`);
 		await this.mergeRows(states);
 	}
 	/**
@@ -50606,34 +51761,95 @@ var DatabaseService = class {
 	/** Remove a deleted file's row and its sample summaries. */
 	async clearCacheForFile(filePath) {
 		const db = this.getDb();
-		log$4.debug(`Clearing cache for file: ${filePath}`);
+		log$5.debug(`Clearing cache for file: ${filePath}`);
 		await Promise.all([db.logs.where("file_path").equals(filePath).delete(), db.sample_summaries.where("file_path").equals(filePath).delete()]);
 	}
 	/**
-	* Clear all cached data from all tables.
+	* Wipe every table — the "Clear Local Database" escape hatch. Unlike
+	* `clearScope`, this reaches rows persisted under names outside any synced
+	* scope's namespace (see `namesInScope` in logsContent).
+	*/
+	async clearAllData() {
+		const db = this.getDb();
+		log$5.debug("Clearing all cached data");
+		await db.transaction("rw", [
+			db.logs,
+			db.sample_summaries,
+			db.sync_scopes
+		], () => Promise.all([
+			db.logs.clear(),
+			db.sample_summaries.clear(),
+			db.sync_scopes.clear()
+		]));
+	}
+	/**
+	* Clear all cached data under a scope: its log rows, their sample
+	* summaries, and the scope's sync record. Other scopes' rows are untouched.
 	*/
-	async clearAllCaches() {
+	async clearScope(scope) {
 		const db = this.getDb();
-		log$4.debug("Clearing all caches");
-		await Promise.all([db.logs.clear(), db.sample_summaries.clear()]);
+		const prefix = scopePrefix(scope.prefix);
+		log$5.debug(`Clearing caches under: ${prefix}`);
+		await db.transaction("rw", [
+			db.logs,
+			db.sample_summaries,
+			db.sync_scopes
+		], () => Promise.all([
+			db.logs.where("file_path").startsWith(prefix).delete(),
+			db.sample_summaries.where("file_path").startsWith(prefix).delete(),
+			db.sync_scopes.where("prefix").startsWith(prefix).delete()
+		]));
+	}
+	/** Record that a scope is active (creating its row on first contact). */
+	async touchSyncScope(prefix) {
+		const db = this.getDb();
+		const key = scopePrefix(prefix);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		await db.transaction("rw", db.sync_scopes, async () => {
+			const existing = await db.sync_scopes.get(key);
+			await db.sync_scopes.put({
+				...existing,
+				prefix: key,
+				last_accessed: now
+			});
+		});
+	}
+	/** Read a scope's sync record (undefined when never activated). */
+	async getSyncScope(prefix) {
+		return this.getDb().sync_scopes.get(scopePrefix(prefix));
+	}
+	/** Record that a listing sync persisted under a scope. */
+	async markScopeSynced(prefix) {
+		const db = this.getDb();
+		const key = scopePrefix(prefix);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		await db.transaction("rw", db.sync_scopes, async () => {
+			const existing = await db.sync_scopes.get(key);
+			await db.sync_scopes.put({
+				prefix: key,
+				last_accessed: existing?.last_accessed ?? now,
+				last_synced: now
+			});
+		});
 	}
 	/**
-	* Get cache statistics.
+	* Get cache statistics for a scope.
 	*/
-	async getCacheStats() {
+	async getCacheStats(scope) {
 		const db = this.getDb();
-		const [logFiles, logSummaries, logHeaders, sampleSummaries] = await Promise.all([
-			db.logs.count(),
-			db.logs.where("depth").anyOf(["previewed", "detailed"]).count(),
-			db.logs.where("depth").equals("detailed").count(),
-			db.sample_summaries.count()
+		const prefix = scopePrefix(scope.prefix);
+		const depthCount = (depth) => db.logs.where("[depth+file_path]").between([depth, prefix], [depth, prefix + "￿"]).count();
+		const [logFiles, previewed, detailed, sampleSummaries] = await Promise.all([
+			db.logs.where("file_path").startsWith(prefix).count(),
+			depthCount("previewed"),
+			depthCount("detailed"),
+			db.sample_summaries.where("file_path").startsWith(prefix).count()
 		]);
 		return {
 			logFiles,
-			logSummaries,
-			logHeaders,
-			sampleSummaries,
-			logHandle: this.manager.getDatabaseHandle()
+			logSummaries: previewed + detailed,
+			logHeaders: detailed,
+			sampleSummaries
 		};
 	}
 };
@@ -50744,11 +51960,12 @@ var rowContext = (row) => row === void 0 ? {} : {
 	model: row.model,
 	status: row.status
 };
-/** Assemble listing rows from an ingested payload's parts (the sink's push
+/** Assemble listing rows from a prepared payload's parts (the sink's push
 *  path — the db read below produces the same shape). */
-var toSamplesListingRows = (logFile, header, summaries) => summaries.map((summary) => ({
+var toSamplesListingRows = (logFile, header, summaries) => summaries.map(({ summary, derived }) => ({
 	logFile,
 	summary,
+	derived,
 	log: logContext(header)
 }));
 var pageOf = (rows, params) => {
@@ -50765,6 +51982,7 @@ var readSamplesListing = async (params) => {
 	return pageOf(records.map((record) => ({
 		logFile: record.file_path,
 		summary: record.summary,
+		derived: record.derived,
 		log: contexts.get(record.file_path) ?? {}
 	})), params);
 };
@@ -50840,6 +52058,7 @@ var removeSamplesListings = (logDir) => {
 * `set*`/`merge*`/`seed*` primitives) are allowed; the invariant is
 * one-directional (db ⟹ cache).
 */
+var log$4 = createLogger("logsContent");
 var EMPTY_LOGS = [];
 var logsKey = (logDir) => [
 	"log_data",
@@ -50949,15 +52168,44 @@ var clearCache = (logDir) => {
 	removeSamplesListings(logDir);
 };
 /**
+* The store scopes every read by `file_path.startsWith(scopePrefix(logDir))`,
+* so persistence requires the listing's names to live in `logDir`'s
+* namespace. A server can violate that (e.g. an older view server hands out
+* an aliased local path as log_dir while names are `file://` URIs) —
+* persisting under such a scope would strand the rows where no scoped read,
+* clear, or seed can reach them, and the empty read-back would blank the
+* just-synced listing. Degrade to cache-only instead.
+*
+* Only listing persistence is gated: the keyed writes below (previews,
+* details, fetch states) still persist out-of-namespace rows, which serve
+* exact-path reads but which no listing sync governs and no scoped clear can
+* remove. "Clear Local Database" (`clearAll`) wipes them along with
+* everything else.
+*/
+var warnedScopes = /* @__PURE__ */ new Set();
+var namesInScope = (logDir, handles) => {
+	const prefix = scopePrefix(logDir);
+	const misnamed = handles.find((handle) => !handle.name.startsWith(prefix));
+	if (misnamed !== void 0) {
+		if (!warnedScopes.has(prefix)) {
+			warnedScopes.add(prefix);
+			log$4.warn(`Listing names (e.g. ${misnamed.name}) are outside the log dir's namespace (${prefix}); skipping persistence for this scope.`);
+		}
+		return false;
+	}
+	return true;
+};
+/**
 * Persist the listing identity tier and cache the resulting full row list.
 * The db write is a merge-upsert (rows keep depth/content) and the cache
 * holds the full re-read, so the full list is read back and returned for the
 * caller's continued sync logic.
 */
 var writeListing = async (db, logDir, handles) => {
-	if (db?.opened()) {
+	if (db?.opened() && namesInScope(logDir, handles)) {
 		await db.writeLogs(handles);
-		const all = await db.readLogs();
+		await db.markScopeSynced(logDir);
+		const all = await db.readLogs({ prefix: logDir });
 		if (all) {
 			setRows(logDir, all);
 			return all;
@@ -50982,14 +52230,11 @@ var writePreviews = async (db, logDir, previews) => {
 * clobber them with an empty read — so the sweep is persistence-gated.
 */
 var writeDetails = async (db, logDir, details) => {
-	const headers = Object.fromEntries(Object.entries(details).map(([name, payload]) => [name, toLogHeader(payload)]));
-	await Promise.all(Object.entries(details).map(([name, payload]) => {
-		const header = headers[name];
-		return header === void 0 ? Promise.resolve() : pushFileSamples(logDir, name, toSamplesListingRows(name, header, payload.sampleSummaries));
-	}));
-	mergePatches(logDir, Object.fromEntries(Object.entries(headers).map(([name, header]) => [name, detailTier(header)])));
+	const prepared = Object.entries(details).map(([name, payload]) => [name, prepareLogDetails(payload)]);
+	await Promise.all(prepared.map(([name, file]) => pushFileSamples(logDir, name, toSamplesListingRows(name, file.header, file.summaries))));
+	mergePatches(logDir, Object.fromEntries(prepared.map(([name, file]) => [name, file.patch])));
 	if (db?.opened()) {
-		await db.writeLogDetails(details);
+		await db.writeLogDetails(Object.fromEntries(prepared));
 		invalidateSamplesListings(logDir);
 	}
 };
@@ -51023,7 +52268,7 @@ var clearFile = async (db, logDir, name) => {
 };
 var clearAll = async (db, logDir) => {
 	clearCache(logDir);
-	if (db?.opened()) await db.clearAllCaches();
+	if (db?.opened()) await db.clearAllData();
 };
 /**
 * The seam as a fetch-engine sink: the write surface bound to a directory and
@@ -51073,7 +52318,8 @@ var resolveLogKey = (logDir, logFile) => {
 var openLogDirDatabase = async (logDir) => {
 	const databaseService = getDatabaseService();
 	try {
-		await databaseService.openDatabase(getApi().get_log_dir_handle(logDir));
+		await databaseService.openDatabase();
+		await databaseService.touchSyncScope(logDir);
 		return databaseService;
 	} catch (e) {
 		console.log(e);
@@ -51081,15 +52327,15 @@ var openLogDirDatabase = async (logDir) => {
 	}
 };
 var ensureActive = async (logDir) => {
-	const databaseHandle = getApi().get_log_dir_handle(logDir);
-	if (!fetchEngine.isStarted() || engineDir !== logDir || getDatabaseService().getDatabaseHandle() !== databaseHandle) {
+	if (!fetchEngine.isStarted() || engineDir !== logDir || !getDatabaseService().opened()) {
 		fetchEngine.stop();
 		const opened = await openLogDirDatabase(logDir);
 		if (!opened) throw new Error("Database service not available");
 		await fetchEngine.start({
 			api: getApi(),
 			database: opened,
-			sink: createLogsContentSink(opened, logDir)
+			sink: createLogsContentSink(opened, logDir),
+			logDir
 		});
 		engineDir = logDir;
 	}
@@ -51114,7 +52360,8 @@ var ensureFetchEngine = (logDir) => {
 				await fetchEngine.start({
 					api: getApi(),
 					database,
-					sink: createLogsContentSink(database, logDir)
+					sink: createLogsContentSink(database, logDir),
+					logDir
 				});
 				engineDir = logDir;
 			}
@@ -51537,90 +52784,6 @@ var sampleHandlesEqual = (sample1, sample2) => {
 	return sampleIdsEqual(sample1.id, sample2.id) && sample1.epoch === sample2.epoch && sample1.logFile === sample2.logFile;
 };
 //#endregion
-//#region ../../packages/inspect-common/src/utils/expandEvents.ts
-/**
-* Expand range-encoded refs against a pool.
-* Each ref is [start, endExclusive] → pool.slice(start, endExclusive).
-*/
-function expandRefs$1(refs, pool) {
-	return refs.flatMap(([start, end]) => pool.slice(start, end));
-}
-function isModelEvent(event) {
-	return event.event === "model";
-}
-/**
-* Expand condensed ModelEvent input/call refs back to inline data.
-*
-* Pure function — returns a new array; input is not mutated.
-* Non-ModelEvents and ModelEvents without refs pass through unchanged.
-*/
-function expandEvents(events, eventsData) {
-	if (!eventsData) return events;
-	const { messages, calls } = eventsData;
-	const hasMessages = messages.length > 0;
-	const hasCalls = calls.length > 0;
-	if (!hasMessages && !hasCalls) return events;
-	return events.map((event) => {
-		if (!isModelEvent(event)) return event;
-		let changed = false;
-		let input = event.input;
-		let call = event.call;
-		if (event.input_refs != null && hasMessages) {
-			input = expandRefs$1(event.input_refs, messages);
-			changed = true;
-		}
-		if (call?.call_refs != null && hasCalls) {
-			const key = call.call_key ?? "messages";
-			const expandedMsgs = expandRefs$1(call.call_refs, calls);
-			call = {
-				...call,
-				request: {
-					...call.request,
-					[key]: expandedMsgs
-				},
-				call_refs: null,
-				call_key: null
-			};
-			changed = true;
-		}
-		return changed ? {
-			...event,
-			input,
-			input_refs: null,
-			call
-		} : event;
-	});
-}
-//#endregion
-//#region ../../packages/inspect-common/src/utils/inputString.ts
-/**
-* Gets a string for a sample input.
-*/
-var inputString = (input) => {
-	if (typeof input === "string") return [input];
-	else return input.map((inp) => {
-		if (typeof inp === "string") return inp;
-		else {
-			const content = inp.content;
-			if (typeof content === "string") return content;
-			else return content.map((con) => {
-				if (con.type === "text") return con.text;
-				else return "";
-			}).join("\n");
-		}
-	});
-};
-//#endregion
-//#region ../../packages/inspect-common/src/utils/modelFallbacks.ts
-/**
-* Total generate calls served via fallback across a sample's rollup.
-*/
-var totalModelFallbacks = (fallbacks) => (fallbacks ?? []).reduce((sum, f) => sum + (f.count ?? 1), 0);
-/**
-* One "requested → served (×N)" line per fallback rollup entry.
-*/
-var modelFallbackLines = (fallbacks) => (fallbacks ?? []).map((f) => `${f.model} → ${f.fallback_model}${(f.count ?? 1) > 1 ? ` (×${f.count})` : ""}`);
-//#endregion
 //#region src/utils/attachments.ts
 var resolveAttachments = (value, attachments, onFailedResolve) => {
 	const CONTENT_PROTOCOL = "tc://";
@@ -52269,13 +53432,14 @@ var scorerMetricKey = (scorerName, metricName) => `${scorerName}/${metricName}`;
 * scorers emitting the same metric (e.g. two "accuracy"s) into one column.
 *
 * @param logs - The directory's Log rows
-* @param scopePrefix - When set, only logs whose name starts with this
-*   prefix contribute (folder view scoping)
+* @param scopeDir - When set, only logs under this directory contribute
+*   (folder view scoping)
 */
-function computeScorerMap(logs, scopePrefix) {
+function computeScorerMap(logs, scopeDir) {
 	const info = {};
+	const prefix = scopeDir ? scopePrefix(scopeDir) : void 0;
 	for (const log of logs) {
-		if (scopePrefix && !log.name.startsWith(scopePrefix)) continue;
+		if (prefix && !log.name.startsWith(prefix)) continue;
 		if (log.header?.results?.scores) {
 			for (const evalScore of log.header.results.scores) if (evalScore.metrics) for (const [metricName, metric] of Object.entries(evalScore.metrics)) {
 				const key = scorerMetricKey(evalScore.name, metricName);
@@ -52309,8 +53473,8 @@ function scorerMapsEqual(a, b) {
 * across flushes.
 */
 var asyncScorerMapsEqual = (a, b) => a.loading === b.loading && a.error === b.error && (a.data !== void 0 && b.data !== void 0 ? scorerMapsEqual(a.data, b.data) : a.data === b.data);
-var useScoreSchema = (logDir, scopePrefix) => {
-	return useStableValue(useMapAsyncData(useLogs(logDir), useCallback((rows) => computeScorerMap(rows, scopePrefix), [scopePrefix])), asyncScorerMapsEqual);
+var useScoreSchema = (logDir, scopeDir) => {
+	return useStableValue(useMapAsyncData(useLogs(logDir), useCallback((rows) => computeScorerMap(rows, scopeDir), [scopeDir])), asyncScorerMapsEqual);
 };
 //#endregion
 //#region src/utils/uri.ts
@@ -55227,7 +56391,7 @@ var initializeStore = (capabilities, storage) => {
 		getItem: (name) => {
 			return storage ? storage.getItem(name) : null;
 		},
-		setItem: debounce$2((name, value) => {
+		setItem: debounce$3((name, value) => {
 			if (storage) storage.setItem(name, value);
 		}, 1e3),
 		removeItem: (name) => {
@@ -57832,9 +58996,6 @@ var clientApi = (api, log_file, debug = false) => {
 			return api.client_events();
 		}),
 		get_log_dir: middleware("get_log_dir", get_log_dir),
-		get_log_dir_handle: middleware("get_log_dir_handle", (log_dir) => {
-			return api.get_log_dir_handle ? api.get_log_dir_handle(log_dir) : log_dir || "default_log_dir";
-		}),
 		get_logs: middleware("get_log_files", get_logs),
 		get_log_root: middleware("get_log_root", get_log_root),
 		get_eval_set: middleware("get_eval_set", (dir) => {
@@ -58025,6 +59186,15 @@ function joinURI(...segments) {
 }
 //#endregion
 //#region src/client/api/static-http/api-static-http.ts
+/** The canonical, origin-unique URL of a deployment's log dir. A relative
+*  configured log_dir is page-relative for fetching, but page-relative
+*  strings are not identities: two bundles at different paths on one origin
+*  would collide in the shared per-origin IndexedDB. So everything the app
+*  sees (log_dir, file names) is absolute. */
+var canonicalDirUrl = (log_dir) => {
+	if (isUri(log_dir)) return log_dir;
+	return joinURI(`${window.location.origin}${window.location.pathname.substring(0, window.location.pathname.lastIndexOf("/"))}`, log_dir);
+};
 var kFallbackAppConfig = {
 	inspect_version: "unknown",
 	scout_version: null
@@ -58049,6 +59219,7 @@ function staticHttpApi(log_dir, log_file, abs_log_dir, app_config) {
 */
 function staticHttpApiForLog(logInfo) {
 	const log_dir = logInfo.log_dir;
+	const canonical_log_dir = log_dir === void 0 ? void 0 : canonicalDirUrl(log_dir);
 	const abs_log_dir = logInfo.abs_log_dir;
 	const app_config = logInfo.app_config ?? kFallbackAppConfig;
 	let manifest = void 0;
@@ -58069,27 +59240,24 @@ function staticHttpApiForLog(logInfo) {
 			return Promise.resolve([]);
 		},
 		get_log_root: async () => {
-			if (log_dir) {
+			if (log_dir && canonical_log_dir) {
 				const manifest = await getManifest();
 				if (manifest) {
 					const logs = Object.entries(manifest).map(([key, preview]) => {
 						return {
-							name: joinURI(log_dir, key),
+							name: joinURI(canonical_log_dir, key),
 							task: preview.task,
 							task_id: preview.task_id
 						};
 					});
 					return Promise.resolve({
 						logs,
-						log_dir,
+						log_dir: canonical_log_dir,
 						abs_log_dir
 					});
 				}
 			}
 		},
-		get_log_dir_handle: (log_dir) => {
-			return joinURI(`${window.location.origin}${window.location.pathname.substring(0, window.location.pathname.lastIndexOf("/"))}`, log_dir || "default_log_dir");
-		},
 		get_eval_set: async (dir) => {
 			const dirSegments = [];
 			if (log_dir) dirSegments.push(log_dir);
@@ -58128,7 +59296,7 @@ function staticHttpApiForLog(logInfo) {
 			if (manifest) {
 				const manifestAbs = {};
 				Object.entries(manifest).forEach(([key, preview]) => {
-					manifestAbs[joinURI(log_dir || "", key)] = preview;
+					manifestAbs[joinURI(canonical_log_dir || "", key)] = preview;
 				});
 				const header = manifestAbs[log_file];
 				if (header) return header;
@@ -58928,12 +60096,13 @@ var resolveLogRoot = async (bs) => {
 */
 var loadResolvedAppConfig = async (bs) => {
 	const [versions, logRoot] = await Promise.all([bs.api.get_app_config(), resolveLogRoot(bs)]);
-	if (!logRoot.log_dir) throw new Error("Log dir not resolved");
+	const logDir = logRoot.log_dir_uri ?? logRoot.log_dir;
+	if (!logDir) throw new Error("Log dir not resolved");
 	return {
 		...bs,
 		inspect_version: versions.inspect_version,
 		scout_version: versions.scout_version ?? null,
-		logDir: logRoot.log_dir,
+		logDir,
 		absLogDir: logRoot.abs_log_dir
 	};
 };
@@ -62419,7 +63588,7 @@ var useVirtuosoState = (virtuosoRef, elementKey, delay = 1e3) => {
 		setListPosition(state);
 	}, [elementKey, setListPosition]);
 	useEffect(() => {
-		debouncedFnRef.current = debounce$2((isScrolling) => {
+		debouncedFnRef.current = debounce$3((isScrolling) => {
 			log$1.debug("List scroll", isScrolling);
 			const element = virtuosoRef.current;
 			if (!element) return;
@@ -65632,11 +66801,6 @@ var getNestedPropertyValue = (obj, path) => {
 	else return;
 	return current;
 };
-var totalTokens = (sample) => {
-	if (!sample.model_usage) return null;
-	return Object.values(sample.model_usage).reduce((sum, u) => sum + (u.total_tokens ?? 0), 0);
-};
-var targetString = (target) => Array.isArray(target) ? target.join(", ") : target ?? "";
 var sampleVariables = (sample, samplesDescriptor) => {
 	return {
 		epoch: sample.epoch,
@@ -65648,13 +66812,13 @@ var sampleVariables = (sample, samplesDescriptor) => {
 		id: sample.id,
 		uuid: sample.uuid ?? null,
 		input: inputString(sample.input).join(" "),
-		target: targetString(sample.target),
+		target: arrayToString(sample.target ?? ""),
 		answer: samplesDescriptor?.selectedScorerDescriptor(sample)?.answer() ?? null,
 		error: sample.error ?? null,
 		limit: sample.limit ?? null,
 		retries: sample.retries ?? 0,
 		fallbacks: totalModelFallbacks(sample.model_fallbacks),
-		tokens: totalTokens(sample),
+		tokens: totalSampleTokens(sample.model_usage) ?? null,
 		duration: sample.total_time ?? null,
 		metadata: sample.metadata
 	};
@@ -66332,11 +67496,11 @@ var baseUrl = (logPath, sampleId, sampleEpoch, prefix = "/logs") => {
 };
 var useSampleUrlBuilder = () => {
 	const location = useLocation();
-	const prefix = location.pathname.startsWith("/tasks") ? "/tasks" : "/logs";
-	return (logPath, sampleId, sampleEpoch, sampleTabId) => {
+	return useCallback((logPath, sampleId, sampleEpoch, sampleTabId) => {
+		const prefix = location.pathname.startsWith("/tasks") ? "/tasks" : "/logs";
 		if (sampleId && sampleEpoch && location.pathname.startsWith("/samples/")) return samplesSampleUrl(logPath, sampleId, sampleEpoch, sampleTabId);
 		else return logSamplesUrl(logPath, sampleId, sampleEpoch, sampleTabId, prefix);
-	};
+	}, [location.pathname]);
 };
 var logSamplesUrl = (logPath, sampleId, sampleEpoch, sampleTabId, prefix = "/logs") => {
 	const decodedLogPath = decodeUrlParam(logPath) || logPath;
@@ -66361,6 +67525,27 @@ var sampleEventUrl = (builder, eventId, logPath, sampleId, sampleEpoch) => {
 var sampleMessageUrl = (builder, messageId, logPath, sampleId, sampleEpoch, tab = kSampleMessagesTabId) => {
 	return `${builder(logPath, sampleId, sampleEpoch, tab)}?message=${messageId}`;
 };
+/**
+* Returns a builder for *shareable* message links: the relative hash route
+* from `sampleMessageUrl` wrapped with the host page's origin/path via
+* `toFullUrl`. Copy-to-clipboard consumers (ChatMessage's copy button) must
+* use this rather than the bare route, which only works for in-app router
+* navigation.
+*/
+var useFullSampleMessageUrlBuilder = () => {
+	const builder = useSampleUrlBuilder();
+	const { logPath: urlLogPath, id: urlSampleId, epoch: urlEpoch } = useLogOrSampleRouteParams();
+	const log_file = useStore((state) => state.logs.selectedLogFile);
+	const log_dir = useLogDir();
+	let targetLogPath = urlLogPath;
+	if (!targetLogPath && log_file) targetLogPath = makeLogsPath(log_file, log_dir);
+	return useCallback((messageId) => toFullUrlMaybe(targetLogPath ? sampleMessageUrl(builder, messageId, targetLogPath, urlSampleId, urlEpoch) : void 0), [
+		builder,
+		targetLogPath,
+		urlSampleId,
+		urlEpoch
+	]);
+};
 var tasksUrl = (log_file, log_dir) => {
 	const path = makeLogsPath(log_file, log_dir);
 	return encodePathParts(`/tasks/${decodeUrlParam(path) || path}`);
@@ -66406,6 +67591,14 @@ var logsUrlRaw = (log_segment, tabId, prefix = "/logs") => {
 	if (tabId) return encodePathParts(`${prefix}/${decodedLogSegment}/${tabId}`);
 	else return encodePathParts(`${prefix}/${decodedLogSegment}`);
 };
+var toFullUrl = (path) => {
+	return `${window.location.origin}${window.location.pathname}${window.location.search}#${path}`;
+};
+var toFullUrlMaybe = (route) => route ? toFullUrl(route) : void 0;
+var routeFromFullUrl = (url) => {
+	const hashIndex = url.indexOf("#");
+	return hashIndex >= 0 ? url.slice(hashIndex + 1) : url;
+};
 var FlowButton_module_default = {
 	button: "_button_1bbut_1",
 	viewerOptions: "_viewerOptions_1bbut_7"
@@ -66746,7 +67939,7 @@ var ViewerOptionsPopover = ({ showing, positionEl, setShowing }) => {
 				}),
 				/* @__PURE__ */ jsx("div", {
 					className: clsx(),
-					children: 12
+					children: DB_VERSION
 				}),
 				/* @__PURE__ */ jsx("div", { className: clsx(ViewerOptionsPopover_module_default.spacer) }),
 				/* @__PURE__ */ jsx("div", {
@@ -67310,11 +68503,11 @@ var scorerMetricHeader = (scorerName, metricName) => `${scorerName} / ${metricNa
 * the per-scorer `score_<scorer>/<metric>` field keys.
 */
 var byMetricField = (metricName) => `metric_${metricName}`;
-var useLogListColumns = (mode = "logs", scopePrefix, viewMode = "by-metric") => {
+var useLogListColumns = (mode = "logs", scopeDir, viewMode = "by-metric") => {
 	const columnVisibility = useStore((state) => state.logs.listing.columnVisibility);
 	const setColumnVisibility = useStore((state) => state.logsActions.setLogsColumnVisibility);
 	const logDir = useLogDir();
-	const scorerMap = useScoreSchema(logDir, scopePrefix).data ?? kNoScorerMap;
+	const scorerMap = useScoreSchema(logDir, scopeDir).data ?? kNoScorerMap;
 	const allColumns = useMemo(() => {
 		const baseColumns = [
 			{
@@ -67829,7 +69022,10 @@ var useLogListColumns = (mode = "logs", scopePrefix, viewMode = "by-metric") =>
 		return allCols;
 	}, [scorerMap, mode]);
 	const listingRows = useLogListing(logDir).data ?? kNoListingRows$1;
-	const hasSampleLimits = useMemo(() => listingRows.some((row) => (!scopePrefix || row.name.startsWith(scopePrefix)) && (row.header?.sampleLimits.length ?? 0) > 0), [listingRows, scopePrefix]);
+	const hasSampleLimits = useMemo(() => {
+		const prefix = scopeDir ? scopePrefix(scopeDir) : void 0;
+		return listingRows.some((row) => (!prefix || row.name.startsWith(prefix)) && (row.header?.sampleLimits.length ?? 0) > 0);
+	}, [listingRows, scopeDir]);
 	const defaultHiddenFields = useMemo(() => {
 		const hidden = /* @__PURE__ */ new Set();
 		if (mode === "tasks") {
@@ -67894,61 +69090,6 @@ var useLogListColumns = (mode = "logs", scopePrefix, viewMode = "by-metric") =>
 	};
 };
 //#endregion
-//#region src/components/FindBandUI.tsx
-var FindBandUI = ({ onClose, onNext, onPrevious, onKeyDown, onChange, onBeforeInput, value, matchCount, matchIndex, noResults = false, disableNav, inputRef: externalRef }) => {
-	const internalRef = useRef(null);
-	const inputRef = externalRef ?? internalRef;
-	const inputProps = {
-		type: "text",
-		placeholder: "Find",
-		onKeyDown,
-		onBeforeInput,
-		onChange
-	};
-	if (value !== void 0) inputProps.value = value;
-	const hasCount = matchCount !== void 0 && matchIndex !== void 0;
-	const showStatus = noResults || hasCount && matchCount > 0;
-	const statusText = hasCount && matchCount > 0 ? `${matchIndex + 1} of ${matchCount}` : "No results";
-	return /* @__PURE__ */ jsxs("div", {
-		"data-unsearchable": "true",
-		className: clsx("findBand"),
-		children: [
-			/* @__PURE__ */ jsx("input", {
-				ref: inputRef,
-				...inputProps
-			}),
-			/* @__PURE__ */ jsx("span", {
-				className: clsx("findBand-match-count", noResults && "findBand-no-results"),
-				style: { visibility: showStatus ? "visible" : "hidden" },
-				children: statusText
-			}),
-			/* @__PURE__ */ jsx("button", {
-				type: "button",
-				title: "Previous match",
-				className: "btn prev",
-				onClick: onPrevious,
-				disabled: disableNav,
-				children: /* @__PURE__ */ jsx("i", { className: ApplicationIcons.arrows.up })
-			}),
-			/* @__PURE__ */ jsx("button", {
-				type: "button",
-				title: "Next match",
-				className: "btn next",
-				onClick: onNext,
-				disabled: disableNav,
-				children: /* @__PURE__ */ jsx("i", { className: ApplicationIcons.arrows.down })
-			}),
-			/* @__PURE__ */ jsx("button", {
-				type: "button",
-				title: "Close",
-				className: "btn close",
-				onClick: onClose,
-				children: /* @__PURE__ */ jsx("i", { className: ApplicationIcons.close })
-			})
-		]
-	});
-};
-//#endregion
 //#region ../../node_modules/.pnpm/@tanstack+table-core@8.21.3/node_modules/@tanstack/table-core/build/lib/index.mjs
 /**
 * table-core
@@ -73194,9 +74335,9 @@ function findMatches(index, term) {
 var LogListGrid = ({ rows, totalRowCount, sorting, columnFilters, currentPath, scopeKey, mode = "logs", busy }) => {
 	const { gridStateByScope, patchGridState } = useLogsListing();
 	const navigate = useNavigate();
-	const scopePrefix = mode === "logs" ? currentPath : void 0;
+	const scopeDir = mode === "logs" ? currentPath : void 0;
 	const [scoresViewMode] = useProperty("log-list-scores-view", "mode", { defaultValue: "by-metric" });
-	const { columns, visibility } = useLogListColumns(mode, scopePrefix, scoresViewMode);
+	const { columns, visibility } = useLogListColumns(mode, scopeDir, scoresViewMode);
 	const handleRowActivate = useCallback((row) => {
 		if (row.url) navigate(row.url);
 	}, [navigate]);
@@ -73282,19 +74423,13 @@ var LogListGrid = ({ rows, totalRowCount, sorting, columnFilters, currentPath, s
 		activeMatchIndex,
 		closeFind
 	]);
-	useEffect(() => {
-		const handleFindKeyDown = (e) => {
-			if ((e.metaKey || e.ctrlKey) && e.key === "f") {
-				e.preventDefault();
-				e.stopPropagation();
-				setShowFind(true);
-				setTimeout(() => findInputRef.current?.focus(), 100);
-			}
-			if (e.key === "Escape" && showFind) closeFind();
-		};
-		document.addEventListener("keydown", handleFindKeyDown, true);
-		return () => document.removeEventListener("keydown", handleFindKeyDown, true);
-	}, [closeFind, showFind]);
+	useFindBandShortcut(useCallback(() => {
+		setShowFind(true);
+		setTimeout(() => findInputRef.current?.focus(), 100);
+	}, []), {
+		onClose: closeFind,
+		isOpen: showFind
+	});
 	return /* @__PURE__ */ jsxs("div", {
 		className: clsx(gridCells_module_default.gridWrapper),
 		children: [showFind && /* @__PURE__ */ jsx(FindBandUI, {
@@ -73587,29 +74722,8 @@ var rowForItem = (item) => item.type === "file" ? item.log : void 0;
 var buildLogListRow = (item) => {
 	const log = rowForItem(item);
 	const details = log?.header;
-	let totalTokens;
-	if (details?.stats?.model_usage) {
-		totalTokens = 0;
-		for (const usage of Object.values(details.stats.model_usage)) totalTokens += usage.total_tokens;
-	}
-	let duration;
-	if (details?.stats?.started_at && details?.stats?.completed_at) {
-		const start = new Date(details.stats.started_at).getTime();
-		const end = new Date(details.stats.completed_at).getTime();
-		if (start && end && end > start) duration = (end - start) / 1e3;
-	}
+	const derived = log?.derived;
 	const taskArgsSource = details?.eval?.task_args_passed ?? details?.eval?.task_args;
-	let taskArgs;
-	if (taskArgsSource) {
-		const entries = Object.entries(taskArgsSource);
-		if (entries.length > 0) taskArgs = entries.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ");
-	}
-	let percentCompleted;
-	const total = details?.results?.total_samples;
-	const completed = details?.results?.completed_samples;
-	if (total && total > 0 && completed !== void 0) percentCompleted = completed / total * 100;
-	const sampleErrors = details?.sampleErrorCount;
-	const sampleLimits = details !== void 0 && details.sampleLimits.length > 0 ? details.sampleLimits.join(", ") : void 0;
 	const row = {
 		id: item.id,
 		name: item.name,
@@ -73628,20 +74742,18 @@ var buildLogListRow = (item) => {
 		totalSamples: details?.results?.total_samples,
 		completedSamples: details?.results?.completed_samples,
 		sandbox: details?.eval?.sandbox?.type,
-		totalTokens,
-		duration,
+		totalTokens: derived?.total_tokens,
+		duration: derived?.duration,
 		taskFile: details?.eval?.task_file ?? void 0,
-		taskArgs,
+		taskArgs: derived?.task_args,
 		taskArgsRaw: taskArgsSource ?? void 0,
 		tags: details?.tags,
-		percentCompleted,
-		sampleErrors,
-		sampleLimits,
+		percentCompleted: derived?.percent_completed,
+		sampleErrors: details?.sampleErrorCount,
+		sampleLimits: derived?.sample_limits,
 		errorMessage: details?.error?.message
 	};
-	if (details?.results?.scores) {
-		for (const evalScore of details.results.scores) if (evalScore.metrics) for (const [metricName, metric] of Object.entries(evalScore.metrics)) row[`score_${evalScore.name}/${metricName}`] = metric.value;
-	}
+	if (derived?.scores) for (const [scorerName, metrics] of Object.entries(derived.scores)) for (const [metricName, value] of Object.entries(metrics)) row[`score_${scorerName}/${metricName}`] = value;
 	return row;
 };
 /**
@@ -73850,9 +74962,9 @@ var LogsPanel = ({ maybeShowSingleLog, mode = "logs" }) => {
 		logDir,
 		showRetriedLogs
 	]);
-	const scopePrefix = mode === "logs" ? currentDir : void 0;
+	const scopeDir = mode === "logs" ? currentDir : void 0;
 	const [scoresViewMode, setScoresViewMode] = useProperty("log-list-scores-view", "mode", { defaultValue: "by-metric" });
-	const { pickerColumns, visibility, setColumnVisibility, getValue, getComparator, getFilterType } = useLogListColumns(mode, scopePrefix, scoresViewMode);
+	const { pickerColumns, visibility, setColumnVisibility, getValue, getComparator, getFilterType } = useLogListColumns(mode, scopeDir, scoresViewMode);
 	const listData = useLogListData({
 		items: logItems,
 		scopeKey,
@@ -74212,418 +75324,6 @@ var useLogSampleNavigationActions = () => {
 		hasNext
 	};
 };
-//#endregion
-//#region src/utils/dom.ts
-/**
-* Finds the nearest scrollable ancestor of an element.
-* Useful for programmatic scrolling when you need to find the scroll container.
-*
-* @param element - The element to start searching from
-* @param options.minScrollBuffer - Minimum difference between scrollHeight and clientHeight
-*                                  to consider an element scrollable (default: 100)
-* @returns The scrollable parent element, or null if none found
-*/
-function findScrollableParent(element, options) {
-	const minBuffer = options?.minScrollBuffer ?? 100;
-	let current = element instanceof HTMLElement ? element : element?.parentElement;
-	while (current && current !== document.body) {
-		const style = getComputedStyle(current);
-		if ((style.overflowY === "auto" || style.overflowY === "scroll") && current.scrollHeight > current.clientHeight + minBuffer) return current;
-		current = current.parentElement;
-	}
-	return null;
-}
-/**
-* Scrolls a Range (text selection) to the center of its scrollable container.
-* Unlike element.scrollIntoView({ block: "center" }), this works correctly
-* for selections within large elements (e.g., code blocks) by scrolling to
-* the actual selection position rather than the element's top.
-*
-* @param range - The Range to scroll into view
-* @param options.behavior - Scroll behavior ('auto' or 'smooth'), default: 'auto'
-* @param options.fallbackToScrollIntoView - Whether to fall back to scrollIntoView
-*                                           if no scrollable parent is found (default: true)
-*/
-function scrollRangeToCenter(range, options) {
-	const { behavior = "auto", fallbackToScrollIntoView = true } = options ?? {};
-	const rects = range.getClientRects();
-	if (rects.length === 0) return;
-	const selectionRect = rects[0];
-	if (selectionRect === void 0) return;
-	const scrollableParent = findScrollableParent(range.startContainer.parentElement);
-	if (scrollableParent) {
-		const parentRect = scrollableParent.getBoundingClientRect();
-		const targetScrollTop = selectionRect.top - parentRect.top + scrollableParent.scrollTop - scrollableParent.clientHeight / 2;
-		scrollableParent.scrollTo({
-			top: Math.max(0, targetScrollTop),
-			behavior
-		});
-	} else if (fallbackToScrollIntoView) range.startContainer.parentElement?.scrollIntoView({
-		behavior,
-		block: "center"
-	});
-}
-//#endregion
-//#region src/components/FindBand.tsx
-var findConfig = {
-	caseSensitive: false,
-	wrapAround: false,
-	wholeWord: false,
-	searchInFrames: false,
-	showDialog: false
-};
-var FindBand = () => {
-	const searchBoxRef = useRef(null);
-	const storeHideFind = useStore((state) => state.appActions.hideFind);
-	const { extendedFindTerm, countAllMatches } = useExtendedFind();
-	const setFindTarget = useFindTargetSetter();
-	const lastFoundItem = useRef(null);
-	const currentSearchTerm = useRef("");
-	const needsCursorRestoreRef = useRef(false);
-	const scrollTimeoutRef = useRef(null);
-	const focusTimeoutRef = useRef(null);
-	const searchIdRef = useRef(0);
-	const cachedCount = useRef({
-		term: "",
-		count: 0
-	});
-	const [matchCount, setMatchCount] = useState(null);
-	const [currentMatchIndex, setCurrentMatchIndex] = useState(0);
-	const [noResults, setNoResults] = useState(false);
-	const handleSearch = useCallback(async (back = false) => {
-		const thisSearchId = ++searchIdRef.current;
-		const searchTerm = searchBoxRef.current?.value ?? "";
-		if (!searchTerm) {
-			setMatchCount(null);
-			setCurrentMatchIndex(0);
-			setNoResults(false);
-			setFindTarget(null);
-			return;
-		}
-		const termChanged = currentSearchTerm.current !== searchTerm;
-		if (termChanged) {
-			lastFoundItem.current = null;
-			currentSearchTerm.current = searchTerm;
-			setCurrentMatchIndex(0);
-		}
-		let total;
-		if (cachedCount.current.term === searchTerm) total = cachedCount.current.count;
-		else {
-			total = countAllMatches(searchTerm);
-			cachedCount.current = {
-				term: searchTerm,
-				count: total
-			};
-		}
-		setMatchCount(total > 0 ? total : null);
-		const focusedElement = document.activeElement;
-		const selection = window.getSelection();
-		let savedRange = null;
-		if (selection && selection.rangeCount > 0) savedRange = selection.getRangeAt(0).cloneRange();
-		const savedScrollParent = savedRange ? findScrollableParent(savedRange.startContainer.parentElement) : null;
-		const savedScrollTop = savedScrollParent?.scrollTop ?? 0;
-		const result = await findExtendedInDOM(searchTerm, back, lastFoundItem.current, extendedFindTerm);
-		if (searchIdRef.current !== thisSearchId) return;
-		setNoResults(!result);
-		if (!result && savedRange) {
-			const sel = window.getSelection();
-			if (sel) {
-				sel.removeAllRanges();
-				sel.addRange(savedRange);
-			}
-			if (savedScrollParent) savedScrollParent.scrollTop = savedScrollTop;
-		}
-		if (result) {
-			const selection = window.getSelection();
-			if (selection && selection.rangeCount > 0) {
-				const range = selection.getRangeAt(0);
-				const parentElement = range.startContainer.parentElement || range.commonAncestorContainer;
-				const isNewMatch = !isLastFoundItem(range, lastFoundItem.current);
-				lastFoundItem.current = {
-					text: range.toString(),
-					offset: range.startOffset,
-					parentElement
-				};
-				if (termChanged) setFindTarget({
-					term: searchTerm,
-					eventId: ""
-				});
-				if (isNewMatch) setCurrentMatchIndex((prev) => {
-					if (back) return prev <= 1 ? total : prev - 1;
-					else return prev >= total ? 1 : prev + 1;
-				});
-				if (scrollTimeoutRef.current !== null) window.clearTimeout(scrollTimeoutRef.current);
-				scrollTimeoutRef.current = window.setTimeout(() => {
-					scrollRangeToCenter(range);
-				}, 100);
-			}
-		}
-		focusedElement?.focus();
-	}, [
-		setFindTarget,
-		extendedFindTerm,
-		countAllMatches
-	]);
-	useEffect(() => {
-		focusTimeoutRef.current = window.setTimeout(() => {
-			searchBoxRef.current?.focus();
-			searchBoxRef.current?.select();
-		}, 10);
-		const focusTimeout = focusTimeoutRef.current;
-		return () => {
-			if (scrollTimeoutRef.current !== null) window.clearTimeout(scrollTimeoutRef.current);
-			if (focusTimeout !== null) window.clearTimeout(focusTimeout);
-			setFindTarget(null);
-		};
-	}, [setFindTarget]);
-	const handleKeyDown = useCallback((e) => {
-		if (e.key === "Escape") storeHideFind();
-		else if (e.key === "Enter") handleSearch(e.shiftKey);
-		else if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === "g") {
-			e.preventDefault();
-			handleSearch(e.shiftKey);
-		} else if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === "f") {
-			searchBoxRef.current?.focus();
-			searchBoxRef.current?.select();
-		}
-	}, [storeHideFind, handleSearch]);
-	const findPrevious = useCallback(() => {
-		handleSearch(true);
-	}, [handleSearch]);
-	const findNext = useCallback(() => {
-		handleSearch(false);
-	}, [handleSearch]);
-	const restoreCursor = useCallback(() => {
-		if (!needsCursorRestoreRef.current) return;
-		needsCursorRestoreRef.current = false;
-		const input = searchBoxRef.current;
-		if (input) {
-			const len = input.value.length;
-			input.setSelectionRange(len, len);
-		}
-	}, []);
-	const runDebouncedSearch = useCallback(async () => {
-		if (!searchBoxRef.current) return;
-		await handleSearch(false);
-		needsCursorRestoreRef.current = true;
-	}, [handleSearch]);
-	const latestRunSearchRef = useRef(runDebouncedSearch);
-	useEffect(() => {
-		latestRunSearchRef.current = runDebouncedSearch;
-		return () => {
-			latestRunSearchRef.current = null;
-		};
-	}, [runDebouncedSearch]);
-	const debouncedSearchRef = useRef(null);
-	const handleInputChange = useCallback(() => {
-		debouncedSearchRef.current ??= debounce$2(() => void latestRunSearchRef.current?.(), 100);
-		debouncedSearchRef.current();
-	}, []);
-	const handleBeforeInput = useCallback(() => {
-		const input = searchBoxRef.current;
-		if (input) {
-			if (!(input.selectionStart !== input.selectionEnd)) restoreCursor();
-		}
-	}, [restoreCursor]);
-	useEffect(() => {
-		const handleGlobalKeyDown = (e) => {
-			if (e.key === "F3") {
-				e.preventDefault();
-				handleSearch(e.shiftKey);
-				return;
-			}
-			if ((e.ctrlKey || e.metaKey) && e.key === "f") {
-				e.preventDefault();
-				e.stopPropagation();
-				searchBoxRef.current?.focus();
-				searchBoxRef.current?.select();
-				return;
-			}
-			if ((e.ctrlKey || e.metaKey) && e.key === "g") {
-				e.preventDefault();
-				e.stopPropagation();
-				handleSearch(e.shiftKey);
-				return;
-			}
-			if (e.ctrlKey || e.metaKey || e.altKey) return;
-			if (e.key.length !== 1 && e.key !== "Backspace" && e.key !== "Delete") return;
-			const input = searchBoxRef.current;
-			if (!input) return;
-			if (document.activeElement !== input) {
-				let active = document.activeElement;
-				while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement;
-				if (active instanceof HTMLInputElement || active instanceof HTMLTextAreaElement || active instanceof HTMLElement && active.isContentEditable) return;
-			}
-			if (!(input.selectionStart !== input.selectionEnd)) restoreCursor();
-			if (document.activeElement !== input) input.focus();
-		};
-		document.addEventListener("keydown", handleGlobalKeyDown, true);
-		return () => {
-			document.removeEventListener("keydown", handleGlobalKeyDown, true);
-		};
-	}, [handleSearch, restoreCursor]);
-	return /* @__PURE__ */ jsx(FindBandUI, {
-		inputRef: searchBoxRef,
-		onClose: storeHideFind,
-		onNext: findNext,
-		onPrevious: findPrevious,
-		onKeyDown: handleKeyDown,
-		onBeforeInput: handleBeforeInput,
-		onChange: handleInputChange,
-		noResults,
-		matchCount: matchCount ?? void 0,
-		matchIndex: matchCount !== null && matchCount > 0 ? currentMatchIndex - 1 : void 0
-	});
-};
-function windowFind(searchTerm, back) {
-	return window.find(searchTerm, findConfig.caseSensitive, back, findConfig.wrapAround, findConfig.wholeWord, findConfig.searchInFrames, findConfig.showDialog);
-}
-function positionSelectionForWrap(back) {
-	if (!back) return;
-	const sel = window.getSelection();
-	if (sel) {
-		const range = document.createRange();
-		range.selectNodeContents(document.body);
-		range.collapse(false);
-		sel.removeAllRanges();
-		sel.addRange(range);
-	}
-}
-async function findExtendedInDOM(searchTerm, back, lastFoundItem, extendedFindTerm) {
-	let result = false;
-	let hasTriedExtendedSearch = false;
-	let extendedSearchSucceeded = false;
-	const maxAttempts = 25;
-	for (let attempts = 0; attempts < maxAttempts; attempts++) {
-		result = windowFind(searchTerm, back);
-		if (result) {
-			const selection = window.getSelection();
-			if (selection && selection.rangeCount > 0) {
-				const range = selection.getRangeAt(0);
-				const isUnsearchable = inUnsearchableElement(range);
-				const isSameAsLast = isLastFoundItem(range, lastFoundItem);
-				if (!isUnsearchable && !isSameAsLast) break;
-				if (isSameAsLast) {
-					if (!hasTriedExtendedSearch) {
-						hasTriedExtendedSearch = true;
-						window.getSelection()?.removeAllRanges();
-						if (await extendedFindTerm(searchTerm, back ? "backward" : "forward")) {
-							extendedSearchSucceeded = true;
-							await waitForTextInDOM(searchTerm);
-							continue;
-						}
-					}
-					if (extendedSearchSucceeded) {
-						const sel = window.getSelection();
-						if (sel?.rangeCount) sel.getRangeAt(0).collapse(!back);
-					} else {
-						window.getSelection()?.removeAllRanges();
-						positionSelectionForWrap(back);
-					}
-					result = windowFind(searchTerm, back);
-					if (result) {
-						const sel = window.getSelection();
-						if (sel && sel.rangeCount > 0) {
-							if (inUnsearchableElement(sel.getRangeAt(0))) continue;
-						}
-					}
-					break;
-				}
-			}
-		} else if (!hasTriedExtendedSearch) {
-			hasTriedExtendedSearch = true;
-			window.getSelection()?.removeAllRanges();
-			if (await extendedFindTerm(searchTerm, back ? "backward" : "forward")) {
-				extendedSearchSucceeded = true;
-				await waitForTextInDOM(searchTerm);
-				continue;
-			}
-			positionSelectionForWrap(back);
-			result = windowFind(searchTerm, back);
-			if (result) {
-				const sel = window.getSelection();
-				if (sel && sel.rangeCount > 0) {
-					if (inUnsearchableElement(sel.getRangeAt(0))) continue;
-				}
-			}
-			break;
-		} else break;
-	}
-	if (result) {
-		const sel = window.getSelection();
-		if (sel?.rangeCount && inUnsearchableElement(sel.getRangeAt(0))) {
-			sel.removeAllRanges();
-			result = false;
-		}
-	}
-	return result;
-}
-function isLastFoundItem(range, lastFoundItem) {
-	if (!lastFoundItem) return false;
-	const currentText = range.toString();
-	const currentOffset = range.startOffset;
-	const currentParentElement = range.startContainer.parentElement || range.commonAncestorContainer;
-	return currentText === lastFoundItem.text && currentOffset === lastFoundItem.offset && currentParentElement === lastFoundItem.parentElement;
-}
-function inUnsearchableElement(range) {
-	let element = selectionParentElement(range);
-	let isUnsearchable = false;
-	while (element) {
-		if (element.hasAttribute("data-unsearchable") || getComputedStyle(element).userSelect === "none") {
-			isUnsearchable = true;
-			break;
-		}
-		element = element.parentElement;
-	}
-	return isUnsearchable;
-}
-function selectionParentElement(range) {
-	let element = null;
-	if (range.startContainer.nodeType === Node.ELEMENT_NODE) element = range.startContainer;
-	else element = range.startContainer.parentElement;
-	if (!element && range.commonAncestorContainer.nodeType === Node.ELEMENT_NODE) element = range.commonAncestorContainer;
-	else if (!element && range.commonAncestorContainer.parentElement) element = range.commonAncestorContainer.parentElement;
-	return element;
-}
-/**
-* Polls until the search term appears in a searchable (non-unsearchable) DOM
-* text node. After Virtuoso scrolls a virtual list item into view, the
-* onContentReady callback may fire before the content is actually rendered,
-* especially for large scroll distances. This ensures we wait for the text
-* to be present before calling window.find().
-*/
-function waitForTextInDOM(searchTerm, timeoutMs = 2e3) {
-	const lowerTerm = searchTerm.toLowerCase();
-	const isTextInSearchableDOM = () => {
-		const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT, { acceptNode: (node) => {
-			let el = node.parentElement;
-			while (el) {
-				if (el.hasAttribute("data-unsearchable")) return NodeFilter.FILTER_REJECT;
-				el = el.parentElement;
-			}
-			return NodeFilter.FILTER_ACCEPT;
-		} });
-		while (walker.nextNode()) if (walker.currentNode.textContent?.toLowerCase().includes(lowerTerm)) return true;
-		return false;
-	};
-	return new Promise((resolve) => {
-		const interval = 50;
-		let elapsed = 0;
-		const check = () => {
-			if (isTextInSearchableDOM()) {
-				resolve(true);
-				return;
-			}
-			elapsed += interval;
-			if (elapsed >= timeoutMs) {
-				resolve(false);
-				return;
-			}
-			setTimeout(check, interval);
-		};
-		check();
-	});
-}
 var InlineSampleDisplay_module_default = {
 	container: "_container_ly812_1",
 	scroller: "_scroller_ly812_7"
@@ -76134,6 +76834,184 @@ var MessageContents = ({ message, references }) => {
 		references
 	}) });
 };
+var AnnotatedScreenshot_module_default = {
+	container: "_container_nfqzf_1",
+	screenshot: "_screenshot_nfqzf_10",
+	overlay: "_overlay_nfqzf_16",
+	badge: "_badge_nfqzf_24",
+	type: "_type_nfqzf_39",
+	key: "_key_nfqzf_45"
+};
+//#endregion
+//#region ../../packages/inspect-components/src/chat/tools/browserActionUtils.ts
+/**
+* Tools whose actions can be annotated onto a screenshot. Membership requires
+* the tool's coordinate arguments to be in screenshot-pixel space and its
+* results to carry post-action screenshots (element-based browser tools like
+* web_browser_* don't qualify). The set plays two roles: it gates which calls
+* get a selfAnnotation, and the before-state scan in computeVisualActionContext
+* stops at the first tool call outside it — so adding a tool here also changes
+* which screenshots earlier actions may pair with.
+*/
+var BROWSER_TOOL_FUNCTIONS = /* @__PURE__ */ new Set(["browser", "computer"]);
+var CLICK_ACTIONS = /* @__PURE__ */ new Set([
+	"left_click",
+	"right_click",
+	"middle_click",
+	"double_click",
+	"triple_click"
+]);
+var VISUAL_BROWSER_ACTIONS = /* @__PURE__ */ new Set([
+	...CLICK_ACTIONS,
+	"scroll",
+	"type",
+	"key"
+]);
+function asString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function asCoordinate(value) {
+	if (Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && Number.isFinite(value[0]) && typeof value[1] === "number" && Number.isFinite(value[1])) return [value[0], value[1]];
+}
+/**
+* Narrows a tool call's arguments into a renderable annotation, or undefined
+* when the call is not a visual browser action (or its args are malformed).
+*/
+function buildSelfAnnotation(functionName, args) {
+	if (!BROWSER_TOOL_FUNCTIONS.has(functionName)) return void 0;
+	const action = asString(args.action);
+	if (action === void 0 || !VISUAL_BROWSER_ACTIONS.has(action)) return void 0;
+	return {
+		action,
+		coordinate: asCoordinate(args.coordinate),
+		text: asString(args.text),
+		scrollDirection: asString(args.scroll_direction)
+	};
+}
+//#endregion
+//#region ../../packages/inspect-components/src/chat/tools/AnnotatedScreenshot.tsx
+/**
+* Renders a tool result's content with the action annotation drawn over its
+* screenshot. Only the last renderable image is annotated: results may carry
+* text alongside the screenshot, and the last image reflects the page state
+* the action targeted.
+*/
+var AnnotatedScreenshotOutput = ({ contents, annotation, context }) => {
+	const annotatedIndex = contents.findLastIndex((c) => c.type === "image" && isRenderableImageSource(c.image));
+	return /* @__PURE__ */ jsx(Fragment$1, { children: contents.map((c, i) => i === annotatedIndex && c.type === "image" ? /* @__PURE__ */ jsx(AnnotatedScreenshot, {
+		src: c.image,
+		annotation
+	}, i) : /* @__PURE__ */ jsx(MessageContent, {
+		contents: [c],
+		context
+	}, i)) });
+};
+/**
+* A screenshot with the action annotation drawn on top. The SVG overlay's
+* viewBox is the image's natural size, so annotation coordinates (which are
+* in screenshot pixels) map to display position without any JS measurement,
+* and the overlay rescales with the image automatically.
+*/
+var AnnotatedScreenshot = ({ src, annotation }) => {
+	const [naturalSize, setNaturalSize] = useState();
+	return /* @__PURE__ */ jsxs("div", {
+		className: AnnotatedScreenshot_module_default.container,
+		children: [
+			/* @__PURE__ */ jsx("img", {
+				src,
+				className: AnnotatedScreenshot_module_default.screenshot,
+				onLoad: (e) => setNaturalSize({
+					width: e.currentTarget.naturalWidth,
+					height: e.currentTarget.naturalHeight
+				})
+			}),
+			naturalSize && naturalSize.width > 0 && naturalSize.height > 0 && /* @__PURE__ */ jsx("svg", {
+				viewBox: `0 0 ${naturalSize.width} ${naturalSize.height}`,
+				preserveAspectRatio: "none",
+				className: AnnotatedScreenshot_module_default.overlay,
+				children: renderSvgAnnotation(annotation)
+			}),
+			renderHtmlAnnotation(annotation)
+		]
+	});
+};
+function renderSvgAnnotation(annotation) {
+	const { action, coordinate } = annotation;
+	if (CLICK_ACTIONS.has(action) && coordinate) {
+		const [x, y] = coordinate;
+		return /* @__PURE__ */ jsxs("g", {
+			transform: `translate(${x}, ${y})`,
+			children: [/* @__PURE__ */ jsx("circle", {
+				cx: "0",
+				cy: "0",
+				r: "16",
+				stroke: "rgba(239,68,68,0.8)",
+				strokeWidth: "3",
+				fill: "none",
+				filter: "drop-shadow(0 0 6px rgba(239,68,68,0.4))"
+			}), /* @__PURE__ */ jsx("svg", {
+				viewBox: "0 0 32 32",
+				width: "30",
+				height: "30",
+				x: "-10",
+				y: "-7",
+				children: /* @__PURE__ */ jsxs("g", {
+					fill: "none",
+					fillRule: "evenodd",
+					transform: "translate(10 7)",
+					children: [/* @__PURE__ */ jsx("path", {
+						d: "m6.148 18.473 1.863-1.003 1.615-.839-2.568-4.816h4.332l-11.379-11.408v16.015l3.316-3.221z",
+						fill: "#fff"
+					}), /* @__PURE__ */ jsx("path", {
+						d: "m6.431 17 1.765-.941-2.775-5.202h3.604l-8.025-8.043v11.188l2.53-2.442z",
+						fill: "#000"
+					})]
+				})
+			})]
+		});
+	}
+	if (action === "scroll" && coordinate) {
+		const [x, y] = coordinate;
+		let arrow = "↕";
+		if (annotation.scrollDirection) {
+			const dir = annotation.scrollDirection.toLowerCase();
+			if (dir.includes("up")) arrow = "↑";
+			else if (dir.includes("down")) arrow = "↓";
+			else if (dir.includes("left")) arrow = "←";
+			else if (dir.includes("right")) arrow = "→";
+		}
+		return /* @__PURE__ */ jsxs("g", {
+			transform: `translate(${x}, ${y})`,
+			children: [/* @__PURE__ */ jsx("circle", {
+				cx: "0",
+				cy: "0",
+				r: "18",
+				fill: "rgba(59,130,246,0.8)"
+			}), /* @__PURE__ */ jsx("text", {
+				x: "0",
+				y: "0",
+				fill: "white",
+				fontSize: "20",
+				textAnchor: "middle",
+				dominantBaseline: "central",
+				fontWeight: "bold",
+				children: arrow
+			})]
+		});
+	}
+	return null;
+}
+function renderHtmlAnnotation(annotation) {
+	const { action, text } = annotation;
+	if (action === "type" || action === "key") {
+		const isKey = action === "key";
+		return /* @__PURE__ */ jsxs("div", {
+			className: clsx(AnnotatedScreenshot_module_default.badge, isKey ? AnnotatedScreenshot_module_default.key : AnnotatedScreenshot_module_default.type),
+			children: ["⌨ ", text || ""]
+		});
+	}
+	return null;
+}
 var customToolRendering_module_default = { submitView: "_submitView_1ru17_1" };
 var ToolSearchView_module_default = {
 	catalog: "_catalog_gx8eg_1",
@@ -76246,7 +77124,7 @@ var ToolCallView_module_default = { toolCallView: "_toolCallView_x6cus_1" };
 /**
 * Renders the ToolCallView component.
 */
-var ToolCallView = ({ id, tool, functionCall, input, description, contentType, view, output, mode, collapsible = true, section = "all", getCustomToolView }) => {
+var ToolCallView = ({ id, tool, functionCall, input, selfAnnotation, inputScreenshot, description, contentType, view, output, mode, collapsible = true, section = "all", getCustomToolView }) => {
 	const displayMode = useDisplayMode();
 	function isContentImage(value) {
 		if (value && typeof value === "object") {
@@ -76282,6 +77160,8 @@ var ToolCallView = ({ id, tool, functionCall, input, description, contentType, v
 		description,
 		contentType,
 		output,
+		selfAnnotation,
+		inputScreenshot,
 		mode
 	};
 	const customView = displayMode === "rendered" ? getCustomToolView?.(props) ?? getDefaultCustomToolView(props) : void 0;
@@ -76327,9 +77207,25 @@ var ToolCallView = ({ id, tool, functionCall, input, description, contentType, v
 		contents: normalizedContent,
 		context
 	}) : null;
+	const actionElement = selfAnnotation && inputScreenshot ? /* @__PURE__ */ jsx(AnnotatedScreenshotOutput, {
+		contents: inputScreenshot,
+		annotation: selfAnnotation,
+		context
+	}) : null;
+	let outputContent = outputSection;
+	if (actionElement) outputContent = hasContent ? /* @__PURE__ */ jsxs(NavPills, {
+		id: `${id}-browser-action`,
+		children: [/* @__PURE__ */ jsx("div", {
+			title: "Result",
+			children: outputSection
+		}), /* @__PURE__ */ jsx("div", {
+			title: "Action",
+			children: actionElement
+		})]
+	}) : actionElement;
 	return /* @__PURE__ */ jsxs("div", {
 		className: clsx(ToolCallView_module_default.toolCallView),
-		children: [section !== "output" ? callSection : null, section !== "call" ? outputSection : null]
+		children: [section !== "output" ? callSection : null, section !== "call" ? outputContent : null]
 	});
 };
 /**
@@ -76366,7 +77262,7 @@ var ClientToolCall_module_default = { custom: "_custom_v2cay_4" };
 * header (terminal icon · mono tool name · args summary), the input zone
 * (e.g. code) and the output well stacked beneath.
 */
-var ClientToolCall = ({ id, tool, title, functionCall, input, description, contentType, view, output, error, className, getCustomToolView }) => {
+var ClientToolCall = ({ id, tool, title, functionCall, input, description, contentType, view, output, selfAnnotation, inputScreenshot, error, className, getCustomToolView }) => {
 	const displayMode = useDisplayMode();
 	const viewProps = {
 		id,
@@ -76376,7 +77272,9 @@ var ClientToolCall = ({ id, tool, title, functionCall, input, description, conte
 		description,
 		contentType,
 		view,
-		output
+		output,
+		selfAnnotation,
+		inputScreenshot
 	};
 	const customView = displayMode === "rendered" ? getCustomToolView?.(viewProps) ?? getDefaultCustomToolView(viewProps) : void 0;
 	if (customView) return /* @__PURE__ */ jsx("div", {
@@ -76385,7 +77283,8 @@ var ClientToolCall = ({ id, tool, title, functionCall, input, description, conte
 	});
 	const hasInput = input !== void 0 && input !== null && input !== "" || !!view?.content;
 	const showError = !!error;
-	const showOutput = !showError && hasOutputContent(output);
+	const showAnnotation = !!selfAnnotation && !!inputScreenshot;
+	const showOutput = !showError && (hasOutputContent(output) || showAnnotation);
 	return /* @__PURE__ */ jsxs(ToolBlock, {
 		id,
 		icon: iconForTool(tool),
@@ -76403,7 +77302,11 @@ var ClientToolCall = ({ id, tool, title, functionCall, input, description, conte
 				contents: input,
 				toolCallView: view
 			})
-		}) }) : null, showError ? /* @__PURE__ */ jsx(ToolBlockOutput, { children: /* @__PURE__ */ jsx(ToolCallErrorView, { error }) }) : showOutput ? /* @__PURE__ */ jsx(ToolBlockOutput, { children: /* @__PURE__ */ jsx(ToolCallView, {
+		}) }) : null, showError ? /* @__PURE__ */ jsxs(ToolBlockOutput, { children: [/* @__PURE__ */ jsx(ToolCallErrorView, { error }), selfAnnotation && inputScreenshot ? /* @__PURE__ */ jsx(AnnotatedScreenshotOutput, {
+			contents: inputScreenshot,
+			annotation: selfAnnotation,
+			context: defaultContext()
+		}) : null] }) : showOutput ? /* @__PURE__ */ jsx(ToolBlockOutput, { children: /* @__PURE__ */ jsx(ToolCallView, {
 			...viewProps,
 			section: "output"
 		}) }) : null]
@@ -88412,7 +89315,9 @@ var ToolEventView = ({ eventNode, childNodes, className, context, eventCallbacks
 		description,
 		contentType,
 		output: event.result ?? "",
-		error: showError ? event.error : void 0,
+		selfAnnotation: context?.selfAnnotation,
+		inputScreenshot: context?.inputScreenshot,
+		error: showError && event.error ? event.error : void 0,
 		view: resolvedView
 	});
 	const toolLabel = toolLabels.messageLabels?.[event.id];
@@ -88517,6 +89422,40 @@ var TranscriptVirtualListComponent_module_default = {
 	runningTool: "_runningTool_t3xlr_31"
 };
 //#endregion
+//#region ../../packages/inspect-components/src/transcript/transcriptVisualActions.ts
+function computeVisualActionContext(eventNodes, index) {
+	const node = eventNodes[index];
+	if (!node || node.event.event !== "tool") return {};
+	const toolEvent = node.event;
+	const selfAnnotation = buildSelfAnnotation(toolEvent.function, toolEvent.arguments);
+	if (!selfAnnotation) return {};
+	for (let i = index - 1; i >= 0; i--) {
+		const candidate = eventNodes[i];
+		if (!candidate) continue;
+		if (candidate.depth > node.depth) continue;
+		if (candidate.depth < node.depth) break;
+		if (candidate.event.event !== "tool") continue;
+		const candEvent = candidate.event;
+		if (!BROWSER_TOOL_FUNCTIONS.has(candEvent.function)) break;
+		const inputScreenshot = normalizeScreenshotResult(candEvent.result);
+		if (inputScreenshot && inputScreenshot.some((c) => c.type === "image")) return {
+			inputScreenshot,
+			selfAnnotation
+		};
+	}
+	return {};
+}
+function normalizeScreenshotResult(result) {
+	if (Array.isArray(result)) {
+		const filtered = result.filter((item) => item.type !== "document");
+		return filtered.length > 0 ? filtered : void 0;
+	}
+	if (result && typeof result === "object" && "type" in result) {
+		if (result.type === "document") return void 0;
+		return [result];
+	}
+}
+//#endregion
 //#region ../../packages/inspect-components/src/transcript/TranscriptVirtualListComponent.tsx
 /**
 * Renders the Transcript component.
@@ -88541,10 +89480,13 @@ var TranscriptVirtualListComponent = ({ id, listHandle, eventNodes, scrollRef, r
 		for (const [i, node] of eventNodes.entries()) {
 			const hasToolEvents = hasToolEventsLookup[i] ?? false;
 			const turnInfo = turnMap?.get(node.id);
+			const { inputScreenshot, selfAnnotation } = computeVisualActionContext(eventNodes, i);
 			map.set(node.id, {
 				hasToolEvents,
 				turnInfo,
-				...eventNodeContext
+				...eventNodeContext,
+				inputScreenshot,
+				selfAnnotation
 			});
 		}
 		return map;
@@ -94712,8 +95654,9 @@ var TranscriptPanel = memo((props) => {
 		logFile,
 		logDir
 	]);
+	const getFullEventUrl = useCallback((eventId) => toFullUrlMaybe(getEventUrl(eventId)), [getEventUrl]);
 	const renderLink = useCallback((url, children) => /* @__PURE__ */ jsx(Link, {
-		to: url,
+		to: routeFromFullUrl(url),
 		replace: true,
 		children
 	}), []);
@@ -94751,8 +95694,8 @@ var TranscriptPanel = memo((props) => {
 		listId: id,
 		initialEventId,
 		initialMessageId,
-		getEventUrl,
-		linkingEnabled: true,
+		getEventUrl: getFullEventUrl,
+		linkingEnabled: isHostedEnvironment(),
 		bulkCollapse,
 		collapseState,
 		eventsListRef,
@@ -94857,14 +95800,7 @@ var SampleDisplay = ({ id, scrollRef, showActivity, focusOnLoad }) => {
 		navigate
 	]);
 	const setNativeFind = useStore((state) => state.appActions.setNativeFind);
-	const getMessageUrl = useCallback((messageId) => {
-		return urlLogPath ? sampleMessageUrl(sampleUrlBuilder, messageId, urlLogPath, urlSampleId, urlEpoch) : void 0;
-	}, [
-		sampleUrlBuilder,
-		urlLogPath,
-		urlSampleId,
-		urlEpoch
-	]);
+	const getMessageUrl = useFullSampleMessageUrlBuilder();
 	const chatDisplay = useMemo(() => ({
 		indented: true,
 		formatDateTime
@@ -95528,37 +96464,27 @@ var SampleDetailComponent = ({ sampleId, epoch, tabId, navigation, navbarConfig
 	useEffect(() => {
 		if (tabId) setSampleTab(tabId);
 	}, [tabId, setSampleTab]);
+	useFindBandShortcut(useCallback(() => setShowFind(true), [setShowFind]), {
+		onClose: hideFind,
+		isOpen: showFind,
+		enabled: !nativeFind
+	});
 	const handleKeyDown = useCallback((e) => {
-		let activeElement = document.activeElement;
-		while (activeElement?.shadowRoot?.activeElement) activeElement = activeElement.shadowRoot.activeElement;
-		const isInputFocused = activeElement && (activeElement.tagName === "INPUT" || activeElement.tagName === "TEXTAREA" || activeElement.tagName === "SELECT" || activeElement instanceof HTMLElement && activeElement.isContentEditable);
-		if ((e.ctrlKey || e.metaKey) && e.key === "f") {
-			if (!nativeFind) {
+		if (isEditableTarget(deepActiveElement())) return;
+		if (e.key === "ArrowLeft") {
+			if (hasPrevious) {
 				e.preventDefault();
-				e.stopPropagation();
-				setShowFind(true);
+				onPrevious();
 			}
-		} else if (e.key === "Escape") {
-			if (!nativeFind) hideFind();
-		} else if (!isInputFocused) {
-			if (e.key === "ArrowLeft") {
-				if (hasPrevious) {
-					e.preventDefault();
-					onPrevious();
-				}
-			} else if (e.key === "ArrowRight") {
-				if (hasNext) {
-					e.preventDefault();
-					onNext();
-				}
+		} else if (e.key === "ArrowRight") {
+			if (hasNext) {
+				e.preventDefault();
+				onNext();
 			}
 		}
 	}, [
-		setShowFind,
-		hideFind,
 		hasPrevious,
 		hasNext,
-		nativeFind,
 		onPrevious,
 		onNext
 	]);
@@ -95574,7 +96500,7 @@ var SampleDetailComponent = ({ sampleId, epoch, tabId, navigation, navbarConfig
 			action();
 		}
 	}, []);
-	return /* @__PURE__ */ jsx(ExtendedFindProvider, { children: /* @__PURE__ */ jsxs(FindTargetProvider, { children: [showFind ? /* @__PURE__ */ jsx(FindBand, {}) : "", /* @__PURE__ */ jsxs("div", {
+	return /* @__PURE__ */ jsx(ExtendedFindProvider, { children: /* @__PURE__ */ jsxs(FindTargetProvider, { children: [showFind ? /* @__PURE__ */ jsx(FindBand, { onClose: hideFind }) : "", /* @__PURE__ */ jsxs("div", {
 		className: SampleDetailComponent_module_default.detail,
 		children: [/* @__PURE__ */ jsx(ApplicationNavbar, {
 			currentPath,
@@ -120440,7 +121366,7 @@ var SampleFilter = () => {
 		activateOnCompletion: (c) => c.label.endsWith(" ")
 	}), [filterItems, samples]);
 	const makeLinter = useCallback(() => linter((view) => getLints(view, filterError)), [filterError]);
-	const debounceSetFilter = useMemo(() => debounce$2((value) => {
+	const debounceSetFilter = useMemo(() => debounce$3((value) => {
 		setFilter(value);
 	}, 200), [setFilter]);
 	const makeUpdateListener = useCallback(() => EditorView.updateListener.of((update) => {
@@ -120885,7 +121811,7 @@ var SamplesTab = ({ running, scrollRef, showColumnSelector, setShowColumnSelecto
 	const items = useMemo(() => {
 		if (!samplesDescriptor || !selectedLogFile) return [];
 		return sampleSummaries.map((sample) => {
-			const tokens = sample.model_usage ? Object.values(sample.model_usage).reduce((sum, u) => sum + (u.total_tokens ?? 0), 0) : void 0;
+			const tokens = totalSampleTokens(sample.model_usage);
 			return {
 				logFile: selectedLogFile,
 				sampleId: sample.id,
@@ -122592,30 +123518,17 @@ var LogViewLayout = () => {
 	const prefix = useRoutePrefix();
 	const navigationUrl = (file, log_dir) => logsUrl(file, log_dir, void 0, prefix);
 	const mainAppRef = useRef(null);
-	useEffect(() => {
-		if (nativeFind) return;
-		const handleGlobalKeyDown = (e) => {
-			if ((e.ctrlKey || e.metaKey) && e.key === "f") {
-				e.preventDefault();
-				e.stopPropagation();
-				if (setShowFind) setShowFind(true);
-			} else if (e.key === "Escape") hideFind();
-		};
-		document.addEventListener("keydown", handleGlobalKeyDown, true);
-		return () => {
-			document.removeEventListener("keydown", handleGlobalKeyDown, true);
-		};
-	}, [
-		setShowFind,
-		hideFind,
-		nativeFind
-	]);
+	useFindBandShortcut(useCallback(() => setShowFind(true), [setShowFind]), {
+		onClose: hideFind,
+		isOpen: showFind,
+		enabled: !nativeFind
+	});
 	return /* @__PURE__ */ jsx(ExtendedFindProvider, { children: /* @__PURE__ */ jsx(FindTargetProvider, { children: /* @__PURE__ */ jsxs("div", {
 		ref: mainAppRef,
 		className: clsx("app-main-grid", singleFileMode ? "single-file-mode" : void 0, "log-view"),
 		tabIndex: 0,
 		children: [
-			showFind ? /* @__PURE__ */ jsx(FindBand, {}) : "",
+			showFind ? /* @__PURE__ */ jsx(FindBand, { onClose: hideFind }) : "",
 			!singleFileMode ? /* @__PURE__ */ jsx(ApplicationNavbar, {
 				fnNavigationUrl: navigationUrl,
 				currentPath: logPath
@@ -123213,7 +124126,7 @@ var SamplesPanel = () => {
 	const currentDirLogFiles = useMemo(() => {
 		const files = [];
 		for (const logFile of logFiles) {
-			const inCurrentDir = logFile.name.startsWith(currentDir);
+			const inCurrentDir = logFile.name.startsWith(scopePrefix(currentDir));
 			const skipped = !showRetriedLogs && logFile.retried;
 			if (inCurrentDir && !skipped) files.push(logFile);
 		}
@@ -123324,8 +124237,7 @@ var SamplesPanel = () => {
 			acc[log.name] = log;
 			return acc;
 		}, {});
-		const allRows = scopedSamples.map(({ logFile, summary: sample, log }) => {
-			const tokens = sample.model_usage ? Object.values(sample.model_usage).reduce((sum, u) => sum + (u.total_tokens ?? 0), 0) : void 0;
+		const allRows = scopedSamples.map(({ logFile, summary: sample, derived, log }) => {
 			const row = {
 				logFile,
 				sampleId: sample.id,
@@ -123335,17 +124247,17 @@ var SamplesPanel = () => {
 				task: log.task || "",
 				model: log.model || "",
 				status: log.status,
-				input: inputString(sample.input).join("\n"),
-				target: Array.isArray(sample.target) ? sample.target.join(", ") : sample.target,
+				input: derived.input,
+				target: derived.target,
 				error: sample.error,
 				limit: sample.limit,
 				retries: sample.retries,
-				fallbacks: totalModelFallbacks(sample.model_fallbacks) || void 0,
+				fallbacks: derived.fallbacks,
 				completed: sample.completed,
-				tokens,
+				tokens: derived.tokens,
 				duration: sample.total_time ?? void 0
 			};
-			if (sample.scores) for (const [scoreName, score] of Object.entries(sample.scores)) row[`${SCORE_FIELD_RAW_PREFIX}${scoreName}`] = score.value;
+			if (derived.scores) for (const [scoreName, value] of Object.entries(derived.scores)) row[`${SCORE_FIELD_RAW_PREFIX}${scoreName}`] = value;
 			return row;
 		});
 		const _sampleRows = allRows.filter((row) => row.logFile in logInCurrentDirByName);
@@ -123570,6 +124482,8 @@ var AppRouter = createHashRouter([{
 //#endregion
 //#region src/app/App.tsx
 var componentIcons = {
+	arrowDown: ApplicationIcons.arrows.down,
+	arrowUp: ApplicationIcons.arrows.up,
 	chevronDown: ApplicationIcons.chevron.down,
 	chevronUp: ApplicationIcons.collapse.up,
 	clearText: ApplicationIcons["clear-text"],