@testsmith/api-spector 0.3.4 → 0.3.6

package/out/main/chunks/snapshots-UFd3XgSS.js

@@ -1,928 +0,0 @@
-"use strict";
-const undici = require("undici");
-const authBuilder = require("./auth-builder-CUs9yzOF.js");
-const promises = require("fs/promises");
-const jsYaml = require("js-yaml");
-const Ajv = require("ajv");
-const path = require("path");
-const crypto = require("crypto");
-const MATCH_KEY = "__match";
-function isMatcher(node) {
-  return typeof node === "object" && node !== null && !Array.isArray(node) && typeof node[MATCH_KEY] === "string";
-}
-function compileMatcher(m) {
-  switch (m[MATCH_KEY]) {
-    case "type":
-      return compileMatcherExample(m.value, false);
-    case "integer":
-      return { type: "integer" };
-    case "decimal":
-    case "number":
-      return { type: "number" };
-    case "boolean":
-      return { type: "boolean" };
-    case "string":
-      return { type: "string" };
-    case "null":
-      return { type: "null" };
-    case "regex":
-      return { type: "string", pattern: m.regex ?? ".*" };
-    case "datetime":
-    case "timestamp":
-      return { type: "string", format: "date-time" };
-    case "date":
-      return { type: "string", format: "date" };
-    case "time":
-      return { type: "string", format: "time" };
-    case "eachLike": {
-      const schema = { type: "array", items: compileMatcherExample(m.value, false) };
-      schema["minItems"] = typeof m.min === "number" ? m.min : 1;
-      return schema;
-    }
-    default:
-      return {};
-  }
-}
-function compileMatcherExample(node, exact = true) {
-  if (isMatcher(node)) return compileMatcher(node);
-  if (node === null) return { type: "null" };
-  const t = typeof node;
-  if (t === "boolean") return exact ? { const: node } : { type: "boolean" };
-  if (t === "number") return exact ? { const: node } : Number.isInteger(node) ? { type: "integer" } : { type: "number" };
-  if (t === "string") return exact ? { const: node } : { type: "string" };
-  if (Array.isArray(node)) {
-    if (node.length === 0) return { type: "array" };
-    const schema = { type: "array", items: node.map((n) => compileMatcherExample(n, exact)) };
-    if (exact) schema["minItems"] = node.length;
-    return schema;
-  }
-  if (t === "object") {
-    const obj = node;
-    const properties = {};
-    const required = [];
-    for (const [key, value] of Object.entries(obj)) {
-      properties[key] = compileMatcherExample(value, exact);
-      required.push(key);
-    }
-    return { type: "object", properties, required, additionalProperties: true };
-  }
-  return {};
-}
-const ajv$1 = new Ajv({ allErrors: true, strict: false });
-function hasContract(contract) {
-  return !!contract && (contract.statusCode !== void 0 || !!contract.bodySchema || !!contract.bodyMatcher || !!contract.headers?.length);
-}
-function validateConsumerResponse(contract, actualStatus, actualHeaders, bodyText) {
-  const violations = [];
-  if (contract.statusCode !== void 0 && actualStatus !== contract.statusCode) {
-    violations.push({
-      type: "status_mismatch",
-      message: `Expected status ${contract.statusCode}, got ${actualStatus}`,
-      expected: String(contract.statusCode),
-      actual: String(actualStatus)
-    });
-  }
-  for (const expected of contract.headers ?? []) {
-    if (!expected.required) continue;
-    const actual = actualHeaders[expected.key.toLowerCase()];
-    if (actual === void 0) {
-      violations.push({
-        type: "missing_header",
-        message: `Required header "${expected.key}" is absent`,
-        expected: expected.value || "(any)",
-        actual: "(absent)"
-      });
-    } else if (expected.value && actual.split(";")[0].trim().toLowerCase() !== expected.value.split(";")[0].trim().toLowerCase()) {
-      violations.push({
-        type: "missing_header",
-        message: `Header "${expected.key}" has unexpected value`,
-        expected: expected.value,
-        actual
-      });
-    }
-  }
-  if (contract.bodySchema?.trim()) {
-    let schema;
-    try {
-      schema = JSON.parse(contract.bodySchema);
-    } catch {
-      violations.push({
-        type: "schema_violation",
-        message: "Contract bodySchema is not valid JSON"
-      });
-      return violations;
-    }
-    violations.push(...validateBody(schema, bodyText));
-  }
-  if (contract.bodyMatcher?.trim()) {
-    let example;
-    try {
-      example = JSON.parse(contract.bodyMatcher);
-    } catch {
-      violations.push({
-        type: "schema_violation",
-        message: "Contract bodyMatcher is not valid JSON"
-      });
-      return violations;
-    }
-    violations.push(...validateBody(compileMatcherExample(example), bodyText));
-  }
-  return violations;
-}
-function validateBody(schema, bodyText) {
-  const violations = [];
-  let data;
-  try {
-    data = JSON.parse(bodyText);
-  } catch {
-    violations.push({
-      type: "schema_violation",
-      message: "Response body is not valid JSON — cannot validate against schema"
-    });
-    return violations;
-  }
-  try {
-    const validate = ajv$1.compile(schema);
-    if (!validate(data)) {
-      for (const err of validate.errors ?? []) {
-        violations.push({
-          type: "schema_violation",
-          message: err.message ?? "Schema violation",
-          path: err.instancePath || "/"
-        });
-      }
-    }
-  } catch (e) {
-    violations.push({
-      type: "schema_violation",
-      message: `Schema compile error: ${e instanceof Error ? e.message : String(e)}`
-    });
-  }
-  return violations;
-}
-async function executeContract(req, vars) {
-  const url = authBuilder.buildUrl(req.url, req.params, vars);
-  const start = Date.now();
-  try {
-    const headers = new undici.Headers();
-    for (const h of req.headers) {
-      if (h.enabled && h.key) headers.set(authBuilder.interpolate(h.key, vars), authBuilder.interpolate(h.value, vars));
-    }
-    const authHeaders = await authBuilder.buildAuthHeaders(req.auth, vars);
-    for (const [k, v] of Object.entries(authHeaders)) headers.set(k, v);
-    let body;
-    if (req.body.mode === "json" && req.body.json) {
-      body = authBuilder.interpolate(req.body.json, vars);
-      if (!headers.has("content-type")) headers.set("Content-Type", "application/json");
-    } else if (req.body.mode === "raw" && req.body.raw) {
-      body = authBuilder.interpolate(req.body.raw, vars);
-    }
-    const resp = await undici.fetch(url, {
-      method: req.method,
-      headers,
-      body: !["GET", "HEAD"].includes(req.method) ? body : void 0
-    });
-    const bodyText = await resp.text();
-    const rawHeaders = {};
-    resp.headers.forEach((v, k) => {
-      rawHeaders[k] = v;
-    });
-    const violations = validateConsumerResponse(req.contract, resp.status, rawHeaders, bodyText);
-    return {
-      requestId: req.id,
-      requestName: req.name,
-      method: req.method,
-      url,
-      passed: violations.length === 0,
-      violations,
-      durationMs: Date.now() - start,
-      actualStatus: resp.status
-    };
-  } catch (err) {
-    return {
-      requestId: req.id,
-      requestName: req.name,
-      method: req.method,
-      url,
-      passed: false,
-      violations: [{
-        type: "status_mismatch",
-        message: `Request failed: ${err instanceof Error ? err.message : String(err)}`
-      }],
-      durationMs: Date.now() - start
-    };
-  }
-}
-async function runConsumerContracts(requests, envVars, collectionVars = {}) {
-  const vars = { ...envVars, ...collectionVars };
-  const contractRequests = requests.filter((r) => !r.disabled && hasContract(r.contract));
-  const start = Date.now();
-  const results = await Promise.all(contractRequests.map((r) => executeContract(r, vars)));
-  const passed = results.filter((r) => r.passed).length;
-  return {
-    mode: "consumer",
-    total: results.length,
-    passed,
-    failed: results.length - passed,
-    results,
-    durationMs: Date.now() - start
-  };
-}
-const ajv = new Ajv({ allErrors: true, strict: false });
-async function loadSpec(specUrl, specPath) {
-  if (specUrl) {
-    const resp = await undici.fetch(specUrl);
-    if (!resp.ok) throw new Error(`HTTP ${resp.status} loading spec from ${specUrl}`);
-    const text = await resp.text();
-    const ct = resp.headers.get("content-type") ?? "";
-    return ct.includes("yaml") || specUrl.endsWith(".yaml") || specUrl.endsWith(".yml") ? jsYaml.load(text) : JSON.parse(text);
-  }
-  if (specPath) {
-    const raw = await promises.readFile(specPath, "utf8");
-    return specPath.endsWith(".yaml") || specPath.endsWith(".yml") ? jsYaml.load(raw) : JSON.parse(raw);
-  }
-  throw new Error("Either specUrl or specPath must be provided");
-}
-function resolveRef(spec, ref) {
-  const parts = ref.replace(/^#\//, "").split("/");
-  return parts.reduce((obj, key) => obj?.[key], spec);
-}
-function resolveSchema(spec, obj, seen = /* @__PURE__ */ new Set()) {
-  if (!obj || typeof obj !== "object") return obj;
-  if (seen.has(obj)) return {};
-  if (Array.isArray(obj)) {
-    seen.add(obj);
-    return obj.map((i) => resolveSchema(spec, i, seen));
-  }
-  const o = obj;
-  if ("$ref" in o) {
-    const target = resolveRef(spec, o["$ref"]);
-    return resolveSchema(spec, target, seen);
-  }
-  seen.add(obj);
-  return Object.fromEntries(Object.entries(o).map(([k, v]) => [k, resolveSchema(spec, v, seen)]));
-}
-function getServerBases(spec) {
-  const servers = spec["servers"] ?? [];
-  if (!servers.length) return [""];
-  return servers.map((s) => {
-    const raw = s.url ?? "";
-    try {
-      return new URL(raw).pathname.replace(/\/$/, "");
-    } catch {
-      return raw.replace(/\/$/, "");
-    }
-  });
-}
-function urlPathname(raw, baseUrl) {
-  try {
-    const pathname = new URL(raw).pathname;
-    if (baseUrl) {
-      try {
-        const basePath = new URL(baseUrl).pathname.replace(/\/$/, "");
-        if (basePath && pathname.startsWith(basePath)) return pathname.slice(basePath.length) || "/";
-      } catch {
-      }
-    }
-    return pathname;
-  } catch {
-    return raw.split("?")[0];
-  }
-}
-function pathTemplateToRegex(base, template) {
-  const combined = (base + template).replace(/\/+/g, "/");
-  const pattern = combined.replace(/\{[^}]+\}/g, "[^/]+");
-  return new RegExp("^" + pattern + "/?$");
-}
-function findOperation(spec, method, reqUrl, requestBaseUrl) {
-  const bases = getServerBases(spec);
-  const pathname = urlPathname(reqUrl, requestBaseUrl);
-  const paths = spec["paths"] ?? {};
-  for (const [template, pathItem] of Object.entries(paths)) {
-    const resolved = resolveSchema(spec, pathItem);
-    for (const base of bases) {
-      if (pathTemplateToRegex(base, template).test(pathname)) {
-        const op = resolved[method.toLowerCase()];
-        return op ? { pathTemplate: template, operation: op } : null;
-      }
-    }
-  }
-  return null;
-}
-function validateRequestAgainstSpec(spec, req, envVars, requestBaseUrl) {
-  const violations = [];
-  const vars = envVars;
-  const url = req.url.replace(/\{\{([^}]+)\}\}/g, (_, k) => vars[k] ?? `{{${k}}}`);
-  const match = findOperation(spec, req.method, url, requestBaseUrl);
-  if (!match) {
-    violations.push({
-      type: "unknown_path",
-      message: `No operation found in spec for ${req.method} ${url}`
-    });
-    return violations;
-  }
-  const { operation } = match;
-  if (req.body.mode === "json" && req.body.json?.trim()) {
-    const requestBody = resolveSchema(spec, operation["requestBody"]);
-    const content = requestBody?.["content"] ?? {};
-    const jsonContent = content["application/json"];
-    if (jsonContent?.["schema"]) {
-      try {
-        const data = JSON.parse(authBuilder.interpolate(req.body.json, vars));
-        const schema = resolveSchema(spec, jsonContent["schema"]);
-        const validate = ajv.compile(schema);
-        if (!validate(data)) {
-          for (const err of validate.errors ?? []) {
-            violations.push({
-              type: "request_body_invalid",
-              message: err.message ?? "Request body schema violation",
-              path: err.instancePath || "/"
-            });
-          }
-        }
-      } catch (e) {
-        violations.push({
-          type: "request_body_invalid",
-          message: `Could not validate request body: ${e instanceof Error ? e.message : String(e)}`
-        });
-      }
-    }
-  }
-  const parameters = resolveSchema(spec, operation["parameters"] ?? []);
-  for (const param of parameters) {
-    const p = param;
-    if (p["in"] === "query" && p["required"] === true) {
-      const name = p["name"];
-      if (!req.params.some((kv) => kv.enabled && kv.key === name)) {
-        violations.push({
-          type: "request_body_invalid",
-          message: `Required query parameter "${name}" is missing`,
-          path: `query.${name}`
-        });
-      }
-    }
-  }
-  return violations;
-}
-async function runProviderVerification(requests, envVars, specUrl, specPath, requestBaseUrl) {
-  const spec = await loadSpec(specUrl, specPath);
-  const start = Date.now();
-  const activeRequests = requests.filter((r) => !r.disabled);
-  const results = activeRequests.map((req) => {
-    const violations = validateRequestAgainstSpec(spec, req, envVars, requestBaseUrl);
-    const url = req.url.replace(/\{\{([^}]+)\}\}/g, (_, k) => envVars[k] ?? `{{${k}}}`);
-    return {
-      requestId: req.id,
-      requestName: req.name,
-      method: req.method,
-      url,
-      passed: violations.length === 0,
-      violations
-    };
-  });
-  const passed = results.filter((r) => r.passed).length;
-  return {
-    mode: "provider",
-    total: results.length,
-    passed,
-    failed: results.length - passed,
-    results,
-    durationMs: Date.now() - start
-  };
-}
-function rebaseUrl(fullUrl, providerBaseUrl) {
-  if (!providerBaseUrl) return fullUrl;
-  try {
-    const orig = new URL(fullUrl, "http://placeholder.invalid");
-    const base = new URL(providerBaseUrl);
-    const basePath = base.pathname.replace(/\/$/, "");
-    base.pathname = (basePath + orig.pathname).replace(/\/{2,}/g, "/");
-    base.search = orig.search;
-    return base.toString();
-  } catch {
-    return fullUrl;
-  }
-}
-async function setupState(stateHandlerUrl, state, action) {
-  if (!stateHandlerUrl) {
-    return {
-      type: "provider_state_failed",
-      message: `Interaction requires provider state "${state}" but no --states-url / stateHandlerUrl was configured`,
-      expected: state
-    };
-  }
-  try {
-    const resp = await undici.fetch(stateHandlerUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ state, action })
-    });
-    if (!resp.ok) {
-      return {
-        type: "provider_state_failed",
-        message: `State handler returned HTTP ${resp.status} setting up "${state}"`,
-        expected: state,
-        actual: String(resp.status)
-      };
-    }
-    return null;
-  } catch (err) {
-    return {
-      type: "provider_state_failed",
-      message: `State handler unreachable for "${state}": ${err instanceof Error ? err.message : String(err)}`,
-      expected: state
-    };
-  }
-}
-async function verifyInteraction(req, vars, providerBaseUrl, stateHandlerUrl) {
-  const url = rebaseUrl(authBuilder.buildUrl(req.url, req.params, vars), providerBaseUrl);
-  const start = Date.now();
-  const violations = [];
-  const states = req.contract?.providerStates ?? [];
-  for (const state of states) {
-    const v = await setupState(stateHandlerUrl, state, "setup");
-    if (v) violations.push(v);
-  }
-  if (violations.length > 0) {
-    return { requestId: req.id, requestName: req.name, method: req.method, url, passed: false, violations, durationMs: Date.now() - start };
-  }
-  try {
-    const headers = new undici.Headers();
-    for (const h of req.headers) {
-      if (h.enabled && h.key) headers.set(authBuilder.interpolate(h.key, vars), authBuilder.interpolate(h.value, vars));
-    }
-    const authHeaders = await authBuilder.buildAuthHeaders(req.auth, vars);
-    for (const [k, v] of Object.entries(authHeaders)) headers.set(k, v);
-    let body;
-    if (req.body.mode === "json" && req.body.json) {
-      body = authBuilder.interpolate(req.body.json, vars);
-      if (!headers.has("content-type")) headers.set("Content-Type", "application/json");
-    } else if (req.body.mode === "raw" && req.body.raw) {
-      body = authBuilder.interpolate(req.body.raw, vars);
-    }
-    const resp = await undici.fetch(url, {
-      method: req.method,
-      headers,
-      body: !["GET", "HEAD"].includes(req.method) ? body : void 0
-    });
-    const bodyText = await resp.text();
-    const rawHeaders = {};
-    resp.headers.forEach((v, k) => {
-      rawHeaders[k] = v;
-    });
-    violations.push(...validateConsumerResponse(req.contract, resp.status, rawHeaders, bodyText));
-    return {
-      requestId: req.id,
-      requestName: req.name,
-      method: req.method,
-      url,
-      passed: violations.length === 0,
-      violations,
-      durationMs: Date.now() - start,
-      actualStatus: resp.status
-    };
-  } catch (err) {
-    violations.push({
-      type: "status_mismatch",
-      message: `Request failed: ${err instanceof Error ? err.message : String(err)}`
-    });
-    return { requestId: req.id, requestName: req.name, method: req.method, url, passed: false, violations, durationMs: Date.now() - start };
-  } finally {
-    for (const state of states) await setupState(stateHandlerUrl, state, "teardown");
-  }
-}
-async function runLiveProviderVerification(requests, envVars, collectionVars = {}, providerBaseUrl, stateHandlerUrl) {
-  const vars = { ...envVars, ...collectionVars };
-  const start = Date.now();
-  const contractRequests = requests.filter((r) => !r.disabled && hasContract(r.contract));
-  const results = [];
-  for (const req of contractRequests) {
-    results.push(await verifyInteraction(req, vars, providerBaseUrl, stateHandlerUrl));
-  }
-  const passed = results.filter((r) => r.passed).length;
-  return {
-    mode: "provider-live",
-    total: results.length,
-    passed,
-    failed: results.length - passed,
-    results,
-    durationMs: Date.now() - start
-  };
-}
-function checkSchemaCompatibility(consumerSchema, providerSchema, path2 = "") {
-  const violations = [];
-  if (!consumerSchema || !providerSchema) return violations;
-  const cType = consumerSchema["type"];
-  const pType = providerSchema["type"];
-  if (cType && pType && cType !== pType) {
-    const ok = cType === "integer" && pType === "number" || cType === "number" && pType === "integer";
-    if (!ok) {
-      violations.push({
-        type: "schema_incompatible",
-        message: `Type mismatch${path2 ? ` at "${path2}"` : ""}: consumer expects "${cType}", provider offers "${pType}"`,
-        path: path2 || "/",
-        expected: cType,
-        actual: pType
-      });
-      return violations;
-    }
-  }
-  if (cType === "array" || Array.isArray(consumerSchema["items"])) {
-    const cItems = consumerSchema["items"];
-    const pItems = providerSchema["items"];
-    if (cItems && pItems) {
-      violations.push(...checkSchemaCompatibility(cItems, pItems, path2 ? `${path2}[]` : "[]"));
-    }
-    return violations;
-  }
-  if (cType === "object" || consumerSchema["properties"]) {
-    const cProps = consumerSchema["properties"] ?? {};
-    const pProps = providerSchema["properties"] ?? {};
-    const cRequired = consumerSchema["required"] ?? [];
-    for (const field of cRequired) {
-      const fieldPath = path2 ? `${path2}.${field}` : field;
-      if (!(field in pProps)) {
-        violations.push({
-          type: "schema_incompatible",
-          message: `Consumer requires field "${fieldPath}" which is not defined in provider schema`,
-          path: fieldPath,
-          expected: "(defined)",
-          actual: "(absent)"
-        });
-      }
-    }
-    for (const [field, cPropSchema] of Object.entries(cProps)) {
-      if (field in pProps) {
-        const fieldPath = path2 ? `${path2}.${field}` : field;
-        violations.push(...checkSchemaCompatibility(
-          cPropSchema,
-          pProps[field],
-          fieldPath
-        ));
-      }
-    }
-  }
-  return violations;
-}
-function getProviderResponseSchema(spec, req, envVars, statusCode, requestBaseUrl) {
-  const url = req.url.replace(/\{\{([^}]+)\}\}/g, (_, k) => envVars[k] ?? `{{${k}}}`);
-  const match = findOperation(spec, req.method, url, requestBaseUrl);
-  if (!match) return null;
-  const responses = match.operation["responses"] ?? {};
-  const candidates = [String(statusCode), `${String(statusCode)[0]}xx`, "2XX", "2xx", "default"];
-  for (const candidate of candidates) {
-    const resp = responses[candidate];
-    if (resp) {
-      const resolved = resolveSchema(spec, resp);
-      const content = resolved["content"] ?? {};
-      const json = content["application/json"];
-      if (json?.["schema"]) {
-        return resolveSchema(spec, json["schema"]);
-      }
-    }
-  }
-  return null;
-}
-async function executeRequest(req, vars) {
-  const url = authBuilder.buildUrl(req.url, req.params, vars);
-  const start = Date.now();
-  try {
-    const headers = new undici.Headers();
-    for (const h of req.headers) {
-      if (h.enabled && h.key) headers.set(authBuilder.interpolate(h.key, vars), authBuilder.interpolate(h.value, vars));
-    }
-    const authHeaders = await authBuilder.buildAuthHeaders(req.auth, vars);
-    for (const [k, v] of Object.entries(authHeaders)) headers.set(k, v);
-    let body;
-    if (req.body.mode === "json" && req.body.json) {
-      body = authBuilder.interpolate(req.body.json, vars);
-      if (!headers.has("content-type")) headers.set("Content-Type", "application/json");
-    }
-    const resp = await undici.fetch(url, {
-      method: req.method,
-      headers,
-      body: !["GET", "HEAD"].includes(req.method) ? body : void 0
-    });
-    const bodyText = await resp.text();
-    const rawHdrs = {};
-    resp.headers.forEach((v, k) => {
-      rawHdrs[k] = v;
-    });
-    return { status: resp.status, headers: rawHdrs, body: bodyText, durationMs: Date.now() - start };
-  } catch (err) {
-    return err instanceof Error ? err : new Error(String(err));
-  }
-}
-async function runBidirectional(requests, envVars, collectionVars = {}, specUrl, specPath, requestBaseUrl) {
-  const spec = await loadSpec(specUrl, specPath);
-  const vars = { ...envVars, ...collectionVars };
-  const start = Date.now();
-  const contractRequests = requests.filter((r) => !r.disabled && hasContract(r.contract));
-  const results = await Promise.all(contractRequests.map(async (req) => {
-    const url = authBuilder.buildUrl(req.url, req.params, vars);
-    const violations = [];
-    const expectedStatus = req.contract.statusCode ?? 200;
-    const consumerSchema = req.contract.bodySchema ? (() => {
-      try {
-        return JSON.parse(req.contract.bodySchema);
-      } catch {
-        return null;
-      }
-    })() : null;
-    if (consumerSchema) {
-      const providerSchema = getProviderResponseSchema(spec, req, vars, expectedStatus, requestBaseUrl);
-      if (!providerSchema) {
-        violations.push({
-          type: "schema_incompatible",
-          message: `No response schema found in spec for ${req.method} ${url} → ${expectedStatus}`
-        });
-      } else {
-        violations.push(...checkSchemaCompatibility(consumerSchema, providerSchema));
-      }
-    }
-    const result = await executeRequest(req, vars);
-    if (result instanceof Error) {
-      violations.push({ type: "status_mismatch", message: `Request failed: ${result.message}` });
-      return { requestId: req.id, requestName: req.name, method: req.method, url, passed: false, violations };
-    }
-    const liveViolations = validateConsumerResponse(
-      req.contract,
-      result.status,
-      result.headers,
-      result.body
-    );
-    violations.push(...liveViolations);
-    return {
-      requestId: req.id,
-      requestName: req.name,
-      method: req.method,
-      url,
-      passed: violations.length === 0,
-      violations,
-      durationMs: result.durationMs,
-      actualStatus: result.status
-    };
-  }));
-  const passed = results.filter((r) => r.passed).length;
-  return {
-    mode: "bidirectional",
-    total: results.length,
-    passed,
-    failed: results.length - passed,
-    results,
-    durationMs: Date.now() - start
-  };
-}
-function esc(s) {
-  return String(s ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function modeLabel(mode) {
-  if (mode === "bidirectional") return "Bi-directional";
-  if (mode === "provider-live") return "Provider (live)";
-  return mode.charAt(0).toUpperCase() + mode.slice(1);
-}
-const STYLE = `
-:root { color-scheme: dark; }
-* { box-sizing: border-box; }
-body { margin: 0; font: 14px/1.5 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Helvetica,Arial,sans-serif;
-  background: #0f1115; color: #e5e7eb; }
-.wrap { max-width: 960px; margin: 0 auto; padding: 32px 24px 64px; }
-h1 { font-size: 20px; margin: 0 0 4px; }
-.sub { color: #8b929e; font-size: 13px; margin: 0 0 24px; }
-.meta { display: flex; flex-wrap: wrap; gap: 8px 20px; color: #9aa1ad; font-size: 12px; margin-bottom: 12px; }
-.meta b { color: #cbd2dc; font-weight: 600; }
-.headline { font-size: 24px; font-weight: 700; }
-.headline.ok { color: #34d399; } .headline.bad { color: #f87171; }
-.bar { display: flex; height: 10px; border-radius: 6px; overflow: hidden; background: #1b1f27; margin: 14px 0 6px; }
-.bar > i { display: block; height: 100%; }
-.bar .ok { background: #34d399; } .bar .bad { background: #f87171; }
-.cards { display: flex; flex-direction: column; gap: 10px; margin-top: 24px; }
-.card { border: 1px solid #232834; border-radius: 10px; overflow: hidden; background: #141821; }
-.card.fail { border-color: #7f1d1d; }
-.row { display: flex; align-items: center; gap: 12px; padding: 12px 16px; }
-.card.fail summary .row { background: rgba(127,29,29,.18); }
-.pill { font-size: 10px; font-weight: 700; padding: 2px 8px; border-radius: 5px; flex-shrink: 0; letter-spacing: .03em; }
-.pill.ok { background: rgba(16,84,55,.55); color: #34d399; }
-.pill.bad { background: rgba(127,29,29,.55); color: #f87171; }
-.method { font: 700 12px ui-monospace,SFMono-Regular,Menlo,monospace; width: 56px; flex-shrink: 0; color: #93c5fd; }
-.name { flex: 1; color: #f3f4f6; font-weight: 500; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-.url { color: #6b7280; font: 11px ui-monospace,monospace; max-width: 280px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-.dur { color: #6b7280; font-size: 11px; }
-.code { font: 700 12px ui-monospace,monospace; }
-.code.s2 { color: #34d399; } .code.s3 { color: #fbbf24; } .code.s4, .code.s5 { color: #f87171; }
-.viol { padding: 14px 16px; border-top: 1px solid #1f2530; display: flex; flex-direction: column; gap: 10px; }
-.v { border-left: 2px solid #dc2626; background: rgba(127,29,29,.12); border-radius: 0 6px 6px 0; padding: 8px 12px; }
-.v .t { font: 700 10px ui-monospace,monospace; color: #f87171; text-transform: uppercase; letter-spacing: .04em; }
-.v .path { font: 10px ui-monospace,monospace; color: #8b929e; background: #1b1f27; padding: 1px 6px; border-radius: 4px; margin-left: 8px; }
-.v .m { color: #fecaca; font-size: 13px; margin: 4px 0 0; }
-.v .ea { font: 11px ui-monospace,monospace; margin-top: 4px; display: flex; gap: 18px; }
-.v .ea .lab { color: #6b7280; }
-.v .ea .exp { color: #34d399; } .v .ea .act { color: #f87171; }
-.pass-note { color: #34d399; font-size: 13px; padding: 12px 16px; border-top: 1px solid #1f2530; }
-table { border-collapse: collapse; width: 100%; margin-top: 16px; font-size: 13px; }
-th, td { border: 1px solid #232834; padding: 8px 12px; text-align: left; }
-th { background: #141821; color: #cbd2dc; font-weight: 600; }
-td.cell { text-align: center; }
-.b { display: inline-block; min-width: 56px; padding: 2px 8px; border-radius: 5px; font-size: 11px; font-weight: 700; }
-.b.ok { background: rgba(16,84,55,.55); color: #34d399; }
-.b.bad { background: rgba(127,29,29,.55); color: #f87171; }
-.b.na { background: #1b1f27; color: #6b7280; }
-.foot { color: #6b7280; font-size: 11px; margin-top: 40px; text-align: center; }
-summary { cursor: pointer; list-style: none; }
-summary::-webkit-details-marker { display: none; }
-`;
-function page(title, body) {
-  return `<!doctype html>
-<html lang="en"><head><meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>${esc(title)}</title>
-<style>${STYLE}</style>
-</head><body><div class="wrap">${body}
-<p class="foot">Generated by API Spector · contract reporting</p>
-</div></body></html>`;
-}
-function statusClass(code) {
-  if (code === void 0) return "";
-  return "s" + String(code)[0];
-}
-function violationHtml(r) {
-  if (r.violations.length === 0) return `<div class="pass-note">All expectations met.</div>`;
-  const items = r.violations.map((v) => {
-    const path2 = v.path ? `<span class="path">${esc(v.path)}</span>` : "";
-    const ea = v.expected || v.actual ? `<div class="ea">${v.expected ? `<span><span class="lab">expected </span><span class="exp">${esc(v.expected)}</span></span>` : ""}${v.actual ? `<span><span class="lab">actual </span><span class="act">${esc(v.actual)}</span></span>` : ""}</div>` : "";
-    return `<div class="v"><div><span class="t">${esc(v.type.replace(/_/g, " "))}</span>${path2}</div><p class="m">${esc(v.message)}</p>${ea}</div>`;
-  }).join("");
-  return `<div class="viol">${items}</div>`;
-}
-function cardHtml(r) {
-  const pill = r.passed ? `<span class="pill ok">PASS</span>` : `<span class="pill bad">FAIL</span>`;
-  const status = r.actualStatus !== void 0 ? `<span class="code ${statusClass(r.actualStatus)}">${r.actualStatus}</span>` : "";
-  const dur = r.durationMs !== void 0 ? `<span class="dur">${r.durationMs}ms</span>` : "";
-  return `<details class="card ${r.passed ? "" : "fail"}" ${r.passed ? "" : "open"}>
-  <summary><div class="row">${pill}<span class="method">${esc(r.method)}</span><span class="name">${esc(r.requestName)}</span><span class="url">${esc(r.url)}</span>${status}${dur}</div></summary>
-  ${violationHtml(r)}
-</details>`;
-}
-function reportToHtml(report, meta = {}) {
-  const okPct = report.total ? Math.round(report.passed / report.total * 100) : 100;
-  const badPct = 100 - okPct;
-  const headlineCls = report.failed === 0 ? "ok" : "bad";
-  const headline = report.failed === 0 ? "✓ All passed" : `✗ ${report.failed} failed`;
-  const metaRows = [
-    `<span><b>Mode</b> ${esc(modeLabel(report.mode))}</span>`,
-    meta.provider ? `<span><b>Provider</b> ${esc(meta.provider)}</span>` : "",
-    meta.consumer ? `<span><b>Consumer</b> ${esc(meta.consumer)}</span>` : "",
-    meta.spec ? `<span><b>Spec</b> ${esc(meta.spec)}</span>` : "",
-    `<span><b>Duration</b> ${report.durationMs}ms</span>`,
-    meta.generatedAt ? `<span><b>Generated</b> ${esc(meta.generatedAt)}</span>` : ""
-  ].filter(Boolean).join("");
-  const failed = report.results.filter((r) => !r.passed);
-  const passed = report.results.filter((r) => r.passed);
-  const cards = [...failed, ...passed].map(cardHtml).join("");
-  const body = `
-<h1>${esc(meta.title ?? "Contract Verification Report")}</h1>
-<p class="sub"><span class="headline ${headlineCls}">${esc(headline)}</span> &nbsp; ${report.passed} / ${report.total} interactions passed</p>
-<div class="meta">${metaRows}</div>
-<div class="bar"><i class="ok" style="width:${okPct}%"></i><i class="bad" style="width:${badPct}%"></i></div>
-<div class="cards">${cards || '<p class="sub">No interactions ran.</p>'}</div>`;
-  return page(meta.title ?? "Contract Verification Report", body);
-}
-function dashboardToHtml(records, generatedAt) {
-  const pacticipants = [...new Set(records.map((r) => r.pacticipant))].sort();
-  const versions = [...new Set(records.map((r) => r.version))].sort();
-  const byKey = new Map(records.map((r) => [`${r.pacticipant}@@${r.version}`, r]));
-  const header = `<tr><th>Pacticipant \\ Version</th>${versions.map((v) => `<th>${esc(v)}</th>`).join("")}</tr>`;
-  const rows = pacticipants.map((p) => {
-    const cells = versions.map((v) => {
-      const rec = byKey.get(`${p}@@${v}`);
-      if (!rec) return `<td class="cell"><span class="b na">—</span></td>`;
-      const cls = rec.passed ? "ok" : "bad";
-      const label = rec.passed ? `${rec.report.total}/${rec.report.total}` : `${rec.report.passed}/${rec.report.total}`;
-      return `<td class="cell" title="${esc(rec.recordedAt)}"><span class="b ${cls}">${esc(label)}</span></td>`;
-    }).join("");
-    return `<tr><td><b>${esc(p)}</b></td>${cells}</tr>`;
-  }).join("");
-  const totalPass = records.filter((r) => r.passed).length;
-  const body = `
-<h1>Contract Dashboard</h1>
-<p class="sub">${records.length} recorded verification${records.length === 1 ? "" : "s"} · ${totalPass} passing</p>
-<div class="meta">${generatedAt ? `<span><b>Generated</b> ${esc(generatedAt)}</span>` : ""}</div>
-${records.length ? `<table>${header}${rows}</table>` : '<p class="sub">No recorded results yet. Run a verification with <code>--record --app-version &lt;ver&gt;</code>.</p>'}`;
-  return page("Contract Dashboard", body);
-}
-const SNAPSHOT_DIR = "contracts";
-function safeName(raw) {
-  return raw.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "spec";
-}
-function sha256(text) {
-  return crypto.createHash("sha256").update(text).digest("hex");
-}
-function detectFormat(source, contentType) {
-  const lc = source.toLowerCase();
-  if (lc.endsWith(".yaml") || lc.endsWith(".yml")) return "yaml";
-  if (lc.endsWith(".json")) return "json";
-  if (contentType.includes("yaml")) return "yaml";
-  return "json";
-}
-function tryExtractSpecVersion(specText, format) {
-  try {
-    const parsed = format === "yaml" ? jsYaml.load(specText) : JSON.parse(specText);
-    const info = parsed?.info;
-    if (info && typeof info.version === "string") return info.version;
-  } catch {
-  }
-  return void 0;
-}
-async function captureSnapshot(workspaceDir, opts) {
-  const { specUrl, specPath } = opts;
-  if (!specUrl && !specPath) throw new Error("captureSnapshot: specUrl or specPath is required");
-  let specText;
-  let format;
-  let source;
-  if (specUrl) {
-    const resp = await undici.fetch(specUrl);
-    if (!resp.ok) throw new Error(`HTTP ${resp.status} loading spec from ${specUrl}`);
-    specText = await resp.text();
-    format = detectFormat(specUrl, resp.headers.get("content-type") ?? "");
-    source = specUrl;
-  } else {
-    specText = await promises.readFile(specPath, "utf8");
-    format = detectFormat(specPath, "");
-    source = specPath;
-  }
-  const id = crypto.randomUUID();
-  const specVersion = tryExtractSpecVersion(specText, format);
-  let name = opts.name?.trim();
-  if (!name) {
-    try {
-      name = new URL(source).hostname;
-    } catch {
-      name = source.split(/[\\/]/).pop() ?? "spec";
-    }
-  }
-  if (specVersion && !name.includes(specVersion)) name = `${name} ${specVersion}`;
-  const snapshot = {
-    version: "1.0",
-    id,
-    name,
-    source,
-    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    format,
-    specVersion,
-    spec: specText,
-    sha256: sha256(specText)
-  };
-  const relPath = path.join(SNAPSHOT_DIR, `${safeName(name)}-${id.slice(0, 8)}.contract.json`);
-  const absPath = path.resolve(workspaceDir, relPath);
-  await promises.mkdir(path.join(workspaceDir, SNAPSHOT_DIR), { recursive: true });
-  await promises.writeFile(absPath, JSON.stringify(snapshot, null, 2), "utf8");
-  Object.defineProperty(snapshot, "__relPath", { value: relPath, enumerable: false });
-  return snapshot;
-}
-function relPathOf(snapshot) {
-  const hidden = snapshot.__relPath;
-  return hidden;
-}
-async function loadSnapshot(workspaceDir, relPath) {
-  const raw = await promises.readFile(path.resolve(workspaceDir, relPath), "utf8");
-  return JSON.parse(raw);
-}
-async function listSnapshots(workspaceDir, registered = []) {
-  const seen = new Set(registered);
-  try {
-    const entries = await promises.readdir(path.join(workspaceDir, SNAPSHOT_DIR));
-    for (const f of entries) {
-      if (f.endsWith(".contract.json")) seen.add(path.join(SNAPSHOT_DIR, f));
-    }
-  } catch {
-  }
-  const out = [];
-  for (const relPath of seen) {
-    try {
-      const snapshot = await loadSnapshot(workspaceDir, relPath);
-      out.push({ relPath, snapshot });
-    } catch {
-    }
-  }
-  out.sort((a, b) => b.snapshot.capturedAt.localeCompare(a.snapshot.capturedAt));
-  return out;
-}
-async function deleteSnapshot(workspaceDir, relPath) {
-  try {
-    await promises.unlink(path.resolve(workspaceDir, relPath));
-  } catch {
-  }
-}
-exports.MATCH_KEY = MATCH_KEY;
-exports.captureSnapshot = captureSnapshot;
-exports.dashboardToHtml = dashboardToHtml;
-exports.deleteSnapshot = deleteSnapshot;
-exports.hasContract = hasContract;
-exports.listSnapshots = listSnapshots;
-exports.loadSnapshot = loadSnapshot;
-exports.relPathOf = relPathOf;
-exports.reportToHtml = reportToHtml;
-exports.runBidirectional = runBidirectional;
-exports.runConsumerContracts = runConsumerContracts;
-exports.runLiveProviderVerification = runLiveProviderVerification;
-exports.runProviderVerification = runProviderVerification;