@copilotkit/aimock 1.43.0 → 1.44.0

package/dist/fixture-loader-services.js

@@ -0,0 +1,114 @@
+import { fixturesOf, hasMcpFakesKey, listFixtureDir, readFixtureJson } from "./fixture-loader.js";
+import { McpFakesAddError, validateMcpFakes } from "./mcp-fakes.js";
+import { join } from "node:path";
+
+//#region src/fixture-loader-services.ts
+/**
+* Fixture loaders that carry MCP fakes (spec F1): the `…WithServices`
+* variants of `loadFixtureFile` / `loadFixturesFromDir`. They return the LLM
+* fixtures and the raw `mcpFakes` blocks with their entry-id `source` (I6).
+*
+* They live outside fixture-loader.ts because they validate blocks with
+* `validateMcpFakes`, and mcp-fakes.ts imports `FixtureLoadError` from
+* fixture-loader.ts at module load (`McpFakesAddError extends
+* FixtureLoadError`): a value import of mcp-fakes.ts from fixture-loader.ts
+* is an import cycle that leaves `FixtureLoadError` uninitialized whenever
+* fixture-loader.ts is loaded first.
+*/
+/**
+* Load one parsed file into `load.out`: its `mcpFakes` blocks under
+* `source`, then its LLM fixtures. A file with a bad block adds nothing; its
+* errors go to `load.errors`, and the load goes on so every bad block of
+* every file is reported (fail-loud rule, spec 5.4; L3). Its L8 warnings are
+* kept either way.
+*/
+function loadServicesFile(filePath, source, load, logger, liveOptions) {
+	const { out } = load;
+	const read = readFixtureJson(filePath, logger);
+	if (read === null) {
+		out.unreadable.push(source);
+		return;
+	}
+	const parsed = read.value;
+	const withFakes = hasMcpFakesKey(parsed);
+	if (withFakes) {
+		const raw = parsed.mcpFakes;
+		const validation = validateMcpFakes(raw, source);
+		out.mcpFakeWarnings.push(...validation.warnings);
+		if (validation.errors.length > 0) {
+			load.errors.push(...validation.errors);
+			return;
+		}
+		if (Array.isArray(raw)) raw.forEach((block, blockIndex) => {
+			out.mcpFakes.push({
+				source,
+				blockIndex,
+				raw: block
+			});
+		});
+		else out.mcpFakes.push({
+			source,
+			blockIndex: null,
+			raw
+		});
+	}
+	out.fixtures.push(...fixturesOf(parsed, filePath, logger, liveOptions, withFakes));
+}
+/**
+* The result of a finished load, or its errors thrown: the one
+* `FixtureLoadError` alone, else a `McpFakesAddError` holding every error and
+* the L8 warnings, so no warning is lost when the load fails.
+*/
+function finish(load) {
+	const { out, errors } = load;
+	const [first] = errors;
+	if (first === void 0) return out;
+	if (errors.length === 1 && out.mcpFakeWarnings.length === 0) throw first;
+	throw new McpFakesAddError(errors, out.mcpFakeWarnings);
+}
+function newLoad() {
+	return {
+		out: {
+			fixtures: [],
+			mcpFakes: [],
+			mcpFakeWarnings: [],
+			unreadable: []
+		},
+		errors: []
+	};
+}
+/**
+* Load one fixture file: its LLM fixtures and its `mcpFakes` blocks. A
+* fakes-only file is accepted. The blocks' `source` (spec I6) is `filePath`
+* as given, or `sourceLabel` when set (the URL of a remote fixture file).
+* A bad block throws a `FixtureLoadError` (a `McpFakesAddError` when there
+* is more than one error, or L8 warnings to keep with it).
+*/
+function loadFixtureFileWithServices(filePath, logger, liveOptions, sourceLabel) {
+	const load = newLoad();
+	loadServicesFile(filePath, sourceLabel ?? filePath, load, logger, liveOptions);
+	return finish(load);
+}
+function loadServicesDir(dirPath, relDir, load, logger, liveOptions) {
+	const listing = listFixtureDir(dirPath, logger);
+	if (listing === null) return;
+	for (const name of listing.jsonFiles) loadServicesFile(join(dirPath, name), relDir + name, load, logger, liveOptions);
+	for (const sub of listing.subdirs) loadServicesDir(join(dirPath, sub), `${relDir}${sub}/`, load, logger, liveOptions);
+}
+/**
+* Load every `.json` file under `dirPath` (sorted, then subdirectories, at
+* full depth, as {@link loadFixturesFromDir}): LLM fixtures and `mcpFakes`
+* blocks. Each block's `source` (spec I6) is its file's path relative to
+* `dirPath`, with `/` separators. Every file is checked before anything is
+* thrown: the bad blocks of all files are reported together, as in
+* {@link loadFixtureFileWithServices}.
+*/
+function loadFixturesFromDirWithServices(dirPath, logger, liveOptions) {
+	const load = newLoad();
+	loadServicesDir(dirPath, "", load, logger, liveOptions);
+	return finish(load);
+}
+
+//#endregion
+export { loadFixtureFileWithServices, loadFixturesFromDirWithServices };
+//# sourceMappingURL=fixture-loader-services.js.map

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

