@copilotkit/aimock 1.43.0 → 1.45.0

package/dist/mcp-fakes-mount.cjs

@@ -0,0 +1,217 @@
+const require_message_text = require('./message-text.cjs');
+const require_fixture_loader = require('./fixture-loader.cjs');
+const require_mcp_fakes = require('./mcp-fakes.cjs');
+const require_mcp_mock = require('./mcp-mock.cjs');
+
+//#region src/mcp-fakes-mount.ts
+/**
+* The control-API prefix. The server hands every request whose path starts
+* with it to the control API, before any mount, so no mount under it is
+* reachable.
+*/
+const CONTROL_PREFIX = "/__aimock";
+/** The handlers an auto-mount created (W3, W6), whichever path created them. */
+const autoMounts = /* @__PURE__ */ new WeakSet();
+/** `handler` was auto-mounted for MCP fakes (at start, after start or by the control API). */
+function isAutoMount(handler) {
+	return autoMounts.has(handler);
+}
+/** A mount "is an MCPMock" for fakes if and only if it implements `addMcpFakes`. */
+function isFakeMount(handler) {
+	return typeof handler.addMcpFakes === "function";
+}
+/**
+* The mount that serves `path`, in dispatch order: an MCPMock at exactly
+* `path`; a conflict when the path is under the control prefix, when a mount
+* that is not an MCPMock serves it first (it would shadow the fakes), or when
+* an MCPMock at `path` without its trailing "/" answers it as its root; none
+* when no mount serves it. An MCPMock mounted at a prefix of `path` lets any
+* other sub-path fall through, so it is skipped. `pending` are the paths an
+* add will auto-mount before this one, in order (they follow `mounts`).
+*/
+function findFakeMount(mounts, path, pending = []) {
+	if (path.startsWith(CONTROL_PREFIX)) return {
+		kind: "conflict",
+		mountPath: CONTROL_PREFIX,
+		reason: "control"
+	};
+	for (const { path: mountPath, handler } of mounts) {
+		if (path !== mountPath && !path.startsWith(mountPath + "/")) continue;
+		if (!isFakeMount(handler)) return {
+			kind: "conflict",
+			mountPath,
+			reason: "not-mcp"
+		};
+		if (mountPath === path) return {
+			kind: "mcp",
+			handler
+		};
+		if (path === mountPath + "/") return {
+			kind: "conflict",
+			mountPath,
+			reason: "mcp-root"
+		};
+	}
+	for (const mountPath of pending) if (path === mountPath + "/") return {
+		kind: "conflict",
+		mountPath,
+		reason: "mcp-root"
+	};
+	return { kind: "none" };
+}
+/** Why the fakes for `path` cannot be served there (no location prefix). */
+function mountConflictDetail(path, target) {
+	switch (target.reason) {
+		case "control": return require_message_text.msg`mount ${require_message_text.quote(path)} is under the control API prefix ${require_message_text.quote(target.mountPath)}, which takes its requests first, so its fakes cannot be served`;
+		case "mcp-root": return require_message_text.msg`mount ${require_message_text.quote(path)} is answered by the MCP mock at ${require_message_text.quote(target.mountPath)} as its root, so its fakes cannot be served`;
+		case "not-mcp": return require_message_text.msg`mount ${require_message_text.quote(path)} is served by ${require_message_text.quote(target.mountPath)}, which is not an MCP mock, so its fakes cannot be served`;
+	}
+}
+/** Wire, push and log (L4, L5) an auto-mounted MCPMock. */
+function pushAutoMount(mounts, path, handler, wiring, logger) {
+	if (wiring.journal) handler.setJournal(wiring.journal);
+	if (wiring.registry) handler.setRegistry(wiring.registry);
+	if (wiring.logger) handler.setLogger(wiring.logger);
+	handler.setReplaySpeed(wiring.replaySpeed ?? 1);
+	const others = mounts.filter((m) => m.path !== path && isFakeMount(m.handler));
+	mounts.push({
+		path,
+		handler
+	});
+	autoMounts.add(handler);
+	logger.info(require_message_text.build(require_message_text.msg`MCP fakes: auto-mounted an MCP mock at ${require_message_text.quote(path)}`));
+	for (const other of others) logger.warn(require_message_text.build(require_message_text.msg`MCP fakes: auto-mounted an MCP mock at ${require_message_text.quote(path)} while an MCP mock is mounted at ${require_message_text.quote(other.path)}; fakes for one path do not reach the other`));
+}
+/**
+* The MCPMock for `path`: the one already mounted there, or a new one pushed
+* onto `mounts` (auto-mount, logs L4 and L5). A conflict is returned, not
+* thrown, so the caller can name the offending block.
+*/
+function ensureFakeMount(mounts, path, wiring, logger) {
+	const target = findFakeMount(mounts, path);
+	if (target.kind === "conflict") return { conflict: target.mountPath };
+	if (target.kind === "mcp") return {
+		handler: target.handler,
+		created: false
+	};
+	const handler = new require_mcp_mock.MCPMock();
+	pushAutoMount(mounts, path, handler, wiring, logger);
+	return {
+		handler,
+		created: true
+	};
+}
+/** A block's `mount` path, read without running getters; the add validates it. */
+function mountOf(raw) {
+	if (typeof raw !== "object" || raw === null) return require_mcp_fakes.MCP_FAKES_DEFAULT_MOUNT;
+	const value = Object.getOwnPropertyDescriptor(raw, "mount")?.value;
+	return typeof value === "string" ? value : require_mcp_fakes.MCP_FAKES_DEFAULT_MOUNT;
+}
+/** The mount-conflict error for one file-origin block. */
+function mountConflictError(block, path, target) {
+	return new require_fixture_loader.FixtureLoadError({
+		rule: "mcp-fakes/mount-conflict",
+		file: block.source,
+		blockId: require_mcp_fakes.blockIdOf(block.source, "", block.blockIndex),
+		entryId: null,
+		detail: mountConflictDetail(path, target)
+	});
+}
+/**
+* Check file-origin `blocks` against `mounts` without changing anything:
+* group them by `mount` path (default `/mcp`), find each group's mount (a
+* mount conflict is one error per block), and add each group to a throwaway
+* store (bad blocks and id collisions inside the input). Throws one
+* `McpFakesAddError` holding every error. With `checked`, only the groups
+* that hold a checked block are checked, and only checked blocks get a
+* mount-conflict error (the others were checked before).
+*/
+function planFileFakes(mounts, blocks, checked) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const block of blocks) {
+		const path = mountOf(block.raw);
+		const group = groups.get(path);
+		if (group) group.push(block);
+		else groups.set(path, [block]);
+	}
+	const errors = [];
+	const warnings = [];
+	const plan = {
+		onExisting: [],
+		onNew: [],
+		warnings
+	};
+	for (const [path, group] of groups) {
+		if (checked && !group.some((block) => checked.has(block))) continue;
+		const target = findFakeMount(mounts, path, plan.onNew.map((g) => g.path));
+		if (target.kind === "conflict") {
+			for (const block of group) if (!checked || checked.has(block)) errors.push(mountConflictError(block, path, target));
+			continue;
+		}
+		try {
+			warnings.push(...new require_mcp_fakes.McpFakeStore().add(group, { kind: "file" }).warnings);
+		} catch (err) {
+			if (!(err instanceof require_mcp_fakes.McpFakesAddError)) throw err;
+			errors.push(...err.errors);
+			warnings.push(...err.warnings);
+			continue;
+		}
+		if (target.kind === "mcp") plan.onExisting.push({
+			handler: target.handler,
+			group
+		});
+		else plan.onNew.push({
+			path,
+			group
+		});
+	}
+	if (errors.length > 0) throw new require_mcp_fakes.McpFakesAddError(errors, warnings);
+	return plan;
+}
+/**
+* Start-time hand-off (F2): check every block first (`planFileFakes`; on any
+* error, a bad block, an id collision or a mount conflict, throws one
+* `McpFakesAddError` holding every error and changes nothing). Then the
+* groups for paths no mount serves are added to new MCPMocks, pushed onto
+* `mounts` (auto-mount, L4, L5) so the mount loop wires them. The groups for
+* an MCPMock already mounted are added by `commit`, once the server listens,
+* so a start that fails after the hand-off leaves those mounts untouched;
+* `undo` removes the auto-mounts. The add warnings (L8) are logged at `warn`.
+*/
+function handOffMcpFakes(mounts, blocks, logger) {
+	const plan = planFileFakes(mounts, blocks);
+	const created = [];
+	for (const { path, group } of plan.onNew) {
+		const handler = new require_mcp_mock.MCPMock();
+		for (const warning of handler.addMcpFakes(group, { kind: "file" }).warnings) logger.warn(warning.message);
+		created.push({
+			path,
+			handler
+		});
+	}
+	for (const { path, handler } of created) pushAutoMount(mounts, path, handler, {}, logger);
+	return {
+		commit() {
+			for (const { handler, group } of plan.onExisting) {
+				const result = handler.addMcpFakes?.(group, { kind: "file" });
+				for (const warning of result?.warnings ?? []) logger.warn(warning.message);
+			}
+		},
+		undo() {
+			for (const { handler } of created) {
+				const at = mounts.findIndex((m) => m.handler === handler);
+				if (at !== -1) mounts.splice(at, 1);
+			}
+		}
+	};
+}
+
+//#endregion
+exports.ensureFakeMount = ensureFakeMount;
+exports.findFakeMount = findFakeMount;
+exports.handOffMcpFakes = handOffMcpFakes;
+exports.isAutoMount = isAutoMount;
+exports.isFakeMount = isFakeMount;
+exports.mountConflictDetail = mountConflictDetail;
+exports.planFileFakes = planFileFakes;
+//# sourceMappingURL=mcp-fakes-mount.cjs.map

