@copilotkit/aimock 1.42.1 → 1.44.0

package/dist/journal.d.cts

@@ -1,7 +1,23 @@
 import { DEFAULT_TEST_ID } from "./constants.cjs";
-import { Fixture, JournalEntry } from "./types.cjs";
+import { ChatCompletionRequest, Fixture, JournalBody, JournalEntry } from "./types.cjs";
 
 //#region src/journal.d.ts
+
+/**
+ * Narrow a journaled body to a chat-completion request.
+ *
+ * `JournalEntry.body` is a union (see {@link JournalBody}): most entries hold a
+ * chat request, but the fine-tuning create payload and this module's own
+ * truncation marker do not. Anything reading `messages`, `model` or the rest of
+ * the chat shape off a journal entry — inside aimock or in a consumer's test
+ * — goes through here, so an entry that is not a chat request fails as a
+ * `false` it can assert on rather than as an undefined property three accesses
+ * later.
+ *
+ * `messages` is the discriminator because it is the one required field no
+ * other journaled shape carries.
+ */
+declare function isChatCompletionBody(body: JournalBody | null | undefined): body is ChatCompletionRequest;
 interface JournalOptions {
   /**
    * Maximum number of entries to retain. When exceeded, oldest entries are
@@ -26,16 +42,57 @@ interface JournalOptions {
    * servers that see many unique testIds.
    */
   fixtureCountsMaxTestIds?: number;
+  /**
+   * Called with every entry {@link Journal.add} creates, right after it is
+   * recorded. The hook exists so an embedder can attribute an entry to the
+   * request that produced it WITHOUT touching each of the ~100 `journal.add`
+   * call sites spread across the handler modules: the server binds the entry
+   * to the in-flight `IncomingMessage` here, and its error arm then amends
+   * that exact object rather than guessing from a caller-supplied header.
+   *
+   * The entry is already recorded when the hook runs, so a hook that throws
+   * does not lose the write — but it does propagate out of `add` into the
+   * caller's error path, so a hook must not throw.
+   */
+  onAdd?: (entry: JournalEntry) => void;
 }
 declare class Journal {
   private entries;
+  private readonly matchedFixtures;
   private readonly fixtureMatchCountsByTestId;
   private readonly maxEntries;
   private readonly fixtureCountsMaxTestIds;
+  private readonly onAdd?;
   constructor(options?: JournalOptions);
+  /**
+   * The per-test-id cap on fixture match-count maps, for an MCP mount to pass
+   * to `McpFakeStore.setMaxTestIds`. Always a non-negative safe integer, `0`
+   * meaning unbounded, and never throws, whatever option was passed:
+   * omitted, zero, negative or `NaN` is `0`; `Infinity` or a value above
+   * `Number.MAX_SAFE_INTEGER` (never reached) is `0`; a fraction of 1 or more
+   * is rounded down (`1.5` evicts at 2 ids, so it keeps 1). For these values
+   * it is the number of test ids the journal keeps.
+   *
+   * An option between 0 and 1 is the exception. The journal keeps no test id
+   * (each new count map is evicted as soon as it is made, so counts never
+   * advance), and a store cap cannot say "keep none" because `0` is
+   * unbounded. The getter returns `1`, the smallest bounded cap, so a store
+   * given it keeps 1 test id where the journal keeps 0.
+   */
+  get fixtureCountsMaxTestIdsCap(): number;
   /** Backwards-compatible accessor — returns the default (no testId) count map. */
   get fixtureMatchCounts(): Map<Fixture, number>;
-  add(entry: Omit<JournalEntry, "id" | "timestamp">): JournalEntry;
+  /** @internal matchedFixture preserves identity when Live supplies safe diagnostics. */
+  add(entry: Omit<JournalEntry, "id" | "timestamp">, matchedFixture?: Fixture): JournalEntry;
+  /**
+   * Return every entry, or with `limit` the most recent `limit` entries.
+   * `0` returns `[]` — exactly what `GET /__aimock/journal?limit=0` answers.
+   * `slice(-0)` is `slice(0)`, so a `0` used to return the ENTIRE journal; it
+   * is special-cased so the library and the HTTP route agree. This is a public
+   * library API, so odd limits are tolerated rather than thrown on: a
+   * non-finite limit (`NaN`, `Infinity`) means "no limit", a fractional limit
+   * floors, and any limit at or below `0` asks for nothing.
+   */
   getAll(opts?: {
     limit?: number;
   }): JournalEntry[];
@@ -72,5 +129,5 @@ declare class Journal {
 }
 //# sourceMappingURL=journal.d.ts.map
 //#endregion
-export { Journal };
+export { Journal, isChatCompletionBody };
 //# sourceMappingURL=journal.d.cts.map

package/dist/journal.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"journal.d.cts","names":[],"sources":["../src/journal.ts"],"sourcesContent":[],"mappings":";;;;UA0FiB,cAAA;;AAAjB;AA0BA;;;;;;;;;;YAkDyB,CAAA,EAAA,MAAA;;;;;;;;;;;;cAlDZ,OAAA;;;;;wBAMU;;4BAUK,IAAI;aAInB,KAAK,oCAAoC;;;MAmBjB;aAOxB;yBAIY,UAAU;;;;;;;;gDAWa,IAAI;;;;;;;;gCA+BpB;sCAKnB,gCACc"}
+{"version":3,"file":"journal.d.cts","names":[],"sources":["../src/journal.ts"],"sourcesContent":[],"mappings":";;;;;;;AA8DA;;;;;AA4DA;AAuCA;;;;;;AA6Ca,iBAhJG,oBAAA,CAgJH,IAAA,EA/IL,WA+IK,GAAA,IAAA,GAAA,SAAA,CAAA,EAAA,IAAA,IA9IF,qBA8IE;AAAyD,UApFrD,cAAA,CAoFqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAhDpD;;cAGL,OAAA;;;;;;;wBAQU;;;;;;;;;;;;;;;;;;4BAgCK,IAAI;;aAKnB,KAAK,oDAAoD,UAAU;;;;;;;;;;;;MA8B3C;aASxB;yBAIY,UAAU;;;;;;;;gDAaa,IAAI;;;;;;;;gCAgCpB;sCAKnB,gCACc"}

