fleetfizz 0.5.0 → 0.5.2

package/dist/fleetfizz.mjs

@@ -6917,6 +6917,11 @@ const ignore$1 = /*#__PURE__*/ dual((args) => isEffect$1(args[0]), (self, option
 	});
 });
 /** @internal */
+const option$1 = (self) => match$1(self, {
+	onFailure: none,
+	onSuccess: some
+});
+/** @internal */
 const result$1 = (self) => matchEager(self, {
 	onFailure: fail$5,
 	onSuccess: succeed$7
@@ -11094,6 +11099,49 @@ const tap = tap$1;
 */
 const result = result$1;
 /**
+* Converts success to `Option.some` and failure to `Option.none`.
+*
+* **When to use**
+*
+* Use when you only care whether an effect succeeds and want recoverable
+* failures represented as `Option.none`.
+*
+* **Details**
+*
+* Success values become `Option.some`, recoverable failures become
+* `Option.none`, and defects still fail the effect.
+*
+* **Gotchas**
+*
+* `option` only captures typed, recoverable failures as `Option.none`.
+* Defects and interruptions are not captured inside the `Option` and still
+* fail the effect.
+*
+* `option` also discards typed failure values. Use `result` if the failure
+* value matters.
+*
+* **Example** (Capturing success or failure as Option)
+*
+* ```ts import.meta.vitest
+* import { Effect, Option } from "effect"
+*
+* const program = Effect.all([
+*   Effect.option(Effect.succeed(1)),
+*   Effect.option(Effect.fail("missing"))
+* ])
+*
+* Effect.runSync(program) // => [Option.some(1), Option.none()]
+* ```
+*
+* @see {@link result} for a version that uses `Result` instead.
+* @see {@link exit} for a version that encapsulates both recoverable errors and defects in an `Exit`.
+*
+* @stability stable
+* @category error handling
+* @since 2.0.0
+*/
+const option = option$1;
+/**
 * Transforms an effect to encapsulate both failure and success using the `Exit`
 * data type.
 *
@@ -29233,7 +29281,7 @@ const visualLength = (text) => {
 * Helper function to pad strings to a specified width.
 * @internal
 */
-const pad$1 = (s, width) => {
+const pad = (s, width) => {
 	const actualLength = visualLength(s);
 	const padding = Math.max(0, width - actualLength);
 	return s + " ".repeat(padding);
@@ -29245,7 +29293,7 @@ const pad$1 = (s, width) => {
 const renderTable = (rows, widthCap) => {
 	const maxColumn = Math.max(...rows.map((r) => visualLength(r.left))) + 4;
 	const col = widthCap === void 0 ? maxColumn : Math.min(maxColumn, widthCap);
-	return rows.map(({ left, right }) => `  ${pad$1(left, Math.max(col, visualLength(left) + 1))}${right}`).join("\n");
+	return rows.map(({ left, right }) => `  ${pad(left, Math.max(col, visualLength(left) + 1))}${right}`).join("\n");
 };
 const formatSubcommandName = (name, alias) => alias ? `${name}, ${alias}` : name;
 /**
@@ -32392,7 +32440,7 @@ const runWith = (command, config) => {
 };
 //#endregion
 //#region package.json
-var version = "0.5.0";
+var version = "0.5.2";
 //#endregion
 //#region ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
 /**
@@ -35226,7 +35274,7 @@ const stampText = (text, stamp) => {
 	const fleet = machinesOf(previous);
 	const shippedTo = {
 		...Object.fromEntries(Object.entries(shippedToOf(previous)).filter(([name]) => fleet.includes(name))),
-		...Object.fromEntries(stamp.reached.map((name) => [name, stamp.shippedAt]))
+		...Object.fromEntries([...stamp.reached, ...stamp.own === void 0 ? [] : [stamp.own]].map((name) => [name, stamp.shippedAt]))
 	};
 	let out = set(text, "shippedAt", stamp.shippedAt);
 	out = set(out, "shippedFrom", stamp.shippedFrom);
@@ -35244,6 +35292,7 @@ const shippedToOf = (config) => {
 	return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
 };
 const isNewer = (remote, local) => remote !== void 0 && (local === void 0 || remote > local);
+const staleCopies = (config, copies, own) => copies.filter((c) => c.machine !== own && isNewer(c.config.shippedTo?.[c.machine], config.shippedTo?.[c.machine]));
 //#endregion
 //#region ../../packages/remote/src/shell.ts
 const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
@@ -35271,11 +35320,11 @@ const fingerprintFn = [
 	"}"
 ].join("\n");
 //#endregion
-//#region ../../packages/remote/src/gather.ts
+//#region ../../packages/remote/src/check.ts
 const STATE_DIR = "~/.local/state/fleetfizz";
 const RECORDS_DIR = `${STATE_DIR}/records`;
 const CONFIG_DIR_SH = "\"${XDG_CONFIG_HOME:-$HOME/.config}/fleetfizz\"";
-const gatherScript = (input) => {
+const checkScript = (input) => {
 	const lines = [
 		prelude,
 		fingerprintFn,
@@ -35768,6 +35817,7 @@ const doneLine = (id, ok, code) => code === void 0 ? `printf 'ff-done {"id":"%s"
 const jsonString = encodeSync(fromJsonString(String$5));
 const jsonRecord = encodeSync(fromJsonString(Record(String$5, String$5)));
 const stepId = (repo, step) => `repo:${repo}:${step}`;
+const isFetchStep = (id) => id.startsWith("repo:") && id.endsWith(":fetch");
 const vpStepId = (step) => step.kind === "reinstall" ? `vp:reinstall:${step.name}` : step.kind === "globals" ? "vp:globals" : `vp:${step.kind}`;
 const CONFIG_STEP = "config";
 const VP_INSTALL = [
@@ -35775,6 +35825,15 @@ const VP_INSTALL = [
 	...vpEnv.split("\n"),
 	"{ hash -r 2>/dev/null || true; }"
 ].join(" && ");
+const marked = (id, run, then = []) => [
+	stepLine(id),
+	...run,
+	`ff_code=$?`,
+	`if [ "$ff_code" -ne 0 ]; then ${doneLine(id, false, "$ff_code")}; else`,
+	doneLine(id, true),
+	...then,
+	"fi"
+];
 const vpStep = (step) => {
 	const id = vpStepId(step);
 	const command = (() => {
@@ -35786,22 +35845,12 @@ const vpStep = (step) => {
 			case "globals": return `command vp install -g ${step.packages.map((p) => quote(`${p.name}@${p.version}`)).join(" ")}`;
 		}
 	})();
-	return [
-		stepLine(id),
-		step.kind === "bootstrap" ? command : `( ${command} )`,
-		`ff_code=$?`,
-		`if [ "$ff_code" -ne 0 ]; then ${doneLine(id, false, "$ff_code")}; else ${doneLine(id, true)}; fi`
-	];
+	return marked(id, [step.kind === "bootstrap" ? command : `( ${command} )`]);
 };
 const configStep = () => {
 	const dir = CONFIG_DIR_SH;
 	const write = (variable, file) => `printf '%s' "$${variable}" | base64 -d > ${dir}/${quote(`${file}.tmp`)} && mv -f ${dir}/${quote(`${file}.tmp`)} ${dir}/${quote(file)}`;
-	return [
-		stepLine(CONFIG_STEP),
-		`( mkdir -p ${dir} && ${write("ff_config", CONFIG_FILE)} && ${write("ff_schema", SCHEMA_FILE)} )`,
-		`ff_code=$?`,
-		`if [ "$ff_code" -ne 0 ]; then ${doneLine(CONFIG_STEP, false, "$ff_code")}; else ${doneLine(CONFIG_STEP, true)}; fi`
-	];
+	return marked(CONFIG_STEP, [`( mkdir -p ${dir} && ${write("ff_config", CONFIG_FILE)} && ${write("ff_schema", SCHEMA_FILE)} )`]);
 };
 const writeRecord = (repo) => {
 	return [
@@ -35826,34 +35875,32 @@ const repoSteps = (repo, input) => {
 	return [
 		`ff_d="$ff_root"/${quote(repo.name)}`,
 		`ff_before=$(git -C "$ff_d" rev-parse HEAD 2>/dev/null || true)`,
-		stepLine(fetch),
-		"(",
-		"  set -e",
-		`  if [ ! -d "$ff_d/.git" ]; then ff_git clone --quiet ${quote(url)} "$ff_d"; fi`,
-		`  if [ "$(git -C "$ff_d" remote get-url origin)" != ${quote(url)} ]; then echo "origin is $(git -C "$ff_d" remote get-url origin), expected ${url}"; exit 1; fi`,
-		...sync.map((l) => `  ${l}`),
-		`  git -C "$ff_d" clean --quiet -fd`,
-		...writeFiles(repo).map((l) => `  ${l}`),
-		")",
-		`ff_code=$?`,
-		`if [ "$ff_code" -ne 0 ]; then ${doneLine(fetch, false, "$ff_code")}; else`,
-		`${doneLine(fetch, true)}`,
-		`ff_after=$(git -C "$ff_d" rev-parse HEAD)`,
-		`ff_state "{\\"fact\\":\\"repo\\",\\"name\\":\\"$(ff_json ${quote(repo.name)})\\",\\"present\\":true,\\"head\\":\\"$(ff_json "$ff_after")\\"}"`,
-		`if [ ${repo.decision.run ? "true" : "false"} = true ] || [ "$ff_after" != "$ff_before" ]; then`,
-		`  ${stepLine(install)}`,
-		`  (cd "$ff_d" && ${envPrefix} "\${SHELL:-/bin/sh}" -lc ${quote(repo.install)})`,
-		`  ff_code=$?`,
-		`  if [ "$ff_code" -ne 0 ]; then ${doneLine(install, false, "$ff_code")}; else`,
-		"    (",
-		"      set -e",
-		...writeRecord(repo).map((l) => `      ${l}`),
-		"    )",
-		`    ff_code=$?`,
-		`    if [ "$ff_code" -ne 0 ]; then echo "could not write the install record"; ${doneLine(install, false, "$ff_code")}; else ${doneLine(install, true)}; fi`,
-		"  fi",
-		"fi",
-		"fi"
+		...marked(fetch, [
+			"(",
+			"  set -e",
+			`  if [ ! -d "$ff_d/.git" ]; then ff_git clone --quiet ${quote(url)} "$ff_d"; fi`,
+			`  if [ "$(git -C "$ff_d" remote get-url origin)" != ${quote(url)} ]; then echo "origin is $(git -C "$ff_d" remote get-url origin), expected ${url}"; exit 1; fi`,
+			...sync.map((l) => `  ${l}`),
+			`  git -C "$ff_d" clean --quiet -fd`,
+			...writeFiles(repo).map((l) => `  ${l}`),
+			")"
+		], [
+			`ff_after=$(git -C "$ff_d" rev-parse HEAD)`,
+			`ff_state "{\\"fact\\":\\"repo\\",\\"name\\":\\"$(ff_json ${quote(repo.name)})\\",\\"present\\":true,\\"head\\":\\"$(ff_json "$ff_after")\\"}"`,
+			`if [ ${repo.decision.run ? "true" : "false"} = true ] || [ "$ff_after" != "$ff_before" ]; then`,
+			`  ${stepLine(install)}`,
+			`  (cd "$ff_d" && ${envPrefix} "\${SHELL:-/bin/sh}" -lc ${quote(repo.install)})`,
+			`  ff_code=$?`,
+			`  if [ "$ff_code" -ne 0 ]; then ${doneLine(install, false, "$ff_code")}; else`,
+			"    (",
+			"      set -e",
+			...writeRecord(repo).map((l) => `      ${l}`),
+			"    )",
+			`    ff_code=$?`,
+			`    if [ "$ff_code" -ne 0 ]; then echo "could not write the install record"; ${doneLine(install, false, "$ff_code")}; else ${doneLine(install, true)}; fi`,
+			"  fi",
+			"fi"
+		])
 	];
 };
 const applyStdin = (token, config, schema) => [
@@ -36039,546 +36086,6 @@ const resolveVersions = fn("resolveVersions")(function* (packages) {
 	return Object.fromEntries(entries);
 });
 //#endregion
-//#region src/ledger.ts
-const Note = Struct({
-	kind: Literals$2([
-		"ask",
-		"answer",
-		"info"
-	]),
-	text: String$5
-});
-const Item = Struct({
-	name: String$5,
-	kind: Literals$2([
-		"version",
-		"repo",
-		"config"
-	]),
-	from: optionalKey(String$5),
-	to: optionalKey(String$5),
-	reason: optionalKey(String$5),
-	changes: Boolean$4,
-	status: Literals$2([
-		"idle",
-		"running",
-		"ok",
-		"failed",
-		"skipped"
-	]),
-	doing: optionalKey(String$5),
-	detail: optionalKey(String$5),
-	output: optionalKey(ArraySchema(String$5)),
-	steps: ArraySchema(String$5),
-	started: optionalKey(Number$2),
-	ended: optionalKey(Number$2)
-});
-const MachineEntry = Struct({
-	name: String$5,
-	status: Literals$2([
-		"gathering",
-		"gathered",
-		"planned",
-		"running",
-		"ok",
-		"skipped",
-		"failed"
-	]),
-	detail: optionalKey(String$5),
-	output: optionalKey(ArraySchema(String$5)),
-	items: ArraySchema(Item),
-	started: optionalKey(Number$2),
-	ended: optionalKey(Number$2)
-});
-const LedgerState = Struct({
-	from: String$5,
-	dryRun: Boolean$4,
-	notes: ArraySchema(Note),
-	machines: ArraySchema(MachineEntry),
-	started: Number$2,
-	ended: optionalKey(Number$2)
-});
-const short = (sha) => sha === void 0 ? void 0 : sha.slice(0, 7);
-const FETCH = ":fetch";
-const doingOf = (id) => id === "config" ? "copying" : id.endsWith(FETCH) ? "fetching" : "installing";
-const itemsOf = (p, state) => {
-	const items = /* @__PURE__ */ new Map();
-	const key = (kind, name) => `${kind}:${name}`;
-	const base = (name, from, kind = "version") => ({
-		name,
-		kind,
-		...from === void 0 ? {} : { from },
-		changes: false,
-		status: "idle",
-		steps: []
-	});
-	const set = (name, change, kind = "version") => items.set(key(kind, name), change(items.get(key(kind, name)) ?? base(name, void 0, kind)));
-	const plans = (id, to, from, reason) => ({ from: gathered, ...item }) => {
-		const now = from === void 0 ? gathered : from ?? void 0;
-		return {
-			...item,
-			...now === void 0 ? {} : { from: now },
-			to,
-			...reason === void 0 ? {} : { reason },
-			changes: true,
-			steps: [...item.steps, id]
-		};
-	};
-	const vp = state.vp?.version ?? void 0;
-	items.set(key("version", "vp"), base("vp", vp));
-	if (state.node != null) items.set(key("version", "node"), base("node", state.node));
-	for (const g of state.globals) items.set(key("version", g.name), base(g.name, g.version));
-	for (const step of p.vp) {
-		const id = vpStepId(step);
-		switch (step.kind) {
-			case "bootstrap":
-				set("vp", plans(id, "latest", null));
-				break;
-			case "vp":
-			case "node":
-				set(step.kind, plans(id, step.version, step.from));
-				break;
-			case "reinstall":
-				set(step.name, plans(id, step.version, step.version, "reinstall"));
-				break;
-			case "globals": for (const pkg of step.packages) set(pkg.name, plans(id, pkg.version, pkg.from ?? null));
-		}
-	}
-	for (const repo of p.repos) {
-		const from = short(state.records[repo.name]?.commit);
-		const to = short(repo.head);
-		items.set(key("repo", repo.name), {
-			name: repo.name,
-			kind: "repo",
-			...from === void 0 ? {} : { from },
-			...to === void 0 ? {} : { to },
-			...repo.decision.run ? { reason: repo.decision.reason } : {},
-			changes: repo.decision.run,
-			status: "idle",
-			steps: [stepId(repo.name, "fetch"), stepId(repo.name, "install")]
-		});
-	}
-	for (const s of p.skipped) set(s.what, (i) => ({
-		...i,
-		status: "skipped",
-		detail: s.reason
-	}));
-	for (const f of p.failures) {
-		const kind = f.section === "repos" ? "repo" : "version";
-		set(f.what, (i) => ({
-			...i,
-			changes: true,
-			status: "failed",
-			detail: f.reason
-		}), kind);
-	}
-	items.set(key("config", CONFIG_STEP), {
-		name: CONFIG_STEP,
-		kind: "config",
-		changes: false,
-		status: "idle",
-		steps: [CONFIG_STEP]
-	});
-	return [...items.values()];
-};
-const outcomeOf = (m, dryRun) => m.status === "skipped" ? "skipped" : m.status === "failed" || m.items.some((i) => i.status === "failed") ? "failed" : m.status === "ok" || m.status === "planned" && dryRun ? "ok" : void 0;
-const tally = (state) => {
-	const outcomes = state.machines.map((m) => outcomeOf(m, state.dryRun));
-	const n = (o) => outcomes.filter((x) => x === o).length;
-	return {
-		ok: n("ok"),
-		skipped: n("skipped"),
-		failed: n("failed")
-	};
-};
-const makeLedger = fn("makeLedger")(function* (input) {
-	const started = yield* currentTimeMillis;
-	let snapshot = {
-		state: {
-			from: input.from,
-			dryRun: input.dryRun,
-			notes: [],
-			machines: input.machines.map((name) => ({
-				name,
-				status: "gathering",
-				items: []
-			})),
-			started
-		},
-		now: started
-	};
-	const listeners = /* @__PURE__ */ new Set();
-	const update = (change) => gen(function* () {
-		const now = yield* currentTimeMillis;
-		snapshot = {
-			state: change(snapshot.state, now),
-			now
-		};
-		for (const listener of listeners) listener();
-	});
-	const machine = (name, change) => update((state, now) => ({
-		...state,
-		machines: state.machines.map((m) => m.name === name ? change(m, now) : m)
-	}));
-	const items = (name, id, change) => machine(name, (m, now) => ({
-		...m,
-		items: m.items.map((i) => i.steps.includes(id) ? change(i, now) : i)
-	}));
-	const store = {
-		get: () => snapshot,
-		subscribe: (listener) => {
-			listeners.add(listener);
-			return () => listeners.delete(listener);
-		},
-		tick: update((state) => state)
-	};
-	return {
-		ledger: {
-			note: fn("ledger.note")(function* (kind, text) {
-				yield* update((state) => ({
-					...state,
-					notes: [...state.notes, {
-						kind,
-						text
-					}]
-				}));
-				yield* log(noteText({
-					kind,
-					text
-				}, styled()));
-			}),
-			gathered: (name) => machine(name, (m) => ({
-				...m,
-				status: "gathered"
-			})),
-			skip: (name, reason) => machine(name, (m) => ({
-				...m,
-				status: "skipped",
-				detail: reason
-			})),
-			fail: (name, [reason = "failed", ...output]) => machine(name, (m, now) => ({
-				...m,
-				status: "failed",
-				detail: reason,
-				...output.length === 0 ? {} : { output },
-				ended: now
-			})),
-			plan: (name, p, state) => machine(name, (m) => ({
-				...m,
-				status: "planned",
-				items: itemsOf(p, state)
-			})),
-			start: (name) => machine(name, (m, now) => ({
-				...m,
-				status: "running",
-				started: now
-			})),
-			stepStarted: (name, id) => items(name, id, (item, now) => item.status === "failed" ? item : {
-				...item,
-				changes: item.changes || !(id === "config" || id.endsWith(FETCH)),
-				status: "running",
-				doing: doingOf(id),
-				started: item.started ?? now
-			}),
-			stepDone: (name, id, result) => items(name, id, (item, now) => {
-				if (item.status === "failed") return item;
-				if (!result.ok) return {
-					...item,
-					changes: true,
-					status: "failed",
-					detail: result.detail,
-					...result.output.length === 0 ? {} : { output: result.output },
-					ended: now
-				};
-				const { doing: _, ...rest } = item;
-				if (id.endsWith(FETCH)) return item.changes ? item : {
-					...rest,
-					status: "idle",
-					ended: now
-				};
-				return {
-					...rest,
-					status: "ok",
-					ended: now
-				};
-			}),
-			fetched: (name, repo, head) => machine(name, (m) => ({
-				...m,
-				items: m.items.map((i) => i.kind === "repo" && i.name === repo ? {
-					...i,
-					to: head.slice(0, 7),
-					changes: i.changes || head.slice(0, 7) !== i.from
-				} : i)
-			})),
-			finish: (name, outcome) => machine(name, (m, now) => ({
-				...m,
-				status: m.status === "failed" ? "failed" : outcome,
-				ended: m.ended ?? now
-			})),
-			end: gen(function* () {
-				yield* update((state, now) => ({
-					...state,
-					ended: now,
-					machines: state.machines.map((m) => m.status === "running" || m.status === "gathering" ? {
-						...m,
-						status: "failed",
-						detail: "stopped",
-						ended: now,
-						items: m.items.map((i) => i.status === "running" ? {
-							...i,
-							status: "failed",
-							detail: "stopped",
-							ended: now
-						} : i)
-					} : m)
-				}));
-				return snapshot.state;
-			})
-		},
-		store
-	};
-});
-const duration = (ms) => {
-	const s = ms / 1e3;
-	if (s < 60) return `${s.toFixed(1)}s`;
-	const m = Math.floor(s / 60);
-	if (m < 60) return `${m}m ${String(Math.floor(s % 60)).padStart(2, "0")}s`;
-	return `${Math.floor(m / 60)}h ${String(m % 60).padStart(2, "0")}m`;
-};
-const value = (i) => i.to === void 0 ? i.from ?? "" : i.from === void 0 ? `+ ${i.to}` : i.from === i.to ? i.to : `${i.from} -> ${i.to}`;
-const note = (i) => {
-	switch (i.status) {
-		case "running": return {
-			text: i.doing ?? "running",
-			style: "run"
-		};
-		case "failed": return {
-			text: "FAIL",
-			style: "fail"
-		};
-		case "skipped": return {
-			text: "SKIP",
-			style: "skip"
-		};
-		case "ok":
-			if (i.kind === "config") return {
-				text: "copied",
-				style: "dim"
-			};
-			if (i.kind === "repo") return i.from !== void 0 && i.from === i.to ? {
-				text: `rebuilt${i.reason === void 0 ? "" : `: ${i.reason}`}`,
-				style: "ok"
-			} : {
-				text: "installed",
-				style: "ok"
-			};
-			return {
-				text: i.reason ?? "done",
-				style: "ok"
-			};
-		case "idle":
-			if (i.changes) return {
-				text: i.reason ?? "",
-				style: "dim"
-			};
-			return {
-				text: i.kind === "repo" ? "up to date" : "",
-				style: "dim"
-			};
-	}
-};
-const elapsed = (started, ended, now) => started === void 0 ? "" : duration((ended ?? now) - started);
-const LIVE_OUTPUT = 12;
-const outputRows = (output, indent, running) => {
-	const cut = running && output.length > LIVE_OUTPUT;
-	const shown = cut ? output.slice(-12) : output;
-	return [...cut ? [[{
-		text: `${indent}(${output.length - LIVE_OUTPUT} earlier lines)`,
-		style: "dim"
-	}]] : [], ...shown.map((line) => [{ text: `${indent}${line}` }])];
-};
-const pad = (text, width) => text.padEnd(width);
-const rows = (state, options) => {
-	const { full, now, live } = options;
-	const running = live && state.ended === void 0;
-	const shownItems = (m) => m.items.filter((i) => full || i.changes || i.status === "failed" || i.status === "skipped");
-	const visible = state.machines.flatMap(shownItems);
-	const nameW = Math.max(0, ...state.machines.map((m) => m.name.length));
-	const itemW = Math.max(0, ...visible.map((i) => i.name.length));
-	const valueW = Math.max(0, ...visible.map((i) => value(i).length));
-	const noteW = Math.max(0, ...visible.map((i) => note(i).text.length));
-	const out = [[]];
-	for (const m of state.machines) {
-		const items = shownItems(m);
-		const upToDate = !m.items.some((i) => i.changes);
-		const head = [{
-			text: pad(m.name, nameW),
-			style: "bold"
-		}, { text: "  " }];
-		const time = {
-			text: elapsed(m.started, m.ended, now),
-			style: "dim"
-		};
-		switch (m.status) {
-			case "gathering":
-			case "gathered":
-				head.push({ text: "      " }, {
-					text: m.status,
-					style: "dim"
-				});
-				break;
-			case "planned":
-				if (m.items.some((i) => i.status === "failed")) head.push({
-					text: "FAIL",
-					style: "fail"
-				});
-				else head.push({ text: "      " }, {
-					text: upToDate ? "up to date" : "",
-					style: "dim"
-				});
-				break;
-			case "running":
-				head.push({
-					text: "RUN ",
-					style: "run"
-				}, { text: "  " }, time);
-				break;
-			case "ok":
-				head.push({
-					text: "OK  ",
-					style: "ok"
-				}, { text: "  " });
-				head.push(upToDate ? {
-					text: "up to date",
-					style: "dim"
-				} : time);
-				break;
-			case "skipped":
-				head.push({
-					text: "SKIP",
-					style: "skip"
-				}, { text: "  " }, { text: m.detail ?? "" });
-				break;
-			case "failed":
-				head.push({
-					text: "FAIL",
-					style: "fail"
-				}, { text: "  " });
-				head.push(m.detail === void 0 ? time : { text: m.detail });
-		}
-		out.push(head);
-		for (const i of items) {
-			const n = note(i);
-			const t = elapsed(i.started, i.ended, now);
-			const idle = i.status === "idle" && !i.changes;
-			out.push([
-				{
-					text: `    ${pad(i.name, itemW)}  `,
-					...idle ? { style: "dim" } : {}
-				},
-				{
-					text: pad(value(i), valueW),
-					...idle ? { style: "dim" } : {}
-				},
-				{ text: "  " },
-				{
-					text: pad(n.text, noteW),
-					...n.style === void 0 ? {} : { style: n.style }
-				},
-				{
-					text: t === "" ? "" : `  ${t.padStart(6)}`,
-					style: "dim"
-				},
-				...i.detail === void 0 ? [] : [{ text: `  ${i.detail}` }]
-			]);
-			if (i.output !== void 0) out.push(...outputRows(i.output, "      ", running));
-		}
-		if (m.output !== void 0) out.push(...outputRows(m.output, "    ", running));
-	}
-	out.push([]);
-	if (state.ended !== void 0) {
-		const t = tally(state);
-		out.push([
-			{
-				text: `${state.dryRun ? "planned" : "ok"} ${t.ok}`,
-				...t.failed === 0 ? { style: "ok" } : {}
-			},
-			{ text: `  skipped ${t.skipped}  ` },
-			{
-				text: `failed ${t.failed}`,
-				...t.failed > 0 ? { style: "fail" } : {}
-			},
-			...state.dryRun ? [] : [{
-				text: `  in ${duration(state.ended - state.started)}`,
-				style: "dim"
-			}]
-		]);
-	}
-	if (live) {
-		const legend = state.ended === void 0 ? `f ${full ? "changes only" : "full list"}  ·  ctrl-c stop` : state.dryRun ? void 0 : "full report: fizz report";
-		if (legend !== void 0) out.push([{
-			text: legend,
-			style: "dim"
-		}]);
-	}
-	while (out.length > 0 && out[out.length - 1]?.length === 0) out.pop();
-	return out;
-};
-const noteRow = (n) => n.kind === "ask" ? [{
-	text: "?",
-	style: "ask"
-}, { text: ` ${n.text}` }] : n.kind === "answer" ? [{
-	text: `  -> ${n.text}`,
-	style: "dim"
-}] : [{ text: n.text }];
-const ANSI = {
-	dim: "\x1B[2m",
-	bold: "\x1B[1m",
-	ok: "\x1B[32m",
-	fail: "\x1B[1;31m",
-	skip: "\x1B[33m",
-	run: "\x1B[34m",
-	ask: "\x1B[1;35m"
-};
-const styled = () => Boolean(process.stdout.isTTY) && process.env.NO_COLOR === void 0;
-const rowText = (row, color) => row.map((s) => color && s.style !== void 0 && s.text !== "" ? `${ANSI[s.style]}${s.text}\u001b[0m` : s.text).join("").trimEnd();
-const noteText = (n, color) => rowText(noteRow(n), color);
-const printRows = (list, color = styled()) => log(list.map((row) => rowText(row, color)).join("\n"));
-//#endregion
-//#region src/report.ts
-const reportPath = () => `${STATE_DIR.replace(/^~/, process.env.HOME ?? "~")}/last-ship.json`;
-const LedgerJson = fromJsonString(LedgerState);
-const encode = encodeEffect(LedgerJson);
-const decode = decodeEffect(LedgerJson);
-const saveReport = fn("saveReport")(function* (state) {
-	const fs = yield* FileSystem;
-	const path = reportPath();
-	yield* fs.makeDirectory(path.slice(0, path.lastIndexOf("/")), { recursive: true });
-	yield* fs.writeFileString(path, yield* encode(state));
-});
-const report = fn("report")(function* () {
-	const fs = yield* FileSystem;
-	const path = reportPath();
-	if (!(yield* fs.exists(path))) return yield* log("no Ship from this Machine yet");
-	const state = yield* decode(yield* fs.readFileString(path));
-	const when = formatLocal(makeUnsafe(state.started), {
-		dateStyle: "medium",
-		timeStyle: "short"
-	});
-	yield* printRows([
-		[{
-			text: `last Ship ${when} from ${state.from}`,
-			style: "dim"
-		}],
-		...state.notes.map(noteRow),
-		...rows(state, {
-			full: true,
-			now: state.ended ?? state.started,
-			live: false
-		})
-	]);
-});
-//#endregion
 //#region ../../node_modules/.pnpm/react@19.3.0/node_modules/react/cjs/react.production.js
 /**
 * @license React
@@ -37981,8 +37488,8 @@ const exitAlternativeScreen = "\x1B[?1049l";
 //#endregion
 //#region ../../node_modules/.pnpm/is-in-ci@2.0.0/node_modules/is-in-ci/index.js
 var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
-const check = (key) => key in env && env[key] !== "0" && env[key] !== "false";
-const isInCi = check("CI") || check("CONTINUOUS_INTEGRATION");
+const check$1 = (key) => key in env && env[key] !== "0" && env[key] !== "false";
+const isInCi = check$1("CI") || check$1("CONTINUOUS_INTEGRATION");
 //#endregion
 //#region ../../node_modules/.pnpm/auto-bind@5.0.1/node_modules/auto-bind/index.js
 const getAllProperties = (object) => {
@@ -64506,6 +64013,79 @@ const getInstance = (stdout, createInstance) => {
 	return instance;
 };
 //#endregion
+//#region ../../node_modules/.pnpm/ink@8.0.0_@types+react@19.3.0_react@19.3.0/node_modules/ink/build/render-to-string.js
+/**
+Render a React element to a string synchronously. Unlike `render()`, this function does not write to stdout, does not set up any terminal event listeners, and returns the rendered output as a string.
+
+Useful for generating documentation, writing output to files, testing, or any scenario where you need the rendered output as a string without starting a persistent terminal application.
+
+**Notes:**
+
+- Terminal-specific hooks (`useInput`, `useStdin`, `useStdout`, `useStderr`, `useApp`, `useFocus`, `useFocusManager`) return default no-op values since there is no terminal session. They will not throw, but they will not function as in a live terminal.
+- `useEffect` callbacks will execute during rendering (due to synchronous rendering mode), but state updates they trigger will not affect the returned output, which reflects the initial render.
+- `useLayoutEffect` callbacks fire synchronously during commit, so state updates they trigger **will** be reflected in the output.
+- The `<Static>` component is supported — its output is prepended to the dynamic output.
+- If a component throws during rendering, the error is propagated to the caller after cleanup.
+
+@example
+```
+import {renderToString, Text, Box} from 'ink';
+
+const output = renderToString(
+<Box padding={1}>
+<Text color="green">Hello World</Text>
+</Box>,
+{columns: 40}
+);
+
+console.log(output);
+```
+*/
+const renderToString = (node, options) => {
+	const columns = options?.columns ?? 80;
+	const rootNode = createNode("ink-root");
+	let capturedStaticOutput = "";
+	rootNode.onStaticChange = () => {
+		capturedStaticOutput = "";
+	};
+	rootNode.onComputeLayout = () => {
+		rootNode.yogaNode.setWidth(columns);
+		rootNode.yogaNode.calculateLayout(void 0, void 0, Yoga.DIRECTION_LTR);
+	};
+	rootNode.onImmediateRender = () => {
+		const { staticOutput } = renderer(rootNode, false);
+		if (staticOutput !== "") capturedStaticOutput += staticOutput;
+	};
+	let uncaughtError;
+	const container = reconciler_default.createContainer(rootNode, import_constants.LegacyRoot, null, false, null, "render-to-string", (error) => {
+		uncaughtError ??= types.isNativeError(error) ? error : new Error(String(error));
+	}, () => {}, () => {}, () => {}, null);
+	let didTeardownSucceed = false;
+	try {
+		let output;
+		let outputHeight;
+		let staticOutput;
+		try {
+			reconciler_default.updateContainerSync((0, import_react.createElement)(RootNodeContext.Provider, { value: rootNode }, node), container, null, () => {});
+			reconciler_default.flushSyncWork();
+			({output, outputHeight} = renderer(rootNode, false));
+			staticOutput = capturedStaticOutput;
+		} finally {
+			reconciler_default.updateContainerSync(null, container, null, () => {});
+			reconciler_default.flushSyncWork();
+			didTeardownSucceed = true;
+			rootNode.yogaNode.free();
+		}
+		if (uncaughtError !== void 0) throw uncaughtError;
+		if (outputHeight > 0) return staticOutput + output;
+		return staticOutput.endsWith("\n") ? staticOutput.slice(0, -1) : staticOutput;
+	} finally {
+		if (!didTeardownSucceed && rootNode.yogaNode) try {
+			rootNode.yogaNode.freeRecursive();
+		} catch {}
+	}
+};
+//#endregion
 //#region ../../node_modules/.pnpm/ink@8.0.0_@types+react@19.3.0_react@19.3.0/node_modules/ink/build/hooks/use-stdin.js
 /**
 A React hook that returns the stdin stream and stdin-related utilities.
@@ -64591,6 +64171,332 @@ const useInput = (inputHandler, options = {}) => {
 	}, [options.isActive, internal_eventEmitter]);
 };
 //#endregion
+//#region ../../node_modules/.pnpm/ink@8.0.0_@types+react@19.3.0_react@19.3.0/node_modules/ink/build/hooks/use-stdout.js
+/**
+A React hook that returns the stdout stream where Ink renders your app.
+*/
+function useStdout() {
+	return (0, import_react.use)(StdoutContext);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ink@8.0.0_@types+react@19.3.0_react@19.3.0/node_modules/ink/build/hooks/use-window-size.js
+/**
+A React hook that returns the current terminal window dimensions and re-renders the component whenever the terminal is resized.
+*/
+const useWindowSize = () => {
+	const { stdout } = useStdout();
+	const [size, setSize] = (0, import_react.useState)(() => getWindowSize(stdout));
+	(0, import_react.useEffect)(() => {
+		const onResize = () => {
+			setSize(getWindowSize(stdout));
+		};
+		stdout.on("resize", onResize);
+		onResize();
+		return () => {
+			stdout.off("resize", onResize);
+		};
+	}, [stdout]);
+	return size;
+};
+//#endregion
+//#region src/ledger.ts
+const Note = Struct({
+	kind: Literals$2([
+		"ask",
+		"answer",
+		"info"
+	]),
+	text: String$5
+});
+const Item = Struct({
+	name: String$5,
+	kind: Literals$2([
+		"version",
+		"repo",
+		"config"
+	]),
+	from: optionalKey(String$5),
+	to: optionalKey(String$5),
+	reason: optionalKey(String$5),
+	changes: Boolean$4,
+	status: Literals$2([
+		"idle",
+		"running",
+		"ok",
+		"failed",
+		"skipped"
+	]),
+	doing: optionalKey(String$5),
+	detail: optionalKey(String$5),
+	output: optionalKey(ArraySchema(String$5)),
+	steps: ArraySchema(String$5),
+	started: optionalKey(Number$2),
+	ended: optionalKey(Number$2)
+});
+const MachineEntry = Struct({
+	name: String$5,
+	status: Literals$2([
+		"checking",
+		"waiting",
+		"planned",
+		"running",
+		"ok",
+		"skipped",
+		"failed"
+	]),
+	detail: optionalKey(String$5),
+	output: optionalKey(ArraySchema(String$5)),
+	items: ArraySchema(Item),
+	started: optionalKey(Number$2),
+	ended: optionalKey(Number$2)
+});
+const LedgerState = Struct({
+	from: String$5,
+	dryRun: Boolean$4,
+	notes: ArraySchema(Note),
+	machines: ArraySchema(MachineEntry),
+	started: Number$2,
+	ended: optionalKey(Number$2)
+});
+const short = (sha) => sha === void 0 ? void 0 : sha.slice(0, 7);
+const doingOf = (id) => id === "config" ? "copying" : isFetchStep(id) ? "fetching" : "installing";
+const itemsOf = (p, state) => {
+	const items = /* @__PURE__ */ new Map();
+	const key = (kind, name) => `${kind}:${name}`;
+	const base = (name, from, kind = "version") => ({
+		name,
+		kind,
+		...from === void 0 ? {} : { from },
+		changes: false,
+		status: "idle",
+		steps: []
+	});
+	const set = (name, change, kind = "version") => items.set(key(kind, name), change(items.get(key(kind, name)) ?? base(name, void 0, kind)));
+	const plans = (id, to, from, reason) => ({ from: checked, ...item }) => {
+		const now = from === void 0 ? checked : from ?? void 0;
+		return {
+			...item,
+			...now === void 0 ? {} : { from: now },
+			to,
+			...reason === void 0 ? {} : { reason },
+			changes: true,
+			steps: [...item.steps, id]
+		};
+	};
+	const vp = state.vp?.version ?? void 0;
+	items.set(key("version", "vp"), base("vp", vp));
+	if (state.node != null) items.set(key("version", "node"), base("node", state.node));
+	for (const g of state.globals) items.set(key("version", g.name), base(g.name, g.version));
+	for (const step of p.vp) {
+		const id = vpStepId(step);
+		switch (step.kind) {
+			case "bootstrap":
+				set("vp", plans(id, "latest", null));
+				break;
+			case "vp":
+			case "node":
+				set(step.kind, plans(id, step.version, step.from));
+				break;
+			case "reinstall":
+				set(step.name, plans(id, step.version, step.version, "reinstall"));
+				break;
+			case "globals": for (const pkg of step.packages) set(pkg.name, plans(id, pkg.version, pkg.from ?? null));
+		}
+	}
+	for (const repo of p.repos) {
+		const from = short(state.records[repo.name]?.commit);
+		const to = short(repo.head);
+		items.set(key("repo", repo.name), {
+			name: repo.name,
+			kind: "repo",
+			...from === void 0 ? {} : { from },
+			...to === void 0 ? {} : { to },
+			...repo.decision.run ? { reason: repo.decision.reason } : {},
+			changes: repo.decision.run,
+			status: "idle",
+			steps: [stepId(repo.name, "fetch"), stepId(repo.name, "install")]
+		});
+	}
+	for (const s of p.skipped) set(s.what, (i) => ({
+		...i,
+		status: "skipped",
+		detail: s.reason
+	}));
+	for (const f of p.failures) {
+		const kind = f.section === "repos" ? "repo" : "version";
+		set(f.what, (i) => ({
+			...i,
+			changes: true,
+			status: "failed",
+			detail: f.reason
+		}), kind);
+	}
+	items.set(key("config", CONFIG_STEP), {
+		name: CONFIG_STEP,
+		kind: "config",
+		changes: false,
+		status: "idle",
+		steps: [CONFIG_STEP]
+	});
+	return [...items.values()];
+};
+const outcomeOf = (m, dryRun) => m.status === "skipped" ? "skipped" : m.status === "failed" || m.items.some((i) => i.status === "failed") ? "failed" : m.status === "ok" || m.status === "planned" && dryRun ? "ok" : void 0;
+const anyFailed = (state) => state.machines.some((m) => outcomeOf(m, state.dryRun) === "failed");
+const makeLedger = fn("makeLedger")(function* (input) {
+	const started = yield* currentTimeMillis;
+	let snapshot = {
+		state: {
+			from: input.from,
+			dryRun: input.dryRun,
+			notes: [],
+			machines: input.machines.map((name) => ({
+				name,
+				status: "checking",
+				items: []
+			})),
+			started
+		},
+		now: started
+	};
+	const listeners = /* @__PURE__ */ new Set();
+	const update = (change) => gen(function* () {
+		const now = yield* currentTimeMillis;
+		snapshot = {
+			state: change(snapshot.state, now),
+			now
+		};
+		for (const listener of listeners) listener();
+	});
+	const machine = (name, change) => update((state, now) => ({
+		...state,
+		machines: state.machines.map((m) => m.name === name ? change(m, now) : m)
+	}));
+	const items = (name, id, change) => machine(name, (m, now) => ({
+		...m,
+		items: m.items.map((i) => i.steps.includes(id) ? change(i, now) : i)
+	}));
+	const store = {
+		get: () => snapshot,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		tick: update((state) => state)
+	};
+	return {
+		ledger: {
+			note: fn("ledger.note")(function* (kind, text) {
+				yield* update((state) => ({
+					...state,
+					notes: [...state.notes, {
+						kind,
+						text
+					}]
+				}));
+				yield* input.print({
+					kind,
+					text
+				});
+			}),
+			checked: (name) => machine(name, (m) => ({
+				...m,
+				status: "waiting"
+			})),
+			skip: (name, reason) => machine(name, (m) => ({
+				...m,
+				status: "skipped",
+				detail: reason
+			})),
+			fail: (name, [reason = "failed", ...output]) => machine(name, (m, now) => ({
+				...m,
+				status: "failed",
+				detail: reason,
+				...output.length === 0 ? {} : { output },
+				ended: now
+			})),
+			plan: (name, p, state) => machine(name, (m) => ({
+				...m,
+				status: "planned",
+				items: itemsOf(p, state)
+			})),
+			start: (name) => machine(name, (m, now) => ({
+				...m,
+				status: "running",
+				started: now
+			})),
+			stepStarted: (name, id) => items(name, id, (item, now) => item.status === "failed" ? item : {
+				...item,
+				changes: item.changes || !(id === "config" || isFetchStep(id)),
+				status: "running",
+				doing: doingOf(id),
+				started: item.started ?? now
+			}),
+			stepDone: (name, id, result) => items(name, id, (item, now) => {
+				if (item.status === "failed") return item;
+				if (!result.ok) return {
+					...item,
+					changes: true,
+					status: "failed",
+					detail: result.detail,
+					...result.output.length === 0 ? {} : { output: result.output },
+					ended: now
+				};
+				const { doing: _, ...rest } = item;
+				if (isFetchStep(id)) return item.changes ? item : {
+					...rest,
+					status: "idle",
+					ended: now
+				};
+				return {
+					...rest,
+					status: "ok",
+					ended: now
+				};
+			}),
+			fetched: (name, repo, head) => machine(name, (m) => ({
+				...m,
+				items: m.items.map((i) => i.kind === "repo" && i.name === repo ? {
+					...i,
+					to: head.slice(0, 7),
+					changes: i.changes || head.slice(0, 7) !== i.from
+				} : i)
+			})),
+			finish: (name, outcome) => machine(name, (m, now) => ({
+				...m,
+				status: m.status === "failed" ? "failed" : outcome,
+				ended: m.ended ?? now
+			})),
+			end: gen(function* () {
+				yield* update((state, now) => ({
+					...state,
+					ended: now,
+					machines: state.machines.map((m) => m.status === "running" || m.status === "checking" ? {
+						...m,
+						status: "failed",
+						detail: "stopped",
+						ended: now,
+						items: m.items.map((i) => i.status === "running" ? {
+							...i,
+							status: "failed",
+							detail: "stopped",
+							ended: now
+						} : i)
+					} : m)
+				}));
+				return snapshot.state;
+			})
+		},
+		store
+	};
+});
+const duration = (ms) => {
+	const s = ms / 1e3;
+	if (s < 60) return `${s.toFixed(1)}s`;
+	const m = Math.floor(s / 60);
+	if (m < 60) return `${m}m ${String(Math.floor(s % 60)).padStart(2, "0")}s`;
+	return `${Math.floor(m / 60)}h ${String(m % 60).padStart(2, "0")}m`;
+};
+//#endregion
 //#region ../../node_modules/.pnpm/react@19.3.0/node_modules/react/cjs/react-jsx-runtime.production.js
 /**
 * @license React
@@ -64838,12 +64744,12 @@ var require_react_jsx_runtime_development = /* @__PURE__ */ __commonJSMin(((expo
 	})();
 }));
 //#endregion
-//#region src/live.tsx
+//#region src/view.tsx
 var import_jsx_runtime = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	if (process.env.NODE_ENV === "production") module.exports = require_react_jsx_runtime_production();
 	else module.exports = require_react_jsx_runtime_development();
 })))();
