@bluewombat/slots 0.10.0 → 0.11.1

package/gates/feature-tests.mjs

@@ -0,0 +1,280 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import {
+  emitVerdict,
+  GATE_FLAGS,
+  ownArgv,
+  parseOptions,
+  take,
+  textOption,
+} from "@bluewombat/slot-kit";
+import { parseJunit, scenarioOf } from "../lib/junit.mjs";
+import { createOutputTail } from "../lib/output-tail.mjs";
+
+// The tests of a Feature, run on the assembled Feature line: does the Feature do what the
+// operator agreed it should? Only the scenarios of this Feature run, not the Project's whole suite.
+//
+// Nothing here knows a stack. The Project supplies one command, run in the workspace through the
+// shell, and the Gate owns the rest: running, comparing.
+//
+// --run COMMAND (required): runs the tests of the Feature and writes a JUnit XML report. `{ids}`
+//   stands for the scenario ids of the manifest joined with "|" (a regular expression:
+//   `pnpm test --grep "{ids}"`), `{junit}` for the path the report must be written to.
+// --manifest PATH: the scenarios of the Feature. Default feature-tests/scenarios.json: a JSON
+//   array of ids, or { "scenarios": [ "S1" | { "id": "S1", "title": "…" } ] }.
+// --junit PATH: where --run writes its report. Default feature-tests/results/junit.xml. Removed
+//   before the run.
+// --max-run-ms N: the most the whole Gate may take. Default 600000 (10 minutes), and never more
+//   than the Gate's own ceiling.
+//
+// A scenario is a manifest id; each test carries its id in its name. The comparison is exact: an
+// id with no test, a test with no id, or a test the runner skipped is a failure.
+//
+// Verdicts: pass; fail-retryable for a red run (a wrong test is its author's to fix, a wrong
+// application the producer's: what the caller does with the report is its own rule); fail-blocking for what no change to the application fixes: a missing manifest,
+// a run that writes no report or outlives its ceiling.
+
+const cwd = process.cwd();
+const KEEP_BYTES = 12_000;
+const MARGIN_MS = 5_000;
+const MIN_PHASE_MS = 1_000;
+const REPORT_CHARS = 8_000;
+
+const parsed = parseOptions(
+  ownArgv(process.argv, GATE_FLAGS),
+  {
+    "--run": {},
+    "--manifest": { fallback: "feature-tests/scenarios.json" },
+    "--junit": { fallback: "feature-tests/results/junit.xml" },
+    "--max-run-ms": { fallback: "600000" },
+  },
+  "feature-tests",
+);
+if (!parsed.ok) {
+  emitVerdict("fail-blocking", parsed.reason);
+  process.exit(0);
+}
+const runTemplate = textOption(parsed.values, "run");
+if (runTemplate === undefined || runTemplate.trim().length === 0) {
+  emitVerdict(
+    "fail-blocking",
+    'feature-tests needs --run "<command>". The Project supplies the command that runs the tests.',
+  );
+  process.exit(0);
+}
+const maxRunMs = positive(textOption(parsed.values, "maxRunMs"));
+if (maxRunMs === undefined) {
+  emitVerdict("fail-blocking", "feature-tests: --max-run-ms takes a positive integer.");
+  process.exit(0);
+}
+const manifestPath = inWorkspace(textOption(parsed.values, "manifest") ?? "");
+const junitPath = inWorkspace(textOption(parsed.values, "junit") ?? "");
+
+const manifest = readManifest();
+if (typeof manifest === "string") {
+  emitVerdict("fail-blocking", manifest);
+  process.exit(0);
+}
+// Typed apart from the early exit above: the functions below are hoisted, and a narrowing does not reach them.
+/** @type {string[]} */
+const ids = manifest;
+
+const ceilingMs = Number(take(process.argv, "--timeout-ms"));
+const budgetMs =
+  Number.isFinite(ceilingMs) && ceilingMs > 0
+    ? Math.min(maxRunMs, Math.max(MIN_PHASE_MS, ceilingMs - MARGIN_MS))
+    : maxRunMs;
+
+const [verdict, report] = await judge();
+emitVerdict(/** @type {"pass" | "fail-retryable" | "fail-blocking"} */ (verdict), report);
+process.exit(0);
+
+/** @returns {Promise<[string, string]>} */
+async function judge() {
+  rmSync(junitPath, { force: true });
+  const command = runTemplate?.replaceAll("{ids}", ids.join("|")).replaceAll("{junit}", junitPath);
+  const run = await runShell(/** @type {string} */ (command), budgetMs);
+  if (run.timedOut) {
+    return ["fail-blocking", timeoutReport(run.output)];
+  }
+  const results = readResults();
+  if (typeof results === "string") {
+    return run.code === 0
+      ? ["fail-blocking", results]
+      : ["fail-retryable", `${results}\n${exitLine(run)} End of its output:\n${run.output}`];
+  }
+  const failing = failingOf(results);
+  if (failing.length > 0) {
+    return ["fail-retryable", redReport(results, failing)];
+  }
+  const foreign = results.cases.filter((c) => scenarioOf(c.name, ids) === undefined);
+  if (foreign.length > 0) {
+    return [
+      "fail-retryable",
+      [
+        `feature-tests: ${foreign.length} test(s) carry no scenario id of the manifest (${ids.join(", ")}): only the scenarios of the Feature run.`,
+        ...foreign.map((c) => `  ${c.name}`),
+        "Every test names its scenario id, and --run must run the ids of the manifest only ({ids}).",
+      ].join("\n"),
+    ];
+  }
+  return [
+    "pass",
+    `feature-tests: ${ids.length} scenario(s) of the feature ran and passed: ${ids.join(", ")}.`,
+  ];
+}
+
+/**
+ * @typedef {{ cases: import("../lib/junit.mjs").TestCase[] }} Result
+ */
+
+/** @returns {Result | string} */
+function readResults() {
+  if (!existsSync(junitPath)) {
+    return `The run wrote no JUnit report at ${junitPath}. --run must write one there ({junit}).`;
+  }
+  const cases = parseJunit(readFileSync(junitPath, "utf8"));
+  if (cases.length === 0) {
+    return `The JUnit report at ${junitPath} holds no test case.`;
+  }
+  return { cases };
+}
+
+/** The scenario ids that are not a pass: failed, skipped, or never run. */
+function failingOf(/** @type {Result} */ results) {
+  return ids.filter((id) => {
+    const mine = results.cases.filter((c) => scenarioOf(c.name, ids) === id);
+    return mine.length === 0 || mine.some((c) => c.status !== "passed");
+  });
+}
+
+function redReport(/** @type {Result} */ results, /** @type {string[]} */ failing) {
+  const lines = [
+    `feature-tests: ${failing.length} of ${ids.length} scenario(s) failed on the assembled feature: ${failing.join(", ")}.`,
+  ];
+  for (const id of failing) {
+    const mine = results.cases.filter((c) => scenarioOf(c.name, ids) === id);
+    if (mine.length === 0) {
+      lines.push(`${id} — no test ran for it.`);
+      continue;
+    }
+    for (const c of mine.filter((m) => m.status !== "passed")) {
+      lines.push(`${id} — ${c.name}`);
+      if (c.status === "skipped") {
+        lines.push("  skipped: a skipped scenario is not a passing one.");
+        continue;
+      }
+      lines.push(`  at: ${firstFrame(c.detail) ?? "(no step given)"}`);
+      lines.push(`  message: ${c.message.slice(0, 600)}`);
+    }
+  }
+  lines.push(`Report: ${junitPath}.`);
+  const text = lines.join("\n");
+  return text.length <= REPORT_CHARS ? text : `${text.slice(0, REPORT_CHARS)}\n…`;
+}
+
+/** The first stack line that is the test's own, where a step failed. */
+function firstFrame(/** @type {string} */ detail) {
+  return detail
+    .split("\n")
+    .map((line) => line.trim())
+    .find((line) => /^at\s|\.(spec|test)\.[cm]?[jt]sx?:\d+/.test(line));
+}
+
+/**
+ * @param {string} command
+ * @param {number} limitMs
+ * @returns {Promise<{ code: number | null, signal: string | null, timedOut: boolean, output: string }>}
+ */
+function runShell(command, limitMs) {
+  return new Promise((done) => {
+    const child = spawn("sh", ["-c", command], {
+      cwd,
+      env: { ...process.env, CI: "true", NO_COLOR: "1", FORCE_COLOR: "0" },
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    const tail = createOutputTail(KEEP_BYTES);
+    child.stdout.on("data", (chunk) => tail.push("stdout", chunk));
+    child.stderr.on("data", (chunk) => tail.push("stderr", chunk));
+    let timedOut = false;
+    const timer = globalThis.setTimeout(
+      () => {
+        timedOut = true;
+        killGroup(child);
+      },
+      Math.max(MIN_PHASE_MS, limitMs),
+    );
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      done({ code: 127, signal: null, timedOut: false, output: `cannot start: ${error.message}` });
+    });
+    child.on("close", (code, signal) => {
+      clearTimeout(timer);
+      done({ code, signal, timedOut, output: tail.text() });
+    });
+  });
+}
+
+/** @param {import("node:child_process").ChildProcess} child */
+function killGroup(child) {
+  try {
+    if (child.pid !== undefined) {
+      process.kill(-child.pid, "SIGKILL");
+    }
+  } catch {
+    child.kill("SIGKILL");
+  }
+}
+
+function timeoutReport(/** @type {string} */ output) {
+  return [
+    `The run did not finish within the ${Math.round(budgetMs / 1000)}s this Gate may take, and was stopped.`,
+    "A person decides: the tests hang.",
+    output.length > 0 ? `Last output:\n${output}` : "It printed nothing.",
+  ].join("\n");
+}
+
+function exitLine(/** @type {{ code: number | null, signal: string | null }} */ run) {
+  return run.signal === null ? `The run exited ${run.code}.` : `The run got ${run.signal}.`;
+}
+
+/** @returns {string[] | string} The ids, or why the manifest is not usable. */
+function readManifest() {
+  if (!existsSync(manifestPath)) {
+    return `The scenarios manifest ${manifestPath} does not exist. The feature-test Ticket writes it: one id per scenario.`;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(manifestPath, "utf8"));
+  } catch (error) {
+    return `The scenarios manifest ${manifestPath} is not JSON: ${error instanceof Error ? error.message : error}`;
+  }
+  const list = Array.isArray(raw) ? raw : raw?.scenarios;
+  if (!Array.isArray(list)) {
+    return `The scenarios manifest ${manifestPath} must be an array of ids, or { "scenarios": [...] }.`;
+  }
+  const found = list.map((entry) => (typeof entry === "string" ? entry : entry?.id));
+  if (found.some((id) => typeof id !== "string" || id.trim().length === 0)) {
+    return `Every scenario of ${manifestPath} needs a non-empty id.`;
+  }
+  const unique = [...new Set(found.map((id) => id.trim()))];
+  if (unique.length !== found.length) {
+    return `The scenarios manifest ${manifestPath} lists an id twice.`;
+  }
+  if (unique.length === 0) {
+    return `The scenarios manifest ${manifestPath} lists no scenario: there is nothing to prove.`;
+  }
+  return unique;
+}
+
+function positive(/** @type {string | undefined} */ text) {
+  const value = Number(text);
+  return Number.isInteger(value) && value > 0 ? value : undefined;
+}
+
+function inWorkspace(/** @type {string} */ path) {
+  return isAbsolute(path) ? path : resolve(cwd, path);
+}