package/dist/journal.d.ts

@@ -1,7 +1,23 @@
 import { DEFAULT_TEST_ID } from "./constants.js";
-import { Fixture, JournalEntry } from "./types.js";
+import { ChatCompletionRequest, Fixture, JournalBody, JournalEntry } from "./types.js";
 
 //#region src/journal.d.ts
+
+/**
+ * Narrow a journaled body to a chat-completion request.
+ *
+ * `JournalEntry.body` is a union (see {@link JournalBody}): most entries hold a
+ * chat request, but the fine-tuning create payload and this module's own
+ * truncation marker do not. Anything reading `messages`, `model` or the rest of
+ * the chat shape off a journal entry — inside aimock or in a consumer's test
+ * — goes through here, so an entry that is not a chat request fails as a
+ * `false` it can assert on rather than as an undefined property three accesses
+ * later.
+ *
+ * `messages` is the discriminator because it is the one required field no
+ * other journaled shape carries.
+ */
+declare function isChatCompletionBody(body: JournalBody | null | undefined): body is ChatCompletionRequest;
 interface JournalOptions {
   /**
    * Maximum number of entries to retain. When exceeded, oldest entries are
@@ -26,16 +42,57 @@ interface JournalOptions {
    * servers that see many unique testIds.
    */
   fixtureCountsMaxTestIds?: number;
+  /**
+   * Called with every entry {@link Journal.add} creates, right after it is
+   * recorded. The hook exists so an embedder can attribute an entry to the
+   * request that produced it WITHOUT touching each of the ~100 `journal.add`
+   * call sites spread across the handler modules: the server binds the entry
+   * to the in-flight `IncomingMessage` here, and its error arm then amends
+   * that exact object rather than guessing from a caller-supplied header.
+   *
+   * The entry is already recorded when the hook runs, so a hook that throws
+   * does not lose the write — but it does propagate out of `add` into the
+   * caller's error path, so a hook must not throw.
+   */
+  onAdd?: (entry: JournalEntry) => void;
 }
 declare class Journal {
   private entries;
+  private readonly matchedFixtures;
   private readonly fixtureMatchCountsByTestId;
   private readonly maxEntries;
   private readonly fixtureCountsMaxTestIds;
+  private readonly onAdd?;
   constructor(options?: JournalOptions);
+  /**
+   * The per-test-id cap on fixture match-count maps, for an MCP mount to pass
+   * to `McpFakeStore.setMaxTestIds`. Always a non-negative safe integer, `0`
+   * meaning unbounded, and never throws, whatever option was passed:
+   * omitted, zero, negative or `NaN` is `0`; `Infinity` or a value above
+   * `Number.MAX_SAFE_INTEGER` (never reached) is `0`; a fraction of 1 or more
+   * is rounded down (`1.5` evicts at 2 ids, so it keeps 1). For these values
+   * it is the number of test ids the journal keeps.
+   *
+   * An option between 0 and 1 is the exception. The journal keeps no test id
+   * (each new count map is evicted as soon as it is made, so counts never
+   * advance), and a store cap cannot say "keep none" because `0` is
+   * unbounded. The getter returns `1`, the smallest bounded cap, so a store
+   * given it keeps 1 test id where the journal keeps 0.
+   */
+  get fixtureCountsMaxTestIdsCap(): number;
   /** Backwards-compatible accessor — returns the default (no testId) count map. */
   get fixtureMatchCounts(): Map<Fixture, number>;
-  add(entry: Omit<JournalEntry, "id" | "timestamp">): JournalEntry;
+  /** @internal matchedFixture preserves identity when Live supplies safe diagnostics. */
+  add(entry: Omit<JournalEntry, "id" | "timestamp">, matchedFixture?: Fixture): JournalEntry;
+  /**
+   * Return every entry, or with `limit` the most recent `limit` entries.
+   * `0` returns `[]` — exactly what `GET /__aimock/journal?limit=0` answers.
+   * `slice(-0)` is `slice(0)`, so a `0` used to return the ENTIRE journal; it
+   * is special-cased so the library and the HTTP route agree. This is a public
+   * library API, so odd limits are tolerated rather than thrown on: a
+   * non-finite limit (`NaN`, `Infinity`) means "no limit", a fractional limit
+   * floors, and any limit at or below `0` asks for nothing.
+   */
   getAll(opts?: {
     limit?: number;
   }): JournalEntry[];
@@ -72,5 +129,5 @@ declare class Journal {
 }
 //# sourceMappingURL=journal.d.ts.map
 //#endregion
-export { Journal };
+export { Journal, isChatCompletionBody };
 //# sourceMappingURL=journal.d.ts.map

package/dist/journal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"journal.d.ts","names":[],"sources":["../src/journal.ts"],"sourcesContent":[],"mappings":";;;;UA0FiB,cAAA;;AAAjB;AA0BA;;;;;;;;;;YAkDyB,CAAA,EAAA,MAAA;;;;;;;;;;;;cAlDZ,OAAA;;;;;wBAMU;;4BAUK,IAAI;aAInB,KAAK,oCAAoC;;;MAmBjB;aAOxB;yBAIY,UAAU;;;;;;;;gDAWa,IAAI;;;;;;;;gCA+BpB;sCAKnB,gCACc"}
+{"version":3,"file":"journal.d.ts","names":[],"sources":["../src/journal.ts"],"sourcesContent":[],"mappings":";;;;;;;AA8DA;;;;;AA4DA;AAuCA;;;;;;AA6Ca,iBAhJG,oBAAA,CAgJH,IAAA,EA/IL,WA+IK,GAAA,IAAA,GAAA,SAAA,CAAA,EAAA,IAAA,IA9IF,qBA8IE;AAAyD,UApFrD,cAAA,CAoFqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAhDpD;;cAGL,OAAA;;;;;;;wBAQU;;;;;;;;;;;;;;;;;;4BAgCK,IAAI;;aAKnB,KAAK,oDAAoD,UAAU;;;;;;;;;;;;MA8B3C;aASxB;yBAIY,UAAU;;;;;;;;gDAaa,IAAI;;;;;;;;gCAgCpB;sCAKnB,gCACc"}

