@augurworks/augur 0.15.2 → 0.15.4

package/scripts/lib/draft.mjs

@@ -11,6 +11,8 @@ import { createHash } from "node:crypto";
 import { merge3 } from "./merge3.mjs";
 
 export const STATE_FILE = ".augur/draft.json";
+/** How many times `land` tries again when the space's manifest is contended. */
+export const LAND_RETRIES = 4;
 export const THEIRS_DIR = ".augur/theirs";
 // The machine-wide registry of open draft folders. `AUGUR_DRAFTS_REGISTRY` exists for the
 // test suite, which must never write into the developer's own home folder.
@@ -28,6 +30,18 @@ const MIME = {
 export const mimeOf = (name) => MIME[path.extname(name).slice(1).toLowerCase()] || "application/octet-stream";
 export const hashBytes = (buf) => createHash("sha256").update(buf).digest("hex");
 export const relOf = (unit, urlPath) => urlPath.slice(unit.length);
+/**
+ * A REPO folder or a URL, as the unit path it publishes to: `<project>/prototypes/<name>`
+ * is the nesting a space clone keeps, served at `/<project>/<name>/`. An agent has just been
+ * looking at the folder, so it is the spelling it will type.
+ */
+export function unitPathFor(input) {
+  const s = String(input == null ? "" : input).trim().slice(0, 300).replace(/\/prototypes\//g, "/");
+  if (!s) return "";
+  const t = s.replace(/^\.\//, "").replace(/\/{2,}/g, "/");
+  if (!t || t === "/") return "/";
+  return `/${t.replace(/^\/+/, "").replace(/\/+$/, "")}/`;
+}
 export const urlOf = (unit, rel) => unit + rel;
 
 export function scanFolder(dir) {
@@ -99,17 +113,30 @@ export const registryList = () => readRegistry().drafts;
  * `/__unit/<verb>` and blobs at `/__publish/<space>/blob/<hash>`. Non-2xx answers come back
  * as `{status, ...body}` rather than throwing, because a 409 is an answer, not a failure.
  */
+/**
+ * The server answers a token it does not know with a bare `forbidden` and no sentence,
+ * ON PURPOSE — a guessed token must learn nothing. This side knows something the server
+ * will not say: the token it just sent is the one saved on this machine, so a bare
+ * refusal means that token is dead here — revoked by a role change or a removal, or
+ * minted for another workspace — and the way back is to pair again.
+ */
+export const TOKEN_NOT_ACCEPTED = "this machine's publish token is not accepted here — it may have been revoked (a role change or a removal does that), or it belongs to another workspace. Run `augur connect` again.";
+export function explainRefusal(body, status) {
+  if (status === 403 && body && body.error === "forbidden" && !body.message) return { ...body, message: TOKEN_NOT_ACCEPTED };
+  return body;
+}
+
 export function unitClient({ origin, token, space, session }) {
   const headers = { Authorization: `Bearer ${token}`, "X-Augur-Session": session || "" };
   const post = async (verb, body) => {
     const r = await fetch(`${origin}/__unit/${verb}`, { method: "POST", headers: { ...headers, "content-type": "application/json" }, body: JSON.stringify(body) });
     const out = await r.json().catch(() => ({}));
-    return r.ok ? out : { status: r.status, ...out };
+    return r.ok ? out : { status: r.status, ...explainRefusal(out, r.status) };
   };
   const get = async (verb, unit) => {
     const r = await fetch(`${origin}/__unit/${verb}?unit=${encodeURIComponent(unit)}`, { headers });
     const out = await r.json().catch(() => ({}));
-    return r.ok ? out : { status: r.status, ...out };
+    return r.ok ? out : { status: r.status, ...explainRefusal(out, r.status) };
   };
   return {
     open: (b) => post("open", b), save: (b) => post("save", b), land: (b) => post("land", b),
@@ -117,16 +144,31 @@ export function unitClient({ origin, token, space, session }) {
     main: (unit) => get("main", unit),
     async blobPut(h, body) {
       const r = await fetch(`${origin}/__publish/${space}/blob/${h}`, { method: "PUT", headers, body });
-      if (!r.ok && r.status !== 204) throw new Error(`blob upload failed: ${r.status}`);
+      if (!r.ok && r.status !== 204) throw await refusalError("blob upload", r);
     },
     async blobGet(h) {
       const r = await fetch(`${origin}/__publish/${space}/blob/${h}`, { headers });
-      if (!r.ok) throw new Error(`blob fetch failed: ${r.status}`);
+      if (!r.ok) throw await refusalError("blob fetch", r);
       return Buffer.from(await r.arrayBuffer());
     },
   };
 }
 
+/**
+ * A non-2xx answer from the blob routes, carried as an error that REMEMBERS it was an
+ * answer: the status and whatever the server said. `guarded` turns that back into a
+ * result, so a role refusal on an upload reads as the refusal it is — before this, a
+ * viewer's save came back as "unreachable, nothing is lost", which was neither.
+ */
+async function refusalError(what, r) {
+  let body = null;
+  try { body = await r.json(); } catch (e) { /* not JSON */ }
+  const err = new Error(`${what} failed: ${r.status}${body && body.error ? ` ${body.error}` : ""}`);
+  err.status = r.status;
+  err.body = body && typeof body === "object" ? explainRefusal(body, r.status) : null;
+  return err;
+}
+
 // ── the verbs ────────────────────────────────────────────────────────────────
 // `blobPut`/`blobGet` throw on a non-2xx answer, and a raw `fetch` can reject outright
 // (offline, DNS, a dropped connection mid-transfer) — a transient failure anywhere inside
@@ -138,7 +180,15 @@ export function unitClient({ origin, token, space, session }) {
 function guarded(fn) {
   return async (...args) => {
     try { return await fn(...args); }
-    catch (err) { return { ok: false, error: "network", message: String((err && err.message) || err) }; }
+    catch (err) {
+      // An answer the server gave (a status) is a refusal and keeps the server's words;
+      // anything else — DNS, a dropped connection, a thrown fixture — is the network.
+      if (err && err.status) {
+        const body = err.body || {};
+        return { ok: false, status: err.status, error: body.error || "refused", message: body.message || String(err.message), ...(body.reason ? { reason: body.reason } : {}) };
+      }
+      return { ok: false, error: "network", message: String((err && err.message) || err) };
+    }
   };
 }
 
@@ -150,11 +200,19 @@ async function materialise(client, unit, table, dir) {
   }
 }
 
-async function doOpenImpl({ client, unit, dir, origin, space, session, now }) {
+async function doOpenImpl({ client, unit, dir, origin, space, session, now, isNew = false }) {
   if (fs.existsSync(dir) && fs.readdirSync(dir).length) return { ok: false, error: "folder-not-empty", dir };
   const createdFolder = !fs.existsSync(dir);
   const o = await client.open({ unit });
   if (o.status) return { ok: false, ...o };
+  // A unit with no files is one that does not exist yet. Creating one is a decision the
+  // caller states with `isNew`; without it, a typo would quietly open an empty draft on a
+  // prototype that was never there. Either mismatch hands the draft straight back.
+  const exists = Object.keys(o.table || {}).length > 0;
+  if (exists !== !isNew) {
+    try { await client.discard({ unit, draftId: o.draftId }); } catch (e) { /* best-effort */ }
+    return { ok: false, error: exists ? "unit-exists" : "unknown-unit", unit };
+  }
   // From here the server-side draft exists, so any failure below must both undo what we
   // wrote to disk and tell the server to drop the orphan — otherwise a retry finds a
   // half-materialised folder (`folder-not-empty`) and the draft it opened is never freed.
@@ -177,7 +235,7 @@ async function doOpenImpl({ client, unit, dir, origin, space, session, now }) {
     throw err;
   }
   const others = (o.presence || []).filter((d) => d.id !== o.draftId);
-  return { ok: true, draftId: o.draftId, address: `${origin}${o.address}`, files: Object.keys(o.table).length, others };
+  return { ok: true, draftId: o.draftId, address: `${origin}${o.address}`, files: Object.keys(o.table).length, others, isNew: !exists };
 }
 
 async function doSaveImpl({ client, dir, baseRevision, baseTable }) {
@@ -206,7 +264,17 @@ async function doLandImpl({ client, dir, note }) {
   if (!st) return { ok: false, error: "not-a-draft", dir };
   const saved = await doSave({ client, dir });
   if (!saved.ok) return saved;
-  const r = await client.land({ unit: st.unit, draftId: st.draftId, baseRevision: st.baseRevision, note: note || "" });
+  // Every landing in a space writes the one manifest by compare-and-set, so eight agents
+  // landing eight prototypes in the same second contend on it. The server retries a few
+  // times and then answers `manifest-contended`; that is a moment, not a refusal — the
+  // draft is still open, its lease released — so this side lands again, with a little
+  // jitter, before telling anyone. Measured live: 8 parallel landings, 2 contended.
+  let r;
+  for (let attempt = 0; ; attempt++) {
+    r = await client.land({ unit: st.unit, draftId: st.draftId, baseRevision: st.baseRevision, note: note || "" });
+    if (r.error !== "manifest-contended" || attempt >= LAND_RETRIES) break;
+    await new Promise((res) => setTimeout(res, 150 + Math.random() * 400 * (attempt + 1)));
+  }
   if (r.status) return { ok: false, ...r };
   st.landed = true; st.landedRevision = r.revision;
   writeState(dir, st);

package/scripts/no-tenant-globals.mjs

@@ -224,6 +224,7 @@ const ALLOWLIST = {
       "mcpHostAllowlist",
       "CANVAS_REGISTRY",
       "PITI_REMARKS",
+      "DERIVED",              // the two store reads a derived gallery needs, per manifest version — the status baseline and the design-system catalog
       "ROSTER_OVERLAY",
       "FREEZE_STATE",
       "SUSPENSION_STATE",
@@ -281,6 +282,21 @@ const ALLOWLIST = {
     },
   },
 
+  // The derived pages: pure renderers over the live store. Every table here is a fact
+  // about the engine's vocabulary — tier names, status words and glyphs, the emoji pool a
+  // card's leading glyph is picked from — the same for every workspace.
+  "src/galleries.mjs": {
+    frozen: [
+      "TIERS",        // the four library tiers whose demos are units
+      "TIER_TITLE",   // their titles
+      "TIER_COPY",    // their hints and empty states
+      "STATUS_META",  // status word → label + class
+      "STATUS_ICONS", // status word → glyph
+      "STATUS_RANK",  // the card order a status implies
+      "EMOJI_POOL",   // the leading-emoji pool, picked by slug hash
+    ],
+  },
+
   "src/bundle-keys.mjs": {
     frozen: [
       "BUNDLE_TENANCY",       // which bundle-store families carry a workspace segment; one word per family is the revert, and a deploy-wide fact — moved here from the worker so the workspace object shares the key shape

package/scripts/open.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// augur open <prototype> [--dir <folder>] [--session <label>]
+// augur open <prototype> [--new] [--dir <folder>] [--session <label>]
 //
 // Open one prototype into a folder of its own, as a draft that is live at once at its own
 // address. Prints who else is drafting it. The folder holds only that prototype's files and
@@ -8,8 +8,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { target, buildStamp } from "./lib/store.mjs";
-import { markPathFor } from "./lib/marks.mjs";
-import { unitClient, doOpen } from "./lib/draft.mjs";
+import { unitClient, doOpen, unitPathFor } from "./lib/draft.mjs";
 import { installAdapters } from "./lib/adapters.mjs";
 import { normUnit } from "../src/unit-core.mjs";
 
@@ -21,7 +20,7 @@ const positional = argv.filter((a, i) => !a.startsWith("--") && !(i > 0 && argv[
 
 const raw = positional[0];
 if (!raw) die("name a prototype: `augur open <opportunity>/<prototype>` (a folder path works too).");
-const unit = normUnit(markPathFor(raw) || raw);
+const unit = normUnit(unitPathFor(raw) || raw);
 if (!unit) die(`"${raw}" is not a prototype path.`);
 let origin, token;
 try { ({ origin, token } = target({ needToken: true })); } catch (e) { die(e.message); }
@@ -35,15 +34,19 @@ const session = process.env.AUGUR_SESSION || opt("--session") || `session-${proc
 const dir = path.resolve(opt("--dir") || unit.split("/").filter(Boolean).pop());
 
 const client = unitClient({ origin, token, space, session });
-const r = await doOpen({ client, unit, dir, origin, space, session, now: new Date().toISOString() });
+const isNew = argv.includes("--new");
+const r = await doOpen({ client, unit, dir, origin, space, session, now: new Date().toISOString(), isNew });
 if (!r.ok) {
   if (r.error === "folder-not-empty") die(`${r.dir} is not empty — pick another folder with --dir.`);
+  if (r.error === "unknown-unit") die(`${unit} does not exist here. To create it: \`augur open --new ${unit.replace(/^\/|\/$/g, "")}\`.`);
+  if (r.error === "unit-exists") die(`${unit} exists already — open it without --new.`);
   if (r.error === "units-not-configured") die("this instance does not serve drafts yet (no unit store bound).");
   if (r.error === "bad-unit" && r.reason === "reserved-folder") die(`${unit} sits under a folder the engine reserves — a prototype lives at <opportunity>/<prototype>.`);
   if (r.error === "bad-unit" && r.reason === "not-a-prototype-folder") die(`${unit} is not a prototype folder — name one as <opportunity>/<prototype>.`);
-  die(`could not open: ${r.error || r.status}${r.reason ? ` (${r.reason})` : ""}`);
+  if (r.error === "network") die(`could not reach the instance (${r.message}).`);
+  die(`could not open: ${r.error || r.status}${r.reason ? ` (${r.reason})` : ""}${r.message ? ` — ${r.message}` : ""}`);
 }
-log(`draft ${r.draftId} on ${unit} — ${r.files} file(s) in ${dir}`);
+log(r.isNew ? `draft ${r.draftId} on ${unit} — a NEW prototype; ${dir} is empty, write its index.html there` : `draft ${r.draftId} on ${unit} — ${r.files} file(s) in ${dir}`);
 // The agent tool's hooks, installed for this machine the first time a draft is opened
 // here (idempotent; `AUGUR_NO_ADAPTERS=1` skips it — the suite and CI set it).
 if (!process.env.AUGUR_NO_ADAPTERS) {

package/scripts/publish.mjs

@@ -25,6 +25,7 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { findShellDir, deployConfig, originHost } from "./lib/instance.mjs";
+import { draftsServed } from "./lib/draft.mjs";
 import { composePublish, filterLitter, unitPaths } from "./lib/publish-compose.mjs";
 import { collectEvidence } from "./lib/publish-evidence.mjs";
 import { stripVolatileHead } from "./lib/publish-conflict.mjs";
@@ -115,6 +116,17 @@ let ORIGIN = (process.env.AUGUR_ORIGIN || DEPLOY_ENV.AUGUR_ORIGIN ||
   deployConfig(ROOT, originHost(cwdSpaceOrigin)).siteOrigin || cwdSpaceOrigin || "")
   .replace(/\/+$/, "");
 if (!ORIGIN) die("no target origin — set AUGUR_ORIGIN, or add \"siteOrigin\" to space.json.");
+// Where the instance serves drafts, a TREE is not what goes live any more: a prototype is
+// changed by opening it and landing it (docs/drafts-that-land.md), and publishing a whole
+// checkout there would put every session's half-done work on the site at once. The engine
+// chrome (`--engine`) is not content and still goes this way.
+if (!ENGINE_ONLY && await draftsServed(ORIGIN)) {
+  die(`${ORIGIN} serves drafts, so a prototype is changed by opening it, not by publishing a tree:\n\n` +
+    `  augur open <opportunity>/<prototype>     # a folder of its own, live at once at its draft address\n` +
+    `  …edit; every save is live there…\n` +
+    `  augur land                               # the real URL moves; the last line printed is the live URL\n\n` +
+    `A prototype that does not exist yet: augur open --new <opportunity>/<name>. Read agents/drafts.md in the engine clone.`);
+}
 // A WORKSPACE THAT MOVED answers its old address with a redirect. A checkout that still
 // names the old address (space.json not yet pulled, a stale AUGUR_ORIGIN) would otherwise
 // POST through that redirect and read the answer as a bad token. One GET with redirects
@@ -642,6 +654,13 @@ function selfUpdate(why) {
   if (NO_SELF_UPDATE || selfUpdateTried || process.env.AUGUR_SELF_UPDATED === "1") return false;
   selfUpdateTried = true;
   const git = (...a) => execFileSync("git", ["-C", ROOT, ...a], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+  // A package install (`npm i -g @augurworks/augur`, or an `npx` run) has no clone to
+  // fast-forward. Say the one line that updates it, in the same place the clone would
+  // have updated itself, and let the caller report the skew.
+  if (!existsSync(path.join(ROOT, ".git"))) {
+    log(`this engine is a package install and is behind what the instance speaks (${why}) — update it: npm i -g @augurworks/augur@latest`);
+    return false;
+  }
   try {
     if (git("rev-parse", "--is-inside-work-tree") !== "true") return false;
     if (git("status", "--porcelain")) {

package/scripts/read.mjs

@@ -3,9 +3,9 @@
 // under _read/<unit>/ beside the draft folders; files carry no write bit and the deny hook
 // refuses edits there. `augur close` inside it removes it. See docs/drafts-that-land.md §7.
 import path from "node:path";
-import { target } from "./lib/store.mjs";
-import { markPathFor } from "./lib/marks.mjs";
-import { unitClient, doRead, readDirFor } from "./lib/draft.mjs";
+import fs from "node:fs";
+import { target, buildStamp } from "./lib/store.mjs";
+import { unitClient, doRead, readDirFor, unitPathFor } from "./lib/draft.mjs";
 import { normUnit } from "../src/unit-core.mjs";
 
 const log = (m) => console.error(`\x1b[35m[read]\x1b[0m ${m}`);
@@ -15,17 +15,24 @@ const opt = (n) => { const i = argv.indexOf(n); return i > -1 ? argv[i + 1] : nu
 const positional = argv.filter((a, i) => !a.startsWith("--") && !(i > 0 && argv[i - 1].startsWith("--")));
 const raw = positional[0];
 if (!raw) die("name a prototype: `augur read <opportunity>/<prototype>`.");
-const unit = normUnit(markPathFor(raw) || raw);
+const unit = normUnit(unitPathFor(raw) || raw);
 if (!unit) die(`"${raw}" is not a prototype path.`);
 let origin, token;
 try { ({ origin, token } = target({ needToken: true })); } catch (e) { die(e.message); }
 const dir = path.resolve(opt("--dir") || readDirFor(unit));
-const client = unitClient({ origin, token, space: "", session: "" });
+// The blob routes are per space, so the copy needs the space id exactly as `open` does:
+// from a space.json in this folder, else from what the instance says it serves.
+let space = null;
+try { space = JSON.parse(fs.readFileSync("space.json", "utf8")).id; } catch (e) { /* not in a space folder */ }
+if (!space) { try { space = Object.keys((await buildStamp(origin)).spaces || {})[0] || null; } catch (e) { /* stamp unreachable */ } }
+if (!space) die("could not tell which space this instance serves — run from a folder with space.json, or set AUGUR_ORIGIN.");
+const client = unitClient({ origin, token, space, session: "" });
 const r = await doRead({ client, unit, dir, origin, now: new Date().toISOString() });
 if (!r.ok) {
   if (r.error === "folder-not-empty") die(`${r.dir} is not empty — pick another folder with --dir.`);
   if (r.error === "units-not-configured") die("this instance does not serve drafts yet (no unit store bound).");
-  die(`could not read: ${r.error || r.status}${r.reason ? ` (${r.reason})` : ""}`);
+  if (r.error === "network") die(`could not reach the instance (${r.message}).`);
+  die(`could not read: ${r.error || r.status}${r.reason ? ` (${r.reason})` : ""}${r.message ? ` — ${r.message}` : ""}`);
 }
 log(`${r.files} file(s) of ${unit} at revision ${r.revision}, read-only`);
 console.log(dir);

package/scripts/save.mjs

@@ -15,7 +15,9 @@ const client = unitClient({ origin, token, space: st.space, session: st.session
 const r = await doSave({ client, dir });
 if (!r.ok) {
   if (r.error === "stale-draft" || r.error === "stale-draft-revision") die("this draft moved under you (another process saved to it) — run `augur sync`.");
-  die(`save refused: ${r.error || r.status}`);
+  if (r.error === "draft-closed") die(`this draft was ${r.landed ? `landed by ${r.name || r.by || "someone"}${r.session ? ` (${r.session})` : ""} at ${r.at}` : "discarded"} — the folder is no longer a draft. Your edits are still here; run augur open on the prototype again and copy them in.`);
+  if (r.error === "network") die(`could not reach the instance (${r.message}). Nothing is lost — the next save carries every change since.`);
+  die(`save refused: ${r.error || r.status}${r.message ? ` — ${r.message}` : ""}`);
 }
 if (r.changed.length) console.error(`\x1b[35m[save]\x1b[0m ${r.changed.length} file(s) live at ${origin}${st.address}`);
 console.log(`${origin}${st.address}`);

package/scripts/status.mjs

@@ -16,7 +16,6 @@ import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import path from "node:path";
 import { resolveOrigin, resolveToken, apiClient, buildStamp, ENGINE_ROOT } from "./lib/store.mjs";
-import { fetchMarks, markLine } from "./lib/marks.mjs";
 import { registryList, unitClient, draftsReport } from "./lib/draft.mjs";
 
 const args = process.argv.slice(2);
@@ -123,28 +122,11 @@ console.log("");
 console.log(`  ${C.dim}engine chrome    ${eng.sha ? eng.sha.slice(0, 12) : "—"}` +
   `${eng.version ? ` (v${eng.version})` : ""}${eng.publishedAt ? `  ·  shipped ${eng.publishedAt}` : ""}${C.off}`);
 
-// ── who is working where, right now ─────────────────────────────────────────
-//
-// `F-presence-marks`. The three numbers above answer "is what I have what is live"; they
-// cannot answer "is somebody else in here", and that is the question that decides whether
-// the next hour of work is going to be merged or forked.
-//
-// NEEDS A TOKEN and does not ask for one. `status` has always been the command that runs
-// with nothing configured — the build stamp is public — so a missing credential quietly
-// costs the marks section and nothing else. It affects the exit code in no way: marks
-// refuse nothing, and a mark is not a problem.
-const markToken = resolveToken(origin);
-if (markToken) {
-  const marks = await fetchMarks(apiClient(origin, markToken));
-  if (marks.length) {
-    console.log("");
-    console.log(`  ${C.dim}being worked on right now${C.off}`);
-    for (const m of marks) console.log(`  ${C.dim}  ${markLine(m)}${C.off}`);
-  }
-} else {
-  // The one thing a fresh agent needs to know and has no other way to learn: this machine
-  // holds no token, and the way to get one is pairing, not a password. Same words as the
-  // instance's own /llms.txt. Costs nothing here — status never needed the token.
+// ── not paired? say how, once ───────────────────────────────────────────────
+// The one thing a fresh agent needs to know and has no other way to learn: this machine
+// holds no token, and the way to get one is pairing, not a password. Same words as the
+// instance's own /llms.txt. Costs nothing here — status never needed the token.
+if (!resolveToken(origin)) {
   console.log("");
   console.log(`  ${C.dim}not paired with ${origin}. Publishing from here needs a token; get one without a password:${C.off}`);
   console.log(`  ${C.dim}  augur connect --origin ${origin}   (the owner approves a code in a signed-in browser)${C.off}`);

package/scripts/sync.mjs

@@ -15,7 +15,9 @@ const token = resolveToken(origin);
 if (!token) die("no publish token — run `augur connect` once.");
 const client = unitClient({ origin, token, space: st.space, session: st.session });
 const r = await doSync({ client, dir });
-if (!r.ok) die(`sync refused: ${r.error || r.status}`);
+if (!r.ok && r.error === "draft-closed") die(`this draft was ${r.landed ? `landed by ${r.name || r.by || "someone"}${r.session ? ` (${r.session})` : ""} at ${r.at}` : "discarded"} — the folder is no longer a draft. Your edits are still here; run augur open on the prototype again and copy them in.`);
+if (!r.ok && r.error === "network") die(`could not reach the instance (${r.message}). Nothing is lost — run augur sync again.`);
+if (!r.ok) die(`sync refused: ${r.error || r.status}${r.message ? ` — ${r.message}` : ""}`);
 for (const f of r.taken) log(`took theirs   ${f}`);
 for (const f of r.merged) log(`merged        ${f}`);
 for (const c of r.conflicts) {