autotel-pact 0.2.0

package/dist/index.cjs

@@ -0,0 +1,967 @@
+'use strict';
+
+var autotel = require('autotel');
+var fs = require('fs');
+var promises = require('fs/promises');
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+// src/wrapper.ts
+
+// src/attrs.ts
+var PACT_ATTRS = {
+  CONSUMER: "pact.consumer",
+  PROVIDER: "pact.provider",
+  KIND: "pact.kind",
+  INTERACTION_DESCRIPTION: "pact.interaction.description",
+  INTERACTION_ID: "pact.interaction.id",
+  INTERACTION_STATES: "pact.interaction.states",
+  CONTRACT_FILE: "pact.contract.file",
+  OUTCOME: "pact.outcome"
+};
+function buildPactAttributes(meta, opts = {}) {
+  const attrs = {
+    [PACT_ATTRS.CONSUMER]: meta.consumer,
+    [PACT_ATTRS.PROVIDER]: meta.provider,
+    [PACT_ATTRS.KIND]: meta.kind,
+    [PACT_ATTRS.INTERACTION_DESCRIPTION]: meta.description,
+    [PACT_ATTRS.INTERACTION_STATES]: meta.states
+  };
+  if (opts.contractFile) {
+    attrs[PACT_ATTRS.CONTRACT_FILE] = opts.contractFile;
+  }
+  if (meta.interactionId) {
+    attrs[PACT_ATTRS.INTERACTION_ID] = meta.interactionId;
+  }
+  return attrs;
+}
+function outcomeAttribute(outcome) {
+  return { [PACT_ATTRS.OUTCOME]: outcome };
+}
+
+// src/types.ts
+var LEDGER_ENTRY_SPEC = "autotel-pact-ledger-entry/v0.2.0";
+var AUDIT_MATRIX_SPEC = "autotel-pact-audit-matrix/v0.2.0";
+function isInteractionLedgerEntry(entry) {
+  return entry.type !== "provider_verification_run";
+}
+function isProviderVerificationRun(entry) {
+  return entry.type === "provider_verification_run";
+}
+
+// src/ledger-normalize.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function normalizeLedgerRecord(parsed) {
+  if (!isRecord(parsed) || parsed.spec !== LEDGER_ENTRY_SPEC) return null;
+  const { consumer, provider, observed_at } = parsed;
+  if (typeof consumer !== "string" || typeof provider !== "string" || typeof observed_at !== "string") {
+    return null;
+  }
+  if (parsed.type === "provider_verification_run") {
+    if (typeof parsed.error !== "string") return null;
+    const entry2 = {
+      type: "provider_verification_run",
+      spec: LEDGER_ENTRY_SPEC,
+      consumer,
+      provider,
+      outcome: "failed",
+      source: parsed.source === "production" ? "production" : "test",
+      role: "provider",
+      observed_at,
+      error: parsed.error
+    };
+    if (typeof parsed.run_id === "string") entry2.run_id = parsed.run_id;
+    if (typeof parsed.git_sha === "string") entry2.git_sha = parsed.git_sha;
+    if (typeof parsed.trace_id === "string") entry2.trace_id = parsed.trace_id;
+    if (typeof parsed.span_id === "string") entry2.span_id = parsed.span_id;
+    return entry2;
+  }
+  if (typeof parsed.interaction !== "string") return null;
+  const states = Array.isArray(parsed.states) ? parsed.states.filter((s) => typeof s === "string") : [];
+  const entry = {
+    type: "interaction",
+    spec: LEDGER_ENTRY_SPEC,
+    consumer,
+    provider,
+    interaction: parsed.interaction,
+    states,
+    kind: parsed.kind === "http" ? "http" : "message",
+    outcome: parsed.outcome === "failed" ? "failed" : "passed",
+    source: parsed.source === "production" ? "production" : "test",
+    role: parsed.role === "provider" ? "provider" : "consumer",
+    duration_ms: typeof parsed.duration_ms === "number" && parsed.duration_ms >= 0 ? parsed.duration_ms : 0,
+    observed_at
+  };
+  if (typeof parsed.interaction_id === "string" && parsed.interaction_id.length > 0) {
+    entry.interaction_id = parsed.interaction_id;
+  }
+  if (typeof parsed.trace_id === "string") entry.trace_id = parsed.trace_id;
+  if (typeof parsed.span_id === "string") entry.span_id = parsed.span_id;
+  if (typeof parsed.run_id === "string") entry.run_id = parsed.run_id;
+  if (typeof parsed.git_sha === "string") entry.git_sha = parsed.git_sha;
+  if (typeof parsed.error === "string") entry.error = parsed.error;
+  return entry;
+}
+
+// src/ledger.ts
+var DEFAULT_DIR = ".autotel-pact";
+function resolveLedgerDir(opts = {}) {
+  return path__default.default.resolve(process.cwd(), opts.dir ?? process.env.AUTOTEL_PACT_LEDGER_DIR ?? DEFAULT_DIR);
+}
+function resolveRunId(opts = {}) {
+  const explicit = opts.runId ?? process.env.AUTOTEL_PACT_RUN_ID;
+  if (explicit) return explicit;
+  return `local-${(/* @__PURE__ */ new Date()).toISOString().replaceAll(/[:.]/g, "-")}`;
+}
+function ledgerPath(opts = {}) {
+  const dir = resolveLedgerDir(opts);
+  return path__default.default.join(dir, `ledger-${resolveRunId(opts)}.jsonl`);
+}
+function writeLine(filePath, entry) {
+  fs.mkdirSync(path__default.default.dirname(filePath), { recursive: true });
+  fs.appendFileSync(filePath, JSON.stringify(entry) + "\n", "utf8");
+}
+function appendLedgerEntry(entry, opts = {}) {
+  const filePath = ledgerPath(opts);
+  const normalized = entry.type === "provider_verification_run" ? entry : { ...entry, spec: LEDGER_ENTRY_SPEC, type: "interaction" };
+  writeLine(filePath, normalized);
+}
+function appendProviderVerificationFailure(entry, opts = {}) {
+  appendLedgerEntry(
+    {
+      type: "provider_verification_run",
+      spec: LEDGER_ENTRY_SPEC,
+      outcome: "failed",
+      role: "provider",
+      source: entry.source ?? "test",
+      consumer: entry.consumer,
+      provider: entry.provider,
+      observed_at: entry.observed_at,
+      error: entry.error,
+      run_id: entry.run_id,
+      git_sha: entry.git_sha,
+      trace_id: entry.trace_id,
+      span_id: entry.span_id
+    },
+    opts
+  );
+}
+function readLedger(opts = {}) {
+  const dir = resolveLedgerDir(opts);
+  if (!fs.existsSync(dir)) return [];
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+  const entries = [];
+  for (const file of files) {
+    const text = fs.readFileSync(path__default.default.join(dir, file), "utf8");
+    for (const line of text.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const normalized = normalizeLedgerRecord(JSON.parse(line));
+        if (normalized) entries.push(normalized);
+      } catch {
+      }
+    }
+  }
+  return entries;
+}
+var MAX_PENDING_WRITES = 4096;
+var asyncWriteChain = Promise.resolve();
+var pendingWrites = 0;
+async function appendLedgerEntryAsync(entry, opts = {}) {
+  if (pendingWrites >= MAX_PENDING_WRITES) {
+    await asyncWriteChain;
+  }
+  const filePath = ledgerPath(opts);
+  const normalized = entry.type === "provider_verification_run" ? entry : { ...entry, spec: LEDGER_ENTRY_SPEC, type: "interaction" };
+  const line = JSON.stringify(normalized);
+  pendingWrites++;
+  const run = asyncWriteChain.then(async () => {
+    try {
+      await promises.mkdir(path__default.default.dirname(filePath), { recursive: true });
+      await promises.appendFile(filePath, line + "\n", "utf8");
+    } finally {
+      pendingWrites--;
+    }
+  });
+  asyncWriteChain = run.catch(() => {
+  });
+  return run;
+}
+async function flushLedgerWrites() {
+  await asyncWriteChain;
+}
+
+// src/wrapper.ts
+function resolveParticipants(pact, opts) {
+  const cfg = pact.config;
+  const consumer = opts.consumer ?? cfg?.consumer;
+  const provider = opts.provider ?? cfg?.provider;
+  if (!consumer || !provider) {
+    throw new Error(
+      "autotel-pact: could not resolve consumer/provider from the Pact instance. Pass `{ consumer, provider }` in the options object."
+    );
+  }
+  return { consumer, provider };
+}
+async function withPactInteraction(pact, handler, opts = {}) {
+  const start = process.hrtime.bigint();
+  const spanName = opts.spanName ?? "pact.interaction";
+  const kind = "message";
+  const { consumer, provider } = resolveParticipants(pact, opts);
+  if (opts.interactionId && typeof pact.withMetadata === "function") {
+    pact.withMetadata({ interactionId: opts.interactionId });
+  }
+  let captured;
+  let handlerResult;
+  return autotel.span(spanName, async (span) => {
+    span.setAttributes({
+      "pact.consumer": consumer,
+      "pact.provider": provider,
+      "pact.kind": kind
+    });
+    try {
+      await pact.verify(async (reified) => {
+        captured = reified;
+        const meta = {
+          consumer,
+          provider,
+          description: reified.description ?? "<unknown>",
+          states: (reified.providerStates ?? []).map((s) => s.name),
+          kind,
+          interactionId: opts.interactionId
+        };
+        span.setAttributes(buildPactAttributes(meta, { contractFile: opts.contractFile }));
+        handlerResult = await handler(reified);
+        return handlerResult;
+      });
+      span.setAttributes(outcomeAttribute("passed"));
+      writeLedgerForOutcome({
+        consumer,
+        provider,
+        captured,
+        kind,
+        outcome: "passed",
+        start,
+        opts
+      });
+      return handlerResult;
+    } catch (error) {
+      span.setAttributes(outcomeAttribute("failed"));
+      writeLedgerForOutcome({
+        consumer,
+        provider,
+        captured,
+        kind,
+        outcome: "failed",
+        start,
+        opts,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  });
+}
+function writeLedgerForOutcome(args) {
+  const { consumer, provider, captured, kind, outcome, start, opts, error } = args;
+  const ctx = autotel.getActiveSpan()?.spanContext();
+  const entry = {
+    type: "interaction",
+    spec: LEDGER_ENTRY_SPEC,
+    consumer,
+    provider,
+    interaction: captured?.description ?? "<unknown>",
+    interaction_id: opts.interactionId,
+    states: (captured?.providerStates ?? []).map((s) => s.name),
+    kind,
+    source: "test",
+    role: "consumer",
+    outcome,
+    duration_ms: Number(process.hrtime.bigint() - start) / 1e6,
+    observed_at: (/* @__PURE__ */ 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);
+}
+function resolveHttpParticipants(pact, opts) {
+  const fromOpts = pact.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 };
+}
+async function withHttpPactInteraction(pact, interaction, testFn, opts = {}) {
+  if (opts.interactionId !== void 0) {
+    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";
+  const { consumer, provider } = resolveHttpParticipants(pact, opts);
+  const meta = {
+    consumer,
+    provider,
+    description: interaction.uponReceiving,
+    states: (interaction.states ?? []).map((s) => s.description),
+    kind,
+    interactionId: opts.interactionId
+  };
+  pact.addInteraction(interaction);
+  return autotel.span(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) {
+  const { meta, outcome, start, opts, error } = args;
+  const ctx = autotel.getActiveSpan()?.spanContext();
+  const entry = {
+    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: (/* @__PURE__ */ 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);
+}
+function listPactFiles(dir) {
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return [];
+  const out = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path__default.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...listPactFiles(full));
+    } else if (entry.isFile() && entry.name.endsWith(".json")) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+function extractInteractionId(metadata) {
+  if (!metadata) return void 0;
+  const id = metadata.interactionId ?? metadata.interaction_id;
+  return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+function interactionsFromPactFile(pact) {
+  const consumer = pact.consumer?.name;
+  const provider = pact.provider?.name;
+  if (!consumer || !provider) return [];
+  const keys = [];
+  for (const m of pact.messages ?? []) {
+    keys.push({
+      consumer,
+      provider,
+      interaction: m.description,
+      kind: "message",
+      interactionId: extractInteractionId(m.metadata)
+    });
+  }
+  for (const i of pact.interactions ?? []) {
+    keys.push({
+      consumer,
+      provider,
+      interaction: i.description,
+      kind: "http",
+      interactionId: extractInteractionId(i.metadata)
+    });
+  }
+  return keys;
+}
+function parsePactFile(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// src/wrapper-provider.ts
+function resolvePactPaths(opts) {
+  const urls = opts.pactUrls ?? [];
+  return urls.map((u) => path__default.default.resolve(process.cwd(), u));
+}
+function inferConsumerFromPacts(pactPaths, fallback) {
+  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) {
+  const pact = parsePactFile(filePath);
+  if (!pact) return "message";
+  if ((pact.interactions?.length ?? 0) > 0) return "http";
+  return "message";
+}
+async function loadVerifier(VerifierClass) {
+  if (VerifierClass) return VerifierClass;
+  const mod = await import('@pact-foundation/pact');
+  const Verifier = mod.Verifier;
+  if (!Verifier) {
+    throw new Error(
+      "autotel-pact: @pact-foundation/pact Verifier not found. Install the peer dependency."
+    );
+  }
+  return Verifier;
+}
+async function withProviderVerification(verifierOpts, wrapOpts = {}) {
+  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 ? void 0 : await loadVerifier(wrapOpts.Verifier);
+  return autotel.span(spanName, async () => {
+    const span = autotel.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",
+        role: "provider",
+        outcome: "passed",
+        observed_at: (/* @__PURE__ */ 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 = {
+            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: (/* @__PURE__ */ 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;
+    }
+  });
+}
+function tagPactInteraction(meta) {
+  const span = autotel.getActiveSpan();
+  if (!span) {
+    throw new Error(
+      "autotel-pact: tagPactInteraction requires an active span. Wrap the handler with trace() first."
+    );
+  }
+  const attrs = buildPactAttributes(meta);
+  span.setAttributes(attrs);
+  if (meta.interactionId) {
+    span.setAttribute(PACT_ATTRS.INTERACTION_ID, meta.interactionId);
+  }
+}
+
+// src/processor.ts
+var DEFAULT_MAX_QUEUE = 1024;
+var WARN_INTERVAL_MS = 6e4;
+function attrString(attrs, key) {
+  const v = attrs[key];
+  if (typeof v === "string" && v.length > 0) return v;
+  return void 0;
+}
+function attrStates(attrs) {
+  const v = attrs[PACT_ATTRS.INTERACTION_STATES];
+  if (Array.isArray(v)) {
+    return v.filter((s) => typeof s === "string");
+  }
+  return [];
+}
+function ledgerEntryFromSpan(span) {
+  const attrs = span.attributes;
+  const consumer = attrString(attrs, PACT_ATTRS.CONSUMER);
+  const provider = attrString(attrs, PACT_ATTRS.PROVIDER);
+  const description = attrString(attrs, PACT_ATTRS.INTERACTION_DESCRIPTION);
+  const interactionId = attrString(attrs, PACT_ATTRS.INTERACTION_ID);
+  if (!consumer || !provider || !description && !interactionId) {
+    return null;
+  }
+  const kindRaw = attrString(attrs, PACT_ATTRS.KIND);
+  const kind = kindRaw === "http" ? "http" : "message";
+  const ctx = span.spanContext();
+  const errored = span.status?.code === 2;
+  const entry = {
+    type: "interaction",
+    spec: LEDGER_ENTRY_SPEC,
+    consumer,
+    provider,
+    interaction: description ?? interactionId,
+    interaction_id: interactionId,
+    states: attrStates(attrs),
+    kind,
+    outcome: errored ? "failed" : "passed",
+    source: "production",
+    role: "consumer",
+    duration_ms: 0,
+    observed_at: (/* @__PURE__ */ 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
+  };
+  if (errored && span.status?.message) {
+    entry.error = span.status.message;
+  }
+  return entry;
+}
+var PactLedgerSpanProcessor = class {
+  opts;
+  maxQueue;
+  pending = [];
+  flushing = false;
+  drops = 0;
+  lastWarnAt = 0;
+  constructor(opts = {}) {
+    this.opts = opts;
+    this.maxQueue = opts.maxQueueSize ?? DEFAULT_MAX_QUEUE;
+  }
+  onStart(_span, _parentContext) {
+  }
+  onEnd(span) {
+    try {
+      const entry = ledgerEntryFromSpan(span);
+      if (!entry) return;
+      if (this.pending.length >= this.maxQueue) {
+        this.pending.shift();
+        this.drops++;
+        this.opts.onDrop?.("queue_full");
+        this.maybeWarn(
+          `autotel-pact: dropped oldest queued ledger entry (queue full, max ${this.maxQueue}). ${this.drops} total drops.`
+        );
+      }
+      this.pending.push({ entry, opts: this.opts });
+      queueMicrotask(() => {
+        void this.flush();
+      });
+    } catch (error) {
+      this.opts.onWriteError?.(error);
+    }
+  }
+  maybeWarn(message) {
+    const now = Date.now();
+    if (now - this.lastWarnAt < WARN_INTERVAL_MS) return;
+    this.lastWarnAt = now;
+    if (this.opts.onWarn) {
+      this.opts.onWarn(message);
+    } else {
+      console.warn(message);
+    }
+  }
+  async flush() {
+    if (this.flushing) return;
+    this.flushing = true;
+    try {
+      while (this.pending.length > 0) {
+        const item = this.pending.shift();
+        try {
+          await appendLedgerEntryAsync(item.entry, item.opts);
+        } catch (error) {
+          this.opts.onWriteError?.(error);
+          this.maybeWarn(
+            `autotel-pact: ledger write failed (fail-open): ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    } finally {
+      this.flushing = false;
+      if (this.pending.length > 0) {
+        queueMicrotask(() => {
+          void this.flush();
+        });
+      }
+    }
+  }
+  async forceFlush() {
+    await this.flush();
+    await flushLedgerWrites();
+  }
+  async shutdown() {
+    await this.forceFlush();
+  }
+};
+function createPactLedgerProcessor(opts = {}) {
+  return new PactLedgerSpanProcessor(opts);
+}
+
+// src/broker.ts
+function authHeaders(config) {
+  const headers = {
+    Accept: "application/json"
+  };
+  if (config.token) {
+    headers.Authorization = `Bearer ${config.token}`;
+  } else if (config.username && config.password) {
+    const encoded = Buffer.from(`${config.username}:${config.password}`).toString("base64");
+    headers.Authorization = `Basic ${encoded}`;
+  }
+  return headers;
+}
+function trimBaseUrl(url) {
+  return url.replace(/\/$/, "");
+}
+function parseBrokerVerificationResult(consumer, provider, json) {
+  if (!json || typeof json !== "object") return null;
+  const body = json;
+  const success = body.success === true || body.success === void 0 && body.result === "success";
+  const verifiedAt = typeof body.verifiedAt === "string" ? body.verifiedAt : typeof body.verified_at === "string" ? body.verified_at : typeof body.createdAt === "string" ? body.createdAt : void 0;
+  return {
+    consumer,
+    provider,
+    success: !!success,
+    verifiedAt
+  };
+}
+async function fetchBrokerVerifications(config, pairs) {
+  const base = trimBaseUrl(config.baseUrl);
+  const headers = authHeaders(config);
+  const results = [];
+  for (const { consumer, provider } of pairs) {
+    const url = `${base}/pacts/provider/${encodeURIComponent(provider)}/consumer/${encodeURIComponent(consumer)}/latest/verification-results`;
+    try {
+      const res = await fetch(url, { headers });
+      if (!res.ok) {
+        results.push({
+          consumer,
+          provider,
+          success: false,
+          error: `HTTP ${res.status} ${res.statusText}`.trim()
+        });
+        continue;
+      }
+      const json = await res.json();
+      const parsed = parseBrokerVerificationResult(consumer, provider, json);
+      results.push(
+        parsed ?? {
+          consumer,
+          provider,
+          success: false,
+          error: "Unparseable broker response"
+        }
+      );
+    } catch (error) {
+      results.push({
+        consumer,
+        provider,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return results;
+}
+function brokerConfigFromEnv() {
+  const baseUrl = process.env.PACT_BROKER_BASE_URL;
+  if (!baseUrl) return void 0;
+  return {
+    baseUrl,
+    token: process.env.PACT_BROKER_TOKEN,
+    username: process.env.PACT_BROKER_USERNAME,
+    password: process.env.PACT_BROKER_PASSWORD
+  };
+}
+
+// src/audit.ts
+var DEFAULT_PACTS_DIR = "./pacts";
+var DEFAULT_WINDOW_DAYS = 14;
+function keyOf(k) {
+  const identity = k.interactionId ?? k.interaction;
+  return `${k.consumer}::${k.provider}::${k.kind}::${identity}`;
+}
+function pairKey(consumer, provider) {
+  return `${consumer}::${provider}`;
+}
+function inWindow(observedAt, cutoff) {
+  const t = Date.parse(observedAt);
+  return Number.isFinite(t) && t >= cutoff;
+}
+function computeAuditMatrix(input) {
+  const windowDays = input.windowDays ?? DEFAULT_WINDOW_DAYS;
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const cutoff = now.getTime() - windowDays * 24 * 60 * 60 * 1e3;
+  const verificationFailures = [];
+  const recentInteractions = [];
+  for (const entry of input.ledger) {
+    if (!inWindow(entry.observed_at, cutoff)) continue;
+    if (isProviderVerificationRun(entry)) {
+      verificationFailures.push(entry);
+      continue;
+    }
+    if (isInteractionLedgerEntry(entry)) {
+      recentInteractions.push(entry);
+    }
+  }
+  const brokerByPair = /* @__PURE__ */ new Map();
+  for (const b of input.brokerVerifications ?? []) {
+    brokerByPair.set(pairKey(b.consumer, b.provider), b);
+  }
+  const testSeenByKey = /* @__PURE__ */ new Map();
+  const prodSeenByKey = /* @__PURE__ */ new Map();
+  const providerVerifiedByKey = /* @__PURE__ */ new Map();
+  const anyObservedByKey = /* @__PURE__ */ new Map();
+  for (const entry of recentInteractions) {
+    const k = keyOf({
+      consumer: entry.consumer,
+      provider: entry.provider,
+      interaction: entry.interaction,
+      kind: entry.kind,
+      interactionId: entry.interaction_id
+    });
+    const push = (map) => {
+      const arr = map.get(k) ?? [];
+      arr.push(entry);
+      map.set(k, arr);
+    };
+    push(anyObservedByKey);
+    if (entry.source === "test" && entry.role === "consumer") {
+      push(testSeenByKey);
+    }
+    if (entry.source === "production") {
+      push(prodSeenByKey);
+    }
+    if (entry.role === "provider" && entry.outcome === "passed") {
+      push(providerVerifiedByKey);
+    }
+  }
+  const contractedByKey = /* @__PURE__ */ new Map();
+  for (const c of input.contracted) {
+    contractedByKey.set(keyOf(c), c);
+  }
+  const rows = [];
+  function pushRow(parts, k, isContracted) {
+    const testObs = testSeenByKey.get(k) ?? [];
+    const prodObs = prodSeenByKey.get(k) ?? [];
+    const providerObs = providerVerifiedByKey.get(k) ?? [];
+    const allObs = anyObservedByKey.get(k) ?? [];
+    const latest = allObs.toSorted(
+      (a, b) => b.observed_at.localeCompare(a.observed_at)
+    )[0];
+    const broker = brokerByPair.get(pairKey(parts.consumer, parts.provider));
+    rows.push({
+      consumer: parts.consumer,
+      provider: parts.provider,
+      interaction: parts.interaction,
+      interaction_id: parts.interactionId ?? latest?.interaction_id,
+      kind: parts.kind,
+      contracted: isContracted,
+      observed: testObs.length > 0 || prodObs.length > 0,
+      test_seen: testObs.length > 0,
+      prod_seen: prodObs.length > 0,
+      provider_verified: providerObs.length > 0,
+      broker_verified: broker?.success === true,
+      broker_verified_at: broker?.verifiedAt,
+      broker_error: broker?.error,
+      last_observed_at: latest?.observed_at,
+      last_outcome: latest?.outcome
+    });
+  }
+  for (const [k, contracted] of contractedByKey) {
+    pushRow(contracted, k, true);
+  }
+  for (const [k, observations] of anyObservedByKey) {
+    if (contractedByKey.has(k)) continue;
+    const first = observations[0];
+    pushRow(
+      {
+        consumer: first.consumer,
+        provider: first.provider,
+        interaction: first.interaction,
+        kind: first.kind,
+        interactionId: first.interaction_id
+      },
+      k,
+      false
+    );
+  }
+  rows.sort(
+    (a, b) => a.consumer.localeCompare(b.consumer) || a.provider.localeCompare(b.provider) || a.interaction.localeCompare(b.interaction)
+  );
+  const counts = {
+    total: rows.length,
+    contracted: rows.filter((r) => r.contracted).length,
+    observed: rows.filter((r) => r.observed).length,
+    contracted_and_test_seen: rows.filter((r) => r.contracted && r.test_seen).length,
+    contracted_not_test_seen: rows.filter((r) => r.contracted && !r.test_seen).length,
+    test_or_prod_seen_not_contracted: rows.filter(
+      (r) => !r.contracted && (r.test_seen || r.prod_seen)
+    ).length,
+    test_seen: rows.filter((r) => r.test_seen).length,
+    prod_seen: rows.filter((r) => r.prod_seen).length,
+    provider_verified: rows.filter((r) => r.provider_verified).length,
+    broker_verified: rows.filter((r) => r.broker_verified).length
+  };
+  const matrix = {
+    spec: AUDIT_MATRIX_SPEC,
+    rows,
+    counts,
+    window_days: windowDays,
+    generated_at: now.toISOString()
+  };
+  if (verificationFailures.length > 0) {
+    matrix.verification_failures = verificationFailures;
+  }
+  return matrix;
+}
+async function runAudit(opts = {}) {
+  const pactsDir = path__default.default.resolve(process.cwd(), opts.pactsDir ?? DEFAULT_PACTS_DIR);
+  const contracted = [];
+  const pairs = /* @__PURE__ */ new Set();
+  for (const file of listPactFiles(pactsDir)) {
+    const pact = parsePactFile(file);
+    if (!pact) continue;
+    const interactions = interactionsFromPactFile(pact);
+    contracted.push(...interactions);
+    const consumer = pact.consumer?.name;
+    const provider = pact.provider?.name;
+    if (consumer && provider) {
+      pairs.add(pairKey(consumer, provider));
+    }
+  }
+  const ledger = readLedger(opts);
+  let brokerVerifications;
+  if (opts.broker) {
+    brokerVerifications = await fetchBrokerVerifications(opts.broker, [...pairs].map((p) => {
+      const [consumer, provider] = p.split("::");
+      return { consumer, provider };
+    }));
+  }
+  return computeAuditMatrix({
+    contracted,
+    ledger,
+    brokerVerifications,
+    windowDays: opts.windowDays
+  });
+}
+function runAuditSync(opts = {}) {
+  const pactsDir = path__default.default.resolve(process.cwd(), opts.pactsDir ?? DEFAULT_PACTS_DIR);
+  const contracted = [];
+  for (const file of listPactFiles(pactsDir)) {
+    const pact = parsePactFile(file);
+    if (pact) contracted.push(...interactionsFromPactFile(pact));
+  }
+  const ledger = readLedger(opts);
+  return computeAuditMatrix({
+    contracted,
+    ledger,
+    windowDays: opts.windowDays
+  });
+}
+
+// src/labels.ts
+var BROKER_GRANULARITY_WARNING = "Broker verification proves the latest pact between a consumer and provider was verified. It does not prove each interaction was individually observed by autotel-pact.";
+
+exports.AUDIT_MATRIX_SPEC = AUDIT_MATRIX_SPEC;
+exports.BROKER_GRANULARITY_WARNING = BROKER_GRANULARITY_WARNING;
+exports.LEDGER_ENTRY_SPEC = LEDGER_ENTRY_SPEC;
+exports.PACT_ATTRS = PACT_ATTRS;
+exports.PactLedgerSpanProcessor = PactLedgerSpanProcessor;
+exports.appendLedgerEntry = appendLedgerEntry;
+exports.appendLedgerEntryAsync = appendLedgerEntryAsync;
+exports.appendProviderVerificationFailure = appendProviderVerificationFailure;
+exports.brokerConfigFromEnv = brokerConfigFromEnv;
+exports.buildPactAttributes = buildPactAttributes;
+exports.computeAuditMatrix = computeAuditMatrix;
+exports.createPactLedgerProcessor = createPactLedgerProcessor;
+exports.fetchBrokerVerifications = fetchBrokerVerifications;
+exports.flushLedgerWrites = flushLedgerWrites;
+exports.interactionsFromPactFile = interactionsFromPactFile;
+exports.isInteractionLedgerEntry = isInteractionLedgerEntry;
+exports.isProviderVerificationRun = isProviderVerificationRun;
+exports.keyOf = keyOf;
+exports.ledgerPath = ledgerPath;
+exports.listPactFiles = listPactFiles;
+exports.outcomeAttribute = outcomeAttribute;
+exports.parseBrokerVerificationResult = parseBrokerVerificationResult;
+exports.parsePactFile = parsePactFile;
+exports.readLedger = readLedger;
+exports.runAudit = runAudit;
+exports.runAuditSync = runAuditSync;
+exports.tagPactInteraction = tagPactInteraction;
+exports.withHttpPactInteraction = withHttpPactInteraction;
+exports.withPactInteraction = withPactInteraction;
+exports.withProviderVerification = withProviderVerification;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map