package/dist/mcp-fakes-mount.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-fakes-mount.cjs","names":["quote","build","MCPMock","MCP_FAKES_DEFAULT_MOUNT","FixtureLoadError","blockIdOf","McpFakeStore","McpFakesAddError"],"sources":["../src/mcp-fakes-mount.ts"],"sourcesContent":["/**\n * Where MCP fakes go on a server (spec 5.2): find the mount that serves a\n * block's `mount` path, auto-mount an `MCPMock` when none does (W3, W6), and\n * the start-time hand-off of `ServiceFixtures.mcpFakes` (F2).\n */\nimport type { Journal } from \"./journal.js\";\nimport type { Logger } from \"./logger.js\";\nimport type { MetricsRegistry } from \"./metrics.js\";\nimport type { McpFakeSource, Mountable } from \"./types.js\";\nimport { FixtureLoadError } from \"./fixture-loader.js\";\nimport { MCPMock } from \"./mcp-mock.js\";\nimport {\n  MCP_FAKES_DEFAULT_MOUNT,\n  McpFakeStore,\n  McpFakesAddError,\n  blockIdOf,\n  type McpFakeIssue,\n} from \"./mcp-fakes.js\";\nimport { build, msg, quote, type Message } from \"./message-text.js\";\n\nexport type MountList = Array<{ path: string; handler: Mountable }>;\n\n/** Dependencies an auto-mount gets when it is created (after start: W4 wiring). */\nexport interface FakeMountWiring {\n  journal?: Journal;\n  registry?: MetricsRegistry;\n  logger?: Logger;\n  /** T1: the server's replay speed for recorded fake timing (default 1). */\n  replaySpeed?: number;\n}\n\n/**\n * The control-API prefix. The server hands every request whose path starts\n * with it to the control API, before any mount, so no mount under it is\n * reachable.\n */\nexport const CONTROL_PREFIX = \"/__aimock\";\n\n/**\n * What serves a block's `mount` path. A conflict is a path no fake there can\n * be served at: a mount that is not an MCPMock serves it first (`not-mcp`), an\n * MCPMock mounted at `mountPath` answers it as its root (`mcp-root`, the path\n * is `mountPath` plus a trailing \"/\"), or it is under the control prefix\n * (`control`).\n */\nexport type FakeMountTarget =\n  | { kind: \"mcp\"; handler: Mountable }\n  | { kind: \"conflict\"; mountPath: string; reason: \"not-mcp\" | \"mcp-root\" | \"control\" }\n  | { kind: \"none\" };\n\n/** The handlers an auto-mount created (W3, W6), whichever path created them. */\nconst autoMounts = new WeakSet<Mountable>();\n\n/** `handler` was auto-mounted for MCP fakes (at start, after start or by the control API). */\nexport function isAutoMount(handler: Mountable): boolean {\n  return autoMounts.has(handler);\n}\n\n/** A mount \"is an MCPMock\" for fakes if and only if it implements `addMcpFakes`. */\nexport function isFakeMount(handler: Mountable): boolean {\n  return typeof handler.addMcpFakes === \"function\";\n}\n\n/**\n * The mount that serves `path`, in dispatch order: an MCPMock at exactly\n * `path`; a conflict when the path is under the control prefix, when a mount\n * that is not an MCPMock serves it first (it would shadow the fakes), or when\n * an MCPMock at `path` without its trailing \"/\" answers it as its root; none\n * when no mount serves it. An MCPMock mounted at a prefix of `path` lets any\n * other sub-path fall through, so it is skipped. `pending` are the paths an\n * add will auto-mount before this one, in order (they follow `mounts`).\n */\nexport function findFakeMount(\n  mounts: MountList,\n  path: string,\n  pending: readonly string[] = [],\n): FakeMountTarget {\n  if (path.startsWith(CONTROL_PREFIX)) {\n    return { kind: \"conflict\", mountPath: CONTROL_PREFIX, reason: \"control\" };\n  }\n  for (const { path: mountPath, handler } of mounts) {\n    if (path !== mountPath && !path.startsWith(mountPath + \"/\")) continue;\n    if (!isFakeMount(handler)) return { kind: \"conflict\", mountPath, reason: \"not-mcp\" };\n    if (mountPath === path) return { kind: \"mcp\", handler };\n    if (path === mountPath + \"/\") return { kind: \"conflict\", mountPath, reason: \"mcp-root\" };\n  }\n  for (const mountPath of pending) {\n    if (path === mountPath + \"/\") return { kind: \"conflict\", mountPath, reason: \"mcp-root\" };\n  }\n  return { kind: \"none\" };\n}\n\n/** Why the fakes for `path` cannot be served there (no location prefix). */\nexport function mountConflictDetail(\n  path: string,\n  target: Extract<FakeMountTarget, { kind: \"conflict\" }>,\n): Message {\n  switch (target.reason) {\n    case \"control\":\n      return msg`mount ${quote(path)} is under the control API prefix ${quote(target.mountPath)}, which takes its requests first, so its fakes cannot be served`;\n    case \"mcp-root\":\n      return msg`mount ${quote(path)} is answered by the MCP mock at ${quote(target.mountPath)} as its root, so its fakes cannot be served`;\n    case \"not-mcp\":\n      return msg`mount ${quote(path)} is served by ${quote(target.mountPath)}, which is not an MCP mock, so its fakes cannot be served`;\n  }\n}\n\n/** Wire, push and log (L4, L5) an auto-mounted MCPMock. */\nfunction pushAutoMount(\n  mounts: MountList,\n  path: string,\n  handler: MCPMock,\n  wiring: FakeMountWiring,\n  logger: Logger,\n): void {\n  if (wiring.journal) handler.setJournal(wiring.journal);\n  if (wiring.registry) handler.setRegistry(wiring.registry);\n  if (wiring.logger) handler.setLogger(wiring.logger);\n  handler.setReplaySpeed(wiring.replaySpeed ?? 1);\n  const others = mounts.filter((m) => m.path !== path && isFakeMount(m.handler));\n  mounts.push({ path, handler });\n  autoMounts.add(handler);\n  logger.info(build(msg`MCP fakes: auto-mounted an MCP mock at ${quote(path)}`));\n  for (const other of others) {\n    logger.warn(\n      build(\n        msg`MCP fakes: auto-mounted an MCP mock at ${quote(path)} while an MCP mock is mounted at ${quote(other.path)}; fakes for one path do not reach the other`,\n      ),\n    );\n  }\n}\n\n/**\n * The MCPMock for `path`: the one already mounted there, or a new one pushed\n * onto `mounts` (auto-mount, logs L4 and L5). A conflict is returned, not\n * thrown, so the caller can name the offending block.\n */\nexport function ensureFakeMount(\n  mounts: MountList,\n  path: string,\n  wiring: FakeMountWiring,\n  logger: Logger,\n): { handler: Mountable; created: boolean } | { conflict: string } {\n  const target = findFakeMount(mounts, path);\n  if (target.kind === \"conflict\") return { conflict: target.mountPath };\n  if (target.kind === \"mcp\") return { handler: target.handler, created: false };\n  const handler = new MCPMock();\n  pushAutoMount(mounts, path, handler, wiring, logger);\n  return { handler, created: true };\n}\n\n/** A block's `mount` path, read without running getters; the add validates it. */\nfunction mountOf(raw: unknown): string {\n  if (typeof raw !== \"object\" || raw === null) return MCP_FAKES_DEFAULT_MOUNT;\n  const value: unknown = Object.getOwnPropertyDescriptor(raw, \"mount\")?.value;\n  return typeof value === \"string\" ? value : MCP_FAKES_DEFAULT_MOUNT;\n}\n\n/** The mount-conflict error for one file-origin block. */\nexport function mountConflictError(\n  block: McpFakeSource,\n  path: string,\n  target: Extract<FakeMountTarget, { kind: \"conflict\" }>,\n): FixtureLoadError {\n  return new FixtureLoadError({\n    rule: \"mcp-fakes/mount-conflict\",\n    file: block.source,\n    blockId: blockIdOf(block.source, \"\", block.blockIndex),\n    entryId: null,\n    detail: mountConflictDetail(path, target),\n  });\n}\n\n/** Where a checked add of file blocks goes: each group by its `mount` path. */\nexport interface FileFakesPlan {\n  /** Groups for a path an MCPMock already serves, with that mount. */\n  onExisting: Array<{ handler: Mountable; group: McpFakeSource[] }>;\n  /** Groups for a path no mount serves, in order: each gets an auto-mount. */\n  onNew: Array<{ path: string; group: McpFakeSource[] }>;\n  /** The add warnings (L8), as a throwaway store reports them. */\n  warnings: McpFakeIssue[];\n}\n\n/**\n * Check file-origin `blocks` against `mounts` without changing anything:\n * group them by `mount` path (default `/mcp`), find each group's mount (a\n * mount conflict is one error per block), and add each group to a throwaway\n * store (bad blocks and id collisions inside the input). Throws one\n * `McpFakesAddError` holding every error. With `checked`, only the groups\n * that hold a checked block are checked, and only checked blocks get a\n * mount-conflict error (the others were checked before).\n */\nexport function planFileFakes(\n  mounts: MountList,\n  blocks: readonly McpFakeSource[],\n  checked?: ReadonlySet<McpFakeSource>,\n): FileFakesPlan {\n  const groups = new Map<string, McpFakeSource[]>();\n  for (const block of blocks) {\n    const path = mountOf(block.raw);\n    const group = groups.get(path);\n    if (group) group.push(block);\n    else groups.set(path, [block]);\n  }\n\n  const errors: FixtureLoadError[] = [];\n  const warnings: McpFakeIssue[] = [];\n  const plan: FileFakesPlan = { onExisting: [], onNew: [], warnings };\n  for (const [path, group] of groups) {\n    if (checked && !group.some((block) => checked.has(block))) continue;\n    const target = findFakeMount(\n      mounts,\n      path,\n      plan.onNew.map((g) => g.path),\n    );\n    if (target.kind === \"conflict\") {\n      for (const block of group) {\n        if (!checked || checked.has(block)) errors.push(mountConflictError(block, path, target));\n      }\n      continue;\n    }\n    try {\n      warnings.push(...new McpFakeStore().add(group, { kind: \"file\" }).warnings);\n    } catch (err) {\n      if (!(err instanceof McpFakesAddError)) throw err;\n      errors.push(...err.errors);\n      warnings.push(...err.warnings);\n      continue;\n    }\n    if (target.kind === \"mcp\") plan.onExisting.push({ handler: target.handler, group });\n    else plan.onNew.push({ path, group });\n  }\n  if (errors.length > 0) throw new McpFakesAddError(errors, warnings);\n  return plan;\n}\n\n/** A start-time hand-off: the auto-mounts are in place, the rest waits for `commit`. */\nexport interface McpFakesHandOff {\n  /** Add the groups for existing MCPMocks (after the server listens). */\n  commit(): void;\n  /** Take the auto-mounts back off the mounts array (start failed). */\n  undo(): void;\n}\n\n/**\n * Start-time hand-off (F2): check every block first (`planFileFakes`; on any\n * error, a bad block, an id collision or a mount conflict, throws one\n * `McpFakesAddError` holding every error and changes nothing). Then the\n * groups for paths no mount serves are added to new MCPMocks, pushed onto\n * `mounts` (auto-mount, L4, L5) so the mount loop wires them. The groups for\n * an MCPMock already mounted are added by `commit`, once the server listens,\n * so a start that fails after the hand-off leaves those mounts untouched;\n * `undo` removes the auto-mounts. The add warnings (L8) are logged at `warn`.\n */\nexport function handOffMcpFakes(\n  mounts: MountList,\n  blocks: McpFakeSource[],\n  logger: Logger,\n): McpFakesHandOff {\n  const plan = planFileFakes(mounts, blocks);\n  const created: Array<{ path: string; handler: MCPMock }> = [];\n  for (const { path, group } of plan.onNew) {\n    const handler = new MCPMock();\n    for (const warning of handler.addMcpFakes(group, { kind: \"file\" }).warnings) {\n      logger.warn(warning.message);\n    }\n    created.push({ path, handler });\n  }\n  for (const { path, handler } of created) pushAutoMount(mounts, path, handler, {}, logger);\n  return {\n    commit(): void {\n      for (const { handler, group } of plan.onExisting) {\n        const result = handler.addMcpFakes?.(group, { kind: \"file\" });\n        for (const warning of result?.warnings ?? []) logger.warn(warning.message);\n      }\n    },\n    undo(): void {\n      for (const { handler } of created) {\n        const at = mounts.findIndex((m) => m.handler === handler);\n        if (at !== -1) mounts.splice(at, 1);\n      }\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/mcp-fakes-mount.js