-const STYLE = {
+const TONE = {
 	dim: { dimColor: true },
 	bold: { bold: true },
 	ok: { color: "green" },
@@ -64858,6 +64764,431 @@ const STYLE = {
 		bold: true
 	}
 };
+const ModeContext = (0, import_react.createContext)({
+	color: false,
+	live: false
+});
+const T = (props) => {
+	const { color } = (0, import_react.useContext)(ModeContext);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, {
+		...color && props.tone !== void 0 ? TONE[props.tone] : {},
+		children: props.children
+	});
+};
+const Line = (props) => {
+	const { live } = (0, import_react.useContext)(ModeContext);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Box, {
+		paddingLeft: props.indent ?? 0,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, {
+			wrap: live ? "truncate-end" : "wrap",
+			children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(T, {
+				tone: props.tone,
+				children: props.children
+			})
+		})
+	});
+};
+const Cell = (props) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Box, {
+	width: props.width,
+	flexShrink: 0,
+	justifyContent: props.right ? "flex-end" : "flex-start",
+	children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, {
+		wrap: "truncate-end",
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(T, {
+			tone: props.tone,
+			children: props.children
+		})
+	})
+});
+const value = (i) => i.to === void 0 ? i.from ?? "" : i.from === void 0 ? `+ ${i.to}` : i.from === i.to ? i.to : `${i.from} → ${i.to}`;
+const statusOf = (i, dryRun) => {
+	switch (i.status) {
+		case "running": return {
+			text: `▸ ${i.doing ?? "running"}`,
+			tone: "run"
+		};
+		case "failed": return {
+			text: "✗ failed",
+			tone: "fail",
+			detail: i.detail
+		};
+		case "skipped": return {
+			text: "– skipped",
+			tone: "skip",
+			detail: i.detail
+		};
+		case "ok":
+			if (i.kind === "config") return {
+				text: "✓ copied",
+				tone: "dim"
+			};
+			if (i.kind === "repo") return i.from !== void 0 && i.from === i.to ? {
+				text: "✓ rebuilt",
+				tone: "ok",
+				detail: i.reason
+			} : {
+				text: "✓ installed",
+				tone: "ok"
+			};
+			return {
+				text: "✓ done",
+				tone: "ok",
+				detail: i.reason
+			};
+		case "idle":
+			if (i.changes) return {
+				text: dryRun ? "· planned" : "· queued",
+				tone: "dim",
+				detail: i.reason
+			};
+			return {
+				text: "",
+				detail: i.kind === "repo" ? "up to date" : void 0
+			};
+	}
+};
+const countsOf = (m) => {
+	const changes = m.items.filter((i) => i.changes && i.status !== "skipped");
+	return {
+		changes: changes.length,
+		done: changes.filter((i) => i.status === "ok").length,
+		failed: m.items.filter((i) => i.status === "failed").length,
+		skipped: m.items.filter((i) => i.status === "skipped").length
+	};
+};
+const settled = (m, dryRun) => dryRun || m.status === "ok" || m.status === "failed";
+const upToDate = (m, dryRun) => {
+	const c = countsOf(m);
+	return c.changes === 0 && c.skipped === 0 && settled(m, dryRun);
+};
+const summaryOf = (m, dryRun) => {
+	if (m.status === "checking" || m.status === "waiting") return [{
+		text: m.status,
+		tone: "dim"
+	}];
+	if (m.status === "skipped") return [{
+		text: "– skipped",
+		tone: "skip"
+	}, { text: `  ${m.detail ?? ""}` }];
+	if (m.status === "failed" && m.detail !== void 0) return [{
+		text: "✗ failed",
+		tone: "fail"
+	}, { text: `  ${m.detail}` }];
+	const { changes, done, failed, skipped } = countsOf(m);
+	if (changes === 0 && skipped === 0) return [{
+		text: "up to date",
+		tone: settled(m, dryRun) ? "ok" : "dim"
+	}];
+	const finished = m.status === "ok" || m.status === "failed";
+	const parts = [];
+	if (dryRun && m.status === "planned") {
+		if (changes > failed) parts.push({
+			text: `${changes - failed} to change`,
+			tone: "dim"
+		});
+	} else if (changes > 0 && (!finished || done > 0)) parts.push({
+		text: `${done} of ${changes} done`,
+		tone: done === changes ? "ok" : "dim"
+	});
+	if (failed > 0) parts.push({
+		text: `${failed} failed`,
+		tone: "fail"
+	});
+	if (skipped > 0) parts.push({
+		text: `${skipped} skipped`,
+		tone: "skip"
+	});
+	return joined(parts);
+};
+const joined = (parts) => parts.flatMap((part, n) => n === 0 ? [part] : [{
+	text: ", ",
+	tone: "dim"
+}, part]);
+const shipSummary = (state) => {
+	const outcomes = state.machines.map((m) => {
+		const outcome = outcomeOf(m, state.dryRun);
+		if (outcome !== "ok") return outcome;
+		const { changes, skipped } = countsOf(m);
+		if (changes > 0) return state.dryRun ? "to change" : "updated";
+		return skipped > 0 ? "skipped" : "up to date";
+	});
+	const counted = (outcome, tone) => {
+		const n = outcomes.filter((o) => o === outcome).length;
+		return n === 0 ? [] : [{
+			text: `${n} ${outcome}`,
+			tone
+		}];
+	};
+	const parts = joined([
+		...counted("updated", "ok"),
+		...counted("to change", "dim"),
+		...counted("up to date", "ok"),
+		...counted("failed", "fail"),
+		...counted("skipped", "skip")
+	]);
+	return parts.length === 0 ? [{
+		text: "nothing changed",
+		tone: "dim"
+	}] : parts;
+};
+const elapsed = (started, ended, now) => started === void 0 ? "" : duration((ended ?? now) - started);
+const Parts = (props) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Line, { children: props.parts.map((part, n) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(T, {
+	tone: part.tone,
+	children: part.text
+}, n)) });
+const GAP = 2;
+const INDENT = 2;
+const nameAt = (w) => w.status + GAP + INDENT;
+const LIVE_OUTPUT = 12;
+const outputLines = (key, output, indent, cut) => {
+	const hidden = cut ? Math.max(0, output.length - LIVE_OUTPUT) : 0;
+	return [...hidden > 0 ? [/* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Line, {
+		indent,
+		tone: "dim",
+		children: [
+			"(",
+			hidden,
+			" earlier lines)"
+		]
+	}, `${key}/earlier`)] : [], ...output.slice(hidden).map((line, n) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Line, {
+		indent,
+		children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(T, {
+			tone: "fail",
+			children: "│ "
+		}), line]
+	}, `${key}/${n}`))];
+};
+const MachineLine = (props) => {
+	const { m, w } = props;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Box, {
+		columnGap: GAP,
+		children: [
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Cell, {
+				width: nameAt(w) + w.item + GAP + w.value,
+				tone: "bold",
+				children: m.name
+			}),
+			w.time > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Cell, {
+				width: w.time,
+				right: true,
+				tone: "dim",
+				children: upToDate(m, props.dryRun) ? "" : elapsed(m.started, m.ended, props.now)
+			}),
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Parts, { parts: summaryOf(m, props.dryRun) })
+		]
+	});
+};
+const ItemLine = (props) => {
+	const { i, w } = props;
+	const status = statusOf(i, props.dryRun);
+	const quiet = i.status === "idle" ? "dim" : void 0;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Box, {
+		columnGap: GAP,
+		children: [
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Cell, {
+				width: w.status,
+				tone: status.tone,
+				children: status.text
+			}),
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Cell, {
+				width: INDENT + w.item,
+				tone: quiet,
+				children: `${" ".repeat(INDENT)}${i.name}`
+			}),
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Cell, {
+				width: w.value,
+				tone: quiet,
+				children: value(i)
+			}),
+			w.time > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Cell, {
+				width: w.time,
+				right: true,
+				tone: "dim",
+				children: elapsed(i.started, i.ended, props.now)
+			}),
+			status.detail !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Line, {
+				tone: quiet,
+				children: status.detail
+			})
+		]
+	});
+};
+const LedgerView = (props) => {
+	const { state, full, now, height } = props;
+	const { dryRun } = state;
+	const { live } = (0, import_react.useContext)(ModeContext);
+	const running = live && state.ended === void 0;
+	const shownItems = (m) => m.items.filter((i) => full || i.changes || i.status === "failed" || i.status === "skipped");
+	const visible = state.machines.flatMap(shownItems);
+	const width = (texts) => Math.max(0, ...texts.map((t) => t.length));
+	const item = width(visible.map((i) => i.name));
+	const status = width(visible.map((i) => statusOf(i, dryRun).text));
+	const w = {
+		status,
+		item,
+		value: Math.max(width(visible.map(value)), width(state.machines.map((m) => m.name)) - (status + GAP + INDENT + item + GAP)),
+		time: width([...visible.map((i) => elapsed(i.started, i.ended, now)), ...state.machines.map((m) => elapsed(m.started, m.ended, now))])
+	};
+	const blocks = state.machines.map((m) => ({
+		m,
+		head: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MachineLine, {
+			m,
+			w,
+			dryRun,
+			now
+		}, m.name),
+		body: [...m.output === void 0 ? [] : outputLines(m.name, m.output, nameAt(w), running), ...shownItems(m).flatMap((i) => [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(ItemLine, {
+			i,
+			w,
+			dryRun,
+			now
+		}, `${m.name}/${i.kind}:${i.name}`), ...i.output === void 0 ? [] : outputLines(`${m.name}/${i.kind}:${i.name}`, i.output, nameAt(w), running)])]
+	}));
+	const legend = state.ended === void 0 ? `f ${full ? "changes only" : "full list"}  ·  ctrl-c stop` : void 0;
+	const room = height === void 0 ? Infinity : height - (legend === void 0 ? 1 : 3);
+	const count = (bs) => bs.reduce((n, b) => n + 1 + b.body.length, Math.max(0, bs.length - 1));
+	const fits = count(blocks) <= room;
+	let spare = room - count(blocks.map((b) => ({
+		...b,
+		body: []
+	})));
+	let cuts = 0;
+	const fitted = [];
+	for (const b of blocks) {
+		const open = b.m.status === "running";
+		if (fits) fitted.push(b);
+		else if (open && b.body.length <= spare) {
+			fitted.push(b);
+			spare -= b.body.length;
+		} else if (open && spare > 0) {
+			const ellipsis = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Line, {
+				indent: nameAt(w),
+				tone: "dim",
+				children: "…"
+			}, `${b.m.name}/cut`);
+			fitted.push({
+				...b,
+				body: [...b.body.slice(0, spare - 1), ellipsis]
+			});
+			spare = 0;
+			cuts += 1;
+		} else fitted.push({
+			...b,
+			body: []
+		});
+	}
+	const lines = fitted.flatMap((b, n) => [
+		...n === 0 ? [] : [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { children: " " }, `${b.m.name}/gap`)],
+		b.head,
+		...b.body
+	]);
+	const shown = lines.length <= room ? lines : lines.slice(0, Math.max(0, room - 1));
+	const hidden = count(blocks) - (shown.length - cuts);
+	if (room < 1) return null;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Box, {
+		flexDirection: "column",
+		marginTop: 1,
+		children: [
+			shown,
+			shown.length < lines.length && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Line, {
+				tone: "dim",
+				children: "…"
+			}),
+			state.ended !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Parts, { parts: [...shipSummary(state), ...dryRun ? [] : [{
+					text: `  in ${duration(state.ended - state.started)}`,
+					tone: "dim"
+				}]] })
+			}),
+			state.ended !== void 0 && props.hint !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Line, {
+				tone: "dim",
+				children: props.hint
+			}),
+			legend !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Line, {
+					tone: "dim",
+					children: [legend, hidden > 0 && `  ·  ${hidden} lines hidden to fit the window`]
+				})
+			})
+		]
+	});
+};
+const NoteLine = (props) => {
+	const { kind, text } = props.note;
+	return kind === "ask" ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Text, { children: [
+		/* @__PURE__ */ (0, import_jsx_runtime.jsx)(T, {
+			tone: "ask",
+			children: "?"
+		}),
+		" ",
+		text
+	] }) : kind === "answer" ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(T, {
+		tone: "dim",
+		children: `  → ${text}`
+	}) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { children: text });
+};
+const Styled = (props) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ModeContext.Provider, {
+	value: {
+		color: props.color,
+		live: props.live
+	},
+	children: props.children
+});
+const colorful = () => Boolean(process.stdout.isTTY) && process.env.NO_COLOR === void 0;
+const columns = () => process.stdout.columns ?? 1e4;
+const toText = (node, color = colorful()) => renderToString(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Styled, {
+	color,
+	live: false,
+	children: node
+}), { columns: columns() });
+const ledgerText = (state, options, color) => toText(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(LedgerView, {
+	state,
+	...options
+}), color);
+const noteText = (note, color) => toText(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(NoteLine, { note }), color);
+//#endregion
+//#region src/report.tsx
+const reportPath = () => `${STATE_DIR.replace(/^~/, process.env.HOME ?? "~")}/last-ship.json`;
+const LedgerJson = fromJsonString(LedgerState);
+const encode = encodeEffect(LedgerJson);
+const decode = decodeEffect(LedgerJson);
+const saveReport = fn("saveReport")(function* (state) {
+	const fs = yield* FileSystem;
+	const path = reportPath();
+	yield* fs.makeDirectory(path.slice(0, path.lastIndexOf("/")), { recursive: true });
+	yield* fs.writeFileString(path, yield* encode(state));
+});
+const report = fn("report")(function* () {
+	const fs = yield* FileSystem;
+	const path = reportPath();
+	if (!(yield* fs.exists(path))) return yield* log("no Ship from this Machine yet");
+	const decoded = yield* decode(yield* fs.readFileString(path)).pipe(option);
+	if (isNone(decoded)) return yield* log(`the last report (${path}) is from another version of fleetfizz; the next Ship replaces it`);
+	const state = decoded.value;
+	const when = formatLocal(makeUnsafe(state.started), {
+		dateStyle: "medium",
+		timeStyle: "short"
+	});
+	yield* log(toText(/* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(T, {
+				tone: "dim",
+				children: `last Ship ${when} from ${state.from}`
+			}),
+			state.notes.map((note, i) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(NoteLine, { note }, i)),
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(LedgerView, {
+				state,
+				full: true,
+				now: state.ended ?? state.started
+			})
+		]
+	})));
+});
+//#endregion
+//#region src/live.tsx
 const cell = (initial) => {
 	let value = initial;
 	const listeners = /* @__PURE__ */ new Set();
@@ -64878,6 +65209,7 @@ const LiveLedger = (props) => {
 	const asking = (0, import_react.useSyncExternalStore)(props.asking.subscribe, props.asking.get);
 	const [full, setFull] = (0, import_react.useState)(false);
 	const [cursor, setCursor] = (0, import_react.useState)(0);
+	const { rows } = useWindowSize();
 	const { isRawModeSupported } = useStdin();
 	useInput((input, key) => {
 		if (key.ctrl && input === "c") process.kill(process.pid, "SIGINT");
@@ -64889,42 +65221,36 @@ const LiveLedger = (props) => {
 			asking.answer(cursor);
 		} else if (input === "f") setFull((f) => !f);
 	}, { isActive: isRawModeSupported });
-	const style = (s) => props.color && s !== void 0 ? STYLE[s] : {};
-	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Box, {
-		flexDirection: "column",
-		children: [asking?.titles.map((title, i) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Text, {
-			wrap: "truncate-end",
-			children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, {
-				...style(i === cursor ? "ask" : "dim"),
-				children: i === cursor ? "  › " : "    "
-			}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, {
-				...style(i === cursor ? void 0 : "dim"),
-				children: title
+	const choices = asking?.titles ?? [];
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Styled, {
+		color: props.color,
+		live: true,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Box, {
+			flexDirection: "column",
+			children: [choices.map((title, i) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Line, {
+				tone: i === cursor ? void 0 : "dim",
+				children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(T, {
+					tone: i === cursor ? "ask" : "dim",
+					children: i === cursor ? "  › " : "    "
+				}), title]
+			}, i)), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LedgerView, {
+				state,
+				full,
+				now,
+				height: rows - 1 - choices.length
 			})]
-		}, `ask-${i}`)), rows(state, {
-			full,
-			now,
-			live: true
-		}).map((row, r) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, {
-			wrap: "truncate-end",
-			children: row.length === 0 ? " " : row.map((segment, s) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, {
-				...style(segment.style),
-				children: segment.text
-			}, s))
-		}, r))]
+		})
 	});
 };
 const startLive = fn("startLive")(function* (store, color) {
 	const asking = cell(void 0);
-	const view = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LiveLedger, {
+	const instance = render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(LiveLedger, {
 		store,
 		asking,
 		color
-	});
-	const instance = render(view, { exitOnCtrlC: false });
+	}), { exitOnCtrlC: false });
 	yield* addFinalizer(() => promise(async () => {
-		instance.rerender(view);
-		await instance.waitUntilRenderFlush();
+		instance.clear();
 		instance.unmount();
 		await instance.waitUntilExit();
 	}));
