@modelcontextprotocol/inspector 2.13.0 → 2.14.0

package/clients/mcpdo/build/{server-BHuKGkMj.js → server-Dv339Ejx.js}

@@ -28,7 +28,10 @@ import { DispatchError, JsonRpcResponseError, TaskFailedError, createApplication
 import { bindTaskReceiver } from "@modelcontextprotocol/ext-tasks/receiver";
 import { runtimeCodecFromStandardSchema, taskId, toJsonValue } from "@modelcontextprotocol/ext-tasks/core";
 import { TASKS_EXTENSION_ID_V2 as TASKS_EXTENSION_KEY } from "@modelcontextprotocol/ext-tasks/core/v2";
-import { AjvJsonSchemaValidator } from "@modelcontextprotocol/client/validators/ajv";
+import Ajv from "ajv";
+import { Ajv2019 } from "ajv/dist/2019.js";
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { addFormats } from "@modelcontextprotocol/client/validators/ajv";
 import { createServer } from "node:http";
 import open from "open";
 import { createInterface as createInterface$1 } from "node:readline/promises";
@@ -4511,7 +4514,8 @@ const EXIT_CODES = {
 	SKILL_INCOMPLETE: 8,
 	SKILL_UNVERIFIABLE: 9,
 	LOAD_THRESHOLD_EXCEEDED: 10,
-	RATE_LIMITED: 11
+	RATE_LIMITED: 11,
+	INTERRUPTED: 130
 };
 function rateLimitFieldsOf(error) {
 	const data = error?.data;
@@ -6171,6 +6175,14 @@ function expectedSecretFields(stored) {
 	if (isStdioStored(stored) && stored.env) for (const k of Object.keys(stored.env)) fields.push(envSecretField(k));
 	return fields;
 }
+function adHocServerName(config) {
+	if (config.type === "sse" || config.type === "streamable-http") try {
+		return new URL(config.url).host || "server";
+	} catch {
+		return "server";
+	}
+	return config.command?.split(/[\\/]/).pop() || "server";
+}
 //#endregion
 //#region ../../core/mcp/node/config.ts
 function parseKeyValuePair(value, previous = {}) {
@@ -6436,8 +6448,9 @@ async function loadServerEntries(serverOptions) {
 	}
 	const configs = resolveServerConfigs(serverOptions, "multi");
 	if (configs.length === 0) throw new Error("At least one server is required. Use --catalog/--config <path> or an ad-hoc target (command/URL).");
-	return { default: {
-		config: configs[0],
+	const config = configs[0];
+	return { [adHocServerName(config)]: {
+		config,
 		settings: mergeSettings(void 0, serverOptions)
 	} };
 }
@@ -6986,6 +6999,13 @@ function readInspectorVersion(callerUrl) {
 	}
 	throw new Error(`Could not locate the ${ROOT_PACKAGE_NAME} root package.json above ${startDir}`);
 }
+function readInspectorVersionSafe(callerUrl) {
+	try {
+		return readInspectorVersion(callerUrl);
+	} catch {
+		return;
+	}
+}
 //#endregion
 //#region src/daemon/paths.ts
 const DAEMON_DIR_ENV = "MCP_INSPECTOR_DAEMON_DIR";
@@ -8439,6 +8459,7 @@ function resolveLoadOptions(flags) {
 	};
 }
 const OTHER_ERRORS = "(other)";
+const NO_TOOL_ERROR_TEXT = "(no text content)";
 const yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
 const realClock = {
 	now: () => performance.now(),
@@ -8508,10 +8529,45 @@ var ErrorTally = class {
 		return list;
 	}
 };
+function isLoadStop(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const { reason, detail } = value;
+	return (reason === "interrupted" || reason === "connection_lost" || reason === "consecutive_errors") && typeof detail === "string";
+}
+function toolErrorText(content) {
+	const blocks = Array.isArray(content) ? content : [];
+	for (const block of blocks) {
+		if (typeof block !== "object" || block === null) continue;
+		const { type, text } = block;
+		if (type !== "text" || typeof text !== "string") continue;
+		const trimmed = text.trim();
+		if (trimmed === "") continue;
+		return trimmed.length > 200 ? `${trimmed.slice(0, 200)}…` : trimmed;
+	}
+	return NO_TOOL_ERROR_TEXT;
+}
+const LOAD_FLAG_CONFLICT = "load_flag_conflict";
+function loadSummaryWarnings(summary) {
+	const warnings = [];
+	const stop = summary.stoppedEarly;
+	if (stop !== void 0 && stop.reason !== "interrupted") warnings.push(`Warning: the load run stopped early (${stop.reason}): ${stop.detail}.`);
+	const shortfall = loadRateShortfallWarning(summary);
+	if (shortfall !== void 0) warnings.push(shortfall);
+	return warnings;
+}
+function loadRateShortfallWarning(summary) {
+	const { rate, achievedRate, plannedStarts, droppedSlots } = summary;
+	if (rate === void 0 || plannedStarts === void 0 || droppedSlots === void 0 || plannedStarts === 0) return;
+	const started = plannedStarts - droppedSlots;
+	if (started >= plannedStarts * .9) return void 0;
+	return `Warning: --load-rate ${rate}/s was not reached: ${started} of ${plannedStarts} planned calls started (${achievedRate}/s); ${droppedSlots} slots were dropped because every worker was busy. Raise --load-concurrency or lower --load-rate.`;
+}
 async function runLoad(call, options, clock = realClock, signal) {
 	const { concurrency, durationMs, requests, rate } = options;
-	const latencies = [];
+	const okLatencies = [];
+	const errorLatencies = [];
 	const tally = new ErrorTally();
+	const toolTally = new ErrorTally();
 	let ok = 0;
 	let toolErrors = 0;
 	let errors = 0;
@@ -8520,6 +8576,37 @@ async function runLoad(call, options, clock = realClock, signal) {
 	const deadline = durationMs === void 0 ? Infinity : start + durationMs;
 	const interval = rate === void 0 ? 0 : 1e3 / rate;
 	let nextStart = start;
+	const halt = new AbortController();
+	let stoppedEarly;
+	let stoppedAt = 0;
+	const stopRun = (stop) => {
+		if (stoppedEarly) {
+			if (stop.reason === "interrupted") stoppedEarly = stop;
+			return;
+		}
+		stoppedEarly = stop;
+		stoppedAt = clock.now();
+		halt.abort();
+	};
+	const onAbort = () => {
+		const reason = signal?.reason;
+		stopRun(isLoadStop(reason) ? reason : {
+			reason: "interrupted",
+			detail: "the run was interrupted"
+		});
+	};
+	if (signal?.aborted) onAbort();
+	else signal?.addEventListener("abort", onAbort, { once: true });
+	let errorStreak = 0;
+	let streakSince = 0;
+	const noteThrown = (now) => {
+		if (errorStreak++ === 0) streakSince = now;
+		const window = now - streakSince;
+		if ((requests === void 0 || started < requests) && now < deadline && nextStart < deadline && (errorStreak >= 50 || errorStreak >= 5 && window >= 1e3)) stopRun({
+			reason: "consecutive_errors",
+			detail: `${errorStreak} calls in a row threw over ${round(window)}ms; the server looks unavailable`
+		});
+	};
 	let turnstile = Promise.resolve();
 	const claimSlot = async () => {
 		const ahead = turnstile;
@@ -8529,7 +8616,7 @@ async function runLoad(call, options, clock = realClock, signal) {
 		try {
 			if (started > 0 && started % 64 === 0) await yieldToEventLoop();
 			for (;;) {
-				if (signal?.aborted) return false;
+				if (halt.signal.aborted) return false;
 				if (requests !== void 0 && started >= requests) return false;
 				const now = clock.now();
 				if (now >= deadline) return false;
@@ -8540,7 +8627,7 @@ async function runLoad(call, options, clock = realClock, signal) {
 					nextStart = now - nextStart < interval ? nextStart + interval : now + interval;
 					return true;
 				}
-				await sleepUnlessAborted(clock, scheduled - now, signal);
+				await sleepUnlessAborted(clock, scheduled - now, halt.signal);
 			}
 		} finally {
 			release();
@@ -8548,26 +8635,57 @@ async function runLoad(call, options, clock = realClock, signal) {
 	};
 	const worker = async (index) => {
 		while (await claimSlot()) {
-			if (signal?.aborted) return;
+			if (halt.signal.aborted) {
+				started--;
+				return;
+			}
 			const t0 = clock.now();
 			try {
-				if (await call(index) === "ok") ok++;
-				else toolErrors++;
+				const outcome = await call(index);
+				const latency = clock.now() - t0;
+				errorStreak = 0;
+				if (outcome === "ok") {
+					ok++;
+					okLatencies.push(latency);
+				} else {
+					toolErrors++;
+					errorLatencies.push(latency);
+					toolTally.add(typeof outcome === "object" ? outcome.message : NO_TOOL_ERROR_TEXT);
+				}
 			} catch (err) {
+				const now = clock.now();
 				errors++;
+				errorLatencies.push(now - t0);
 				tally.add(err instanceof Error ? err.message : String(err));
+				noteThrown(now);
 			}
-			latencies.push(clock.now() - t0);
 		}
 	};
-	await Promise.all(Array.from({ length: concurrency }, (_, i) => worker(i)));
-	const elapsedMs = clock.now() - start;
+	try {
+		await Promise.all(Array.from({ length: concurrency }, (_, i) => worker(i)));
+	} finally {
+		signal?.removeEventListener("abort", onAbort);
+	}
+	const end = clock.now();
+	const requestCapped = requests !== void 0 && started >= requests;
+	const elapsedMs = durationMs !== void 0 && stoppedEarly === void 0 && !requestCapped ? Math.max(end - start, durationMs) : end - start;
 	const completed = ok + toolErrors + errors;
+	const startWindowEnd = () => {
+		let windowEnd = deadline;
+		if (requestCapped) windowEnd = Math.min(windowEnd, nextStart);
+		if (stoppedEarly !== void 0) windowEnd = Math.min(windowEnd, stoppedAt);
+		/* v8 ignore next -- defensive: a run with no duration, no request cap
+		and no stop never ends, so one of the three always applies. */
+		return Number.isFinite(windowEnd) ? windowEnd : end;
+	};
 	return {
 		concurrency,
 		...durationMs !== void 0 && { durationMs },
 		...requests !== void 0 && { requestLimit: requests },
-		...rate !== void 0 && { rate },
+		...rate !== void 0 && rateFigures(rate, {
+			started,
+			windowMs: startWindowEnd() - start
+		}),
 		requests: completed,
 		ok,
 		toolErrors,
@@ -8575,8 +8693,23 @@ async function runLoad(call, options, clock = realClock, signal) {
 		errorRate: completed === 0 ? 0 : round((toolErrors + errors) / completed, 4),
 		elapsedMs: round(elapsedMs),
 		throughput: elapsedMs > 0 ? round(completed * 1e3 / elapsedMs) : 0,
-		latencyMs: summarizeLatency(latencies),
-		errorMessages: tally.entries()
+		okThroughput: elapsedMs > 0 ? round(ok * 1e3 / elapsedMs) : 0,
+		latencyMs: summarizeLatency(okLatencies),
+		errorLatencyMs: summarizeLatency(errorLatencies),
+		errorMessages: tally.entries(),
+		toolErrorMessages: toolTally.entries(),
+		...stoppedEarly !== void 0 && { stoppedEarly }
+	};
+}
+function rateFigures(rate, run) {
+	const { started, windowMs } = run;
+	const slots = Math.ceil(windowMs * rate / 1e3 - 1e-9);
+	const plannedStarts = Math.max(started, slots);
+	return {
+		rate,
+		plannedStarts,
+		droppedSlots: plannedStarts - started,
+		achievedRate: windowMs > 0 ? round(started * 1e3 / windowMs) : 0
 	};
 }
 async function runLoadAcrossConnections(primary, openConnection, callOn, options, clock = realClock, signal) {
@@ -8638,7 +8771,11 @@ async function runToolLoad(inspectorClient, args, options, extra = {}) {
 		/* v8 ignore next 3 -- defensive: `ToolCallInvocation.result` is nullable,
 		but both call paths throw on failure rather than return a null result. */
 		if (invocation.result === null) throw new Error(invocation.error ?? "Tool call failed");
-		return invocation.result.isError === true ? "tool_error" : "ok";
+		if (invocation.result.isError !== true) return "ok";
+		return {
+			outcome: "tool_error",
+			message: toolErrorText(invocation.result.content)
+		};
 	};
 	const summary = await runLoadAcrossConnections(inspectorClient, extra.openConnection, call, options, extra.clock, extra.signal);
 	return {
@@ -9855,6 +9992,627 @@ function validateToolOutput(provider, tool, result) {
 	}
 }
 //#endregion
+//#region ../../core/json/linearRegExp.ts
+var CharMatcher = class {
+	re;
+	ascii = /* @__PURE__ */ new Uint8Array(128);
+	constructor(source, unicode) {
+		this.re = new RegExp(`^(?:${source})$`, unicode ? "u" : "");
+	}
+	matches(cp, unicode) {
+		if (cp < 128) {
+			const memo = this.ascii[cp];
+			if (memo !== 0) return memo === 1;
+			const result = this.re.test(String.fromCharCode(cp));
+			this.ascii[cp] = result ? 1 : 2;
+			return result;
+		}
+		return this.re.test(unicode ? String.fromCodePoint(cp) : String.fromCharCode(cp));
+	}
+};
+var Unsupported = class extends Error {};
+const MAX_GROUP_DEPTH = 64;
+const MAX_PROGRAM_SIZE = 1e4;
+const MAX_COMPILE_STEPS = 10 * MAX_PROGRAM_SIZE;
+const MAX_PATTERN_LENGTH = 8192;
+const COMPILE_BUDGET_EXHAUSTED = "the patterns together exceed the compilation budget";
+function isCompileBudgetExhausted(budget) {
+	return budget.steps < 0 || budget.size < 0;
+}
+const QUANTIFIER_BRACES = /\{(\d+)(?:(,)(\d*))?\}/y;
+const HEX4 = /^[0-9a-fA-F]{4}$/;
+const HEX2 = /^[0-9a-fA-F]{2}$/;
+var Parser = class {
+	pos = 0;
+	src;
+	unicode;
+	constructor(src, unicode) {
+		this.src = src;
+		this.unicode = unicode;
+	}
+	parse() {
+		const node = this.parseAlternation(0);
+		/* v8 ignore next -- the native RegExp constructor rejects an unbalanced `)` first */
+		if (this.pos !== this.src.length) throw new Unsupported("unbalanced group");
+		return node;
+	}
+	parseAlternation(depth) {
+		const options = [this.parseSequence(depth)];
+		while (this.src[this.pos] === "|") {
+			this.pos++;
+			options.push(this.parseSequence(depth));
+		}
+		return options.length === 1 ? options[0] : {
+			kind: "alt",
+			options
+		};
+	}
+	parseSequence(depth) {
+		const items = [];
+		while (this.pos < this.src.length && this.src[this.pos] !== "|" && this.src[this.pos] !== ")") items.push(this.parseTerm(depth));
+		return items.length === 1 ? items[0] : {
+			kind: "seq",
+			items
+		};
+	}
+	parseTerm(depth) {
+		const atom = this.parseAtom(depth);
+		const quantifier = this.readQuantifier();
+		if (!quantifier) return atom;
+		if (this.src[this.pos] === "?") this.pos++;
+		return {
+			kind: "repeat",
+			body: atom,
+			...quantifier
+		};
+	}
+	readQuantifier() {
+		const c = this.src[this.pos];
+		if (c === "*") {
+			this.pos++;
+			return {
+				min: 0,
+				max: Infinity
+			};
+		}
+		if (c === "+") {
+			this.pos++;
+			return {
+				min: 1,
+				max: Infinity
+			};
+		}
+		if (c === "?") {
+			this.pos++;
+			return {
+				min: 0,
+				max: 1
+			};
+		}
+		if (c === "{") {
+			QUANTIFIER_BRACES.lastIndex = this.pos;
+			const m = QUANTIFIER_BRACES.exec(this.src);
+			if (!m) return void 0;
+			this.pos += m[0].length;
+			const min = Number(m[1]);
+			return {
+				min,
+				max: m[2] === void 0 ? min : m[3] ? Number(m[3]) : Infinity
+			};
+		}
+	}
+	parseAtom(depth) {
+		switch (this.src[this.pos]) {
+			case "(": return this.parseGroup(depth);
+			case "[": return this.parseClass();
+			case "\\": return this.parseEscape();
+			case ".":
+				this.pos++;
+				return {
+					kind: "char",
+					source: "."
+				};
+			case "^":
+				this.pos++;
+				return {
+					kind: "assert",
+					assertion: "start"
+				};
+			case "$":
+				this.pos++;
+				return {
+					kind: "assert",
+					assertion: "end"
+				};
+			case "*":
+			case "+":
+			case "?":
+ /* v8 ignore next -- "nothing to repeat" is a native syntax error */
+			throw new Unsupported("nothing to repeat");
+			case "{":
+				QUANTIFIER_BRACES.lastIndex = this.pos;
+				if (QUANTIFIER_BRACES.test(this.src))
+ /* v8 ignore next -- rejected by the native RegExp constructor first */
+				throw new Unsupported("nothing to repeat");
+				this.pos++;
+				return {
+					kind: "char",
+					source: "\\{"
+				};
+			default: {
+				const width = this.codePointWidth(this.pos);
+				const source = this.src.slice(this.pos, this.pos + width);
+				this.pos += width;
+				return {
+					kind: "char",
+					source
+				};
+			}
+		}
+	}
+	codePointWidth(at) {
+		if (!this.unicode) return 1;
+		return this.src.codePointAt(at) > 65535 ? 2 : 1;
+	}
+	parseGroup(depth) {
+		if (depth >= MAX_GROUP_DEPTH) throw new Unsupported("groups nested too deeply");
+		this.pos++;
+		if (this.src.startsWith("?:", this.pos)) this.pos += 2;
+		else if (this.src.startsWith("?<", this.pos) && this.src[this.pos + 2] !== "=" && this.src[this.pos + 2] !== "!") {
+			const close = this.src.indexOf(">", this.pos);
+			/* v8 ignore next -- an unterminated group name is a native syntax error */
+			if (close < 0) throw new Unsupported("unterminated group name");
+			this.pos = close + 1;
+		} else if (this.src[this.pos] === "?") throw new Unsupported("lookaround or group modifier");
+		const body = this.parseAlternation(depth + 1);
+		/* v8 ignore next -- an unterminated group is a native syntax error */
+		if (this.src[this.pos] !== ")") throw new Unsupported("unterminated group");
+		this.pos++;
+		return body;
+	}
+	parseClass() {
+		const start = this.pos;
+		this.pos++;
+		while (this.pos < this.src.length && this.src[this.pos] !== "]") this.pos += this.src[this.pos] === "\\" ? 2 : 1;
+		/* v8 ignore next -- an unterminated class is a native syntax error */
+		if (this.pos >= this.src.length) throw new Unsupported("unterminated class");
+		this.pos++;
+		return {
+			kind: "char",
+			source: this.src.slice(start, this.pos)
+		};
+	}
+	parseEscape() {
+		const next = this.src[this.pos + 1];
+		/* v8 ignore next -- a trailing backslash is a native syntax error */
+		if (next === void 0) throw new Unsupported("trailing backslash");
+		switch (next) {
+			case "b":
+				this.pos += 2;
+				return {
+					kind: "assert",
+					assertion: "wordBoundary"
+				};
+			case "B":
+				this.pos += 2;
+				return {
+					kind: "assert",
+					assertion: "notWordBoundary"
+				};
+			case "1":
+			case "2":
+			case "3":
+			case "4":
+			case "5":
+			case "6":
+			case "7":
+			case "8":
+			case "9":
+			case "k": throw new Unsupported("backreference");
+			case "0":
+				if (/[0-9]/.test(this.src[this.pos + 2] ?? "")) throw new Unsupported("octal escape");
+				return this.takeChar(2);
+			case "c":
+				if (!/[a-zA-Z]/.test(this.src[this.pos + 2] ?? "")) throw new Unsupported("incomplete control escape");
+				return this.takeChar(3);
+			case "p":
+			case "P":
+				if (this.unicode && this.src[this.pos + 2] === "{") return this.takeThrough("}");
+				return this.takeChar(2);
+			case "x": return this.takeChar(HEX2.test(this.src.slice(this.pos + 2, this.pos + 4)) ? 4 : 2);
+			case "u": return this.parseUnicodeEscape();
+			default: return this.takeChar(1 + this.codePointWidth(this.pos + 1));
+		}
+	}
+	parseUnicodeEscape() {
+		if (this.unicode && this.src[this.pos + 2] === "{") return this.takeThrough("}");
+		const hex = this.src.slice(this.pos + 2, this.pos + 6);
+		if (!HEX4.test(hex)) return this.takeChar(2);
+		const unit = parseInt(hex, 16);
+		if (this.unicode && unit >= 55296 && unit <= 56319 && this.src.startsWith("\\u", this.pos + 6)) {
+			const low = this.src.slice(this.pos + 8, this.pos + 12);
+			if (HEX4.test(low)) {
+				const lowUnit = parseInt(low, 16);
+				if (lowUnit >= 56320 && lowUnit <= 57343) return this.takeChar(12);
+			}
+		}
+		return this.takeChar(6);
+	}
+	takeChar(length) {
+		const source = this.src.slice(this.pos, this.pos + length);
+		this.pos += length;
+		return {
+			kind: "char",
+			source
+		};
+	}
+	takeThrough(terminator) {
+		const end = this.src.indexOf(terminator, this.pos);
+		/* v8 ignore next -- an unterminated `\p{` / `\u{` is a native syntax error */
+		if (end < 0) throw new Unsupported("unterminated escape");
+		return this.takeChar(end + 1 - this.pos);
+	}
+};
+var Compiler = class {
+	prog = [];
+	matchers = /* @__PURE__ */ new Map();
+	unicode;
+	budget;
+	steps = 0;
+	constructor(unicode, budget) {
+		this.unicode = unicode;
+		this.budget = budget;
+	}
+	emit(inst) {
+		if (this.prog.length >= 1e4) throw new Unsupported("pattern too complex");
+		if (this.budget && --this.budget.size < 0) throw new Unsupported(COMPILE_BUDGET_EXHAUSTED);
+		this.prog.push(inst);
+		return this.prog.length - 1;
+	}
+	matcher(source) {
+		let matcher = this.matchers.get(source);
+		if (!matcher) {
+			try {
+				matcher = new CharMatcher(source, this.unicode);
+			} catch {
+				/* v8 ignore start -- defensive: each atom is a slice the native constructor already accepted in context */
+				throw new Unsupported("unrecognized character syntax");
+			}
+			this.matchers.set(source, matcher);
+		}
+		return matcher;
+	}
+	compile(node) {
+		if (++this.steps > 1e5) throw new Unsupported("pattern too complex");
+		if (this.budget && --this.budget.steps < 0) throw new Unsupported(COMPILE_BUDGET_EXHAUSTED);
+		switch (node.kind) {
+			case "char":
+				this.emit({
+					op: "char",
+					matcher: this.matcher(node.source)
+				});
+				return;
+			case "assert":
+				this.emit({
+					op: "assert",
+					assertion: node.assertion
+				});
+				return;
+			case "seq":
+				for (const item of node.items) this.compile(item);
+				return;
+			case "alt":
+				this.compileAlternation(node.options);
+				return;
+			case "repeat":
+				this.compileRepeat(node.body, node.min, node.max);
+				return;
+		}
+	}
+	compileAlternation(options) {
+		const jumps = [];
+		for (let i = 0; i < options.length - 1; i++) {
+			const split = this.emit({
+				op: "split",
+				a: 0,
+				b: 0
+			});
+			this.patchSplit(split, split + 1, -1);
+			this.compile(options[i]);
+			jumps.push(this.emit({
+				op: "jmp",
+				to: 0
+			}));
+			this.patchSplit(split, -1, this.prog.length);
+		}
+		this.compile(options[options.length - 1]);
+		for (const jump of jumps) this.patchJump(jump, this.prog.length);
+	}
+	compileRepeat(body, min, max) {
+		for (let i = 0; i < min; i++) {
+			const before = this.prog.length;
+			this.compile(body);
+			if (this.prog.length === before) return;
+		}
+		if (max === Infinity) {
+			const split = this.emit({
+				op: "split",
+				a: 0,
+				b: 0
+			});
+			this.compile(body);
+			this.emit({
+				op: "jmp",
+				to: split
+			});
+			this.patchSplit(split, split + 1, this.prog.length);
+			return;
+		}
+		const splits = [];
+		for (let i = min; i < max; i++) {
+			const split = this.emit({
+				op: "split",
+				a: 0,
+				b: 0
+			});
+			this.patchSplit(split, split + 1, -1);
+			splits.push(split);
+			this.compile(body);
+		}
+		for (const split of splits) this.patchSplit(split, -1, this.prog.length);
+	}
+	patchSplit(at, a, b) {
+		const inst = this.prog[at];
+		if (a >= 0) inst.a = a;
+		if (b >= 0) inst.b = b;
+	}
+	patchJump(at, to) {
+		this.prog[at].to = to;
+	}
+};
+function isWordUnit(unit) {
+	return unit >= 48 && unit <= 57 || unit >= 65 && unit <= 90 || unit >= 97 && unit <= 122 || unit === 95;
+}
+var LinearRegExp = class {
+	anchoredStart;
+	prog;
+	unicode;
+	constructor(prog, unicode) {
+		this.prog = prog;
+		this.unicode = unicode;
+		const first = prog[0];
+		this.anchoredStart = first !== void 0 && first.op === "assert" && first.assertion === "start";
+	}
+	get size() {
+		return this.prog.length;
+	}
+	cost(input) {
+		return (input.length + 1) * this.prog.length;
+	}
+	search(input, budget) {
+		if (this.cost(input) > budget) return void 0;
+		const prog = this.prog;
+		const size = prog.length;
+		const mark = new Int32Array(size).fill(-1);
+		const stack = [];
+		let clist = new Int32Array(size);
+		let nlist = new Int32Array(size);
+		const add = (list, count, start, pos, generation) => {
+			stack.push(start);
+			while (stack.length > 0) {
+				const pc = stack.pop();
+				if (mark[pc] === generation) continue;
+				mark[pc] = generation;
+				const inst = prog[pc];
+				switch (inst.op) {
+					case "match":
+						stack.length = 0;
+						return -1;
+					case "jmp":
+						stack.push(inst.to);
+						break;
+					case "split":
+						stack.push(inst.b, inst.a);
+						break;
+					case "assert":
+						if (this.holds(inst.assertion, input, pos)) stack.push(pc + 1);
+						break;
+					case "char": list[count++] = pc;
+				}
+			}
+			return count;
+		};
+		let pos = 0;
+		let generation = 0;
+		let clen = add(clist, 0, 0, pos, generation);
+		if (clen < 0) return true;
+		while (pos < input.length) {
+			if (this.anchoredStart && clen === 0) return false;
+			const cp = this.unicode ? input.codePointAt(pos) : input.charCodeAt(pos);
+			const next = pos + (this.unicode && cp > 65535 ? 2 : 1);
+			generation++;
+			let nlen = 0;
+			for (let i = 0; i < clen; i++) {
+				const pc = clist[i];
+				if (prog[pc].matcher.matches(cp, this.unicode)) {
+					nlen = add(nlist, nlen, pc + 1, next, generation);
+					if (nlen < 0) return true;
+				}
+			}
+			nlen = add(nlist, nlen, 0, next, generation);
+			if (nlen < 0) return true;
+			[clist, nlist] = [nlist, clist];
+			clen = nlen;
+			pos = next;
+		}
+		return false;
+	}
+	holds(assertion, input, pos) {
+		switch (assertion) {
+			case "start": return pos === 0;
+			case "end": return pos === input.length;
+			case "wordBoundary":
+			case "notWordBoundary": return (pos > 0 && isWordUnit(input.charCodeAt(pos - 1))) !== (pos < input.length && isWordUnit(input.charCodeAt(pos))) === (assertion === "wordBoundary");
+		}
+	}
+};
+function compileLinearRegExp(pattern, unicode, budget) {
+	if (pattern.length > 8192) return {
+		ok: false,
+		reason: `pattern longer than ${MAX_PATTERN_LENGTH} characters`
+	};
+	if (budget) {
+		budget.steps -= pattern.length;
+		if (isCompileBudgetExhausted(budget)) return {
+			ok: false,
+			reason: COMPILE_BUDGET_EXHAUSTED
+		};
+	}
+	new RegExp(pattern, unicode ? "u" : "");
+	try {
+		const ast = new Parser(pattern, unicode).parse();
+		const compiler = new Compiler(unicode, budget);
+		compiler.compile(ast);
+		compiler.prog.push({ op: "match" });
+		return {
+			ok: true,
+			regExp: new LinearRegExp(compiler.prog, unicode)
+		};
+	} catch (error) {
+		/* v8 ignore next -- every throw inside the parser/compiler is an Unsupported */
+		if (!(error instanceof Unsupported)) throw error;
+		return {
+			ok: false,
+			reason: error.message
+		};
+	}
+}
+//#endregion
+//#region ../../core/mcp/linearPatternValidator.ts
+const PATTERN_EVALUATION_BUDGET = 2e7;
+const SCHEMA_COMPILE_BUDGET = {
+	steps: 10 * MAX_COMPILE_STEPS,
+	size: 10 * MAX_PROGRAM_SIZE
+};
+const MAX_QUOTED_PATTERN = 120;
+const DRAFT_2020_12 = /* @__PURE__ */ new Set(["https://json-schema.org/draft/2020-12/schema", "http://json-schema.org/draft/2020-12/schema"]);
+const DRAFT_2019_09 = /* @__PURE__ */ new Set(["https://json-schema.org/draft/2019-09/schema", "http://json-schema.org/draft/2019-09/schema"]);
+const DRAFT_07_OR_06 = /* @__PURE__ */ new Set([
+	"https://json-schema.org/draft-07/schema",
+	"http://json-schema.org/draft-07/schema",
+	"https://json-schema.org/draft-06/schema",
+	"http://json-schema.org/draft-06/schema"
+]);
+function declaredDialect(schema) {
+	const declared = schema.$schema;
+	if (typeof declared !== "string") return "2020-12";
+	const uri = declared.replace(/#$/, "");
+	if (DRAFT_2020_12.has(uri)) return "2020-12";
+	if (DRAFT_2019_09.has(uri)) return "2019-09";
+	if (DRAFT_07_OR_06.has(uri)) return "draft-7";
+	throw new Error(`JSON Schema declares an unsupported dialect ("$schema": "${declared.slice(0, 200)}"). Supported: JSON Schema 2020-12, 2019-09, draft-07, and draft-06.`);
+}
+function quote(pattern) {
+	return pattern.length > MAX_QUOTED_PATTERN ? `${pattern.slice(0, MAX_QUOTED_PATTERN)}…` : pattern;
+}
+var PatternLedger = class {
+	remaining = PATTERN_EVALUATION_BUDGET;
+	unevaluated = /* @__PURE__ */ new Set();
+	reset() {
+		this.remaining = PATTERN_EVALUATION_BUDGET;
+		this.unevaluated.clear();
+	}
+};
+var LinearPattern = class {
+	source;
+	flags;
+	compiled;
+	ledger;
+	constructor(source, flags, compiled, ledger) {
+		this.source = source;
+		this.flags = flags;
+		this.compiled = compiled;
+		this.ledger = ledger;
+	}
+	test(input) {
+		if (!this.compiled.ok) return this.skip(this.compiled.reason);
+		const { regExp } = this.compiled;
+		const cost = regExp.cost(input);
+		if (cost > this.ledger.remaining) return this.skip(`checking a ${input.length}-character value would exceed the evaluation budget`);
+		this.ledger.remaining -= cost;
+		return regExp.search(input, cost) === true;
+	}
+	skip(reason) {
+		this.ledger.unevaluated.add(`pattern "${quote(this.source)}" was not evaluated (${reason})`);
+		return true;
+	}
+	toString() {
+		return `/${this.source}/${this.flags}`;
+	}
+};
+function createRegExpEngine(ledger, budget) {
+	const engine = (pattern, flags) => new LinearPattern(pattern, flags, compileLinearRegExp(pattern, flags.includes("u"), budget()), ledger);
+	return Object.assign(engine, { code: "linearRegExp" });
+}
+var LinearPatternJsonSchemaValidator = class {
+	ledger = new PatternLedger();
+	engines = /* @__PURE__ */ new Map();
+	compileBudget = { ...SCHEMA_COMPILE_BUDGET };
+	overBudget = /* @__PURE__ */ new WeakSet();
+	engineFor(dialect) {
+		let engine = this.engines.get(dialect);
+		if (!engine) {
+			const options = {
+				strict: false,
+				validateFormats: true,
+				validateSchema: false,
+				allErrors: true,
+				code: { regExp: createRegExpEngine(this.ledger, () => this.compileBudget) }
+			};
+			engine = dialect === "2020-12" ? new Ajv2020(options) : dialect === "2019-09" ? new Ajv2019(options) : new Ajv(options);
+			addFormats(engine);
+			this.engines.set(dialect, engine);
+		}
+		return engine;
+	}
+	getValidator(schema) {
+		const engine = this.engineFor(declaredDialect(schema));
+		const id = schema.$id;
+		const validate = this.tracked(() => (typeof id === "string" ? engine.getSchema(id) : void 0) ?? engine.compile(schema));
+		const overBudget = this.overBudget.has(validate);
+		return (input) => {
+			this.ledger.reset();
+			const valid = validate(input);
+			const unevaluated = [...this.ledger.unevaluated];
+			if (overBudget) unevaluated.unshift("the schema's patterns exceed the compilation budget");
+			if (valid && unevaluated.length === 0) return {
+				valid: true,
+				data: input,
+				errorMessage: void 0
+			};
+			const messages = valid ? [] : [engine.errorsText(validate.errors)];
+			if (unevaluated.length > 0) messages.push(`${unevaluated.join("; ")}, so the value could not be verified against the schema`);
+			return {
+				valid: false,
+				data: void 0,
+				errorMessage: messages.join("; ")
+			};
+		};
+	}
+	tracked(run) {
+		const outer = this.compileBudget;
+		const budget = { ...SCHEMA_COMPILE_BUDGET };
+		this.compileBudget = budget;
+		try {
+			const validate = run();
+			if (isCompileBudgetExhausted(budget)) this.overBudget.add(validate);
+			return validate;
+		} finally {
+			this.compileBudget = outer;
+		}
+	}
+};
+//#endregion
 //#region ../../core/mcp/uriTemplate.ts
 const OPERATORS = [
 	"+",
@@ -11490,6 +12248,16 @@ var RemoteClientTransport = class {
 		}
 		return await res.json();
 	}
+	releaseOnPageHide() {
+		if (!this._sessionId) return false;
+		this.fetchFn(`${this.baseUrl}/api/mcp/disconnect`, {
+			method: "POST",
+			headers: this.headers,
+			body: JSON.stringify({ sessionId: this._sessionId }),
+			keepalive: true
+		}).catch(() => {});
+		return true;
+	}
 	async close() {
 		if (this.closed) return;
 		this.closed = true;
@@ -12427,7 +13195,7 @@ var InspectorClient = class InspectorClient extends InspectorClientEventTarget {
 				params: request.params,
 				signal: controller.signal
 			});
-			this.outputValidator ??= new AjvJsonSchemaValidator();
+			this.outputValidator ??= new LinearPatternJsonSchemaValidator();
 			const invalid = validateAppElicitResult(this.outputValidator, request.params, result);
 			if (invalid) {
 				this.logger.warn({
@@ -13026,7 +13794,7 @@ var InspectorClient = class InspectorClient extends InspectorClientEventTarget {
 		});
 	}
 	validateToolOutput(tool, result) {
-		this.outputValidator ??= new AjvJsonSchemaValidator();
+		this.outputValidator ??= new LinearPatternJsonSchemaValidator();
 		return validateToolOutput(this.outputValidator, tool, result);
 	}
 	cancelPendingTaskInput(taskId) {
@@ -13873,6 +14641,10 @@ var InspectorClient = class InspectorClient extends InspectorClientEventTarget {
 	getRemoteBackendSessionId() {
 		if (this.baseTransport instanceof RemoteClientTransport) return this.baseTransport.getRemoteBackendSessionId();
 	}
+	releaseRemoteSessionOnPageHide() {
+		if (this.baseTransport instanceof RemoteClientTransport) return this.baseTransport.releaseOnPageHide();
+		return false;
+	}
 	async resumeAfterOAuth(authorizationCode, options) {
 		await this.completeOAuthFlow(authorizationCode, options?.iss, options?.state);
 		const remoteSessionId = options?.remoteSessionId;
@@ -14338,21 +15110,38 @@ function isLoopbackHost(host) {
 //#region ../../core/auth/node/oauth-callback-server.ts
 const DEFAULT_HOSTNAME = "127.0.0.1";
 const DEFAULT_CALLBACK_PATH = "/oauth/callback";
-const SUCCESS_HTML = `<!DOCTYPE html>
-<html>
-<head><meta charset="utf-8"><title>OAuth complete</title></head>
-<body><p>OAuth complete. You can close this window.</p></body>
-</html>`;
-function errorHtml(message) {
+const SUCCESS_HTML = page("OAuth complete", "OAuth complete. You can close this window.");
+const NOT_CALLBACK_HTML = page("Not the OAuth callback", "This address is not the OAuth callback the Inspector is waiting for. Sign-in has not finished; return to the Inspector to continue.");
+const STATE_MISMATCH_HTML = page("OAuth callback ignored", "This callback does not belong to the sign-in in progress and was ignored. Sign-in has not finished; the Inspector is still waiting for the authorization server.");
+const ALREADY_HANDLED_HTML = page("OAuth callback already received", "This sign-in has already received its callback. You can close this window.");
+const STOPPED_HTML = page("OAuth callback not expected", "The Inspector is no longer waiting for this sign-in. Start sign-in again from the Inspector.");
+function errorHtml(serverText) {
+	return page("OAuth error", `OAuth failed. The authorization server said: ${serverText}`);
+}
+function exchangeErrorHtml(message) {
+	return page("OAuth error", `OAuth failed: ${message}`);
+}
+function page(title, text) {
 	return `<!DOCTYPE html>
 <html>
-<head><meta charset="utf-8"><title>OAuth error</title></head>
-<body><p>OAuth failed: ${escapeHtml(message)}</p></body>
+<head><meta charset="utf-8"><title>${escapeHtml(title)}</title></head>
+<body><p>${escapeHtml(text)}</p></body>
 </html>`;
 }
 function escapeHtml(s) {
 	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
+const ANY_STATE = Symbol("any-state");
+const STOPPED = Symbol("stopped");
+function createStopSignal() {
+	let fire;
+	return {
+		stopped: new Promise((resolve) => {
+			fire = () => resolve(STOPPED);
+		}),
+		fire
+	};
+}
 var OAuthCallbackServer = class {
 	server = null;
 	port = 0;
@@ -14360,6 +15149,8 @@ var OAuthCallbackServer = class {
 	handled = false;
 	onCallback;
 	onError;
+	expectedState = Promise.resolve(ANY_STATE);
+	stopSignal = createStopSignal();
 	async start(options = {}) {
 		const { port = 0, hostname = DEFAULT_HOSTNAME, path = DEFAULT_CALLBACK_PATH, onCallback, onError } = options;
 		if (!path.startsWith("/")) return Promise.reject(/* @__PURE__ */ new Error("Callback path must start with '/' (absolute path)"));
@@ -14367,6 +15158,8 @@ var OAuthCallbackServer = class {
 		this.onError = onError;
 		this.handled = false;
 		this.callbackPath = path;
+		this.stopSignal = createStopSignal();
+		this.expectedState = "expectedState" in options ? Promise.race([Promise.resolve(options.expectedState).catch(() => STOPPED), this.stopSignal.stopped]) : Promise.resolve(ANY_STATE);
 		return new Promise((resolve, reject) => {
 			this.server = createServer((req, res) => this.handleRequest(req, res));
 			this.server.on("error", reject);
@@ -14390,6 +15183,7 @@ var OAuthCallbackServer = class {
 	}
 	async stop() {
 		if (!this.server) return;
+		this.stopSignal.fire();
 		await new Promise((resolve) => {
 			this.server.close(() => resolve());
 		});
@@ -14398,11 +15192,14 @@ var OAuthCallbackServer = class {
 	handleRequest(req, res) {
 		const needJson = req.headers["accept"]?.includes("application/json");
 		const send = (status, body, contentType = "text/html; charset=utf-8") => {
-			res.writeHead(status, { "Content-Type": contentType });
+			res.writeHead(status, {
+				"Content-Type": contentType,
+				Connection: "close"
+			});
 			res.end(body);
 		};
 		if (req.method !== "GET") {
-			send(405, needJson ? "{\"error\":\"Method Not Allowed\"}" : SUCCESS_HTML);
+			send(405, needJson ? "{\"error\":\"Method Not Allowed\"}" : NOT_CALLBACK_HTML);
 			return;
 		}
 		let pathname;
@@ -14419,15 +15216,26 @@ var OAuthCallbackServer = class {
 			search = u.search;
 			state = u.searchParams.get("state") ?? void 0;
 		} catch {
-			send(400, needJson ? "{\"error\":\"Bad Request\"}" : SUCCESS_HTML);
+			send(400, needJson ? "{\"error\":\"Bad Request\"}" : NOT_CALLBACK_HTML);
 			return;
 		}
 		if (pathname !== this.callbackPath) {
-			send(404, needJson ? "{\"error\":\"Not Found\"}" : SUCCESS_HTML);
+			send(404, needJson ? "{\"error\":\"Not Found\"}" : NOT_CALLBACK_HTML);
+			return;
+		}
+		this.expectedState.then((expected) => this.handleCallback(expected, state, search, needJson, send));
+	}
+	handleCallback(expected, state, search, needJson, send) {
+		if (expected === STOPPED) {
+			send(503, needJson ? "{\"error\":\"Not waiting for a callback\"}" : STOPPED_HTML);
+			return;
+		}
+		if (expected !== ANY_STATE && state !== expected) {
+			send(400, needJson ? "{\"error\":\"State mismatch\"}" : STATE_MISMATCH_HTML);
 			return;
 		}
 		if (this.handled) {
-			send(409, needJson ? "{\"error\":\"Callback already handled\"}" : SUCCESS_HTML);
+			send(409, needJson ? "{\"error\":\"Callback already handled\"}" : ALREADY_HANDLED_HTML);
 			return;
 		}
 		const params = parseOAuthCallbackParams(search);
@@ -14445,9 +15253,10 @@ var OAuthCallbackServer = class {
 				const msg = err instanceof Error ? err.message : String(err);
 				this.onError?.({
 					error: "callback_error",
-					error_description: msg
+					error_description: msg,
+					source: "callback"
 				});
-				send(500, errorHtml(msg));
+				send(500, exchangeErrorHtml(msg));
 				this.stop();
 			});
 			else {
@@ -14460,7 +15269,8 @@ var OAuthCallbackServer = class {
 		const msg = generateOAuthErrorDescription(params);
 		this.onError?.({
 			error: params.error,
-			error_description: params.error_description ?? void 0
+			error_description: params.error_description ?? void 0,
+			source: "redirect"
 		});
 		send(400, errorHtml(msg));
 	}
@@ -14524,6 +15334,14 @@ function toRunnerOAuthError(err) {
 	}
 	return err instanceof Error ? err : new Error(String(err));
 }
+function stateOf(authorizationUrl) {
+	return authorizationUrl.searchParams.get("state") ?? void 0;
+}
+function callbackErrorMessage(params) {
+	if (params.source === "callback") return params.error_description ?? "OAuth callback failed";
+	if (!params.error && !params.error_description) return "OAuth error";
+	return `OAuth authorization failed. The authorization server said: ${params.error_description ? `${params.error_description} (${params.error})` : params.error}`;
+}
 async function runRunnerInteractiveOAuth(options) {
 	const server = (options.createCallbackServer ?? createOAuthCallbackServer)();
 	let flowResolve;
@@ -14553,11 +15371,16 @@ async function runRunnerInteractiveOAuth(options) {
 		process.on("SIGTERM", onSignal);
 	}
 	let timeoutId;
+	let resolveExpectedState;
+	const expectedState = new Promise((resolve) => {
+		resolveExpectedState = resolve;
+	});
 	try {
 		const { redirectUrl } = await racingSignals(server.start({
 			hostname: options.callbackListen.hostname,
 			port: options.callbackListen.port,
 			path: options.callbackListen.pathname,
+			expectedState,
 			onCallback: async (params) => {
 				try {
 					await options.client.completeOAuthFlow(params.code, params.iss, params.state);
@@ -14567,10 +15390,7 @@ async function runRunnerInteractiveOAuth(options) {
 				}
 			},
 			onError: (params) => {
-				flowReject(new Error(
-					/* v8 ignore next -- params.error is a required non-null string, so the "OAuth error" fallback is unreachable */
-					params.error_description ?? params.error ?? "OAuth error"
-				));
+				flowReject(new Error(callbackErrorMessage(params)));
 			}
 		}));
 		options.onCallbackServer?.(server);
@@ -14586,10 +15406,16 @@ async function runRunnerInteractiveOAuth(options) {
 		})]);
 		waitForCallback.catch(() => {});
 		if (options.authorizationUrl) {
+			resolveExpectedState(stateOf(options.authorizationUrl));
 			await racingSignals(options.client.beginInteractiveAuthorization(options.authorizationUrl));
 			await waitForCallback;
-		} else if (await racingSignals(options.client.authenticate()) !== void 0) await waitForCallback;
-		else return { kind: "already_authorized" };
+		} else {
+			const authUrl = await racingSignals(options.client.authenticate());
+			if (authUrl !== void 0) {
+				resolveExpectedState(stateOf(authUrl));
+				await waitForCallback;
+			} else return { kind: "already_authorized" };
+		}
 		if (options.authChallenge) {
 			if (!await racingSignals(options.client.checkAuthChallengeSatisfied(options.authChallenge, { scopeOnly: true }))) return {
 				kind: "insufficient_scope",
@@ -15655,6 +16481,7 @@ function connectCancelledError() {
 }
 //#endregion
 //#region src/daemon/server.ts
+const DAEMON_VERSION = readInspectorVersionSafe(import.meta.url);
 const MCPDO_RUN_OPTIONS = { skillBudgetHint: MCPDO_SKILL_BUDGET_HINT };
 const autoCancelElicitationChannel = { request(frame) {
 	return Promise.resolve({
@@ -15828,7 +16655,8 @@ var DaemonServer = class DaemonServer {
 				result: {
 					pong: true,
 					pid: process.pid,
-					stopping: this.stopping
+					stopping: this.stopping,
+					version: DAEMON_VERSION
 				}
 			} };
 			case "connect": {
@@ -15976,13 +16804,23 @@ var DaemonServer = class DaemonServer {
 		if (isTerminalStatus(client.getStatus())) throw new CliExitCodeError(EXIT_CODES.UNREACHABLE, "The connection dropped before this command could run; re-run the command to reconnect.", { code: "connection_stale" });
 		const unwire = wireElicitationBridge(client, autoCancelElicitationChannel, requestId);
 		const stop = new AbortController();
-		const onCallerGone = () => stop.abort();
+		const abortRequests = new AbortController();
+		const onCallerGone = () => {
+			stop.abort();
+			abortRequests.abort();
+		};
 		signal?.addEventListener("abort", onCallerGone, { once: true });
 		const onStatus = (event) => {
-			if (isTerminalStatus(event.detail)) stop.abort();
+			if (!isTerminalStatus(event.detail)) return;
+			const lost = {
+				reason: "connection_lost",
+				detail: `the connection went ${event.detail}`
+			};
+			stop.abort(lost);
+			abortRequests.abort(new DOMException(`load run stopped: ${lost.detail}`, "AbortError"));
 		};
 		client.addEventListener("statusChange", onStatus);
-		const clearAmbientSignal = client.setAmbientRequestSignal(stop.signal);
+		const clearAmbientSignal = client.setAmbientRequestSignal(abortRequests.signal);
 		const extras = [];
 		try {
 			return {
@@ -15990,8 +16828,8 @@ var DaemonServer = class DaemonServer {
 				summary: await runToolLoad(client, methodArgs, load, {
 					signal: stop.signal,
 					...openLoadClient && { openConnection: async () => {
-						const extra = await openLoadClient(client, stop.signal);
-						const clearExtraSignal = extra.setAmbientRequestSignal(stop.signal);
+						const extra = await openLoadClient(client, abortRequests.signal);
+						const clearExtraSignal = extra.setAmbientRequestSignal(abortRequests.signal);
 						const unwireExtra = wireElicitationBridge(extra, autoCancelElicitationChannel, requestId);
 						extras.push({
 							client: extra,
@@ -16277,4 +17115,4 @@ function raceCallOrElicitation(outcome, channel) {
 	}))]);
 }
 //#endregion
-export { CliExitCodeError as $, sanitizeDeep as A, ensureDaemonDir as B, clearAllOAuthClientState as C, positiveNumberParser as D, positiveIntegerParser as E, readDaemonTokenFile as F, loadServerEntries as G, getDaemonLogPath as H, DAEMON_DIR_ENV as I, parseKeyValuePair as J, selectServerEntry as K, DAEMON_TOKEN_ENV as L, encodeRequest as M, generateDaemonToken as N, resolveLoadOptions as O, getDaemonTokenFromEnv as P, DEFAULT_TASK_TTL_MS as Q, assertSocketPathWithinLimit as R, NodeOAuthStorage as S, resetNodeOAuthStorageCache as T, getDaemonSocketPath as U, getDaemonDir as V, readInspectorVersion as W, withDefaultCatalogPath as X, resolveServerSource as Y, DEFAULT_MAX_FETCH_REQUESTS as Z, isCliAutoOpenForced as _, obtainPendingUrlForKey as a, setSecretStorageWarningsQuiet as at, DEFAULT_CONNECT_TIMEOUT_MS as b, runAuthHelper as c, CallbackNavigation as ct, emaLogin as d, idpOAuthStorageKey as dt, EXIT_CODES as et, emaLogout as f, normalizeIdpIssuer as ft, runEmaIdpInteractiveFlow as g, requireIdp as h, awaitableLog as ht, obtainPendingAuthUrl as i, getSecretStorageInfo as it, sanitizeText as j, isSafeLinkTarget as k, writePendingAuthMarker as l, clearEmaIdpSession as lt, loadEmaIdpConfig as m, awaitableError as mt, AUTH_HELPER_COMMAND as n, readOAuthStore as nt, pendingAuthMarkerPath as o, warnAboutSecretStorage as ot, getEmaStatus as p, parseIdpOAuthStorageKey as pt, parseHeaderPair as q, PENDING_AUTH_TTL_MS as r, disallowMemorySecretStoreFallback as rt, removeOwnPendingAuthMarker as s, InMemorySecretStore as st, DaemonServer as t, handleError as tt, authorizeInFrontend as u, getEmaIdpLoginState as ut, PLAIN as v, getStateFilePath as w, withConnectTimeout as x, styleFromOpts as y, createPrivateDaemonDir as z };
+export { withDefaultCatalogPath as $, resolveLoadOptions as A, assertSocketPathWithinLimit as B, clearAllOAuthClientState as C, loadSummaryWarnings as D, LOAD_FLAG_CONFLICT as E, generateDaemonToken as F, getDaemonSocketPath as G, ensureDaemonDir as H, getDaemonTokenFromEnv as I, loadServerEntries as J, readInspectorVersion as K, readDaemonTokenFile as L, sanitizeDeep as M, sanitizeText as N, positiveIntegerParser as O, encodeRequest as P, resolveServerSource as Q, DAEMON_DIR_ENV as R, NodeOAuthStorage as S, resetNodeOAuthStorageCache as T, getDaemonDir as U, createPrivateDaemonDir as V, getDaemonLogPath as W, parseHeaderPair as X, selectServerEntry as Y, parseKeyValuePair as Z, isCliAutoOpenForced as _, awaitableError as _t, obtainPendingUrlForKey as a, readOAuthStore as at, DEFAULT_CONNECT_TIMEOUT_MS as b, runAuthHelper as c, setSecretStorageWarningsQuiet as ct, emaLogin as d, CallbackNavigation as dt, DEFAULT_MAX_FETCH_REQUESTS as et, emaLogout as f, clearEmaIdpSession as ft, runEmaIdpInteractiveFlow as g, parseIdpOAuthStorageKey as gt, requireIdp as h, normalizeIdpIssuer as ht, obtainPendingAuthUrl as i, handleError as it, isSafeLinkTarget as j, positiveNumberParser as k, writePendingAuthMarker as l, warnAboutSecretStorage as lt, loadEmaIdpConfig as m, idpOAuthStorageKey as mt, AUTH_HELPER_COMMAND as n, CliExitCodeError as nt, pendingAuthMarkerPath as o, disallowMemorySecretStoreFallback as ot, getEmaStatus as p, getEmaIdpLoginState as pt, readInspectorVersionSafe as q, PENDING_AUTH_TTL_MS as r, EXIT_CODES as rt, removeOwnPendingAuthMarker as s, getSecretStorageInfo as st, DaemonServer as t, DEFAULT_TASK_TTL_MS as tt, authorizeInFrontend as u, InMemorySecretStore as ut, PLAIN as v, awaitableLog as vt, getStateFilePath as w, withConnectTimeout as x, styleFromOpts as y, DAEMON_TOKEN_ENV as z };