@copilotkit/aimock 1.44.0 → 1.45.0

package/dist/fakes-plugin.js

@@ -0,0 +1,127 @@
+import { MCP_FAKES_DEFAULT_TEST_ID } from "./mcp-fakes.js";
+import { AimockFakesReportError, formatFakesReport } from "./mcp-fakes-report.js";
+
+//#region src/fakes-plugin.ts
+/** TI1/TI2 separator: space, U+203A, space. */
+const TEST_ID_SEPARATOR = " › ";
+const FAKES_REPORT_MODES = [
+	"off",
+	"warn",
+	"fail"
+];
+/** The `fakesReport` option, checked: an unknown mode fails `beforeAll`. */
+function fakesReportMode(mode) {
+	if (mode === void 0) return "off";
+	if (!FAKES_REPORT_MODES.includes(mode)) throw new Error(`useAimock(): fakesReport must be one of ${FAKES_REPORT_MODES.map((m) => JSON.stringify(m)).join(", ")}; got ${JSON.stringify(mode)}`);
+	return mode;
+}
+/**
+* The URL and headers that reach the fakes scoped to `testId` (and
+* `opts.context`) at `opts.mount`. `URLSearchParams` writes a space as `+`,
+* which the mount reads back as a space in the query.
+*/
+function fakesTarget(url, testId, opts = {}) {
+	const mount = opts.mount ?? "/mcp";
+	const query = new URLSearchParams({ testId });
+	const headers = { "X-Test-Id": encodeURIComponent(testId) };
+	if (opts.context) {
+		query.set("context", opts.context);
+		headers["X-AIMock-Context"] = encodeURIComponent(opts.context);
+	}
+	return {
+		testId,
+		mcpUrl: `${url}${mount}?${query.toString()}`,
+		headers
+	};
+}
+/** RP6: read `GET /__aimock/mcp/fakes/report` for one identity. */
+async function fetchFakesReport(url, testId, context) {
+	const query = new URLSearchParams();
+	if (testId !== null) query.set("testId", testId);
+	if (context !== null) query.set("context", context);
+	const res = await fetch(`${url}/__aimock/mcp/fakes/report?${query.toString()}`);
+	if (!res.ok) throw new Error(`aimock fakes report: HTTP ${res.status} ${await res.text()}`);
+	return await res.json();
+}
+function identityKey(testId, context) {
+	return `${testId ?? ""}\u0000${context ?? ""}`;
+}
+/** Per-`useAimock` state shared by the Vitest and Jest adapters. */
+var FakesPluginState = class {
+	registered = /* @__PURE__ */ new Map();
+	/** RP7 (b): id of the last journal entry when the test started (C2). */
+	marker = null;
+	constructor(mode) {
+		this.mode = mode;
+	}
+	/** Start of a test, after the match-count reset. */
+	beforeEach(llm) {
+		this.registered.clear();
+		this.marker = llm.getLastRequest()?.id ?? null;
+	}
+	/** RP7 (a): `fakesFor` registers the identity for the current test. */
+	register(testId, context) {
+		this.registered.set(identityKey(testId, context), {
+			testId,
+			context
+		});
+	}
+	/**
+	* RP7 (a) and (b): the registered identities, plus every (test id, context)
+	* an MCP request carried since the marker. If the marker entry is gone
+	* (FIFO cap or a cleared journal), every remaining entry is newer.
+	*/
+	identities(llm) {
+		const all = llm.getRequests();
+		const at = this.marker === null ? -1 : all.findIndex((e) => e.id === this.marker);
+		const newer = at >= 0 ? all.slice(at + 1) : all;
+		const out = new Map(this.registered);
+		for (const entry of newer) {
+			if (entry.service !== "mcp" || entry.testId === void 0) continue;
+			const testId = entry.testId === MCP_FAKES_DEFAULT_TEST_ID ? null : entry.testId;
+			const context = entry.context ?? null;
+			out.set(identityKey(testId, context), {
+				testId,
+				context
+			});
+		}
+		return [...out.values()];
+	}
+	/**
+	* End of a test, before the next reset: read each identity's report.
+	* Under `"fail"`, a report with `ok: false` throws `AimockFakesReportError`
+	* (the first failing report, with every failing report's text); under
+	* `"warn"`, the text goes to `console.warn`. An unconsumed entry two
+	* reports share (an entry scoped by test id only, checked with and without
+	* a context) is listed once.
+	*/
+	async afterEach(llm, url) {
+		if (this.mode === "off") return;
+		const failing = [];
+		const lines = [];
+		const unconsumedSeen = /* @__PURE__ */ new Set();
+		for (const id of this.identities(llm)) {
+			const report = await fetchFakesReport(url, id.testId, id.context);
+			if (report.ok) continue;
+			failing.push(report);
+			for (const line of formatFakesReport(report).split("\n")) {
+				if (line.startsWith("  unconsumed: ")) {
+					if (unconsumedSeen.has(line)) continue;
+					unconsumedSeen.add(line);
+				}
+				lines.push(line);
+			}
+		}
+		if (failing.length === 0) return;
+		const text = lines.join("\n");
+		if (this.mode === "warn") {
+			console.warn(text);
+			return;
+		}
+		throw new AimockFakesReportError(failing[0], text);
+	}
+};
+
+//#endregion
+export { FakesPluginState, TEST_ID_SEPARATOR, fakesReportMode, fakesTarget, fetchFakesReport };
+//# sourceMappingURL=fakes-plugin.js.map

