@coffre/cli 0.1.13 → 0.1.14

package/dist/templates/node/README.md

@@ -62,8 +62,10 @@ With AWS KMS instead of a key of your own, the vault also needs a
 To do the same by hand, see
 [deploy.md](https://github.com/erwinkn/coffre/blob/main/docs/deploy.md#appendix-the-database-by-hand).
 
-Run `pnpm migrate`, with the administrator's URL in `DATABASE_URL`, after
-every package upgrade, before starting either process.
+To upgrade: `coffre update` here, restart both processes, then `coffre migrate`
+([upgrading](https://github.com/erwinkn/coffre/blob/main/docs/deploy.md#upgrading)).
+For automation, `pnpm migrate`, with the administrator's URL in
+`DATABASE_URL`, does the last step.
 
 For tests and local development only, both URLs may instead name the same
 absolute SQLite file, e.g. `file:/tmp/coffre-local.db`; migrate that URL once

package/dist/templates/node/package.json

@@ -13,11 +13,11 @@
     "conformance": "coffre-conformance node"
   },
   "dependencies": {
-    "@coffre/server": "0.1.13",
-    "@coffre/vault": "0.1.13"
+    "@coffre/server": "0.1.14",
+    "@coffre/vault": "0.1.14"
   },
   "devDependencies": {
-    "@coffre/conformance": "0.1.13",
+    "@coffre/conformance": "0.1.14",
     "@types/node": "26.1.1",
     "typescript": "5.9.3"
   }

package/dist/templates/workers/README.md

@@ -76,8 +76,10 @@ pnpm exec wrangler secret put APP_KEY -c app/wrangler.jsonc
 pnpm exec wrangler secret put GITHUB_CLIENT_SECRET -c app/wrangler.jsonc
 ```
 
-Run `pnpm migrate`, with the administrator's URL in `DATABASE_URL`, after
-every upgrade of `@coffre/server`, before deploying it.
+To upgrade: `coffre update` here, deploy, then `coffre migrate`
+([upgrading](https://github.com/erwinkn/coffre/blob/main/docs/deploy.md#upgrading)).
+For automation, `pnpm migrate`, with the administrator's URL in
+`DATABASE_URL`, does the last step.
 
 Keep older vault keys after a rotation, for good: what they wrapped still
 needs them, and so does what the vault signed under them before it. With AWS KMS

package/dist/templates/workers/package.json

@@ -14,13 +14,13 @@
     "conformance": "coffre-conformance workers"
   },
   "dependencies": {
-    "@coffre/server": "0.1.13",
-    "@coffre/ui": "0.1.13",
-    "@coffre/vault": "0.1.13"
+    "@coffre/server": "0.1.14",
+    "@coffre/ui": "0.1.14",
+    "@coffre/vault": "0.1.14"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "5.20260920.1",
-    "@coffre/conformance": "0.1.13",
+    "@coffre/conformance": "0.1.14",
     "typescript": "5.9.3",
     "wrangler": "4.118.0"
   }

package/dist/tty-BDa14JX2.js

@@ -0,0 +1,283 @@
+import { openSync } from "node:fs";
+import { emitKeypressEvents } from "node:readline";
+import tty from "node:tty";
+//#region src/tty.ts
+const plain = (text) => text;
+/**
+* The web UI's accent, green and red, at the depth the terminal takes:
+* 24-bit, 256 colours or the 16 named ones. NO_COLOR (and FORCE_COLOR) are
+* the stream's own `hasColors`; bold and dim stay, being no colour.
+*/
+function style(stream) {
+	if (stream.isTTY !== true) return {
+		ansi: false,
+		bold: plain,
+		dim: plain,
+		accent: plain,
+		green: plain,
+		red: plain
+	};
+	const terminal = stream;
+	const depth = typeof terminal.hasColors === "function" && terminal.hasColors() ? terminal.getColorDepth() : 1;
+	const sgr = (open, close) => (text) => `\x1b[${open}m${text}\x1b[${close}m`;
+	const colour = (rgb, index256, index16) => depth >= 24 ? sgr(`38;2;${rgb.join(";")}`, "39") : depth >= 8 ? sgr(`38;5;${index256}`, "39") : depth >= 4 ? sgr(String(index16), "39") : plain;
+	return {
+		ansi: true,
+		bold: sgr("1", "22"),
+		dim: sgr("2", "22"),
+		accent: colour([
+			91,
+			141,
+			239
+		], 69, 94),
+		green: colour([
+			63,
+			174,
+			111
+		], 71, 32),
+		red: colour([
+			229,
+			83,
+			75
+		], 167, 31)
+	};
+}
+const ESCAPE = /\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07]*\x07/g;
+/** Columns `text` takes on screen: its characters, less its escape codes. */
+function width(text) {
+	return [...text.replace(ESCAPE, "")].length;
+}
+/** `text` cut to `columns` on screen, escape codes kept, an ellipsis where it was cut. */
+function truncate(text, columns) {
+	if (width(text) <= columns) return text;
+	let out = "";
+	let used = 0;
+	for (let i = 0; i < text.length;) {
+		ESCAPE.lastIndex = i;
+		const code = text[i] === "\x1B" ? ESCAPE.exec(text) : null;
+		if (code !== null && code.index === i) {
+			out += code[0];
+			i += code[0].length;
+			continue;
+		}
+		const char = String.fromCodePoint(text.codePointAt(i));
+		if (used === columns - 1) return `${out}…${text.includes("\x1B") ? "\x1B[0m" : ""}`;
+		out += char;
+		used += 1;
+		i += char.length;
+	}
+	return out;
+}
+/** Plain `text` in lines of at most `columns`, broken at spaces, or anywhere in a word longer than a line. */
+function wrap(text, columns) {
+	const lines = [];
+	let line = "";
+	for (const word of text.split(" ")) {
+		let rest = word;
+		while (width(rest) > columns) {
+			if (line !== "") lines.push(line);
+			line = "";
+			lines.push([...rest].slice(0, columns).join(""));
+			rest = [...rest].slice(columns).join("");
+		}
+		if (line === "") line = rest;
+		else if (width(line) + 1 + width(rest) <= columns) line += ` ${rest}`;
+		else {
+			lines.push(line);
+			line = rest;
+		}
+	}
+	return [...lines, line];
+}
+/** `text` wrapped to the stream's width, each line indented by `indent` spaces. */
+function paragraph(out, text, indent = 2) {
+	const pad = " ".repeat(indent);
+	return wrap(text, Math.max(20, (out.columns || 80) - indent - 1)).map((line) => `${pad}${line}`).join("\n");
+}
+/** "a, b or c". */
+function listed(items, last) {
+	return items.length < 2 ? items.join("") : `${items.slice(0, -1).join(", ")} ${last} ${items.at(-1)}`;
+}
+/** A labelled row: `label` in a column of `column`, `text` wrapped beside it with a hanging indent. */
+function row(out, s, label, text, indent = 4, column = 10) {
+	const lines = wrap(text, Math.max(20, (out.columns || 80) - indent - column - 1));
+	const pad = " ".repeat(indent);
+	return lines.map((line, i) => `${pad}${i === 0 ? s.dim(label.padEnd(column)) : " ".repeat(column)}${line}`).join("\n");
+}
+/**
+* The keyboard: stdin when it is a terminal, otherwise the terminal itself,
+* as `less` reads it when its input is piped. Null without one.
+*/
+function keyboard() {
+	if (process.stdin.isTTY) return process.stdin;
+	try {
+		return new tty.ReadStream(openSync("/dev/tty", "r"));
+	} catch {
+		return null;
+	}
+}
+/** Where a screen is drawn and read from: stdout, and the keyboard. Null unless both are a terminal. */
+function openTerminal() {
+	if (!process.stdout.isTTY) return null;
+	const keys = keyboard();
+	return keys === null ? null : {
+		keys,
+		out: process.stdout
+	};
+}
+/** Release a keyboard `keyboard()` opened: stdin stays, /dev/tty closes. */
+function release(keys) {
+	keys.setRawMode?.(false);
+	keys.pause();
+	if (keys !== process.stdin) keys.destroy?.();
+}
+/**
+* Every key pressed, in raw mode, until `until` returns true, or `signal`
+* aborts the reading. Raw mode is on when this returns: a prompt shown after
+* it gets every key, none echoed or edited by the terminal first.
+*/
+function readKeys(keys, until, signal) {
+	emitKeypressEvents(keys);
+	keys.setRawMode?.(true);
+	keys.resume();
+	return new Promise((resolve, reject) => {
+		let busy = Promise.resolve();
+		const stop = () => {
+			keys.off("keypress", onKey);
+			signal?.removeEventListener("abort", stop);
+			keys.setRawMode?.(false);
+			keys.pause();
+			resolve();
+		};
+		const onKey = (sequence, key) => {
+			busy = busy.then(async () => {
+				if (await until(key ?? { sequence }, sequence ?? key?.sequence ?? "")) stop();
+			}).catch(reject);
+		};
+		keys.on("keypress", onKey);
+		if (signal?.aborted) stop();
+		else signal?.addEventListener("abort", stop);
+	});
+}
+/** What a typed key does to a line: its new text, or `submit`, or `cancel`. */
+function edit(text, key, sequence) {
+	if (key.ctrl && key.name === "c") return "cancel";
+	if (key.name === "return" || key.name === "enter") return "submit";
+	if (key.name === "backspace") return text.slice(0, -1);
+	if (key.ctrl && key.name === "u") return "";
+	if (!key.ctrl && !key.meta && sequence.length > 0 && !sequence.startsWith("\x1B") && sequence >= " ") return text + sequence;
+	return text;
+}
+/**
+* A question answered by typing, shown as typed, `initial` to start from;
+* `note`, dim under it while it is asked; `check` says why an answer will
+* not do, under it. Once given, the question becomes one line: what was
+* asked, and the answer. Ctrl-C cancels.
+*/
+async function textLine(keys, out, s, question, hint, options = {}) {
+	const columns = Math.max(20, (out.columns || 80) - 1);
+	let typed = options.initial ?? "";
+	let error = null;
+	const draw = () => {
+		const below = [...error === null ? [] : [s.red(error)], ...options.note === void 0 ? [] : wrap(options.note, columns - 4).map(s.dim)].map((line) => `\n${truncate(`    ${line}`, columns)}`);
+		out.write(`\r\x1b[J${below.join("")}${below.length > 0 ? `\x1b[${below.length}A` : ""}\r${truncate(`    ${s.accent("›")} ${typed}`, columns)}`);
+	};
+	let cancelled = false;
+	const answered = readKeys(keys, async (key, sequence) => {
+		const next = edit(typed, key, sequence);
+		if (next === "cancel") cancelled = true;
+		else if (next === "submit") {
+			if (typed.trim() === "") return false;
+			error = await options.check?.(typed.trim()) ?? null;
+			if (error === null) return true;
+		} else {
+			typed = next;
+			error = null;
+		}
+		if (cancelled) return true;
+		draw();
+		return false;
+	});
+	out.write(`${truncate(`  ${s.accent("?")} ${s.bold(question)} ${s.dim(hint)}`, columns)}\n`);
+	draw();
+	await answered;
+	out.write("\r\x1B[J\x1B[1A\x1B[2K");
+	if (cancelled) throw new Cancelled();
+	out.write(`${truncate(`  ${s.green("✓")} ${s.dim(question)}  ${typed.trim()}`, columns)}\n`);
+	return typed.trim();
+}
+/** One of `options`, chosen with the arrows and Enter; then one line, as `textLine` leaves. Ctrl-C cancels. */
+async function select(keys, out, s, question, options) {
+	const columns = Math.max(20, (out.columns || 80) - 1);
+	let at = 0;
+	let drawn = 0;
+	const draw = () => {
+		const lines = [`  ${s.accent("?")} ${s.bold(question)} ${s.dim("↑↓ then Enter")}`, ...options.map((option, i) => i === at ? `    ${s.accent("›")} ${s.accent(option)}` : `      ${option}`)];
+		out.write(`${drawn > 0 ? `\x1b[${drawn}F` : ""}${lines.map((line) => `${truncate(line, columns)}\x1b[K\n`).join("")}`);
+		drawn = lines.length;
+	};
+	let cancelled = false;
+	const chosen = readKeys(keys, (key) => {
+		if (key.ctrl && key.name === "c") cancelled = true;
+		else if (key.name === "return" || key.name === "enter") return true;
+		else if (key.name === "up" || key.name === "k") at = (at - 1 + options.length) % options.length;
+		else if (key.name === "down" || key.name === "j" || key.name === "tab") at = (at + 1) % options.length;
+		if (cancelled) return true;
+		draw();
+		return false;
+	});
+	draw();
+	await chosen;
+	out.write(`\x1b[${drawn}F\x1b[J`);
+	if (cancelled) throw new Cancelled();
+	out.write(`${truncate(`  ${s.green("✓")} ${s.dim(question)}  ${options[at]}`, columns)}\n`);
+	return at;
+}
+var Cancelled = class extends Error {
+	constructor() {
+		super("cancelled");
+	}
+};
+/**
+* A line typed without echo: a bullet for each character, so that a paste
+* shows it arrived. The question, its hint and the bullets go once it is
+* given. Ctrl-C cancels.
+*/
+async function hiddenLine(keys, out, s, question, hint) {
+	const columns = Math.max(20, (out.columns || 80) - 1);
+	let typed = "";
+	const draw = () => {
+		const count = typed.length > 0 ? s.dim(`  ${typed.length} characters`) : "";
+		out.write(`\r\x1b[2K${truncate(`    ${s.accent("›")} ${"•".repeat(typed.length)}`, columns - width(count))}${count}`);
+	};
+	let cancelled = false;
+	const typedIn = readKeys(keys, (key, sequence) => {
+		const next = edit(typed, key, sequence);
+		if (next === "cancel") cancelled = true;
+		else if (next === "submit") return true;
+		else typed = next;
+		if (cancelled) return true;
+		draw();
+		return false;
+	});
+	out.write(`${truncate(`  ${s.accent("?")} ${s.bold(question)}`, columns)}\n${truncate(`    ${s.dim(hint)}`, columns)}\n`);
+	draw();
+	await typedIn;
+	out.write("\r\x1B[2K\x1B[1A\x1B[2K\x1B[1A\x1B[2K");
+	if (cancelled) throw new Cancelled();
+	return typed.trim();
+}
+/** One key: y for yes, anything else for no. Ctrl-C cancels. */
+async function yes(keys) {
+	let answer = false;
+	let cancelled = false;
+	await readKeys(keys, (key) => {
+		if (key.ctrl && key.name === "c") cancelled = true;
+		answer = key.name === "y";
+		return true;
+	});
+	if (cancelled) throw new Cancelled();
+	return answer;
+}
+//#endregion
+export { openTerminal as a, release as c, style as d, textLine as f, yes as g, wrap as h, listed as i, row as l, width as m, edit as n, paragraph as o, truncate as p, hiddenLine as r, readKeys as s, Cancelled as t, select as u };

package/dist/update-DwGbG-eM.js

@@ -0,0 +1,263 @@
+import { a as openTerminal, c as release, d as style, i as listed, t as Cancelled } from "./tty-BDa14JX2.js";
+import { n as StepFailed, r as Steps, t as cliVersion } from "./version-CPk6zTTK.js";
+import { a as install, n as coffrePins, r as deploymentKind, t as bumpPins } from "./deployment-S8za5nUu.js";
+import { createRequire } from "node:module";
+import { parseArgs } from "node:util";
+import { spawn, spawnSync } from "node:child_process";
+import { readFileSync, realpathSync } from "node:fs";
+import { dirname, join, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+* Every migration this version ships, oldest first, per engine: read from
+* the journals at build time, so a Worker, which has no files, knows them
+* too. A database that has applied fewer is behind this code, whatever
+* `REQUIRED_MIGRATIONS` lets it run on.
+*/
+const KNOWN_MIGRATIONS = {
+	postgres: [{
+		"idx": 0,
+		"version": "7",
+		"when": 1790930587507,
+		"tag": "0000_baseline",
+		"breakpoints": true
+	}, {
+		"idx": 1,
+		"version": "7",
+		"when": 1791062292678,
+		"tag": "0001_remove_syncs",
+		"breakpoints": true
+	}].map((entry) => entry.tag),
+	sqlite: [{
+		"idx": 0,
+		"version": "6",
+		"when": 1790874462505,
+		"tag": "0000_baseline",
+		"breakpoints": true
+	}, {
+		"idx": 1,
+		"version": "6",
+		"when": 1791062293531,
+		"tag": "0001_remove_syncs",
+		"breakpoints": true
+	}].map((entry) => entry.tag)
+};
+//#endregion
+//#region src/update.ts
+const PACKAGE = "@coffre/cli";
+/**
+* How the CLI at `path` was installed: under npx's cache, a global root
+* (`npm root -g`, `pnpm root -g`), a project's node_modules, or a checkout.
+*/
+function installOf(path, roots) {
+	if (path.includes(`${sep}_npx${sep}`)) return { kind: "npx" };
+	if (roots.pnpm !== null && path.startsWith(dirname(roots.pnpm) + sep)) return { kind: "pnpm" };
+	if (roots.npm !== null && path.startsWith(roots.npm + sep)) return { kind: "npm" };
+	const modules = path.lastIndexOf(`${sep}node_modules${sep}`);
+	if (modules !== -1) return {
+		kind: "project",
+		dir: path.slice(0, modules)
+	};
+	if (path.includes(`${sep}packages${sep}cli${sep}`)) return { kind: "checkout" };
+	return { kind: "unknown" };
+}
+/** The migrations a deployment's installed coffre ships, through its server's own @coffre/db; null before an install. */
+function deploymentMigrations(dir) {
+	try {
+		const server = createRequire(realpathSync(join(dir, "node_modules", "@coffre", "server", "package.json")));
+		return journalTags(join(dirname(server.resolve("@coffre/db/package.json")), "dist", "migrations", "postgres"));
+	} catch {
+		return null;
+	}
+}
+function journalTags(folder) {
+	return JSON.parse(readFileSync(join(folder, "meta", "_journal.json"), "utf8")).entries.map((entry) => entry.tag);
+}
+/**
+* What moving from version `from` to `to` asks of the database, said once it
+* is installed: the migrations `after` has and `before` did not.
+*/
+function migrationsAdded(from, to, before, after) {
+	const added = after.filter((tag) => !before.includes(tag));
+	if (added.length === 0) return `coffre ${to} adds no migration to ${from}'s: deploying it is all.`;
+	return `coffre ${to} adds ${added.length === 1 ? "1 migration" : `${added.length} migrations`} to ${from}'s (${listed(added, "and")}): after deploying, run \`coffre migrate\`.`;
+}
+/** coffre's latest release, as the registry has it. */
+async function latestVersion() {
+	const registry = (process.env.npm_config_registry ?? "https://registry.npmjs.org/").replace(/\/?$/, "/");
+	const response = await fetch(`${registry}${PACKAGE}/latest`, { headers: { accept: "application/json" } });
+	if (!response.ok) throw new Error(`${registry} answered ${response.status} for ${PACKAGE}`);
+	return (await response.json()).version;
+}
+function globalRoot(manager) {
+	const ran = spawnSync(manager, ["root", "-g"], {
+		encoding: "utf8",
+		timeout: 1e4
+	});
+	const root = ran.status === 0 ? ran.stdout.trim() : "";
+	if (root === "") return null;
+	try {
+		return realpathSync(root);
+	} catch {
+		return root;
+	}
+}
+/** A command, its output kept to explain a failure. */
+function command(name, args, cwd) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(name, args, {
+			cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...process.env,
+				COREPACK_ENABLE_DOWNLOAD_PROMPT: "0"
+			}
+		});
+		let output = "";
+		child.stdout.setEncoding("utf8").on("data", (chunk) => output += chunk);
+		child.stderr.setEncoding("utf8").on("data", (chunk) => output += chunk);
+		child.on("error", () => reject(/* @__PURE__ */ new Error(`${name} is not installed`)));
+		child.on("close", (code) => {
+			if (code === 0) return resolve();
+			if (/minimumReleaseAge|minimum-release-age/i.test(output)) return reject(/* @__PURE__ */ new Error(`${name} holds back releases newer than its minimumReleaseAge, and this one is new: wait, or allow @coffre/* (minimumReleaseAgeExclude), as a deployment coffre init writes does`));
+			reject(/* @__PURE__ */ new Error(`${name} ${args.join(" ")} failed: ${output.trim().split("\n").slice(-3).join(" ")}`));
+		});
+	});
+}
+async function update(args) {
+	let yes;
+	try {
+		({yes} = parseArgs({
+			args,
+			options: { yes: {
+				type: "boolean",
+				default: false
+			} },
+			strict: true
+		}).values);
+	} catch {
+		process.stderr.write("usage: coffre update [--yes]\n");
+		process.exit(2);
+	}
+	const terminal = openTerminal();
+	const out = terminal?.out ?? process.stderr;
+	const s = style(out);
+	const keys = () => terminal?.keys ?? null;
+	const ask = async (question, step) => {
+		if (yes) return true;
+		if (keys() === null) throw new Error("nothing here to confirm on: run coffre update on a terminal, or pass --yes");
+		return step.ask(question);
+	};
+	const current = cliVersion();
+	const self = realpathSync(fileURLToPath(import.meta.url));
+	const how = installOf(self, {
+		npm: globalRoot("npm"),
+		pnpm: globalRoot("pnpm")
+	});
+	const dir = process.cwd();
+	const kind = deploymentKind(dir);
+	const deployment = kind === "workers" || kind === "node" ? dir : null;
+	const pins = deployment === null ? {} : coffrePins(deployment);
+	const pinned = [...new Set(Object.values(pins))];
+	if (s.ansi) out.write(`\n  ${s.bold("coffre update")}  ${s.dim(`this CLI${deployment === null ? "" : ", and this deployment"}`)}\n\n`);
+	const steps = new Steps(out, [
+		"Look up coffre's latest release",
+		"Update this CLI",
+		...deployment === null ? [] : ["Update this deployment's coffre packages"]
+	], keys, (error) => error instanceof Error ? error.message : String(error));
+	let before = (deployment === null ? null : deploymentMigrations(deployment)) ?? KNOWN_MIGRATIONS.postgres;
+	const from = deployment !== null && pinned.length === 1 ? pinned[0] : current;
+	let after = null;
+	let latest = current;
+	try {
+		await steps.run(0, async () => {
+			latest = await latestVersion();
+			return `coffre ${latest} is the latest release; this CLI is ${current}`;
+		});
+		await steps.run(1, async (step) => {
+			if (current === latest) return `This CLI is up to date, at ${current}`;
+			switch (how.kind) {
+				case "npx": return {
+					text: "Nothing to update: npx runs the version it is given",
+					details: [`npx ${PACKAGE}@${latest} … runs ${latest}`]
+				};
+				case "checkout": return {
+					text: "Nothing to update here: this CLI runs from a checkout of coffre",
+					details: ["git pull, then pnpm install and pnpm build"]
+				};
+				case "project": return how.dir === deployment ? {
+					text: `This CLI is one of the deployment's packages, updated with them below`,
+					details: []
+				} : {
+					text: `Nothing updated: this CLI is a dependency of ${how.dir}`,
+					details: [`update it there: its @coffre/cli pin, to ${latest}`]
+				};
+				case "unknown": return {
+					text: "Nothing updated: where this CLI was installed from is unclear",
+					details: [`npm install -g ${PACKAGE}@${latest}, or pnpm add -g ${PACKAGE}@${latest}`]
+				};
+				default: {
+					const run = how.kind === "npm" ? ["npm", [
+						"install",
+						"-g",
+						`${PACKAGE}@${latest}`
+					]] : ["pnpm", [
+						"add",
+						"-g",
+						`${PACKAGE}@${latest}`
+					]];
+					if (!await ask(`Update this CLI from ${current} to ${latest}, with ${run[0]} ${run[1].join(" ")}?`, step)) return {
+						text: `This CLI stays at ${current}`,
+						details: []
+					};
+					step.note(`Updating this CLI, with ${run[0]}`);
+					await command(run[0], [...run[1]], dir);
+					after ??= journalTags(join(dirname(self), "migrations", "postgres"));
+					return `Updated this CLI from ${current} to ${latest}, with ${run[0]}`;
+				}
+			}
+		});
+		if (deployment !== null) await steps.run(2, async (step) => {
+			if (pinned.length === 1 && pinned[0] === latest) return `This deployment's coffre packages are at ${latest} already`;
+			const was = pinned.length === 1 ? pinned[0] : listed(pinned, "and");
+			if (!await ask(`Move this deployment's coffre packages from ${was} to ${latest}, and install them?`, step)) return {
+				text: `This deployment stays at ${was}`,
+				details: []
+			};
+			before = deploymentMigrations(deployment) ?? before;
+			bumpPins(deployment, latest);
+			step.note(`Installing coffre ${latest}'s packages, with pnpm`);
+			await install(deployment);
+			after = deploymentMigrations(deployment) ?? after;
+			return {
+				text: `Moved this deployment from ${was} to ${latest}, and installed it`,
+				details: [`${Object.keys(pins).length} coffre packages, which minimumReleaseAge lets through at once`]
+			};
+		});
+	} catch (error) {
+		if (error instanceof Cancelled) finish(out, `${s.red("✗")} cancelled; nothing after the last step done was changed`, 130);
+		if (error instanceof StepFailed) finish(out, "", 1);
+		finish(out, `${s.red("✗")} ${error instanceof Error ? error.message : String(error)}`, 1);
+	} finally {
+		steps.end();
+		if (terminal !== null) release(terminal.keys);
+	}
+	out.write("\n");
+	if (after !== null) {
+		out.write(`  ${migrationsAdded(from, latest, before, after)}\n`);
+		if (deployment !== null) {
+			const deploy = kind === "workers" ? "`pnpm run deploy`, or a push for Workers Builds" : "restarting the server";
+			out.write(`  ${s.dim(`Deploy it as you do: ${deploy}.`)}\n`);
+		}
+		out.write("\n");
+	}
+}
+function finish(out, message, code) {
+	if (message !== "") out.write(`${message}\n`);
+	process.exit(code);
+}
+//#endregion
+export { update };