@@ -0,0 +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"}

package/dist/fixture-loader.cjs

@@ -1,4 +1,6 @@
 const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+const require_constants = require('./constants.cjs');
+const require_message_text = require('./message-text.cjs');
 const require_helpers = require('./helpers.cjs');
 const require_live_fixture = require('./live-fixture.cjs');
 const require_chaos = require('./chaos.cjs');
@@ -33,7 +35,11 @@ function normalizeResponse(raw, liveOptions) {
 	});
 	return response;
 }
+var InvalidFixtureMatchError = class extends TypeError {};
 function entryToFixture(entry, logger, liveOptions) {
+	if (entry === null || typeof entry !== "object" || Array.isArray(entry)) throw new TypeError("Fixture entry must be an object");
+	if (entry.match == null) throw new TypeError("Fixture match must be an object");
+	if (typeof entry.match !== "object" || Array.isArray(entry.match)) throw new InvalidFixtureMatchError("Fixture match must be an object");
 	const fixture = {
 		match: {
 			userMessage: entry.match.userMessage,
@@ -92,34 +98,94 @@ function warn(logger, msg, ...rest) {
 	if (logger) logger.warn(msg, ...rest);
 	else console.warn(`[fixture-loader] ${msg}`, ...rest);
 }
-function loadFixtureFile(filePath, logger, liveOptions) {
+/**
+* A parsed JSON value, or `null` when the file could not be read or parsed (warned).
+*
+* @internal Shared with fixture-loader-services.ts.
+*/
+function readFixtureJson(filePath, logger) {
 	let raw;
 	try {
 		raw = (0, node_fs.readFileSync)(filePath, "utf-8");
 	} catch (err) {
 		warn(logger, `Could not read file ${filePath}:`, err);
-		return [];
+		return null;
 	}
-	let parsed;
 	try {
-		parsed = JSON.parse(raw);
+		return { value: JSON.parse(raw) };
 	} catch (err) {
 		warn(logger, `Invalid JSON in ${filePath}:`, err);
-		return [];
+		return null;
 	}
+}
+/**
+* `parsed` is a JSON object with an own top-level `mcpFakes` key.
+*
+* @internal Shared with fixture-loader-services.ts.
+*/
+function hasMcpFakesKey(parsed) {
+	return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && Object.prototype.hasOwnProperty.call(parsed, "mcpFakes");
+}
+/**
+* The LLM fixtures of a parsed file. A missing or non-array `fixtures` is
+* warned and gives none, except that a file with `mcpFakes` may leave
+* `fixtures` out (`fixturesOptional`, spec 5.4). An entry whose `match` is
+* not an object is skipped with a warning; any other bad entry throws.
+*
+* @internal Shared with fixture-loader-services.ts.
+*/
+function fixturesOf(parsed, filePath, logger, liveOptions, fixturesOptional) {
+	if (fixturesOptional && typeof parsed === "object" && parsed !== null && !Object.prototype.hasOwnProperty.call(parsed, "fixtures")) return [];
 	if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.fixtures)) {
 		warn(logger, `Missing or invalid "fixtures" array in ${filePath}`);
 		return [];
 	}
-	return parsed.fixtures.map((e) => entryToFixture(e, logger, liveOptions));
+	const fixtures = [];
+	for (const [index, entry] of parsed.fixtures.entries()) try {
+		fixtures.push(entryToFixture(entry, logger, liveOptions));
+	} catch (error) {
+		if (!(error instanceof InvalidFixtureMatchError)) throw error;
+		warn(logger, `Skipping fixture at index ${index} in ${filePath}: ${error.message}`);
+	}
+	return fixtures;
 }
-function loadFixturesFromDir(dirPath, logger, liveOptions) {
+/**
+* B13: the old loaders return LLM fixtures only, so a file with `mcpFakes`
+* fails loud instead of losing its fakes.
+*/
+function cannotCarryFakes(filePath) {
+	return new FixtureLoadError({
+		rule: "mcp-fakes/loader-cannot-carry-fakes",
+		file: filePath,
+		blockId: null,
+		entryId: null,
+		detail: require_message_text.msg`top-level "mcpFakes" key: loadFixtureFile and loadFixturesFromDir cannot carry MCP fakes; use loadFixtureFileWithServices or loadFixturesFromDirWithServices, or LLMock.loadFixtureFile or LLMock.loadFixtureDir`
+	});
+}
+/**
+* Load the LLM fixtures of one file. Throws a `FixtureLoadError` (rule
+* `mcp-fakes/loader-cannot-carry-fakes`) when the file has a top-level
+* `mcpFakes` key; use `loadFixtureFileWithServices` (fixture-loader-services.ts) for such files.
+*/
+function loadFixtureFile(filePath, logger, liveOptions) {
+	const read = readFixtureJson(filePath, logger);
+	if (read === null) return [];
+	if (hasMcpFakesKey(read.value)) throw cannotCarryFakes(filePath);
+	return fixturesOf(read.value, filePath, logger, liveOptions, false);
+}
+/**
+* The `.json` files (sorted) and the subdirectories (sorted) of `dirPath`,
+* or `null` when it cannot be read (warned).
+*
+* @internal Shared with fixture-loader-services.ts.
+*/
+function listFixtureDir(dirPath, logger) {
 	let entries;
 	try {
 		entries = (0, node_fs.readdirSync)(dirPath);
 	} catch (err) {
 		warn(logger, `Could not read directory ${dirPath}:`, err);
-		return [];
+		return null;
 	}
 	const jsonFiles = [];
 	const subdirs = [];
@@ -137,13 +203,28 @@ function loadFixturesFromDir(dirPath, logger, liveOptions) {
 		if (name.endsWith(".json")) jsonFiles.push(name);
 	}
 	jsonFiles.sort();
+	subdirs.sort();
+	return {
+		jsonFiles,
+		subdirs
+	};
+}
+/**
+* Load the LLM fixtures of every `.json` file under `dirPath`. Throws a
+* `FixtureLoadError` (rule `mcp-fakes/loader-cannot-carry-fakes`) on the
+* first file with a top-level `mcpFakes` key; use
+* `loadFixturesFromDirWithServices` (fixture-loader-services.ts) for such
+* directories.
+*/
+function loadFixturesFromDir(dirPath, logger, liveOptions) {
+	const listing = listFixtureDir(dirPath, logger);
+	if (listing === null) return [];
 	const fixtures = [];
-	for (const name of jsonFiles) {
+	for (const name of listing.jsonFiles) {
 		const filePath = (0, node_path.join)(dirPath, name);
 		fixtures.push(...loadFixtureFile(filePath, logger, liveOptions));
 	}
-	subdirs.sort();
-	for (const sub of subdirs) fixtures.push(...loadFixturesFromDir((0, node_path.join)(dirPath, sub), logger, liveOptions));
+	for (const sub of listing.subdirs) fixtures.push(...loadFixturesFromDir((0, node_path.join)(dirPath, sub), logger, liveOptions));
 	return fixtures;
 }
 /**
@@ -806,18 +887,98 @@ function validateFixtures(fixtures, liveOptions) {
 	}
 	return results;
 }
+/**
+* `text` with every run of line breaks, and the spaces around it, folded to
+* one space: CR, LF, VT, FF, NEL, and the Unicode line and paragraph
+* separators.
+*/
+function oneLine(text) {
+	return text.replace(/\s*[\r\n\v\f\u0085\u2028\u2029]+\s*/g, " ");
+}
+/**
+* The `detail` as a `FixtureLoadError` message adds it: built in a budget of
+* its own, cut to at most `MCP_FAKES_ECHO_LIMIT` chars in all, with each of
+* its user parts cut once. A text detail is folded onto one line, gets the
+* escaping of every JSON text part (`jsonText`: each control char left, C0,
+* DEL or C1, and the line and paragraph separators as `\uXXXX`) and is cut
+* as JSON text (it is
+* made of fixed text, paths and quoted values, where a backslash only starts
+* a JSON escape; a stray one only moves the cut back a few chars).
+*/
+function capPart(detail) {
+	return require_message_text.within(require_constants.MCP_FAKES_ECHO_LIMIT, typeof detail === "string" ? require_message_text.msg`${require_message_text.jsonText(oneLine(detail))}` : detail);
+}
+/**
+* One `file`, `blockId` or `entryId` as the message names it: JSON-quoted
+* (control chars escaped, so a name can neither break the line nor pose as
+* the message layout), and cut once to `MCP_FAKES_ECHO_LIMIT` chars at most.
+* An empty string is `""`, so the message names every part `toJSON()` keeps.
+*/
+function namePart(text) {
+	return require_message_text.msg`${require_message_text.quote(text)}`;
+}
+/**
+* Thrown for a fixture-load case aimock cannot honor (fail-loud rule). Only
+* the MCP fakes code throws it; other fixture-loader paths log warnings.
+* `blockId` and `entryId` are own properties only when supplied, so
+* `toJSON()` (the control API's HTTP 400 `details`) omits them otherwise.
+* The message names `file` and every non-null `blockId` and `entryId`, an
+* empty string as `""`, so it agrees with `toJSON()`. `options.cause` (the
+* standard `ErrorOptions`) keeps the underlying error, such as a JSON parse
+* failure; `toJSON()` leaves it out.
+*/
+var FixtureLoadError = class extends Error {
+	/** Typed `string` so a subclass can set its own name. */
+	name = "FixtureLoadError";
+	rule;
+	file;
+	constructor(init, options) {
+		const file = init.file === null ? require_message_text.msg`<no file>` : namePart(init.file);
+		const block = init.blockId == null ? require_message_text.msg`` : require_message_text.msg`, block ${namePart(init.blockId)}`;
+		const entry = init.entryId == null ? require_message_text.msg`` : require_message_text.msg`, entry ${namePart(init.entryId)}`;
+		super(oneLine(require_message_text.build(require_message_text.msg`${file}${block}${entry}: [${require_message_text.fixed(init.rule)}] ${capPart(init.detail)}`)), options);
+		this.rule = init.rule;
+		this.file = init.file;
+		if (init.blockId !== void 0) Object.defineProperty(this, "blockId", {
+			value: init.blockId,
+			enumerable: true,
+			writable: false
+		});
+		if (init.entryId !== void 0) Object.defineProperty(this, "entryId", {
+			value: init.entryId,
+			enumerable: true,
+			writable: false
+		});
+	}
+	toJSON() {
+		const json = {
+			name: this.name,
+			rule: this.rule,
+			file: this.file,
+			message: this.message
+		};
+		if (this.blockId !== void 0) json.blockId = this.blockId;
+		if (this.entryId !== void 0) json.entryId = this.entryId;
+		return json;
+	}
+};
 
 //#endregion
+exports.FixtureLoadError = FixtureLoadError;
 exports.INJECTED_STATUS_RANGE = INJECTED_STATUS_RANGE;
 exports.claimOneShotError = claimOneShotError;
 exports.clearFixtureQueue = clearFixtureQueue;
 exports.entryToFixture = entryToFixture;
+exports.fixturesOf = fixturesOf;
+exports.hasMcpFakesKey = hasMcpFakesKey;
 exports.isInjectableStatus = isInjectableStatus;
 exports.isOneShotError = isOneShotError;
+exports.listFixtureDir = listFixtureDir;
 exports.loadFixtureFile = loadFixtureFile;
 exports.loadFixturesFromDir = loadFixturesFromDir;
 exports.normalizeResponse = normalizeResponse;
 exports.queueOneShotError = queueOneShotError;
+exports.readFixtureJson = readFixtureJson;
 exports.releaseOneShotError = releaseOneShotError;
 exports.renderValidationRef = renderValidationRef;
 exports.validateFixtures = validateFixtures;