@@ -64962,25 +65288,25 @@ const runOn = fn("runOn")(function* (target, script, secrets, onLine, ledger) {
 	}
 	return run;
 });
-const GATHER_TIMEOUT = "2 minutes";
-const gather = fn("gather")(function* (target, script, ledger) {
+const CHECK_TIMEOUT = "2 minutes";
+const check = fn("check")(function* (target, script, ledger) {
 	const facts = [];
 	const output = [];
 	const run = yield* runOn(target, script, [], (line) => sync(() => {
 		if (line.kind === "state") facts.push(line.fact);
 		else if (line.kind === "text" && line.text.trim() !== "") output.push(line.text.trimEnd());
 	}), ledger).pipe(timeoutOrElse({
-		duration: GATHER_TIMEOUT,
-		orElse: () => ledger.fail(target.name, [`gather took more than ${GATHER_TIMEOUT}; something on that Machine is blocking`, ...output]).pipe(as({ kind: "failed" }))
+		duration: CHECK_TIMEOUT,
+		orElse: () => ledger.fail(target.name, [`checking took more than ${CHECK_TIMEOUT}; something on that Machine is blocking`, ...output]).pipe(as({ kind: "failed" }))
 	}));
 	if (run.kind !== "ran") return { kind: run.kind };
 	const state = assembleState(facts);
 	if (!state.complete) {
-		yield* ledger.fail(target.name, ["gather did not finish", ...output]);
+		yield* ledger.fail(target.name, ["checking did not finish", ...output]);
 		return { kind: "failed" };
 	}
 	return {
-		kind: "gathered",
+		kind: "checked",
 		state
 	};
 });
@@ -65064,7 +65390,7 @@ const askQuestions = fn("askQuestions")(function* (questions, flags, ledger, ask
 				value: bump
 			},
 			{
-				title: "skip on these Machines (leave as is, report SKIP)",
+				title: "skip on these Machines (leave as is, shown as skipped)",
 				value: { kind: "skip" }
 			},
 			{
@@ -65102,19 +65428,18 @@ const packagesToResolve = (config) => {
 	];
 };
 const rebuildOf = (flags) => flags.rebuild.length === 0 ? "none" : flags.rebuild.includes("all") ? "all" : flags.rebuild;
-const staleConfigs = fn("staleConfigs")(function* (local, inputIsLocalFile, gathered, ledger) {
-	const stale = [];
-	for (const { machine, local: isLocal, state } of gathered) {
-		if (isLocal && inputIsLocalFile || state.config === void 0) continue;
+const staleConfigs = fn("staleConfigs")(function* (config, own, checked, ledger) {
+	const copies = [];
+	for (const { machine, state } of checked) {
+		if (state.config === void 0) continue;
 		const parsed = yield* result(parseConfig(machine.name, state.config));
-		if (parsed._tag === "Failure") {
-			yield* ledger.note("info", `the config on ${machine.name} does not parse; it will be overwritten`);
-			continue;
-		}
-		const remote = parsed.success;
-		if (isNewer(remote.shippedTo?.[machine.name], local.shippedTo?.[machine.name])) stale.push(`${machine.name} (shipped ${remote.shippedAt} from ${remote.shippedFrom ?? "unknown"})`);
+		if (parsed._tag === "Failure") yield* ledger.note("info", `the config on ${machine.name} does not parse; it will be overwritten`);
+		else copies.push({
+			machine: machine.name,
+			config: parsed.success
+		});
 	}
-	return stale;
+	return staleCopies(config, copies, own).map((c) => `${c.machine} (shipped ${c.config.shippedAt} from ${c.config.shippedFrom ?? "unknown"})`);
 });
 const schemaJson = encodeSync(fromJsonString(Unknown, { space: 2 }));
 const ship = fn("ship")(function* (flags) {
@@ -65125,6 +65450,7 @@ const ship = fn("ship")(function* (flags) {
 	const unknown = unknownMachines(config, tailnet, flags.only);
 	if (unknown.length > 0) return yield* fail$1(new ShipError(`unknown Machine: ${unknown.join(", ")} (the tailnet has: ${tailnet.fleet.map((m) => m.name).join(", ")})`));
 	const fleet = new Set(Object.keys(config.machines));
+	const own = flags.config === void 0 ? tailnet.self.name : void 0;
 	if (!fleet.has(tailnet.self.name)) return yield* fail$1(new ShipError(`this Machine (${tailnet.self.name}) is not in machines in ${path}`));
 	const outsideFleet = flags.only.filter((name) => !fleet.has(name));
 	if (outsideFleet.length > 0) return yield* fail$1(new ShipError(`not in machines in ${path}: ${outsideFleet.join(", ")}`));
@@ -65132,30 +65458,36 @@ const ship = fn("ship")(function* (flags) {
 	const targetsList = tailnet.fleet.filter((m) => fleet.has(m.name) && (flags.only.length === 0 || flags.only.includes(m.name))).toSorted((a, b) => order.indexOf(a.name) - order.indexOf(b.name));
 	const count = `${targetsList.length} machine${targetsList.length === 1 ? "" : "s"}`;
 	yield* log(`${flags.dryRun ? "dry run, " : ""}${count} from ${tailnet.self.name}`);
+	const color = colorful();
 	const { ledger, store } = yield* makeLedger({
 		from: tailnet.self.name,
 		dryRun: flags.dryRun,
-		machines: targetsList.map((m) => m.name)
+		machines: targetsList.map((m) => m.name),
+		print: (note) => log(noteText(note, color))
 	});
-	const live = canRedraw() ? yield* startLive(store, styled()) : noLive;
+	const redraw = canRedraw();
 	let changing = false;
 	const finish = fn("finish")(function* () {
 		const state = yield* ledger.end;
-		if (changing) yield* saveReport(state).pipe(catch_((e) => error(`could not save the report for fizz report: ${e.message}`)));
-		if (live === noLive) yield* printRows(rows(state, {
-			full: true,
+		const saved = changing && (yield* saveReport(state).pipe(as(true), catch_((e) => error(`could not save the report for fizz report: ${e.message}`).pipe(as(false)))));
+		yield* log(ledgerText(state, redraw ? {
+			full: false,
 			now: state.ended ?? 0,
-			live: false
-		}));
-		if (tally(state).failed > 0) process.exitCode = 1;
+			...saved ? { hint: "full report: fizz report" } : {}
+		} : {
+			full: true,
+			now: state.ended ?? 0
+		}, color));
+		if (anyFailed(state)) process.exitCode = 1;
 	});
 	yield* addFinalizer(() => finish());
+	const live = redraw ? yield* startLive(store, color) : noLive;
 	const cloneRootOf = (machine) => config.machines[machine.name]?.clones ?? "~/.local/share/fleetfizz/clones";
-	const gatherRepos = (config.repos ?? []).map((r) => ({
+	const checkRepos = (config.repos ?? []).map((r) => ({
 		name: repoName(r),
 		outputs: r.outputs ?? []
 	}));
-	const gathered = yield* forEach$1(targetsList, fn("gatherOne")(function* (machine) {
+	const checked = yield* forEach$1(targetsList, fn("checkOne")(function* (machine) {
 		const local = machine.name === tailnet.self.name;
 		if (!machine.online) {
 			yield* ledger.skip(machine.name, "offline");
@@ -65165,23 +65497,23 @@ const ship = fn("ship")(function* (flags) {
 			yield* ledger.skip(machine.name, "no Tailscale SSH server");
 			return;
 		}
-		const script = gatherScript({
+		const script = checkScript({
 			cloneRoot: cloneRootOf(machine),
-			repos: gatherRepos
+			repos: checkRepos
 		});
-		const result = yield* gather({
+		const result = yield* check({
 			name: machine.name,
 			local
 		}, script, ledger);
-		if (result.kind !== "gathered") return void 0;
-		yield* ledger.gathered(machine.name);
+		if (result.kind !== "checked") return void 0;
+		yield* ledger.checked(machine.name);
 		return {
 			machine,
 			local,
 			state: result.state
 		};
 	}), { concurrency: "unbounded" }).pipe(map$5((list) => list.filter((g) => g !== void 0)));
-	const stale = yield* staleConfigs(config, flags.config === void 0, gathered, ledger);
+	const stale = yield* staleConfigs(config, own, checked, ledger);
 	if (stale.length > 0) {
 		const what = `newer config on ${stale.join(", ")}`;
 		if (flags.dryRun) yield* ledger.note("info", `${what}; a Ship would ask before overwriting it`);
@@ -65201,7 +65533,7 @@ const ship = fn("ship")(function* (flags) {
 		}
 	}
 	const versions = yield* resolveVersions(packagesToResolve(config));
-	const planAll = (cfg, answers) => gathered.map((g) => ({
+	const planAll = (cfg, answers) => checked.map((g) => ({
 		...g,
 		plan: plan({
 			config: cfg,
@@ -65242,7 +65574,8 @@ const ship = fn("ship")(function* (flags) {
 	const stampWith = (reached) => stampText(original, {
 		shippedAt,
 		shippedFrom: tailnet.self.name,
-		reached: [...reached, ...flags.config === void 0 ? [tailnet.self.name] : []]
+		reached,
+		own
 	});
 	const stamped = stampWith(planned.map((g) => g.machine.name));
 	yield* fs.writeFileString(path, stamped);
@@ -65271,7 +65604,7 @@ const ship = fn("ship")(function* (flags) {
 //#endregion
 //#region src/bin.ts
 const shipCommand = make("ship", {
-	dryRun: Boolean$1("dry-run").pipe(withDefault(false), withDescription$1("Gather and plan only. Print every Machine's plan and change nothing.")),
+	dryRun: Boolean$1("dry-run").pipe(withDefault(false), withDescription$1("Check and plan only. Print every Machine's plan and change nothing.")),
 	only: String$1("only").pipe(atLeast(0), withDescription$1("Ship only to these Machines (repeat the flag).")),
 	rebuild: String$1("rebuild").pipe(atLeast(0), withDescription$1("Run a repo's Install Command even when its record matches; `all` for every repo.")),
 	bump: Boolean$1("bump").pipe(withDefault(false), withDescription$1("Answer every above-range question by bumping the config.")),