@@ -0,0 +1,211 @@
+import { build, msg, quote } from "./message-text.js";
+import { FixtureLoadError } from "./fixture-loader.js";
+import { MCP_FAKES_DEFAULT_MOUNT, McpFakeStore, McpFakesAddError, blockIdOf } from "./mcp-fakes.js";
+import { MCPMock } from "./mcp-mock.js";
+
+//#region src/mcp-fakes-mount.ts
+/**
+* The control-API prefix. The server hands every request whose path starts
+* with it to the control API, before any mount, so no mount under it is
+* reachable.
+*/
+const CONTROL_PREFIX = "/__aimock";
+/** The handlers an auto-mount created (W3, W6), whichever path created them. */
+const autoMounts = /* @__PURE__ */ new WeakSet();
+/** `handler` was auto-mounted for MCP fakes (at start, after start or by the control API). */
+function isAutoMount(handler) {
+	return autoMounts.has(handler);
+}
+/** A mount "is an MCPMock" for fakes if and only if it implements `addMcpFakes`. */
+function isFakeMount(handler) {
+	return typeof handler.addMcpFakes === "function";
+}
+/**
+* The mount that serves `path`, in dispatch order: an MCPMock at exactly
+* `path`; a conflict when the path is under the control prefix, when a mount
+* that is not an MCPMock serves it first (it would shadow the fakes), or when
+* an MCPMock at `path` without its trailing "/" answers it as its root; none
+* when no mount serves it. An MCPMock mounted at a prefix of `path` lets any
+* other sub-path fall through, so it is skipped. `pending` are the paths an
+* add will auto-mount before this one, in order (they follow `mounts`).
+*/
+function findFakeMount(mounts, path, pending = []) {
+	if (path.startsWith(CONTROL_PREFIX)) return {
+		kind: "conflict",
+		mountPath: CONTROL_PREFIX,
+		reason: "control"
+	};
+	for (const { path: mountPath, handler } of mounts) {
+		if (path !== mountPath && !path.startsWith(mountPath + "/")) continue;
+		if (!isFakeMount(handler)) return {
+			kind: "conflict",
+			mountPath,
+			reason: "not-mcp"
+		};
+		if (mountPath === path) return {
+			kind: "mcp",
+			handler
+		};
+		if (path === mountPath + "/") return {
+			kind: "conflict",
+			mountPath,
+			reason: "mcp-root"
+		};
+	}
+	for (const mountPath of pending) if (path === mountPath + "/") return {
+		kind: "conflict",
+		mountPath,
+		reason: "mcp-root"
+	};
+	return { kind: "none" };
+}
+/** Why the fakes for `path` cannot be served there (no location prefix). */
+function mountConflictDetail(path, target) {
+	switch (target.reason) {
+		case "control": return msg`mount ${quote(path)} is under the control API prefix ${quote(target.mountPath)}, which takes its requests first, so its fakes cannot be served`;
+		case "mcp-root": return msg`mount ${quote(path)} is answered by the MCP mock at ${quote(target.mountPath)} as its root, so its fakes cannot be served`;
+		case "not-mcp": return msg`mount ${quote(path)} is served by ${quote(target.mountPath)}, which is not an MCP mock, so its fakes cannot be served`;
+	}
+}
+/** Wire, push and log (L4, L5) an auto-mounted MCPMock. */
+function pushAutoMount(mounts, path, handler, wiring, logger) {
+	if (wiring.journal) handler.setJournal(wiring.journal);
+	if (wiring.registry) handler.setRegistry(wiring.registry);
+	if (wiring.logger) handler.setLogger(wiring.logger);
+	handler.setReplaySpeed(wiring.replaySpeed ?? 1);
+	const others = mounts.filter((m) => m.path !== path && isFakeMount(m.handler));
+	mounts.push({
+		path,
+		handler
+	});
+	autoMounts.add(handler);
+	logger.info(build(msg`MCP fakes: auto-mounted an MCP mock at ${quote(path)}`));
+	for (const other of others) logger.warn(build(msg`MCP fakes: auto-mounted an MCP mock at ${quote(path)} while an MCP mock is mounted at ${quote(other.path)}; fakes for one path do not reach the other`));
+}
+/**
+* The MCPMock for `path`: the one already mounted there, or a new one pushed
+* onto `mounts` (auto-mount, logs L4 and L5). A conflict is returned, not
+* thrown, so the caller can name the offending block.
+*/
+function ensureFakeMount(mounts, path, wiring, logger) {
+	const target = findFakeMount(mounts, path);
+	if (target.kind === "conflict") return { conflict: target.mountPath };
+	if (target.kind === "mcp") return {
+		handler: target.handler,
+		created: false
+	};
+	const handler = new MCPMock();
+	pushAutoMount(mounts, path, handler, wiring, logger);
+	return {
+		handler,
+		created: true
+	};
+}
+/** A block's `mount` path, read without running getters; the add validates it. */
+function mountOf(raw) {
+	if (typeof raw !== "object" || raw === null) return MCP_FAKES_DEFAULT_MOUNT;
+	const value = Object.getOwnPropertyDescriptor(raw, "mount")?.value;
+	return typeof value === "string" ? value : MCP_FAKES_DEFAULT_MOUNT;
+}
+/** The mount-conflict error for one file-origin block. */
+function mountConflictError(block, path, target) {
+	return new FixtureLoadError({
+		rule: "mcp-fakes/mount-conflict",
+		file: block.source,
+		blockId: blockIdOf(block.source, "", block.blockIndex),
+		entryId: null,
+		detail: mountConflictDetail(path, target)
+	});
+}
+/**
+* Check file-origin `blocks` against `mounts` without changing anything:
+* group them by `mount` path (default `/mcp`), find each group's mount (a
+* mount conflict is one error per block), and add each group to a throwaway
+* store (bad blocks and id collisions inside the input). Throws one
+* `McpFakesAddError` holding every error. With `checked`, only the groups
+* that hold a checked block are checked, and only checked blocks get a
+* mount-conflict error (the others were checked before).
+*/
+function planFileFakes(mounts, blocks, checked) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const block of blocks) {
+		const path = mountOf(block.raw);
+		const group = groups.get(path);
+		if (group) group.push(block);
+		else groups.set(path, [block]);
+	}
+	const errors = [];
+	const warnings = [];
+	const plan = {
+		onExisting: [],
+		onNew: [],
+		warnings
+	};
+	for (const [path, group] of groups) {
+		if (checked && !group.some((block) => checked.has(block))) continue;
+		const target = findFakeMount(mounts, path, plan.onNew.map((g) => g.path));
+		if (target.kind === "conflict") {
+			for (const block of group) if (!checked || checked.has(block)) errors.push(mountConflictError(block, path, target));
+			continue;
+		}
+		try {
+			warnings.push(...new McpFakeStore().add(group, { kind: "file" }).warnings);
+		} catch (err) {
+			if (!(err instanceof McpFakesAddError)) throw err;
+			errors.push(...err.errors);
+			warnings.push(...err.warnings);
+			continue;
+		}
+		if (target.kind === "mcp") plan.onExisting.push({
+			handler: target.handler,
+			group
+		});
+		else plan.onNew.push({
+			path,
+			group
+		});
+	}
+	if (errors.length > 0) throw new McpFakesAddError(errors, warnings);
+	return plan;
+}
+/**
+* Start-time hand-off (F2): check every block first (`planFileFakes`; on any
+* error, a bad block, an id collision or a mount conflict, throws one
+* `McpFakesAddError` holding every error and changes nothing). Then the
+* groups for paths no mount serves are added to new MCPMocks, pushed onto
+* `mounts` (auto-mount, L4, L5) so the mount loop wires them. The groups for
+* an MCPMock already mounted are added by `commit`, once the server listens,
+* so a start that fails after the hand-off leaves those mounts untouched;
+* `undo` removes the auto-mounts. The add warnings (L8) are logged at `warn`.
+*/
+function handOffMcpFakes(mounts, blocks, logger) {
+	const plan = planFileFakes(mounts, blocks);
+	const created = [];
+	for (const { path, group } of plan.onNew) {
+		const handler = new MCPMock();
+		for (const warning of handler.addMcpFakes(group, { kind: "file" }).warnings) logger.warn(warning.message);
+		created.push({
+			path,
+			handler
+		});
+	}
+	for (const { path, handler } of created) pushAutoMount(mounts, path, handler, {}, logger);
+	return {
+		commit() {
+			for (const { handler, group } of plan.onExisting) {
+				const result = handler.addMcpFakes?.(group, { kind: "file" });
+				for (const warning of result?.warnings ?? []) logger.warn(warning.message);
+			}
+		},
+		undo() {
+			for (const { handler } of created) {
+				const at = mounts.findIndex((m) => m.handler === handler);
+				if (at !== -1) mounts.splice(at, 1);
+			}
+		}
+	};
+}
+
+//#endregion
+export { ensureFakeMount, findFakeMount, handOffMcpFakes, isAutoMount, isFakeMount, mountConflictDetail, planFileFakes };
+//# sourceMappingURL=mcp-fakes-mount.js.map