package/gates/parent-clean.mjs

@@ -5,11 +5,17 @@ import { join, relative, resolve } from "node:path";
 import { emitVerdict, GATE_FLAGS, ownArgv } from "@bluewombat/slot-kit";
 
 // Parent working files must not change during the Attempt.
-// --parent DIR (repeatable). Other git worktrees of this Child are included.
+// --parent DIR (repeatable): always watched.
+// The main worktree of this Child's repository is watched too. Its other linked
+// worktrees are sibling Children (parallel tickets, escalated leftovers): they are
+// legitimately dirty, so they are ignored unless --siblings is given.
+// A watched git tree only counts files modified after this Child was created, so
+// work that was already there (a human's uncommitted edit) is not a leak.
 
 const cwd = resolve(process.cwd());
 const tokens = ownArgv(process.argv, GATE_FLAGS);
 const named = [];
+let withSiblings = false;
 
 for (let i = 0; i < tokens.length; i++) {
   const token = tokens[i];
@@ -23,12 +29,19 @@ for (let i = 0; i < tokens.length; i++) {
     i += 1;
     continue;
   }
-  emitVerdict("fail-blocking", `parent-clean does not take "${token}". Use --parent <dir>.`);
+  if (token === "--siblings") {
+    withSiblings = true;
+    continue;
+  }
+  emitVerdict(
+    "fail-blocking",
+    `parent-clean does not take "${token}". Use --parent <dir> or --siblings.`,
+  );
   process.exit(0);
 }
 
 const parents = [...named];