package/dist/journal.js

@@ -36,6 +36,23 @@ function capBody(body) {
 	};
 }
 /**
+* Narrow a journaled body to a chat-completion request.
+*
+* `JournalEntry.body` is a union (see {@link JournalBody}): most entries hold a
+* chat request, but the fine-tuning create payload and this module's own
+* truncation marker do not. Anything reading `messages`, `model` or the rest of
+* the chat shape off a journal entry — inside aimock or in a consumer's test
+* — goes through here, so an entry that is not a chat request fails as a
+* `false` it can assert on rather than as an undefined property three accesses
+* later.
+*
+* `messages` is the discriminator because it is the one required field no
+* other journaled shape carries.
+*/
+function isChatCompletionBody(body) {
+	return body !== null && body !== void 0 && Array.isArray(body.messages) && typeof body.model === "string";
+}
+/**
 * Compare two field values, handling RegExp by source+flags rather than reference.
 */
 function fieldEqual(a, b) {
@@ -59,43 +76,82 @@ function systemMessageEqual(a, b) {
 * (ignoring sequenceIndex). Used to group sequenced fixtures.
 */
 function matchCriteriaEqual(a, b) {
-	return fieldEqual(a.userMessage, b.userMessage) && systemMessageEqual(a.systemMessage, b.systemMessage) && fieldEqual(a.inputText, b.inputText) && fieldEqual(a.toolCallId, b.toolCallId) && fieldEqual(a.toolName, b.toolName) && fieldEqual(a.model, b.model) && fieldEqual(a.responseFormat, b.responseFormat) && fieldEqual(a.predicate, b.predicate) && fieldEqual(a.endpoint, b.endpoint) && fieldEqual(a.turnIndex, b.turnIndex) && fieldEqual(a.hasToolResult, b.hasToolResult);
+	return fieldEqual(a.userMessage, b.userMessage) && systemMessageEqual(a.systemMessage, b.systemMessage) && fieldEqual(a.inputText, b.inputText) && fieldEqual(a.toolCallId, b.toolCallId) && fieldEqual(a.toolName, b.toolName) && fieldEqual(a.model, b.model) && fieldEqual(a.responseFormat, b.responseFormat) && fieldEqual(a.predicate, b.predicate) && fieldEqual(a.endpoint, b.endpoint) && fieldEqual(a.turnIndex, b.turnIndex) && fieldEqual(a.hasToolResult, b.hasToolResult) && fieldEqual(a.toolResultContains, b.toolResultContains) && fieldEqual(a.context, b.context);
 }
 var Journal = class {
 	entries = [];
+	matchedFixtures = /* @__PURE__ */ new WeakMap();
 	fixtureMatchCountsByTestId = /* @__PURE__ */ new Map();
 	maxEntries;
 	fixtureCountsMaxTestIds;
+	onAdd;
 	constructor(options = {}) {
+		this.onAdd = options.onAdd;
 		const cap = options.maxEntries;
 		this.maxEntries = cap !== void 0 && cap > 0 ? cap : 0;
 		const testIdCap = options.fixtureCountsMaxTestIds;
 		this.fixtureCountsMaxTestIds = testIdCap !== void 0 && testIdCap > 0 ? testIdCap : 0;
 	}
+	/**
+	* The per-test-id cap on fixture match-count maps, for an MCP mount to pass
+	* to `McpFakeStore.setMaxTestIds`. Always a non-negative safe integer, `0`
+	* meaning unbounded, and never throws, whatever option was passed:
+	* omitted, zero, negative or `NaN` is `0`; `Infinity` or a value above
+	* `Number.MAX_SAFE_INTEGER` (never reached) is `0`; a fraction of 1 or more
+	* is rounded down (`1.5` evicts at 2 ids, so it keeps 1). For these values
+	* it is the number of test ids the journal keeps.
+	*
+	* An option between 0 and 1 is the exception. The journal keeps no test id
+	* (each new count map is evicted as soon as it is made, so counts never
+	* advance), and a store cap cannot say "keep none" because `0` is
+	* unbounded. The getter returns `1`, the smallest bounded cap, so a store
+	* given it keeps 1 test id where the journal keeps 0.
+	*/
+	get fixtureCountsMaxTestIdsCap() {
+		const cap = this.fixtureCountsMaxTestIds;
+		if (!(cap > 0) || cap > Number.MAX_SAFE_INTEGER) return 0;
+		return Math.max(1, Math.floor(cap));
+	}
 	/** Backwards-compatible accessor — returns the default (no testId) count map. */
 	get fixtureMatchCounts() {
 		return this.getFixtureMatchCountsForTest(DEFAULT_TEST_ID);
 	}
-	add(entry) {
+	/** @internal matchedFixture preserves identity when Live supplies safe diagnostics. */
+	add(entry, matchedFixture) {
 		const full = {
 			id: generateId("req"),
 			timestamp: Date.now(),
 			...entry,
 			body: capBody(entry.body)
 		};
+		if (matchedFixture) this.matchedFixtures.set(full, matchedFixture);
 		this.entries.push(full);
 		if (this.maxEntries > 0 && this.entries.length > this.maxEntries) this.entries.shift();
+		this.onAdd?.(full);
 		return full;
 	}
+	/**
+	* Return every entry, or with `limit` the most recent `limit` entries.
+	* `0` returns `[]` — exactly what `GET /__aimock/journal?limit=0` answers.
+	* `slice(-0)` is `slice(0)`, so a `0` used to return the ENTIRE journal; it
+	* is special-cased so the library and the HTTP route agree. This is a public
+	* library API, so odd limits are tolerated rather than thrown on: a
+	* non-finite limit (`NaN`, `Infinity`) means "no limit", a fractional limit
+	* floors, and any limit at or below `0` asks for nothing.
+	*/
 	getAll(opts) {
-		if (opts?.limit !== void 0) return this.entries.slice(-opts.limit);
+		if (opts?.limit !== void 0 && Number.isFinite(opts.limit)) {
+			const limit = Math.floor(opts.limit);
+			if (limit <= 0) return [];
+			return this.entries.slice(-limit);
+		}
 		return this.entries.slice();
 	}
 	getLast() {
 		return this.entries.length > 0 ? this.entries[this.entries.length - 1] : null;
 	}
 	findByFixture(fixture) {
-		return this.entries.filter((e) => e.response.fixture === fixture);
+		return this.entries.filter((e) => (this.matchedFixtures.get(e) ?? e.response.fixture) === fixture);
 	}
 	/**
 	* READ-ONLY accessor. Returns the existing count map for `testId`, or an
@@ -161,5 +217,5 @@ var Journal = class {
 };
 
 //#endregion
-export { Journal };
+export { Journal, isChatCompletionBody };
 //# sourceMappingURL=journal.js.map

package/dist/journal.js.map

@@ -1 +1 @@
-{"version":3,"file":"journal.js","names":[],"sources":["../src/journal.ts"],"sourcesContent":["import { generateId } from \"./helpers.js\";\nimport type { ChatCompletionRequest, Fixture, FixtureMatch, JournalEntry } from \"./types.js\";\nimport { DEFAULT_TEST_ID } from \"./constants.js\";\nexport { DEFAULT_TEST_ID } from \"./constants.js\";\n\n/**\n * Maximum UTF-8 byte length of a serialized request body retained in a\n * journal entry. Bodies whose JSON serialization exceeds this byte size are\n * replaced with a truncation marker.\n *\n * Only the request `body` field is capped here. `headers` and `path` are\n * retained uncapped, but they are naturally bounded by Node's default ~16 KB\n * maximum HTTP header size, so the per-entry overhead beyond the body cap\n * remains small. Combined with the journal's maxEntries limit (default 1000),\n * the total `JSON.stringify(journal.getAll())` output stays well under V8's\n * ~512 MB string limit even at maximum capacity.\n */\nconst JOURNAL_BODY_CAP_BYTES = 64 * 1024; // 64 KB\n\n/**\n * If `body` serializes to more than JOURNAL_BODY_CAP_BYTES (in UTF-8 bytes),\n * replace it with a truncation marker. Returns the original body when within\n * the cap, or null when `body` is null.\n *\n * The gate uses Buffer.byteLength (UTF-8 bytes) rather than .length (UTF-16\n * code units) to match the constant name and to correctly cap multibyte\n * content (e.g. CJK/emoji) whose code-unit count falls under the threshold\n * but whose byte size does not.\n */\nfunction capBody(body: ChatCompletionRequest | null): ChatCompletionRequest | null {\n  if (body === null) return null;\n  const serialized = JSON.stringify(body);\n  if (Buffer.byteLength(serialized, \"utf8\") <= JOURNAL_BODY_CAP_BYTES) return body;\n  // Cast: the marker is not a real ChatCompletionRequest, but the field type\n  // is already nullable-union and downstream consumers (e.g. GET /journal)\n  // treat the body as opaque JSON — the truncation marker is safe to store.\n  return {\n    __aimock_truncated: true,\n    originalByteSize: Buffer.byteLength(serialized, \"utf8\"),\n    note: \"body truncated by aimock journal cap (64 KB limit)\",\n  } as unknown as ChatCompletionRequest;\n}\n\n/**\n * Compare two field values, handling RegExp by source+flags rather than reference.\n */\nfunction fieldEqual(a: unknown, b: unknown): boolean {\n  if (a instanceof RegExp && b instanceof RegExp)\n    return a.source === b.source && a.flags === b.flags;\n  return a === b;\n}\n\n/**\n * Compare two systemMessage values. Handles string, string[], and RegExp.\n * Both-undefined is treated as equal.\n */\nfunction systemMessageEqual(\n  a: string | string[] | RegExp | undefined,\n  b: string | string[] | RegExp | undefined,\n): boolean {\n  if (a === undefined && b === undefined) return true;\n  if (a === undefined || b === undefined) return false;\n  if (typeof a === \"string\" && typeof b === \"string\") return a === b;\n  if (Array.isArray(a) && Array.isArray(b))\n    return a.length === b.length && a.every((v, i) => v === b[i]);\n  if (a instanceof RegExp && b instanceof RegExp)\n    return a.source === b.source && a.flags === b.flags;\n  return false;\n}\n\n/**\n * Check whether two fixture match objects have the same criteria\n * (ignoring sequenceIndex). Used to group sequenced fixtures.\n */\nfunction matchCriteriaEqual(a: FixtureMatch, b: FixtureMatch): boolean {\n  return (\n    fieldEqual(a.userMessage, b.userMessage) &&\n    systemMessageEqual(a.systemMessage, b.systemMessage) &&\n    fieldEqual(a.inputText, b.inputText) &&\n    fieldEqual(a.toolCallId, b.toolCallId) &&\n    fieldEqual(a.toolName, b.toolName) &&\n    fieldEqual(a.model, b.model) &&\n    fieldEqual(a.responseFormat, b.responseFormat) &&\n    fieldEqual(a.predicate, b.predicate) &&\n    fieldEqual(a.endpoint, b.endpoint) &&\n    fieldEqual(a.turnIndex, b.turnIndex) &&\n    fieldEqual(a.hasToolResult, b.hasToolResult)\n  );\n}\n\nexport interface JournalOptions {\n  /**\n   * Maximum number of entries to retain. When exceeded, oldest entries are\n   * dropped FIFO. Set to 0 (or omit) for unbounded retention (the historical\n   * default — suitable for short-lived test runs only). Negative values are\n   * rejected at the CLI parse layer; programmatically they are treated as 0\n   * (unbounded) for back-compat.\n   *\n   * Long-running servers (e.g. mock proxies in CI/demo environments) should\n   * always set a finite cap: every request appends an entry holding the\n   * request body + headers + fixture reference, and without a cap the\n   * journal grows until the process OOMs.\n   */\n  maxEntries?: number;\n  /**\n   * Maximum number of unique testIds retained in the fixture match-count\n   * map (`fixtureMatchCountsByTestId`). When exceeded, the oldest testId\n   * (by first-insertion order) is evicted FIFO. Set to 0 (or omit) for\n   * unbounded retention. Negative values are rejected at the CLI parse\n   * layer; programmatically they are treated as 0 (unbounded) for\n   * back-compat. Without a cap this map can grow over time in long-running\n   * servers that see many unique testIds.\n   */\n  fixtureCountsMaxTestIds?: number;\n}\n\nexport class Journal {\n  private entries: JournalEntry[] = [];\n  private readonly fixtureMatchCountsByTestId: Map<string, Map<Fixture, number>> = new Map();\n  private readonly maxEntries: number;\n  private readonly fixtureCountsMaxTestIds: number;\n\n  constructor(options: JournalOptions = {}) {\n    // Treat 0 or negative as \"unbounded\" to preserve prior behavior when\n    // the option is omitted or explicitly disabled.\n    const cap = options.maxEntries;\n    this.maxEntries = cap !== undefined && cap > 0 ? cap : 0;\n    const testIdCap = options.fixtureCountsMaxTestIds;\n    this.fixtureCountsMaxTestIds = testIdCap !== undefined && testIdCap > 0 ? testIdCap : 0;\n  }\n\n  /** Backwards-compatible accessor — returns the default (no testId) count map. */\n  get fixtureMatchCounts(): Map<Fixture, number> {\n    return this.getFixtureMatchCountsForTest(DEFAULT_TEST_ID);\n  }\n\n  add(entry: Omit<JournalEntry, \"id\" | \"timestamp\">): JournalEntry {\n    const full: JournalEntry = {\n      id: generateId(\"req\"),\n      timestamp: Date.now(),\n      ...entry,\n      body: capBody(entry.body),\n    };\n    this.entries.push(full);\n    // FIFO eviction when over capacity. Array.prototype.shift() is O(n)\n    // regardless of how many we drop per add; we accept it at small caps\n    // (default 1000) because the constant factor is tiny and this runs once\n    // per request. For much larger caps, switch to a ring buffer for true\n    // O(1) eviction.\n    if (this.maxEntries > 0 && this.entries.length > this.maxEntries) {\n      this.entries.shift();\n    }\n    return full;\n  }\n\n  getAll(opts?: { limit?: number }): JournalEntry[] {\n    if (opts?.limit !== undefined) {\n      return this.entries.slice(-opts.limit);\n    }\n    return this.entries.slice();\n  }\n\n  getLast(): JournalEntry | null {\n    return this.entries.length > 0 ? this.entries[this.entries.length - 1] : null;\n  }\n\n  findByFixture(fixture: Fixture): JournalEntry[] {\n    return this.entries.filter((e) => e.response.fixture === fixture);\n  }\n\n  /**\n   * READ-ONLY accessor. Returns the existing count map for `testId`, or an\n   * empty transient Map if none exists. Does NOT insert into the cache and\n   * does NOT trigger FIFO eviction — callers may read freely without\n   * perturbing cache state. For the write path, see\n   * `getOrCreateFixtureMatchCountsForTest`.\n   */\n  getFixtureMatchCountsForTest(testId: string): Map<Fixture, number> {\n    return this.fixtureMatchCountsByTestId.get(testId) ?? new Map();\n  }\n\n  /**\n   * WRITE path: get the count map for `testId`, inserting a fresh empty Map\n   * if missing and running FIFO eviction when the testId cap is exceeded.\n   * Only callers that intend to mutate the map (e.g. incrementing a count)\n   * should use this.\n   */\n  private getOrCreateFixtureMatchCountsForTest(testId: string): Map<Fixture, number> {\n    let counts = this.fixtureMatchCountsByTestId.get(testId);\n    if (!counts) {\n      counts = new Map();\n      this.fixtureMatchCountsByTestId.set(testId, counts);\n      // FIFO eviction when over capacity. JS Map preserves insertion order,\n      // so the first key returned by keys() is the oldest. Same O(n) shift\n      // caveat as `entries`: acceptable at small caps (default 500).\n      if (\n        this.fixtureCountsMaxTestIds > 0 &&\n        this.fixtureMatchCountsByTestId.size > this.fixtureCountsMaxTestIds\n      ) {\n        const oldest = this.fixtureMatchCountsByTestId.keys().next().value;\n        if (oldest !== undefined) {\n          this.fixtureMatchCountsByTestId.delete(oldest);\n        }\n      }\n    }\n    return counts;\n  }\n\n  getFixtureMatchCount(fixture: Fixture, testId = DEFAULT_TEST_ID): number {\n    return this.getFixtureMatchCountsForTest(testId).get(fixture) ?? 0;\n  }\n\n  incrementFixtureMatchCount(\n    fixture: Fixture,\n    allFixtures?: readonly Fixture[],\n    testId = DEFAULT_TEST_ID,\n  ): void {\n    const counts = this.getOrCreateFixtureMatchCountsForTest(testId);\n    counts.set(fixture, (counts.get(fixture) ?? 0) + 1);\n    // When a sequenced fixture matches, also increment all siblings with matching criteria\n    if (fixture.match.sequenceIndex !== undefined && allFixtures) {\n      for (const sibling of allFixtures) {\n        if (sibling === fixture) continue;\n        if (sibling.match.sequenceIndex === undefined) continue;\n        if (matchCriteriaEqual(fixture.match, sibling.match)) {\n          counts.set(sibling, (counts.get(sibling) ?? 0) + 1);\n        }\n      }\n    }\n  }\n\n  clearMatchCounts(testId?: string): void {\n    if (testId !== undefined) {\n      this.fixtureMatchCountsByTestId.delete(testId);\n    } else {\n      this.fixtureMatchCountsByTestId.clear();\n    }\n  }\n\n  /**\n   * Clear ONLY the request journal entries, preserving fixture match-counts.\n   * Match-counts are fixture-matching/sequencing state, not journal data, so\n   * clearing the journal must not silently rewind sequenced fixtures. Used by\n   * `POST /__aimock/reset/journal`. For a full reset (entries + match-counts),\n   * use `clear()` instead.\n   */\n  clearEntries(): void {\n    this.entries = [];\n  }\n\n  clear(): void {\n    this.entries = [];\n    this.fixtureMatchCountsByTestId.clear();\n  }\n\n  get size(): number {\n    return this.entries.length;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"journal.js","names":[],"sources":["../src/journal.ts"],"sourcesContent":["import { generateId } from \"./helpers.js\";\nimport type {\n  ChatCompletionRequest,\n  Fixture,\n  FixtureMatch,\n  JournalBody,\n  JournalEntry,\n} from \"./types.js\";\nimport { DEFAULT_TEST_ID } from \"./constants.js\";\nexport { DEFAULT_TEST_ID } from \"./constants.js\";\n\n/**\n * Maximum UTF-8 byte length of a serialized request body retained in a\n * journal entry. Bodies whose JSON serialization exceeds this byte size are\n * replaced with a truncation marker.\n *\n * Only the request `body` field is capped here. `headers` and `path` are\n * retained uncapped, but they are naturally bounded by Node's default ~16 KB\n * maximum HTTP header size, so the per-entry overhead beyond the body cap\n * remains small. Combined with the journal's maxEntries limit (default 1000),\n * the total `JSON.stringify(journal.getAll())` output stays well under V8's\n * ~512 MB string limit even at maximum capacity.\n */\nconst JOURNAL_BODY_CAP_BYTES = 64 * 1024; // 64 KB\n\n/**\n * If `body` serializes to more than JOURNAL_BODY_CAP_BYTES (in UTF-8 bytes),\n * replace it with a truncation marker. Returns the original body when within\n * the cap, or null when `body` is null.\n *\n * The gate uses Buffer.byteLength (UTF-8 bytes) rather than .length (UTF-16\n * code units) to match the constant name and to correctly cap multibyte\n * content (e.g. CJK/emoji) whose code-unit count falls under the threshold\n * but whose byte size does not.\n */\nfunction capBody(body: JournalBody | null): JournalBody | null {\n  if (body === null) return null;\n  const serialized = JSON.stringify(body);\n  if (Buffer.byteLength(serialized, \"utf8\") <= JOURNAL_BODY_CAP_BYTES) return body;\n  // The marker is not a chat request, and `JournalBody` no longer claims it is\n  // — downstream consumers (e.g. GET /journal) treat the body as opaque JSON.\n  return {\n    __aimock_truncated: true,\n    originalByteSize: Buffer.byteLength(serialized, \"utf8\"),\n    note: \"body truncated by aimock journal cap (64 KB limit)\",\n  };\n}\n\n/**\n * Narrow a journaled body to a chat-completion request.\n *\n * `JournalEntry.body` is a union (see {@link JournalBody}): most entries hold a\n * chat request, but the fine-tuning create payload and this module's own\n * truncation marker do not. Anything reading `messages`, `model` or the rest of\n * the chat shape off a journal entry — inside aimock or in a consumer's test\n * — goes through here, so an entry that is not a chat request fails as a\n * `false` it can assert on rather than as an undefined property three accesses\n * later.\n *\n * `messages` is the discriminator because it is the one required field no\n * other journaled shape carries.\n */\nexport function isChatCompletionBody(\n  body: JournalBody | null | undefined,\n): body is ChatCompletionRequest {\n  return (\n    body !== null &&\n    body !== undefined &&\n    Array.isArray((body as { messages?: unknown }).messages) &&\n    typeof (body as { model?: unknown }).model === \"string\"\n  );\n}\n\n/**\n * Compare two field values, handling RegExp by source+flags rather than reference.\n */\nfunction fieldEqual(a: unknown, b: unknown): boolean {\n  if (a instanceof RegExp && b instanceof RegExp)\n    return a.source === b.source && a.flags === b.flags;\n  return a === b;\n}\n\n/**\n * Compare two systemMessage values. Handles string, string[], and RegExp.\n * Both-undefined is treated as equal.\n */\nfunction systemMessageEqual(\n  a: string | string[] | RegExp | undefined,\n  b: string | string[] | RegExp | undefined,\n): boolean {\n  if (a === undefined && b === undefined) return true;\n  if (a === undefined || b === undefined) return false;\n  if (typeof a === \"string\" && typeof b === \"string\") return a === b;\n  if (Array.isArray(a) && Array.isArray(b))\n    return a.length === b.length && a.every((v, i) => v === b[i]);\n  if (a instanceof RegExp && b instanceof RegExp)\n    return a.source === b.source && a.flags === b.flags;\n  return false;\n}\n\n/**\n * Check whether two fixture match objects have the same criteria\n * (ignoring sequenceIndex). Used to group sequenced fixtures.\n */\nfunction matchCriteriaEqual(a: FixtureMatch, b: FixtureMatch): boolean {\n  return (\n    fieldEqual(a.userMessage, b.userMessage) &&\n    systemMessageEqual(a.systemMessage, b.systemMessage) &&\n    fieldEqual(a.inputText, b.inputText) &&\n    fieldEqual(a.toolCallId, b.toolCallId) &&\n    fieldEqual(a.toolName, b.toolName) &&\n    fieldEqual(a.model, b.model) &&\n    fieldEqual(a.responseFormat, b.responseFormat) &&\n    fieldEqual(a.predicate, b.predicate) &&\n    fieldEqual(a.endpoint, b.endpoint) &&\n    fieldEqual(a.turnIndex, b.turnIndex) &&\n    fieldEqual(a.hasToolResult, b.hasToolResult) &&\n    fieldEqual(a.toolResultContains, b.toolResultContains) &&\n    fieldEqual(a.context, b.context)\n  );\n}\n\nexport interface JournalOptions {\n  /**\n   * Maximum number of entries to retain. When exceeded, oldest entries are\n   * dropped FIFO. Set to 0 (or omit) for unbounded retention (the historical\n   * default — suitable for short-lived test runs only). Negative values are\n   * rejected at the CLI parse layer; programmatically they are treated as 0\n   * (unbounded) for back-compat.\n   *\n   * Long-running servers (e.g. mock proxies in CI/demo environments) should\n   * always set a finite cap: every request appends an entry holding the\n   * request body + headers + fixture reference, and without a cap the\n   * journal grows until the process OOMs.\n   */\n  maxEntries?: number;\n  /**\n   * Maximum number of unique testIds retained in the fixture match-count\n   * map (`fixtureMatchCountsByTestId`). When exceeded, the oldest testId\n   * (by first-insertion order) is evicted FIFO. Set to 0 (or omit) for\n   * unbounded retention. Negative values are rejected at the CLI parse\n   * layer; programmatically they are treated as 0 (unbounded) for\n   * back-compat. Without a cap this map can grow over time in long-running\n   * servers that see many unique testIds.\n   */\n  fixtureCountsMaxTestIds?: number;\n  /**\n   * Called with every entry {@link Journal.add} creates, right after it is\n   * recorded. The hook exists so an embedder can attribute an entry to the\n   * request that produced it WITHOUT touching each of the ~100 `journal.add`\n   * call sites spread across the handler modules: the server binds the entry\n   * to the in-flight `IncomingMessage` here, and its error arm then amends\n   * that exact object rather than guessing from a caller-supplied header.\n   *\n   * The entry is already recorded when the hook runs, so a hook that throws\n   * does not lose the write — but it does propagate out of `add` into the\n   * caller's error path, so a hook must not throw.\n   */\n  onAdd?: (entry: JournalEntry) => void;\n}\n\nexport class Journal {\n  private entries: JournalEntry[] = [];\n  private readonly matchedFixtures = new WeakMap<JournalEntry, Fixture>();\n  private readonly fixtureMatchCountsByTestId: Map<string, Map<Fixture, number>> = new Map();\n  private readonly maxEntries: number;\n  private readonly fixtureCountsMaxTestIds: number;\n  private readonly onAdd?: (entry: JournalEntry) => void;\n\n  constructor(options: JournalOptions = {}) {\n    this.onAdd = options.onAdd;\n    // Treat 0 or negative as \"unbounded\" to preserve prior behavior when\n    // the option is omitted or explicitly disabled.\n    const cap = options.maxEntries;\n    this.maxEntries = cap !== undefined && cap > 0 ? cap : 0;\n    const testIdCap = options.fixtureCountsMaxTestIds;\n    this.fixtureCountsMaxTestIds = testIdCap !== undefined && testIdCap > 0 ? testIdCap : 0;\n  }\n\n  /**\n   * The per-test-id cap on fixture match-count maps, for an MCP mount to pass\n   * to `McpFakeStore.setMaxTestIds`. Always a non-negative safe integer, `0`\n   * meaning unbounded, and never throws, whatever option was passed:\n   * omitted, zero, negative or `NaN` is `0`; `Infinity` or a value above\n   * `Number.MAX_SAFE_INTEGER` (never reached) is `0`; a fraction of 1 or more\n   * is rounded down (`1.5` evicts at 2 ids, so it keeps 1). For these values\n   * it is the number of test ids the journal keeps.\n   *\n   * An option between 0 and 1 is the exception. The journal keeps no test id\n   * (each new count map is evicted as soon as it is made, so counts never\n   * advance), and a store cap cannot say \"keep none\" because `0` is\n   * unbounded. The getter returns `1`, the smallest bounded cap, so a store\n   * given it keeps 1 test id where the journal keeps 0.\n   */\n  get fixtureCountsMaxTestIdsCap(): number {\n    const cap = this.fixtureCountsMaxTestIds;\n    if (!(cap > 0) || cap > Number.MAX_SAFE_INTEGER) return 0;\n    return Math.max(1, Math.floor(cap));\n  }\n\n  /** Backwards-compatible accessor — returns the default (no testId) count map. */\n  get fixtureMatchCounts(): Map<Fixture, number> {\n    return this.getFixtureMatchCountsForTest(DEFAULT_TEST_ID);\n  }\n\n  /** @internal matchedFixture preserves identity when Live supplies safe diagnostics. */\n  add(entry: Omit<JournalEntry, \"id\" | \"timestamp\">, matchedFixture?: Fixture): JournalEntry {\n    const full: JournalEntry = {\n      id: generateId(\"req\"),\n      timestamp: Date.now(),\n      ...entry,\n      body: capBody(entry.body),\n    };\n    if (matchedFixture) this.matchedFixtures.set(full, matchedFixture);\n    this.entries.push(full);\n    // FIFO eviction when over capacity. Array.prototype.shift() is O(n)\n    // regardless of how many we drop per add; we accept it at small caps\n    // (default 1000) because the constant factor is tiny and this runs once\n    // per request. For much larger caps, switch to a ring buffer for true\n    // O(1) eviction.\n    if (this.maxEntries > 0 && this.entries.length > this.maxEntries) {\n      this.entries.shift();\n    }\n    this.onAdd?.(full);\n    return full;\n  }\n\n  /**\n   * Return every entry, or with `limit` the most recent `limit` entries.\n   * `0` returns `[]` — exactly what `GET /__aimock/journal?limit=0` answers.\n   * `slice(-0)` is `slice(0)`, so a `0` used to return the ENTIRE journal; it\n   * is special-cased so the library and the HTTP route agree. This is a public\n   * library API, so odd limits are tolerated rather than thrown on: a\n   * non-finite limit (`NaN`, `Infinity`) means \"no limit\", a fractional limit\n   * floors, and any limit at or below `0` asks for nothing.\n   */\n  getAll(opts?: { limit?: number }): JournalEntry[] {\n    if (opts?.limit !== undefined && Number.isFinite(opts.limit)) {\n      const limit = Math.floor(opts.limit);\n      if (limit <= 0) return [];\n      return this.entries.slice(-limit);\n    }\n    return this.entries.slice();\n  }\n\n  getLast(): JournalEntry | null {\n    return this.entries.length > 0 ? this.entries[this.entries.length - 1] : null;\n  }\n\n  findByFixture(fixture: Fixture): JournalEntry[] {\n    return this.entries.filter(\n      (e) => (this.matchedFixtures.get(e) ?? e.response.fixture) === fixture,\n    );\n  }\n\n  /**\n   * READ-ONLY accessor. Returns the existing count map for `testId`, or an\n   * empty transient Map if none exists. Does NOT insert into the cache and\n   * does NOT trigger FIFO eviction — callers may read freely without\n   * perturbing cache state. For the write path, see\n   * `getOrCreateFixtureMatchCountsForTest`.\n   */\n  getFixtureMatchCountsForTest(testId: string): Map<Fixture, number> {\n    return this.fixtureMatchCountsByTestId.get(testId) ?? new Map();\n  }\n\n  /**\n   * WRITE path: get the count map for `testId`, inserting a fresh empty Map\n   * if missing and running FIFO eviction when the testId cap is exceeded.\n   * Only callers that intend to mutate the map (e.g. incrementing a count)\n   * should use this.\n   */\n  private getOrCreateFixtureMatchCountsForTest(testId: string): Map<Fixture, number> {\n    let counts = this.fixtureMatchCountsByTestId.get(testId);\n    if (!counts) {\n      counts = new Map();\n      this.fixtureMatchCountsByTestId.set(testId, counts);\n      // FIFO eviction when over capacity. JS Map preserves insertion order,\n      // so the first key returned by keys() is the oldest. Same O(n) shift\n      // caveat as `entries`: acceptable at small caps (createServer\n      // default 500; a bare Journal is unbounded).\n      if (\n        this.fixtureCountsMaxTestIds > 0 &&\n        this.fixtureMatchCountsByTestId.size > this.fixtureCountsMaxTestIds\n      ) {\n        const oldest = this.fixtureMatchCountsByTestId.keys().next().value;\n        if (oldest !== undefined) {\n          this.fixtureMatchCountsByTestId.delete(oldest);\n        }\n      }\n    }\n    return counts;\n  }\n\n  getFixtureMatchCount(fixture: Fixture, testId = DEFAULT_TEST_ID): number {\n    return this.getFixtureMatchCountsForTest(testId).get(fixture) ?? 0;\n  }\n\n  incrementFixtureMatchCount(\n    fixture: Fixture,\n    allFixtures?: readonly Fixture[],\n    testId = DEFAULT_TEST_ID,\n  ): void {\n    const counts = this.getOrCreateFixtureMatchCountsForTest(testId);\n    counts.set(fixture, (counts.get(fixture) ?? 0) + 1);\n    // When a sequenced fixture matches, also increment all siblings with matching criteria\n    if (fixture.match.sequenceIndex !== undefined && allFixtures) {\n      for (const sibling of allFixtures) {\n        if (sibling === fixture) continue;\n        if (sibling.match.sequenceIndex === undefined) continue;\n        if (matchCriteriaEqual(fixture.match, sibling.match)) {\n          counts.set(sibling, (counts.get(sibling) ?? 0) + 1);\n        }\n      }\n    }\n  }\n\n  clearMatchCounts(testId?: string): void {\n    if (testId !== undefined) {\n      this.fixtureMatchCountsByTestId.delete(testId);\n    } else {\n      this.fixtureMatchCountsByTestId.clear();\n    }\n  }\n\n  /**\n   * Clear ONLY the request journal entries, preserving fixture match-counts.\n   * Match-counts are fixture-matching/sequencing state, not journal data, so\n   * clearing the journal must not silently rewind sequenced fixtures. Used by\n   * `POST /__aimock/reset/journal`. For a full reset (entries + match-counts),\n   * use `clear()` instead.\n   */\n  clearEntries(): void {\n    this.entries = [];\n  }\n\n  clear(): void {\n    this.entries = [];\n    this.fixtureMatchCountsByTestId.clear();\n  }\n\n  get size(): number {\n    return this.entries.length;\n  }\n}\n"],"mappings":"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"}