autotel-pact 0.2.0

package/src/wrapper-http.ts

@@ -0,0 +1,194 @@
+// HTTP Pact wrapper. Mirrors the Pact-Message wrapper shape but targets
+// PactV3 / PactV4 (HTTP) instances, where the lifecycle is
+// `addInteraction(...)` + `executeTest(fn)` instead of `.verify(handler)`.
+
+import { span as autotelSpan, getActiveSpan } from 'autotel';
+import { buildPactAttributes, outcomeAttribute } from './attrs.js';
+import { appendLedgerEntry, type LedgerOptions } from './ledger.js';
+import {
+  LEDGER_ENTRY_SPEC,
+  type InteractionLedgerEntry,
+  type PactInteractionMeta,
+} from './types.js';
+
+/**
+ * Minimal structural type for a PactV3 / PactV4 HTTP pact instance — we
+ * only call `addInteraction` and `executeTest`. The `opts` property is
+ * private in Pact-JS but readable at runtime, exactly like the message
+ * variant's `config`.
+ */
+export interface HttpPactLike {
+  addInteraction: (interaction: HttpInteraction) => unknown;
+  executeTest: <T>(testFn: (mockServer: HttpMockServer) => Promise<T>) => Promise<T | undefined>;
+}
+
+interface HttpPactWithOpts extends HttpPactLike {
+  opts?: { consumer?: string; provider?: string };
+}
+
+/**
+ * Structural shape of a single HTTP interaction as passed to
+ * `PactV3.addInteraction`. We only read the description and states
+ * directly; the rest is forwarded to Pact untouched.
+ */
+export interface HttpInteraction {
+  uponReceiving: string;
+  states?: Array<{ description: string; parameters?: unknown }>;
+  withRequest?: unknown;
+  willRespondWith?: unknown;
+  [key: string]: unknown;
+}
+
+/** Subset of Pact's `V3MockServer` the test function typically uses. */
+export interface HttpMockServer {
+  url: string;
+  port: number;
+  [key: string]: unknown;
+}
+
+export type HttpPactTestFn<T> = (mockServer: HttpMockServer) => Promise<T>;
+
+export interface WithHttpPactInteractionOptions extends LedgerOptions {
+  contractFile?: string;
+  spanName?: string;
+  consumer?: string;
+  provider?: string;
+  /** See {@link WithPactInteractionOptions.interactionId}. */
+  interactionId?: string;
+}
+
+function resolveHttpParticipants(
+  pact: HttpPactLike,
+  opts: WithHttpPactInteractionOptions,
+): { consumer: string; provider: string } {
+  const fromOpts = (pact as HttpPactWithOpts).opts;
+  const consumer = opts.consumer ?? fromOpts?.consumer;
+  const provider = opts.provider ?? fromOpts?.provider;
+  if (!consumer || !provider) {
+    throw new Error(
+      'autotel-pact: could not resolve consumer/provider from the PactV3 instance. ' +
+        'Pass `{ consumer, provider }` in the options object.',
+    );
+  }
+  return { consumer, provider };
+}
+
+/**
+ * Wrap a Pact-JS HTTP test (PactV3 / PactV4) so that:
+ *   1. The interaction is added to the pact via `addInteraction`.
+ *   2. An autotel span opens around the test body, with `pact.*` attributes.
+ *   3. A ledger entry records that this interaction was exercised.
+ *
+ * Mirrors `withPactInteraction` (the message variant) so the DX is the
+ * same regardless of contract kind.
+ *
+ * @example
+ * ```ts
+ * const provider = new PactV3({ consumer: 'Web', provider: 'Catalog', dir: './pacts' });
+ *
+ * it('gets all products', async () => {
+ *   await withHttpPactInteraction(
+ *     provider,
+ *     {
+ *       states: [{ description: 'products exist' }],
+ *       uponReceiving: 'get all products',
+ *       withRequest: { method: 'GET', path: '/products' },
+ *       willRespondWith: { status: 200, body: [...] },
+ *     },
+ *     async (mockServer) => {
+ *       const api = new API(mockServer.url);
+ *       expect(await api.getAllProducts()).toEqual([...]);
+ *     },
+ *   );
+ * });
+ * ```
+ */
+export async function withHttpPactInteraction<T>(
+  pact: HttpPactLike,
+  interaction: HttpInteraction,
+  testFn: HttpPactTestFn<T>,
+  opts: WithHttpPactInteractionOptions = {},
+): Promise<T | undefined> {
+  // PactV3 interactions have no metadata channel we can write an id into
+  // (V4's `comments` field will let us do this in a future release). Without
+  // a way to land the id on the pact-file side, observed-side and contracted-
+  // side would key on different identities and produce spurious STALE+SHADOW
+  // pairs. Refuse the option until v0.2 wires it through PactV4.
+  if (opts.interactionId !== undefined) {
+    throw new Error(
+      'autotel-pact: `interactionId` is not yet supported for HTTP Pact. ' +
+        'PactV3 interactions have no metadata channel to persist the id; ' +
+        'support arrives in v0.2 via PactV4 comments. Use the description as ' +
+        'the stable identity for HTTP interactions in v0.1.',
+    );
+  }
+
+  const start = process.hrtime.bigint();
+  const spanName = opts.spanName ?? 'pact.interaction';
+  const kind = 'http' as const;
+  const { consumer, provider } = resolveHttpParticipants(pact, opts);
+
+  const meta: PactInteractionMeta = {
+    consumer,
+    provider,
+    description: interaction.uponReceiving,
+    states: (interaction.states ?? []).map((s) => s.description),
+    kind,
+    interactionId: opts.interactionId,
+  };
+
+  pact.addInteraction(interaction);
+
+  return autotelSpan(spanName, async (span) => {
+    span.setAttributes(buildPactAttributes(meta, { contractFile: opts.contractFile }));
+
+    try {
+      const result = await pact.executeTest(testFn);
+      span.setAttributes(outcomeAttribute('passed'));
+      writeHttpLedgerEntry({ meta, outcome: 'passed', start, opts });
+      return result;
+    } catch (error) {
+      span.setAttributes(outcomeAttribute('failed'));
+      writeHttpLedgerEntry({
+        meta,
+        outcome: 'failed',
+        start,
+        opts,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
+    }
+  });
+}
+
+function writeHttpLedgerEntry(args: {
+  meta: PactInteractionMeta;
+  outcome: 'passed' | 'failed';
+  start: bigint;
+  opts: WithHttpPactInteractionOptions;
+  error?: string;
+}): void {
+  const { meta, outcome, start, opts, error } = args;
+  const ctx = getActiveSpan()?.spanContext();
+  const entry: InteractionLedgerEntry = {
+    type: 'interaction',
+    spec: LEDGER_ENTRY_SPEC,
+    consumer: meta.consumer,
+    provider: meta.provider,
+    interaction: meta.description,
+    interaction_id: meta.interactionId,
+    states: meta.states,
+    kind: 'http',
+    source: 'test',
+    role: 'consumer',
+    outcome,
+    duration_ms: Number(process.hrtime.bigint() - start) / 1e6,
+    observed_at: new Date().toISOString(),
+    trace_id: ctx?.traceId,
+    span_id: ctx?.spanId,
+    run_id: process.env.AUTOTEL_PACT_RUN_ID,
+    git_sha: process.env.GIT_SHA ?? process.env.GITHUB_SHA,
+    error,
+  };
+  appendLedgerEntry(entry, opts);
+}

package/src/wrapper-provider.test.ts

@@ -0,0 +1,132 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { readLedger } from './ledger.js';
+import { isInteractionLedgerEntry, isProviderVerificationRun } from './types.js';
+import {
+  withProviderVerification,
+  type VerifierConstructor,
+} from './wrapper-provider.js';
+
+let workDir: string;
+let originalCwd: string;
+
+beforeEach(() => {
+  originalCwd = process.cwd();
+  workDir = mkdtempSync(path.join(tmpdir(), 'autotel-pact-prov-'));
+  process.chdir(workDir);
+});
+
+afterEach(() => {
+  process.chdir(originalCwd);
+  rmSync(workDir, { recursive: true, force: true });
+});
+
+function mockVerifier(outcome: 'pass' | 'fail'): VerifierConstructor {
+  return class {
+    constructor(_opts: unknown) {}
+    verifyProvider() {
+      if (outcome === 'fail') return Promise.reject(new Error('verifier failed'));
+      return Promise.resolve();
+    }
+  };
+}
+
+describe('withProviderVerification', () => {
+  it('appends per-interaction rows on success only', async () => {
+    const pactDir = path.join(workDir, 'pacts');
+    const { mkdirSync, writeFileSync } = await import('node:fs');
+    mkdirSync(pactDir, { recursive: true });
+    writeFileSync(
+      path.join(pactDir, 'A-B.json'),
+      JSON.stringify({
+        consumer: { name: 'A' },
+        provider: { name: 'B' },
+        messages: [{ description: 'evt1' }, { description: 'evt2' }],
+      }),
+    );
+
+    await withProviderVerification(
+      {
+        provider: 'B',
+        providerBaseUrl: 'http://localhost:0',
+        pactUrls: [path.join(pactDir, 'A-B.json')],
+      },
+      { runId: 'prov-ok', Verifier: mockVerifier('pass') },
+    );
+
+    const entries = readLedger({ runId: 'prov-ok' });
+    expect(entries).toHaveLength(2);
+    expect(entries.every(isInteractionLedgerEntry)).toBe(true);
+    expect(entries.every((e) => e.role === 'provider' && e.outcome === 'passed')).toBe(true);
+  });
+
+  it('skipVerifier emits per-interaction rows without loading or calling a Verifier', async () => {
+    const pactDir = path.join(workDir, 'pacts');
+    const { mkdirSync, writeFileSync } = await import('node:fs');
+    mkdirSync(pactDir, { recursive: true });
+    writeFileSync(
+      path.join(pactDir, 'A-B.json'),
+      JSON.stringify({
+        consumer: { name: 'A' },
+        provider: { name: 'B' },
+        messages: [{ description: 'evt1' }, { description: 'evt2' }],
+      }),
+    );
+
+    // No Verifier supplied. Without skipVerifier this would dynamically import
+    // @pact-foundation/pact. With skipVerifier: true, no import happens.
+    const VerifierThatWouldThrow = class {
+      constructor(_opts: unknown) {
+        throw new Error('Verifier should not be instantiated when skipVerifier is true');
+      }
+      verifyProvider() {
+        throw new Error('unreachable');
+      }
+    };
+
+    await withProviderVerification(
+      {
+        provider: 'B',
+        providerBaseUrl: 'http://localhost:0',
+        pactUrls: [path.join(pactDir, 'A-B.json')],
+      },
+      { runId: 'prov-skip', skipVerifier: true, Verifier: VerifierThatWouldThrow },
+    );
+
+    const entries = readLedger({ runId: 'prov-skip' });
+    expect(entries).toHaveLength(2);
+    expect(entries.every(isInteractionLedgerEntry)).toBe(true);
+    expect(entries.every((e) => e.role === 'provider' && e.outcome === 'passed')).toBe(true);
+  });
+
+  it('appends run-level failure without interaction rows', async () => {
+    const pactDir = path.join(workDir, 'pacts');
+    const { mkdirSync, writeFileSync } = await import('node:fs');
+    mkdirSync(pactDir, { recursive: true });
+    writeFileSync(
+      path.join(pactDir, 'A-B.json'),
+      JSON.stringify({
+        consumer: { name: 'A' },
+        provider: { name: 'B' },
+        messages: [{ description: 'evt' }],
+      }),
+    );
+
+    await expect(
+      withProviderVerification(
+        {
+          provider: 'B',
+          providerBaseUrl: 'http://localhost:0',
+          pactUrls: [path.join(pactDir, 'A-B.json')],
+        },
+        { runId: 'prov-fail', Verifier: mockVerifier('fail') },
+      ),
+    ).rejects.toThrow(/verifier failed/);
+
+    const entries = readLedger({ runId: 'prov-fail' });
+    expect(entries).toHaveLength(1);
+    expect(isProviderVerificationRun(entries[0]!)).toBe(true);
+  });
+});

package/src/wrapper-provider.ts

@@ -0,0 +1,163 @@
+import path from 'node:path';
+import { span as autotelSpan, getActiveSpan } from 'autotel';
+import { appendLedgerEntry, appendProviderVerificationFailure, type LedgerOptions } from './ledger.js';
+import { interactionsFromPactFile, parsePactFile } from './pact-file.js';
+import { LEDGER_ENTRY_SPEC, type InteractionLedgerEntry, type PactKind } from './types.js';
+import { PACT_ATTRS } from './attrs.js';
+
+/**
+ * Minimal Verifier options — structural match for @pact-foundation/pact Verifier.
+ */
+export interface VerifierOptionsLike {
+  provider: string;
+  providerBaseUrl: string;
+  pactUrls?: string[];
+  logLevel?: string;
+  [key: string]: unknown;
+}
+
+export interface VerifierLike {
+  verifyProvider: () => Promise<unknown>;
+}
+
+export interface VerifierConstructor {
+  new (options: VerifierOptionsLike): VerifierLike;
+}
+
+export interface WithProviderVerificationOptions extends LedgerOptions {
+  /** Consumer name when not inferrable from pact files. */
+  consumer?: string;
+  spanName?: string;
+  /** Custom Verifier class (defaults to dynamic import from @pact-foundation/pact). */
+  Verifier?: VerifierConstructor;
+  /**
+   * Skip loading and calling the Verifier entirely. Emits the same
+   * per-interaction ledger rows as a successful verification, parsed from the
+   * supplied pact files. Use for demos, smoke tests, and audit-pipeline
+   * exercises where running a real provider is impractical. Do not use in
+   * production CI: it will mark every interaction in the pact file as
+   * provider-verified without any actual verification.
+   */
+  skipVerifier?: boolean;
+}
+
+function resolvePactPaths(opts: VerifierOptionsLike): string[] {
+  const urls = opts.pactUrls ?? [];
+  return urls.map((u) => path.resolve(process.cwd(), u));
+}
+
+function inferConsumerFromPacts(pactPaths: string[], fallback?: string): string {
+  for (const filePath of pactPaths) {
+    const pact = parsePactFile(filePath);
+    if (pact?.consumer?.name) return pact.consumer.name;
+  }
+  if (fallback) return fallback;
+  throw new Error(
+    'autotel-pact: could not infer consumer from pact files. Pass `consumer` in options.',
+  );
+}
+
+function kindForPactFile(filePath: string): PactKind {
+  const pact = parsePactFile(filePath);
+  if (!pact) return 'message';
+  if ((pact.interactions?.length ?? 0) > 0) return 'http';
+  return 'message';
+}
+
+async function loadVerifier(
+  VerifierClass?: VerifierConstructor,
+): Promise<VerifierConstructor> {
+  if (VerifierClass) return VerifierClass;
+  const mod = await import('@pact-foundation/pact');
+  const Verifier = (mod as { Verifier?: VerifierConstructor }).Verifier;
+  if (!Verifier) {
+    throw new Error(
+      'autotel-pact: @pact-foundation/pact Verifier not found. Install the peer dependency.',
+    );
+  }
+  return Verifier;
+}
+
+/**
+ * Wrap provider verification — records per-interaction evidence only on success.
+ */
+export async function withProviderVerification(
+  verifierOpts: VerifierOptionsLike,
+  wrapOpts: WithProviderVerificationOptions = {},
+): Promise<void> {
+  const pactPaths = resolvePactPaths(verifierOpts);
+  const provider = verifierOpts.provider;
+  const consumer = inferConsumerFromPacts(pactPaths, wrapOpts.consumer);
+  const spanName = wrapOpts.spanName ?? 'pact.verification';
+  const start = process.hrtime.bigint();
+  const Verifier = wrapOpts.skipVerifier ? undefined : await loadVerifier(wrapOpts.Verifier);
+
+  return autotelSpan(spanName, async () => {
+    const span = getActiveSpan();
+    span?.setAttributes({
+      [PACT_ATTRS.CONSUMER]: consumer,
+      [PACT_ATTRS.PROVIDER]: provider,
+      [PACT_ATTRS.KIND]: pactPaths.length === 1 ? kindForPactFile(pactPaths[0]!) : 'message',
+      'pact.role': 'provider',
+    });
+
+    try {
+      if (Verifier) {
+        await new Verifier(verifierOpts).verifyProvider();
+      }
+      span?.setAttributes({ [PACT_ATTRS.OUTCOME]: 'passed' });
+
+      const ctx = span?.spanContext();
+      const base = {
+        source: 'test' as const,
+        role: 'provider' as const,
+        outcome: 'passed' as const,
+        observed_at: new Date().toISOString(),
+        trace_id: ctx?.traceId,
+        span_id: ctx?.spanId,
+        run_id: process.env.AUTOTEL_PACT_RUN_ID,
+        git_sha: process.env.GIT_SHA ?? process.env.GITHUB_SHA,
+      };
+
+      for (const filePath of pactPaths) {
+        const pact = parsePactFile(filePath);
+        if (!pact) continue;
+        const interactions = interactionsFromPactFile(pact);
+        for (const i of interactions) {
+          const entry: InteractionLedgerEntry = {
+            type: 'interaction',
+            spec: LEDGER_ENTRY_SPEC,
+            consumer: i.consumer,
+            provider: i.provider,
+            interaction: i.interaction,
+            interaction_id: i.interactionId,
+            states: [],
+            kind: i.kind,
+            duration_ms: Number(process.hrtime.bigint() - start) / 1e6,
+            ...base,
+          };
+          appendLedgerEntry(entry, wrapOpts);
+        }
+      }
+    } catch (error) {
+      span?.setAttributes({ [PACT_ATTRS.OUTCOME]: 'failed' });
+      const message = error instanceof Error ? error.message : String(error);
+      const ctx = span?.spanContext();
+      appendProviderVerificationFailure(
+        {
+          consumer,
+          provider,
+          source: 'test',
+          observed_at: new Date().toISOString(),
+          error: message,
+          trace_id: ctx?.traceId,
+          span_id: ctx?.spanId,
+          run_id: process.env.AUTOTEL_PACT_RUN_ID,
+          git_sha: process.env.GIT_SHA ?? process.env.GITHUB_SHA,
+        },
+        wrapOpts,
+      );
+      throw error;
+    }
+  });
+}

package/src/wrapper.test.ts

@@ -0,0 +1,176 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { readLedger } from './ledger.js';
+import { withPactInteraction, type MessageConsumerPactLike, type ReifiedMessage } from './wrapper.js';
+
+class FakeMessagePact implements MessageConsumerPactLike {
+  config = { consumer: 'OrderShipper', provider: 'OrderService' };
+  recordedMetadata: Record<string, unknown> = {};
+
+  constructor(
+    private message: ReifiedMessage,
+    private shouldFailHandler = false,
+  ) {}
+
+  withMetadata(metadata: Record<string, unknown>): this {
+    Object.assign(this.recordedMetadata, metadata);
+    return this;
+  }
+
+  async verify(handler: (msg: ReifiedMessage) => unknown): Promise<unknown> {
+    if (this.shouldFailHandler) {
+      throw new Error('handler rejected message');
+    }
+    return handler(this.message);
+  }
+}
+
+let workDir: string;
+let originalCwd: string;
+
+beforeEach(() => {
+  originalCwd = process.cwd();
+  workDir = mkdtempSync(path.join(tmpdir(), 'autotel-pact-wrap-'));
+  process.chdir(workDir);
+});
+
+afterEach(() => {
+  process.chdir(originalCwd);
+  rmSync(workDir, { recursive: true, force: true });
+  delete process.env.AUTOTEL_PACT_RUN_ID;
+});
+
+const sampleMessage: ReifiedMessage = {
+  contents: { orderId: 'ord-123' },
+  description: 'an OrderCreated event',
+  providerStates: [{ name: 'an order exists' }],
+  metadata: { 'content-type': 'application/json' },
+};
+
+describe('withPactInteraction', () => {
+  it('runs the handler and writes a passed ledger entry', async () => {
+    const pact = new FakeMessagePact(sampleMessage);
+    const result = await withPactInteraction(
+      pact,
+      (msg) => ({ processed: (msg.contents as { orderId: string }).orderId }),
+      { runId: 'r-pass' },
+    );
+
+    expect(result).toEqual({ processed: 'ord-123' });
+
+    const entries = readLedger({ runId: 'r-pass' });
+    expect(entries).toHaveLength(1);
+    expect(entries[0]).toMatchObject({
+      consumer: 'OrderShipper',
+      provider: 'OrderService',
+      interaction: 'an OrderCreated event',
+      states: ['an order exists'],
+      kind: 'message',
+      outcome: 'passed',
+    });
+    expect(entries[0]!.duration_ms).toBeGreaterThanOrEqual(0);
+    expect(entries[0]!.observed_at).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+  });
+
+  it('writes a failed ledger entry when the handler throws', async () => {
+    const pact = new FakeMessagePact(sampleMessage);
+    await expect(
+      withPactInteraction(
+        pact,
+        () => {
+          throw new Error('boom');
+        },
+        { runId: 'r-fail' },
+      ),
+    ).rejects.toThrow('boom');
+
+    const entries = readLedger({ runId: 'r-fail' });
+    expect(entries).toHaveLength(1);
+    expect(entries[0]).toMatchObject({ outcome: 'failed', error: 'boom' });
+  });
+
+  it('writes a failed ledger entry when pact.verify itself rejects', async () => {
+    const pact = new FakeMessagePact(sampleMessage, true);
+    await expect(
+      withPactInteraction(pact, () => {}, { runId: 'r-verify-fail' }),
+    ).rejects.toThrow('handler rejected message');
+
+    const entries = readLedger({ runId: 'r-verify-fail' });
+    expect(entries).toHaveLength(1);
+    expect(entries[0]!.outcome).toBe('failed');
+  });
+
+  it('persists interactionId on the ledger entry when supplied', async () => {
+    const pact = new FakeMessagePact(sampleMessage);
+    await withPactInteraction(pact, () => 'ok', {
+      runId: 'r-iid',
+      interactionId: 'order.created.v1',
+    });
+
+    const entries = readLedger({ runId: 'r-iid' });
+    expect(entries[0]!.interaction_id).toBe('order.created.v1');
+  });
+
+  it('writes interactionId into the pact message metadata so the audit can match both sides', async () => {
+    const pact = new FakeMessagePact(sampleMessage);
+    await withPactInteraction(pact, () => 'ok', {
+      runId: 'r-iid-meta',
+      interactionId: 'order.created.v1',
+    });
+
+    // The metadata makes its way into the pact file via Pact-JS's
+    // `withMetadata` API. The audit's `extractInteractionId` then reads it
+    // back on the contracted side, so the row collapses with the ledger
+    // (interaction_id-keyed) row instead of fragmenting.
+    expect(pact.recordedMetadata.interactionId).toBe('order.created.v1');
+  });
+
+  it('does not touch withMetadata when interactionId is not supplied', async () => {
+    const pact = new FakeMessagePact(sampleMessage);
+    await withPactInteraction(pact, () => 'ok', { runId: 'r-no-iid' });
+    expect(pact.recordedMetadata).toEqual({});
+  });
+
+  it('throws a helpful error when consumer/provider cannot be resolved', async () => {
+    // Pact-like with no config and no override — wrapper should refuse cleanly.
+    const bare: MessageConsumerPactLike = {
+      async verify(handler) {
+        return handler(sampleMessage);
+      },
+    };
+    await expect(
+      withPactInteraction(bare, () => {}, { runId: 'r-no-cfg' }),
+    ).rejects.toThrow(/could not resolve consumer\/provider/);
+  });
+
+  it('uses opts.consumer/provider fallbacks when the pact lacks config', async () => {
+    const bare: MessageConsumerPactLike = {
+      async verify(handler) {
+        return handler(sampleMessage);
+      },
+    };
+    await withPactInteraction(bare, () => {}, {
+      runId: 'r-fallback',
+      consumer: 'OverrideConsumer',
+      provider: 'OverrideProvider',
+    });
+
+    const entries = readLedger({ runId: 'r-fallback' });
+    expect(entries[0]).toMatchObject({
+      consumer: 'OverrideConsumer',
+      provider: 'OverrideProvider',
+    });
+  });
+
+  it('records one ledger entry per interaction when the same pact instance is reused', async () => {
+    const pact = new FakeMessagePact(sampleMessage);
+    await withPactInteraction(pact, () => 'a', { runId: 'r-reuse' });
+    await withPactInteraction(pact, () => 'b', { runId: 'r-reuse' });
+
+    const entries = readLedger({ runId: 'r-reuse' });
+    expect(entries).toHaveLength(2);
+    expect(entries.every((e) => e.outcome === 'passed')).toBe(true);
+  });
+});