@testsmith/api-spector 0.4.9 → 0.5.1

package/bin/cli.js

@@ -22,6 +22,9 @@ const COMMANDS = {
   record:   { entrypoint: 'record.js',  runner: 'node' },
   agents:   { entrypoint: 'agents.js',  runner: 'node' },
   contract: { entrypoint: 'contract.js',runner: 'node' },
+  coverage: { entrypoint: 'coverage.js',runner: 'node' },
+  'generate-tests': { entrypoint: 'generate-tests.js', runner: 'node' },
+  compare:  { entrypoint: 'compare.js', runner: 'node' },
   wsdl:     { entrypoint: 'wsdl.js',    runner: 'node' },
 }
 
@@ -35,6 +38,9 @@ function printHelp() {
   console.log('    api-spector mock     --workspace <path>   Start mock servers from CLI')
   console.log('    api-spector record   --upstream <url>     Record API traffic as mock stubs')
   console.log('    api-spector contract list|run             Manage & run pinned contract snapshots')
+  console.log('    api-spector coverage --spec <file>        Measure OpenAPI test coverage')
+  console.log('    api-spector generate-tests --spec <file>  Generate tests from an OpenAPI spec')
+  console.log('    api-spector compare <old> <new>           Diff specs; find breaking changes + impact')
   console.log('    api-spector wsdl     describe|import-*    Inspect a WSDL or import as collection/mock')
   console.log('')
   console.log('  Options:')

package/out/main/chunks/coverage-C54mZEh_.js

@@ -0,0 +1,146 @@
+"use strict";
+const HTTP_METHODS = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+function normalizePath(url) {
+  let u = (url || "").trim();
+  u = u.split("#")[0].split("?")[0];
+  u = u.replace(/\{\{[^}]*\}\}/g, "");
+  u = u.replace(/^[a-z0-9+.-]+:\/\/[^/]*/i, "");
+  u = u.replace(/\/{2,}/g, "/");
+  if (!u.startsWith("/")) u = "/" + u;
+  u = u.replace(/\/+$/, "");
+  return u === "" ? "/" : u;
+}
+function segments(path) {
+  return path.split("/").filter(Boolean);
+}
+function isParam(seg) {
+  return seg.startsWith("{") && seg.endsWith("}");
+}
+function pathMatches(requestUrl, template) {
+  const reqSegs = segments(normalizePath(requestUrl));
+  const tplSegs = segments(template);
+  if (reqSegs.length < tplSegs.length) return false;
+  const tail = reqSegs.slice(reqSegs.length - tplSegs.length);
+  return tplSegs.every((seg, i) => isParam(seg) ? tail[i] !== void 0 && tail[i] !== "" : tail[i] === seg);
+}
+function resolveRef(spec, ref) {
+  const parts = ref.replace(/^#\//, "").split("/");
+  return parts.reduce((o, k) => o?.[decodeURIComponent(k.replace(/~1/g, "/").replace(/~0/g, "~"))], spec);
+}
+function deref(spec, node, depth = 0, seen = /* @__PURE__ */ new Set()) {
+  if (!node || typeof node !== "object" || depth > 8) return node;
+  if (Array.isArray(node)) return node.map((n) => deref(spec, n, depth + 1, seen));
+  if ("$ref" in node) {
+    const target = resolveRef(spec, node.$ref);
+    if (!target || seen.has(target)) return {};
+    return deref(spec, target, depth + 1, /* @__PURE__ */ new Set([...seen, target]));
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(node)) out[k] = deref(spec, v, depth + 1, seen);
+  return out;
+}
+function flattenSchemaPaths(schema, prefix = "", depth = 0) {
+  if (!schema || typeof schema !== "object" || depth > 8) return [];
+  const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+  const out = [];
+  if (type === "object" || schema.properties) {
+    for (const [name, sub] of Object.entries(schema.properties ?? {})) {
+      const path = prefix ? `${prefix}.${name}` : name;
+      out.push(path);
+      out.push(...flattenSchemaPaths(sub, path, depth + 1));
+    }
+  } else if (type === "array" && schema.items) {
+    out.push(...flattenSchemaPaths(schema.items, `${prefix}[]`, depth + 1));
+  }
+  return out;
+}
+function flattenValuePaths(value, prefix = "", depth = 0) {
+  if (value == null || typeof value !== "object" || depth > 8) return [];
+  const out = [];
+  if (Array.isArray(value)) {
+    for (const el of value) out.push(...flattenValuePaths(el, `${prefix}[]`, depth + 1));
+  } else {
+    for (const [k, v] of Object.entries(value)) {
+      const path = prefix ? `${prefix}.${k}` : k;
+      out.push(path);
+      out.push(...flattenValuePaths(v, path, depth + 1));
+    }
+  }
+  return [...new Set(out)];
+}
+function successResponseSchema(spec, responses) {
+  const code = Object.keys(responses ?? {}).filter((c) => /^2\d\d$/.test(c)).sort()[0];
+  if (!code) return void 0;
+  const schema = responses[code]?.content?.["application/json"]?.schema ?? responses[code]?.content?.["application/json;charset=utf-8"]?.schema;
+  return schema ? deref(spec, schema) : void 0;
+}
+function enumerateOperations(spec) {
+  const doc = spec ?? {};
+  const ops = [];
+  for (const [path, item] of Object.entries(doc.paths ?? {})) {
+    if (!item || typeof item !== "object") continue;
+    for (const [method, op] of Object.entries(item)) {
+      if (!HTTP_METHODS.includes(method.toLowerCase())) continue;
+      if (!op || typeof op !== "object") continue;
+      const declaredStatuses = Object.keys(op.responses ?? {}).filter((c) => /^\d{3}$/.test(c));
+      ops.push({ method: method.toUpperCase(), path, operationId: op.operationId, declaredStatuses, responses: op.responses });
+    }
+  }
+  return ops;
+}
+function round(n) {
+  return Math.round(n * 10) / 10;
+}
+function computeCoverage(spec, requests, observations = []) {
+  const doc = spec ?? {};
+  const operations = enumerateOperations(spec).map((op) => {
+    const mapped = requests.filter((r) => r.method.toUpperCase() === op.method && pathMatches(r.url, op.path));
+    const obs = observations.filter((o) => o.method.toUpperCase() === op.method && pathMatches(o.url, op.path));
+    const asserted = mapped.map((r) => r.expectedStatus).filter((s) => typeof s === "number");
+    const seen = obs.map((o) => o.status);
+    const covered = /* @__PURE__ */ new Set([...asserted, ...seen]);
+    const coveredStatuses2 = op.declaredStatuses.filter((code) => covered.has(Number(code)));
+    const hasNegativeTest = [...covered].some((s) => s >= 400);
+    const declaredProperties2 = flattenSchemaPaths(successResponseSchema(doc, op.responses ?? {}));
+    const observedPaths = new Set(obs.flatMap((o) => o.responsePaths ?? []));
+    const coveredProperties2 = declaredProperties2.filter((p) => observedPaths.has(p));
+    return {
+      method: op.method,
+      path: op.path,
+      operationId: op.operationId,
+      tested: mapped.length > 0 || obs.length > 0,
+      requests: mapped.map((r) => r.name),
+      declaredStatuses: op.declaredStatuses,
+      coveredStatuses: coveredStatuses2,
+      hasNegativeTest,
+      declaredProperties: declaredProperties2,
+      coveredProperties: coveredProperties2
+    };
+  });
+  const tested = operations.filter((o) => o.tested).length;
+  const declaredStatuses = operations.reduce((n, o) => n + o.declaredStatuses.length, 0);
+  const coveredStatuses = operations.reduce((n, o) => n + o.coveredStatuses.length, 0);
+  const declaredProperties = operations.reduce((n, o) => n + o.declaredProperties.length, 0);
+  const coveredProperties = operations.reduce((n, o) => n + o.coveredProperties.length, 0);
+  const withoutNegativeTest = operations.filter((o) => o.tested && !o.hasNegativeTest).length;
+  return {
+    spec: { title: doc.info?.title, version: doc.info?.version },
+    totals: {
+      operations: operations.length,
+      tested,
+      untested: operations.length - tested,
+      operationPct: operations.length ? round(tested / operations.length * 100) : 0,
+      declaredStatuses,
+      coveredStatuses,
+      statusPct: declaredStatuses ? round(coveredStatuses / declaredStatuses * 100) : 0,
+      withoutNegativeTest,
+      declaredProperties,
+      coveredProperties,
+      propertyPct: declaredProperties ? round(coveredProperties / declaredProperties * 100) : 0
+    },
+    operations
+  };
+}
+exports.computeCoverage = computeCoverage;
+exports.flattenValuePaths = flattenValuePaths;
+exports.pathMatches = pathMatches;

package/out/main/chunks/{handle-CF2LjTGV.js → handle-b6bp3fb0.js}

@@ -104,10 +104,28 @@ const IPC = {
     fetch: "wsdl:fetch",
     import: "wsdl:import"
   },
+  // ─── gRPC ──────────────────────────────────────────────────────────────────
+  grpc: {
+    /** Load a .proto (source or path) and enumerate its services/methods. */
+    loadProto: "grpc:loadProto",
+    /** Invoke a method (unary or server-streaming). Streams back messages. */
+    invoke: "grpc:invoke",
+    /** Cancel an in-flight call. */
+    cancel: "grpc:cancel",
+    /** Event: a received message frame. */
+    message: "grpc:message",
+    /** Event: call status change (running / completed / error, with code). */
+    status: "grpc:status"
+  },
   // ─── Docs generation ───────────────────────────────────────────────────────
   docs: {
     generate: "docs:generate"
   },
+  // ─── OpenAPI coverage ────────────────────────────────────────────────────────
+  coverage: {
+    /** Read + parse an OpenAPI spec (file path, URL, or raw text). */
+    loadSpec: "coverage:loadSpec"
+  },
   // ─── Contract testing ──────────────────────────────────────────────────────
   contract: {
     run: "contract:run",

package/out/main/chunks/{import-ChCkdHOB.js → import-BeY7gjWL.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const uuid = require("uuid");
-const soapHandler = require("./soap-handler-pOrJ625E.js");
-require("./handle-CF2LjTGV.js");
+const soapHandler = require("./soap-handler-BYkE6MyE.js");
+require("./handle-b6bp3fb0.js");
 require("https");
 require("http");
 require("@xmldom/xmldom");

package/out/main/chunks/{request-exec-DeXgxps8.js → request-exec-D_xyyt3_.js}

@@ -24,10 +24,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 const undici = require("undici");
 const promises = require("fs/promises");
 const nodeTls = require("tls");
-const handle = require("./handle-CF2LjTGV.js");
-const node_fs = require("node:fs");
-const node_os = require("node:os");
-const node_path = require("node:path");
+const handle = require("./handle-b6bp3fb0.js");
+const fs = require("node:fs");
+const os = require("node:os");
+const path$1 = require("node:path");
 const node_crypto = require("node:crypto");
 const crypto = require("crypto");
 const path = require("path");
@@ -124,7 +124,7 @@ function env$3(...names) {
 }
 function readFileTrim(path2) {
   try {
-    return node_fs.readFileSync(path2, "utf8").trim() || void 0;
+    return fs.readFileSync(path2, "utf8").trim() || void 0;
   } catch {
     return void 0;
   }
@@ -135,7 +135,7 @@ function resolveConn$3() {
   if (!address) {
     throw new Error("Vault is not configured: set VAULT_ADDR (or settings.secrets.vault.address)");
   }
-  const token = env$3("VAULT_TOKEN", "API_SPECTOR_VAULT_TOKEN") ?? readFileTrim(node_path.join(node_os.homedir(), ".vault-token"));
+  const token = env$3("VAULT_TOKEN", "API_SPECTOR_VAULT_TOKEN") ?? readFileTrim(path$1.join(os.homedir(), ".vault-token"));
   const roleId = env$3("VAULT_ROLE_ID", "API_SPECTOR_VAULT_ROLE_ID") ?? cfg.roleId;
   const secretId = env$3("VAULT_SECRET_ID", "API_SPECTOR_VAULT_SECRET_ID");
   const jwt = env$3("VAULT_JWT", "API_SPECTOR_VAULT_JWT") ?? (env$3("VAULT_JWT_PATH", "API_SPECTOR_VAULT_JWT_PATH") ? readFileTrim(env$3("VAULT_JWT_PATH", "API_SPECTOR_VAULT_JWT_PATH")) : void 0);

package/out/main/chunks/{snapshots-8wLrfQcq.js → snapshots-BJiZNuRN.js}

@@ -3,7 +3,7 @@ const promises = require("fs/promises");
 const path = require("path");
 const crypto = require("crypto");
 const undici = require("undici");
-const requestExec = require("./request-exec-DeXgxps8.js");
+const requestExec = require("./request-exec-D_xyyt3_.js");
 const Ajv = require("ajv");
 const jsYaml = require("js-yaml");
 require("http");

package/out/main/chunks/{soap-handler-pOrJ625E.js → soap-handler-BYkE6MyE.js}

@@ -1,5 +1,5 @@
 "use strict";
-const handle = require("./handle-CF2LjTGV.js");
+const handle = require("./handle-b6bp3fb0.js");
 const https = require("https");
 const http = require("http");
 const xmldom = require("@xmldom/xmldom");
@@ -315,7 +315,7 @@ function registerSoapHandlers(ipc) {
   handle.handleIpc(ipc, handle.IPC.wsdl.import, async (_event, opts) => {
     const { validateWsdlImport } = await Promise.resolve().then(() => require("./ipc-validate-k6KI8adf.js"));
     validateWsdlImport(opts);
-    const { importWsdl } = await Promise.resolve().then(() => require("./import-ChCkdHOB.js"));
+    const { importWsdl } = await Promise.resolve().then(() => require("./import-BeY7gjWL.js"));
     const wsdlText = opts.xml ?? (opts.url ? await fetchUrl(opts.url) : "");
     if (!wsdlText) throw new Error("wsdl:import requires either `url` or `xml`");
     return importWsdl(wsdlText, { name: opts.name, existingMockPorts: opts.existingMockPorts });

package/out/main/compare.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+"use strict";
+const promises = require("fs/promises");
+const jsYaml = require("js-yaml");
+const undici = require("undici");
+const coverage = require("./chunks/coverage-C54mZEh_.js");
+const cliCommon = require("./chunks/cli-common-BKYgsbGB.js");
+require("path");
+require("crypto");
+const HTTP_METHODS = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+function resolveRef(spec, ref) {
+  const parts = ref.replace(/^#\//, "").split("/");
+  return parts.reduce((o, k) => o?.[decodeURIComponent(k.replace(/~1/g, "/").replace(/~0/g, "~"))], spec);
+}
+function deref(spec, node, depth = 0, seen = /* @__PURE__ */ new Set()) {
+  if (!node || typeof node !== "object" || depth > 8) return node;
+  if (Array.isArray(node)) return node.map((n) => deref(spec, n, depth + 1, seen));
+  if ("$ref" in node) {
+    const target = resolveRef(spec, node.$ref);
+    if (!target || seen.has(target)) return {};
+    return deref(spec, target, depth + 1, /* @__PURE__ */ new Set([...seen, target]));
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(node)) out[k] = deref(spec, v, depth + 1, seen);
+  return out;
+}
+function walk(schema, prefix, depth, types, required) {
+  if (!schema || typeof schema !== "object" || depth > 8) return;
+  const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+  if (type === "object" || schema.properties) {
+    const req = schema.required ?? [];
+    for (const [name, sub] of Object.entries(schema.properties ?? {})) {
+      const p = prefix ? `${prefix}.${name}` : name;
+      const subType = (Array.isArray(sub?.type) ? sub.type[0] : sub?.type) ?? (sub?.properties ? "object" : "any");
+      types.set(p, subType);
+      if (req.includes(name)) required.add(p);
+      walk(sub, p, depth + 1, types, required);
+    }
+  } else if (type === "array" && schema.items) {
+    walk(schema.items, `${prefix}[]`, depth + 1, types, required);
+  }
+}
+function schemaInfo(spec, schema) {
+  const types = /* @__PURE__ */ new Map();
+  const required = /* @__PURE__ */ new Set();
+  if (schema) walk(deref(spec, schema), "", 0, types, required);
+  return { types, required };
+}
+function requestSchema(spec, op) {
+  return deref(spec, op?.requestBody)?.content?.["application/json"]?.schema;
+}
+function successResponseSchema(spec, op) {
+  const responses = op?.responses ?? {};
+  const code = Object.keys(responses).filter((c) => /^2\d\d$/.test(c)).sort()[0];
+  return code ? deref(spec, responses[code])?.content?.["application/json"]?.schema : void 0;
+}
+function paramRequired(spec, pathItem, op) {
+  const raw = [...pathItem?.parameters ?? [], ...op?.parameters ?? []].map((p) => deref(spec, p));
+  const m = /* @__PURE__ */ new Map();
+  for (const p of raw) if (p?.name && p?.in) m.set(`${p.in}:${p.name}`, !!p.required);
+  return m;
+}
+function operations(spec) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [path, item] of Object.entries(spec?.paths ?? {})) {
+    if (!item || typeof item !== "object") continue;
+    for (const [method, op] of Object.entries(item)) {
+      if (!HTTP_METHODS.includes(method.toLowerCase())) continue;
+      map.set(`${method.toUpperCase()} ${path}`, { method: method.toUpperCase(), path, pathItem: item, op });
+    }
+  }
+  return map;
+}
+function diffSpecs(oldSpec, newSpec) {
+  const oldOps = operations(oldSpec);
+  const newOps = operations(newSpec);
+  const changes = [];
+  for (const [key, o] of oldOps) {
+    if (!newOps.has(key)) {
+      changes.push({ kind: "operation-removed", breaking: true, method: o.method, path: o.path, detail: `Operation ${key} was removed` });
+    }
+  }
+  for (const [key, n] of newOps) {
+    if (!oldOps.has(key)) {
+      changes.push({ kind: "operation-added", breaking: false, method: n.method, path: n.path, detail: `Operation ${key} was added` });
+      continue;
+    }
+    const o = oldOps.get(key);
+    const label = `${n.method} ${n.path}`;
+    const oReq = schemaInfo(oldSpec, requestSchema(oldSpec, o.op));
+    const nReq = schemaInfo(newSpec, requestSchema(newSpec, n.op));
+    for (const p of nReq.required) {
+      if (!oReq.required.has(p)) {
+        changes.push({ kind: "request-required-added", breaking: true, method: n.method, path: n.path, detail: `${label}: request field "${p}" is now required` });
+      }
+    }
+    for (const [p, t] of nReq.types) {
+      const ot = oReq.types.get(p);
+      if (ot && ot !== t) {
+        changes.push({ kind: "request-type-changed", breaking: true, method: n.method, path: n.path, detail: `${label}: request field "${p}" type ${ot} -> ${t}` });
+      }
+    }
+    const oRes = schemaInfo(oldSpec, successResponseSchema(oldSpec, o.op));
+    const nRes = schemaInfo(newSpec, successResponseSchema(newSpec, n.op));
+    for (const [p, t] of oRes.types) {
+      if (!nRes.types.has(p)) {
+        changes.push({ kind: "response-removed", breaking: true, method: n.method, path: n.path, detail: `${label}: response field "${p}" was removed` });
+      } else if (nRes.types.get(p) !== t) {
+        changes.push({ kind: "response-type-changed", breaking: true, method: n.method, path: n.path, detail: `${label}: response field "${p}" type ${t} -> ${nRes.types.get(p)}` });
+      }
+    }
+    const oParams = paramRequired(oldSpec, o.pathItem, o.op);
+    const nParams = paramRequired(newSpec, n.pathItem, n.op);
+    for (const [k, req] of nParams) {
+      if (req && !oParams.get(k)) {
+        changes.push({ kind: "param-required-added", breaking: true, method: n.method, path: n.path, detail: `${label}: parameter "${k}" is now required` });
+      }
+    }
+    const oCodes = Object.keys(o.op?.responses ?? {}).filter((c) => /^2\d\d$/.test(c));
+    const nCodes = new Set(Object.keys(n.op?.responses ?? {}));
+    for (const c of oCodes) {
+      if (!nCodes.has(c)) {
+        changes.push({ kind: "success-code-removed", breaking: true, method: n.method, path: n.path, detail: `${label}: success response ${c} was removed` });
+      }
+    }
+  }
+  return changes;
+}
+function summarizeDiff(changes) {
+  return {
+    breaking: changes.filter((c) => c.breaking).length,
+    nonBreaking: changes.filter((c) => !c.breaking).length
+  };
+}
+async function loadSpec(source) {
+  const isUrl = /^https?:\/\//i.test(source);
+  const raw = isUrl ? await (async () => {
+    const r = await undici.fetch(source);
+    if (!r.ok) throw new Error(`HTTP ${r.status} fetching ${source}`);
+    return r.text();
+  })() : await promises.readFile(source, "utf8");
+  return /\.ya?ml$/i.test(source) || !isUrl && !raw.trim().startsWith("{") ? jsYaml.load(raw) : JSON.parse(raw);
+}
+async function analyseImpact(changes, wsPath) {
+  const { workspace, dir } = await cliCommon.loadWorkspace(wsPath);
+  const collections = await cliCommon.loadCollections(workspace, dir);
+  const reqs = [];
+  for (const col of collections) {
+    for (const r of Object.values(col.requests ?? {})) {
+      if (r.disabled) continue;
+      reqs.push({ name: `${col.name} / ${r.name}`, method: r.method, url: r.url });
+    }
+  }
+  return changes.filter((c) => c.breaking && c.method).map((change) => ({
+    change,
+    tests: reqs.filter((r) => r.method.toUpperCase() === change.method && coverage.pathMatches(r.url, change.path)).map((r) => r.name)
+  }));
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const positional = argv.filter((a) => !a.startsWith("--"));
+  const args = cliCommon.parseArgs(argv);
+  if (args.help || args.h || positional.length < 2) {
+    console.log("\nUsage:\n  api-spector compare <old-spec> <new-spec> [--workspace <path>] [--fail-on-breaking] [--json]\n");
+    process.exit(positional.length < 2 && !args.help && !args.h ? 2 : 0);
+  }
+  const [oldSource, newSource] = positional;
+  let changes;
+  try {
+    const [oldSpec, newSpec] = await Promise.all([loadSpec(oldSource), loadSpec(newSource)]);
+    changes = diffSpecs(oldSpec, newSpec);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(2);
+  }
+  const impact = args.workspace ? await analyseImpact(changes, args.workspace) : null;
+  const { breaking, nonBreaking } = summarizeDiff(changes);
+  if (args.json) {
+    console.log(JSON.stringify({ changes, impact, summary: { breaking, nonBreaking } }, null, 2));
+  } else {
+    console.log("");
+    if (breaking) {
+      console.log(cliCommon.color("  BREAKING CHANGES", cliCommon.C.bold, cliCommon.C.red));
+      for (const c of changes.filter((c2) => c2.breaking)) console.log(`  ${cliCommon.color("✗", cliCommon.C.red)} ${c.detail}`);
+      console.log("");
+    }
+    if (nonBreaking) {
+      console.log(cliCommon.color("  NON-BREAKING", cliCommon.C.bold, cliCommon.C.green));
+      for (const c of changes.filter((c2) => !c2.breaking)) console.log(`  ${cliCommon.color("✓", cliCommon.C.green)} ${c.detail}`);
+      console.log("");
+    }
+    if (!changes.length) console.log(cliCommon.color("  No differences.\n", cliCommon.C.gray));
+    if (impact) {
+      const hit = impact.filter((a) => a.tests.length > 0);
+      const totalTests = new Set(hit.flatMap((a) => a.tests)).size;
+      console.log(cliCommon.color("  IMPACT", cliCommon.C.bold, cliCommon.C.white));
+      if (!breaking) {
+        console.log(cliCommon.color("  No breaking changes. Safe to deploy.\n", cliCommon.C.green));
+      } else if (totalTests === 0) {
+        console.log(`  ${breaking} breaking change(s), but no test in this workspace exercises the affected operations.`);
+        console.log(cliCommon.color("  Recommendation: add tests for those operations, then re-check.\n", cliCommon.C.yellow));
+      } else {
+        for (const a of hit) {
+          console.log(`  ${cliCommon.color(a.change.detail, cliCommon.C.yellow)}`);
+          for (const t of a.tests) console.log(cliCommon.color(`      - ${t}`, cliCommon.C.gray));
+        }
+        console.log("");
+        console.log(cliCommon.color(`  BLOCK DEPLOYMENT: ${breaking} breaking change(s) affect ${totalTests} test(s).`, cliCommon.C.bold, cliCommon.C.red));
+        console.log("");
+      }
+    }
+  }
+  if (args["fail-on-breaking"] && breaking > 0) process.exit(1);
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(2);
+});

package/out/main/contract.js

@@ -2,7 +2,7 @@
 "use strict";
 const promises = require("fs/promises");
 const path = require("path");
-const snapshots = require("./chunks/snapshots-8wLrfQcq.js");
+const snapshots = require("./chunks/snapshots-BJiZNuRN.js");
 const crypto = require("crypto");
 const undici = require("undici");
 const os = require("os");
@@ -10,9 +10,9 @@ const cliCommon = require("./chunks/cli-common-BKYgsbGB.js");
 const child_process = require("child_process");
 const jsYaml = require("js-yaml");
 const environments = require("./chunks/environments-iM3SUM-4.js");
-require("./chunks/request-exec-DeXgxps8.js");
+require("./chunks/request-exec-D_xyyt3_.js");
 require("tls");
-require("./chunks/handle-CF2LjTGV.js");
+require("./chunks/handle-b6bp3fb0.js");
 require("node:fs");
 require("node:os");
 require("node:path");