-for (const worktree of otherWorktrees(cwd)) {
+for (const worktree of otherWorktrees(cwd, withSiblings)) {
   if (!parents.includes(worktree)) {
     parents.push(worktree);
   }
@@ -67,15 +80,22 @@ if (leaked.length > 0) {
 
 emitVerdict("pass");
 
-/** Other worktrees of this repository, minus the ones git has marked prunable. */
-/** @param {string} workspace @returns {string[]} */
-function otherWorktrees(workspace) {
+/**
+ * The main worktree of this repository (git lists it first), plus the other linked
+ * worktrees when `siblings` is set. Worktrees git has marked prunable are left out.
+ */
+/** @param {string} workspace @param {boolean} siblings @returns {string[]} */
+function otherWorktrees(workspace, siblings) {
   const result = git(workspace, ["worktree", "list", "--porcelain"]);
   if (result.status !== 0) {
     return [];
   }
   const trees = [];
-  for (const record of result.stdout.split("\n\n")) {
+  const records = result.stdout.split("\n\n");
+  for (const [index, record] of records.entries()) {
+    if (index > 0 && !siblings) {
+      break;
+    }
     const lines = record.split("\n");
     const entry = lines.find((line) => line.startsWith("worktree "));
     if (entry === undefined || lines.some((line) => line.startsWith("prunable"))) {
@@ -100,10 +120,12 @@ function leaksIn(parent, workspace) {
     if (status.status !== 0) {
       return [`${parent}: git status failed`];
     }
+    const referenceMs = referenceTime(workspace);
     const lines = status.stdout
       .split("\n")
       .map((line) => line.trimEnd())
-      .filter(Boolean);
+      .filter(Boolean)
+      .filter((line) => !untouchedSince(parent, line, referenceMs));
     return lines.map((line) => `${relative(workspace, parent) || parent}: ${line}`);
   }
   const referenceMs = referenceTime(workspace);
@@ -117,6 +139,22 @@ function leaksIn(parent, workspace) {
   return dirty;
 }
 
+/**
+ * A status line whose file still exists and was last written before the Child was
+ * created is older than the Attempt. A deletion has no date and always counts.
+ * @param {string} parent
+ * @param {string} line
+ * @param {number} referenceMs
+ */
+function untouchedSince(parent, line, referenceMs) {
+  const path = line.slice(3).split(" -> ").at(-1) ?? "";
+  try {
+    return statSync(join(parent, path.replace(/^"|"$/g, ""))).mtimeMs <= referenceMs;
+  } catch {
+    return false;
+  }
+}
+
 /** @param {string} workspace */
 function referenceTime(workspace) {
   const gitFile = join(workspace, ".git");

package/gates/tests-only.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { emitVerdict, GATE_FLAGS, ownArgv, pathMatchesGlob } from "@bluewombat/slot-kit";
+
+// Fail-retryable when the workspace changed a path that matches none of the globs: the one place
+// the workspace may be written is what the globs name (the tests and their manifest). The other
+// side of `sensitive-path`, which names what may not be touched; a Project whose tests sit among its
+// code (`**/*.test.ts` in every package) cannot say "everything but" with globs that only deny.
+// Remaining argv after Implementer's flags are the globs.
+//
+// What counts is what a fold can carry: tracked paths that differ from HEAD (added, modified,
+// deleted, renamed) and new paths .gitignore does not exclude.
+
+const cwd = process.cwd();
+const globs = ownArgv(process.argv, GATE_FLAGS).filter((token) => token.length > 0);
+
+if (globs.length === 0) {
+  emitVerdict("fail-blocking", "tests-only needs at least one glob.");
+  process.exit(0);
+}
+
+const status = spawnSync(
+  "git",
+  ["-C", cwd, "status", "--porcelain=v1", "-z", "--untracked-files=all"],
+  {
+    encoding: "utf8",
+  },
+);
+if (status.status !== 0) {
+  emitVerdict("fail-blocking", `tests-only needs a git workspace: ${status.stderr.trim()}`);
+  process.exit(0);
+}
+
+/** @type {Set<string>} */
+const changed = new Set();
+const fields = status.stdout.split("\0");
+for (let i = 0; i < fields.length; i++) {
+  const entry = fields[i] ?? "";
+  if (entry.length < 4) {
+    continue;
+  }
+  changed.add(entry.slice(3));
+  // A rename or a copy carries the old path in the next field.
+  if (entry[0] === "R" || entry[0] === "C") {
+    const old = fields[++i];
+    if (old !== undefined && old.length > 0) {
+      changed.add(old);
+    }
+  }
+}
+
+const outside = [...changed]
+  .map((path) => path.replaceAll("\\", "/"))
+  .filter((path) => !globs.some((glob) => pathMatchesGlob(path, glob)))
+  .sort();
+
+if (outside.length > 0) {
+  emitVerdict(
+    "fail-retryable",
+    `Paths changed that are not tests or their manifest (${globs.join(", ")}):\n${outside.join("\n")}`,
+  );
+  process.exit(0);
+}
+
+emitVerdict("pass");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bluewombat/slots",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "type": "module",
   "description": "Shipped mason slots: Builders, Gates, publishers, and refreshers a Project names in its config.",
   "keywords": [
@@ -52,7 +52,7 @@
     "test": "tsx --test $(find test -name '*.test.ts')"
   },
   "dependencies": {
-    "@bluewombat/slot-kit": "^0.10.0",
+    "@bluewombat/slot-kit": "^0.11.1",
     "@pinkpuma/deck": "1.1.0"
   }
 }

package/publishers/git.mjs

@@ -14,18 +14,29 @@ import {
 // Put the ticket's work where the Authority can read it, by pushing the name
 // Isolator gave it to the work line's own remote.
 //
-// A plain push, and no force of any kind. Integrator only ever adds history, so
-// republishing after a refusal is a fast-forward of what was already there. A
-// rejection therefore means the name moved under us — someone else's commit, or
-// a rewrite — and that is exactly the case worth refusing rather than
-// overwriting.
+// What is pushed is the Ticket's result, not what its workspace went through:
+// the workspace is snapshotted again at every integration, and a blob that was
+// added and removed along the way (an install, a build) would travel with its
+// history and make a pack no host accepts. So one commit is made from the
+// branch's tree, on top of the work line's tip, and that commit is pushed.
+// A resubmission continues what this slot published before, which the work line
+// remembers, so the push stays a fast-forward.
+//
+// A plain push, and no force of any kind. A rejection means the name moved
+// under us — someone else's commit, or a rewrite — and that is exactly the
+// case worth refusing rather than overwriting: a branch this slot did not
+// publish is never built upon.
 //
 // The remote is `origin`, and there is no option for it: Host reads the work
 // line back from `origin` after the Authority folds, with no way to learn what
 // this slot was told. An option that publishes to one remote while the refresh
 // reads another is a trap, so it waits for that half to become a slot too.
 //
-// Runs in the work line. mason appends --id, --ref and --target.
+// A Feature's line is not a Ticket's result: it is a history the Authority built
+// by folding Tickets into it, already on the remote, and it is pushed as it is,
+// a fast-forward of what the remote holds. mason says so with `--kind line`.
+//
+// Runs in the work line. mason appends --id, --ref, --target and --kind.
 
 const cwd = process.cwd();
 const tokens = ownArgv(process.argv, PUBLISHER_FLAGS);
@@ -48,18 +59,108 @@ if (!existsSync(join(cwd, ".git"))) {
 
 // C locale: git's words become the refusal a team reads on the tracker, and a
 // machine's own language would put French or German in an English thread.
-const pushed = spawnSync("git", ["-C", cwd, "push", remote, `${ref}:${ref}`], {
-  encoding: "utf8",
-  env: { ...process.env, LC_ALL: "C" },
-});
-if (pushed.error !== undefined) {
-  writeDiagnostic(`git publisher cannot run git: ${pushed.error.message}\n`);
-  process.exit(1);
+const env = { ...process.env, LC_ALL: "C" };
+/** @param {...string} args */
+const git = (...args) => spawnSync("git", ["-C", cwd, ...args], { encoding: "utf8", env });
+/** @param {{ stderr?: string | null, stdout?: string | null }} run */
+const text = (run) => `${run.stderr ?? ""}${run.stdout ?? ""}`.trim().slice(-1000);
+
+/**
+ * Runs git; a git that cannot run at all ends the slot, anything else is the caller's to read.
+ * @param {...string} args
+ */
+function run(...args) {
+  const done = git(...args);
+  if (done.error !== undefined) {
+    writeDiagnostic(`git publisher cannot run git: ${done.error.message}\n`);
+    process.exit(1);
+  }
+  return done;
 }
-if (pushed.status !== 0) {
-  const detail = `${pushed.stderr ?? ""}${pushed.stdout ?? ""}`.trim().slice(-1000);
-  emitPublishRefusal(`Could not publish ${ref}: ${detail}`);
+
+/**
+ * @param {string} what
+ * @param {{ stderr?: string | null, stdout?: string | null }} [done]
+ * @returns {never}
+ */
+function refuse(what, done) {
+  emitPublishRefusal(
+    `Could not publish ${ref}: ${what}${done === undefined ? "" : `: ${text(done)}`}`,
+  );
+  process.exit(0);
+}
+
+const kind = take(process.argv, "--kind") ?? "ticket";
+if (kind === "line") {
+  const pushedLine = run("push", remote, `refs/heads/${ref}:refs/heads/${ref}`);
+  if (pushedLine.status !== 0) {
+    refuse("the push was refused", pushedLine);
+  }
+  emitPublication(ref);
+  process.exit(0);
+}
+
+const target = take(process.argv, "--target");
+const id = take(process.argv, "--id");
+if (target === undefined || target.trim().length === 0) {
+  refuse("it was given no --target to build on");
+}
+
+// The line's tip, as the remote holds it: what the Submission is a change to.
+const fetched = run("fetch", "--quiet", remote, target);
+if (fetched.status !== 0) {
+  refuse(`cannot read ${target} from ${remote}`, fetched);
+}
+const tip = run("rev-parse", "FETCH_HEAD");
+const tipOid = tip.stdout.trim();
+if (tip.status !== 0 || tipOid.length === 0) {
+  refuse(`cannot read ${target}`, tip);
+}
+const tree = run("rev-parse", `${ref}^{tree}`);
+if (tree.status !== 0) {
+  refuse(`${ref} is not a branch of this work line`, tree);
+}
+const treeOid = tree.stdout.trim();
+
+// What this slot published before: the work line keeps it under `refs/published/`.
+// A name that holds anything else moved under us, and is left for the push to
+// reject.
+const recordName = `refs/published/${ref}`;
+let before;
+const recorded = run("rev-parse", "--verify", "--quiet", recordName).stdout.trim();
+const remoteRef = run("ls-remote", remote, `refs/heads/${ref}`);
+const remoteOid = remoteRef.stdout.trim().split(/\s+/)[0] ?? "";
+if (recorded.length > 0 && remoteRef.status === 0 && remoteOid === recorded) {
+  before = recorded;
+}
+
+// Nothing new: the same tree on the same line, already there.
+if (
+  before !== undefined &&
+  run("rev-parse", `${before}^{tree}`).stdout.trim() === treeOid &&
+  run("merge-base", "--is-ancestor", tipOid, before).status === 0
+) {
+  emitPublication(ref);
   process.exit(0);
 }
 
+const parents = [...new Set([before, tipOid].filter((oid) => oid !== undefined))];
+const made = run(
+  "commit-tree",
+  treeOid,
+  ...parents.flatMap((oid) => ["-p", oid]),
+  "-m",
+  `Submission of ${id ?? ref}`,
+);
+const commit = made.stdout.trim();
+if (made.status !== 0 || commit.length === 0) {
+  refuse("cannot make the commit", made);
+}
+
+const pushed = run("push", remote, `${commit}:refs/heads/${ref}`);
+if (pushed.status !== 0) {
+  refuse("the push was refused", pushed);
+}
+run("update-ref", recordName, commit);
+
 emitPublication(ref);