package/dist/mcp-fakes-mount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-fakes-mount.js","names":[],"sources":["../src/mcp-fakes-mount.ts"],"sourcesContent":["/**\n * Where MCP fakes go on a server (spec 5.2): find the mount that serves a\n * block's `mount` path, auto-mount an `MCPMock` when none does (W3, W6), and\n * the start-time hand-off of `ServiceFixtures.mcpFakes` (F2).\n */\nimport type { Journal } from \"./journal.js\";\nimport type { Logger } from \"./logger.js\";\nimport type { MetricsRegistry } from \"./metrics.js\";\nimport type { McpFakeSource, Mountable } from \"./types.js\";\nimport { FixtureLoadError } from \"./fixture-loader.js\";\nimport { MCPMock } from \"./mcp-mock.js\";\nimport {\n  MCP_FAKES_DEFAULT_MOUNT,\n  McpFakeStore,\n  McpFakesAddError,\n  blockIdOf,\n  type McpFakeIssue,\n} from \"./mcp-fakes.js\";\nimport { build, msg, quote, type Message } from \"./message-text.js\";\n\nexport type MountList = Array<{ path: string; handler: Mountable }>;\n\n/** Dependencies an auto-mount gets when it is created (after start: W4 wiring). */\nexport interface FakeMountWiring {\n  journal?: Journal;\n  registry?: MetricsRegistry;\n  logger?: Logger;\n  /** T1: the server's replay speed for recorded fake timing (default 1). */\n  replaySpeed?: number;\n}\n\n/**\n * The control-API prefix. The server hands every request whose path starts\n * with it to the control API, before any mount, so no mount under it is\n * reachable.\n */\nexport const CONTROL_PREFIX = \"/__aimock\";\n\n/**\n * What serves a block's `mount` path. A conflict is a path no fake there can\n * be served at: a mount that is not an MCPMock serves it first (`not-mcp`), an\n * MCPMock mounted at `mountPath` answers it as its root (`mcp-root`, the path\n * is `mountPath` plus a trailing \"/\"), or it is under the control prefix\n * (`control`).\n */\nexport type FakeMountTarget =\n  | { kind: \"mcp\"; handler: Mountable }\n  | { kind: \"conflict\"; mountPath: string; reason: \"not-mcp\" | \"mcp-root\" | \"control\" }\n  | { kind: \"none\" };\n\n/** The handlers an auto-mount created (W3, W6), whichever path created them. */\nconst autoMounts = new WeakSet<Mountable>();\n\n/** `handler` was auto-mounted for MCP fakes (at start, after start or by the control API). */\nexport function isAutoMount(handler: Mountable): boolean {\n  return autoMounts.has(handler);\n}\n\n/** A mount \"is an MCPMock\" for fakes if and only if it implements `addMcpFakes`. */\nexport function isFakeMount(handler: Mountable): boolean {\n  return typeof handler.addMcpFakes === \"function\";\n}\n\n/**\n * The mount that serves `path`, in dispatch order: an MCPMock at exactly\n * `path`; a conflict when the path is under the control prefix, when a mount\n * that is not an MCPMock serves it first (it would shadow the fakes), or when\n * an MCPMock at `path` without its trailing \"/\" answers it as its root; none\n * when no mount serves it. An MCPMock mounted at a prefix of `path` lets any\n * other sub-path fall through, so it is skipped. `pending` are the paths an\n * add will auto-mount before this one, in order (they follow `mounts`).\n */\nexport function findFakeMount(\n  mounts: MountList,\n  path: string,\n  pending: readonly string[] = [],\n): FakeMountTarget {\n  if (path.startsWith(CONTROL_PREFIX)) {\n    return { kind: \"conflict\", mountPath: CONTROL_PREFIX, reason: \"control\" };\n  }\n  for (const { path: mountPath, handler } of mounts) {\n    if (path !== mountPath && !path.startsWith(mountPath + \"/\")) continue;\n    if (!isFakeMount(handler)) return { kind: \"conflict\", mountPath, reason: \"not-mcp\" };\n    if (mountPath === path) return { kind: \"mcp\", handler };\n    if (path === mountPath + \"/\") return { kind: \"conflict\", mountPath, reason: \"mcp-root\" };\n  }\n  for (const mountPath of pending) {\n    if (path === mountPath + \"/\") return { kind: \"conflict\", mountPath, reason: \"mcp-root\" };\n  }\n  return { kind: \"none\" };\n}\n\n/** Why the fakes for `path` cannot be served there (no location prefix). */\nexport function mountConflictDetail(\n  path: string,\n  target: Extract<FakeMountTarget, { kind: \"conflict\" }>,\n): Message {\n  switch (target.reason) {\n    case \"control\":\n      return msg`mount ${quote(path)} is under the control API prefix ${quote(target.mountPath)}, which takes its requests first, so its fakes cannot be served`;\n    case \"mcp-root\":\n      return msg`mount ${quote(path)} is answered by the MCP mock at ${quote(target.mountPath)} as its root, so its fakes cannot be served`;\n    case \"not-mcp\":\n      return msg`mount ${quote(path)} is served by ${quote(target.mountPath)}, which is not an MCP mock, so its fakes cannot be served`;\n  }\n}\n\n/** Wire, push and log (L4, L5) an auto-mounted MCPMock. */\nfunction pushAutoMount(\n  mounts: MountList,\n  path: string,\n  handler: MCPMock,\n  wiring: FakeMountWiring,\n  logger: Logger,\n): void {\n  if (wiring.journal) handler.setJournal(wiring.journal);\n  if (wiring.registry) handler.setRegistry(wiring.registry);\n  if (wiring.logger) handler.setLogger(wiring.logger);\n  handler.setReplaySpeed(wiring.replaySpeed ?? 1);\n  const others = mounts.filter((m) => m.path !== path && isFakeMount(m.handler));\n  mounts.push({ path, handler });\n  autoMounts.add(handler);\n  logger.info(build(msg`MCP fakes: auto-mounted an MCP mock at ${quote(path)}`));\n  for (const other of others) {\n    logger.warn(\n      build(\n        msg`MCP fakes: auto-mounted an MCP mock at ${quote(path)} while an MCP mock is mounted at ${quote(other.path)}; fakes for one path do not reach the other`,\n      ),\n    );\n  }\n}\n\n/**\n * The MCPMock for `path`: the one already mounted there, or a new one pushed\n * onto `mounts` (auto-mount, logs L4 and L5). A conflict is returned, not\n * thrown, so the caller can name the offending block.\n */\nexport function ensureFakeMount(\n  mounts: MountList,\n  path: string,\n  wiring: FakeMountWiring,\n  logger: Logger,\n): { handler: Mountable; created: boolean } | { conflict: string } {\n  const target = findFakeMount(mounts, path);\n  if (target.kind === \"conflict\") return { conflict: target.mountPath };\n  if (target.kind === \"mcp\") return { handler: target.handler, created: false };\n  const handler = new MCPMock();\n  pushAutoMount(mounts, path, handler, wiring, logger);\n  return { handler, created: true };\n}\n\n/** A block's `mount` path, read without running getters; the add validates it. */\nfunction mountOf(raw: unknown): string {\n  if (typeof raw !== \"object\" || raw === null) return MCP_FAKES_DEFAULT_MOUNT;\n  const value: unknown = Object.getOwnPropertyDescriptor(raw, \"mount\")?.value;\n  return typeof value === \"string\" ? value : MCP_FAKES_DEFAULT_MOUNT;\n}\n\n/** The mount-conflict error for one file-origin block. */\nexport function mountConflictError(\n  block: McpFakeSource,\n  path: string,\n  target: Extract<FakeMountTarget, { kind: \"conflict\" }>,\n): FixtureLoadError {\n  return new FixtureLoadError({\n    rule: \"mcp-fakes/mount-conflict\",\n    file: block.source,\n    blockId: blockIdOf(block.source, \"\", block.blockIndex),\n    entryId: null,\n    detail: mountConflictDetail(path, target),\n  });\n}\n\n/** Where a checked add of file blocks goes: each group by its `mount` path. */\nexport interface FileFakesPlan {\n  /** Groups for a path an MCPMock already serves, with that mount. */\n  onExisting: Array<{ handler: Mountable; group: McpFakeSource[] }>;\n  /** Groups for a path no mount serves, in order: each gets an auto-mount. */\n  onNew: Array<{ path: string; group: McpFakeSource[] }>;\n  /** The add warnings (L8), as a throwaway store reports them. */\n  warnings: McpFakeIssue[];\n}\n\n/**\n * Check file-origin `blocks` against `mounts` without changing anything:\n * group them by `mount` path (default `/mcp`), find each group's mount (a\n * mount conflict is one error per block), and add each group to a throwaway\n * store (bad blocks and id collisions inside the input). Throws one\n * `McpFakesAddError` holding every error. With `checked`, only the groups\n * that hold a checked block are checked, and only checked blocks get a\n * mount-conflict error (the others were checked before).\n */\nexport function planFileFakes(\n  mounts: MountList,\n  blocks: readonly McpFakeSource[],\n  checked?: ReadonlySet<McpFakeSource>,\n): FileFakesPlan {\n  const groups = new Map<string, McpFakeSource[]>();\n  for (const block of blocks) {\n    const path = mountOf(block.raw);\n    const group = groups.get(path);\n    if (group) group.push(block);\n    else groups.set(path, [block]);\n  }\n\n  const errors: FixtureLoadError[] = [];\n  const warnings: McpFakeIssue[] = [];\n  const plan: FileFakesPlan = { onExisting: [], onNew: [], warnings };\n  for (const [path, group] of groups) {\n    if (checked && !group.some((block) => checked.has(block))) continue;\n    const target = findFakeMount(\n      mounts,\n      path,\n      plan.onNew.map((g) => g.path),\n    );\n    if (target.kind === \"conflict\") {\n      for (const block of group) {\n        if (!checked || checked.has(block)) errors.push(mountConflictError(block, path, target));\n      }\n      continue;\n    }\n    try {\n      warnings.push(...new McpFakeStore().add(group, { kind: \"file\" }).warnings);\n    } catch (err) {\n      if (!(err instanceof McpFakesAddError)) throw err;\n      errors.push(...err.errors);\n      warnings.push(...err.warnings);\n      continue;\n    }\n    if (target.kind === \"mcp\") plan.onExisting.push({ handler: target.handler, group });\n    else plan.onNew.push({ path, group });\n  }\n  if (errors.length > 0) throw new McpFakesAddError(errors, warnings);\n  return plan;\n}\n\n/** A start-time hand-off: the auto-mounts are in place, the rest waits for `commit`. */\nexport interface McpFakesHandOff {\n  /** Add the groups for existing MCPMocks (after the server listens). */\n  commit(): void;\n  /** Take the auto-mounts back off the mounts array (start failed). */\n  undo(): void;\n}\n\n/**\n * Start-time hand-off (F2): check every block first (`planFileFakes`; on any\n * error, a bad block, an id collision or a mount conflict, throws one\n * `McpFakesAddError` holding every error and changes nothing). Then the\n * groups for paths no mount serves are added to new MCPMocks, pushed onto\n * `mounts` (auto-mount, L4, L5) so the mount loop wires them. The groups for\n * an MCPMock already mounted are added by `commit`, once the server listens,\n * so a start that fails after the hand-off leaves those mounts untouched;\n * `undo` removes the auto-mounts. The add warnings (L8) are logged at `warn`.\n */\nexport function handOffMcpFakes(\n  mounts: MountList,\n  blocks: McpFakeSource[],\n  logger: Logger,\n): McpFakesHandOff {\n  const plan = planFileFakes(mounts, blocks);\n  const created: Array<{ path: string; handler: MCPMock }> = [];\n  for (const { path, group } of plan.onNew) {\n    const handler = new MCPMock();\n    for (const warning of handler.addMcpFakes(group, { kind: \"file\" }).warnings) {\n      logger.warn(warning.message);\n    }\n    created.push({ path, handler });\n  }\n  for (const { path, handler } of created) pushAutoMount(mounts, path, handler, {}, logger);\n  return {\n    commit(): void {\n      for (const { handler, group } of plan.onExisting) {\n        const result = handler.addMcpFakes?.(group, { kind: \"file\" });\n        for (const warning of result?.warnings ?? []) logger.warn(warning.message);\n      }\n    },\n    undo(): void {\n      for (const { handler } of created) {\n        const at = mounts.findIndex((m) => m.handler === handler);\n        if (at !== -1) mounts.splice(at, 1);\n      }\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/mcp-fakes-report.cjs