package/dist/fakes-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fakes-plugin.js","names":[],"sources":["../src/fakes-plugin.ts"],"sourcesContent":["/**\n * The MCP fakes part of the Vitest and Jest plugins (record-replay RP7, TI):\n * `fakesFor` targets, the per-test fake report check in `afterEach`, and the\n * state both adapters share. The default test id itself is built by each\n * adapter (TI1 Vitest, TI2 Jest), and it is used only by the fakes helpers\n * (TI4): nothing here tags LLM or control traffic.\n */\nimport type { LLMock } from \"./llmock.js\";\nimport {\n  AimockFakesReportError,\n  formatFakesReport,\n  type McpFakesReport,\n} from \"./mcp-fakes-report.js\";\nimport { MCP_FAKES_DEFAULT_TEST_ID } from \"./mcp-fakes.js\";\n\n/** RP7: what `afterEach` does with a failing report. `\"off\"` is the default. */\nexport type FakesReportMode = \"off\" | \"warn\" | \"fail\";\n\n/** RP7: what `fakesFor` returns, for an MCP client. */\nexport interface FakesTarget {\n  /** The test id the URL and headers carry (explicit, or the inferred default). */\n  testId: string;\n  /** The mount URL with `?testId=` (and `&context=`). */\n  mcpUrl: string;\n  /** The matching `X-Test-Id` / `X-AIMock-Context` headers, URI-encoded. */\n  headers: Record<string, string>;\n}\n\nexport interface FakesForOptions {\n  /** The context the fake blocks are scoped to. */\n  context?: string;\n  /** The MCP mount path (default `\"/mcp\"`). */\n  mount?: string;\n}\n\n/** TI1/TI2 separator: space, U+203A, space. */\nexport const TEST_ID_SEPARATOR = \" › \";\n\nconst FAKES_REPORT_MODES: readonly FakesReportMode[] = [\"off\", \"warn\", \"fail\"];\n\n/** The `fakesReport` option, checked: an unknown mode fails `beforeAll`. */\nexport function fakesReportMode(mode: FakesReportMode | undefined): FakesReportMode {\n  if (mode === undefined) return \"off\";\n  if (!FAKES_REPORT_MODES.includes(mode)) {\n    throw new Error(\n      `useAimock(): fakesReport must be one of ${FAKES_REPORT_MODES.map((m) => JSON.stringify(m)).join(\", \")}; got ${JSON.stringify(mode)}`,\n    );\n  }\n  return mode;\n}\n\n/**\n * The URL and headers that reach the fakes scoped to `testId` (and\n * `opts.context`) at `opts.mount`. `URLSearchParams` writes a space as `+`,\n * which the mount reads back as a space in the query.\n */\nexport function fakesTarget(url: string, testId: string, opts: FakesForOptions = {}): FakesTarget {\n  const mount = opts.mount ?? \"/mcp\";\n  const query = new URLSearchParams({ testId });\n  const headers: Record<string, string> = { \"X-Test-Id\": encodeURIComponent(testId) };\n  if (opts.context) {\n    query.set(\"context\", opts.context);\n    headers[\"X-AIMock-Context\"] = encodeURIComponent(opts.context);\n  }\n  return { testId, mcpUrl: `${url}${mount}?${query.toString()}`, headers };\n}\n\n/** RP6: read `GET /__aimock/mcp/fakes/report` for one identity. */\nexport async function fetchFakesReport(\n  url: string,\n  testId: string | null,\n  context: string | null,\n): Promise<McpFakesReport> {\n  const query = new URLSearchParams();\n  if (testId !== null) query.set(\"testId\", testId);\n  if (context !== null) query.set(\"context\", context);\n  const res = await fetch(`${url}/__aimock/mcp/fakes/report?${query.toString()}`);\n  if (!res.ok) {\n    throw new Error(`aimock fakes report: HTTP ${res.status} ${await res.text()}`);\n  }\n  return (await res.json()) as McpFakesReport;\n}\n\n/** One identity the report checks; `null` means none supplied. */\nexport interface FakesIdentity {\n  testId: string | null;\n  context: string | null;\n}\n\nfunction identityKey(testId: string | null, context: string | null): string {\n  return `${testId ?? \"\"}\\u0000${context ?? \"\"}`;\n}\n\n/** Per-`useAimock` state shared by the Vitest and Jest adapters. */\nexport class FakesPluginState {\n  private readonly registered = new Map<string, FakesIdentity>();\n  /** RP7 (b): id of the last journal entry when the test started (C2). */\n  private marker: string | null = null;\n\n  constructor(readonly mode: FakesReportMode) {}\n\n  /** Start of a test, after the match-count reset. */\n  beforeEach(llm: LLMock): void {\n    this.registered.clear();\n    this.marker = llm.getLastRequest()?.id ?? null;\n  }\n\n  /** RP7 (a): `fakesFor` registers the identity for the current test. */\n  register(testId: string, context: string | null): void {\n    this.registered.set(identityKey(testId, context), { testId, context });\n  }\n\n  /**\n   * RP7 (a) and (b): the registered identities, plus every (test id, context)\n   * an MCP request carried since the marker. If the marker entry is gone\n   * (FIFO cap or a cleared journal), every remaining entry is newer.\n   */\n  identities(llm: LLMock): FakesIdentity[] {\n    const all = llm.getRequests();\n    const at = this.marker === null ? -1 : all.findIndex((e) => e.id === this.marker);\n    const newer = at >= 0 ? all.slice(at + 1) : all;\n    const out = new Map(this.registered);\n    for (const entry of newer) {\n      if (entry.service !== \"mcp\" || entry.testId === undefined) continue;\n      const testId = entry.testId === MCP_FAKES_DEFAULT_TEST_ID ? null : entry.testId;\n      const context = entry.context ?? null;\n      out.set(identityKey(testId, context), { testId, context });\n    }\n    return [...out.values()];\n  }\n\n  /**\n   * End of a test, before the next reset: read each identity's report.\n   * Under `\"fail\"`, a report with `ok: false` throws `AimockFakesReportError`\n   * (the first failing report, with every failing report's text); under\n   * `\"warn\"`, the text goes to `console.warn`. An unconsumed entry two\n   * reports share (an entry scoped by test id only, checked with and without\n   * a context) is listed once.\n   */\n  async afterEach(llm: LLMock, url: string): Promise<void> {\n    if (this.mode === \"off\") return;\n    const failing: McpFakesReport[] = [];\n    const lines: string[] = [];\n    const unconsumedSeen = new Set<string>();\n    for (const id of this.identities(llm)) {\n      const report = await fetchFakesReport(url, id.testId, id.context);\n      if (report.ok) continue;\n      failing.push(report);\n      for (const line of formatFakesReport(report).split(\"\\n\")) {\n        if (line.startsWith(\"  unconsumed: \")) {\n          if (unconsumedSeen.has(line)) continue;\n          unconsumedSeen.add(line);\n        }\n        lines.push(line);\n      }\n    }\n    if (failing.length === 0) return;\n    const text = lines.join(\"\\n\");\n    if (this.mode === \"warn\") {\n      console.warn(text);\n      return;\n    }\n    throw new AimockFakesReportError(failing[0], text);\n  }\n}\n"],"mappings":"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"}

package/dist/fixture-loader-services.cjs

@@ -53,7 +53,7 @@ function loadServicesFile(filePath, source, load, logger, liveOptions) {
 			raw
 		});
 	}
