@deployanyway/ship-it-meter 0.3.0 → 1.0.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 1.0.0
+
+- Show Your Receipts: release policies from actual reports.
+- Typed API, CLI integration, runnable codebase example and meaningful workflow tests.
+- Stable contracts and migration guidance; original humor stays around accurate facts.
+
+## 0.4.0
+
+Twelve named demonstration scenarios show passing evidence, Friday releases, missing evidence, failed builds, failing tests, low coverage, critical issues, lint failures, dirty worktrees, feature branches, zero tests and weekend incidents. These are examples, never evidence about your real project.
+
+```sh
+
+
 ## 0.3.0 — 2026-10-08
 
 - Useful structured API/CLI additions described in README.
@@ -21,3 +34,4 @@
 
 - Deterministic readiness score with explanations and technical blocker caps.
 - CLI, documented scoring rules, tests, linting, formatting, and Node 22/24 CI.
+```

package/MIGRATION.md

@@ -3,3 +3,15 @@
 Node 22.13+ is required. Existing core APIs remain available; TypeScript declarations and CommonJS exports are new. The CLI now lives in src/cli.js behind the same executable path. Input/stdout behavior for new options is documented in README.
 
 Install 0.3.0 with npm. Seeds and exact humorous wording are version-specific. Do not treat jokes or heuristic scores as production evidence.
+
+## 0.3.0 to 0.4.0
+
+12 discoverable evidence scenarios and releasePlan with ordered blocker/review/release tasks and observable completion criteria; API and CLI scenarios/plans; passing/blocked gate exit codes preserved.
+
+Existing defaults and entry points remain available. The new release plan and demonstration scenarios are opt-in; the original scoring and gate rules are retained.
+
+## 0.4.0 to stable 1.0.0
+
+Report APIs and CLI receipt mode are additive. Existing supplied-evidence scoring remains a heuristic and named scenarios remain examples. Use report policies for actual CI gating; do not confuse demonstration scenarios with measured artifacts.
+
+See README for exact contracts, bounds and failure behavior.

package/README.md

@@ -1,6 +1,79 @@
 # ship-it-meter
 