@@ -0,0 +1,111 @@
+const require_mcp_fakes_mount = require('./mcp-fakes-mount.cjs');
+
+//#region src/mcp-fakes-report.ts
+/** RP7/RP8: thrown by the plugins under "fail" and by assertFakesReport. */
+var AimockFakesReportError = class extends Error {
+	report;
+	constructor(report, message) {
+		super(message);
+		this.name = "AimockFakesReportError";
+		this.report = report;
+	}
+};
+/** TI5: a default test id cannot be inferred safely. */
+var AimockTestIdCollisionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AimockTestIdCollisionError";
+	}
+};
+function isReportSource(handler) {
+	return typeof handler === "object" && handler !== null && typeof handler.fakesReportPart === "function";
+}
+/** RP1-RP5 over every fake mount of a server. Reads only: no state changes (RP9). */
+function buildFakesReport(mounts, testId, context) {
+	let evicted = false;
+	const served = [];
+	const unconsumed = [];
+	const unfaked = [];
+	const failures = [];
+	const sharedUnconsumed = [];
+	for (const { path, handler } of mounts) {
+		if (!require_mcp_fakes_mount.isFakeMount(handler) || !isReportSource(handler)) continue;
+		const part = handler.fakesReportPart(testId, context, path);
+		evicted ||= part.evicted;
+		served.push(...part.served);
+		unconsumed.push(...part.unconsumed);
+		unfaked.push(...part.unfaked);
+		failures.push(...part.failures);
+		sharedUnconsumed.push(...part.sharedUnconsumed);
+	}
+	served.sort((a, b) => a.seq - b.seq);
+	failures.sort((a, b) => a.seq - b.seq);
+	return {
+		testId,
+		context,
+		ok: failures.length === 0 && !evicted && unconsumed.length === 0,
+		evicted,
+		served: served.map(({ entryId, mount, tool, args }) => ({
+			entryId,
+			mount,
+			tool,
+			args
+		})),
+		unconsumed,
+		unfaked,
+		failures: failures.map(({ code, mount, tool, args }) => ({
+			code,
+			mount,
+			tool,
+			args
+		})),
+		sharedUnconsumed
+	};
+}
+/** `value` as one line of JSON; a value with no JSON text is shown as `String(value)`. */
+function jsonText(value) {
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+/**
+* RP7 message: a header naming the test id (and context), then one line per
+* failure, then per unconsumed entry id, then the evicted line. With
+* `failOnUnfaked`, one line per unfaked call follows.
+*/
+function formatFakesReport(report, opts = {}) {
+	const lines = [`aimock MCP fakes report failed (${report.testId === null ? "no test id" : `testId ${JSON.stringify(report.testId)}`}${report.context === null ? "" : `, context ${JSON.stringify(report.context)}`}):`];
+	for (const f of report.failures) lines.push(`  failure ${f.code}: tools/call ${f.tool} on ${f.mount} with ${jsonText(f.args)}`);
+	for (const u of report.unconsumed) lines.push(`  unconsumed: ${u.entryId} (${u.mount} ${u.tool})`);
+	if (report.evicted) lines.push("  evicted: this test id's fake state was evicted by the per-mount test-id cap, or its event log overflowed (1000 events); the report is incomplete");
+	if (opts.failOnUnfaked === true) for (const u of report.unfaked) lines.push(`  unfaked: tools/call ${u.tool} on ${u.mount} answered by ${u.answeredBy}`);
+	return lines.join("\n");
+}
+/** RP8: throw `AimockFakesReportError` when the report fails (RP5, plus unfaked under `failOnUnfaked`). */
+function assertFakesReport(report, opts = {}) {
+	const unfakedFails = opts.failOnUnfaked === true && report.unfaked.length > 0;
+	if (report.ok && !unfakedFails) return;
+	throw new AimockFakesReportError(report, formatFakesReport(report, opts));
+}
+/** The query parameters `GET /__aimock/mcp/fakes/report` accepts. */
+const MCP_FAKES_REPORT_PARAMS = new Set(["testId", "context"]);
+/** RP6: `GET /__aimock/mcp/fakes/report?testId=&context=`. Always answers; returns true. */
+function handleFakesReportRoute(res, searchParams, mounts) {
+	const reply = (status, body) => {
+		res.writeHead(status, { "Content-Type": "application/json" });
+		res.end(JSON.stringify(body));
+		return true;
+	};
+	for (const key of searchParams.keys()) if (!MCP_FAKES_REPORT_PARAMS.has(key)) return reply(400, { error: `Unknown query parameter: '${key}'. Supported: ${[...MCP_FAKES_REPORT_PARAMS].join(", ")}` });
+	return reply(200, buildFakesReport(mounts, searchParams.get("testId") || null, searchParams.get("context") || null));
+}
+
+//#endregion
+exports.AimockFakesReportError = AimockFakesReportError;
+exports.AimockTestIdCollisionError = AimockTestIdCollisionError;
+exports.assertFakesReport = assertFakesReport;
+exports.formatFakesReport = formatFakesReport;
+exports.handleFakesReportRoute = handleFakesReportRoute;
+//# sourceMappingURL=mcp-fakes-report.cjs.map

package/dist/mcp-fakes-report.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-fakes-report.cjs","names":["isFakeMount"],"sources":["../src/mcp-fakes-report.ts"],"sourcesContent":["/**\n * The per-test MCP fake report (record-replay RP1-RP8): one identity (a test\n * id, plus an optional context) across every MCP mount of one server. Each\n * mount's `MCPMock` gives its part (`fakesReportPart`, from the store's event\n * log); this module merges the parts, decides `ok` (RP5), formats the failure\n * message (RP7) and serves `GET /__aimock/mcp/fakes/report` (RP6).\n */\nimport type * as http from \"node:http\";\nimport type { MountList } from \"./mcp-fakes-mount.js\";\nimport { isFakeMount } from \"./mcp-fakes-mount.js\";\nimport type { McpFakeReportPart } from \"./mcp-fakes.js\";\n\ntype ServedRow = McpFakeReportPart[\"served\"][number];\ntype FailureRow = McpFakeReportPart[\"failures\"][number];\n\n/**\n * RP3: the report. `served` and `failures` are in call order across mounts;\n * their rows have no `seq` (the internal ordering key the parts carry).\n */\nexport interface McpFakesReport {\n  testId: string | null;\n  context: string | null;\n  ok: boolean;\n  evicted: boolean;\n  served: Omit<ServedRow, \"seq\">[];\n  unconsumed: McpFakeReportPart[\"unconsumed\"];\n  unfaked: McpFakeReportPart[\"unfaked\"];\n  failures: Omit<FailureRow, \"seq\">[];\n  sharedUnconsumed: McpFakeReportPart[\"sharedUnconsumed\"];\n}\n\n/** RP7/RP8: thrown by the plugins under \"fail\" and by assertFakesReport. */\nexport class AimockFakesReportError extends Error {\n  readonly report: McpFakesReport;\n  constructor(report: McpFakesReport, message: string) {\n    super(message);\n    this.name = \"AimockFakesReportError\";\n    this.report = report;\n  }\n}\n\n/** TI5: a default test id cannot be inferred safely. */\nexport class AimockTestIdCollisionError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"AimockTestIdCollisionError\";\n  }\n}\n\ninterface ReportSource {\n  fakesReportPart(testId: string | null, context: string | null, mount: string): McpFakeReportPart;\n}\n\nfunction isReportSource(handler: unknown): handler is ReportSource {\n  return (\n    typeof handler === \"object\" &&\n    handler !== null &&\n    typeof (handler as Partial<ReportSource>).fakesReportPart === \"function\"\n  );\n}\n\n/** RP1-RP5 over every fake mount of a server. Reads only: no state changes (RP9). */\nexport function buildFakesReport(\n  mounts: MountList,\n  testId: string | null,\n  context: string | null,\n): McpFakesReport {\n  let evicted = false;\n  const served: ServedRow[] = [];\n  const unconsumed: McpFakesReport[\"unconsumed\"] = [];\n  const unfaked: McpFakesReport[\"unfaked\"] = [];\n  const failures: FailureRow[] = [];\n  const sharedUnconsumed: McpFakesReport[\"sharedUnconsumed\"] = [];\n  for (const { path, handler } of mounts) {\n    if (!isFakeMount(handler) || !isReportSource(handler)) continue;\n    const part = handler.fakesReportPart(testId, context, path);\n    evicted ||= part.evicted;\n    served.push(...part.served);\n    unconsumed.push(...part.unconsumed);\n    unfaked.push(...part.unfaked);\n    failures.push(...part.failures);\n    sharedUnconsumed.push(...part.sharedUnconsumed);\n  }\n  // `seq` is shared by every store, so it orders calls across mounts.\n  served.sort((a, b) => a.seq - b.seq);\n  failures.sort((a, b) => a.seq - b.seq);\n  const ok = failures.length === 0 && !evicted && unconsumed.length === 0; // RP5\n  return {\n    testId,\n    context,\n    ok,\n    evicted,\n    served: served.map(({ entryId, mount, tool, args }) => ({ entryId, mount, tool, args })),\n    unconsumed,\n    unfaked,\n    failures: failures.map(({ code, mount, tool, args }) => ({ code, mount, tool, args })),\n    sharedUnconsumed,\n  };\n}\n\n/** `value` as one line of JSON; a value with no JSON text is shown as `String(value)`. */\nfunction jsonText(value: unknown): string {\n  try {\n    const text = JSON.stringify(value) as string | undefined;\n    return text ?? String(value);\n  } catch {\n    return String(value);\n  }\n}\n\n/**\n * RP7 message: a header naming the test id (and context), then one line per\n * failure, then per unconsumed entry id, then the evicted line. With\n * `failOnUnfaked`, one line per unfaked call follows.\n */\nexport function formatFakesReport(\n  report: McpFakesReport,\n  opts: { failOnUnfaked?: boolean } = {},\n): string {\n  const who = report.testId === null ? \"no test id\" : `testId ${JSON.stringify(report.testId)}`;\n  const ctx = report.context === null ? \"\" : `, context ${JSON.stringify(report.context)}`;\n  const lines = [`aimock MCP fakes report failed (${who}${ctx}):`];\n  for (const f of report.failures) {\n    lines.push(`  failure ${f.code}: tools/call ${f.tool} on ${f.mount} with ${jsonText(f.args)}`);\n  }\n  for (const u of report.unconsumed) {\n    lines.push(`  unconsumed: ${u.entryId} (${u.mount} ${u.tool})`);\n  }\n  if (report.evicted) {\n    lines.push(\n      \"  evicted: this test id's fake state was evicted by the per-mount test-id cap, or its event log overflowed (1000 events); the report is incomplete\",\n    );\n  }\n  if (opts.failOnUnfaked === true) {\n    for (const u of report.unfaked) {\n      lines.push(`  unfaked: tools/call ${u.tool} on ${u.mount} answered by ${u.answeredBy}`);\n    }\n  }\n  return lines.join(\"\\n\");\n}\n\n/** RP8: throw `AimockFakesReportError` when the report fails (RP5, plus unfaked under `failOnUnfaked`). */\nexport function assertFakesReport(\n  report: McpFakesReport,\n  opts: { failOnUnfaked?: boolean } = {},\n): void {\n  const unfakedFails = opts.failOnUnfaked === true && report.unfaked.length > 0;\n  if (report.ok && !unfakedFails) return;\n  throw new AimockFakesReportError(report, formatFakesReport(report, opts));\n}\n\n/** The query parameters `GET /__aimock/mcp/fakes/report` accepts. */\nconst MCP_FAKES_REPORT_PARAMS = new Set([\"testId\", \"context\"]);\n\n/** RP6: `GET /__aimock/mcp/fakes/report?testId=&context=`. Always answers; returns true. */\nexport function handleFakesReportRoute(\n  res: http.ServerResponse,\n  searchParams: URLSearchParams,\n  mounts: MountList,\n): true {\n  const reply = (status: number, body: unknown): true => {\n    res.writeHead(status, { \"Content-Type\": \"application/json\" });\n    res.end(JSON.stringify(body));\n    return true;\n  };\n  for (const key of searchParams.keys()) {\n    if (!MCP_FAKES_REPORT_PARAMS.has(key)) {\n      return reply(400, {\n        error: `Unknown query parameter: '${key}'. Supported: ${[...MCP_FAKES_REPORT_PARAMS].join(\", \")}`,\n      });\n    }\n  }\n  // Empty values are not supplied, as on GET /__aimock/mcp/fakes.\n  const testId = searchParams.get(\"testId\") || null;\n  const context = searchParams.get(\"context\") || null;\n  return reply(200, buildFakesReport(mounts, testId, context));\n}\n"],"mappings":"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"}