@copilotkit/aimock 1.42.1 → 1.44.0

package/dist/mcp-fakes.js

@@ -0,0 +1,1614 @@
+import { DEFAULT_TEST_ID, MCP_FAKES_ECHO_LIMIT } from "./constants.js";
+import { build, fixed, fullText, jsonText, msg, quote, quoteJson } from "./message-text.js";
+import { FixtureLoadError } from "./fixture-loader.js";
+
+//#region src/mcp-fakes.ts
+/**
+* MCP fakes: the fake model core.
+*
+* Pure module, no I/O. It owns block validation (the bad-block cases (a)-(j)
+* listed in `MCP_FAKES_LOAD_RULES`), entry ids and the per-mount counters in
+* them, block-id and entry-id uniqueness per mount, scope matching, scope
+* tiers, argument equality, the synchronous claim step with its mismatch and
+* exhausted details (`firstDifference`), consumption state per test id with
+* its FIFO cap, the undeclared-tool policy, and the fake tools for
+* `tools/list`. One `McpFakeStore` serves one MCP mount.
+*/
+/** Default `mount` path of a block. */
+const MCP_FAKES_DEFAULT_MOUNT = "/mcp";
+/**
+* Name of the consumption state shared by requests that supply no test id:
+* the journal's `DEFAULT_TEST_ID`. The store keeps that state apart from an
+* explicitly supplied test id equal to this string;
+* `resetState(MCP_FAKES_DEFAULT_TEST_ID)` resets both.
+*/
+const MCP_FAKES_DEFAULT_TEST_ID = DEFAULT_TEST_ID;
+/**
+* Default FIFO cap on distinct test ids (`McpFakeStoreOptions.maxTestIds`),
+* for a mount with no journal. A mount with a journal mirrors the journal's
+* effective cap (`fixtureCountsMaxTestIdsCap`): 500 under `createServer` unless
+* the option is set, and `0` (unbounded) for a bare `Journal` or an explicit `0`.
+*/
+const MCP_FAKES_DEFAULT_MAX_TEST_IDS = 500;
+/**
+* Deepest nesting of objects and arrays accepted in an `mcpFakes` value: the
+* value itself (a block, or the array of blocks) is level 1. A container
+* below this level is not copied; the input snapshot holds a "nested deeper
+* than 64 levels" value there, which the check of the enclosing field reports
+* as its own bad block.
+*/
+const MCP_FAKES_MAX_DEPTH = 64;
+/** The reason a container below `MCP_FAKES_MAX_DEPTH` levels is not copied. */
+const DEPTH_REASON = msg`nested deeper than ${MCP_FAKES_MAX_DEPTH} levels`;
+/** Longest `firstDifference` text (path plus both values), cut the same way. */
+const DIFF_LIMIT = 1e3;
+const BLOCK_KEYS = new Set([
+	"scope",
+	"mount",
+	"undeclaredTools",
+	"tools"
+]);
+const TOOL_KEYS = new Set([
+	"name",
+	"description",
+	"inputSchema",
+	"calls"
+]);
+const CALL_KEYS = new Set([
+	"args",
+	"anyArgs",
+	"result",
+	"error",
+	"id"
+]);
+const SCOPE_KEYS = new Set(["testId", "context"]);
+const TIER_ORDER = [
+	"testId+context",
+	"testId",
+	"context",
+	"shared"
+];
+/**
+* The error a failed add throws. It is a `FixtureLoadError` whose `rule`,
+* `file`, `blockId` and `entryId` are those of the first error, and whose
+* `message` is the first error's message plus the count of the others.
+* `errors` holds every error found in the input, in order (the first
+* included; see `validateBlock` for the checks that stop early), and
+* `warnings` the shadowed-entry warnings of the blocks that passed every
+* check. Both are frozen, non-writable arrays; `toJSON()` returns copies.
+*/
+var McpFakesAddError = class extends FixtureLoadError {
+	name = "McpFakesAddError";
+	constructor(errors, warnings) {
+		const first = errors[0];
+		if (!first) throw new TypeError(build(msg`McpFakesAddError needs at least one error`));
+		super({
+			rule: first.rule,
+			file: first.file,
+			blockId: first.blockId,
+			entryId: first.entryId,
+			detail: ""
+		});
+		const more = errors.length - 1;
+		this.message = more > 0 ? build(msg`${fixed(first.message)} (and ${more} more ${fixed(more === 1 ? "error" : "errors")})`) : first.message;
+		Object.defineProperty(this, "errors", {
+			value: Object.freeze([...errors]),
+			enumerable: true,
+			writable: false
+		});
+		Object.defineProperty(this, "warnings", {
+			value: Object.freeze(warnings.map((w) => Object.freeze({ ...w }))),
+			enumerable: true,
+			writable: false
+		});
+	}
+	toJSON() {
+		return {
+			...super.toJSON(),
+			name: this.name,
+			errors: this.errors.map((e) => e.toJSON()),
+			warnings: this.warnings.map((w) => ({ ...w }))
+		};
+	}
+};
+/** An object whose prototype is `Object.prototype` or `null` (not an array). */
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/**
+* The one own-key listing for input data: own, enumerable, string keys.
+* Inherited names (`constructor`, `toString`, `__proto__`) are never listed.
+*
+* @internal
+*/
+function ownKeys(obj) {
+	return Object.keys(obj);
+}
+/**
+* The one key check: `key` is an own property of `obj`. Unlike `key in obj`,
+* it never sees the prototype chain, so `hasOwnKey({}, "constructor")` is
+* false.
+*
+* @internal
+*/
+function hasOwnKey(obj, key) {
+	return Object.prototype.hasOwnProperty.call(obj, key);
+}
+/**
+* A user value as one message part: a string is JSON-quoted (quotes and
+* control chars escaped), any other value is rendered as JSON (or as
+* `undefined`, `NaN`, `10n`, ... where JSON cannot at the top level), and a
+* snapshot placeholder, a nested bigint, a cycle, a container too deep, a
+* symbol or function, and a value whose reading throws each as a `<reason>`
+* placeholder whose user text is quoted (see `render`). The builder cuts it
+* once, to its share and to no more than its max, never inside a JSON escape
+* (`\n`, `\u0001`). Whatever the caller's code throws is caught; an error of
+* aimock's own is not.
+*/
+function shown(value, max = MCP_FAKES_ECHO_LIMIT) {
+	return jsonText(render(value), max);
+}
+function render(value) {
+	if (value === void 0) return "undefined";
+	if (typeof value === "number" && !Number.isFinite(value)) return String(value);
+	if (typeof value === "bigint") return `${value}n`;
+	return renderMember(() => value, "", []) ?? notJson(value);
+}
+/**
+* Thrown by `userCode` when code the caller supplied throws: a `toJSON`, a
+* getter, a `Proxy` trap, a `toString`. The renderer catches only this, so a
+* defect in aimock's own rendering code is never hidden as a placeholder.
+*/
+var UserCodeThrew = class {
+	constructor(error) {
+		this.error = error;
+	}
+};
+/**
+* `run()`, which touches the caller's value and so may run the caller's code;
+* whatever that code throws comes out as a `UserCodeThrew`.
+*/
+function userCode(run) {
+	try {
+		return run();
+	} catch (error) {
+		throw new UserCodeThrew(error);
+	}
+}
+/** A placeholder in a rendered value: `<reason>`, the reason's text whole. */
+function placeholder(reason) {
+	return `<${fullText(reason)}>`;
+}
+/** The reason a rendered value holds where it reaches one of its own containers. */
+const CIRCULAR_REASON = msg`a circular reference`;
+/**
+* A value that `renderJson` gives no JSON for (a symbol, a function): a
+* placeholder that names its type and, when it has one, quotes its text.
+*/
+function notJson(value) {
+	const reason = msg`not a JSON value (got ${fixed(typeof value)})`;
+	let text;
+	try {
+		text = userCode(() => String(value));
+	} catch (err) {
+		if (!(err instanceof UserCodeThrew)) throw err;
+		return placeholder(reason);
+	}
+	return placeholder(msg`${reason}: ${quote(text)}`);
+}
+/**
+* One value of a rendered value, read by `read` (which may run the caller's
+* code), rendered by `renderJson`. Where the caller's code throws while it is
+* read or rendered, it renders as an "unreadable value" placeholder that
+* quotes what was thrown, and the rest of the value is kept.
+*/
+function renderMember(read, key, stack) {
+	try {
+		return renderJson(userCode(read), key, stack);
+	} catch (err) {
+		if (!(err instanceof UserCodeThrew)) throw err;
+		return placeholder(msg`an unreadable value (reading it threw ${describeThrown(err.error)})`);
+	}
+}
+/**
+* `value` as `JSON.stringify` renders it, except that a snapshot placeholder,
+* a bigint below the top level, a cycle (found through `stack`, the
+* containers being rendered) and a container more than `MCP_FAKES_MAX_DEPTH`
+* levels down each render as a `<reason>` placeholder. A placeholder is known
+* by its class, never by its text, so no user value can pose as one.
+* `undefined` where `JSON.stringify` gives `undefined`. Every part it joins
+* is `JSON.stringify` output or placeholder text. Every read of the caller's
+* value goes through `userCode`, so the only error it lets out from the
+* caller's code is a `UserCodeThrew`.
+*/
+function renderJson(value, key, stack) {
+	if (userCode(() => value instanceof NotPlain)) return placeholder(value.reason);
+	if (value !== null && (typeof value === "object" || typeof value === "bigint")) {
+		const toJSON = userCode(() => value.toJSON);
+		if (typeof toJSON === "function") value = userCode(() => toJSON.call(value, key));
+	}
+	if (typeof value === "bigint") return placeholder(msg`a bigint (${fixed(`${value}n`)})`);
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	const container = value;
+	if (userCode(() => container instanceof Number || container instanceof String || container instanceof Boolean)) return userCode(() => JSON.stringify(container));
+	if (stack.includes(container)) return placeholder(CIRCULAR_REASON);
+	if (stack.length >= MCP_FAKES_MAX_DEPTH) return placeholder(DEPTH_REASON);
+	stack.push(container);
+	try {
+		if (userCode(() => Array.isArray(container))) {
+			const array = container;
+			const length = userCode(() => array.length);
+			const items = [];
+			for (let i = 0; i < length; i++) items.push(renderMember(() => array[i], String(i), stack) ?? "null");
+			return `[${items.join(",")}]`;
+		}
+		const record = container;
+		const members = [];
+		for (const k of userCode(() => ownKeys(record))) {
+			const item = renderMember(() => record[k], k, stack);
+			if (item !== void 0) members.push(`${JSON.stringify(k)}:${item}`);
+		}
+		return `{${members.join(",")}}`;
+	} finally {
+		stack.pop();
+	}
+}
+/**
+* A thrown value as a message part: its text (user text: a Proxy trap's or a
+* `toJSON`'s message) JSON-quoted; never throws.
+*/
+function describeThrown(err) {
+	try {
+		return quote(err instanceof Error ? `${err.name}: ${err.message}` : String(err));
+	} catch {
+		return fixed("an unprintable value");
+	}
+}
+/**
+* A built-in `Object.prototype.toString` tag (`[object Date]`). Any other tag
+* can come from a user `Symbol.toStringTag`, so a message JSON-quotes it: it
+* then cannot pose as JSON structure or a `<...>` placeholder, and holds no
+* backslash that is not a JSON escape.
+*/
+const BUILTIN_TAG = /^\[object [A-Za-z][A-Za-z0-9]*\]$/;
+/** A `toString` tag as a message part: a built-in one as is, any other quoted. */
+function tagPart(tag) {
+	return BUILTIN_TAG.test(tag) ? fixed(tag) : quote(tag);
+}
+/**
+* A place in the caller's input that the boundary snapshot could not copy as
+* plain data. It replaces that value in the snapshot, so every later check
+* sees a non-plain value and reports its own rule with `reason`.
+*/
+var NotPlain = class {
+	constructor(reason) {
+		this.reason = reason;
+		Object.freeze(this);
+	}
+};
+/**
+* The input boundary: one plain-data copy of a caller's value, made once at
+* `McpFakeStore.add` / `validateMcpFakes` entry; every check after it reads
+* only the copy. It reads own, enumerable, string-keyed data properties only:
+* getters are never run and inherited fields never seen. Never throws. Where
+* the value is not plain data, the copy holds a `NotPlain`: a non-plain
+* object or array (`Date`, `Map`, a class instance, an object with a custom
+* prototype), a symbol key, an accessor property, a sparse array, an array
+* with a non-index key, a cycle, a function, symbol or bigint, or a value
+* whose reading throws (a hostile or revoked `Proxy`). Strings, numbers
+* (non-finite ones too), booleans, `null` and `undefined` are kept as is.
+* Copied objects have a `null` prototype.
+*
+* An object or array below `maxDepth` levels (the root is level 1) is not
+* read: the copy holds a "nested deeper than `MCP_FAKES_MAX_DEPTH` levels"
+* `NotPlain` there, so the copy never recurses deeper than that. Only the
+* reflective reads of the caller's value (`readShape`) are guarded by a
+* `catch`; a throw from aimock's own copy code is a bug and propagates.
+*
+* Each caller object is read once, and copied once per level it is reached
+* at: an object reached through several paths (shared references) is not
+* copied once per path, so the time is linear in the number of objects, not
+* exponential in the depth. The copy keeps that sharing. An object on a
+* cycle is still never copied without a placeholder somewhere under it.
+*/
+function snapshotInput(value, maxDepth = MCP_FAKES_MAX_DEPTH) {
+	return snapshotValue(value, {
+		maxDepth,
+		ancestors: [],
+		shapes: /* @__PURE__ */ new Map(),
+		copies: /* @__PURE__ */ new Map()
+	});
+}
+function snapshotValue(value, state) {
+	if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (typeof value !== "object") return new NotPlain(msg`not a JSON value (got ${fixed(typeof value)})`);
+	const { ancestors } = state;
+	if (ancestors.includes(value)) return new NotPlain(msg`a circular reference`);
+	const level = ancestors.length;
+	if (level >= state.maxDepth) return new NotPlain(DEPTH_REASON);
+	let byLevel = state.copies.get(value);
+	if (byLevel?.has(level)) return byLevel.get(level);
+	let shape = state.shapes.get(value);
+	if (shape === void 0) {
+		shape = readShape(value);
+		state.shapes.set(value, shape);
+	}
+	if (shape instanceof NotPlain) return shape;
+	ancestors.push(value);
+	let copy;
+	try {
+		copy = copyShape(shape, state);
+	} finally {
+		ancestors.pop();
+	}
+	if (!byLevel) {
+		byLevel = /* @__PURE__ */ new Map();
+		state.copies.set(value, byLevel);
+	}
+	byLevel.set(level, copy);
+	return copy;
+}
+/**
+* Every reflective read of one caller object, and nothing else: the only
+* code a hostile or revoked `Proxy` can make throw. A throw here is the
+* caller's value being unreadable, so it becomes a `NotPlain`.
+*/
+function readShape(value) {
+	try {
+		const isArray = Array.isArray(value);
+		const proto = Object.getPrototypeOf(value);
+		if (isArray ? proto !== Array.prototype : proto !== Object.prototype && proto !== null) {
+			const tag = Object.prototype.toString.call(value);
+			return new NotPlain(msg`not a plain JSON ${fixed(isArray ? "array" : "object")} (got ${tagPart(tag)})`);
+		}
+		const data = [];
+		for (const key of Reflect.ownKeys(value)) {
+			const desc = Reflect.getOwnPropertyDescriptor(value, key);
+			if (!desc?.enumerable) continue;
+			if (typeof key === "symbol") return new NotPlain(msg`an object with a symbol key`);
+			data.push([key, hasOwnKey(desc, "value") ? desc.value : ACCESSOR]);
+		}
+		const lengthDesc = isArray ? Reflect.getOwnPropertyDescriptor(value, "length") : void 0;
+		return {
+			isArray,
+			data,
+			length: typeof lengthDesc?.value === "number" ? lengthDesc.value : 0
+		};
+	} catch (err) {
+		return new NotPlain(msg`an unreadable value (reading it threw ${describeThrown(err)})`);
+	}
+}
+/**
+* Most holes a sparse array may have and still be copied element by element.
+* Its `length` costs the caller nothing, so a longer one is not walked.
+*/
+const SPARSE_HOLE_LIMIT = 1e4;
+/**
+* Copy what `readShape` read; recurses through `snapshotValue`. A hole in a
+* sparse array becomes a placeholder in its own place, so the array is still
+* an array and every other element is still checked.
+*/
+function copyShape(shape, state) {
+	const { data, length } = shape;
+	if (shape.isArray) {
+		const own = new Map(data);
+		for (const [key] of data) {
+			const n = Number(key);
+			if (key !== String(n) || !Number.isInteger(n) || n < 0 || n >= length) return new NotPlain(msg`an array with a non-index key ${quote(key)}`);
+		}
+		const holes = length - own.size;
+		if (holes > SPARSE_HOLE_LIMIT) {
+			let hole = 0;
+			while (own.has(String(hole))) hole += 1;
+			return new NotPlain(msg`a sparse array with ${holes} holes (the first at [${hole}])`);
+		}
+		const out = [];
+		for (let i = 0; i < length; i++) {
+			const key = String(i);
+			out.push(own.has(key) ? snapshotField(own.get(key), state) : new NotPlain(msg`a hole in a sparse array`));
+		}
+		return out;
+	}
+	const out = Object.create(null);
+	for (const [key, item] of data) Object.defineProperty(out, key, {
+		value: snapshotField(item, state),
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	return out;
+}
+/** Marks an accessor property in `readShape` (its getter is never run). */
+const ACCESSOR = Symbol("accessor");
+function snapshotField(item, state) {
+	return item === ACCESSOR ? new NotPlain(msg`an accessor property (getters are not read)`) : snapshotValue(item, state);
+}
+/**
+* A copy of `value`, a snapshot copy, with every container below `levels`
+* levels (the value itself is level 1) replaced by the depth placeholder.
+* Used by `McpFakeStore.add` for a block of an array-form `mcpFakes`, whose
+* array is level 1. It does not change `value`: a snapshot can share one copy
+* between paths at different levels. Each container is copied once per level
+* (`memo`), so shared references stay linear.
+*/
+function capDepth(value, levels, memo = /* @__PURE__ */ new Map()) {
+	if (value instanceof NotPlain || typeof value !== "object" || value === null) return value;
+	if (levels < 1) return new NotPlain(DEPTH_REASON);
+	let byLevel = memo.get(value);
+	if (byLevel?.has(levels)) return byLevel.get(levels);
+	let out;
+	if (Array.isArray(value)) out = value.map((item) => capDepth(item, levels - 1, memo));
+	else {
+		const src = value;
+		const obj = Object.create(null);
+		for (const key of ownKeys(src)) Object.defineProperty(obj, key, {
+			value: capDepth(src[key], levels - 1, memo),
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
+		out = obj;
+	}
+	if (!byLevel) {
+		byLevel = /* @__PURE__ */ new Map();
+		memo.set(value, byLevel);
+	}
+	byLevel.set(levels, out);
+	return out;
+}
+/**
+* Freeze `value` and everything under it (plain data only). A frozen object
+* is not walked again: this module freezes children before their parent, and
+* a shared child is then frozen once.
+*/
+function deepFreeze(value) {
+	if (typeof value === "object" && value !== null && !Object.isFrozen(value)) {
+		const obj = value;
+		for (const key of ownKeys(obj)) deepFreeze(obj[key]);
+		Object.freeze(value);
+	}
+	return value;
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.length > 0;
+}
+/** A field is present when it is an own key whose value is not `undefined`. */
+function has(raw, key) {
+	return hasOwnKey(raw, key) && raw[key] !== void 0;
+}
+/** Own keys whose value is not `undefined` (an `undefined` field is absent). */
+function presentKeys(raw) {
+	return ownKeys(raw).filter((key) => raw[key] !== void 0);
+}
+/**
+* The first place under `value` that is not plain JSON (as `JSON.parse` could
+* produce it), or `null`. An object field set to `undefined` is absent, as in
+* `JSON.stringify`. Rejects an `undefined` array item, functions, symbols,
+* bigints, non-finite numbers, sparse-array holes and objects whose prototype
+* is not `Object.prototype` or `null` (`Date`, `Map`, class instances). Its
+* input is always the input snapshot, which holds no cycle (`snapshotInput`
+* puts a placeholder there) and no container deeper than
+* `MCP_FAKES_MAX_DEPTH`, so the recursion is bounded. A container found clean
+* is not checked again (`clean`), so a shared one is walked once.
+*/
+function jsonProblem(value, path, clean = /* @__PURE__ */ new WeakSet()) {
+	if (value instanceof NotPlain) return msg`${pathPart(path)} is ${value.reason}`;
+	if (value === null || typeof value === "string" || typeof value === "boolean") return null;
+	if (typeof value === "number") return Number.isFinite(value) ? null : msg`${pathPart(path)} must be a finite number, got ${shown(value)}`;
+	if (typeof value !== "object") return msg`${pathPart(path)} is not a JSON value (got ${fixed(typeof value)})`;
+	if (clean.has(value)) return null;
+	let problem = null;
+	if (Array.isArray(value)) for (let i = 0; i < value.length && !problem; i++) problem = hasOwnKey(value, String(i)) ? jsonProblem(value[i], `${path}[${i}]`, clean) : msg`${pathPart(`${path}[${i}]`)} is a hole in a sparse array`;
+	else {
+		const proto = Object.getPrototypeOf(value);
+		if (proto !== Object.prototype && proto !== null) {
+			const tag = Object.prototype.toString.call(value);
+			problem = msg`${pathPart(path)} must be a plain JSON object, got ${tagPart(tag)}`;
+		} else {
+			const obj = value;
+			for (const key of presentKeys(obj)) {
+				problem = jsonProblem(obj[key], pathKey(path, key), clean);
+				if (problem) break;
+			}
+		}
+	}
+	if (!problem) clean.add(value);
+	return problem;
+}
+/**
+* Deep copy of a plain JSON value (checked by `jsonProblem`), optionally
+* deep-frozen. Keys are defined, not assigned, so `"__proto__"` stays data;
+* a field set to `undefined` is left out. A container reached through several
+* paths is copied once (`memo`), and the copy shares it the same way.
+*/
+function copyJson(value, freeze = false, memo = /* @__PURE__ */ new Map()) {
+	if (typeof value !== "object" || value === null) return value;
+	if (memo.has(value)) return memo.get(value);
+	let out;
+	if (Array.isArray(value)) out = value.map((item) => copyJson(item, freeze, memo));
+	else {
+		const src = value;
+		const obj = {};
+		for (const key of presentKeys(src)) Object.defineProperty(obj, key, {
+			value: copyJson(src[key], freeze, memo),
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
+		out = obj;
+	}
+	if (freeze) Object.freeze(out);
+	memo.set(value, out);
+	return out;
+}
+/** Block id: `<source><load>[<block>]`, with no `[<block>]` for a single-object `mcpFakes`. */
+function blockIdOf(source, loadSuffix, blockIndex) {
+	return `${source}${loadSuffix}${blockIndex === null ? "" : `[${blockIndex}]`}`;
+}
+function localOf(toolName, index, userId) {
+	return isNonEmptyString(userId) ? userId : `${toolName}#${index}`;
+}
+function tierOf(scope) {
+	if (scope === "shared") return "shared";
+	if (scope.testId !== void 0 && scope.context !== void 0) return "testId+context";
+	if (scope.testId !== void 0) return "testId";
+	return "context";
+}
+/** Scope match: exact, case-sensitive, no normalization; `"shared"` matches every request. */
+function scopeMatches(scope, identity) {
+	if (scope === "shared") return true;
+	if (scope.testId !== void 0 && identity.testId !== scope.testId) return false;
+	if (scope.context !== void 0 && identity.context !== scope.context) return false;
+	return true;
+}
+function badBlock(ctx, letter, detail, entryId = null) {
+	return new FixtureLoadError({
+		rule: `mcp-fakes/bad-block:${letter}`,
+		file: ctx.source,
+		blockId: ctx.blockId,
+		entryId,
+		detail
+	});
+}
+/** Every scope error goes to `errors`; returns the scope only when it is clean. */
+function validateScope(raw, ctx, errors) {
+	if (raw === void 0) {
+		errors.push(badBlock(ctx, "a", msg`block has no scope`));
+		return null;
+	}
+	if (raw === "shared") return "shared";
+	if (!isPlainObject(raw)) {
+		errors.push(badBlock(ctx, "b", msg`scope must be "shared" or an object, got ${shown(raw)}`));
+		return null;
+	}
+	const before = errors.length;
+	for (const key of presentKeys(raw)) if (!SCOPE_KEYS.has(key)) errors.push(badBlock(ctx, "b", msg`scope has unknown key ${shown(key)}`));
+	if (!has(raw, "testId") && !has(raw, "context")) errors.push(badBlock(ctx, "b", msg`scope object has neither testId nor context`));
+	for (const key of ["testId", "context"]) if (has(raw, key) && !isNonEmptyString(raw[key])) errors.push(badBlock(ctx, "b", msg`scope.${fixed(key)} must be a non-empty string, got ${shown(raw[key])}`));
+	if (errors.length > before) return null;
+	const testId = raw.testId;
+	const context = raw.context;
+	if (testId !== void 0 && context !== void 0) return Object.freeze({
+		testId,
+		context
+	});
+	if (testId !== void 0) return Object.freeze({ testId });
+	return Object.freeze({ context });
+}
+const mustBeString = (v, p) => typeof v === "string" ? null : msg`${pathPart(p)} must be a string, got ${shown(v)}`;
+const mustBeNumber = (v, p) => typeof v === "number" ? null : msg`${pathPart(p)} must be a number, got ${shown(v)}`;
+const mustBeBoolean = (v, p) => typeof v === "boolean" ? null : msg`${pathPart(p)} must be a boolean, got ${shown(v)}`;
+const mustBeObject = (v, p) => isPlainObject(v) ? null : msg`${pathPart(p)} must be a JSON object, got ${shown(v)}`;
+/** Base64 as the SDK's `Base64Schema` accepts it (`atob` does not throw). */
+const mustBeBase64 = (v, p) => {
+	if (typeof v === "string") try {
+		atob(v);
+		return null;
+	} catch {}
+	return msg`${pathPart(p)} must be a base64 string, got ${shown(v)}`;
+};
+function oneOf(values) {
+	const list = values.map((v) => quoteJson(v)).join(", ");
+	return (v, p) => typeof v === "string" && values.includes(v) ? null : msg`${pathPart(p)} must be one of ${fixed(list)}, got ${shown(v)}`;
+}
+function arrayOf(item, noun = "an array") {
+	return (v, p) => {
+		if (!Array.isArray(v)) return msg`${pathPart(p)} must be ${fixed(noun)}, got ${shown(v)}`;
+		for (let i = 0; i < v.length; i++) {
+			const problem = item(v[i], `${p}[${i}]`);
+			if (problem) return problem;
+		}
+		return null;
+	};
+}
+const mustBeStringArray = arrayOf(mustBeString, "an array of strings");
+/**
+* An object with `required` fields and `optional` ones (an `undefined` field
+* is absent). Other keys are not checked.
+*/
+function shape(required, optional = {}) {
+	return (v, p) => {
+		if (!isPlainObject(v)) return msg`${pathPart(p)} must be a JSON object, got ${shown(v)}`;
+		for (const key of ownKeys(required)) {
+			const check = required[key];
+			const problem = check(has(v, key) ? v[key] : void 0, pathKey(p, key));
+			if (problem) return problem;
+		}
+		for (const key of ownKeys(optional)) {
+			const check = optional[key];
+			if (!has(v, key)) continue;
+			const problem = check(v[key], pathKey(p, key));
+			if (problem) return problem;
+		}
+		return null;
+	};
+}
+/**
+* RFC 3339 date-time with seconds and a `Z` or `±hh:mm` offset: the pattern of
+* zod's `z.iso.datetime({ offset: true })`, which the SDK uses for
+* `Annotations.lastModified`.
+*/
+const ISO_DATETIME = /^(?:(?:\d\d[2468][048]|\d\d[13579][26]|\d\d0[48]|[02468][048]00|[13579][26]00)-02-29|\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\d|30)|(?:02)-(?:0[1-9]|1\d|2[0-8])))T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
+const ANNOTATIONS = shape({}, {
+	audience: arrayOf(oneOf(["user", "assistant"])),
+	priority: (v, p) => typeof v === "number" && v >= 0 && v <= 1 ? null : msg`${pathPart(p)} must be a number from 0 to 1, got ${shown(v)}`,
+	lastModified: (v, p) => typeof v === "string" && ISO_DATETIME.test(v) ? null : msg`${pathPart(p)} must be an ISO 8601 date-time with seconds and an offset, got ${shown(v)}`
+});
+const ICON = shape({ src: mustBeString }, {
+	mimeType: mustBeString,
+	sizes: mustBeStringArray,
+	theme: oneOf(["light", "dark"])
+});
+/** MCP `TextResourceContents` / `BlobResourceContents`: exactly one of text / blob. */
+const RESOURCE_CONTENTS = (v, p) => {
+	if (!isPlainObject(v)) return msg`${pathPart(p)} must be a JSON object with uri and text or blob, got ${shown(v)}`;
+	if (has(v, "text") === has(v, "blob")) return msg`${pathPart(p)} needs exactly one of text / blob`;
+	return shape({
+		uri: mustBeString,
+		...has(v, "text") ? { text: mustBeString } : { blob: mustBeBase64 }
+	}, {
+		mimeType: mustBeString,
+		_meta: mustBeObject
+	})(v, p);
+};
+/** Fields every content block may carry. */
+const CONTENT_COMMON = {
+	annotations: ANNOTATIONS,
+	_meta: mustBeObject
+};
+/** Each MCP content block type, with its fields. */
+const CONTENT_TYPES = new Map([
+	["text", shape({ text: mustBeString }, CONTENT_COMMON)],
+	["image", shape({
+		data: mustBeBase64,
+		mimeType: mustBeString
+	}, CONTENT_COMMON)],
+	["audio", shape({
+		data: mustBeBase64,
+		mimeType: mustBeString
+	}, CONTENT_COMMON)],
+	["resource_link", shape({
+		uri: mustBeString,
+		name: mustBeString
+	}, {
+		title: mustBeString,
+		description: mustBeString,
+		mimeType: mustBeString,
+		size: mustBeNumber,
+		icons: arrayOf(ICON),
+		...CONTENT_COMMON
+	})],
+	["resource", shape({ resource: RESOURCE_CONTENTS }, CONTENT_COMMON)]
+]);
+const CONTENT_TYPE_LIST = [...CONTENT_TYPES.keys()].map((type) => quoteJson(type)).join(", ");
+/** One MCP content block, checked by its `type`. */
+const CONTENT_BLOCK = (v, p) => {
+	if (!isPlainObject(v)) return msg`${pathPart(p)} must be a content object, got ${shown(v)}`;
+	const check = typeof v.type === "string" ? CONTENT_TYPES.get(v.type) : void 0;
+	if (!check) return msg`${pathPart(p)}.type must be one of ${fixed(CONTENT_TYPE_LIST)}, got ${shown(v.type)}`;
+	return check(v, p);
+};
+const CONTENT = arrayOf(CONTENT_BLOCK, "an array of content blocks");
+/** The SDK client's `RequestMeta` keys on a result's `_meta`; other keys pass through. */
+const RESULT_META = shape({}, {
+	progressToken: (v, p) => typeof v === "string" || Number.isSafeInteger(v) ? null : msg`${pathPart(p)} must be a string or an integer, got ${shown(v)}`,
+	"io.modelcontextprotocol/related-task": shape({ taskId: mustBeString })
+});
+/**
+* The keys of a full `CallToolResult`. An object `result` with any of
+* them is that form, and must have a `content` array; any other object is
+* structured data.
+*/
+const FULL_RESULT_KEYS = new Set([
+	"content",
+	"isError",
+	"structuredContent",
+	"_meta"
+]);
+const FULL_RESULT = shape({ content: CONTENT }, {
+	isError: mustBeBoolean,
+	structuredContent: mustBeObject,
+	_meta: RESULT_META
+});
+function isFullResult(obj) {
+	return [...FULL_RESULT_KEYS].some((key) => has(obj, key));
+}
+/**
+* A valid `result`: a string; a content array; a full `CallToolResult` (`content`
+* array, optional boolean `isError`, optional object `structuredContent` and
+* `_meta`, nothing else); or a JSON object with none of those keys (served as
+* text plus `structuredContent`).
+*/
+function validateResult(result) {
+	if (typeof result === "string") return null;
+	if (!Array.isArray(result) && !isPlainObject(result)) return msg`result must be a string, a content array or an object, got ${shown(result)}`;
+	const json = jsonProblem(result, "result");
+	if (json) return json;
+	if (Array.isArray(result)) return CONTENT(result, "result");
+	if (!isFullResult(result)) return null;
+	for (const key of presentKeys(result)) if (!FULL_RESULT_KEYS.has(key)) return msg`result has unknown key ${shown(key)}`;
+	return FULL_RESULT(result, "result");
+}
+/**
+* MCP `Tool.inputSchema`: a JSON Schema object with `type: "object"` at the
+* root; `properties`, when present, maps names to schema objects, and
+* `required`, when present, lists names. Any other JSON Schema keyword is
+* allowed.
+*/
+const INPUT_SCHEMA = shape({ type: (v, p) => v === "object" ? null : msg`${pathPart(p)} must be "object", got ${shown(v)}` }, {
+	properties: (v, p) => {
+		if (!isPlainObject(v)) return mustBeObject(v, p);
+		for (const key of presentKeys(v)) {
+			const problem = mustBeObject(v[key], pathKey(p, key));
+			if (problem) return problem;
+		}
+		return null;
+	},
+	required: mustBeStringArray
+});
+function inputSchemaProblem(schema) {
+	if (!isPlainObject(schema)) return mustBeObject(schema, "inputSchema");
+	return jsonProblem(schema, "inputSchema") ?? INPUT_SCHEMA(schema, "inputSchema");
+}
+/**
+* Validate one call entry of the input snapshot. Every error goes to
+* `errors`; returns its entry id whether or not it is clean, so that the
+* block's entry-id uniqueness check also sees invalid entries, and the frozen call
+* only when it is clean. `toolName` is the tool's name, or a `tools[<i>]`
+* placeholder when that name is invalid.
+*/
+function validateCall(raw, toolName, label, index, ctx, errors) {
+	const idRaw = isPlainObject(raw) ? raw.id : void 0;
+	const entryId = `${ctx.blockId}:${localOf(toolName, index, idRaw)}`;
+	const where = msg`${label} calls[${index}]`;
+	const bad = (letter, detail) => {
+		errors.push(badBlock(ctx, letter, msg`${where} ${detail}`, entryId));
+	};
+	if (!isPlainObject(raw)) {
+		bad("d", msg`must be an object, got ${shown(raw)}`);
+		return {
+			entryId,
+			call: null
+		};
+	}
+	const before = errors.length;
+	for (const key of presentKeys(raw)) if (!CALL_KEYS.has(key)) bad("h", msg`has unknown key ${shown(key)}`);
+	if (has(raw, "id") && !isNonEmptyString(raw.id)) bad("d", msg`id must be a non-empty string, got ${shown(raw.id)}`);
+	if (has(raw, "anyArgs") && raw.anyArgs !== true) bad("j", msg`anyArgs must be true, got ${shown(raw.anyArgs)}`);
+	const hasArgs = has(raw, "args");
+	if (hasArgs === has(raw, "anyArgs")) bad("d", msg`needs exactly one of args / anyArgs`);
+	if (hasArgs) {
+		const problem = isPlainObject(raw.args) ? jsonProblem(raw.args, "args") : msg`args must be a JSON object, got ${shown(raw.args)}`;
+		if (problem) bad("d", problem);
+	}
+	const hasResult = has(raw, "result");
+	const hasError = has(raw, "error");
+	if (hasResult === hasError) bad("d", msg`needs exactly one of result / error`);
+	if (hasError && typeof raw.error !== "string") bad("d", msg`error must be a string, got ${shown(raw.error)}`);
+	if (hasResult) {
+		const problem = validateResult(raw.result);
+		if (problem) bad("d", problem);
+	}
+	if (errors.length > before) return {
+		entryId,
+		call: null
+	};
+	const match = hasArgs ? { args: copyJson(raw.args, true) } : { anyArgs: true };
+	const answer = hasResult ? { result: copyJson(raw.result, true) } : { error: raw.error };
+	return {
+		entryId,
+		call: Object.freeze({
+			id: entryId,
+			index,
+			...match,
+			...answer
+		})
+	};
+}
+/**
+* Validate one tool of the input snapshot. Every error goes to `errors`, and
+* the entry ids of all its calls (valid or not; with an invalid tool name,
+* only the user ids) to `entryIds`; returns the frozen tool only when it is
+* clean.
+*/
+function validateTool(raw, index, ctx, errors, entryIds) {
+	const where = `tools[${index}]`;
+	const place = msg`tools[${index}]`;
+	if (!isPlainObject(raw)) {
+		errors.push(badBlock(ctx, "g", msg`${place} must be an object, got ${shown(raw)}`));
+		return null;
+	}
+	const before = errors.length;
+	for (const key of presentKeys(raw)) if (!TOOL_KEYS.has(key)) errors.push(badBlock(ctx, "h", msg`${place} has unknown key ${shown(key)}`));
+	const name = isNonEmptyString(raw.name) ? raw.name : null;
+	if (name === null) errors.push(badBlock(ctx, "g", msg`${place} needs a string name, got ${shown(raw.name)}`));
+	const tw = name === null ? place : msg`tool ${quote(name)}`;
+	if (has(raw, "description") && typeof raw.description !== "string") errors.push(badBlock(ctx, "g", msg`${tw} description must be a string, got ${shown(raw.description)}`));
+	if (has(raw, "inputSchema")) {
+		const problem = inputSchemaProblem(raw.inputSchema);
+		if (problem) errors.push(badBlock(ctx, "g", msg`${tw} ${problem}`));
+	}
+	const calls = [];
+	if (!Array.isArray(raw.calls) || raw.calls.length === 0) errors.push(badBlock(ctx, "g", msg`${tw} calls must be a non-empty array, got ${shown(raw.calls)}`));
+	else raw.calls.forEach((rawCall, i) => {
+		const { entryId, call } = validateCall(rawCall, name ?? where, tw, i, ctx, errors);
+		if (name !== null || isPlainObject(rawCall) && isNonEmptyString(rawCall.id)) entryIds.push(entryId);
+		if (call) calls.push(call);
+	});
+	if (errors.length > before || name === null) return null;
+	const tool = {
+		name,
+		calls: Object.freeze(calls)
+	};
+	if (typeof raw.description === "string") tool.description = raw.description;
+	if (isPlainObject(raw.inputSchema)) tool.inputSchema = copyJson(raw.inputSchema, true);
+	return Object.freeze(tool);
+}
+/**
+* Validate one block of the input snapshot. Every check runs and each problem
+* goes to `errors` (no first-stop), with two limits: a block, tool or call
+* entry that is not an object is not checked further, and one `result` or
+* `inputSchema` value reports only its first problem. Entry-id uniqueness
+* inside the block is checked here over every declared entry, valid or not;
+* uniqueness across blocks is the caller's.
+*/
+function validateBlock(raw, source, blockIndex, load, errors) {
+	const ctx = {
+		source,
+		load,
+		blockIndex,
+		blockId: blockIdOf(source, load, blockIndex)
+	};
+	if (!isPlainObject(raw)) {
+		errors.push(badBlock(ctx, "i", msg`mcpFakes block must be an object, got ${shown(raw)}`));
+		return {
+			block: null,
+			entryIds: [],
+			warnings: []
+		};
+	}
+	const before = errors.length;
+	for (const key of presentKeys(raw)) if (!BLOCK_KEYS.has(key)) errors.push(badBlock(ctx, "h", msg`block has unknown key ${shown(key)}`));
+	const scope = validateScope(raw.scope, ctx, errors);
+	let undeclared;
+	if (has(raw, "undeclaredTools")) if (raw.undeclaredTools === "allow" || raw.undeclaredTools === "deny") undeclared = raw.undeclaredTools;
+	else errors.push(badBlock(ctx, "g", msg`undeclaredTools must be "allow" or "deny", got ${shown(raw.undeclaredTools)}`));
+	if (scope === "shared" && undeclared === "deny") errors.push(badBlock(ctx, "c", msg`scope "shared" cannot have undeclaredTools "deny"`));
+	let mount = MCP_FAKES_DEFAULT_MOUNT;
+	if (has(raw, "mount")) if (typeof raw.mount === "string" && raw.mount.startsWith("/")) mount = raw.mount;
+	else errors.push(badBlock(ctx, "g", msg`mount must be a string starting with "/", got ${shown(raw.mount)}`));
+	const tools = [];
+	const declaredIds = [];
+	if (!Array.isArray(raw.tools)) errors.push(badBlock(ctx, "g", msg`tools must be an array, got ${shown(raw.tools)}`));
+	else if (raw.tools.length === 0) {
+		if (undeclared !== "deny" || scope === "shared") errors.push(badBlock(ctx, "g", msg`tools is empty; an empty tools array (tools: []) is allowed only on a scoped (not "shared") block with undeclaredTools "deny"`));
+	} else {
+		const names = /* @__PURE__ */ new Set();
+		raw.tools.forEach((rawTool, i) => {
+			const name = isPlainObject(rawTool) && isNonEmptyString(rawTool.name) ? rawTool.name : null;
+			const duplicate = name !== null && names.has(name);
+			if (duplicate) errors.push(badBlock(ctx, "e", msg`tool ${quote(name)} is declared twice in one block`));
+			else if (name !== null) names.add(name);
+			const tool = validateTool(rawTool, i, ctx, errors, duplicate ? [] : declaredIds);
+			if (tool && !duplicate) tools.push(tool);
+		});
+	}
+	const seen = /* @__PURE__ */ new Set();
+	for (const id of declaredIds) {
+		if (seen.has(id)) errors.push(badBlock(ctx, "f", msg`entry id ${quote(id)} is not unique`, id));
+		seen.add(id);
+	}
+	const entryIds = [...seen];
+	if (errors.length > before || scope === null) return {
+		block: null,
+		entryIds,
+		warnings: []
+	};
+	const warnings = [];
+	for (const tool of tools) {
+		let lastAny = null;
+		for (const call of tool.calls) if (call.anyArgs) lastAny = call;
+		else if (lastAny) warnings.push({
+			file: source,
+			blockId: ctx.blockId,
+			entryId: call.id,
+			message: build(msg`entry ${quote(call.id)} is shadowed until the preceding anyArgs entry ${quote(lastAny.id)} is consumed`)
+		});
+	}
+	return {
+		block: Object.freeze({
+			source,
+			load,
+			blockIndex,
+			blockId: ctx.blockId,
+			scope,
+			tier: tierOf(scope),
+			mount,
+			...undeclared !== void 0 ? { undeclaredTools: undeclared } : {},
+			tools: Object.freeze(tools)
+		}),
+		entryIds,
+		warnings
+	};
+}
+/**
+* Standalone validation of a raw `mcpFakes` value (one object, or an array of
+* blocks) from one `source`. It takes the plain-data snapshot of `raw`
+* (getters are not run, inherited fields not read) and reports every
+* bad-block case (a)-(j) found as a `FixtureLoadError` naming the source and
+* block; entry-id collisions inside a block are (f). Never throws. Ids use the
+* first-load form (empty `load`). The store does not use this function:
+* `McpFakeStore.add` runs the same per-block checks (`validateBlock`) with its
+* own load suffix, and adds the entry-id check across blocks (against the
+* mount and the earlier blocks of the same input). `blocks` holds only the
+* clean blocks (deeply frozen), `warnings` only their shadowed-entry warnings.
+*/
+function validateMcpFakes(raw, source) {
+	const errors = [];
+	const warnings = [];
+	const blocks = [];
+	const input = snapshotInput(raw);
+	let items;
+	if (Array.isArray(input) && input.length === 0) {
+		errors.push(badBlock({
+			source,
+			blockId: null
+		}, "i", msg`mcpFakes is an empty array`));
+		return {
+			blocks,
+			errors,
+			warnings
+		};
+	} else if (Array.isArray(input)) items = input.map((item, i) => ({
+		raw: item,
+		blockIndex: i
+	}));
+	else if (isPlainObject(input)) items = [{
+		raw: input,
+		blockIndex: null
+	}];
+	else {
+		errors.push(badBlock({
+			source,
+			blockId: null
+		}, "i", msg`mcpFakes must be an object or an array, got ${shown(input)}`));
+		return {
+			blocks,
+			errors,
+			warnings
+		};
+	}
+	for (const item of items) {
+		const outcome = validateBlock(item.raw, source, item.blockIndex, "", errors);
+		if (outcome.block) {
+			blocks.push(outcome.block);
+			warnings.push(...outcome.warnings);
+		}
+	}
+	return {
+		blocks,
+		errors,
+		warnings
+	};
+}
+function blockEntryIds(block) {
+	return block.tools.flatMap((t) => t.calls.map((c) => c.id));
+}
+/**
+* Turn a call entry's `result` or `error` into a `tools/call` result. The
+* returned object is a fresh copy the caller may change. A full
+* `CallToolResult` (validation guarantees any object with one of its keys
+* has a `content` array) is copied unchanged, with no `isError` added;
+* every other shape sets `isError`. Throws when the entry has
+* neither (validation makes that a bad block (d)).
+*/
+function toCallToolResult(call) {
+	if (call.error !== void 0) return {
+		content: [{
+			type: "text",
+			text: call.error
+		}],
+		isError: true
+	};
+	const result = call.result;
+	if (result === void 0 || result === null) throw new Error(build(msg`toCallToolResult: call entry has neither result nor error`));
+	if (typeof result === "string") return {
+		content: [{
+			type: "text",
+			text: result
+		}],
+		isError: false
+	};
+	if (Array.isArray(result)) return {
+		content: copyJson(result),
+		isError: false
+	};
+	const obj = copyJson(result);
+	if (Array.isArray(obj.content)) return {
+		...obj,
+		content: obj.content
+	};
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(obj)
+		}],
+		structuredContent: obj,
+		isError: false
+	};
+}
+function jsonEqual(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		return a.every((v, i) => jsonEqual(v, b[i]));
+	}
+	if (isPlainObject(a) && isPlainObject(b)) {
+		const ak = ownKeys(a);
+		const bk = ownKeys(b);
+		if (ak.length !== bk.length) return false;
+		return ak.every((k) => hasOwnKey(b, k) && jsonEqual(a[k], b[k]));
+	}
+	return false;
+}
+/**
+* Argument equality: key order ignored, array order matters, no coercion,
+* numbers equal as parsed JSON, absent `arguments` is `{}`, non-object
+* `arguments` never equals an `args` entry (only an `anyArgs` entry matches
+* it).
+*/
+function mcpArgsEqual(expected, received) {
+	const actual = received === void 0 ? {} : received;
+	if (!isPlainObject(actual)) return false;
+	return jsonEqual(expected, actual);
+}
+/**
+* `path` and one more key: `.key` for a short identifier, else `[<key>]` with
+* the key JSON-quoted whole. The path is cut once, where a message shows it
+* (`pathPart`).
+*/
+function pathKey(path, key) {
+	return key.length <= MCP_FAKES_ECHO_LIMIT && /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? `${path}.${key}` : `${path}[${quoteJson(key)}]`;
+}
+/**
+* A JSON path (built by `pathKey`) as a message part: user data, cut as JSON
+* text, so the cut never splits an escape of a quoted key.
+*/
+function pathPart(path) {
+	return jsonText(path);
+}
+function diffAt(path, expected, received) {
+	if (Array.isArray(expected)) {
+		if (!Array.isArray(received)) return msg`${pathPart(path)}: expected an array, received ${shown(received)}`;
+		if (expected.length !== received.length) return msg`${pathPart(path)}: expected an array of length ${expected.length}, received length ${received.length}`;
+		for (let i = 0; i < expected.length; i++) {
+			const d = diffAt(`${path}[${i}]`, expected[i], received[i]);
+			if (d) return d;
+		}
+		return null;
+	}
+	if (isPlainObject(expected)) {
+		if (!isPlainObject(received)) return msg`${pathPart(path)}: expected an object, received ${shown(received)}`;
+		for (const key of ownKeys(expected)) {
+			const p = pathKey(path, key);
+			if (!hasOwnKey(received, key)) return msg`${pathPart(p)}: expected ${shown(expected[key])}, received nothing (key missing)`;
+			const d = diffAt(p, expected[key], received[key]);
+			if (d) return d;
+		}
+		for (const key of ownKeys(received)) if (!hasOwnKey(expected, key)) return msg`${pathPart(pathKey(path, key))}: unexpected key, received ${shown(received[key])}`;
+		return null;
+	}
+	if (expected === received) return null;
+	return msg`${pathPart(path)}: expected ${shown(expected)}, received ${shown(received)}`;
+}
+/**
+* A JSON path to the first unequal value, with both values (the mismatch
+* detail). Returns `""` when `mcpArgsEqual(expected, received)` holds. The
+* path and each value are cut at `MCP_FAKES_ECHO_LIMIT` chars and the whole
+* text at 1000, each part once.
+*/
+function firstDifference(expected, received) {
+	const diff = diffAt("$", expected, received === void 0 ? {} : received);
+	return diff ? build(diff, DIFF_LIMIT) : "";
+}
+/**
+* Approximate count of differences, used to pick the closest declared entry.
+* A key or array element present on one side only counts as 1, whatever its
+* subtree size.
+*/
+function diffCount(expected, received) {
+	if (Array.isArray(expected) && Array.isArray(received)) {
+		const n = Math.max(expected.length, received.length);
+		let count = 0;
+		for (let i = 0; i < n; i++) if (i >= expected.length || i >= received.length) count += 1;
+		else count += diffCount(expected[i], received[i]);
+		return count;
+	}
+	if (isPlainObject(expected) && isPlainObject(received)) {
+		let count = 0;
+		for (const key of new Set([...ownKeys(expected), ...ownKeys(received)])) {
+			const inE = hasOwnKey(expected, key);
+			const inR = hasOwnKey(received, key);
+			count += inE && inR ? diffCount(expected[key], received[key]) : 1;
+		}
+		return count;
+	}
+	return jsonEqual(expected, received) ? 0 : 1;
+}
+function callMatches(call, received) {
+	return call.anyArgs === true || call.args !== void 0 && mcpArgsEqual(call.args, received);
+}
+var McpFakeStore = class {
+	blocks = [];
+	/** Entry id → the block id that owns it, for every loaded entry. */
+	ids = /* @__PURE__ */ new Map();
+	/** Block id → its `source`, for every loaded block. */
+	blockIds = /* @__PURE__ */ new Map();
+	/**
+	* Consumption state: supplied test id → consumed entry ids. Map insertion
+	* order is the FIFO order of the cap.
+	*/
+	consumed = /* @__PURE__ */ new Map();
+	/** Consumed entry ids for requests with no test id. Never evicted. */
+	untagged = /* @__PURE__ */ new Set();
+	/**
+	* Test ids whose state the cap evicted. A claim from one of them, of a tool
+	* an applicable block declares, is `evicted` until the test id is reset; a
+	* mark never ages out, because a forgotten mark would silently replay
+	* entries the test id already consumed. Memory stays bounded per evicted
+	* test id: one id string, against the entry-id set the cap dropped. The set only grows with distinct test ids, and every
+	* reset door clears it (`resetState`, `clear`). A cap of `0` evicts
+	* nothing, so marks made under an earlier cap stay until reset.
+	*/
+	evicted = /* @__PURE__ */ new Set();
+	/**
+	* The last `<n>` of `code#<n>` / `control-api#<n>` used by a run-time
+	* addition (see `nextRuntimeNumber`). Never rewound.
+	*/
+	runtimeAdds = 0;
+	/**
+	* The `<k>` of `@<k>`: loads per source string, skipping a `@<k>` that a
+	* loaded block id already starts (see `add`). Never rewound.
+	*/
+	loadCounts = /* @__PURE__ */ new Map();
+	maxTestIds;
+	constructor(options = {}) {
+		this.maxTestIds = checkCap(options.maxTestIds ?? MCP_FAKES_DEFAULT_MAX_TEST_IDS);
+	}
+	/**
+	* Set the FIFO cap on distinct test ids; an MCP mount can pass the
+	* journal's `fixtureCountsMaxTestIdsCap`. A lower cap evicts the oldest test
+	* ids at once. `0` is unbounded: nothing is evicted, and test ids already
+	* marked evicted stay marked until reset. An invalid cap throws a
+	* `RangeError` and leaves the cap unchanged.
+	*/
+	setMaxTestIds(cap) {
+		this.maxTestIds = checkCap(cap);
+		this.enforceCap();
+	}
+	/**
+	* Take one plain-data snapshot of `sources` and `origin` (getters are not
+	* run, inherited fields not read, holes, symbol keys, proxies that throw and
+	* non-plain objects are errors), validate the whole snapshot, derive entry
+	* ids and their counters, check that every block id and every entry id is
+	* unique against the mount and inside the input (bad block (f), naming the
+	* block that already owns the id and, for a block id, that block's source),
+	* then append. Every block is checked,
+	* valid or not (no first-stop; `validateBlock` says which checks stop
+	* early). On any error, throws one `McpFakesAddError` carrying every error
+	* found, and the warnings of the blocks that passed every check, and adds
+	* nothing (no counter is consumed); it never throws anything else for a bad
+	* input (a throw from a defect in aimock itself is not caught). An empty
+	* input, an invalid `origin` or an invalid source item (not an object, an
+	* empty `source`, a `blockIndex` that is not `null` or a non-negative
+	* integer) is a bad block (i).
+	*
+	* With `kind: "file"`, consecutive sources with the same `source` string
+	* and increasing `blockIndex` form one load (one `@<k>`). A load whose
+	* derived block ids a loaded block already has (a file named `"a@2"`
+	* starts the ids of `@2`; a file named `"a[0]"` has the id of block 0 of
+	* the first load) takes the next free `@<k>`, so a file name never blocks
+	* later loads of another source. A file loaded after the block whose id
+	* its name spells is still the bad block (f). With a run-time origin,
+	* blocks are numbered per `McpFakeAddOrigin`; a block given with a null
+	* `blockIndex` keeps the single-object depth limit.
+	*/
+	add(sources, origin) {
+		const originData = snapshotInput(origin);
+		const kind = isPlainObject(originData) ? originData.kind : void 0;
+		if (kind !== "file" && kind !== "code" && kind !== "control-api") throw new McpFakesAddError([badBlock({
+			source: null,
+			blockId: null
+		}, "i", isPlainObject(originData) ? msg`origin.kind must be "file", "code" or "control-api", got ${shown(kind)}` : msg`origin must be an object { kind }, got ${shown(originData)}`)], []);
+		const runtimeNumber = kind === "file" ? null : this.nextRuntimeNumber(kind);
+		const runtimeSource = runtimeNumber === null ? null : `${kind}#${runtimeNumber}`;
+		const input = snapshotInput(sources, MCP_FAKES_MAX_DEPTH + 2);
+		if (!Array.isArray(input) || input.length === 0) {
+			const detail = Array.isArray(input) ? msg`mcpFakes holds no blocks` : msg`the blocks to add must be an array, got ${shown(input)}`;
+			throw new McpFakesAddError([badBlock({
+				source: runtimeSource,
+				blockId: null
+			}, "i", detail)], []);
+		}
+		const errors = [];
+		const warnings = [];
+		const accepted = [];
+		/** Entry id → owning block id, for this input. */
+		const newIds = /* @__PURE__ */ new Map();
+		/** Block id → source, for this input. */
+		const newBlockIds = /* @__PURE__ */ new Map();
+		const pendingLoads = /* @__PURE__ */ new Map();
+		const items = [];
+		input.forEach((item, position) => {
+			const fail = (detail, file = runtimeSource) => {
+				errors.push(badBlock({
+					source: file,
+					blockId: null
+				}, "i", msg`blocks[${position}] ${detail}`));
+			};
+			if (!isPlainObject(item)) {
+				fail(msg`must be an object { source, blockIndex, raw }, got ${shown(item)}`);
+				return;
+			}
+			const { source, blockIndex } = item;
+			if (runtimeSource === null && !isNonEmptyString(source)) {
+				fail(msg`source must be a non-empty string, got ${shown(source)}`);
+				return;
+			}
+			const sourceText = typeof source === "string" ? source : "";
+			const index = blockIndex === null || typeof blockIndex === "number" && Number.isSafeInteger(blockIndex) && blockIndex >= 0 ? blockIndex : void 0;
+			if (index === void 0) {
+				fail(msg`blockIndex must be null or a non-negative integer, got ${shown(blockIndex)}`, runtimeSource ?? sourceText);
+				return;
+			}
+			items.push({
+				position,
+				source: sourceText,
+				blockIndex: index,
+				raw: item.raw
+			});
+		});
+		const singleObject = input.length === 1 && items.length === 1 && items[0].blockIndex === null;
+		/** Two consecutive file items with one source and a rising block index are one load. */
+		const sameLoad = (prev, item) => prev !== void 0 && prev.source === item.source && prev.blockIndex !== null && item.blockIndex !== null && item.blockIndex > prev.blockIndex;
+		let load = "";
+		for (const [at, item] of items.entries()) {
+			const source = runtimeSource ?? item.source;
+			let blockIndex = item.blockIndex;
+			if (runtimeSource === null) {
+				if (!sameLoad(items[at - 1], item)) {
+					const indices = [];
+					for (let j = at; j < items.length && (j === at || sameLoad(items[j - 1], items[j])); j++) {
+						const index = items[j].blockIndex;
+						if (index !== null) indices.push(index);
+					}
+					let k = (pendingLoads.get(source) ?? this.loadCounts.get(source) ?? 0) + 1;
+					while (k > 1 ? this.blockIdPrefixTaken(blockIdOf(source, `@${k}`, null), newBlockIds) : indices.some((index) => {
+						const derived = blockIdOf(source, "", index);
+						return (this.blockIds.get(derived) ?? newBlockIds.get(derived)) === derived;
+					})) k += 1;
+					pendingLoads.set(source, k);
+					load = k === 1 ? "" : `@${k}`;
+				}
+			} else blockIndex = singleObject ? null : item.position;
+			const outcome = validateBlock(item.blockIndex === null ? item.raw : capDepth(item.raw, MCP_FAKES_MAX_DEPTH - 1), source, blockIndex, load, errors);
+			const blockId = blockIdOf(source, load, blockIndex);
+			const blockOwner = this.blockIds.get(blockId) ?? newBlockIds.get(blockId);
+			let collided = blockOwner !== void 0;
+			if (blockOwner !== void 0) errors.push(badBlock({
+				source,
+				blockId
+			}, "f", blockCollisionDetail(source, blockOwner, this.blockIds.has(blockId))));
+			else newBlockIds.set(blockId, source);
+			for (const id of outcome.entryIds) {
+				const loaded = this.ids.get(id);
+				const earlier = newIds.get(id);
+				if (!newIds.has(id)) newIds.set(id, blockId);
+				if (blockOwner !== void 0) continue;
+				const where = loaded !== void 0 ? msg`is already loaded on this mount, in block ${quote(loaded)}` : earlier !== void 0 ? msg`collides with an entry of block ${quote(earlier)} earlier in the same input` : null;
+				if (where === null) continue;
+				errors.push(badBlock({
+					source,
+					blockId
+				}, "f", msg`entry id ${quote(id)} ${where}`, id));
+				collided = true;
+			}
+			if (outcome.block && !collided) {
+				accepted.push(outcome.block);
+				warnings.push(...outcome.warnings);
+			}
+		}
+		if (errors.length > 0) throw new McpFakesAddError(errors, warnings);
+		for (const [source, k] of pendingLoads) this.loadCounts.set(source, k);
+		if (runtimeNumber !== null) this.runtimeAdds = runtimeNumber;
+		for (const [id, owner] of newIds) this.ids.set(id, owner);
+		for (const [blockId, source] of newBlockIds) this.blockIds.set(blockId, source);
+		this.blocks.push(...accepted);
+		return { warnings };
+	}
+	/**
+	* The `<n>` for the next run-time add of `kind`: one more than the last one
+	* used, skipping any number whose `<kind>#<n>` already starts a loaded block
+	* id (and so every entry id of that block). A file source may be spelled
+	* `code#1`; without the skip, every later run-time add would collide with it
+	* and fail, and a failed add does not advance `<n>`. Blocks loaded after a
+	* run-time add still collide with it as usual (the later block fails).
+	*/
+	nextRuntimeNumber(kind) {
+		let n = this.runtimeAdds + 1;
+		while (this.blockIdPrefixTaken(`${kind}#${n}`)) n += 1;
+		return n;
+	}
+	/**
+	* A loaded block id (or one in `pending`, the blocks earlier in the same
+	* input) starts with `prefix` and does not go on with a digit, so `prefix`
+	* would start a colliding block or entry id (`a@2` is taken by `a@2` and
+	* `a@2[0]`, not by `a@23`).
+	*/
+	blockIdPrefixTaken(prefix, pending) {
+		for (const ids of [this.blockIds, pending ?? /* @__PURE__ */ new Map()]) for (const blockId of ids.keys()) if (blockId.startsWith(prefix) && !/^[0-9]/.test(blockId.slice(prefix.length))) return true;
+		return false;
+	}
+	/** Unload every fake and its state. The id counters (`<n>`, `<k>`) are kept. */
+	clear() {
+		this.blocks = [];
+		this.ids.clear();
+		this.blockIds.clear();
+		this.resetState();
+	}
+	/**
+	* Reset consumption state for one test id, or all. Also clears an
+	* `evicted` mark. `MCP_FAKES_DEFAULT_TEST_ID` resets the untagged state as
+	* well as an explicit test id of that name. That matches
+	* `Journal.clearMatchCounts` (which `LLMock.resetMatchCounts` calls), where
+	* untagged requests and an explicit `__default__` share one key.
+	*/
+	resetState(testId) {
+		if (testId === void 0) {
+			this.consumed.clear();
+			this.untagged.clear();
+			this.evicted.clear();
+			return;
+		}
+		this.consumed.delete(testId);
+		this.evicted.delete(testId);
+		if (testId === MCP_FAKES_DEFAULT_TEST_ID) this.untagged.clear();
+	}
+	/** Every entry id on this mount, in load order. */
+	allEntryIds() {
+		return this.blocks.flatMap(blockEntryIds);
+	}
+	/** The blocks whose scope matches `identity`, in load order. A frozen list of frozen blocks. */
+	applicable(identity) {
+		return Object.freeze(this.blocks.filter((b) => scopeMatches(b.scope, identity)));
+	}
+	/** The candidate entries for `tool` from the most specific tier declaring it. */
+	selectTier(tool, identity) {
+		const blocks = this.applicable(identity);
+		for (const tier of TIER_ORDER) {
+			const entries = [];
+			for (const block of blocks) {
+				if (block.tier !== tier) continue;
+				const t = block.tools.find((x) => x.name === tool);
+				if (t) for (const entry of t.calls) entries.push({
+					block,
+					entry
+				});
+			}
+			if (entries.length > 0) return {
+				tier,
+				entries
+			};
+		}
+		return null;
+	}
+	/**
+	* Find the first unconsumed matching entry of the selected tier (load order,
+	* then `calls` order) and mark it consumed, synchronously (no `await`
+	* between find and mark), so concurrent calls never share an entry. The
+	* result is built and checked to serialize as JSON before the entry is
+	* marked, so a result that cannot be sent throws and leaves the entry
+	* unconsumed. An `anyArgs` entry answers any `arguments`, a non-object
+	* value included; only an `args` entry needs an object.
+	*/
+	claim(tool, args, identity) {
+		const selection = this.selectTier(tool, identity);
+		if (!selection) return Object.freeze({ kind: "none" });
+		const testId = identity.testId;
+		if (testId !== null && this.evicted.has(testId)) return Object.freeze({
+			kind: "evicted",
+			tool,
+			testId,
+			maxTestIds: this.maxTestIds
+		});
+		const used = this.stateOf(testId);
+		const received = args === void 0 ? {} : args;
+		for (const { block, entry } of selection.entries) {
+			if (used?.has(entry.id)) continue;
+			if (!callMatches(entry, received)) continue;
+			let result;
+			try {
+				result = toCallToolResult(entry);
+			} catch (err) {
+				throw new Error(build(msg`MCP fake entry ${quote(entry.id)}: its tools/call result cannot be built: ${describeThrown(err)}`), { cause: err });
+			}
+			try {
+				JSON.stringify(result);
+			} catch (err) {
+				throw new Error(build(msg`MCP fake entry ${quote(entry.id)}: result cannot be serialized as JSON: ${describeThrown(err)}`), { cause: err });
+			}
+			this.stateFor(testId).add(entry.id);
+			return Object.freeze({
+				kind: "answer",
+				tool,
+				entry,
+				block,
+				tier: selection.tier,
+				result
+			});
+		}
+		const matching = selection.entries.filter(({ entry }) => callMatches(entry, received));
+		if (matching.length > 0) return Object.freeze({
+			kind: "exhausted",
+			tool,
+			received,
+			matchingDeclared: matching.length,
+			matchingConsumed: matching.filter(({ entry }) => used?.has(entry.id)).length,
+			matchingIds: Object.freeze(matching.map(({ entry }) => entry.id))
+		});
+		let closest = null;
+		let best = Infinity;
+		for (const { entry } of selection.entries) {
+			if (!entry.args) continue;
+			const score = diffCount(entry.args, received);
+			if (score < best) {
+				best = score;
+				closest = entry;
+			}
+		}
+		return Object.freeze({
+			kind: "mismatch",
+			tool,
+			received,
+			declared: deepFreeze(selection.entries.map(({ entry }) => declaredEntry(entry, used))),
+			firstDifference: closest?.args ? firstDifference(closest.args, received) : ""
+		});
+	}
+	/**
+	* The undeclared-tool policy, first of: `override` (`null` or omitted falls
+	* back to `identity.undeclared`, the request's or session's
+	* `X-AIMock-MCP-Undeclared` / `?undeclared=` value) → `deny` when any
+	* applicable scoped block says `deny` → `allow`.
+	*/
+	policy(identity, override = null) {
+		const effective = override ?? identity.undeclared;
+		if (effective) return effective;
+		for (const block of this.applicable(identity)) if (block.scope !== "shared" && block.undeclaredTools === "deny") return "deny";
+		return "allow";
+	}
+	/** Tool names any applicable block (any tier) declares, in load order. */
+	declaredTools(identity) {
+		const names = /* @__PURE__ */ new Set();
+		for (const block of this.applicable(identity)) for (const t of block.tools) names.add(t.name);
+		return [...names];
+	}
+	/**
+	* Fake tools for `tools/list`, metadata from the most specific
+	* tier declaring each tool; inside that tier, the first block in load order
+	* that declares it. A tool with no `inputSchema` lists `{ type: "object" }`.
+	* Merging with registered tools is the mount's job.
+	*/
+	listTools(identity) {
+		return this.declaredTools(identity).map((name) => {
+			const tool = this.selectTier(name, identity)?.entries[0].block.tools.find((t) => t.name === name);
+			const listing = {
+				name,
+				inputSchema: tool?.inputSchema ? copyJson(tool.inputSchema) : { type: "object" }
+			};
+			if (tool?.description !== void 0) listing.description = tool.description;
+			return listing;
+		});
+	}
+	/**
+	* For `GET /__aimock/mcp/fakes`: applicable blocks with consumed state for
+	* `testId`. For a test id the cap evicted, every block says `evicted: true`.
+	* Deeply frozen.
+	*/
+	snapshot(testId, context) {
+		const used = this.stateOf(testId);
+		const evicted = testId !== null && this.evicted.has(testId);
+		return deepFreeze(this.applicable({
+			testId,
+			context,
+			undeclared: null
+		}).map((block) => ({
+			blockId: block.blockId,
+			source: block.source,
+			mount: block.mount,
+			scope: block.scope,
+			undeclaredTools: block.undeclaredTools ?? "allow",
+			evicted,
+			tools: block.tools.map((t) => ({
+				name: t.name,
+				entries: t.calls.map((c) => declaredEntry(c, used))
+			}))
+		})));
+	}
+	/** The consumed ids for `testId` (`null`: untagged), without creating state. */
+	stateOf(testId) {
+		return testId === null ? this.untagged : this.consumed.get(testId);
+	}
+	stateFor(testId) {
+		if (testId === null) return this.untagged;
+		let set = this.consumed.get(testId);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.consumed.set(testId, set);
+			this.enforceCap();
+		}
+		return set;
+	}
+	/**
+	* FIFO cap: evict the oldest test ids until the cap holds, marking each
+	* evicted. A cap of `0` evicts nothing. The marks are not capped (see
+	* `evicted`).
+	*/
+	enforceCap() {
+		if (this.maxTestIds === 0) return;
+		for (const oldest of this.consumed.keys()) {
+			if (this.consumed.size <= this.maxTestIds) break;
+			this.consumed.delete(oldest);
+			this.evicted.add(oldest);
+		}
+	}
+};
+/**
+* The detail of a block-id collision (bad block (f)). The message prefix
+* already names the block id, so the detail names the two sources.
+*/
+function blockCollisionDetail(source, owner, loaded) {
+	return loaded ? msg`block id (this block's source: ${quote(source)}) is already loaded on this mount by source ${quote(owner)}` : msg`block id (this block's source: ${quote(source)}) collides with a block earlier in the same input, from source ${quote(owner)}`;
+}
+/** The test-id cap: a non-negative safe integer, `0` meaning unbounded. Anything else throws. */
+function checkCap(cap) {
+	if (!Number.isSafeInteger(cap) || cap < 0) throw new RangeError(build(msg`MCP fakes maxTestIds must be a non-negative integer (0 = unbounded), got ${shown(cap)}`));
+	return cap;
+}
+function declaredEntry(entry, used) {
+	const consumed = used?.has(entry.id) ?? false;
+	return entry.args ? {
+		id: entry.id,
+		args: copyJson(entry.args),
+		consumed
+	} : {
+		id: entry.id,
+		anyArgs: true,
+		consumed
+	};
+}
+
+//#endregion
+export { MCP_FAKES_DEFAULT_MOUNT, MCP_FAKES_DEFAULT_TEST_ID, McpFakeStore, McpFakesAddError, blockIdOf, validateMcpFakes };
+//# sourceMappingURL=mcp-fakes.js.map