@forwardimpact/libharness 0.1.22 → 1.0.0

package/src/trace-render.js

@@ -0,0 +1,211 @@
+/**
+ * Text renderers for `fit-trace` query output.
+ *
+ * One named export per renderable verb. Each renderer accepts the query result
+ * plus `{multi, signatures}` and returns a string. `multi` controls
+ * source-attribution prefixing (`grep -H` convention); record-per-line
+ * renderers prepend `<basename>:`, block renderers emit `# <basename>` headers.
+ *
+ * Internal module — imported by `commands/trace.js` and tests by relative
+ * path, never re-exported from `src/index.js`.
+ */
+
+/** Collapse newlines/tabs in a value to a single-line, grep-friendly string. */
+function oneLine(value) {
+  const str = typeof value === "string" ? value : JSON.stringify(value ?? null);
+  return str.replace(/[\r\n\t]+/g, " ").trim();
+}
+
+/** Group records by their `source` field (multi-file path), preserving order. */
+function groupBySource(records) {
+  const groups = new Map();
+  for (const record of records) {
+    const key = record.source ?? "";
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(record);
+  }
+  return groups;
+}
+
+/**
+ * Render record-per-line output, prefixing each line with `<source>:` when
+ * multi-file. `lineOf` maps one record to its text line.
+ * @param {object[]} records
+ * @param {(record: object) => string} lineOf
+ * @param {{multi: boolean}} opts
+ * @returns {string}
+ */
+function renderLines(records, lineOf, { multi }) {
+  return records
+    .map((r) => (multi && r.source ? `${r.source}:${lineOf(r)}` : lineOf(r)))
+    .join("\n");
+}
+
+/**
+ * Render a block per source. `blockOf` maps one record to a multi-line string;
+ * multi-file output separates groups with `# <source>` headers.
+ * @param {object[]} records
+ * @param {(record: object) => string} blockOf
+ * @param {{multi: boolean}} opts
+ * @returns {string}
+ */
+function renderBlocks(records, blockOf, { multi }) {
+  if (!multi) return records.map(blockOf).join("\n");
+  const out = [];
+  for (const [source, group] of groupBySource(records)) {
+    out.push(`# ${source}`);
+    out.push(...group.map(blockOf));
+  }
+  return out.join("\n");
+}
+
+/** `[turnIdx] <Tool> <toolUseId>` / `  in:` / `  out:` per block. */
+export function renderToolCalls(records, opts = {}) {
+  return renderBlocks(
+    records,
+    (r) => {
+      const head = `[${r.turnIndex}] ${r.name} ${r.toolUseId}`;
+      const input = `  in: ${oneLine(r.input)}`;
+      const out = `  out: ${
+        r.result ? oneLine(r.result.content) : "(no result)"
+      }`;
+      return [head, input, out].join("\n");
+    },
+    opts,
+  );
+}
+
+/** `[turnIdx] <command>` per line, newlines escaped. */
+export function renderCommands(records, opts = {}) {
+  return renderLines(
+    records,
+    (r) => `[${r.turnIndex}] ${oneLine(r.command)}`,
+    opts,
+  );
+}
+
+/** `<count>\t<path>` frequency-sorted. */
+export function renderPaths(records, opts = {}) {
+  return renderLines(records, (r) => `${r.count}\t${r.path}`, opts);
+}
+
+/** Metadata header, per-row metrics, then Tool and Path delta tables. */
+export function renderCompare(result) {
+  const { a, b, toolDelta, pathDelta } = result;
+  const part = (p) => (p == null ? "(none)" : p);
+  const lines = [];
+  lines.push(
+    `A: ${a.metadata.caseName} / ${part(a.metadata.participant)}${
+      a.metadata.marker ? ` ${a.metadata.marker}` : ""
+    }`,
+  );
+  lines.push(
+    `B: ${b.metadata.caseName} / ${part(b.metadata.participant)}${
+      b.metadata.marker ? ` ${b.metadata.marker}` : ""
+    }`,
+  );
+  lines.push("");
+  lines.push(`turns    | ${a.turnCount} | ${b.turnCount}`);
+  lines.push(`tools    | ${a.tools.length} | ${b.tools.length}`);
+  lines.push(`paths    | ${a.pathCount} | ${b.pathCount}`);
+  lines.push(`cost     | ${a.cost} | ${b.cost}`);
+  lines.push("");
+  lines.push("Tool | A | B | Δ");
+  for (const d of toolDelta) {
+    lines.push(`${d.tool} | ${d.a} | ${d.b} | ${d.diff}`);
+  }
+  lines.push("");
+  lines.push("Path | A | B | Δ");
+  for (const d of pathDelta) {
+    lines.push(`${d.path} | ${d.a} | ${d.b} | ${d.diff}`);
+  }
+  return lines.join("\n");
+}
+
+/** `Tool | Turns | In | Out | Share` sorted Share desc. */
+export function renderStatsByTool(result) {
+  const lines = ["Tool | Turns | In | Out | Share"];
+  for (const b of result.perTool) {
+    lines.push(
+      `${b.tool} | ${b.turns} | ${Math.round(b.inputTokens)} | ${Math.round(
+        b.outputTokens,
+      )} | ${b.costShare.toFixed(4)}`,
+    );
+  }
+  return lines.join("\n");
+}
+
+/** Totals block only. */
+export function renderStatsSummary(result) {
+  const t = result.totals;
+  return [
+    `inputTokens: ${t.inputTokens}`,
+    `outputTokens: ${t.outputTokens}`,
+    `cacheReadInputTokens: ${t.cacheReadInputTokens}`,
+    `cacheCreationInputTokens: ${t.cacheCreationInputTokens}`,
+    `totalCostUsd: ${t.totalCostUsd}`,
+    `durationMs: ${t.durationMs}`,
+  ].join("\n");
+}
+
+/** `[turnIdx] <prefix>: <excerpt>` per match. */
+export function renderSearch(records, opts = {}) {
+  const lines = [];
+  for (const hit of records) {
+    const idx = hit.turn?.index;
+    const prefix = multiPrefix(hit, opts);
+    for (const match of hit.matches ?? []) {
+      lines.push(`${prefix}[${idx}] ${oneLine(match)}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+/** Source prefix for a multi-file record (search/default), or "". */
+function multiPrefix(record, { multi }) {
+  return multi && record.source ? `${record.source}:` : "";
+}
+
+/**
+ * Default renderer for every other renderable verb: one record per block,
+ * fields rendered as `key: value` lines (no JSON braces or quotes, so the
+ * default output is grep/awk-friendly and does not parse as JSON). Nested
+ * values are collapsed to a single grep-friendly line. Multi-file output
+ * separates source groups with `# <source>` headers (`renderBlocks`
+ * convention).
+ * @param {object[]|object} result
+ * @param {{multi: boolean}} opts
+ * @returns {string}
+ */
+export function renderDefault(result, opts = {}) {
+  const records = Array.isArray(result) ? result : [result];
+  return renderBlocks(records, (r) => recordBlock(stripSource(r)), opts);
+}
+
+/**
+ * Render one record as `key: value` lines. Scalars render verbatim; objects
+ * and arrays collapse to a single line via `oneLine`. A non-object record
+ * (string/number) renders as its own single line.
+ * @param {*} record
+ * @returns {string}
+ */
+function recordBlock(record) {
+  if (record == null || typeof record !== "object" || Array.isArray(record)) {
+    return oneLine(record);
+  }
+  return Object.entries(record)
+    .map(([key, value]) => {
+      const scalar = value == null || typeof value !== "object";
+      return `${key}: ${scalar ? String(value) : oneLine(value)}`;
+    })
+    .join("\n");
+}
+
+/** Drop the orchestrator-injected `source` field before textifying. */
+function stripSource(record) {
+  if (record == null || typeof record !== "object" || Array.isArray(record)) {
+    return record;
+  }
+  const { source, ...rest } = record;
+  return rest;
+}

package/src/trace-usage.js

@@ -0,0 +1,249 @@
+/**
+ * Token-usage accounting for structured trace documents.
+ *
+ * `stats()` reports totals that name their population: result-event sums when
+ * the trace carries them (authoritative), the per-message fallback otherwise,
+ * or the carried last-wins summary for a pre-change document. These helpers
+ * compute the per-message accounting and surface any divergence against the
+ * result-event sums so a mismatch is reported, never silently absorbed.
+ */
+
+/** Zero-valued token usage, used as the carried-document fallback. */
+export const ZERO_USAGE = {
+  inputTokens: 0,
+  outputTokens: 0,
+  cacheReadInputTokens: 0,
+  cacheCreationInputTokens: 0,
+};
+
+/**
+ * Per-stream-event breakdown for a pre-change document, labeled as carried —
+ * old documents lack message identity, so rows stay keyed by turn index.
+ * @param {object[]} turns
+ * @returns {object[]}
+ */
+export function carriedPerTurn(turns) {
+  const perTurn = [];
+  for (const turn of turns) {
+    if (turn.role !== "assistant" || !turn.usage) continue;
+    perTurn.push({
+      index: turn.index,
+      inputTokens: turn.usage.inputTokens ?? 0,
+      outputTokens: turn.usage.outputTokens ?? 0,
+      cacheReadInputTokens: turn.usage.cacheReadInputTokens ?? 0,
+      cacheCreationInputTokens: turn.usage.cacheCreationInputTokens ?? 0,
+      population: "carried-document-per-turn",
+    });
+  }
+  return perTurn;
+}
+
+/**
+ * Whether a structured-document version predates per-message accounting
+ * (1.2.0). A trace with no version (collected by this build from NDJSON) is
+ * not pre-change. Compares numeric version parts so 1.10.0 reads as post-change.
+ * @param {string|undefined|null} version
+ * @returns {boolean}
+ */
+export function isPreChangeDoc(version) {
+  if (typeof version !== "string") return false;
+  const [major = 0, minor = 0] = version
+    .split(".")
+    .map((part) => parseInt(part, 10) || 0);
+  if (major !== 1) return major < 1;
+  // Per-message accounting arrived in 1.2.0; any 1.2.x is post-change.
+  return minor < 2;
+}
+
+/**
+ * Account assistant usage once per API message. Turns are grouped by
+ * `messageId` (a null id is its own singleton message); per message the
+ * field-wise max across its snapshots is taken — order-insensitive, equal to
+ * the single value when a message's duplicate snapshots are byte-identical
+ * (zero residual against result-event sums), and a floor for output (the
+ * largest streaming snapshot, never an overstatement).
+ * @param {object[]} turns
+ * @returns {{perMessage: object[], totals: object}}
+ */
+export function perMessageUsage(turns) {
+  const byMessage = new Map();
+  let singletonSeq = 0;
+
+  for (const turn of turns) {
+    if (turn.role !== "assistant" || !turn.usage) continue;
+    const key = turn.messageId ?? `__null__${singletonSeq++}`;
+    accumulateMessage(byMessage, key, turn);
+  }
+
+  const totals = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+  };
+  const perMessage = [];
+  for (const row of byMessage.values()) {
+    totals.inputTokens += row.inputTokens;
+    totals.outputTokens += row.outputTokens;
+    totals.cacheReadInputTokens += row.cacheReadInputTokens;
+    totals.cacheCreationInputTokens += row.cacheCreationInputTokens;
+    perMessage.push({
+      ...row,
+      outputIsStreamingSnapshot: true,
+      population: "api-message",
+    });
+  }
+  return { perMessage, totals };
+}
+
+/**
+ * Fold one assistant turn's usage into its message bucket by field-wise max.
+ * @param {Map<string, object>} byMessage
+ * @param {string} key
+ * @param {object} turn
+ */
+function accumulateMessage(byMessage, key, turn) {
+  const u = turn.usage;
+  const prev = byMessage.get(key);
+  if (!prev) {
+    byMessage.set(key, {
+      messageId: turn.messageId ?? null,
+      inputTokens: u.inputTokens ?? 0,
+      outputTokens: u.outputTokens ?? 0,
+      cacheReadInputTokens: u.cacheReadInputTokens ?? 0,
+      cacheCreationInputTokens: u.cacheCreationInputTokens ?? 0,
+    });
+    return;
+  }
+  prev.inputTokens = Math.max(prev.inputTokens, u.inputTokens ?? 0);
+  prev.outputTokens = Math.max(prev.outputTokens, u.outputTokens ?? 0);
+  prev.cacheReadInputTokens = Math.max(
+    prev.cacheReadInputTokens,
+    u.cacheReadInputTokens ?? 0,
+  );
+  prev.cacheCreationInputTokens = Math.max(
+    prev.cacheCreationInputTokens,
+    u.cacheCreationInputTokens ?? 0,
+  );
+}
+
+/**
+ * Compare per-message sums against the result-event sums on the fields the
+ * spec guarantees parity for (input, cacheRead, cacheCreation — never output,
+ * which always diverges by mechanism 2). Returns the first divergent field as
+ * `{field, perMessageSum, resultEventSum}`, or null when all agree.
+ * @param {object} perMessageTotals
+ * @param {object} resultEventUsage
+ * @returns {object|null}
+ */
+export function computeDivergence(perMessageTotals, resultEventUsage) {
+  for (const field of [
+    "inputTokens",
+    "cacheReadInputTokens",
+    "cacheCreationInputTokens",
+  ]) {
+    const perMessageSum = perMessageTotals[field] ?? 0;
+    const resultEventSum = resultEventUsage[field] ?? 0;
+    if (perMessageSum !== resultEventSum) {
+      return { field, perMessageSum, resultEventSum };
+    }
+  }
+  return null;
+}
+
+/** Sentinel bucket name for assistant turns that ran no tool call. */
+const NO_TOOL = "(no-tool)";
+
+/**
+ * Attribute per-turn usage to per-tool buckets: each `tool_use` block gets an
+ * equal share of its host turn's usage; assistant turns with no `tool_use`
+ * block contribute full usage to the `(no-tool)` bucket.
+ * @param {object[]} turns
+ * @returns {{buckets: Map<string, {inputTokens: number, outputTokens: number}>, bucketTurns: Map<string, Set<number>>}}
+ */
+export function bucketUsageByTool(turns) {
+  const buckets = new Map();
+  const bucketTurns = new Map();
+  const ensure = (name) => {
+    if (!buckets.has(name)) {
+      buckets.set(name, { inputTokens: 0, outputTokens: 0 });
+      bucketTurns.set(name, new Set());
+    }
+    return buckets.get(name);
+  };
+
+  for (const turn of turns) {
+    if (turn.role !== "assistant" || !turn.usage) continue;
+    const input = turn.usage.inputTokens ?? 0;
+    const output = turn.usage.outputTokens ?? 0;
+    const toolBlocks = turn.content.filter((b) => b.type === "tool_use");
+    const targets = toolBlocks.length === 0 ? [NO_TOOL] : toolBlocks;
+    const shareIn = input / targets.length;
+    const shareOut = output / targets.length;
+    for (const target of targets) {
+      const name = typeof target === "string" ? target : target.name;
+      const bucket = ensure(name);
+      bucket.inputTokens += shareIn;
+      bucket.outputTokens += shareOut;
+      bucketTurns.get(name).add(turn.index);
+    }
+  }
+  return { buckets, bucketTurns };
+}
+
+/**
+ * Scale per-tool buckets onto the headline totals so the input, output, and
+ * `costShare` columns each sum to the corresponding `totals` value (and 1.0)
+ * exactly, regardless of population (result-event-sum, per-message-fallback, or
+ * carried-document). The largest bucket absorbs the rounding residual on each
+ * axis (criterion-6 invariant).
+ * @param {Map<string, {inputTokens: number, outputTokens: number}>} buckets
+ * @param {Map<string, Set<number>>} bucketTurns
+ * @param {object} totals
+ * @returns {Array<{tool: string, turns: number, inputTokens: number, outputTokens: number, costShare: number}>}
+ */
+export function reconcileBucketsToTotals(buckets, bucketTurns, totals) {
+  const rawIn = sumField(buckets, "inputTokens");
+  const rawOut = sumField(buckets, "outputTokens");
+  const scaleIn = rawIn === 0 ? 0 : (totals.inputTokens ?? 0) / rawIn;
+  const scaleOut = rawOut === 0 ? 0 : (totals.outputTokens ?? 0) / rawOut;
+  for (const b of buckets.values()) {
+    b.inputTokens *= scaleIn;
+    b.outputTokens *= scaleOut;
+  }
+
+  const totalTokens =
+    sumField(buckets, "inputTokens") + sumField(buckets, "outputTokens");
+  const perTool = [...buckets.entries()].map(([tool, b]) => ({
+    tool,
+    turns: bucketTurns.get(tool).size,
+    inputTokens: b.inputTokens,
+    outputTokens: b.outputTokens,
+    costShare:
+      totalTokens === 0 ? 0 : (b.inputTokens + b.outputTokens) / totalTokens,
+  }));
+  perTool.sort(
+    (x, y) => y.costShare - x.costShare || x.tool.localeCompare(y.tool),
+  );
+
+  if (perTool.length > 0) {
+    const top = perTool[0];
+    const sum = (field) => perTool.reduce((s, r) => s + r[field], 0);
+    top.inputTokens += (totals.inputTokens ?? 0) - sum("inputTokens");
+    top.outputTokens += (totals.outputTokens ?? 0) - sum("outputTokens");
+    top.costShare += 1 - sum("costShare");
+  }
+  return perTool;
+}
+
+/**
+ * Sum one numeric field across every bucket value.
+ * @param {Map<string, object>} buckets
+ * @param {string} field
+ * @returns {number}
+ */
+function sumField(buckets, field) {
+  let total = 0;
+  for (const b of buckets.values()) total += b[field];
+  return total;
+}

package/src/fixture/assertions.js

@@ -1,42 +0,0 @@
-import assert from "node:assert";
-
-/**
- * Asserts that a function throws with a matching message
- * @param {Function} fn - Function to test
- * @param {RegExp|string} pattern - Pattern to match
- * @param {string} message - Assertion message
- */
-export function assertThrowsMessage(fn, pattern, message) {
-  assert.throws(
-    fn,
-    { message: pattern instanceof RegExp ? pattern : new RegExp(pattern) },
-    message,
-  );
-}
-
-/**
- * Asserts that an async function rejects with a matching message
- * @param {Function} fn - Async function to test
- * @param {RegExp|string} pattern - Pattern to match
- * @param {string} message - Assertion message
- */
-export async function assertRejectsMessage(fn, pattern, message) {
-  await assert.rejects(
-    fn,
-    { message: pattern instanceof RegExp ? pattern : new RegExp(pattern) },
-    message,
-  );
-}
-
-/**
- * Creates a deferred promise for async testing
- * @returns {object} Object with promise, resolve, and reject
- */
-export function createDeferred() {
-  let resolve, reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve, reject };
-}

package/src/fixture/cache.js

@@ -1,50 +0,0 @@
-/**
- * Cross-file fixture caching helpers. The test runner currently executes one
- * test file per process, but fixtures loaded inside a file (e.g. starter
- * standard YAML via `createDataLoader().loadAllData(dir)`) are re-parsed for
- * every `test(...)` case unless hoisted. See spec 620.
- */
-
-const caches = new WeakMap();
-const stringCaches = new Map();
-
-/**
- * Wraps an async factory so it is invoked at most once per unique key.
- *
- * @template T
- * @param {string} key - Cache key. Using the same key returns the cached value.
- * @param {() => Promise<T>} factory - Factory invoked on miss.
- * @returns {Promise<T>}
- */
-export async function memoizeAsync(key, factory) {
-  if (stringCaches.has(key)) return stringCaches.get(key);
-  const promise = Promise.resolve().then(factory);
-  stringCaches.set(key, promise);
-  try {
-    return await promise;
-  } catch (err) {
-    stringCaches.delete(key);
-    throw err;
-  }
-}
-
-/**
- * Caches the result of `fn(subject)` keyed by identity of `subject`. Useful
- * for expensive derivations over a frozen input object.
- *
- * @template S, T
- * @param {S} subject
- * @param {(subject: S) => T} fn
- * @returns {T}
- */
-export function memoizeOnSubject(subject, fn) {
-  if (!caches.has(subject)) caches.set(subject, fn(subject));
-  return caches.get(subject);
-}
-
-/**
- * Clears all memoization caches. Only useful in self-tests of this helper.
- */
-export function __resetMemoCaches() {
-  stringCaches.clear();
-}

package/src/fixture/eval.js

@@ -1,146 +0,0 @@
-/**
- * Test helpers for libeval-style streams, tool-use messages, and traces.
- *
- * Before these helpers existed, every test file under libraries/libeval/test
- * inlined its own copy of concludeMsg / redirectMsg / tellMsg / stripAnsi /
- * collect / writeLines / buildTrace. See spec 620.
- */
-
-/**
- * Builds a tool-use message envelope as emitted by the agent SDK.
- * Replaces per-file concludeMsg / redirectMsg / tellMsg / shareMsg helpers.
- *
- * @param {string} name - Tool name, e.g. "Conclude", "Redirect", "Tell", "Share".
- * @param {object} input - Tool input payload.
- * @param {object} [options]
- * @param {string} [options.id] - Explicit tool_use id. Defaults to `${name.toLowerCase()}-1`.
- * @returns {object} Assistant message with a single tool_use content block.
- */
-export function createToolUseMsg(name, input, { id } = {}) {
-  return {
-    type: "assistant",
-    message: {
-      content: [
-        {
-          type: "tool_use",
-          id: id || `${name.toLowerCase()}-1`,
-          name,
-          input,
-        },
-      ],
-    },
-  };
-}
-
-/**
- * Builds an assistant text message envelope as emitted by the agent SDK.
- * @param {string} text - Text content.
- * @returns {object} Assistant message with a single text content block.
- */
-export function createTextBlockMsg(text) {
-  return {
-    type: "assistant",
-    message: {
-      content: [{ type: "text", text }],
-    },
-  };
-}
-
-/**
- * Reads a PassThrough / Readable stream to a single string.
- * @param {import("node:stream").Readable} stream
- * @returns {string}
- */
-export function collectStream(stream) {
-  const data = stream.read();
-  return data ? data.toString() : "";
-}
-
-/**
- * Reads a stream and returns non-empty lines.
- * @param {import("node:stream").Readable} stream
- * @returns {string[]}
- */
-export function collectLines(stream) {
-  return collectStream(stream).split("\n").filter(Boolean);
-}
-
-/**
- * Strips ANSI SGR escape sequences from a string.
- * @param {string} s
- * @returns {string}
- */
-export function stripAnsi(s) {
-  // biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI SGR detection is intentional.
-  return s.replace(/\[[0-9;]*m/g, "");
-}
-
-/**
- * Writes each line followed by a newline to the writer, then ends it.
- * @param {import("node:stream").Writable} writer
- * @param {string[]} lines
- * @returns {Promise<void>}
- */
-export async function writeLines(writer, lines) {
-  for (const line of lines) writer.write(line + "\n");
-  await new Promise((resolve) => writer.end(resolve));
-}
-
-/**
- * Builds a minimal-but-valid trace object for TraceQuery tests.
- * Replaces a 155-line inline buildTrace in trace-query.test.js.
- *
- * @param {object} [overrides]
- * @param {object} [overrides.metadata]
- * @param {object[]} [overrides.turns]
- * @param {object} [overrides.summary]
- * @returns {object} Trace object.
- */
-export function createTestTrace(overrides = {}) {
-  const { metadata = {}, turns = [], summary = {} } = overrides;
-  return {
-    schema_version: "1.1",
-    metadata: {
-      session_id: "sess-test",
-      model: "claude-opus-4-7",
-      started_at: "2026-01-01T00:00:00Z",
-      ended_at: "2026-01-01T00:00:05Z",
-      tools: [],
-      ...metadata,
-    },
-    turns,
-    summary: {
-      total_turns: turns.length,
-      total_tokens: 0,
-      tool_calls: 0,
-      errors: 0,
-      ...summary,
-    },
-  };
-}
-
-/**
- * Creates an async-generator agent query stub. The shape of `messages`
- * determines per-call behaviour:
- *  - Flat array of message objects: yielded on every invocation.
- *  - Array of arrays (batches): the Nth invocation yields messages from the
- *    Nth batch. Subsequent calls past the last batch repeat the last one.
- *
- * @param {object[] | object[][]} messages
- * @param {(params: object) => void} [onParams] - Invoked with call params.
- * @returns {Function} Async generator mimicking `query({...})`.
- */
-export function createMockAgentQuery(messages, onParams) {
-  const isBatched = Array.isArray(messages[0]);
-  let callIndex = 0;
-  return async function* mockQuery(params) {
-    if (onParams) onParams(params);
-    if (!isBatched) {
-      for (const msg of messages) yield msg;
-      return;
-    }
-    const batch = messages[callIndex] ?? messages[messages.length - 1] ?? [];
-    callIndex += 1;
-    for (const msg of batch) yield msg;
-  };
-}