-> **Version 0.3.0:** install from npm with Node 22.13+ or Node 24. See MIGRATION.md for changes from 0.2.0.
+## Show Your Receipts: release policies from actual reports (1.0.0)
+
+evaluateReports(bundle, policy) turns actual test, coverage and build receipts into a release gate and prioritized repair tasks. parseTestReport supports completed Node TAP v13 and Jest JSON. parseCoverageReport supports c8/Istanbul coverage-summary.json. Skipped/todo tests are excluded from executed evidence; failed/cancelled tests, unsuccessful Jest suites and collected-only/interrupted runs do not count as successful execution. Coverage counts must reconcile; empty lines/statements are not measured evidence.
+
+```js
+import { evaluateReports } from "@deployanyway/ship-it-meter";
+const result = evaluateReports(
+  {
+    commit: "abc123",
+    tests: {
+      commit: "abc123",
+      capturedAt: "2026-10-09T02:00:00Z",
+      format: "node-tap",
+      data: tapOutput,
+    },
+    coverage: {
+      commit: "abc123",
+      capturedAt: "2026-10-09T02:00:00Z",
+      format: "istanbul-summary",
+      data: coverageSummary,
+    },
+    build: {
+      commit: "abc123",
+      capturedAt: "2026-10-09T02:00:00Z",
+      exitCode: buildExitCode,
+    },
+  },
+  { minTests: 1, minCoverage: 80, minScore: 80, maxAgeMs: 3600000 },
+);
+if (!result.passed) console.error(result.blockers);
+```
+
+All three receipts are required, must identify the same nonempty bundle commit, and use valid UTC ISO capturedAt timestamps. Future/stale receipts block. Default policy: at least one executed test, all four coverage percentages >=80, passing build and score >=80, max age one hour. now can be supplied for deterministic evaluation. Unknown policy keys throw, so misspelled thresholds do not silently apply defaults. The policy is configurable; it does not alter your artifacts.
+
+Result adds evidence, receipts, commit, policy and evaluatedAt to a release plan. Each receipt exposes acceptance and issues; rejected receipts add blocker tasks with verification criteria. The final summary/passed value follows receipt blockers, even when the heuristic score looks good. Parse helpers throw on malformed reports; evaluateReports converts report problems into blockers. Invalid policy/bundle configuration throws.
+
+```sh
+ship-it-meter --report-file receipts.json --policy '{"minCoverage":90,"maxAgeMs":1800000}' --json
+cat receipts.json | ship-it-meter --reports --json
+node node_modules/@deployanyway/ship-it-meter/examples/report-gate.mjs receipts.json
+```
+
+Report CLI input is bounded to 10 MiB and exits 1 when blocked, 2 for invalid arguments/configuration. Receipt mode rejects manual evidence overrides and conflicting gate/scenario flags. The browser demo uses pure parsers; file reading and CI collection happen in Node. Metadata is a claim from your trusted pipeline, not a cryptographic attestation; do not relabel old reports or trust arbitrary submitted bundles. The gate neither runs your CI nor deploys anything. See examples/collect-receipts.mjs for collecting new Node test and c8 coverage reports together, followed by your actual npm build, inside an npm script. It requires c8 as a project dev dependency, Node-discoverable tests (or explicit test file arguments), npm run build, an unchanged Git commit and clean tracked source. Generated/untracked files must be excluded from your test configuration; receipt metadata remains a trusted pipeline claim.
+
+## Stable v1 contract
+
+Node 22.13+ or Node 24. MIT licensed. CLI flags, structured fields, ESM/CommonJS exports and declarations are covered by tests and installed-package checks. Existing 0.4 APIs remain available except the explicitly documented doggo-log redaction/text-context changes. Future incompatible public API changes require a major release; callers should consume structured fields rather than parse jokes. Exact humorous wording and seeded catalog choices are version-specific. No telemetry, external API keys or network service is needed for core use.
+
+Run npm test, npm run lint, npm run format:check, npm run coverage, npm run test:types and npm run verify:package from a source checkout. Runnable examples are shipped under examples/. The root demo is https://deployanyway.github.io/.
+
+## Evidence into an actual release plan (0.4.0)
+
+Twelve named demonstration scenarios show passing evidence, Friday releases, missing evidence, failed builds, failing tests, low coverage, critical issues, lint failures, dirty worktrees, feature branches, zero tests and weekend incidents. These are examples, never evidence about your real project.
+
+```sh
+npx @deployanyway/ship-it-meter --list-scenarios
+npx @deployanyway/ship-it-meter --scenario failed-build --plan
+npx @deployanyway/ship-it-meter --scenario ready --plan --json
+```
+
+```js
+import {
+  releasePlan,
+  releaseScenarios,
+  scenarioEvidence,
+} from "@deployanyway/ship-it-meter";
+console.log(releaseScenarios());
+const plan = releasePlan(scenarioEvidence("failing-tests"), { minScore: 80 });
+console.log(plan.passed, plan.summary, plan.tasks);
+```
+
+`releasePlan(evidence?, options?)` includes the existing gate plus prioritized tasks with stable IDs and observable verification criteria. Priorities are blocker, review and release. `scenarioEvidence(name)` and `releaseScenarios()` return independent evidence copies. CLI flags override scenario fields; stdin and scenario cannot be combined. Choose one of plan, gate or checklist. A blocked plan/gate exits 1; invalid input exits 2. Readiness remains a heuristic based on caller-supplied evidence; it does not run CI or approve deployment automatically. Coverage below 80 adds a review task, not a separate hard blocker; the configured score threshold and existing gate rules still decide the gate.
+
+> **Version 0.4.0:** install from npm with Node 22.13+ or Node 24. See MIGRATION.md for changes from 0.2.0.
 
 [![npm version](https://img.shields.io/npm/v/%40deployanyway%2Fship-it-meter)](https://www.npmjs.com/package/@deployanyway/ship-it-meter)
 [![CI](https://github.com/DeployAnyway/ship-it-meter/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/DeployAnyway/ship-it-meter/actions/workflows/ci.yml)

package/dist/index.cjs

@@ -20,11 +20,349 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.js
 var index_exports = {};
 __export(index_exports, {
+  evaluateReports: () => evaluateReports,
+  parseCoverageReport: () => parseCoverageReport,
+  parseTestReport: () => parseTestReport,
   preflight: () => preflight,
   releaseGate: () => releaseGate,
+  releasePlan: () => releasePlan,
+  releaseScenarios: () => releaseScenarios,
+  scenarioEvidence: () => scenarioEvidence,
   shipIt: () => shipIt
 });
 module.exports = __toCommonJS(index_exports);
+
+// src/scenarios.js
+var scenarios = {
+  ready: {
+    description: "Passing evidence, clean worktree and main branch. Boring is a compliment.",
+    evidence: {
+      tests: 125,
+      coverage: 96,
+      build: true,
+      branch: "main",
+      day: "tuesday"
+    }
+  },
+  friday: {
+    description: "Good evidence on Friday. Confirm rollback and on-call before the victory lap.",
+    evidence: {
+      tests: 125,
+      coverage: 92,
+      build: true,
+      branch: "main",
+      day: "friday"
+    }
+  },
+  "no-evidence": {
+    description: "Confidence is present. Test, coverage and build evidence have not arrived.",
+    evidence: {}
+  },
+  "failed-build": {
+    description: "The build is red. The deploy button is not a color correction tool.",
+    evidence: {
+      tests: 125,
+      coverage: 92,
+      build: false
+    }
+  },
+  "failing-tests": {
+    description: "Some tests fail. Green deployment lights will not repair assertions.",
+    evidence: {
+      tests: 125,
+      failingTests: 3,
+      coverage: 92,
+      build: true
+    }
+  },
+  "low-coverage": {
+    description: "A passing build with many untested paths. The bugs appreciate the privacy.",
+    evidence: {
+      tests: 125,
+      coverage: 45,
+      build: true
+    }
+  },
+  "critical-issue": {
+    description: "A critical issue blocks the gate even when everything else looks cheerful.",
+    evidence: {
+      tests: 125,
+      coverage: 96,
+      build: true,
+      criticalIssues: 1
+    }
+  },
+  "lint-failures": {
+    description: "Lint failures are still failures, however decorative the semicolons feel.",
+    evidence: {
+      tests: 125,
+      coverage: 96,
+      build: true,
+      lintFailures: 2
+    }
+  },
+  "dirty-worktree": {
+    description: "The laptop contains uncommitted changes. It is not the release archive.",
+    evidence: {
+      tests: 125,
+      coverage: 96,
+      build: true,
+      uncommittedChanges: true
+    }
+  },
+  "feature-branch": {
+    description: "Healthy evidence on a feature branch. Verify the intended release source.",
+    evidence: {
+      tests: 125,
+      coverage: 96,
+      build: true,
+      branch: "feature/zoomies"
+    }
+  },
+  "zero-tests": {
+    description: "No tests ran. Zero failures is an especially small achievement here.",
+    evidence: {
+      tests: 0,
+      coverage: 0,
+      build: true
+    }
+  },
+  "weekend-incident": {
+    description: "A failed build, failing tests and a critical issue. Bring evidence, not a bigger confidence hat.",
+    evidence: {
+      tests: 125,
+      failingTests: 12,
+      coverage: 60,
+      build: false,
+      criticalIssues: 1,
+      day: "saturday"
+    }
+  }
+};
+function releaseScenarios() {
+  return Object.entries(scenarios).map(([name, value]) => ({
+    name,
+    description: value.description,
+    evidence: { ...value.evidence }
+  }));
+}
+function scenarioEvidence(name) {
+  if (typeof name !== "string" || !Object.hasOwn(scenarios, name))
+    throw new RangeError(
+      "Unknown scenario. Choose: " + Object.keys(scenarios).join(", ")
+    );
+  return { ...scenarios[name].evidence };
+}
+
+// src/reports.js
+var object = (value, label) => {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new TypeError(`${label} must be an object.`);
+  return value;
+};
+var count = (value, label) => {
+  if (!Number.isSafeInteger(value) || value < 0)
+    throw new TypeError(`${label} must be a nonnegative safe integer.`);
+  return value;
+};
+var json = (value) => typeof value === "string" ? JSON.parse(value) : value;
+var date = (value, label) => {
+  if (typeof value !== "string" || !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d{1,3})?Z$/.test(value) || !Number.isFinite(Date.parse(value)) || new Date(value).toISOString().slice(0, 19) !== value.slice(0, 19))
+    throw new TypeError(`${label} must be a UTC ISO timestamp.`);
+  return Date.parse(value);
+};
+function parseTestReport(data, format = "node-tap") {
+  if (format === "node-tap") {
+    if (typeof data !== "string" || !data.startsWith("TAP version 13") || /^Bail out!/m.test(data))
+      throw new TypeError("Expected a completed Node TAP v13 report.");
+    const values = {};
+    for (const key of [
+      "tests",
+      "pass",
+      "fail",
+      "cancelled",
+      "skipped",
+      "todo"
+    ]) {
+      const matches = [
+        ...data.matchAll(new RegExp(`^# ${key} (\\d+)\\r?$`, "gm"))
+      ];
+      if (matches.length !== 1)
+        throw new TypeError(`TAP requires one ${key} summary.`);
+      values[key] = count(Number(matches[0][1]), key);
+    }
+    if (values.pass + values.fail + values.cancelled + values.skipped + values.todo !== values.tests)
+      throw new TypeError("TAP counts do not reconcile.");
+    return {
+      tests: values.tests - values.skipped - values.todo,
+      passedTests: values.pass,
+      failingTests: values.fail + values.cancelled,
+      skippedTests: values.skipped,
+      todoTests: values.todo,
+      successful: values.fail + values.cancelled === 0
+    };
+  }
+  if (format === "jest") {
+    const report = object(json(data), "Jest report");
+    const total = count(report.numTotalTests, "numTotalTests"), passed = count(report.numPassedTests, "numPassedTests"), failed = count(report.numFailedTests, "numFailedTests"), pending = count(report.numPendingTests, "numPendingTests"), todo = count(report.numTodoTests ?? 0, "numTodoTests");
+    if (total !== passed + failed + pending + todo || typeof report.success !== "boolean")
+      throw new TypeError("Jest counts/success do not reconcile.");
+    if (report.wasInterrupted || report.testResults?.some(
+      (result) => result.assertionResults?.some(
+        (assertion) => assertion.wouldRun === true
+      )
+    ))
+      throw new TypeError(
+        "Interrupted or collected-only Jest output is not executed evidence."
+      );
+    const failedSuites = count(
+      report.numFailedTestSuites ?? 0,
+      "numFailedTestSuites"
+    );
+    return {
+      tests: total - pending - todo,
+      passedTests: passed,
+      failingTests: failed,
+      skippedTests: pending,
+      todoTests: todo,
+      successful: report.success && failed === 0 && failedSuites === 0
+    };
+  }
+  throw new RangeError("Supported test formats: node-tap, jest.");
+}
+function parseCoverageReport(data) {
+  const total = object(
+    object(json(data), "Coverage report").total,
+    "Coverage total"
+  ), result = {};
+  for (const key of ["lines", "statements", "functions", "branches"]) {
+    const metric = object(total[key], `Coverage ${key}`), all = count(metric.total, `${key}.total`), covered = count(metric.covered, `${key}.covered`);
+    if (all === 0 && ["lines", "statements"].includes(key) || covered > all || typeof metric.pct !== "number" || !Number.isFinite(metric.pct) || metric.pct < 0 || metric.pct > 100)
+      throw new TypeError(
+        `Coverage ${key} must contain measured code and a percentage.`
+      );
+    const computed = all === 0 ? 100 : covered / all * 100;
+    if (Math.abs(computed - metric.pct) > 0.02)
+      throw new TypeError(`Coverage ${key} percentage disagrees with counts.`);
+    result[key] = metric.pct;
+  }
+  return result;
+}
+function evaluateReports(bundle, options = {}) {
+  object(bundle, "Report bundle");
+  object(options, "Policy");
+  for (const key of Object.keys(options))
+    if (!["minTests", "minCoverage", "minScore", "maxAgeMs", "now"].includes(key))
+      throw new TypeError(`Unknown policy option: ${key}.`);
+  if (typeof bundle.commit !== "string" || !bundle.commit.trim())
+    throw new TypeError("Report bundle requires a nonempty commit.");
+  const policy = {
+    minTests: 1,
+    minCoverage: 80,
+    minScore: 80,
+    maxAgeMs: 36e5,
+    ...options
+  };
+  for (const [key, value] of Object.entries({
+    minTests: 1,
+    minCoverage: 80,
+    minScore: 80,
+    maxAgeMs: 36e5
+  }))
+    if (policy[key] === void 0) policy[key] = value;
+  count(policy.minTests, "minTests");
+  if (policy.minTests < 1) throw new RangeError("minTests must be positive.");
+  for (const key of ["minCoverage", "minScore"])
+    if (typeof policy[key] !== "number" || !Number.isFinite(policy[key]) || policy[key] < 0 || policy[key] > 100)
+      throw new RangeError(`${key} must be from 0 to 100.`);
+  if (!Number.isSafeInteger(policy.maxAgeMs) || policy.maxAgeMs < 1)
+    throw new RangeError("maxAgeMs must be a positive safe integer.");
+  const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const nowMs = date(now, "now");
+  const evidence = {}, receipts = [], blockers = [];
+  for (const kind of ["tests", "coverage", "build"]) {
+    const issues = [], report = bundle[kind];
+    if (!report) {
+      issues.push(`${kind}: report is missing.`);
+    } else
+      try {
+        object(report, kind);
+        const captured = date(report.capturedAt, `${kind}.capturedAt`);
+        if (report.commit !== bundle.commit)
+          issues.push(`${kind}: commit does not match ${bundle.commit}.`);
+        if (captured > nowMs)
+          issues.push(`${kind}: timestamp is in the future.`);
+        if (nowMs - captured > policy.maxAgeMs)
+          issues.push(`${kind}: report is stale.`);
+        if (kind === "tests") {
+          if (!["node-tap", "jest"].includes(report.format))
+            throw new RangeError("Test format must be node-tap or jest.");
+          const parsed = parseTestReport(report.data, report.format);
+          evidence.tests = parsed.tests;
+          evidence.failingTests = parsed.failingTests;
+          if (!parsed.successful)
+            issues.push("tests: test execution was unsuccessful.");
+          if (parsed.tests < policy.minTests)
+            issues.push(
+              `tests: ${parsed.tests} executed tests is below ${policy.minTests}.`
+            );
+        } else if (kind === "coverage") {
+          if (report.format !== "istanbul-summary")
+            throw new RangeError("Coverage format must be istanbul-summary.");
+          const coverage = parseCoverageReport(report.data);
+          evidence.coverage = coverage.lines;
+          for (const [metric, value] of Object.entries(coverage))
+            if (value < policy.minCoverage)
+              issues.push(
+                `coverage: ${metric} ${value}% is below ${policy.minCoverage}%.`
+              );
+        } else {
+          count(report.exitCode, "build.exitCode");
+          evidence.build = report.exitCode === 0;
+          if (report.exitCode !== 0)
+            issues.push(`build: command exited ${report.exitCode}.`);
+        }
+      } catch (error) {
+        issues.push(`${kind}: ${error.message}`);
+      }
+    receipts.push({
+      kind,
+      format: kind === "build" ? "exit-code" : report?.format ?? "missing",
+      commit: typeof report?.commit === "string" ? report.commit : null,
+      capturedAt: typeof report?.capturedAt === "string" ? report.capturedAt : null,
+      accepted: issues.length === 0,
+      issues
+    });
+    blockers.push(...issues);
+  }
+  const plan = releasePlan(evidence, { minScore: policy.minScore });
+  const combined = [.../* @__PURE__ */ new Set([...blockers, ...plan.blockers])];
+  const receiptTasks = receipts.filter((item) => !item.accepted).map((item) => ({
+    id: "receipt-" + item.kind,
+    priority: "blocker",
+    title: "Repair " + item.kind + " evidence",
+    verify: `Generate a completed ${item.kind} report for ${bundle.commit} with a current UTC timestamp; resolve: ${item.issues.join(" ")}`
+  }));
+  return {
+    ...plan,
+    summary: combined.length ? "The receipts say stop. Confidence must wait." : plan.summary,
+    tasks: [...receiptTasks, ...plan.tasks],
+    passed: combined.length === 0,
+    blockers: combined,
+    evidence,
+    receipts,
+    commit: bundle.commit,
+    policy: {
+      minTests: policy.minTests,
+      minCoverage: policy.minCoverage,
+      minScore: policy.minScore,
+      maxAgeMs: policy.maxAgeMs
+    },
+    evaluatedAt: now
+  };
+}
+
+// src/index.js
 var days = [
   "monday",
   "tuesday",
@@ -175,9 +513,119 @@ function preflight(input = {}) {
     );
   return { ...result, actions };
 }
+function releasePlan(input = {}, options = {}) {
+  const gate = releaseGate(input, options);
+  const tasks = [];
+  const add = (id, priority, title, verify) => tasks.push({ id, priority, title, verify });
+  if (input.build !== true)
+    add(
+      "build",
+      "blocker",
+      "Get a passing build",
+      "Run the release build for the exact commit and record its successful result."
+    );
+  if (!input.tests)
+    add(
+      "tests",
+      "blocker",
+      "Run a nonempty test suite",
+      "Record the test count and outcome for the release commit."
+    );
+  if (input.failingTests)
+    add(
+      "failing-tests",
+      "blocker",
+      "Repair failing tests",
+      "Reproduce each failure, fix its cause and rerun the suite."
+    );
+  if (input.coverage === void 0)
+    add(
+      "coverage-evidence",
+      "blocker",
+      "Measure coverage",
+      "Generate coverage for the release commit and record the percentage."
+    );
+  else if (input.coverage < 80)
+    add(
+      "coverage-review",
+      "review",
+      "Review untested paths",
+      "Inspect uncovered critical paths and add meaningful tests where needed."
+    );
+  if (input.criticalIssues)
+    add(
+      "critical-issues",
+      "blocker",
+      "Resolve critical issues",
+      "Record the resolution and verify the affected behavior."
+    );
+  if (input.lintFailures)
+    add(
+      "lint",
+      "blocker",
+      "Fix lint failures",
+      "Run the configured lint checks successfully."
+    );
+  if (input.uncommittedChanges)
+    add(
+      "worktree",
+      "blocker",
+      "Reconcile local changes",
+      "Commit or stash intentionally and verify the exact release source."
+    );
+  if (input.branch && !["main", "master"].includes(input.branch.trim()))
+    add(
+      "branch",
+      "review",
+      "Confirm release branch",
+      "Verify that this branch is the intended release source and that its CI passed."
+    );
+  if (input.day?.trim().toLowerCase() === "friday")
+    add(
+      "friday",
+      "review",
+      "Confirm weekend support",
+      "Identify monitoring ownership and a tested rollback path."
+    );
+  if (gate.score < gate.minScore)
+    add(
+      "score",
+      "blocker",
+      "Improve evidence to the configured threshold",
+      "Address score deductions, rerun the checks and reevaluate the gate."
+    );
+  add(
+    "rollback",
+    "release",
+    "Prepare the return route",
+    "Verify the rollback artifact and procedure before deployment."
+  );
+  add(
+    "monitoring",
+    "release",
+    "Watch the actual release",
+    "Check health and error metrics after deployment and name an owner."
+  );
+  const summaries = {
+    "Absolutely Not": "The evidence says stop. The confidence hat can wait.",
+    Questionable: "The release has questions. Answer them before adding confetti.",
+    "Probably Fine": "Close is a useful direction, not a deployment receipt.",
+    "Ship It": "Good evidence. Keep the parachute and watch the landing.",
+    "Suspiciously Ready": "Boring, verified readiness. Give the checks their share of the applause."
+  };
+  const rank = { blocker: 0, review: 1, release: 2 };
+  tasks.sort((a, b) => rank[a.priority] - rank[b.priority]);
+  return { ...gate, summary: summaries[gate.verdict], tasks };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  evaluateReports,
+  parseCoverageReport,
+  parseTestReport,
   preflight,
   releaseGate,
+  releasePlan,
+  releaseScenarios,
+  scenarioEvidence,
   shipIt
 });

package/examples/basic.js

@@ -0,0 +1,12 @@
+import { shipIt } from "@deployanyway/ship-it-meter";
+
+console.log(
+  shipIt({
+    tests: 125,
+    failingTests: 2,
+    coverage: 82,
+    day: "Friday",
+    branch: "main",
+    build: true,
+  }),
+);

package/examples/collect-receipts.mjs

@@ -0,0 +1,85 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync, writeFileSync, mkdtempSync, rmSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { evaluateReports } from "@deployanyway/ship-it-meter";
+// Configure in your project: "release:receipts": "node node_modules/@deployanyway/ship-it-meter/examples/collect-receipts.mjs"
+// Requires your project's c8 dev dependency, Node tests using Node test discovery, and npm run build.
+const run = (args) =>
+  spawnSync(process.execPath, args, {
+    encoding: "utf8",
+    maxBuffer: 10 * 1024 * 1024,
+  });
+const git = (args) => spawnSync("git", args, { encoding: "utf8" });
+let temp;
+try {
+  if (!process.env.npm_execpath)
+    throw new Error(
+      "Run through an npm script so the build uses the current npm CLI.",
+    );
+  const head = git(["rev-parse", "HEAD"]);
+  if (head.status !== 0)
+    throw new Error("Cannot identify the exact Git commit.");
+  const commit = head.stdout.trim();
+  const clean = () => {
+    const status = git(["status", "--porcelain", "--untracked-files=no"]);
+    if (status.status !== 0 || status.stdout.trim())
+      throw new Error(
+        "Tracked source changes must be committed before collecting receipts.",
+      );
+  };
+  clean();
+  temp = mkdtempSync(join(tmpdir(), "deployanyway-receipts-"));
+  const tests = run([
+    resolve("node_modules/c8/bin/c8.js"),
+    "--reporter=json-summary",
+    "--reports-dir",
+    temp,
+    "--temp-directory",
+    join(temp, "v8"),
+    process.execPath,
+    "--test",
+    "--test-reporter=tap",
+    ...process.argv.slice(2),
+  ]);
+  if (tests.error) throw tests.error;
+  const testTime = new Date().toISOString(),
+    coverage = JSON.parse(
+      readFileSync(join(temp, "coverage-summary.json"), "utf8"),
+    );
+  const build = run([process.env.npm_execpath, "run", "build"]);
+  if (build.error) throw build.error;
+  const after = git(["rev-parse", "HEAD"]);
+  if (after.status !== 0 || after.stdout.trim() !== commit)
+    throw new Error("Commit changed during collection.");
+  clean();
+  const bundle = {
+    commit,
+    tests: {
+      commit,
+      capturedAt: testTime,
+      format: "node-tap",
+      data: tests.stdout,
+    },
+    coverage: {
+      commit,
+      capturedAt: testTime,
+      format: "istanbul-summary",
+      data: coverage,
+    },
+    build: {
+      commit,
+      capturedAt: new Date().toISOString(),
+      exitCode: build.status,
+    },
+  };
+  writeFileSync("receipts.json", JSON.stringify(bundle, null, 2));
+  const result = evaluateReports(bundle);
+  console.log(JSON.stringify(result, null, 2));
+  process.exitCode = result.passed ? 0 : 1;
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 2;
+} finally {
+  if (temp) rmSync(temp, { recursive: true, force: true });
+}