-	out.fixtures.push(...require_fixture_loader.fixturesOf(parsed, filePath, logger, liveOptions, withFakes));
+	out.fixtures.push(...require_fixture_loader.fixturesOf(parsed, filePath, logger, liveOptions, withFakes, source));
 }
 /**
 * The result of a finished load, or its errors thrown: the one

package/dist/fixture-loader-services.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"fixture-loader-services.cjs","names":["readFixtureJson","hasMcpFakesKey","validateMcpFakes","fixturesOf","McpFakesAddError","listFixtureDir"],"sources":["../src/fixture-loader-services.ts"],"sourcesContent":["/**\n * Fixture loaders that carry MCP fakes (spec F1): the `…WithServices`\n * variants of `loadFixtureFile` / `loadFixturesFromDir`. They return the LLM\n * fixtures and the raw `mcpFakes` blocks with their entry-id `source` (I6).\n *\n * They live outside fixture-loader.ts because they validate blocks with\n * `validateMcpFakes`, and mcp-fakes.ts imports `FixtureLoadError` from\n * fixture-loader.ts at module load (`McpFakesAddError extends\n * FixtureLoadError`): a value import of mcp-fakes.ts from fixture-loader.ts\n * is an import cycle that leaves `FixtureLoadError` uninitialized whenever\n * fixture-loader.ts is loaded first.\n */\nimport { join } from \"node:path\";\nimport type { LiveOptions } from \"./live-types.js\";\nimport type { Logger } from \"./logger.js\";\nimport {\n  fixturesOf,\n  hasMcpFakesKey,\n  listFixtureDir,\n  readFixtureJson,\n  type FixtureLoadError,\n} from \"./fixture-loader.js\";\nimport { McpFakesAddError, validateMcpFakes, type McpFakeIssue } from \"./mcp-fakes.js\";\nimport type { Fixture, McpFakeSource } from \"./types.js\";\n\n/** What {@link loadFixtureFileWithServices} and {@link loadFixturesFromDirWithServices} return. */\nexport interface FixturesWithServices {\n  /** LLM fixtures, as the old loaders return them. */\n  fixtures: Fixture[];\n  /**\n   * The raw `mcpFakes` blocks, one per block, in load order, each with its\n   * entry-id `source` (spec I6) and `blockIndex` (`null` for the\n   * single-object form). Validated per file; checks across files and loads\n   * (entry-id collisions) happen when a mount adds them.\n   */\n  mcpFakes: McpFakeSource[];\n  /** Shadowed-entry warnings (L8) of those blocks, for the caller to print. */\n  mcpFakeWarnings: McpFakeIssue[];\n  /**\n   * The entry-id `source` (I6) of each file that could not be read or was\n   * not valid JSON. Such a file is warned and skipped, as before, so it adds\n   * no fixtures and no blocks; a `--watch` reload uses this list to tell a\n   * file it could not parse from a file whose `mcpFakes` were removed.\n   */\n  unreadable: string[];\n}\n\n/** A load in progress: the result, plus every bad-block error of every file. */\ninterface ServicesLoad {\n  out: FixturesWithServices;\n  errors: FixtureLoadError[];\n}\n\n/**\n * Load one parsed file into `load.out`: its `mcpFakes` blocks under\n * `source`, then its LLM fixtures. A file with a bad block adds nothing; its\n * errors go to `load.errors`, and the load goes on so every bad block of\n * every file is reported (fail-loud rule, spec 5.4; L3). Its L8 warnings are\n * kept either way.\n */\nfunction loadServicesFile(\n  filePath: string,\n  source: string,\n  load: ServicesLoad,\n  logger: Logger | undefined,\n  liveOptions: LiveOptions | undefined,\n): void {\n  const { out } = load;\n  const read = readFixtureJson(filePath, logger);\n  if (read === null) {\n    out.unreadable.push(source);\n    return;\n  }\n  const parsed = read.value;\n  const withFakes = hasMcpFakesKey(parsed);\n  if (withFakes) {\n    const raw = parsed.mcpFakes;\n    const validation = validateMcpFakes(raw, source);\n    out.mcpFakeWarnings.push(...validation.warnings);\n    if (validation.errors.length > 0) {\n      load.errors.push(...validation.errors);\n      return;\n    }\n    if (Array.isArray(raw)) {\n      raw.forEach((block: unknown, blockIndex: number) => {\n        out.mcpFakes.push({ source, blockIndex, raw: block });\n      });\n    } else {\n      out.mcpFakes.push({ source, blockIndex: null, raw });\n    }\n  }\n  out.fixtures.push(...fixturesOf(parsed, filePath, logger, liveOptions, withFakes));\n}\n\n/**\n * The result of a finished load, or its errors thrown: the one\n * `FixtureLoadError` alone, else a `McpFakesAddError` holding every error and\n * the L8 warnings, so no warning is lost when the load fails.\n */\nfunction finish(load: ServicesLoad): FixturesWithServices {\n  const { out, errors } = load;\n  const [first] = errors;\n  if (first === undefined) return out;\n  if (errors.length === 1 && out.mcpFakeWarnings.length === 0) throw first;\n  throw new McpFakesAddError(errors, out.mcpFakeWarnings);\n}\n\nfunction newLoad(): ServicesLoad {\n  return { out: { fixtures: [], mcpFakes: [], mcpFakeWarnings: [], unreadable: [] }, errors: [] };\n}\n\n/**\n * Load one fixture file: its LLM fixtures and its `mcpFakes` blocks. A\n * fakes-only file is accepted. The blocks' `source` (spec I6) is `filePath`\n * as given, or `sourceLabel` when set (the URL of a remote fixture file).\n * A bad block throws a `FixtureLoadError` (a `McpFakesAddError` when there\n * is more than one error, or L8 warnings to keep with it).\n */\nexport function loadFixtureFileWithServices(\n  filePath: string,\n  logger?: Logger,\n  liveOptions?: LiveOptions,\n  sourceLabel?: string,\n): FixturesWithServices {\n  const load = newLoad();\n  loadServicesFile(filePath, sourceLabel ?? filePath, load, logger, liveOptions);\n  return finish(load);\n}\n\nfunction loadServicesDir(\n  dirPath: string,\n  relDir: string,\n  load: ServicesLoad,\n  logger: Logger | undefined,\n  liveOptions: LiveOptions | undefined,\n): void {\n  const listing = listFixtureDir(dirPath, logger);\n  if (listing === null) return;\n  for (const name of listing.jsonFiles) {\n    loadServicesFile(join(dirPath, name), relDir + name, load, logger, liveOptions);\n  }\n  for (const sub of listing.subdirs) {\n    loadServicesDir(join(dirPath, sub), `${relDir}${sub}/`, load, logger, liveOptions);\n  }\n}\n\n/**\n * Load every `.json` file under `dirPath` (sorted, then subdirectories, at\n * full depth, as {@link loadFixturesFromDir}): LLM fixtures and `mcpFakes`\n * blocks. Each block's `source` (spec I6) is its file's path relative to\n * `dirPath`, with `/` separators. Every file is checked before anything is\n * thrown: the bad blocks of all files are reported together, as in\n * {@link loadFixtureFileWithServices}.\n */\nexport function loadFixturesFromDirWithServices(\n  dirPath: string,\n  logger?: Logger,\n  liveOptions?: LiveOptions,\n): FixturesWithServices {\n  const load = newLoad();\n  loadServicesDir(dirPath, \"\", load, logger, liveOptions);\n  return finish(load);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,SAAS,iBACP,UACA,QACA,MACA,QACA,aACM;CACN,MAAM,EAAE,QAAQ;CAChB,MAAM,OAAOA,uCAAgB,UAAU,OAAO;AAC9C,KAAI,SAAS,MAAM;AACjB,MAAI,WAAW,KAAK,OAAO;AAC3B;;CAEF,MAAM,SAAS,KAAK;CACpB,MAAM,YAAYC,sCAAe,OAAO;AACxC,KAAI,WAAW;EACb,MAAM,MAAM,OAAO;EACnB,MAAM,aAAaC,mCAAiB,KAAK,OAAO;AAChD,MAAI,gBAAgB,KAAK,GAAG,WAAW,SAAS;AAChD,MAAI,WAAW,OAAO,SAAS,GAAG;AAChC,QAAK,OAAO,KAAK,GAAG,WAAW,OAAO;AACtC;;AAEF,MAAI,MAAM,QAAQ,IAAI,CACpB,KAAI,SAAS,OAAgB,eAAuB;AAClD,OAAI,SAAS,KAAK;IAAE;IAAQ;IAAY,KAAK;IAAO,CAAC;IACrD;MAEF,KAAI,SAAS,KAAK;GAAE;GAAQ,YAAY;GAAM;GAAK,CAAC;;AAGxD,KAAI,SAAS,KAAK,GAAGC,kCAAW,QAAQ,UAAU,QAAQ,aAAa,UAAU,CAAC;;;;;;;AAQpF,SAAS,OAAO,MAA0C;CACxD,MAAM,EAAE,KAAK,WAAW;CACxB,MAAM,CAAC,SAAS;AAChB,KAAI,UAAU,OAAW,QAAO;AAChC,KAAI,OAAO,WAAW,KAAK,IAAI,gBAAgB,WAAW,EAAG,OAAM;AACnE,OAAM,IAAIC,mCAAiB,QAAQ,IAAI,gBAAgB;;AAGzD,SAAS,UAAwB;AAC/B,QAAO;EAAE,KAAK;GAAE,UAAU,EAAE;GAAE,UAAU,EAAE;GAAE,iBAAiB,EAAE;GAAE,YAAY,EAAE;GAAE;EAAE,QAAQ,EAAE;EAAE;;;;;;;;;AAUjG,SAAgB,4BACd,UACA,QACA,aACA,aACsB;CACtB,MAAM,OAAO,SAAS;AACtB,kBAAiB,UAAU,eAAe,UAAU,MAAM,QAAQ,YAAY;AAC9E,QAAO,OAAO,KAAK;;AAGrB,SAAS,gBACP,SACA,QACA,MACA,QACA,aACM;CACN,MAAM,UAAUC,sCAAe,SAAS,OAAO;AAC/C,KAAI,YAAY,KAAM;AACtB,MAAK,MAAM,QAAQ,QAAQ,UACzB,sCAAsB,SAAS,KAAK,EAAE,SAAS,MAAM,MAAM,QAAQ,YAAY;AAEjF,MAAK,MAAM,OAAO,QAAQ,QACxB,qCAAqB,SAAS,IAAI,EAAE,GAAG,SAAS,IAAI,IAAI,MAAM,QAAQ,YAAY;;;;;;;;;;AAYtF,SAAgB,gCACd,SACA,QACA,aACsB;CACtB,MAAM,OAAO,SAAS;AACtB,iBAAgB,SAAS,IAAI,MAAM,QAAQ,YAAY;AACvD,QAAO,OAAO,KAAK"}
+{"version":3,"file":"fixture-loader-services.cjs","names":["readFixtureJson","hasMcpFakesKey","validateMcpFakes","fixturesOf","McpFakesAddError","listFixtureDir"],"sources":["../src/fixture-loader-services.ts"],"sourcesContent":["/**\n * Fixture loaders that carry MCP fakes (spec F1): the `…WithServices`\n * variants of `loadFixtureFile` / `loadFixturesFromDir`. They return the LLM\n * fixtures and the raw `mcpFakes` blocks with their entry-id `source` (I6).\n *\n * They live outside fixture-loader.ts because they validate blocks with\n * `validateMcpFakes`, and mcp-fakes.ts imports `FixtureLoadError` from\n * fixture-loader.ts at module load (`McpFakesAddError extends\n * FixtureLoadError`): a value import of mcp-fakes.ts from fixture-loader.ts\n * is an import cycle that leaves `FixtureLoadError` uninitialized whenever\n * fixture-loader.ts is loaded first.\n */\nimport { join } from \"node:path\";\nimport type { LiveOptions } from \"./live-types.js\";\nimport type { Logger } from \"./logger.js\";\nimport {\n  fixturesOf,\n  hasMcpFakesKey,\n  listFixtureDir,\n  readFixtureJson,\n  type FixtureLoadError,\n} from \"./fixture-loader.js\";\nimport { McpFakesAddError, validateMcpFakes, type McpFakeIssue } from \"./mcp-fakes.js\";\nimport type { Fixture, McpFakeSource } from \"./types.js\";\n\n/** What {@link loadFixtureFileWithServices} and {@link loadFixturesFromDirWithServices} return. */\nexport interface FixturesWithServices {\n  /** LLM fixtures, as the old loaders return them. */\n  fixtures: Fixture[];\n  /**\n   * The raw `mcpFakes` blocks, one per block, in load order, each with its\n   * entry-id `source` (spec I6) and `blockIndex` (`null` for the\n   * single-object form). Validated per file; checks across files and loads\n   * (entry-id collisions) happen when a mount adds them.\n   */\n  mcpFakes: McpFakeSource[];\n  /** Shadowed-entry warnings (L8) of those blocks, for the caller to print. */\n  mcpFakeWarnings: McpFakeIssue[];\n  /**\n   * The entry-id `source` (I6) of each file that could not be read or was\n   * not valid JSON. Such a file is warned and skipped, as before, so it adds\n   * no fixtures and no blocks; a `--watch` reload uses this list to tell a\n   * file it could not parse from a file whose `mcpFakes` were removed.\n   */\n  unreadable: string[];\n}\n\n/** A load in progress: the result, plus every bad-block error of every file. */\ninterface ServicesLoad {\n  out: FixturesWithServices;\n  errors: FixtureLoadError[];\n}\n\n/**\n * Load one parsed file into `load.out`: its `mcpFakes` blocks under\n * `source`, then its LLM fixtures. A file with a bad block adds nothing; its\n * errors go to `load.errors`, and the load goes on so every bad block of\n * every file is reported (fail-loud rule, spec 5.4; L3). Its L8 warnings are\n * kept either way.\n */\nfunction loadServicesFile(\n  filePath: string,\n  source: string,\n  load: ServicesLoad,\n  logger: Logger | undefined,\n  liveOptions: LiveOptions | undefined,\n): void {\n  const { out } = load;\n  const read = readFixtureJson(filePath, logger);\n  if (read === null) {\n    out.unreadable.push(source);\n    return;\n  }\n  const parsed = read.value;\n  const withFakes = hasMcpFakesKey(parsed);\n  if (withFakes) {\n    const raw = parsed.mcpFakes;\n    const validation = validateMcpFakes(raw, source);\n    out.mcpFakeWarnings.push(...validation.warnings);\n    if (validation.errors.length > 0) {\n      load.errors.push(...validation.errors);\n      return;\n    }\n    if (Array.isArray(raw)) {\n      raw.forEach((block: unknown, blockIndex: number) => {\n        out.mcpFakes.push({ source, blockIndex, raw: block });\n      });\n    } else {\n      out.mcpFakes.push({ source, blockIndex: null, raw });\n    }\n  }\n  out.fixtures.push(...fixturesOf(parsed, filePath, logger, liveOptions, withFakes, source));\n}\n\n/**\n * The result of a finished load, or its errors thrown: the one\n * `FixtureLoadError` alone, else a `McpFakesAddError` holding every error and\n * the L8 warnings, so no warning is lost when the load fails.\n */\nfunction finish(load: ServicesLoad): FixturesWithServices {\n  const { out, errors } = load;\n  const [first] = errors;\n  if (first === undefined) return out;\n  if (errors.length === 1 && out.mcpFakeWarnings.length === 0) throw first;\n  throw new McpFakesAddError(errors, out.mcpFakeWarnings);\n}\n\nfunction newLoad(): ServicesLoad {\n  return { out: { fixtures: [], mcpFakes: [], mcpFakeWarnings: [], unreadable: [] }, errors: [] };\n}\n\n/**\n * Load one fixture file: its LLM fixtures and its `mcpFakes` blocks. A\n * fakes-only file is accepted. The blocks' `source` (spec I6) is `filePath`\n * as given, or `sourceLabel` when set (the URL of a remote fixture file).\n * A bad block throws a `FixtureLoadError` (a `McpFakesAddError` when there\n * is more than one error, or L8 warnings to keep with it).\n */\nexport function loadFixtureFileWithServices(\n  filePath: string,\n  logger?: Logger,\n  liveOptions?: LiveOptions,\n  sourceLabel?: string,\n): FixturesWithServices {\n  const load = newLoad();\n  loadServicesFile(filePath, sourceLabel ?? filePath, load, logger, liveOptions);\n  return finish(load);\n}\n\nfunction loadServicesDir(\n  dirPath: string,\n  relDir: string,\n  load: ServicesLoad,\n  logger: Logger | undefined,\n  liveOptions: LiveOptions | undefined,\n): void {\n  const listing = listFixtureDir(dirPath, logger);\n  if (listing === null) return;\n  for (const name of listing.jsonFiles) {\n    loadServicesFile(join(dirPath, name), relDir + name, load, logger, liveOptions);\n  }\n  for (const sub of listing.subdirs) {\n    loadServicesDir(join(dirPath, sub), `${relDir}${sub}/`, load, logger, liveOptions);\n  }\n}\n\n/**\n * Load every `.json` file under `dirPath` (sorted, then subdirectories, at\n * full depth, as {@link loadFixturesFromDir}): LLM fixtures and `mcpFakes`\n * blocks. Each block's `source` (spec I6) is its file's path relative to\n * `dirPath`, with `/` separators. Every file is checked before anything is\n * thrown: the bad blocks of all files are reported together, as in\n * {@link loadFixtureFileWithServices}.\n */\nexport function loadFixturesFromDirWithServices(\n  dirPath: string,\n  logger?: Logger,\n  liveOptions?: LiveOptions,\n): FixturesWithServices {\n  const load = newLoad();\n  loadServicesDir(dirPath, \"\", load, logger, liveOptions);\n  return finish(load);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,SAAS,iBACP,UACA,QACA,MACA,QACA,aACM;CACN,MAAM,EAAE,QAAQ;CAChB,MAAM,OAAOA,uCAAgB,UAAU,OAAO;AAC9C,KAAI,SAAS,MAAM;AACjB,MAAI,WAAW,KAAK,OAAO;AAC3B;;CAEF,MAAM,SAAS,KAAK;CACpB,MAAM,YAAYC,sCAAe,OAAO;AACxC,KAAI,WAAW;EACb,MAAM,MAAM,OAAO;EACnB,MAAM,aAAaC,mCAAiB,KAAK,OAAO;AAChD,MAAI,gBAAgB,KAAK,GAAG,WAAW,SAAS;AAChD,MAAI,WAAW,OAAO,SAAS,GAAG;AAChC,QAAK,OAAO,KAAK,GAAG,WAAW,OAAO;AACtC;;AAEF,MAAI,MAAM,QAAQ,IAAI,CACpB,KAAI,SAAS,OAAgB,eAAuB;AAClD,OAAI,SAAS,KAAK;IAAE;IAAQ;IAAY,KAAK;IAAO,CAAC;IACrD;MAEF,KAAI,SAAS,KAAK;GAAE;GAAQ,YAAY;GAAM;GAAK,CAAC;;AAGxD,KAAI,SAAS,KAAK,GAAGC,kCAAW,QAAQ,UAAU,QAAQ,aAAa,WAAW,OAAO,CAAC;;;;;;;AAQ5F,SAAS,OAAO,MAA0C;CACxD,MAAM,EAAE,KAAK,WAAW;CACxB,MAAM,CAAC,SAAS;AAChB,KAAI,UAAU,OAAW,QAAO;AAChC,KAAI,OAAO,WAAW,KAAK,IAAI,gBAAgB,WAAW,EAAG,OAAM;AACnE,OAAM,IAAIC,mCAAiB,QAAQ,IAAI,gBAAgB;;AAGzD,SAAS,UAAwB;AAC/B,QAAO;EAAE,KAAK;GAAE,UAAU,EAAE;GAAE,UAAU,EAAE;GAAE,iBAAiB,EAAE;GAAE,YAAY,EAAE;GAAE;EAAE,QAAQ,EAAE;EAAE;;;;;;;;;AAUjG,SAAgB,4BACd,UACA,QACA,aACA,aACsB;CACtB,MAAM,OAAO,SAAS;AACtB,kBAAiB,UAAU,eAAe,UAAU,MAAM,QAAQ,YAAY;AAC9E,QAAO,OAAO,KAAK;;AAGrB,SAAS,gBACP,SACA,QACA,MACA,QACA,aACM;CACN,MAAM,UAAUC,sCAAe,SAAS,OAAO;AAC/C,KAAI,YAAY,KAAM;AACtB,MAAK,MAAM,QAAQ,QAAQ,UACzB,sCAAsB,SAAS,KAAK,EAAE,SAAS,MAAM,MAAM,QAAQ,YAAY;AAEjF,MAAK,MAAM,OAAO,QAAQ,QACxB,qCAAqB,SAAS,IAAI,EAAE,GAAG,SAAS,IAAI,IAAI,MAAM,QAAQ,YAAY;;;;;;;;;;AAYtF,SAAgB,gCACd,SACA,QACA,aACsB;CACtB,MAAM,OAAO,SAAS;AACtB,iBAAgB,SAAS,IAAI,MAAM,QAAQ,YAAY;AACvD,QAAO,OAAO,KAAK"}

package/dist/fixture-loader-services.js

@@ -52,7 +52,7 @@ function loadServicesFile(filePath, source, load, logger, liveOptions) {
 			raw
 		});
 	}
