@qawolf/ci-sdk 3.0.0 → 3.2.0

package/dist/index.js

@@ -2,6 +2,88 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
+// src/lib/sdk/domain/detectProviderDeploymentId/index.ts
+var ciSystems = [
+  {
+    ci: "github",
+    isActive: /* @__PURE__ */ __name((env) => env.GITHUB_ACTIONS === "true", "isActive"),
+    // GITHUB_RUN_ID is stable across re-runs and GITHUB_RUN_ATTEMPT increments,
+    // and both are shared by every job in the workflow, so GITHUB_JOB separates
+    // jobs that deploy in parallel. GITHUB_JOB names the job definition, which
+    // every leg of a matrix shares, so those legs need a discriminator.
+    variables: ["GITHUB_RUN_ID", "GITHUB_RUN_ATTEMPT", "GITHUB_JOB"]
+  },
+  {
+    ci: "gitlab",
+    isActive: /* @__PURE__ */ __name((env) => env.GITLAB_CI === "true", "isActive"),
+    // Retrying a job keeps the pipeline id and mints a new job id.
+    variables: ["CI_PIPELINE_ID", "CI_JOB_ID"]
+  },
+  {
+    ci: "circleci",
+    isActive: /* @__PURE__ */ __name((env) => env.CIRCLECI === "true", "isActive"),
+    // A rerun keeps the workflow id and allocates a new build number. A job
+    // run with `parallelism` shares both across its containers, so those need
+    // a discriminator.
+    variables: ["CIRCLE_WORKFLOW_ID", "CIRCLE_BUILD_NUM"]
+  },
+  {
+    ci: "buildkite",
+    isActive: /* @__PURE__ */ __name((env) => env.BUILDKITE === "true", "isActive"),
+    // BUILDKITE_BUILD_ID covers the whole build, so BUILDKITE_JOB_ID separates
+    // the jobs within it and BUILDKITE_RETRY_COUNT separates a job's retries.
+    variables: [
+      "BUILDKITE_BUILD_ID",
+      "BUILDKITE_JOB_ID",
+      "BUILDKITE_RETRY_COUNT"
+    ]
+  },
+  {
+    ci: "jenkins",
+    // JENKINS_URL is unset on some agent configurations.
+    isActive: /* @__PURE__ */ __name((env) => env.JENKINS_URL !== void 0 || env.JENKINS_HOME !== void 0, "isActive"),
+    // BUILD_TAG is `jenkins-${JOB_NAME}-${BUILD_NUMBER}`, and Jenkins allocates
+    // a fresh BUILD_NUMBER for every externally visible re-run — Rebuild,
+    // Naginator, Replay and Restart from Stage — so it needs no attempt
+    // counter. An in-pipeline `retry {}` reuses it, but reports nothing new.
+    // A declarative `matrix` or `parallel` block runs its branches inside one
+    // build and so shares BUILD_TAG; those branches need a discriminator.
+    variables: ["BUILD_TAG"]
+  },
+  {
+    ci: "bitbucket",
+    isActive: /* @__PURE__ */ __name((env) => env.BITBUCKET_WORKSPACE !== void 0 || env.BITBUCKET_BUILD_NUMBER !== void 0, "isActive"),
+    // Rerunning a whole pipeline mints a new build number, but rerunning only
+    // the failed steps keeps it and increments the step's run number instead.
+    // Parallel steps share both, so BITBUCKET_STEP_UUID separates them.
+    variables: [
+      "BITBUCKET_BUILD_NUMBER",
+      "BITBUCKET_STEP_UUID",
+      "BITBUCKET_STEP_RUN_NUMBER"
+    ]
+  }
+];
+function detectProviderDeploymentId({
+  discriminator,
+  env = process.env
+} = {}) {
+  const system = ciSystems.find((candidate) => candidate.isActive(env));
+  if (!system) return { outcome: "unsupported" };
+  const missingVariables = system.variables.filter((name) => !env[name]);
+  if (missingVariables.length > 0)
+    return { ci: system.ci, missingVariables, outcome: "missing-variables" };
+  const composed = system.variables.map((name) => env[name]).join("-");
+  return {
+    ci: system.ci,
+    // A colon separates the discriminator because a job id can itself contain
+    // a hyphen, so joining with one would let job "deploy-web" collide with
+    // job "deploy" discriminated by "web".
+    id: discriminator ? `${composed}:${discriminator}` : composed,
+    outcome: "detected"
+  };
+}
+__name(detectProviderDeploymentId, "detectProviderDeploymentId");
+
 // src/lib/other.ts
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -16,6 +98,9 @@ var buildFetchWithTimeout = /* @__PURE__ */ __name((fetch, defaultTimeoutMs) =>
   return fetch(args[0], { ...args[1], signal });
 }, "buildFetchWithTimeout");
 
