dsh-mnemon 0.5.27 → 0.5.28

package/lib/index.js

@@ -541,6 +541,7 @@ var MnemonAutoBackupScheduler = class {
 	lastAt;
 	lastAttemptAt;
 	lastError;
+	lastFailure;
 	lastCommit;
 	lastPushed;
 	constructor(runtime, now = () => /* @__PURE__ */ new Date()) {
@@ -574,6 +575,7 @@ var MnemonAutoBackupScheduler = class {
 			...this.lastAt === void 0 ? {} : { lastAt: this.lastAt },
 			...this.lastAttemptAt === void 0 || !available ? {} : { nextAt: new Date(this.lastAttemptAt + minutes * MINUTE_MS).toISOString() },
 			...this.lastError === void 0 ? {} : { lastError: this.lastError },
+			...this.lastError === void 0 || this.lastFailure === void 0 ? {} : { lastFailure: this.lastFailure },
 			...this.lastCommit === void 0 ? {} : { lastCommit: this.lastCommit },
 			...this.lastPushed === void 0 ? {} : { lastPushed: this.lastPushed }
 		};
@@ -619,19 +621,26 @@ var MnemonAutoBackupScheduler = class {
 		const controller = new AbortController();
 		this.controller = controller;
 		try {
-			if (sync.settings().read().repoUrl === void 0) this.lastError = void 0;
-			else if (!this.runtime.config.writeEnabled) this.lastError = "dsh-mnemon is configured read-only";
-			else {
+			if (sync.settings().read().repoUrl === void 0) {
+				this.lastError = void 0;
+				this.lastFailure = void 0;
+			} else if (!this.runtime.config.writeEnabled) {
+				this.lastError = "dsh-mnemon is configured read-only";
+				this.lastFailure = void 0;
+			} else {
 				const result = await sync.push({ signal: controller.signal });
 				this.lastAt = this.now().toISOString();
 				this.lastCommit = result.commit;
 				this.lastPushed = result.pushed;
 				this.lastError = result.pushed ? void 0 : result.committed ? result.reason : void 0;
+				this.lastFailure = this.lastError === void 0 ? void 0 : result.failure;
 			}
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
-			if (!this.stopped && !message.includes(BUSY_MESSAGE)) {
+			const reason = error instanceof Error ? error.reason : void 0;
+			if (!this.stopped && reason !== "busy" && !message.includes(BUSY_MESSAGE)) {
 				this.lastError = message;
+				this.lastFailure = typeof reason === "string" ? reason : void 0;
 				console.warn("dsh-mnemon: automatic Git backup failed", error);
 			}
 		} finally {
@@ -707,7 +716,7 @@ function createStorageRoot(config, workspaceRoot) {
 const MNEMON_MACHINE_DIRECTORY = "state";
 const MNEMON_MACHINE_FILE = "machine.json";
 const MNEMON_MACHINE_VERSION = 1;
-const MAX_LABEL_CHARACTERS = 120;
+const CONTROL = /[\p{Cc}\u2028\u2029]/u;
 function record$8(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
@@ -715,16 +724,26 @@ function record$8(value) {
 function defaultMachineLabel() {
 	const name = hostname().trim();
 	const label = name === "" ? "this machine" : name;
-	return label.length > MAX_LABEL_CHARACTERS ? label.slice(0, MAX_LABEL_CHARACTERS) : label;
+	return label.length > 120 ? label.slice(0, 120) : label;
+}
+/** A name a person gives this machine, as it is stored and shown. */
+function machineLabel(value) {
+	const label = typeof value === "string" ? value.trim() : "";
+	if (label === "" || label.length > 120 || CONTROL.test(label)) throw new Error("machine name must be 1 to " + String(120) + " characters on one line");
+	return label;
 }
 /**
 * The machine identity store. One file, one identity, created on first read and
 * then stable for the life of the data directory: an id that changed would
 * make every earlier entry look like it came from another machine.
+*
+* The name is not part of that promise. A host-name label follows the computer's
+* host name, and a person can name the machine instead. Every read goes to the
+* file, because the pack manager and the sync channel each hold a store and a
+* rename through one has to reach what the other stamps.
 */
 var MnemonMachineStore = class {
 	root;
-	cached;
 	constructor(runner) {
 		this.root = resolve(runner.effectiveDataDir());
 	}
@@ -736,10 +755,42 @@ var MnemonMachineStore = class {
 	}
 	/** This installation's identity, creating and persisting one when none exists yet. */
 	read() {
-		if (this.cached !== void 0) return this.cached;
+		return this.current().identity;
+	}
+	/** The identity with the source of its name, bringing the stored record up to date. */
+	current() {
 		const stored = this.stored();
-		this.cached = stored ?? this.create();
-		return this.cached;
+		if (stored === void 0) return this.write({
+			id: randomUUID(),
+			label: defaultMachineLabel(),
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		}, "hostname");
+		if (stored.source === "hostname") {
+			const label = defaultMachineLabel();
+			if (stored.identity.label !== label || !stored.marked) return this.write({
+				...stored.identity,
+				label
+			}, "hostname");
+		} else if (!stored.marked) return this.write(stored.identity, "custom");
+		return {
+			identity: stored.identity,
+			source: stored.source
+		};
+	}
+	/**
+	* Name this machine. A typed name stays as given; null or an empty name goes back
+	* to the host name. The id never changes, so earlier entries keep pointing here.
+	*/
+	rename(value) {
+		const label = value === null || value === "" ? void 0 : machineLabel(value);
+		const identity = this.current().identity;
+		return label === void 0 ? this.write({
+			...identity,
+			label: defaultMachineLabel()
+		}, "hostname") : this.write({
+			...identity,
+			label
+		}, "custom");
 	}
 	stored() {
 		let value;
@@ -753,29 +804,42 @@ var MnemonMachineStore = class {
 		if (typeof parsed.id !== "string" || parsed.id.trim() === "") return void 0;
 		if (typeof parsed.label !== "string" || parsed.label.trim() === "") return void 0;
 		if (typeof parsed.createdAt !== "string") return void 0;
-		return {
+		const identity = {
 			id: parsed.id,
 			label: parsed.label,
 			createdAt: parsed.createdAt
 		};
-	}
-	create() {
-		const identity = {
-			id: randomUUID(),
-			label: defaultMachineLabel(),
-			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		if (parsed.labelSource === "hostname" || parsed.labelSource === "custom") return {
+			identity,
+			source: parsed.labelSource,
+			marked: true
+		};
+		return {
+			identity,
+			source: parsed.label === defaultMachineLabel() ? "hostname" : "custom",
+			marked: false
 		};
+	}
+	write(identity, source) {
 		mkdirSync(this.directory(), {
 			recursive: true,
 			mode: 448
 		});
 		const temporary = `${this.path()}.${randomUUID()}.tmp`;
-		writeFileSync(temporary, `${JSON.stringify({
-			version: MNEMON_MACHINE_VERSION,
-			...identity
-		}, null, 2)}\n`, { mode: 384 });
-		renameSync(temporary, this.path());
-		return identity;
+		try {
+			writeFileSync(temporary, `${JSON.stringify({
+				version: MNEMON_MACHINE_VERSION,
+				...identity,
+				labelSource: source
+			}, null, 2)}\n`, { mode: 384 });
+			renameSync(temporary, this.path());
+		} finally {
+			rmSync(temporary, { force: true });
+		}
+		return {
+			identity,
+			source
+		};
 	}
 };
 //#endregion
@@ -1573,6 +1637,7 @@ function mergeDocuments(root, pack) {
 	for (const source of incoming.index.documents) {
 		const existing = ids.get(source.id);
 		if (existing !== void 0 && existing.contentHash === source.contentHash) continue;
+		if (existing !== void 0 && current.index.documents.some((document) => document.contentHash === source.contentHash)) continue;
 		let document = source;
 		let bytes = incoming.files.get(source.id);
 		if (existing !== void 0) {
@@ -1595,7 +1660,10 @@ function mergeRegistry(root, pack) {
 		let body = source;
 		const sourceDb = incoming.databases.get(source.id);
 		if (ids.has(source.id)) {
-			if (sha256$1(current.databases.get(source.id)) === sha256$1(sourceDb)) continue;
+			const currentDb = current.databases.get(source.id);
+			const incomingHash = sha256$1(sourceDb);
+			if (sha256$1(currentDb) === incomingHash) continue;
+			if ([...current.databases.values()].some((database) => sha256$1(database) === incomingHash)) continue;
 			const id = randomUUID();
 			body = {
 				...source,
@@ -2591,6 +2659,20 @@ function createGitHubTransport(options = {}) {
 	});
 }
 //#endregion
+//#region src/host/sync-error.ts
+/**
+* A sync failure the settings page can name in its own language. The message
+* stays the Host's own words for logs and for anything the page cannot name.
+*/
+var MnemonSyncError = class extends Error {
+	reason;
+	constructor(reason, message) {
+		super(message);
+		this.reason = reason;
+		this.name = "MnemonSyncError";
+	}
+};
+//#endregion
 //#region src/host/github-auth.ts
 /**
 * GitHub sign-in for the repository sync channel: the OAuth device flow, the
@@ -2641,7 +2723,8 @@ function codeOf(body) {
 }
 function failure$2(action, status, body) {
 	const code = codeOf(body);
-	return /* @__PURE__ */ new Error(code === void 0 ? action + " failed with HTTP " + String(status) : action + " failed: " + code);
+	const message = code === void 0 ? action + " failed with HTTP " + String(status) : action + " failed: " + code;
+	return status === 401 ? new MnemonSyncError("github-unauthorized", message) : new Error(message);
 }
 /** Read one grant out of a stored record, refusing anything else. */
 function githubGrantFromRecord(record_) {
@@ -2920,17 +3003,20 @@ var MnemonGitHubAuth = class {
 	/** The repositories the account may write to, most recently pushed first. */
 	async repositories(signal) {
 		const token = await this.requireToken();
-		const url = "https://api.github.com/user/repos?per_page=" + String(100) + "&sort=updated&affiliation=owner%2Ccollaborator%2Corganization_member";
-		const { status, body } = await this.ask(url, {
-			headers: this.authorization(token),
-			...signal === void 0 ? {} : { signal }
-		}, "listing GitHub repositories");
-		if (status !== 200) throw failure$2("listing GitHub repositories", status, body);
-		if (!Array.isArray(body)) throw new Error("the GitHub repository answer was not a list");
 		const repositories = [];
-		for (const entry of body) {
-			const repository = repositoryOf(entry);
-			if (repository !== void 0) repositories.push(repository);
+		for (let page = 1; page <= 5; page += 1) {
+			const url = "https://api.github.com/user/repos?per_page=" + String(100) + "&page=" + String(page) + "&sort=updated&affiliation=owner%2Ccollaborator%2Corganization_member";
+			const { status, body } = await this.ask(url, {
+				headers: this.authorization(token),
+				...signal === void 0 ? {} : { signal }
+			}, "listing GitHub repositories");
+			if (status !== 200) throw failure$2("listing GitHub repositories", status, body);
+			if (!Array.isArray(body)) throw new Error("the GitHub repository answer was not a list");
+			for (const entry of body) {
+				const repository = repositoryOf(entry);
+				if (repository !== void 0 && !repositories.some((known) => known.fullName === repository.fullName)) repositories.push(repository);
+			}
+			if (body.length < 100) break;
 		}
 		return {
 			login: await this.account(token, signal) ?? "",
@@ -3234,7 +3320,28 @@ var MnemonSyncSettingsStore = class {
 //#region src/host/git-sync.ts
 /** The oldest Git the channel drives: `archive`, `ls-remote`, `-C`, and `credential` all predate it. */
 const MNEMON_SYNC_MINIMUM_GIT = "2.20";
-const MNEMON_SYNC_GIT_TIMEOUT_MS = 12e4;
+/**
+* How long the settings page waits to learn whether the remote answers. A page
+* that opens should not hang on a host that drops packets, and anything slower
+* than this is reported as a timeout rather than awaited.
+*/
+const MNEMON_SYNC_STATUS_TIMEOUT_MS = 2e4;
+/** A push Git refused because the branch moved is folded in and tried once more. */
+const PUSH_ATTEMPTS = 2;
+/**
+* No sync runs this long, so a lock older than this is abandoned whoever holds it.
+* It also covers a process id that a restart handed to an unrelated process.
+*/
+const STALE_LOCK_MS = 36e5;
+const LOCK_OWNER = "owner.json";
+/**
+* A lock without an owner record was taken by a version that kept none, and may
+* still be in use by it; it is taken over only once no such run could still last.
+*/
+const OWNERLESS_LOCK_MS = 9e5;
+/** The mirror's own Git config names the repository it was filled from. */
+const ORIGIN_KEY = "mnemon.origin";
+const LAST_RUN_FILE = "last-run.json";
 const GIT_LABEL = "git";
 const MANIFEST = "manifest.json";
 const CHECKSUMS = "checksums.json";
@@ -3295,6 +3402,16 @@ function gitEnvironment(environment = process.env) {
 	sanitized.GCM_INTERACTIVE = "never";
 	return sanitized;
 }
+/** The host an HTTPS address hands a token to; any other address takes none. */
+function tokenHost(repoUrl) {
+	if (repoUrl === void 0) return void 0;
+	try {
+		const url = new URL(repoUrl);
+		return url.protocol === "https:" ? url.host.toLowerCase() : void 0;
+	} catch {
+		return;
+	}
+}
 /** Whether a repository address is HTTPS on github.com, the only host a GitHub grant is for. */
 function isGitHubHttps(repoUrl) {
 	try {
@@ -3304,6 +3421,37 @@ function isGitHubHttps(repoUrl) {
 		return false;
 	}
 }
+/**
+* What kind of failure one Git error describes. Git words these differently per
+* transport and per host, so the patterns are the phrases each transport uses:
+* a refused or missing credential, an address that leads nowhere (GitHub answers
+* "not found" for a private repository it will not show without credentials), a
+* network that does not reach the host, and a host that never answered.
+*/
+function remoteIssueOf(message) {
+	const text = message.toLowerCase();
+	if (/did not respond within|timed out|timeout was reached/u.test(text)) return "timeout";
+	if (/authentication failed|could not read (username|password)|terminal prompts disabled|permission denied|invalid username or password|bad credentials|returned error: 40[13]|host key verification failed|access denied|denied to /u.test(text)) return "auth";
+	if (/repository not found|not found|does not appear to be a git repository|no such file or directory|does not exist|returned error: 404/u.test(text)) return "not-found";
+	if (/could not resolve|failed to connect|couldn't connect|connection (refused|reset|closed|timed out)|network is unreachable|no route to host|unable to access|ssl|tls|proxy|empty reply/u.test(text)) return "network";
+	return "unknown";
+}
+const REMOTE_FAILURE = {
+	auth: "remote-auth",
+	"not-found": "remote-not-found",
+	network: "remote-network",
+	timeout: "remote-timeout",
+	unknown: void 0
+};
+/** One failed remote command as the error a caller reports: named when it can be. */
+function remoteFailure(message) {
+	const reason = REMOTE_FAILURE[remoteIssueOf(message)];
+	return reason === void 0 ? new Error(message) : new MnemonSyncError(reason, message);
+}
+/** Whether Git refused a push because the branch moved on since this run read it. */
+function rejectedPush(output) {
+	return /\[rejected\]|fetch first|non-fast-forward/iu.test(output);
+}
 function record$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
@@ -3450,9 +3598,9 @@ function objectCount(output) {
 	if (loose === null || bytes === null || packed === null || packedBytes === null) return void 0;
 	return {
 		loose: Number(loose[1]),
-		bytes: Number(bytes[1]),
+		bytes: Number(bytes[1]) * 1024,
 		packed: Number(packed[1]),
-		packedBytes: Number(packedBytes[1])
+		packedBytes: Number(packedBytes[1]) * 1024
 	};
 }
 /** How many commits one page asks for: the caller's window, clamped to what one listing should carry. */
@@ -3718,6 +3866,8 @@ var MnemonGitSync = class {
 		};
 		const commit = existsSync(this.store.mirror()) && git.available ? await this.lastCommit(signal) : void 0;
 		const autoBackup = this.autoBackupView?.();
+		const lastRun = repoUrl === void 0 ? void 0 : this.lastRun();
+		const machine = this.machine.current();
 		return {
 			enabled: true,
 			configured: repoUrl !== void 0,
@@ -3726,14 +3876,27 @@ var MnemonGitSync = class {
 			mirrorPath: this.store.mirror(),
 			git,
 			remote,
-			machine: this.machine.read(),
+			machine: machine.identity,
+			machineLabel: {
+				source: machine.source,
+				hostname: defaultMachineLabel()
+			},
 			...commit === void 0 ? {} : { lastCommit: commit },
+			...lastRun === void 0 ? {} : { lastRun },
 			...autoBackup === void 0 ? {} : { autoBackup }
 		};
 	}
 	async configure(patch) {
-		const next = this.store.patch(patch);
+		const previous = this.store.read();
+		const fields = record$3(patch);
+		const { machineLabel: name, ...settings } = fields ?? {};
+		const naming = fields !== void 0 && "machineLabel" in fields;
+		if (naming && name !== null && name !== "") machineLabel(name);
+		const next = this.store.patch(fields === void 0 ? patch : settings);
+		if (next.token !== void 0 && previous.repoUrl !== void 0 && fields !== void 0 && !("token" in fields) && tokenHost(previous.repoUrl) !== tokenHost(next.repoUrl)) delete next.token;
 		this.store.write(next);
+		if (naming) this.machine.rename(name);
+		if (previous.repoUrl !== next.repoUrl) rmSync(this.lastRunPath(), { force: true });
 		return this.credentialView(next);
 	}
 	/**
@@ -3747,106 +3910,202 @@ var MnemonGitSync = class {
 		await this.requireGit(input.signal);
 		const message = commitMessage(input.message, this.now());
 		return this.lock(async () => {
-			const prepared = await this.ensureMirror(settings, input.signal);
-			await this.packs.recordDeletions();
-			const remote = await this.readRemote(settings, input.signal);
-			let merged;
-			if (remote !== void 0) {
-				const imported = await this.packs.importPack(Buffer.from(remote.archive).toString("base64"), {
-					mode: "merge",
-					tombstones: {
-						version: 1,
-						tombstones: remote.tombstones
-					}
-				});
-				merged = {
-					commit: remote.commit,
-					...remote.machine === void 0 ? {} : { machine: {
-						id: remote.machine.id,
-						label: remote.machine.label
-					} },
-					components: imported.components,
-					summary: imported.summary,
-					tombstones: remote.tombstones.length
-				};
+			let result = await this.pushOnce(settings, message, input.signal);
+			let added = result.merged?.runtime?.added ?? 0;
+			let held = result.merged?.runtime?.held ?? 0;
+			for (let attempt = 1; attempt < PUSH_ATTEMPTS && result.failure === "push-rejected"; attempt += 1) {
+				result = await this.pushOnce(settings, message, input.signal);
+				added += result.merged?.runtime?.added ?? 0;
+				held = result.merged?.runtime?.held ?? held;
 			}
-			const exported = await this.packs.exportPack("full", { stamp: true });
-			const entries = unpack(Buffer.from(exported.base64, "base64"));
-			const extension = {
-				channel: "git",
-				branch: settings.branch,
-				subdir: settings.subdir,
-				pushedAt: exported.manifest.exportedAt,
-				machine: this.machine.read(),
-				tombstones: this.packs.tombstones().tombstones
+			if (result.merged !== void 0 && (added > 0 || result.merged.runtime !== void 0)) result = {
+				...result,
+				merged: {
+					...result.merged,
+					runtime: {
+						added,
+						held
+					}
+				}
 			};
-			entries[MANIFEST] = new TextEncoder().encode(JSON.stringify({
-				...exported.manifest,
-				[SYNC_EXTENSION]: extension
-			}, null, 2) + "\n");
-			const before = readFiles(this.payloadRoot(settings.subdir));
-			if (prepared.tip === void 0 || !holdsPayload(before, entries)) this.writePayload(settings.subdir, entries);
-			const staged = await this.git([
-				"add",
-				"--all",
-				"--",
-				settings.subdir
-			], {
-				cwd: this.store.mirror(),
-				signal: input.signal
+			if (result.pushed || !result.committed) this.recordRun({
+				kind: "sync",
+				commit: result.commit,
+				pushed: result.pushed,
+				...result.merged?.runtime === void 0 ? {} : { added: result.merged.runtime.added }
 			});
-			if (staged.exitCode !== 0) throw new Error("git add failed: " + tail(staged.stderr || staged.stdout));
-			const committed = (await this.git([
-				"status",
-				"--porcelain",
+			return result;
+		});
+	}
+	async pushOnce(settings, message, signal) {
+		const prepared = await this.ensureMirror(settings, signal);
+		await this.packs.recordDeletions();
+		const remote = await this.readPrepared(settings, prepared);
+		let merged;
+		if (remote !== void 0) {
+			const imported = await this.packs.importPack(Buffer.from(remote.archive).toString("base64"), {
+				mode: "merge",
+				tombstones: {
+					version: 1,
+					tombstones: remote.tombstones
+				}
+			});
+			merged = {
+				commit: remote.commit,
+				...remote.machine === void 0 ? {} : { machine: {
+					id: remote.machine.id,
+					label: remote.machine.label
+				} },
+				components: imported.components,
+				summary: imported.summary,
+				tombstones: remote.tombstones.length,
+				...imported.runtime === void 0 ? {} : { runtime: imported.runtime }
+			};
+		}
+		const exported = await this.packs.exportPack("full", { stamp: true });
+		const entries = unpack(Buffer.from(exported.base64, "base64"));
+		const extension = {
+			channel: "git",
+			branch: settings.branch,
+			subdir: settings.subdir,
+			pushedAt: exported.manifest.exportedAt,
+			machine: this.machine.read(),
+			tombstones: this.packs.tombstones().tombstones
+		};
+		entries[MANIFEST] = new TextEncoder().encode(JSON.stringify({
+			...exported.manifest,
+			[SYNC_EXTENSION]: extension
+		}, null, 2) + "\n");
+		const before = readFiles(this.payloadRoot(settings.subdir));
+		if (prepared.tip === void 0 || !holdsPayload(before, entries)) this.writePayload(settings.subdir, entries);
+		const staged = await this.git([
+			"add",
+			"--all",
+			"--",
+			settings.subdir
+		], {
+			cwd: this.store.mirror(),
+			signal
+		});
+		if (staged.exitCode !== 0) throw new Error("git add failed: " + tail(staged.stderr || staged.stdout));
+		const committed = (await this.git([
+			"status",
+			"--porcelain",
+			"--",
+			settings.subdir
+		], {
+			cwd: this.store.mirror(),
+			signal
+		})).stdout.trim() !== "";
+		if (committed) {
+			const identity = await this.commitIdentity(settings, signal);
+			const result = await this.git([
+				...identity,
+				"commit",
+				"--quiet",
+				"-m",
+				message,
 				"--",
 				settings.subdir
 			], {
 				cwd: this.store.mirror(),
-				signal: input.signal
-			})).stdout.trim() !== "";
-			if (committed) {
-				const identity = [...settings.authorName === "" ? [] : ["-c", "user.name=" + settings.authorName], ...settings.authorEmail === "" ? [] : ["-c", "user.email=" + settings.authorEmail]];
-				const result = await this.git([
-					...identity,
-					"commit",
-					"--quiet",
-					"-m",
-					message,
-					"--",
-					settings.subdir
-				], {
-					cwd: this.store.mirror(),
-					signal: input.signal
-				});
-				if (result.exitCode !== 0) throw new Error("git commit failed: " + tail(result.stderr || result.stdout));
-			}
-			const head = await this.head(input.signal);
-			const published = committed ? await this.publish(settings, await this.credential(settings), input.signal) : {
-				pushed: false,
-				reason: prepared.tip === void 0 ? "nothing to publish" : "the branch already holds this payload"
-			};
-			const compaction = await this.compact(input.signal);
-			const summary = exported.manifest.summary.map((entry) => ({
-				...entry,
-				changed: componentChanged(before, entries, entry.component)
-			}));
+				signal
+			});
+			if (result.exitCode !== 0) throw new Error("git commit failed: " + tail(result.stderr || result.stdout));
+		}
+		const head = await this.head(signal);
+		const published = committed ? await this.publish(settings, await this.credential(settings), signal) : {
+			pushed: false,
+			reason: prepared.tip === void 0 ? "nothing to publish" : "the branch already holds this payload"
+		};
+		const compaction = await this.compact(signal);
+		const summary = exported.manifest.summary.map((entry) => ({
+			...entry,
+			changed: componentChanged(before, entries, entry.component)
+		}));
+		return {
+			repoUrl: settings.repoUrl,
+			branch: settings.branch,
+			subdir: settings.subdir,
+			commit: head,
+			committed,
+			message,
+			files: Object.keys(entries).length,
+			bytes: Object.values(entries).reduce((total, bytes) => total + bytes.byteLength, 0),
+			summary,
+			pushed: published.pushed,
+			...merged === void 0 ? {} : { merged },
+			...published.reason === void 0 ? {} : { reason: published.reason },
+			...published.failure === void 0 ? {} : { failure: published.failure },
+			...compaction === void 0 ? {} : { compaction }
+		};
+	}
+	/**
+	* The identity a sync commit is recorded under: the one configured here, else the
+	* Git identity this machine has. A machine without one gets the channel's own
+	* rather than a failed commit, and rather than the account and host names Git
+	* would otherwise guess and publish.
+	*/
+	async commitIdentity(settings, signal) {
+		const name = settings.authorName !== "" ? settings.authorName : await this.configured("user.name", signal) ?? "dsh-mnemon sync";
+		const email = settings.authorEmail !== "" ? settings.authorEmail : await this.configured("user.email", signal) ?? "mnemon@localhost";
+		return [
+			"-c",
+			"user.name=" + name,
+			"-c",
+			"user.email=" + email
+		];
+	}
+	/** One Git setting as this machine resolves it, or nothing when no config sets it. */
+	async configured(key, signal) {
+		const result = await this.git([
+			"config",
+			"--get",
+			key
+		], {
+			cwd: this.store.mirror(),
+			signal
+		});
+		const value = result.exitCode === 0 ? result.stdout.trim() : "";
+		return value === "" ? void 0 : value;
+	}
+	/** When memory last travelled through this channel, or nothing when it never did. */
+	lastRun() {
+		try {
+			const value = record$3(JSON.parse(readFileSync(this.lastRunPath(), "utf8")));
+			if (value === void 0 || typeof value.at !== "string" || typeof value.commit !== "string") return void 0;
+			if (value.kind !== "sync" && value.kind !== "merge") return void 0;
 			return {
-				repoUrl: settings.repoUrl,
-				branch: settings.branch,
-				subdir: settings.subdir,
-				commit: head,
-				committed,
-				message,
-				files: Object.keys(entries).length,
-				bytes: Object.values(entries).reduce((total, bytes) => total + bytes.byteLength, 0),
-				summary,
-				pushed: published.pushed,
-				...merged === void 0 ? {} : { merged },
-				...published.reason === void 0 ? {} : { reason: published.reason },
-				...compaction === void 0 ? {} : { compaction }
+				at: value.at,
+				kind: value.kind,
+				commit: value.commit,
+				pushed: value.pushed === true,
+				...typeof value.added === "number" && Number.isInteger(value.added) && value.added >= 0 ? { added: value.added } : {}
 			};
-		});
+		} catch {
+			return;
+		}
+	}
+	lastRunPath() {
+		return join(this.store.directory(), "sync", LAST_RUN_FILE);
+	}
+	/** Remember one finished run. Bookkeeping never fails the run it describes. */
+	recordRun(run) {
+		const path = this.lastRunPath();
+		const temporary = path + "." + String(process.pid) + ".tmp";
+		try {
+			mkdirSync(join(path, ".."), {
+				recursive: true,
+				mode: 448
+			});
+			writeFileSync(temporary, JSON.stringify({
+				at: this.now().toISOString(),
+				...run
+			}, null, 2) + "\n", { mode: 384 });
+			renameSync(temporary, path);
+		} catch {
+			rmSync(temporary, { force: true });
+		}
 	}
 	/** Read the remote payload and report what it would change, without importing anything. */
 	async preview(signal) {
@@ -3855,7 +4114,7 @@ var MnemonGitSync = class {
 		const exported = await this.packs.exportPack("full");
 		return this.lock(async () => {
 			const remote = await this.readRemote(settings, signal);
-			if (remote === void 0) throw new Error(this.absentPayload(settings));
+			if (remote === void 0) throw this.absentPayload(settings);
 			const local = unpack(Buffer.from(exported.base64, "base64"));
 			const components = MNEMON_PACK_COMPONENTS.map((component) => {
 				const published = remote.manifest.summary.find((entry) => entry.component === component);
@@ -3930,7 +4189,7 @@ var MnemonGitSync = class {
 		const exported = await this.packs.exportPack("full");
 		return this.lock(async () => {
 			const remote = await this.readRemote(settings, signal);
-			if (remote === void 0) throw new Error(this.absentPayload(settings));
+			if (remote === void 0) throw this.absentPayload(settings);
 			const local = unpack(Buffer.from(exported.base64, "base64"));
 			const limits = this.runtimeLimits();
 			const mine = runtimeOf(local, limits, "the local");
@@ -4000,7 +4259,7 @@ var MnemonGitSync = class {
 		};
 		return this.lock(async () => {
 			const remote = await this.readRemote(settings, input.signal);
-			if (remote === void 0) throw new Error(this.absentPayload(settings));
+			if (remote === void 0) throw this.absentPayload(settings);
 			const imported = await this.packs.importPack(Buffer.from(remote.archive).toString("base64"), {
 				...options,
 				tombstones: {
@@ -4008,6 +4267,12 @@ var MnemonGitSync = class {
 					tombstones: remote.tombstones
 				}
 			});
+			this.recordRun({
+				kind: "merge",
+				commit: remote.commit,
+				pushed: false,
+				...imported.runtime === void 0 ? {} : { added: imported.runtime.added }
+			});
 			return {
 				imported: true,
 				mode: imported.mode,
@@ -4025,11 +4290,11 @@ var MnemonGitSync = class {
 		});
 	}
 	absentPayload(settings) {
-		return "the branch " + settings.branch + " holds no Mnemon payload at " + settings.subdir + " yet; push one first";
+		return new MnemonSyncError("remote-empty", "the branch " + settings.branch + " holds no Mnemon payload at " + settings.subdir + " yet; push one first");
 	}
 	requireRepository() {
 		const settings = this.store.read();
-		if (settings.repoUrl === void 0) throw new Error("no sync repository is configured; set repoUrl in " + this.store.path() + " first");
+		if (settings.repoUrl === void 0) throw new MnemonSyncError("no-repository", "no sync repository is configured; set repoUrl in " + this.store.path() + " first");
 		return {
 			...settings,
 			repoUrl: settings.repoUrl
@@ -4067,12 +4332,12 @@ var MnemonGitSync = class {
 	}
 	async requireGit(signal) {
 		const status = await this.gitStatus(signal);
-		if (!status.available) throw new Error("Git is not available on this Host: " + (status.issue ?? "unknown reason"));
+		if (!status.available) throw new MnemonSyncError("git-missing", "Git is not available on this Host: " + (status.issue ?? "unknown reason"));
 	}
 	async remoteStatus(settings, signal) {
 		const credential = await this.credential(settings);
 		try {
-			const tip = await this.lsRemote(settings, credential, signal);
+			const tip = await this.lsRemote(settings, credential, signal, MNEMON_SYNC_STATUS_TIMEOUT_MS);
 			return tip === void 0 ? {
 				reachable: true,
 				branchExists: false
@@ -4082,26 +4347,40 @@ var MnemonGitSync = class {
 				commit: tip
 			};
 		} catch (error) {
+			const message = this.mask(error instanceof Error ? error.message : String(error), credential);
 			return {
 				reachable: false,
 				branchExists: false,
-				error: this.mask(error instanceof Error ? error.message : String(error), credential)
+				error: message,
+				issue: remoteIssueOf(message)
 			};
 		}
 	}
-	async lsRemote(settings, credential, signal) {
+	/**
+	* The branch tip the remote holds, or nothing when it holds no such branch. A
+	* remote that cannot be read fails with the kind of failure it was, the token
+	* masked, so the page can say "sign in" rather than print Git's trace.
+	*/
+	async lsRemote(settings, credential, signal, timeoutMs) {
 		const reference = "refs/heads/" + settings.branch;
-		const result = await this.git([
-			"ls-remote",
-			"--heads",
-			settings.repoUrl,
-			reference
-		], {
-			signal,
-			token: credential.token,
-			authenticated: true
-		});
-		if (result.exitCode !== 0) throw new Error(tail(result.stderr || result.stdout) || "git ls-remote failed");
+		let result;
+		try {
+			result = await this.git([
+				"ls-remote",
+				"--heads",
+				settings.repoUrl,
+				reference
+			], {
+				signal,
+				token: credential.token,
+				authenticated: true,
+				...timeoutMs === void 0 ? {} : { timeoutMs }
+			});
+		} catch (error) {
+			if (signal?.aborted === true) throw error;
+			throw remoteFailure(this.mask(error instanceof Error ? error.message : String(error), credential));
+		}
+		if (result.exitCode !== 0) throw remoteFailure(this.mask(tail(result.stderr || result.stdout) || "git ls-remote failed", credential));
 		for (const line of result.stdout.split("\n")) {
 			const [commit, name] = line.trim().split(/\s+/u);
 			if (name === reference && commit !== void 0) return commit;
@@ -4218,6 +4497,20 @@ var MnemonGitSync = class {
 			recursive: true,
 			mode: 448
 		});
+		if (existsSync(join(mirror, ".git"))) {
+			const origin = await this.git([
+				"config",
+				"--get",
+				ORIGIN_KEY
+			], {
+				cwd: mirror,
+				signal
+			});
+			if (origin.exitCode !== 0 || origin.stdout.trim() !== settings.repoUrl) rmSync(mirror, {
+				recursive: true,
+				force: true
+			});
+		}
 		if (!existsSync(join(mirror, ".git"))) {
 			rmSync(mirror, {
 				recursive: true,
@@ -4226,10 +4519,18 @@ var MnemonGitSync = class {
 			const initialized = await this.git([
 				"init",
 				"--quiet",
-				"--initial-branch=" + settings.branch,
 				mirror
 			], { signal });
 			if (initialized.exitCode !== 0) throw new Error("git init failed: " + tail(initialized.stderr || initialized.stdout));
+			const marked = await this.git([
+				"config",
+				ORIGIN_KEY,
+				settings.repoUrl
+			], {
+				cwd: mirror,
+				signal
+			});
+			if (marked.exitCode !== 0) throw new Error("git config failed: " + tail(marked.stderr || marked.stdout));
 		}
 		const current = await this.git([
 			"symbolic-ref",
@@ -4251,7 +4552,10 @@ var MnemonGitSync = class {
 			if (renamed.exitCode !== 0) throw new Error("git symbolic-ref failed: " + tail(renamed.stderr || renamed.stdout));
 		}
 		const tip = await this.lsRemote(settings, credential, signal);
-		if (tip === void 0) return {};
+		if (tip === void 0) {
+			await this.startHistory(settings.branch, signal);
+			return {};
+		}
 		const fetched = await this.git([
 			"fetch",
 			"--no-tags",
@@ -4264,7 +4568,7 @@ var MnemonGitSync = class {
 			token: credential.token,
 			authenticated: true
 		});
-		if (fetched.exitCode !== 0) throw new Error("git fetch failed: " + this.mask(tail(fetched.stderr || fetched.stdout), credential));
+		if (fetched.exitCode !== 0) throw remoteFailure("git fetch failed: " + this.mask(tail(fetched.stderr || fetched.stdout), credential));
 		const reset = await this.git([
 			"reset",
 			"--hard",
@@ -4278,6 +4582,32 @@ var MnemonGitSync = class {
 		return { tip };
 	}
 	/**
+	* Point the mirror at a branch the remote does not hold. The next commit starts a
+	* history of its own: continuing the one this mirror kept, from a branch the remote
+	* has since deleted, would publish every earlier payload all over again.
+	*/
+	async startHistory(branch, signal) {
+		const mirror = this.store.mirror();
+		await this.git([
+			"update-ref",
+			"-d",
+			"refs/heads/" + branch
+		], {
+			cwd: mirror,
+			signal
+		});
+		const emptied = await this.git(["read-tree", "--empty"], {
+			cwd: mirror,
+			signal
+		});
+		if (emptied.exitCode !== 0) throw new Error("git read-tree failed: " + tail(emptied.stderr || emptied.stdout));
+		const cleaned = await this.git(["clean", "-fdxq"], {
+			cwd: mirror,
+			signal
+		});
+		if (cleaned.exitCode !== 0) throw new Error("git clean failed: " + tail(cleaned.stderr || cleaned.stdout));
+	}
+	/**
 	* The payload directory inside the mirror. A link where that directory or one of
 	* its parents should be would lead every read, removal and write out of the mirror,
 	* so a path that crosses one is refused before anything touches it.
@@ -4318,26 +4648,37 @@ var MnemonGitSync = class {
 	}
 	async publish(settings, credential, signal) {
 		const reference = "refs/heads/" + settings.branch + ":refs/heads/" + settings.branch;
-		const result = await this.git([
-			"push",
-			"--porcelain",
-			settings.repoUrl,
-			reference
-		], {
-			cwd: this.store.mirror(),
-			signal,
-			token: credential.token,
-			authenticated: true
-		});
+		let result;
+		try {
+			result = await this.git([
+				"push",
+				"--porcelain",
+				settings.repoUrl,
+				reference
+			], {
+				cwd: this.store.mirror(),
+				signal,
+				token: credential.token,
+				authenticated: true
+			});
+		} catch (error) {
+			if (signal?.aborted === true) throw error;
+			const reason = this.mask(error instanceof Error ? error.message : String(error), credential);
+			const failure = REMOTE_FAILURE[remoteIssueOf(reason)];
+			return {
+				pushed: false,
+				reason,
+				...failure === void 0 ? {} : { failure }
+			};
+		}
 		if (result.exitCode === 0) return { pushed: true };
-		const reason = this.mask(tail(result.stderr || result.stdout), credential);
-		if (credential.token === void 0) return {
-			pushed: false,
-			reason: "the commit stays local because no token is available: " + (reason || "git push failed")
-		};
+		const output = this.mask(result.stdout + "\n" + result.stderr, credential);
+		const reason = this.mask(tail(result.stderr || result.stdout), credential) || "git push failed";
+		const failure = rejectedPush(output) ? "push-rejected" : REMOTE_FAILURE[remoteIssueOf(output)];
 		return {
 			pushed: false,
-			reason: reason || "git push failed"
+			reason: credential.token === void 0 && failure !== "push-rejected" ? "the commit stays local because no token is available: " + reason : reason,
+			...failure === void 0 ? {} : { failure }
 		};
 	}
 	/**
@@ -4410,9 +4751,12 @@ var MnemonGitSync = class {
 			};
 		}
 	}
-	/** Validate the remote payload and rebuild the exact pack archive the ZIP path would have produced. */
+	/** Refresh the mirror, then read the payload the branch holds. */
 	async readRemote(settings, signal) {
-		const prepared = await this.ensureMirror(settings, signal);
+		return this.readPrepared(settings, await this.ensureMirror(settings, signal));
+	}
+	/** Validate the payload a refreshed mirror holds and rebuild the exact pack archive the ZIP path would have produced. */
+	async readPrepared(settings, prepared) {
 		if (prepared.tip === void 0) return void 0;
 		const files = readFiles(this.payloadRoot(settings.subdir));
 		const manifestBytes = files[MANIFEST];
@@ -4465,13 +4809,36 @@ var MnemonGitSync = class {
 			recursive: true,
 			mode: 448
 		});
-		return withDirectoryLock(join(this.store.directory(), ".sync.lock"), operation);
+		return withDirectoryLock(join(this.store.directory(), ".sync.lock"), async () => {
+			this.sweepCredentials();
+			return operation();
+		});
+	}
+	/**
+	* Remove the one-command credential files a Host that stopped mid-command left
+	* behind. Each holds a token, so one whose process is gone is deleted rather
+	* than kept until the next restart of that process id.
+	*/
+	sweepCredentials() {
+		let names;
+		try {
+			names = readdirSync(this.store.directory());
+		} catch {
+			return;
+		}
+		for (const name of names) {
+			const match = /^\.credentials\.(\d+)\.\d+\.tmp$/u.exec(name);
+			if (match === null) continue;
+			const pid = Number(match[1]);
+			if (pid === process.pid || processAlive(pid)) continue;
+			rmSync(join(this.store.directory(), name), { force: true });
+		}
 	}
 	async git(args, options) {
 		const prepared = this.credentials(args, options);
 		try {
 			return await this.run(GIT_LABEL, prepared.args, {
-				timeoutMs: MNEMON_SYNC_GIT_TIMEOUT_MS,
+				timeoutMs: options.timeoutMs ?? 12e4,
 				env: gitEnvironment(),
 				...options.cwd === void 0 ? {} : { cwd: options.cwd },
 				...options.signal === void 0 ? {} : { signal: options.signal },
@@ -4520,11 +4887,17 @@ var MnemonGitSync = class {
 		};
 	}
 };
+/**
+* How the payload files differ. The manifest and the checksum inventory describe a
+* payload rather than hold memory, and the manifest's export time differs on every
+* read, so counting them would report a difference where every component agrees.
+*/
 function compareFiles(published, local) {
 	let changed = 0;
 	let added = 0;
 	let removed = 0;
-	for (const path of /* @__PURE__ */ new Set([...Object.keys(published), ...Object.keys(local)])) {
+	const paths = new Set([...Object.keys(published), ...Object.keys(local)].filter((path) => path !== MANIFEST && path !== CHECKSUMS));
+	for (const path of paths) {
 		const remote = published[path];
 		const mine = local[path];
 		if (remote === void 0) added += 1;
@@ -4532,13 +4905,46 @@ function compareFiles(published, local) {
 		else if (sha256Hex(remote) !== sha256Hex(mine)) changed += 1;
 	}
 	return {
-		total: (/* @__PURE__ */ new Set([...Object.keys(published), ...Object.keys(local)])).size,
+		total: paths.size,
 		changed,
 		added,
 		removed
 	};
 }
-/** A single-writer lock for one storage root's sync work; the pack locks cover the shared data. */
+/** Whether a process of this machine still runs; one the Host may not signal is assumed alive. */
+function processAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
+/**
+* Whether a lock was left by an operation that can no longer release it: its owner
+* process is gone, or it is older than any sync takes. The age also covers a
+* process id that a restart handed to an unrelated process.
+*/
+function abandoned(path, now) {
+	let age;
+	try {
+		age = now - statSync(path).mtimeMs;
+	} catch {
+		return false;
+	}
+	if (age > STALE_LOCK_MS) return true;
+	try {
+		const pid = record$3(JSON.parse(readFileSync(join(path, LOCK_OWNER), "utf8")))?.pid;
+		return typeof pid === "number" && Number.isInteger(pid) && pid > 0 && pid !== process.pid && !processAlive(pid);
+	} catch {
+		return age > OWNERLESS_LOCK_MS;
+	}
+}
+/**
+* A single-writer lock for one storage root's sync work; the pack locks cover the
+* shared data. The lock records its owner, so a Host that stopped mid-operation
+* does not leave every later sync refused until someone deletes the directory.
+*/
 async function withDirectoryLock(path, operation) {
 	const deadline = Date.now() + LOCK_TIMEOUT_MS;
 	let held = false;
@@ -4549,9 +4955,28 @@ async function withDirectoryLock(path, operation) {
 		});
 		held = true;
 	} catch {
+		if (abandoned(path, Date.now())) {
+			const aside = path + ".abandoned." + String(process.pid) + "." + String(Date.now());
+			try {
+				if (abandoned(path, Date.now())) renameSync(path, aside);
+			} catch {
+				continue;
+			}
+			rmSync(aside, {
+				recursive: true,
+				force: true
+			});
+			continue;
+		}
 		await new Promise((resolveReady) => setTimeout(resolveReady, 25));
 	}
-	if (!held) throw new Error("another Mnemon sync operation is still running");
+	if (!held) throw new MnemonSyncError("busy", "another Mnemon sync operation is still running");
+	try {
+		writeFileSync(join(path, LOCK_OWNER), JSON.stringify({
+			pid: process.pid,
+			startedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}) + "\n", { mode: 384 });
+	} catch {}
 	try {
 		return await operation();
 	} finally {
@@ -11056,12 +11481,13 @@ function success$1(value) {
 	};
 }
 function failure$1(error) {
+	const reason = error instanceof Error ? error.reason : void 0;
 	return {
 		ok: false,
 		error: {
 			code: "internal",
 			message: error instanceof Error ? error.message : String(error),
-			details: {}
+			details: typeof reason === "string" ? { reason } : {}
 		}
 	};
 }