-	out.fixtures.push(...fixturesOf(parsed, filePath, logger, liveOptions, withFakes));
+	out.fixtures.push(...fixturesOf(parsed, filePath, logger, liveOptions, withFakes, source));
 }
 /**
 * The result of a finished load, or its errors thrown: the one

package/dist/fixture-loader-services.js.map

@@ -1 +1 @@
-{"version":3,"file":"fixture-loader-services.js","names":[],"sources":["../src/fixture-loader-services.ts"],"sourcesContent":["/**\n * Fixture loaders that carry MCP fakes (spec F1): the `…WithServices`\n * variants of `loadFixtureFile` / `loadFixturesFromDir`. They return the LLM\n * fixtures and the raw `mcpFakes` blocks with their entry-id `source` (I6).\n *\n * They live outside fixture-loader.ts because they validate blocks with\n * `validateMcpFakes`, and mcp-fakes.ts imports `FixtureLoadError` from\n * fixture-loader.ts at module load (`McpFakesAddError extends\n * FixtureLoadError`): a value import of mcp-fakes.ts from fixture-loader.ts\n * is an import cycle that leaves `FixtureLoadError` uninitialized whenever\n * fixture-loader.ts is loaded first.\n */\nimport { join } from \"node:path\";\nimport type { LiveOptions } from \"./live-types.js\";\nimport type { Logger } from \"./logger.js\";\nimport {\n  fixturesOf,\n  hasMcpFakesKey,\n  listFixtureDir,\n  readFixtureJson,\n  type FixtureLoadError,\n} from \"./fixture-loader.js\";\nimport { McpFakesAddError, validateMcpFakes, type McpFakeIssue } from \"./mcp-fakes.js\";\nimport type { Fixture, McpFakeSource } from \"./types.js\";\n\n/** What {@link loadFixtureFileWithServices} and {@link loadFixturesFromDirWithServices} return. */\nexport interface FixturesWithServices {\n  /** LLM fixtures, as the old loaders return them. */\n  fixtures: Fixture[];\n  /**\n   * The raw `mcpFakes` blocks, one per block, in load order, each with its\n   * entry-id `source` (spec I6) and `blockIndex` (`null` for the\n   * single-object form). Validated per file; checks across files and loads\n   * (entry-id collisions) happen when a mount adds them.\n   */\n  mcpFakes: McpFakeSource[];\n  /** Shadowed-entry warnings (L8) of those blocks, for the caller to print. */\n  mcpFakeWarnings: McpFakeIssue[];\n  /**\n   * The entry-id `source` (I6) of each file that could not be read or was\n   * not valid JSON. Such a file is warned and skipped, as before, so it adds\n   * no fixtures and no blocks; a `--watch` reload uses this list to tell a\n   * file it could not parse from a file whose `mcpFakes` were removed.\n   */\n  unreadable: string[];\n}\n\n/** A load in progress: the result, plus every bad-block error of every file. */\ninterface ServicesLoad {\n  out: FixturesWithServices;\n  errors: FixtureLoadError[];\n}\n\n/**\n * Load one parsed file into `load.out`: its `mcpFakes` blocks under\n * `source`, then its LLM fixtures. A file with a bad block adds nothing; its\n * errors go to `load.errors`, and the load goes on so every bad block of\n * every file is reported (fail-loud rule, spec 5.4; L3). Its L8 warnings are\n * kept either way.\n */\nfunction loadServicesFile(\n  filePath: string,\n  source: string,\n  load: ServicesLoad,\n  logger: Logger | undefined,\n  liveOptions: LiveOptions | undefined,\n): void {\n  const { out } = load;\n  const read = readFixtureJson(filePath, logger);\n  if (read === null) {\n    out.unreadable.push(source);\n    return;\n  }\n  const parsed = read.value;\n  const withFakes = hasMcpFakesKey(parsed);\n  if (withFakes) {\n    const raw = parsed.mcpFakes;\n    const validation = validateMcpFakes(raw, source);\n    out.mcpFakeWarnings.push(...validation.warnings);\n    if (validation.errors.length > 0) {\n      load.errors.push(...validation.errors);\n      return;\n    }\n    if (Array.isArray(raw)) {\n      raw.forEach((block: unknown, blockIndex: number) => {\n        out.mcpFakes.push({ source, blockIndex, raw: block });\n      });\n    } else {\n      out.mcpFakes.push({ source, blockIndex: null, raw });\n    }\n  }\n  out.fixtures.push(...fixturesOf(parsed, filePath, logger, liveOptions, withFakes));\n}\n\n/**\n * The result of a finished load, or its errors thrown: the one\n * `FixtureLoadError` alone, else a `McpFakesAddError` holding every error and\n * the L8 warnings, so no warning is lost when the load fails.\n */\nfunction finish(load: ServicesLoad): FixturesWithServices {\n  const { out, errors } = load;\n  const [first] = errors;\n  if (first === undefined) return out;\n  if (errors.length === 1 && out.mcpFakeWarnings.length === 0) throw first;\n  throw new McpFakesAddError(errors, out.mcpFakeWarnings);\n}\n\nfunction newLoad(): ServicesLoad {\n  return { out: { fixtures: [], mcpFakes: [], mcpFakeWarnings: [], unreadable: [] }, errors: [] };\n}\n\n/**\n * Load one fixture file: its LLM fixtures and its `mcpFakes` blocks. A\n * fakes-only file is accepted. The blocks' `source` (spec I6) is `filePath`\n * as given, or `sourceLabel` when set (the URL of a remote fixture file).\n * A bad block throws a `FixtureLoadError` (a `McpFakesAddError` when there\n * is more than one error, or L8 warnings to keep with it).\n */\nexport function loadFixtureFileWithServices(\n  filePath: string,\n  logger?: Logger,\n  liveOptions?: LiveOptions,\n  sourceLabel?: string,\n): FixturesWithServices {\n  const load = newLoad();\n  loadServicesFile(filePath, sourceLabel ?? filePath, load, logger, liveOptions);\n  return finish(load);\n}\n\nfunction loadServicesDir(\n  dirPath: string,\n  relDir: string,\n  load: ServicesLoad,\n  logger: Logger | undefined,\n  liveOptions: LiveOptions | undefined,\n): void {\n  const listing = listFixtureDir(dirPath, logger);\n  if (listing === null) return;\n  for (const name of listing.jsonFiles) {\n    loadServicesFile(join(dirPath, name), relDir + name, load, logger, liveOptions);\n  }\n  for (const sub of listing.subdirs) {\n    loadServicesDir(join(dirPath, sub), `${relDir}${sub}/`, load, logger, liveOptions);\n  }\n}\n\n/**\n * Load every `.json` file under `dirPath` (sorted, then subdirectories, at\n * full depth, as {@link loadFixturesFromDir}): LLM fixtures and `mcpFakes`\n * blocks. Each block's `source` (spec I6) is its file's path relative to\n * `dirPath`, with `/` separators. Every file is checked before anything is\n * thrown: the bad blocks of all files are reported together, as in\n * {@link loadFixtureFileWithServices}.\n */\nexport function loadFixturesFromDirWithServices(\n  dirPath: string,\n  logger?: Logger,\n  liveOptions?: LiveOptions,\n): FixturesWithServices {\n  const load = newLoad();\n  loadServicesDir(dirPath, \"\", load, logger, liveOptions);\n  return finish(load);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA4DA,SAAS,iBACP,UACA,QACA,MACA,QACA,aACM;CACN,MAAM,EAAE,QAAQ;CAChB,MAAM,OAAO,gBAAgB,UAAU,OAAO;AAC9C,KAAI,SAAS,MAAM;AACjB,MAAI,WAAW,KAAK,OAAO;AAC3B;;CAEF,MAAM,SAAS,KAAK;CACpB,MAAM,YAAY,eAAe,OAAO;AACxC,KAAI,WAAW;EACb,MAAM,MAAM,OAAO;EACnB,MAAM,aAAa,iBAAiB,KAAK,OAAO;AAChD,MAAI,gBAAgB,KAAK,GAAG,WAAW,SAAS;AAChD,MAAI,WAAW,OAAO,SAAS,GAAG;AAChC,QAAK,OAAO,KAAK,GAAG,WAAW,OAAO;AACtC;;AAEF,MAAI,MAAM,QAAQ,IAAI,CACpB,KAAI,SAAS,OAAgB,eAAuB;AAClD,OAAI,SAAS,KAAK;IAAE;IAAQ;IAAY,KAAK;IAAO,CAAC;IACrD;MAEF,KAAI,SAAS,KAAK;GAAE;GAAQ,YAAY;GAAM;GAAK,CAAC;;AAGxD,KAAI,SAAS,KAAK,GAAG,WAAW,QAAQ,UAAU,QAAQ,aAAa,UAAU,CAAC;;;;;;;AAQpF,SAAS,OAAO,MAA0C;CACxD,MAAM,EAAE,KAAK,WAAW;CACxB,MAAM,CAAC,SAAS;AAChB,KAAI,UAAU,OAAW,QAAO;AAChC,KAAI,OAAO,WAAW,KAAK,IAAI,gBAAgB,WAAW,EAAG,OAAM;AACnE,OAAM,IAAI,iBAAiB,QAAQ,IAAI,gBAAgB;;AAGzD,SAAS,UAAwB;AAC/B,QAAO;EAAE,KAAK;GAAE,UAAU,EAAE;GAAE,UAAU,EAAE;GAAE,iBAAiB,EAAE;GAAE,YAAY,EAAE;GAAE;EAAE,QAAQ,EAAE;EAAE;;;;;;;;;AAUjG,SAAgB,4BACd,UACA,QACA,aACA,aACsB;CACtB,MAAM,OAAO,SAAS;AACtB,kBAAiB,UAAU,eAAe,UAAU,MAAM,QAAQ,YAAY;AAC9E,QAAO,OAAO,KAAK;;AAGrB,SAAS,gBACP,SACA,QACA,MACA,QACA,aACM;CACN,MAAM,UAAU,eAAe,SAAS,OAAO;AAC/C,KAAI,YAAY,KAAM;AACtB,MAAK,MAAM,QAAQ,QAAQ,UACzB,kBAAiB,KAAK,SAAS,KAAK,EAAE,SAAS,MAAM,MAAM,QAAQ,YAAY;AAEjF,MAAK,MAAM,OAAO,QAAQ,QACxB,iBAAgB,KAAK,SAAS,IAAI,EAAE,GAAG,SAAS,IAAI,IAAI,MAAM,QAAQ,YAAY;;;;;;;;;;AAYtF,SAAgB,gCACd,SACA,QACA,aACsB;CACtB,MAAM,OAAO,SAAS;AACtB,iBAAgB,SAAS,IAAI,MAAM,QAAQ,YAAY;AACvD,QAAO,OAAO,KAAK"}
+{"version":3,"file":"fixture-loader-services.js","names":[],"sources":["../src/fixture-loader-services.ts"],"sourcesContent":["/**\n * Fixture loaders that carry MCP fakes (spec F1): the `…WithServices`\n * variants of `loadFixtureFile` / `loadFixturesFromDir`. They return the LLM\n * fixtures and the raw `mcpFakes` blocks with their entry-id `source` (I6).\n *\n * They live outside fixture-loader.ts because they validate blocks with\n * `validateMcpFakes`, and mcp-fakes.ts imports `FixtureLoadError` from\n * fixture-loader.ts at module load (`McpFakesAddError extends\n * FixtureLoadError`): a value import of mcp-fakes.ts from fixture-loader.ts\n * is an import cycle that leaves `FixtureLoadError` uninitialized whenever\n * fixture-loader.ts is loaded first.\n */\nimport { join } from \"node:path\";\nimport type { LiveOptions } from \"./live-types.js\";\nimport type { Logger } from \"./logger.js\";\nimport {\n  fixturesOf,\n  hasMcpFakesKey,\n  listFixtureDir,\n  readFixtureJson,\n  type FixtureLoadError,\n} from \"./fixture-loader.js\";\nimport { McpFakesAddError, validateMcpFakes, type McpFakeIssue } from \"./mcp-fakes.js\";\nimport type { Fixture, McpFakeSource } from \"./types.js\";\n\n/** What {@link loadFixtureFileWithServices} and {@link loadFixturesFromDirWithServices} return. */\nexport interface FixturesWithServices {\n  /** LLM fixtures, as the old loaders return them. */\n  fixtures: Fixture[];\n  /**\n   * The raw `mcpFakes` blocks, one per block, in load order, each with its\n   * entry-id `source` (spec I6) and `blockIndex` (`null` for the\n   * single-object form). Validated per file; checks across files and loads\n   * (entry-id collisions) happen when a mount adds them.\n   */\n  mcpFakes: McpFakeSource[];\n  /** Shadowed-entry warnings (L8) of those blocks, for the caller to print. */\n  mcpFakeWarnings: McpFakeIssue[];\n  /**\n   * The entry-id `source` (I6) of each file that could not be read or was\n   * not valid JSON. Such a file is warned and skipped, as before, so it adds\n   * no fixtures and no blocks; a `--watch` reload uses this list to tell a\n   * file it could not parse from a file whose `mcpFakes` were removed.\n   */\n  unreadable: string[];\n}\n\n/** A load in progress: the result, plus every bad-block error of every file. */\ninterface ServicesLoad {\n  out: FixturesWithServices;\n  errors: FixtureLoadError[];\n}\n\n/**\n * Load one parsed file into `load.out`: its `mcpFakes` blocks under\n * `source`, then its LLM fixtures. A file with a bad block adds nothing; its\n * errors go to `load.errors`, and the load goes on so every bad block of\n * every file is reported (fail-loud rule, spec 5.4; L3). Its L8 warnings are\n * kept either way.\n */\nfunction loadServicesFile(\n  filePath: string,\n  source: string,\n  load: ServicesLoad,\n  logger: Logger | undefined,\n  liveOptions: LiveOptions | undefined,\n): void {\n  const { out } = load;\n  const read = readFixtureJson(filePath, logger);\n  if (read === null) {\n    out.unreadable.push(source);\n    return;\n  }\n  const parsed = read.value;\n  const withFakes = hasMcpFakesKey(parsed);\n  if (withFakes) {\n    const raw = parsed.mcpFakes;\n    const validation = validateMcpFakes(raw, source);\n    out.mcpFakeWarnings.push(...validation.warnings);\n    if (validation.errors.length > 0) {\n      load.errors.push(...validation.errors);\n      return;\n    }\n    if (Array.isArray(raw)) {\n      raw.forEach((block: unknown, blockIndex: number) => {\n        out.mcpFakes.push({ source, blockIndex, raw: block });\n      });\n    } else {\n      out.mcpFakes.push({ source, blockIndex: null, raw });\n    }\n  }\n  out.fixtures.push(...fixturesOf(parsed, filePath, logger, liveOptions, withFakes, source));\n}\n\n/**\n * The result of a finished load, or its errors thrown: the one\n * `FixtureLoadError` alone, else a `McpFakesAddError` holding every error and\n * the L8 warnings, so no warning is lost when the load fails.\n */\nfunction finish(load: ServicesLoad): FixturesWithServices {\n  const { out, errors } = load;\n  const [first] = errors;\n  if (first === undefined) return out;\n  if (errors.length === 1 && out.mcpFakeWarnings.length === 0) throw first;\n  throw new McpFakesAddError(errors, out.mcpFakeWarnings);\n}\n\nfunction newLoad(): ServicesLoad {\n  return { out: { fixtures: [], mcpFakes: [], mcpFakeWarnings: [], unreadable: [] }, errors: [] };\n}\n\n/**\n * Load one fixture file: its LLM fixtures and its `mcpFakes` blocks. A\n * fakes-only file is accepted. The blocks' `source` (spec I6) is `filePath`\n * as given, or `sourceLabel` when set (the URL of a remote fixture file).\n * A bad block throws a `FixtureLoadError` (a `McpFakesAddError` when there\n * is more than one error, or L8 warnings to keep with it).\n */\nexport function loadFixtureFileWithServices(\n  filePath: string,\n  logger?: Logger,\n  liveOptions?: LiveOptions,\n  sourceLabel?: string,\n): FixturesWithServices {\n  const load = newLoad();\n  loadServicesFile(filePath, sourceLabel ?? filePath, load, logger, liveOptions);\n  return finish(load);\n}\n\nfunction loadServicesDir(\n  dirPath: string,\n  relDir: string,\n  load: ServicesLoad,\n  logger: Logger | undefined,\n  liveOptions: LiveOptions | undefined,\n): void {\n  const listing = listFixtureDir(dirPath, logger);\n  if (listing === null) return;\n  for (const name of listing.jsonFiles) {\n    loadServicesFile(join(dirPath, name), relDir + name, load, logger, liveOptions);\n  }\n  for (const sub of listing.subdirs) {\n    loadServicesDir(join(dirPath, sub), `${relDir}${sub}/`, load, logger, liveOptions);\n  }\n}\n\n/**\n * Load every `.json` file under `dirPath` (sorted, then subdirectories, at\n * full depth, as {@link loadFixturesFromDir}): LLM fixtures and `mcpFakes`\n * blocks. Each block's `source` (spec I6) is its file's path relative to\n * `dirPath`, with `/` separators. Every file is checked before anything is\n * thrown: the bad blocks of all files are reported together, as in\n * {@link loadFixtureFileWithServices}.\n */\nexport function loadFixturesFromDirWithServices(\n  dirPath: string,\n  logger?: Logger,\n  liveOptions?: LiveOptions,\n): FixturesWithServices {\n  const load = newLoad();\n  loadServicesDir(dirPath, \"\", load, logger, liveOptions);\n  return finish(load);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA4DA,SAAS,iBACP,UACA,QACA,MACA,QACA,aACM;CACN,MAAM,EAAE,QAAQ;CAChB,MAAM,OAAO,gBAAgB,UAAU,OAAO;AAC9C,KAAI,SAAS,MAAM;AACjB,MAAI,WAAW,KAAK,OAAO;AAC3B;;CAEF,MAAM,SAAS,KAAK;CACpB,MAAM,YAAY,eAAe,OAAO;AACxC,KAAI,WAAW;EACb,MAAM,MAAM,OAAO;EACnB,MAAM,aAAa,iBAAiB,KAAK,OAAO;AAChD,MAAI,gBAAgB,KAAK,GAAG,WAAW,SAAS;AAChD,MAAI,WAAW,OAAO,SAAS,GAAG;AAChC,QAAK,OAAO,KAAK,GAAG,WAAW,OAAO;AACtC;;AAEF,MAAI,MAAM,QAAQ,IAAI,CACpB,KAAI,SAAS,OAAgB,eAAuB;AAClD,OAAI,SAAS,KAAK;IAAE;IAAQ;IAAY,KAAK;IAAO,CAAC;IACrD;MAEF,KAAI,SAAS,KAAK;GAAE;GAAQ,YAAY;GAAM;GAAK,CAAC;;AAGxD,KAAI,SAAS,KAAK,GAAG,WAAW,QAAQ,UAAU,QAAQ,aAAa,WAAW,OAAO,CAAC;;;;;;;AAQ5F,SAAS,OAAO,MAA0C;CACxD,MAAM,EAAE,KAAK,WAAW;CACxB,MAAM,CAAC,SAAS;AAChB,KAAI,UAAU,OAAW,QAAO;AAChC,KAAI,OAAO,WAAW,KAAK,IAAI,gBAAgB,WAAW,EAAG,OAAM;AACnE,OAAM,IAAI,iBAAiB,QAAQ,IAAI,gBAAgB;;AAGzD,SAAS,UAAwB;AAC/B,QAAO;EAAE,KAAK;GAAE,UAAU,EAAE;GAAE,UAAU,EAAE;GAAE,iBAAiB,EAAE;GAAE,YAAY,EAAE;GAAE;EAAE,QAAQ,EAAE;EAAE;;;;;;;;;AAUjG,SAAgB,4BACd,UACA,QACA,aACA,aACsB;CACtB,MAAM,OAAO,SAAS;AACtB,kBAAiB,UAAU,eAAe,UAAU,MAAM,QAAQ,YAAY;AAC9E,QAAO,OAAO,KAAK;;AAGrB,SAAS,gBACP,SACA,QACA,MACA,QACA,aACM;CACN,MAAM,UAAU,eAAe,SAAS,OAAO;AAC/C,KAAI,YAAY,KAAM;AACtB,MAAK,MAAM,QAAQ,QAAQ,UACzB,kBAAiB,KAAK,SAAS,KAAK,EAAE,SAAS,MAAM,MAAM,QAAQ,YAAY;AAEjF,MAAK,MAAM,OAAO,QAAQ,QACxB,iBAAgB,KAAK,SAAS,IAAI,EAAE,GAAG,SAAS,IAAI,IAAI,MAAM,QAAQ,YAAY;;;;;;;;;;AAYtF,SAAgB,gCACd,SACA,QACA,aACsB;CACtB,MAAM,OAAO,SAAS;AACtB,iBAAgB,SAAS,IAAI,MAAM,QAAQ,YAAY;AACvD,QAAO,OAAO,KAAK"}