+// src/lib/sdk/defaults/clock.ts
+var defaultClock = { now: /* @__PURE__ */ __name(() => Date.now(), "now"), sleep };
+
 // src/lib/sdk/defaults/fetch.ts
 var defaultFetch = globalThis.fetch;
 
@@ -38,7 +123,7 @@ var defaultServiceBase = "https://app.qawolf.com/";
 // package.json
 var package_default = {
   name: "@qawolf/ci-sdk",
-  version: "3.0.0",
+  version: "3.2.0",
   private: false,
   description: "A simple SDK for interacting with QAWolf in CI scripts.",
   keywords: [],
@@ -61,18 +146,20 @@ var package_default = {
     "lint:ci": "npm run lint:first-half; FIRST_HALF_EXIT=$?; npm run lint:second-half && exit $FIRST_HALF_EXIT",
     "lint:dev": "npm run lint:first-half",
     "lint:first-half": "oxlint . --fix --quiet --report-unused-disable-directives --type-aware && oxfmt --write .",
-    "lint:second-half": "dpdm --exit-code circular:1 --no-tree --no-warning --transform --include='.*' --exclude='/(dist|node_modules)/' '**/*'",
+    "lint:second-half": "rev-dep config run",
     prepublishOnly: "nx run ci-sdk:build",
     test: 'NODE_OPTIONS="--experimental-vm-modules" NODE_NO_WARNINGS=1 jest',
     "tsc:check": "tsc --noEmit"
   },
   dependencies: {
+    "@qawolf/api-contracts": ">=0.71.0",
     "@qawolf/ci-utils": "^2.0.0",
     "@sinonjs/fake-timers": "^10.3.0",
-    tslib: "^2.6.2"
+    tslib: "^2.6.2",
+    zod: "^4.1.11"
   },
   devDependencies: {
-    "@qawolf/platform-builder": "^1.2.3",
+    "@qawolf/platform-builder": "^1.2.7",
     tsx: "^4.19.4",
     typescript: "^5.9.3"
   },
@@ -1111,12 +1198,551 @@ async function pollCiGreenlightStatus(deps, apiConfig, {
 }
 __name(pollCiGreenlightStatus, "pollCiGreenlightStatus");
 
+// src/lib/sdk/domain/reportDeployment/index.ts
+import { publicContractsV1 } from "@qawolf/api-contracts";
+
+// src/lib/sdk/publicApi/callContract.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+__name(isRecord2, "isRecord");
+function isSuperJsonEnvelope(data) {
+  return "json" in data && Object.keys(data).every((key) => key === "json" || key === "meta");
+}
+__name(isSuperJsonEnvelope, "isSuperJsonEnvelope");
+function unwrapTrpcEnvelope(body) {
+  if (!isRecord2(body) || !isRecord2(body.result)) return void 0;
+  const data = body.result.data;
+  return isRecord2(data) && isSuperJsonEnvelope(data) ? data.json : data;
+}
+__name(unwrapTrpcEnvelope, "unwrapTrpcEnvelope");
+function readTrpcError(body) {
+  const wrapped = isRecord2(body) ? body.error : void 0;
+  const error = isRecord2(wrapped) && isRecord2(wrapped.json) ? wrapped.json : wrapped;
+  if (!isRecord2(error)) return { eventId: void 0, message: void 0 };
+  const data = isRecord2(error.data) ? error.data : void 0;
+  return {
+    eventId: typeof data?.eventId === "string" ? data.eventId : void 0,
+    message: typeof error.message === "string" ? error.message : void 0
+  };
+}
+__name(readTrpcError, "readTrpcError");
+function parseJson(text) {
+  if (text === void 0) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+__name(parseJson, "parseJson");
+async function readHttpError(response, contractName, log) {
+  const bodyText = await response.text().catch(() => void 0);
+  const { eventId, message } = readTrpcError(parseJson(bodyText));
+  const statusText = response.status >= 500 ? "Server Error" : response.statusText || "Unknown Error";
+  const eventIdSuffix = eventId ? ` (Event ID: ${eventId})` : "";
+  const messageSuffix = message ? `: ${message}` : "";
+  log.error(
+    `\u274C [${contractName}] ${response.status} ${statusText}${eventIdSuffix}${messageSuffix}`
+  );
+  return {
+    eventId,
+    httpStatus: response.status,
+    message,
+    outcome: "http-error"
+  };
+}
+__name(readHttpError, "readHttpError");
+async function callPublicContract({ fetch: localFetch, log }, apiConfig, {
+  contract,
+  input
+}) {
+  const procedurePath = `public.${contract.name}`;
+  let bodyText;
+  try {
+    const response = await localFetch(
+      new URL(`/api/trpc/${procedurePath}`, apiConfig.serviceBase),
+      {
+        // The server's superjson transformer reads the input from `json`.
+        body: JSON.stringify({ json: input }),
+        headers: {
+          Authorization: `Bearer ${apiConfig.apiKey}`,
+          "Content-Type": "application/json",
+          "User-Agent": apiConfig.userAgent
+        },
+        method: "POST"
+      }
+    );
+    if (!response.ok) return readHttpError(response, contract.name, log);
+    bodyText = await response.text();
+  } catch {
+    log.error(`\u{1F6AB} Network error from ${contract.name}.`);
+    return { outcome: "network-error" };
+  }
+  const parsed = contract.output.safeParse(
+    unwrapTrpcEnvelope(parseJson(bodyText))
+  );
+  if (!parsed.success) {
+    log.error(
+      `\u{1F6AB} Invalid response from ${contract.name} (${parsed.error.issues[0]?.message ?? "the response body did not match the contract"}), aborting.`
+    );
+    return { outcome: "invalid-response-body" };
+  }
+  return { data: parsed.data, outcome: "ok" };
+}
+__name(callPublicContract, "callPublicContract");
+
+// src/lib/sdk/domain/reportDeployment/index.ts
+async function reportDeployment(deps, apiConfig, params) {
+  const result = await callPublicContract(deps, apiConfig, {
+    contract: publicContractsV1.deployment.reportStatus,
+    input: params
+  });
+  if (result.outcome !== "ok") return mapFailure(result);
+  const { deployment } = result.data;
+  deps.log.info(
+    `\u2705 Deployment ${deployment.id} reported as ${deployment.status}: ${deployment.url}`
+  );
+  return { deployment, outcome: "reported" };
+}
+__name(reportDeployment, "reportDeployment");
+function mapFailure(result) {
+  if (result.outcome !== "http-error") return { outcome: result.outcome };
+  const { httpStatus, message } = result;
+  if (httpStatus === 400) return { message, outcome: "invalid-request" };
+  if (httpStatus === 401 || httpStatus === 403)
+    return { message, outcome: "unauthorized" };
+  if (httpStatus === 404) return { message, outcome: "not-found" };
+  if (httpStatus === 409) return { message, outcome: "conflict" };
+  if (httpStatus >= 500) return { httpStatus, outcome: "server-error" };
+  return { httpStatus, message, outcome: "unexpected-status" };
+}
+__name(mapFailure, "mapFailure");
+
+// src/lib/sdk/domain/waitForVerdict/awaitRuns.ts
+import { publicContractsV1 as publicContractsV12 } from "@qawolf/api-contracts";
+
+// src/lib/sdk/domain/waitForVerdict/failures.ts
+function handleCallFailure(failure, deploymentId) {
+  if (failure.outcome === "network-error") {
+    return {
+      exhaustedVerdict: { deploymentId, outcome: "network-error" },
+      kind: "retry"
+    };
+  }
+  if (failure.outcome === "invalid-response-body") {
+    return {
+      kind: "stop",
+      verdict: { deploymentId, outcome: "invalid-response-body" }
+    };
+  }
+  const { httpStatus, message } = failure;
+  if (httpStatus >= 500) {
+    return {
+      exhaustedVerdict: { deploymentId, httpStatus, outcome: "server-error" },
+      kind: "retry"
+    };
+  }
+  if (httpStatus === 401 || httpStatus === 403) {
+    return {
+      kind: "stop",
+      verdict: { deploymentId, message, outcome: "unauthorized" }
+    };
+  }
+  if (httpStatus === 404) {
+    return {
+      kind: "stop",
+      verdict: { deploymentId, message, outcome: "not-found" }
+    };
+  }
+  return {
+    kind: "stop",
+    verdict: {
+      deploymentId,
+      httpStatus,
+      message,
+      outcome: "unexpected-status"
+    }
+  };
+}
+__name(handleCallFailure, "handleCallFailure");
+
+// src/lib/sdk/domain/waitForVerdict/poll.ts
+async function pollUntil(ctx, {
+  deadlineAt,
+  onData,
+  onDeadline,
+  request
+}) {
+  const { clock, log } = ctx.deps;
+  const { deploymentId } = ctx;
+  const { maxRetries, retryInterval, signal } = ctx.config;
+  let retries = 0;
+  const sleepWithinBudget = /* @__PURE__ */ __name((intervalMs) => clock.sleep(Math.max(0, Math.min(intervalMs, deadlineAt - clock.now()))), "sleepWithinBudget");
+  for (; ; ) {
+    if (signal?.aborted)
+      return { deploymentId, outcome: "canceled-by-caller" };
+    if (clock.now() >= deadlineAt) return onDeadline();
+    const result = await request();
+    if (result.outcome === "ok") {
+      retries = 0;
+      const step = await onData(result.data);
+      if (step.kind === "done") return step.result;
+      await sleepWithinBudget(step.intervalMs);
+      continue;
+    }
+    const handling = handleCallFailure(result, deploymentId);
+    if (handling.kind === "stop") return handling.verdict;
+    retries += 1;
+    if (retries > maxRetries) return handling.exhaustedVerdict;
+    log.warn(
+      `\u23F3 QA Wolf did not answer, trying again... (${retries}/${maxRetries})`
+    );
+    await sleepWithinBudget(retryInterval);
+  }
+}
+__name(pollUntil, "pollUntil");
+
+// src/lib/sdk/domain/waitForVerdict/progress.ts
+function describeStage(stage) {
+  switch (stage.stage) {
+    case "waiting-for-evaluation":
+      return "\u23F3 Waiting for QA Wolf to evaluate this deployment's triggers...";
+    case "waiting-for-run": {
+      const { matchedTriggerCount } = stage;
+      return `\u23F3 ${matchedTriggerCount} trigger${pluralize(matchedTriggerCount)} matched; waiting for a run to start...`;
+    }
+    case "waiting-for-verdict": {
+      const urls = stage.runs.map((run) => run.runUrl).join(" ");
+      return `\u23F3 ${stage.runs.length} run${pluralize(stage.runs.length)} executing... ${urls}`;
+    }
+    default:
+      throw Error(`Unexpected stage: ${stage}`);
+  }
+}
+__name(describeStage, "describeStage");
+async function reportStage(ctx, previousDescription, stage) {
+  const description = describeStage(stage);
+  if (description === previousDescription) return description;
+  ctx.deps.log.info(description);
+  try {
+    await ctx.config.onProgress?.(stage);
+  } catch (error) {
+    ctx.deps.log.error("The onProgress callback failed.", error);
+  }
+  return description;
+}
+__name(reportStage, "reportStage");
+
+// src/lib/sdk/domain/waitForVerdict/readEvaluations.ts
+var notConsideredMessages = {
+  "not-a-deployment-trigger": "The trigger has no deployment conditions, so no deployment can fire it.",
+  "trigger-paused": "The trigger was paused when the deployment was evaluated."
+};
+function readDidNotMatch(conditionSets) {
+  const reasons = conditionSets.flatMap(
+    (set) => set.conditions.flatMap(
+      (condition) => condition.outcome === "did-not-match" ? [condition.reason] : []
+    )
+  );
+  return reasons.length > 0 ? reasons.join(" ") : "The trigger's conditions did not match this deployment.";
+}
+__name(readDidNotMatch, "readDidNotMatch");
+function toTriggerNote(evaluation) {
+  const { triggerName, verdict } = evaluation;
+  if (verdict.outcome === "did-not-match")
+    return { message: readDidNotMatch(verdict.conditionSets), triggerName };
+  if (verdict.outcome === "not-considered") {
+    return {
+      message: notConsideredMessages[verdict.reason],
+      triggerName
+    };
+  }
+  if (verdict.run.status === "did-not-run") {
+    return {
+      message: verdict.run.message,
+      reason: verdict.run.reason,
+      triggerName
+    };
+  }
+  return void 0;
+}
+__name(toTriggerNote, "toTriggerNote");
+function toMatchedRun(evaluation) {
+  const { triggerName, verdict } = evaluation;
+  if (verdict.outcome !== "matched") return void 0;
+  if (verdict.run.status === "ran")
+    return { runId: verdict.run.runId, triggerName };
+  if (verdict.run.status === "did-not-run" && verdict.run.supersededByRunId)
+    return { runId: verdict.run.supersededByRunId, triggerName };
+  return void 0;
+}
+__name(toMatchedRun, "toMatchedRun");
+function isStillProducingARun(evaluation) {
+  const { verdict } = evaluation;
+  return verdict.outcome === "matched" && (verdict.run.status === "starting" || verdict.run.status === "unknown");
+}
+__name(isStillProducingARun, "isStillProducingARun");
+function readEvaluations(evaluations) {
+  if (evaluations.state === "not-evaluated") return { kind: "not-evaluated" };
+  const runs = evaluations.evaluations.flatMap((evaluation) => {
+    const run = toMatchedRun(evaluation);
+    return run ? [run] : [];
+  });
+  const matched = evaluations.evaluations.filter(
+    (evaluation) => evaluation.verdict.outcome === "matched"
+  );
+  if (evaluations.evaluations.some(isStillProducingARun))
+    return { kind: "awaiting-run", matchedTriggerCount: matched.length, runs };
+  if (runs.length > 0) return { kind: "runs", runs };
+  return {
+    kind: "not-tested",
+    reason: matched.length > 0 ? "no-run-created" : "no-trigger-matched",
+    triggers: evaluations.evaluations.flatMap((evaluation) => {
+      const note = toTriggerNote(evaluation);
+      return note ? [note] : [];
+    })
+  };
+}
+__name(readEvaluations, "readEvaluations");
+
+// src/lib/sdk/domain/waitForVerdict/awaitRuns.ts
+async function awaitRuns(ctx) {
+  const { clock } = ctx.deps;
+  const { deploymentId } = ctx;
+  const { runAppearanceTimeout, timeout, triggerPollInterval } = ctx.config;
+  const overallDeadlineAt = ctx.startedAt + timeout;
+  let knownRuns = [];
+  let lastStage = { stage: "waiting-for-evaluation" };
+  let lastDescription = void 0;
+  return pollUntil(ctx, {
+    deadlineAt: Math.min(
+      overallDeadlineAt,
+      ctx.startedAt + runAppearanceTimeout
+    ),
+    async onData(evaluations) {
+      const reading = readEvaluations(evaluations);
+      if (reading.kind === "runs")
+        return { kind: "done", result: { kind: "runs", runs: reading.runs } };
+      if (reading.kind === "not-tested") {
+        return {
+          kind: "done",
+          result: {
+            deploymentId,
+            outcome: "not-tested",
+            reason: reading.reason,
+            triggers: reading.triggers
+          }
+        };
+      }
+      knownRuns = reading.kind === "awaiting-run" ? reading.runs : knownRuns;
+      lastStage = reading.kind === "awaiting-run" ? {
+        matchedTriggerCount: reading.matchedTriggerCount,
+        stage: "waiting-for-run"
+      } : { stage: "waiting-for-evaluation" };
+      lastDescription = await reportStage(ctx, lastDescription, lastStage);
+      return { intervalMs: triggerPollInterval, kind: "continue" };
+    },
+    onDeadline() {
+      const now = clock.now();
+      if (knownRuns.length > 0 && now < overallDeadlineAt)
+        return { kind: "runs", runs: knownRuns };
+      return {
+        deploymentId,
+        elapsedMs: now - ctx.startedAt,
+        lastStage,
+        outcome: "timed-out",
+        runs: []
+      };
+    },
+    request: /* @__PURE__ */ __name(() => callPublicContract(ctx.deps, ctx.apiConfig, {
+      contract: publicContractsV12.deployment.listTriggerEvaluations,
+      input: { deploymentId }
+    }), "request")
+  });
+}
+__name(awaitRuns, "awaitRuns");
+
+// src/lib/sdk/domain/waitForVerdict/awaitVerdict.ts
+import { publicContractsV1 as publicContractsV13 } from "@qawolf/api-contracts";
+var settledStatuses = ["passed", "failed", "canceled"];
+function isSettled(run) {
+  return settledStatuses.includes(run.status);
+}
+__name(isSettled, "isSettled");
+function aggregateRuns(deploymentId, runs) {
+  if (runs.some((run) => run.status === "failed")) {
+    return {
+      blockingBugCount: runs.reduce(
+        (total, run) => total + run.blockingBugCount,
+        0
+      ),
+      deploymentId,
+      outcome: "failed",
+      runs
+    };
+  }
+  if (runs.some((run) => run.status === "canceled"))
+    return { deploymentId, outcome: "run-canceled", runs };
+  return { deploymentId, outcome: "passed", runs };
+}
+__name(aggregateRuns, "aggregateRuns");
+function keepOnePerRun(runs) {
+  return runs.filter(
+    (run, index) => runs.findIndex((other) => other.runId === run.runId) === index
+  );
+}
+__name(keepOnePerRun, "keepOnePerRun");
+async function requestRuns(ctx, matched) {
+  const answers = await Promise.all(
+    matched.map(async (run) => ({
+      result: await callPublicContract(ctx.deps, ctx.apiConfig, {
+        contract: publicContractsV13.run.get,
+        // A suite can hold hundreds of flows and the verdict reads none of
+        // them, so ask for the smallest list the contract allows.
+        input: { flowStatuses: ["failed"], runId: run.runId }
+      }),
+      triggerName: run.triggerName
+    }))
+  );
+  const failed = answers.find((answer) => answer.result.outcome !== "ok");
+  if (failed && failed.result.outcome !== "ok") return failed.result;
+  return {
+    data: keepOnePerRun(
+      answers.flatMap(
+        (answer) => answer.result.outcome === "ok" ? [
+          {
+            blockingBugCount: answer.result.data.blockingBugCount,
+            // The canonical id, which can name a run other than the one asked for.
+            runId: answer.result.data.runId,
+            runUrl: answer.result.data.url,
+            status: answer.result.data.status,
+            triggerName: answer.triggerName
+          }
+        ] : []
+      )
+    ),
+    outcome: "ok"
+  };
+}
+__name(requestRuns, "requestRuns");
+async function awaitVerdict(ctx, matched) {
+  const { deploymentId } = ctx;
+  let lastRuns = [];
+  let lastDescription = void 0;
+  return pollUntil(ctx, {
+    deadlineAt: ctx.startedAt + ctx.config.timeout,
+    async onData(runs) {
+      lastRuns = runs;
+      if (runs.every(isSettled))
+        return { kind: "done", result: aggregateRuns(deploymentId, runs) };
+      lastDescription = await reportStage(ctx, lastDescription, {
+        runs,
+        stage: "waiting-for-verdict"
+      });
+      return { intervalMs: ctx.config.runPollInterval, kind: "continue" };
+    },
+    onDeadline: /* @__PURE__ */ __name(() => ({
+      deploymentId,
+      elapsedMs: ctx.deps.clock.now() - ctx.startedAt,
+      lastStage: { runs: lastRuns, stage: "waiting-for-verdict" },
+      outcome: "timed-out",
+      runs: lastRuns
+    }), "onDeadline"),
+    request: /* @__PURE__ */ __name(() => requestRuns(ctx, matched), "request")
+  });
+}
+__name(awaitVerdict, "awaitVerdict");
+
+// src/lib/sdk/domain/waitForVerdict/consts.ts
+var waitForVerdictDefaults = {
+  maxRetries: 10,
+  retryInterval: 10 * 1e3,
+  runAppearanceTimeout: 5 * 60 * 1e3,
+  runPollInterval: 30 * 1e3,
+  timeout: 120 * 60 * 1e3,
+  triggerPollInterval: 3 * 1e3
+};
+
+// src/lib/sdk/domain/waitForVerdict/logVerdict.ts
+function runUrls(runs) {
+  return runs.map((run) => run.runUrl).join(" ");
+}
+__name(runUrls, "runUrls");
+function logVerdict(log, verdict) {
+  switch (verdict.outcome) {
+    case "canceled-by-caller":
+      return log.warn("\u{1F6AB} The wait was canceled before QA Wolf answered.");
+    case "failed":
+      return log.error(
+        `\u274C QA Wolf found ${verdict.blockingBugCount} blocking bug${pluralize(verdict.blockingBugCount)}. ${runUrls(verdict.runs)}`
+      );
+    case "not-tested": {
+      log.info(
+        verdict.reason === "no-trigger-matched" ? "\u26A0\uFE0F QA Wolf: nothing to test for this deployment." : "\u26A0\uFE0F QA Wolf: a trigger matched this deployment but started no run."
+      );
+      for (const trigger of verdict.triggers)
+        log.info(`   ${trigger.triggerName}: ${trigger.message}`);
+      return;
+    }
+    case "passed":
+      return log.info(`\u2705 QA Wolf gate: passed. ${runUrls(verdict.runs)}`);
+    case "run-canceled":
+      return log.error(
+        `\u{1F6AB} The run was canceled, so QA Wolf reached no verdict. ${runUrls(verdict.runs)}`
+      );
+    case "timed-out":
+      return log.error(
+        `\u{1F6AB} Gave up after ${Math.round(verdict.elapsedMs / 1e3)}s waiting for QA Wolf. ${runUrls(verdict.runs)}`
+      );
+    default:
+      return void 0;
+  }
+}
+__name(logVerdict, "logVerdict");
+
+// src/lib/sdk/domain/waitForVerdict/index.ts
+async function waitForVerdict(deps, apiConfig, {
+  deploymentId,
+  maxRetries = waitForVerdictDefaults.maxRetries,
+  onProgress,
+  retryInterval = waitForVerdictDefaults.retryInterval,
+  runAppearanceTimeout = waitForVerdictDefaults.runAppearanceTimeout,
+  runPollInterval = waitForVerdictDefaults.runPollInterval,
+  signal,
+  timeout = waitForVerdictDefaults.timeout,
+  triggerPollInterval = waitForVerdictDefaults.triggerPollInterval
+}) {
+  const ctx = {
+    apiConfig,
+    config: {
+      maxRetries,
+      onProgress,
+      retryInterval,
+      runAppearanceTimeout,
+      runPollInterval,
+      signal,
+      timeout,
+      triggerPollInterval
+    },
+    deploymentId,
+    deps,
+    startedAt: deps.clock.now()
+  };
+  const phase = await awaitRuns(ctx);
+  const verdict = "kind" in phase ? await awaitVerdict(ctx, phase.runs) : phase;
+  logVerdict(deps.log, verdict);
+  return verdict;
+}
+__name(waitForVerdict, "waitForVerdict");
+
 // src/lib/sdk/index.ts
 function makeQaWolfSdk({
   apiKey,
   serviceBase = defaultServiceBase,
   userAgent = defaultUserAgent
 }, {
+  clock = defaultClock,
   fetch = defaultFetch,
   log = defaultLogDriver
 } = {}) {
@@ -1127,6 +1753,7 @@ We recommend 'undici' package for that purpose. See the Requirement section of o
     );
   }
   const deps = {
+    clock,
     // Versions of fetch may have different default timeouts. For consistency, we explicitly set it to 2 minutes here.
     // The increased timeout helps avoid edge cases where we need to search for a commit against multiple
     // code hosting service repositories as a fallback when not finding the repository based on organization/name.
@@ -1135,7 +1762,15 @@ We recommend 'undici' package for that purpose. See the Requirement section of o
   };
   const apiConfig = { apiKey, serviceBase, userAgent };
   return {
+    /**
+     * @deprecated Reports through the legacy `deploy_success` webhook, which
+     * triggers do not see. Use `deployment.reportStatus` instead.
+     */
     attemptNotifyDeploy: attemptNotifyDeploy.bind(null, deps, apiConfig),
+    deployment: {
+      reportStatus: reportDeployment.bind(null, deps, apiConfig),
+      waitForVerdict: waitForVerdict.bind(null, deps, apiConfig)
+    },
     generateSignedUrlForRunInputsExecutablesStorage: generateSignedUrlForRunInputsExecutablesStorage.bind(
       null,
       deps,
@@ -1148,11 +1783,16 @@ We recommend 'undici' package for that purpose. See the Requirement section of o
       apiConfig
     ),
     notifyTerminatedEphemeralEnvironment: notifyTerminatedEphemeralEnvironment.bind(null, deps, apiConfig),
+    /**
+     * @deprecated Polls a run id that only `attemptNotifyDeploy` returns, so it
+     * keeps the pipeline on the legacy `deploy_success` webhook.
+     */
     pollCiGreenlightStatus: pollCiGreenlightStatus.bind(null, deps, apiConfig)
   };
 }
 __name(makeQaWolfSdk, "makeQaWolfSdk");
 export {
+  detectProviderDeploymentId,
   makeQaWolfSdk
 };
 //# sourceMappingURL=index.js.map