mainflow 0.29.0 → 0.30.0

package/dist/{operation-Bp4U2bx3.js → operation-BQiUL0eq.js}

@@ -1,13 +1,13 @@
-import { $ as nowMinute, B as ROUTES, F as renumberFiles, H as applyOperation, I as renumberPath, L as renumberText, N as applyOffline, P as renumberRequest, R as scopeOfPath, V as requestTime, at as ConflictError, ct as contentHash, ot as DATA_DIR, st as WriteError, tt as nodeStorage, z as AUTHORIZATION } from "./host-BJnrv8xF.js";
+import { $ as AUTHORIZATION, F as renumberFiles, I as renumberPath, L as renumberText, N as applyOffline, P as renumberRequest, Q as nodeStorage, R as scopeOfPath, X as nowMinute, at as ConflictError, ct as contentHash, et as ROUTES, ot as DATA_DIR, st as WriteError, tt as requestTime, z as applyOperation } from "./host-DmVNYRql.js";
 import { createHash, randomBytes } from "node:crypto";
-import { closeSync, existsSync, linkSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, watch, writeFileSync } from "node:fs";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { accessSync, appendFileSync, chmodSync, closeSync, constants, copyFileSync, existsSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { execFileSync, spawn, spawnSync } from "node:child_process";
 import { parse as parse$1 } from "yaml";
 import { homedir } from "node:os";
-import { createServer, request } from "node:http";
-import { request as request$1 } from "node:https";
+import { Agent, createServer, request } from "node:http";
+import { Agent as Agent$1, request as request$1 } from "node:https";
 import { EventEmitter } from "node:events";
 import { appendFile, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { diff3Merge } from "node-diff3";
@@ -15,12 +15,16 @@ import { diff3Merge } from "node-diff3";
 /**
 * The server could not be reached, or the connection broke. `sent` says whether the request may have reached the
 * server: a refused connection did not, a reset or timeout after sending may have, so its result is unknown.
+* `broken` says the connection closed under the request without an answer, as one the server closed while idle does;
+* the server is there, so the request can go again at once under its requestId.
 */
 var Unreachable = class extends Error {
 	sent;
-	constructor(message, sent) {
+	broken;
+	constructor(message, sent, broken = false) {
 		super(message);
 		this.sent = sent;
+		this.broken = broken;
 	}
 };
 /** The server refused before the hub (401, 400, 404) or failed (500). */
@@ -41,21 +45,38 @@ const NOT_SENT = /* @__PURE__ */ new Set([
 	"UND_ERR_CONNECT_TIMEOUT",
 	"ECONNECT_TIMEOUT"
 ]);
-/** Error codes of a pooled connection the server had already closed. */
+/** Error codes of a connection that closed under a request, such as a pooled one the server had already closed. */
 const STALE = /* @__PURE__ */ new Set([
 	"UND_ERR_SOCKET",
 	"ECONNRESET",
 	"EPIPE"
 ]);
+/** How often the connection writes go on is used while it would be idle, so the next write finds it open. */
+const WARM_MS = 1e4;
+/** How long keeping the connection open waits for its answer. */
+const WARM_TIMEOUT_MS = 5e3;
 const causeCode = (error) => {
 	for (let cause = error; cause; cause = cause.cause) if (typeof cause.code === "string") return cause.code;
 };
 var ServerApi = class {
 	settings;
 	timeoutMs;
+	/**
+	* The connection writes go on, kept open between them: opening one costs two round trips, for TCP and TLS. One
+	* connection at a time, since the client sends one write at a time; a request waits for the one before it.
+	*/
+	agent;
+	/** Requests on `agent` not answered yet */
+	busy = 0;
 	constructor(settings, timeoutMs = 3e4) {
 		this.settings = settings;
 		this.timeoutMs = timeoutMs;
+		const options = {
+			keepAlive: true,
+			maxSockets: 1,
+			maxFreeSockets: 1
+		};
+		this.agent = settings.url.startsWith("https:") ? new Agent$1(options) : new Agent(options);
 	}
 	get headers() {
 		return {
@@ -63,15 +84,16 @@ var ServerApi = class {
 			"content-type": "application/json"
 		};
 	}
-	async call(method, route, body) {
+	async call(method, route, body, fresh = false) {
 		const url = `${this.settings.url}${route}`;
 		let answer;
 		try {
-			answer = method === "GET" ? await this.fetchGet(url) : await this.freshRequest(method, url, JSON.stringify(body));
+			answer = method === "GET" ? await this.fetchGet(url) : await this.write(method, url, JSON.stringify(body), fresh);
 		} catch (error) {
 			const code = causeCode(error);
 			const detail = [code, error.cause?.message ?? error.message].filter(Boolean).join(": ");
-			throw new Unreachable(`cannot reach the sync server at ${this.settings.url}${detail ? ` (${detail})` : ""}`, !(code && NOT_SENT.has(code)));
+			const sent = !(code && NOT_SENT.has(code));
+			throw new Unreachable(`cannot reach the sync server at ${this.settings.url}${detail ? ` (${detail})` : ""}`, sent, sent && STALE.has(code ?? ""));
 		}
 		let parsed;
 		try {
@@ -103,21 +125,26 @@ var ServerApi = class {
 		}
 	}
 	/**
-	* A write goes on a connection of its own, never on a pooled one. The server may have closed an idle pooled
-	* connection with the close still on its way; a request sent on it is lost, and the client could not tell that
-	* from a request lost after the server applied it.
+	* A write goes on the kept connection, or with `fresh` on one of its own. The server may have closed the kept
+	* connection while idle, with the close still on its way, so a write sent on it can go unanswered: the error is
+	* `broken` (Unreachable), and the client sends it again at once under its requestId, which the server answers with
+	* the response it kept if it took the request after all. Keeping the connection busy (warm) makes that rare.
 	*/
-	freshRequest(method, url, body) {
+	write(method, url, body, fresh) {
+		return this.exchange(method, url, {
+			...this.headers,
+			"content-length": String(Buffer.byteLength(body))
+		}, body, fresh ? false : this.agent, this.timeoutMs);
+	}
+	exchange(method, url, headers, body, agent, timeoutMs) {
 		const send = url.startsWith("https:") ? request$1 : request;
+		if (agent) this.busy++;
 		return new Promise((resolve, reject) => {
 			const req = send(url, {
 				method,
-				agent: false,
-				headers: {
-					...this.headers,
-					"content-length": Buffer.byteLength(body)
-				},
-				timeout: this.timeoutMs
+				agent,
+				headers,
+				timeout: timeoutMs
 			}, (res) => {
 				const chunks = [];
 				res.on("data", (chunk) => chunks.push(chunk));
@@ -130,11 +157,27 @@ var ServerApi = class {
 			req.on("timeout", () => req.destroy(Object.assign(/* @__PURE__ */ new Error("no answer in time"), { code: req.socket?.connecting === false ? "ETIMEDOUT" : "ECONNECT_TIMEOUT" })));
 			req.on("error", reject);
 			req.end(body);
+		}).finally(() => {
+			if (agent) this.busy--;
 		});
 	}
+	/**
+	* Keep the write connection open: a request that needs no hub, on it, unless a request is on it already. Opens it
+	* when there is none, so the first write after connecting finds one. A failure is the next write's to find.
+	*/
+	async warm() {
+		if (this.busy > 0) return;
+		try {
+			await this.exchange("GET", `${this.settings.url}${ROUTES.version}`, {}, void 0, this.agent, WARM_TIMEOUT_MS);
+		} catch {}
+	}
+	/** Close the kept connection; a later request opens another. */
+	close() {
+		this.agent.destroy();
+	}
 	/** Send one request; the response is the hub's answer, applied or refused. */
-	async send(request) {
-		return (await this.call("POST", ROUTES.request(this.settings.hub), request)).body;
+	async send(request, options = {}) {
+		return (await this.call("POST", ROUTES.request(this.settings.hub), request, options.fresh === true)).body;
 	}
 	/** Every file of the hub, as of the hub's `seq`. */
 	async snapshot() {
@@ -145,14 +188,17 @@ var ServerApi = class {
 			files: body.files
 		};
 	}
-	/** Upload a whole hub; refused with 409 when the server already holds one and `replace` is not set. */
+	/**
+	* Upload a whole hub; refused with 409 when the server already holds one and `replace` is not set. It goes on a
+	* connection of its own, not the kept one, since it has no requestId to be sent again under when its connection breaks.
+	*/
 	async upload(files, dirs, replace = false) {
 		const { body } = await this.call("PUT", ROUTES.snapshot(this.settings.hub), {
 			protocol: 2,
 			files,
 			dirs,
 			replace
-		});
+		}, true);
 		return body;
 	}
 	/** Open the hub's broadcast connection. */
@@ -199,11 +245,70 @@ function alignLines(a, b) {
 		keptB
 	};
 }
-/** How many lines differ between two texts: the lines only in a plus the lines only in b. */
-function lineDistance(a, b) {
+/**
+* How many lines differ between two texts: the lines only in a plus the lines only in b, as alignLines leaves them.
+* Found by growing the number of differing lines one at a time (Myers' O(ND) difference), so two texts a few lines
+* apart cost about one pass over their lines, however long they are. With `limit`, a distance of `limit` or more is
+* not worked out: `limit` is returned.
+*/
+function lineDistance(a, b, limit = Infinity) {
 	if (a === b) return 0;
-	const { keptA, keptB } = alignLines(split(a), split(b));
-	return keptA.filter((kept) => !kept).length + keptB.filter((kept) => !kept).length;
+	const x = split(a);
+	const y = split(b);
+	let start = 0;
+	while (start < x.length && start < y.length && x[start] === y[start]) start++;
+	let endX = x.length;
+	let endY = y.length;
+	while (endX > start && endY > start && x[endX - 1] === y[endY - 1]) {
+		endX--;
+		endY--;
+	}
+	const n = endX - start;
+	const m = endY - start;
+	const most = Math.min(n + m, limit);
+	if (n === 0 || m === 0) return Math.min(n + m, limit);
+	const offset = most + 1;
+	const furthest = new Int32Array(2 * most + 3);
+	for (let d = 0; d <= most; d++) for (let k = -d; k <= d; k += 2) {
+		let i = k === -d || k !== d && furthest[offset + k - 1] < furthest[offset + k + 1] ? furthest[offset + k + 1] : furthest[offset + k - 1] + 1;
+		let j = i - k;
+		while (i < n && j < m && x[start + i] === y[start + j]) {
+			i++;
+			j++;
+		}
+		furthest[offset + k] = i;
+		if (i >= n && j >= m) return d;
+	}
+	return limit;
+}
+/** How many lines `text` has, as lineDistance counts them. */
+function lineCount(text) {
+	let count = 1;
+	for (let at = text.indexOf("\n"); at >= 0; at = text.indexOf("\n", at + 1)) count++;
+	return count;
+}
+/**
+* The version among `versions`, oldest first, with the fewest lines differing from `text` (lineDistance), the newest
+* on a tie; undefined when there is none. The versions are compared newest first, and one whose line count alone puts
+* it as far from `text` as the closest so far is not compared at all: the lines that differ are at least the
+* difference in line counts, and an older version must be strictly closer to be chosen; nor is a comparison carried
+* past the closest distance so far. So a writer that added or changed a line of the version on disk costs about one
+* pass over the file per version left to compare, however long the file is.
+*/
+function closestVersion(versions, text) {
+	const lines = lineCount(text);
+	let best;
+	let bestDistance = Infinity;
+	for (let i = versions.length - 1; i >= 0 && bestDistance > 0; i--) {
+		const version = versions[i];
+		if (Math.abs(lineCount(version.text) - lines) >= bestDistance) continue;
+		const distance = lineDistance(version.text, text, bestDistance);
+		if (distance < bestDistance) {
+			best = version;
+			bestDistance = distance;
+		}
+	}
+	return best;
 }
 //#endregion
 //#region ../sync/dist/merge.js
@@ -243,6 +348,8 @@ const syncPaths = (root) => {
 		tmp: join(own, "tmp"),
 		conflicts: join(own, "conflicts"),
 		known: join(own, "known.json"),
+		/** The text of each version known.json names, in a file named by its content hash */
+		knownTexts: join(own, "known"),
 		queue: join(own, "queue.json"),
 		notices: join(own, "notices.jsonl"),
 		daemon: join(own, "daemon.json"),
@@ -273,8 +380,15 @@ function isSynced(path) {
 }
 /** Whether the directory at `path` may hold synced files, so a scan walks into it. */
 const mayHoldSynced = (path) => path !== "local" ? !path.startsWith("local/") || path === "local/sessions" : true;
+/**
+* Whether the client's file watcher watches inside the directory at `path`: one that may hold synced files, and
+* local/sync/ itself for the outbox; the directories under local/sync/ hold only the client's own files.
+*/
+const watchedDir = (path) => path === "local/sync" || mayHoldSynced(path);
 //#endregion
 //#region ../sync/dist/state.js
+/** Whether `entry` waits for the server: not one it refused. */
+const waiting = (entry) => entry.refused === void 0;
 /** A new entry's id. */
 const entryId = () => randomBytes(8).toString("hex");
 const entryPaths = (entry) => entry.kind === "op" ? Object.keys(entry.written) : [entry.path];
@@ -288,7 +402,8 @@ const LOCAL_MINUTE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})$/;
 *
 * Around a daylight saving change the minute is read as Date reads a local time. A minute that occurs twice, in the
 * hour an autumn change repeats, always gets the earlier offset, the one before the change; the minute itself is
-* kept, and the server writes only the minute until it uses the offset, so nothing written differs. A minute in the
+* kept. The server writes the whole `now`, so that earlier offset is what lands in the hub's files: an hour off from the
+* instant the operation really ran, for a minute in that repeated hour that ran after the change. A minute in the
 * hour a spring change skips would move an hour forward, but a local clock never shows one, so none is queued.
 */
 function currentRequest(request) {
@@ -316,7 +431,36 @@ function writeJson(file, value) {
 	renameSync(temp, file);
 }
 const readKnown = (root) => readJson(syncPaths(root).known, {}).files ?? {};
-const writeKnown = (root, files) => writeJson(syncPaths(root).known, { files });
+/** The text of the version known.json names by `hash`; undefined when it was not kept, as by a sync client before known/. */
+function readKnownText(root, hash) {
+	try {
+		const text = readFileSync(join(syncPaths(root).knownTexts, hash), "utf8");
+		return contentHash(text) === hash ? text : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Write known.json, and into known/ the text of each version it names that is not
+* there yet; the texts of versions it no longer names are removed. A version whose text the client does not have keeps
+* the text known/ holds, if any. The new texts go first, then known.json, then the removals, so a client killed at any
+* step leaves a known.json whose every text is in known/.
+*/
+function writeKnown(root, files) {
+	const dir = syncPaths(root).knownTexts;
+	mkdirSync(dir, { recursive: true });
+	const named = new Set(Object.values(files).map((file) => file.hash));
+	const held = new Set(readdirSync(dir));
+	for (const { hash, text } of Object.values(files)) {
+		if (text === void 0 || held.has(hash)) continue;
+		writeFileSync(join(dir, `${hash}.tmp`), text);
+		renameSync(join(dir, `${hash}.tmp`), join(dir, hash));
+		held.add(hash);
+	}
+	const known = { files: Object.fromEntries(Object.entries(files).map(([path, file]) => [path, file.hash])) };
+	writeJson(syncPaths(root).known, known);
+	for (const name of held) if (!named.has(name)) rmSync(join(dir, name), { force: true });
+}
 const writeQueue = (root, entries) => writeJson(syncPaths(root).queue, { entries });
 /** The queue as queue.json has it; an entry from before entries had ids gets one, written back. Call under the write lock. */
 function readQueue(root) {
@@ -336,7 +480,10 @@ const underLock = (root, fn) => nodeStorage(root).lock(fn);
 const HELPER_SOURCE = "mainflow-swap.c";
 /** What `mainflow-swap --version` prints; another answer is a helper this client does not speak to. */
 const HELPER_PROTOCOL = "mainflow-swap 1";
-/** The file name of a prebuilt helper; macOS builds one universal binary. */
+/**
+* The file name of a prebuilt helper. A release ships darwin-arm64, darwin-x64, linux-arm64 and linux-x64;
+* a local build on macOS makes one darwin-universal file instead.
+*/
 const prebuiltName = (platform, arch) => `mainflow-swap-${platform}-${arch}`;
 /** Where the native/ directory is: beside this module in the built package, or the source tree's dist/native. */
 function nativeDirs() {
@@ -362,11 +509,36 @@ const works = (file) => {
 		return false;
 	}
 };
-const cacheDir = () => join(process.env.XDG_CACHE_HOME || join(homedir(), ".cache"), "mainflow");
+const cacheDir = (env = process.env) => join(env.XDG_CACHE_HOME || join(homedir(), ".cache"), "mainflow");
+const isExecutable = (file) => {
+	try {
+		accessSync(file, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+};
+/** Copy a prebuilt helper that lost its execute bit into the cache directory as 0755; null when that does not work. */
+function executableCopy(file, env) {
+	const text = readFileSync(file);
+	const target = join(cacheDir(env), `${basename(file)}-${createHash("sha1").update(text).digest("hex").slice(0, 12)}`);
+	if (existsSync(target) && isExecutable(target) && works(target)) return target;
+	const temp = `${target}.${process.pid}.tmp`;
+	try {
+		mkdirSync(dirname(target), { recursive: true });
+		copyFileSync(file, temp);
+		chmodSync(temp, 493);
+		renameSync(temp, target);
+		return works(target) ? target : null;
+	} catch {
+		rmSync(temp, { force: true });
+		return null;
+	}
+}
 /** Compile the shipped source into the cache directory; null when there is no source or no working compiler. */
-function compile(source) {
+function compile(source, env) {
 	const text = readFileSync(source);
-	const target = join(cacheDir(), `${prebuiltName(process.platform, process.arch)}-${createHash("sha1").update(text).digest("hex").slice(0, 12)}`);
+	const target = join(cacheDir(env), `${prebuiltName(process.platform, process.arch)}-${createHash("sha1").update(text).digest("hex").slice(0, 12)}`);
 	if (existsSync(target) && works(target)) return target;
 	mkdirSync(dirname(target), { recursive: true });
 	const temp = `${target}.${process.pid}.tmp`;
@@ -388,7 +560,7 @@ function compile(source) {
 	}
 }
 /** Find a working helper for this machine; see the top of this file for the order. */
-function findHelper(env = process.env) {
+function findHelper(env = process.env, dirs = nativeDirs()) {
 	if (process.platform !== "darwin" && process.platform !== "linux") return {
 		path: null,
 		source: "none"
@@ -402,17 +574,26 @@ function findHelper(env = process.env) {
 		source: "none"
 	};
 	const names = [prebuiltName(process.platform, process.arch), prebuiltName(process.platform, "universal")];
-	for (const dir of nativeDirs()) for (const name of names) {
+	for (const dir of dirs) for (const name of names) {
 		const file = join(dir, name);
-		if (existsSync(file) && works(file)) return {
-			path: file,
+		if (!existsSync(file)) continue;
+		if (isExecutable(file)) {
+			if (works(file)) return {
+				path: file,
+				source: "prebuilt"
+			};
+			continue;
+		}
+		const copy = executableCopy(file, env);
+		if (copy) return {
+			path: copy,
 			source: "prebuilt"
 		};
 	}
-	for (const dir of nativeDirs()) {
+	for (const dir of dirs) {
 		const source = join(dir, HELPER_SOURCE);
 		if (!existsSync(source)) continue;
-		const compiled = compile(source);
+		const compiled = compile(source, env);
 		if (compiled) return {
 			path: compiled,
 			source: "compiled"
@@ -490,11 +671,128 @@ function startSwapper(dir, env = process.env) {
 	}
 }
 //#endregion
-//#region ../sync/dist/client.js
+//#region ../sync/dist/watch.js
+/** The mode for this platform: `recursive` where fs.watch watches a tree natively, `directories` elsewhere, such as Linux. */
+const PLATFORM_MODE = process.platform === "darwin" || process.platform === "win32" ? "recursive" : "directories";
+/** Watch the tree at `root`, an existing directory. Throws when the root cannot be watched. */
+function watchTree(root, options) {
+	return (options.mode ?? PLATFORM_MODE) === "recursive" ? recursiveWatch(root, options) : new DirectoryWatcher(root, options);
+}
+const childOf = (dir, name) => dir === "" ? name : `${dir}/${name}`;
+function recursiveWatch(root, { include, onChange, onError }) {
+	const included = (path) => {
+		for (let at = path.indexOf("/"); at >= 0; at = path.indexOf("/", at + 1)) if (!include(path.slice(0, at))) return false;
+		return include("");
+	};
+	const watcher = watch(root, { recursive: true }, (_event, name) => {
+		if (!name) return;
+		const path = String(name).split(sep).join("/");
+		if (included(path)) onChange(path);
+	});
+	watcher.on("error", (error) => onError(error, "", true));
+	return {
+		mode: "recursive",
+		directories: () => [""],
+		close: () => watcher.close()
+	};
+}
+var DirectoryWatcher = class {
+	root;
+	options;
+	mode = "directories";
+	watched = /* @__PURE__ */ new Map();
+	closed = false;
+	constructor(root, options) {
+		this.root = root;
+		this.options = options;
+		const error = this.add("", false);
+		if (error) throw error;
+	}
+	directories() {
+		return [...this.watched.keys()];
+	}
+	close() {
+		this.closed = true;
+		this.drop("");
+	}
+	/**
+	* Watch `dir` and the directories in it. With `report`, each file found in them is reported, since it may have been
+	* written before its directory was watched. Returns the error when `dir` itself cannot be watched.
+	*/
+	add(dir, report) {
+		if (this.closed || this.watched.has(dir) || !this.options.include(dir)) return;
+		const full = join(this.root, dir);
+		let entries;
+		try {
+			if (!(dir === "" ? statSync(full) : lstatSync(full)).isDirectory()) throw Object.assign(/* @__PURE__ */ new Error(`not a directory: ${full}`), { code: "ENOTDIR" });
+			const watcher = watch(full, (event, name) => this.event(dir, watcher, event, name));
+			watcher.on("error", (error) => {
+				if (this.watched.get(dir) !== watcher) return;
+				this.drop(dir);
+				this.options.onError(error, dir, true);
+			});
+			this.watched.set(dir, watcher);
+			entries = readdirSync(full, { withFileTypes: true });
+		} catch (error) {
+			this.drop(dir);
+			if (dir === "") return error;
+			const code = error.code;
+			if (code !== "ENOENT" && code !== "ENOTDIR") this.options.onError(error, dir, false);
+			return;
+		}
+		for (const entry of entries) {
+			const path = childOf(dir, entry.name);
+			if (entry.isDirectory()) this.add(path, report);
+			else if (report) this.options.onChange(path);
+		}
+	}
+	event(dir, watcher, event, name) {
+		if (this.watched.get(dir) !== watcher || !name) return;
+		const path = childOf(dir, name);
+		if (event === "rename") {
+			if (dir !== "" && name === basename(dir) && !exists(join(this.root, path))) this.renamed(dir);
+			else this.renamed(path);
+		}
+		this.options.onChange(path);
+	}
+	/**
+	* `path` appeared or went away. A directory watched there is let go, since it may be gone, or another one put in its
+	* place, which can even have the same inode; whatever directory is there now is watched, with its files reported.
+	*/
+	renamed(path) {
+		const watched = this.watched.has(path);
+		let directory = false;
+		try {
+			directory = lstatSync(join(this.root, path)).isDirectory();
+		} catch {}
+		if (watched) this.drop(path);
+		if (directory) this.add(path, true);
+	}
+	/** Stop watching `dir` and every directory under it. */
+	drop(dir) {
+		for (const [path, watcher] of this.watched) {
+			if (dir !== "" && path !== dir && !path.startsWith(`${dir}/`)) continue;
+			watcher.close();
+			this.watched.delete(path);
+		}
+	}
+};
+function exists(file) {
+	try {
+		lstatSync(file);
+		return true;
+	} catch {
+		return false;
+	}
+}
 const HISTORY = 20;
 /** A text's short content hash, for traces. */
 const short = (text) => text == null ? String(text) : contentHash(text).slice(0, 7);
-const SETTLE_MS = 100;
+/** How long after the file watcher's last event for a path the path is looked at, so a write in progress is not sent half done */
+const SETTLE_MS = 20;
+/** How often whenSettled compares a file's size and modification time, and how long it does so at most */
+const SETTLE_POLL_MS = 5;
+const SETTLE_LIMIT_MS = 1e3;
 /**
 * Snapshots in a row that bring neither a missing change nor anything newer before the change counts as lost; the
 * ones before the last are each followed by a pause before the next
@@ -509,6 +807,14 @@ const BINARY_RECHECK_MS = 150;
 const EMPTY_RECHECK_MS = 300;
 /** How long after the exchange the displaced file is read again, for a program that still held it open */
 const LATE_WRITE_MS = 150;
+/**
+* How long the client exchanges files one after another before the event loop gets a turn, so a sync client exchanging
+* many files at once, as after a large snapshot, still answers /status and the other requests of its port
+*/
+const SWAP_SLICE_MS = 50;
+/** Failures of the atomic exchange helper in a row after which files are written with a rename for SWAP_PAUSE_MS */
+const SWAP_FAILURES = 3;
+const SWAP_PAUSE_MS = 6e4;
 /** queue.json, relative to .mainflow/: other writers append to it, and the client sends what they appended */
 const OUTBOX = `${SYNC_DIR}/queue.json`;
 const sleep$1 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -556,9 +862,26 @@ function heldBase(entry) {
 	} : void 0;
 }
 /**
-* The request an edit sends, sent at once or from the outbox: its text on its base, moved first onto the server's
-* merge of its base when the server merged it (`serverBase`), with the base as the common ancestor. `unresolved` while
-* its base is a local text the server has not answered for; `overlap` when the move overlaps.
+* The text `entry` holds for `path`: a text, null for no file, undefined for a path it does not write. A displaced
+* text, one the server's version took off disk (src/state.ts), is included; it is what a refusal saves.
+*/
+function textAt(entry, path) {
+	if (entry.kind === "op") return entry.written[path];
+	if (entry.path !== path) return void 0;
+	if (entry.kind === "remove") return null;
+	return entry.text;
+}
+/**
+* What `entry` left on disk at `path` when it was queued: a text, null for no file, undefined for nothing, as for a
+* path it does not write or a displaced text, which the server's version took off disk.
+*/
+function wroteAt(entry, path) {
+	return entry.kind === "patch" && entry.displaced ? void 0 : textAt(entry, path);
+}
+/**
+* The request a queued edit sends: its text on its base, moved first onto the server's merge of its base when the
+* server merged it (`serverBase`), with the base as the common ancestor. `unresolved` while its base is a local text
+* the server has not answered for; `overlap` when the move overlaps.
 */
 function patchRequest(entry) {
 	if (entry.base === null && entry.baseText !== void 0) return "unresolved";
@@ -583,11 +906,20 @@ var SyncClient = class extends EventEmitter {
 	api;
 	problems = [];
 	reported = 0;
+	/** What each path holds on disk as the client last left it, confirmed or not */
 	expected = /* @__PURE__ */ new Map();
+	/**
+	* The version of each path the server confirmed that the client last had on disk, as known.json and known/ keep it:
+	* a server's version written here, or a writer's text the server answered for while the file still held it
+	*/
+	confirmed = /* @__PURE__ */ new Map();
+	/**
+	* The refused outbox entries whose writer this run told, or found told by a run before (resumeRefusals): only these
+	* leave the outbox, once no file holds what they wrote (dropSettled)
+	*/
+	told = /* @__PURE__ */ new Set();
 	/** The confirmed versions of each path, oldest first, at most HISTORY; versions() adds what the outbox holds */
 	history = /* @__PURE__ */ new Map();
-	/** The writer's texts of the direct edits and Edits sent outside the outbox that wait for an answer, by path */
-	unanswered = /* @__PURE__ */ new Map();
 	cloud = /* @__PURE__ */ new Map();
 	/** The hub's seq of each path's version in `cloud`: a version from the server with a seq no higher is not newer */
 	fileSeq = /* @__PURE__ */ new Map();
@@ -597,7 +929,6 @@ var SyncClient = class extends EventEmitter {
 	ahead = /* @__PURE__ */ new Set();
 	waiters = /* @__PURE__ */ new Set();
 	inflight = /* @__PURE__ */ new Map();
-	dirty = /* @__PURE__ */ new Set();
 	chains = /* @__PURE__ */ new Map();
 	work = /* @__PURE__ */ new Set();
 	binaries = /* @__PURE__ */ new Set();
@@ -614,18 +945,39 @@ var SyncClient = class extends EventEmitter {
 	sending = null;
 	ws = null;
 	connected = false;
+	/** Whether a snapshot was taken on the current connection; cleared when a connection opens or is lost, and when one fails */
+	current = false;
+	/** No reconnecting: stop() or the test hook disconnect() */
 	stopped = false;
+	/** stop() was called: nothing more is scheduled, taken in, written to disk or sent */
+	closing = false;
 	flushing = false;
+	/** stop() gave up waiting for work under way: that work no longer writes the outbox, known.json or files */
+	abandoned = false;
+	/** The send of the outbox under way, which stop() waits for */
+	flushRun = null;
 	resyncing = null;
 	resyncAgain = false;
 	/** Whether a snapshot has been taken, after which a path the server never mentioned does not exist there */
 	synced = false;
 	reconnectTimer;
 	pingTimer;
+	/** Keeps the connection writes go on open while connected (ServerApi.warm) */
+	warmTimer;
 	rescanTimer;
 	queueTimer;
 	watcher;
+	/** The file watcher's timers, one per path waiting to settle */
+	watchTimers = /* @__PURE__ */ new Map();
+	/** Rereads of displaced files still to come (recheck), which stop() waits for */
+	rechecks = /* @__PURE__ */ new Set();
 	swapper = null;
+	/** The helper's failures in a row, and until when files are written with a rename after SWAP_FAILURES of them */
+	swapFailures = 0;
+	swapPausedUntil = 0;
+	/** The exchange before which the next one waits (exchangeTurn), and when the client last let the event loop run */
+	exchanging = Promise.resolve();
+	sliceStarted = 0;
 	/** Settles once the first connection attempt synced or failed */
 	firstContact;
 	backoff = 500;
@@ -652,16 +1004,20 @@ var SyncClient = class extends EventEmitter {
 	get online() {
 		return this.connected && !this.stopped;
 	}
+	/** Writes waiting in the outbox for the server: not the ones it refused, which wait for nothing (src/state.ts). */
 	get queued() {
-		return this.queue.length;
+		return this.queue.filter(waiting).length;
 	}
-	/** Whether the local files have every change the server has: online, with the snapshot taken and not being retaken. */
+	/**
+	* Whether the local files have every change the server has: online, with this connection's snapshot taken and not
+	* being retaken (I1).
+	*/
 	get caughtUp() {
-		return this.online && this.synced && this.resyncing === null;
+		return this.online && this.current && this.resyncing === null;
 	}
-	/** Whether files are written with the atomic exchange. */
+	/** Whether files are written with the atomic exchange: there is a helper, not paused after failing in a row. */
 	get swapping() {
-		return this.swapper !== null;
+		return this.swapper !== null && Date.now() >= this.swapPausedUntil;
 	}
 	/**
 	* The file at `path` as the server last had it to this client's knowledge: its text, null when the server has no such
@@ -685,6 +1041,7 @@ var SyncClient = class extends EventEmitter {
 		}
 		await this.restoreKnown();
 		await this.whenFree(() => this.syncQueue());
+		await this.resumeRefusals();
 		if (this.opts.watch !== false) this.startWatcher();
 		await this.scan(true, true);
 		const every = this.opts.rescanMs ?? 2e3;
@@ -693,35 +1050,85 @@ var SyncClient = class extends EventEmitter {
 		await this.firstContact;
 	}
 	/**
-	* What the last run left on disk, from known.json. A file that still holds that version is read, so it is a version
-	* a local edit can be based on (layer 1) as it was before the restart; without it, a program that read the file
-	* before a change from the server arrived would have its write based on that change and undo it.
+	* What the last run left on disk, from known.json: the version the server confirmed, with its text from known/. It
+	* is a version a local edit can be based on (layer 1) as it was before the restart, whether the file still holds it
+	* or was changed since; without it, a program that read the file before a change from the server arrived would have
+	* its write based on that change and undo it, and a change made while no client ran would have no base text to tell
+	* the writer's lines from another environment's (layer 2). Without its text, as known.json of an older client, only
+	* a file that still holds it gives it. What the outbox wrote, refused writes included, is read after it (restoreEntry).
 	*/
 	async restoreKnown() {
 		for (const [path, hash] of Object.entries(readKnown(this.root))) {
 			const local = await this.readLocal(path);
-			if (local.kind === "text" && contentHash(local.text) === hash) {
-				this.expected.set(path, {
-					hash,
-					text: local.text
-				});
-				this.remember(path, {
-					text: local.text,
-					server: local.text
-				});
-			} else this.expected.set(path, { hash });
+			const text = local.kind === "text" && contentHash(local.text) === hash ? local.text : readKnownText(this.root, hash);
+			const disk = text === void 0 ? { hash } : {
+				hash,
+				text
+			};
+			this.expected.set(path, disk);
+			this.confirmed.set(path, disk);
+			if (text !== void 0) this.remember(path, {
+				text,
+				server: text
+			});
 		}
 	}
+	/**
+	* The refusals a run killed before it settled them left in the outbox (src/state.ts): each text not saved yet is saved,
+	* and the writer is told what notices.jsonl does not have under the entry's id; an operation's writer gets its answer.
+	* Nothing is sent again. An entry whose files no longer hold what it wrote leaves the outbox; the others stay until
+	* the server's version replaces what they wrote (refuse).
+	*/
+	async resumeRefusals() {
+		const refused = this.queue.filter((entry) => entry.refused !== void 0);
+		if (refused.length === 0) return;
+		const before = this.toldBefore();
+		for (const entry of refused) await this.tell(entry, (problem) => before.has(`${entry.id}\0${problem.kind}\0${problem.path}`));
+		await this.whenFree(() => this.editQueue((entries) => this.dropSettled(entries)));
+	}
+	/** What notices.jsonl says the writer was told of each refused outbox entry, as `id\0kind\0path`. */
+	toldBefore() {
+		const out = /* @__PURE__ */ new Set();
+		let lines;
+		try {
+			lines = readFileSync(this.paths.notices, "utf8").split("\n");
+		} catch {
+			return out;
+		}
+		for (const line of lines) try {
+			const notice = JSON.parse(line);
+			if (typeof notice.entry === "string") out.add(`${notice.entry}\0${String(notice.kind)}\0${String(notice.path)}`);
+		} catch {}
+		return out;
+	}
+	/**
+	* Stop: nothing more is scheduled, taken in from the server, written to disk or sent, whatever timer or answer comes
+	* later. Work already under way ends first: a reconcile, and the reread of a displaced file, whose late write is
+	* queued, since no later run can find it.
+	*/
 	async stop() {
+		this.closing = true;
 		this.stopped = true;
 		clearTimeout(this.reconnectTimer);
 		clearInterval(this.pingTimer);
+		clearInterval(this.warmTimer);
 		clearInterval(this.rescanTimer);
 		clearTimeout(this.queueTimer);
+		for (const timer of this.watchTimers.values()) clearTimeout(timer);
+		this.watchTimers.clear();
 		this.watcher?.close();
 		this.ws?.close();
-		await Promise.allSettled(this.chains.values());
-		this.saveKnownNow();
+		const settled = Promise.allSettled([
+			...this.rechecks,
+			...this.chains.values(),
+			...this.flushRun ? [this.flushRun] : []
+		]);
+		let timer;
+		const limit = new Promise((resolve) => timer = setTimeout(() => resolve(false), this.opts.stopWaitMs ?? 5e3));
+		if (!await Promise.race([settled.then(() => true), limit])) this.abandoned = true;
+		clearTimeout(timer);
+		this.api.close();
+		this.saveKnownNow(true);
 	}
 	/** Test hook: drop the connection as a lost network would, and stay offline until reconnect(). */
 	disconnect() {
@@ -744,7 +1151,7 @@ var SyncClient = class extends EventEmitter {
 		const deadline = Date.now() + timeoutMs;
 		this.outboxChanged();
 		for (;;) {
-			if (!(this.work.size > 0 || [...this.inflight.values()].some((n) => n > 0) || this.flushing || this.resyncing !== null || this.online && this.queue.length > 0)) return true;
+			if (!(this.work.size > 0 || [...this.inflight.values()].some((n) => n > 0) || this.flushing || this.resyncing !== null || this.online && this.queued > 0)) return true;
 			if (Date.now() > deadline) return false;
 			await (this.work.size > 0 ? Promise.race([Promise.allSettled(this.work), sleep$1(50)]) : sleep$1(50));
 		}
@@ -756,18 +1163,20 @@ var SyncClient = class extends EventEmitter {
 		this.ahead.clear();
 		let opened = false;
 		ws.addEventListener("open", () => {
+			if (this.closing) return ws.close();
 			opened = true;
 			this.diagnosed = false;
 			this.connected = true;
+			this.current = false;
 			this.backoff = 500;
 			this.lastPong = Date.now();
 			clearInterval(this.pingTimer);
 			this.pingTimer = setInterval(() => this.ping(ws), 15e3);
+			clearInterval(this.warmTimer);
+			this.api.warm();
+			this.warmTimer = setInterval(() => void this.api.warm(), WARM_MS);
 			this.log("connected");
-			this.track(this.resync().then(() => this.flushQueue()).then(() => this.emit("synced")).catch((error) => {
-				this.log(`could not sync: ${error.message}`);
-				ws.close();
-			}));
+			this.track(this.resync().then(() => this.flushQueue()).then(() => this.emit("synced")).catch((error) => this.log(`could not sync: ${error.message}`)));
 		});
 		ws.addEventListener("message", (event) => {
 			if (this.ws === ws) this.onMessage(String(event.data));
@@ -794,7 +1203,9 @@ var SyncClient = class extends EventEmitter {
 	markOffline() {
 		const was = this.connected;
 		this.connected = false;
+		this.current = false;
 		clearInterval(this.pingTimer);
+		clearInterval(this.warmTimer);
 		for (const waiter of this.waiters) waiter.done();
 		this.waiters.clear();
 		if (was) this.log("offline");
@@ -817,6 +1228,7 @@ var SyncClient = class extends EventEmitter {
 		} catch {}
 	}
 	onMessage(data) {
+		if (this.closing) return;
 		if (data === "pong") {
 			this.lastPong = Date.now();
 			return;
@@ -902,7 +1314,7 @@ var SyncClient = class extends EventEmitter {
 			this.waiters.delete(waiter);
 			this.log(`no broadcast of ${path} after its response; reloading the snapshot`);
 			this.resync().catch(() => {}).finally(done);
-		}, 1e4);
+		}, this.opts.deliveryMs ?? 1e4);
 		await arrived;
 		clearTimeout(timer);
 	}
@@ -912,9 +1324,12 @@ var SyncClient = class extends EventEmitter {
 	* reconciled: the server broadcasts a change after storing it, so a snapshot asked for later holds it. One that
 	* still does not, and brought nothing newer, is asked for again after a pause; after STALLED_SNAPSHOTS of them the
 	* server is taken to have lost those changes, as when its storage was replaced: the versions the client holds from
-	* after the gap are forgotten and the snapshot is taken once more, as it is.
+	* after the gap are forgotten and the snapshot is taken once more, as it is. The connection has its snapshot once
+	* one ends while it is open (I1); one that fails leaves it without, and the client reconnects to take a fresh one,
+	* rather than send on the snapshot of an earlier connection.
 	*/
 	resync() {
+		if (this.closing) return Promise.resolve();
 		if (this.resyncing) {
 			this.resyncAgain = true;
 			return this.resyncing;
@@ -940,10 +1355,15 @@ var SyncClient = class extends EventEmitter {
 					this.log(`missed the hub's changes ${missing} while taking the snapshot; reloading it`);
 					if (stalled > 0) await sleep$1(250 * 2 ** (stalled - 1));
 					this.resyncAgain = true;
-				} while (this.resyncAgain);
+				} while (this.resyncAgain && !this.closing);
+				this.current = this.connected && !this.closing;
+			} catch (error) {
+				this.current = false;
+				this.ws?.close();
+				throw error;
 			} finally {
 				this.resyncing = null;
-				if (this.connected && this.queue.length > 0) this.track(this.flushQueue());
+				if (this.connected && this.queued > 0) this.track(this.flushQueue());
 			}
 		})();
 		return this.resyncing;
@@ -960,6 +1380,7 @@ var SyncClient = class extends EventEmitter {
 			snapshot = await this.api.snapshot();
 			if (upload > 0 || snapshot.files.some((event) => event.kind === "file") || !await this.uploadIfEmpty()) break;
 		}
+		if (this.closing) return;
 		const { seq, files } = snapshot;
 		if (seq < before) {
 			this.log(`the sync server's seq went back from ${before} to ${seq}; taking its snapshot as it is`);
@@ -1013,8 +1434,9 @@ var SyncClient = class extends EventEmitter {
 		this.log(`uploaded the hub: ${result.files} files`);
 		return true;
 	}
-	/** Reconcile `path` after whatever earlier work on it has finished. */
+	/** Reconcile `path` after whatever earlier work on it has finished; nothing once stopping. */
 	schedule(path) {
+		if (this.closing) return;
 		const next = (this.chains.get(path) ?? Promise.resolve()).then(() => this.reconcile(path)).catch((error) => this.log(`${path}: ${error.stack ?? String(error)}`));
 		this.chains.set(path, next);
 		this.track(next).then(() => {
@@ -1026,8 +1448,13 @@ var SyncClient = class extends EventEmitter {
 		promise.finally(() => this.work.delete(promise)).catch(() => {});
 		return promise;
 	}
-	isBusy(path) {
-		return (this.inflight.get(path) ?? 0) > 0 || this.online && this.queue.some((entry) => entryPaths(entry).includes(path));
+	/**
+	* Whether a write in the outbox is about `path`, as the outbox was last read, or on its way to the server: the file
+	* keeps what the client wrote there until the server answered (I4), online or not. finish() reconciles it after. A
+	* refused write is answered: the server's version replaces what it wrote.
+	*/
+	pending(path) {
+		return (this.inflight.get(path) ?? 0) > 0 || this.queue.some((entry) => waiting(entry) && entryPaths(entry).includes(path));
 	}
 	async readLocal(path) {
 		let bytes;
@@ -1051,14 +1478,11 @@ var SyncClient = class extends EventEmitter {
 		}
 	}
 	/**
-	* Compare the local file with what the client last left there and with the server's version, and act: send a
-	* local change, write the server's version, or nothing. A path waiting for a response is marked and done after.
+	* Compare the local file with what the client last left there and with the server's version, and act: queue a
+	* local change, write the server's version, or nothing. A local change is queued whatever else is in the outbox,
+	* each write an entry of its own; the server's version waits while the outbox has a write about the file (I4).
 	*/
 	async reconcile(path) {
-		if (this.isBusy(path)) {
-			this.dirty.add(path);
-			return;
-		}
 		const local = await this.readLocal(path);
 		if (local.kind === "binary") {
 			await sleep$1(BINARY_RECHECK_MS);
@@ -1083,32 +1507,63 @@ var SyncClient = class extends EventEmitter {
 			}
 			if (target === local.text) return this.adopt(path, local.text);
 			if (target === void 0) return;
-			return this.sendLocal(path, local.text, { start: target === null ? null : {
+			return this.queueLocal(path, local.text, { start: target === null ? null : {
 				text: local.text,
 				server: local.text
 			} });
 		}
 		if (!this.matches(disk, local)) {
+			if (local.kind === "text" && target === local.text && !this.pending(path)) {
+				this.adopt(path, local.text);
+				return this.release(path);
+			}
 			if (local.kind === "text") {
 				if (local.text === "" && disk?.text) {
 					await sleep$1(EMPTY_RECHECK_MS);
 					const again = await this.readLocal(path);
 					if (again.kind !== "text" || again.text !== "") return this.schedule(path);
 				}
-				return this.sendLocal(path, local.text);
+				return this.queueLocal(path, local.text);
+			}
+			if (target === null || disk === null) {
+				this.forget(path);
+				this.confirm(path, null);
+				return this.release(path);
 			}
-			if (target === null || disk === null) return this.forget(path);
-			return this.sendRemove(path, disk.hash);
+			return this.queueRemove(path, disk);
 		}
 		if (target === void 0 || (disk === null ? target === null : target !== null && disk.hash === contentHash(target))) {
 			if (disk?.text !== void 0) this.remember(path, {
 				text: disk.text,
 				server: disk.text
 			});
-			return;
+			if (target === void 0) return;
+			this.confirm(path, disk);
+			return this.release(path);
 		}
+		if (this.pending(path)) return;
 		await this.replace(path, target);
 	}
+	/**
+	* Whether the file at `path` holds `text` now, null for no file; read at once, for a caller under the write lock.
+	* Decoded as readLocal decodes it, so a file that starts with a byte order mark holds the text read from it.
+	*/
+	onDisk(path, text) {
+		let bytes;
+		try {
+			bytes = readFileSync(join(this.paths.data, path));
+		} catch (error) {
+			const code = error.code;
+			if (code === "ENOENT" || code === "ENOTDIR" || code === "EISDIR") return text === null;
+			throw error;
+		}
+		if (text === null) return false;
+		try {
+			return decoder.decode(bytes) === text;
+		} catch {
+			return false;
+		}
+	}
 	matches(disk, local) {
 		if (disk === null) return local.kind === "absent";
 		return local.kind === "text" && disk.hash === contentHash(local.text);
@@ -1122,14 +1577,34 @@ var SyncClient = class extends EventEmitter {
 			text,
 			server: text
 		});
-		this.saveKnown();
+		this.confirm(path, {
+			hash: contentHash(text),
+			text
+		});
 	}
 	/** A removed file starts over: its earlier versions are gone from the server and are no base for a new one. */
 	forget(path) {
 		this.expected.set(path, null);
 		this.history.delete(path);
+	}
+	/**
+	* The server confirmed that `path` holds `disk`, which the file holds as the client left it: known.json names it from
+	* now on (I4). A version only written here, still in the outbox, is never confirmed.
+	*/
+	confirm(path, disk) {
+		const held = this.confirmed.get(path);
+		if (held === void 0 ? false : held === null ? disk === null : disk !== null && held.hash === disk.hash && (held.text !== void 0 || disk.text === void 0)) return;
+		this.confirmed.set(path, disk);
 		this.saveKnown();
 	}
+	/** The writer's `text` of `path` was answered: confirmed, when the file still holds it as the client left it. */
+	confirmWritten(path, text) {
+		const disk = this.expected.get(path);
+		if (text === null ? disk === null : disk != null && disk.hash === contentHash(text)) this.confirm(path, text === null ? null : {
+			hash: contentHash(text),
+			text
+		});
+	}
 	/** A confirmed version of `path`, the newest; the oldest goes beyond HISTORY. */
 	remember(path, version) {
 		const list = (this.history.get(path) ?? []).filter((v) => v.text !== version.text);
@@ -1166,13 +1641,13 @@ var SyncClient = class extends EventEmitter {
 		}
 		let step;
 		try {
-			step = await this.whenFree(() => underLock(this.root, () => this.replaceHeld(path, file, temp, target)));
+			step = await this.exchangeTurn(() => this.whenFree(() => this.locked(() => this.replaceHeld(path, file, temp, target))));
 		} catch (error) {
 			await rm(temp, { force: true });
 			throw error;
 		}
 		if (step.kind === "exists" || step.kind === "missing") return this.schedule(path);
-		if (step.kind === "linked") return;
+		if (step.kind === "linked" || step.kind === "kept") return;
 		if (step.kind === "removed") {
 			if (step.moved !== null && step.disk && contentHash(step.moved) !== step.disk.hash) {
 				const saved = await this.saveConflict(path, step.moved);
@@ -1191,18 +1666,64 @@ var SyncClient = class extends EventEmitter {
 		const later = swapped && changed && displaced === "";
 		if (changed && !later) {
 			this.log(`${path}: a local write landed while the server's version was written; sending it`);
-			await this.sendLocal(path, displaced, { displaced: from });
+			await this.queueLocal(path, displaced, { displaced: from });
+		}
+		if (swapped) {
+			const recheck = this.recheck(path, temp, later ? null : displaced, from);
+			this.rechecks.add(recheck);
+			this.track(recheck).finally(() => this.rechecks.delete(recheck));
+		} else await rm(temp, { force: true });
+	}
+	/**
+	* Run `fn`, the part of replace done under the write lock, after the one before it has finished. Exchanges run one
+	* at a time without giving up the thread (the helper is waited for), so many of them at once, as after a large
+	* snapshot, would hold the event loop for seconds: every SWAP_SLICE_MS the event loop gets a turn before the next one,
+	* and the client keeps answering on its port meanwhile.
+	*/
+	async exchangeTurn(fn) {
+		const previous = this.exchanging;
+		let release;
+		this.exchanging = new Promise((resolve) => release = resolve);
+		try {
+			await previous;
+			if (Date.now() - this.sliceStarted >= SWAP_SLICE_MS) {
+				await new Promise((resolve) => setImmediate(resolve));
+				this.sliceStarted = Date.now();
+			}
+			return await fn();
+		} finally {
+			release();
+		}
+	}
+	/**
+	* The atomic exchange helper failed or refused to exchange `path`, which is written with a rename: the next file tries
+	* the helper again, so one timeout does not turn layer 3 off. After SWAP_FAILURES in a row, files are written with a
+	* rename for SWAP_PAUSE_MS, since each failure may hold the write lock for the helper's timeout. Recorded as info.
+	*/
+	swapFailed(path, reason) {
+		this.swapFailures++;
+		const pause = this.swapFailures >= SWAP_FAILURES;
+		if (pause) {
+			this.swapPausedUntil = Date.now() + SWAP_PAUSE_MS;
+			this.swapFailures = 0;
 		}
-		if (swapped) this.track(this.recheck(path, temp, later ? null : displaced, from));
-		else await rm(temp, { force: true });
+		const message = `atomic exchange failed (${reason}); ${pause ? `failed ${SWAP_FAILURES} times in a row, so files are written with a rename for ${SWAP_PAUSE_MS / 1e3} s` : "the next file tries it again"}`;
+		this.log(`${path}: ${message}`);
+		this.info(path, message);
 	}
 	/**
 	* The part of replace done under the hub's write lock. The outbox is taken in first: every operation in it was
 	* written on the file as the client expects it before this replacement, and none can be appended until the lock
 	* is released, so an operation is never compared with a version it was not written on (the invariants at the top).
+	* A file the outbox has a write about keeps it (I4), and a client that is stopping writes nothing. A refused write's
+	* text the file held leaves the outbox in the same hold, once the server's version is there (refuse).
 	*/
 	replaceHeld(path, file, temp, target) {
 		this.editHeld();
+		if (this.closing || this.pending(path)) {
+			rmSync(temp, { force: true });
+			return { kind: "kept" };
+		}
 		const disk = this.expected.get(path);
 		const read = (at) => {
 			try {
@@ -1218,6 +1739,8 @@ var SyncClient = class extends EventEmitter {
 				if (error.code !== "ENOENT") throw error;
 			}
 			this.forget(path);
+			this.confirm(path, null);
+			if (this.holds(path)) this.editHeld((entries) => this.releaseHeld(entries, path));
 			const moved = read(temp);
 			rmSync(temp, { force: true });
 			return {
@@ -1236,32 +1759,33 @@ var SyncClient = class extends EventEmitter {
 			}
 			rmSync(temp, { force: true });
 			this.wrote(path, target);
+			if (this.holds(path)) this.editHeld((entries) => this.releaseHeld(entries, path));
 			return { kind: "linked" };
 		}
 		let displaced = null;
 		let swapped = false;
 		let hooked = false;
-		if (this.swapper) {
+		if (this.swapping) {
 			this.opts.beforeReplace?.(file);
 			hooked = true;
 			let answer;
 			try {
 				answer = this.swapper.swap(temp, file);
 			} catch (error) {
-				this.log(`atomic exchange failed (${error.message}); writing with a rename from now on`);
-				this.swapper = null;
-				answer = "unsupported";
+				answer = error;
 			}
 			if (answer === "missing") {
 				rmSync(temp, { force: true });
 				return { kind: "missing" };
 			}
+			if (answer === "ok") this.swapFailures = 0;
+			else {
+				this.swapFailed(path, answer === "unsupported" ? "the file system refused it" : answer.message);
+				if (answer !== "unsupported" && read(file) === target && read(temp) !== target) answer = "ok";
+			}
 			if (answer === "ok") {
 				swapped = true;
 				displaced = read(temp);
-			} else if (this.swapper) {
-				this.log("the file system refused the atomic exchange; writing with a rename from now on");
-				this.swapper = null;
 			}
 		}
 		if (!swapped) {
@@ -1271,6 +1795,7 @@ var SyncClient = class extends EventEmitter {
 		}
 		const among = new Set(this.versions(path).map((v) => v.text));
 		this.wrote(path, target);
+		if (this.holds(path)) this.editHeld((entries) => this.releaseHeld(entries, path));
 		return {
 			kind: "written",
 			displaced,
@@ -1297,7 +1822,7 @@ var SyncClient = class extends EventEmitter {
 				...from,
 				among: /* @__PURE__ */ new Set([...from.among, taken])
 			};
-			await this.withChain(path, () => this.sendLocal(path, later, { displaced: held }));
+			await this.withChain(path, () => this.queueLocal(path, later, { displaced: held }));
 		}
 	}
 	withChain(path, fn) {
@@ -1314,16 +1839,19 @@ var SyncClient = class extends EventEmitter {
 			text,
 			server: text
 		});
-		this.saveKnown();
+		this.confirm(path, {
+			hash: contentHash(text),
+			text
+		});
 	}
 	/**
 	* Every version a local write of `path` may have started from, oldest first (docs/sync.md "直接改檔的基準"): the
 	* confirmed ones kept in memory; from the outbox, the base of each queued edit whose base is known, and, unconfirmed,
-	* what each queued write left on disk; and, unconfirmed, each direct edit waiting for its answer. A write answered
-	* but still queued counts as unconfirmed until it leaves the outbox, in the same hold that fills in the bases on it.
-	* Only the entries before `upto` count, for an entry whose base can come only from the writes ahead of it. A text
-	* both confirmed and unconfirmed is unconfirmed, since only the answer to the write that put it on disk confirms
-	* it; the outbox and the requests in flight hold every unconfirmed text, so a restart reads them back.
+	* what each queued write wrote. A write answered but still queued counts as unconfirmed until it leaves the outbox,
+	* in the same hold that fills in the bases on it. Only the entries before `upto` count, for an entry whose base can
+	* come only from the writes ahead of it. A text both confirmed and unconfirmed is unconfirmed, since only the answer
+	* to the write that put it on disk confirms it; the outbox holds every unconfirmed text, so a restart reads them back.
+	* A text the server refused is no version: it never becomes one the server holds.
 	*/
 	versions(path, entries = this.queue, upto = entries.length) {
 		const out = /* @__PURE__ */ new Map();
@@ -1334,10 +1862,10 @@ var SyncClient = class extends EventEmitter {
 			if (held && !out.has(held.text)) out.set(held.text, held);
 		}
 		for (const entry of ahead) {
+			if (!waiting(entry)) continue;
 			const text = entry.kind === "op" ? entry.written[path] : entry.kind === "patch" && entry.path === path ? entry.text : void 0;
 			if (typeof text === "string") out.set(text, { text });
 		}
-		for (const text of this.unanswered.get(path) ?? []) out.set(text, { text });
 		return [...out.values()];
 	}
 	/**
@@ -1346,146 +1874,71 @@ var SyncClient = class extends EventEmitter {
 	*/
 	startOf(path, text, before, scope = {}) {
 		const all = this.versions(path, scope.entries, scope.upto).filter((v) => scope.among?.has(v.text) ?? true);
-		const candidates = this.opts.nearestBase === false ? all.filter((v) => v.text === before?.text || v.server === before?.text).slice(-1) : all;
-		let best;
-		let bestDistance = Infinity;
-		for (const version of candidates) {
-			const distance = lineDistance(version.text, text);
-			if (distance <= bestDistance) {
-				best = version;
-				bestDistance = distance;
-			}
-		}
-		return best;
+		return closestVersion(this.opts.nearestBase === false ? all.filter((v) => v.text === before?.text || v.server === before?.text).slice(-1) : all, text);
 	}
 	/**
-	* Send a local text of `path`, at once when the client has caught up and its base is confirmed, through the outbox
-	* otherwise. A text on disk is what the client now expects there. A `displaced` text, one the server's version took
-	* off disk, is not: it was written over the version the client had left there, and on a version the old file held
-	* (layer 3). `start` overrides layer 1: the version the writer started from, or null for a new file.
+	* Queue a local text of `path`, on the version layer 1 chooses among the versions the writes queued ahead of it
+	* leave. A text on disk is what the client now expects there, adopted in the hold of the write lock that queues it
+	* (I2): a file that no longer holds it there, as after an operation written on it since it was read, or that holds
+	* what the client expects already, is reconciled again instead. A `displaced` text, one the server's version took off
+	* disk, is not on disk: it was written over the version the client had left there, and on a version the old file held
+	* (layer 3); with none of those left, it is based on the text the client had left there, so layer 2 still tells the
+	* writer's lines from the ones the server changed meanwhile. `start` overrides layer 1: the version the writer started
+	* from, or null for a new file.
 	*/
-	async sendLocal(path, text, options = {}) {
+	async queueLocal(path, text, options = {}) {
 		const { displaced } = options;
-		const before = displaced ? displaced.over : this.expected.get(path);
-		const last = before?.text;
-		if (!displaced) {
-			this.expected.set(path, {
+		if (await this.enqueue((entries) => {
+			const before = displaced ? displaced.over : this.expected.get(path);
+			if (!displaced && (!this.onDisk(path, text) || before?.hash === contentHash(text))) return null;
+			const last = before?.text;
+			if (!displaced) this.expected.set(path, {
 				hash: contentHash(text),
 				text
 			});
-			this.saveKnown();
-		}
-		const write = editOn(path, text, options.start !== void 0 ? options.start ?? void 0 : before === null ? void 0 : this.startOf(path, text, before, { among: displaced?.among }), options.start === null ? null : before?.hash ?? null, last);
-		this.trace(`local ${path} ${short(text)} on disk ${short(before?.text ?? null)} versions [${this.versions(path).map((v) => `${short(v.text)}→${v.server === void 0 ? "?" : short(v.server)}`).join(" ")}] chose base ${write.base?.slice(0, 7) ?? "null"} baseText ${short(write.baseText ?? null)}${write.serverBase === void 0 ? "" : ` serverBase ${short(write.serverBase)}`}`);
-		if (!this.caughtUp) return this.enqueue(write);
-		const request = patchRequest(write);
-		if (request === "unresolved") return this.enqueue(write);
-		if (request === "overlap") {
-			const saved = await this.saveConflict(path, text);
-			return this.problem({
-				kind: "conflict",
-				path,
-				saved,
-				message: `${path} was edited on top of an earlier edit that the server merged with other changes, and the two edits overlap; the text written here was saved to ${saved}`
+			let start = options.start !== void 0 ? options.start ?? void 0 : before === null ? void 0 : this.startOf(path, text, before, {
+				entries,
+				among: displaced?.among
 			});
-		}
-		await this.sendEdit(write, request, {
-			writer: text,
-			base: write.baseText,
-			last
-		});
-	}
-	/**
-	* Send a direct edit at once, outside the outbox. While it waits for its answer, the writer's text is a version the
-	* server has not confirmed, so layer 1 can tell a later write based on it from one based on an older version. When
-	* the connection breaks after sending, the edit goes into the outbox with the very request, under its requestId, so
-	* the server answers it again if it took it the first time; one never sent goes in to be sent later.
-	*/
-	async sendEdit(write, request, context) {
-		const { path } = write;
-		this.inflight.set(path, (this.inflight.get(path) ?? 0) + 1);
-		this.awaitAnswer(path, write.text);
-		const id = entryId();
-		const firstSentSeq = this.hubSeq;
-		const queued = this.queuedIds();
-		this.trace(`patch ${path} ${id} base ${request.base?.slice(0, 7) ?? "null"} text ${short(request.text)} writer ${short(context.writer)} baseText ${short(context.base ?? null)}`);
-		try {
-			let response;
-			try {
-				response = await this.api.send({
-					...request,
-					requestId: id
-				});
-			} catch (error) {
-				this.trace(`patch ${path} failed: ${error.message}`);
-				if (!(error instanceof Unreachable)) throw error;
-				return await this.enqueue(write, {
-					queued,
-					...error.sent ? { sent: {
-						id,
-						firstSentSeq,
-						sent: request
-					} } : {}
-				});
-			}
-			await this.settleEdit(path, response, context, request.text);
-		} finally {
-			this.answeredDirect(path, write.text);
-		}
-	}
-	/** The outbox entries as last read, for a write sent outside it: what was queued when it was sent. */
-	queuedIds() {
-		return new Set(this.queue.map((entry) => entry.id));
-	}
-	/** A direct edit or Edit sent outside the outbox now waits for its answer. */
-	awaitAnswer(path, text) {
-		this.unanswered.set(path, [...this.unanswered.get(path) ?? [], text]);
-	}
-	/**
-	* A direct edit or Edit sent outside the outbox was answered, or queued: its text is confirmed, or held by the
-	* outbox. The outbox is read again, which fills in the base of the edits queued on it, and sent.
-	*/
-	answeredDirect(path, text) {
-		const texts = this.unanswered.get(path) ?? [];
-		texts.splice(texts.indexOf(text), 1);
-		if (texts.length === 0) this.unanswered.delete(path);
-		this.release(path);
-		if (this.queue.length > 0) this.outboxChanged();
-	}
-	release(path) {
-		const count = (this.inflight.get(path) ?? 1) - 1;
-		if (count > 0) this.inflight.set(path, count);
-		else this.inflight.delete(path);
-		this.dirty.delete(path);
+			if (displaced && start === void 0 && displaced.over.text !== void 0) start = {
+				text: displaced.over.text,
+				server: displaced.over.text
+			};
+			const write = {
+				...editOn(path, text, start, options.start === null ? null : before?.hash ?? null, last),
+				...displaced ? { displaced: true } : {}
+			};
+			this.trace(`local ${path} ${short(text)} on disk ${short(before?.text ?? null)} versions [${this.versions(path, entries).map((v) => `${short(v.text)}→${v.server === void 0 ? "?" : short(v.server)}`).join(" ")}] chose base ${write.base?.slice(0, 7) ?? "null"} baseText ${short(write.baseText ?? null)}${write.serverBase === void 0 ? "" : ` serverBase ${short(write.serverBase)}`}`);
+			return write;
+		}) !== null) return;
+		this.trace(`local ${path} ${short(text)} changed before it was queued; reconciling it again`);
 		this.schedule(path);
 	}
-	/** What a response to a direct edit means for the writer (layer 2), then wait for the broadcast it caused. */
-	async settleEdit(path, response, context, sent) {
+	/** What the response to queued edit `entry` means for the writer (layer 2), then wait for the broadcast it caused. */
+	async settleEdit(entry, response, context, sent) {
+		const { path } = entry;
 		this.trace(`response ${path} ${response.ok ? `${response.files.map((f) => `${f.path} ${f.kind === "file" ? short(f.text) : f.kind}`).join(", ")}` : `${response.reason}: ${response.message}`}`);
 		if (response.ok) {
 			const file = response.files.find((f) => f.path === path);
 			const result = file?.kind === "file" ? file.text : file?.kind === "removed" ? null : this.cloud.get(path) ?? sent ?? context.writer;
-			if (typeof result === "string") this.remember(path, {
-				text: context.writer,
-				server: result
-			});
-			if (typeof result === "string") this.classify(path, context, result);
+			if (typeof result === "string") {
+				this.remember(path, {
+					text: context.writer,
+					server: result
+				});
+				this.confirmWritten(path, context.writer);
+				this.classify(path, context, result);
+			}
 			if (file) await this.delivery(path, response.seq);
 			return;
 		}
-		const saved = await this.saveConflict(path, context.writer);
-		if (response.reason === "conflict") this.problem({
-			kind: "conflict",
+		const conflict = response.reason === "conflict";
+		await this.refuse(entry, [{
+			kind: conflict ? "conflict" : "refused",
 			path,
-			saved,
-			message: `${path}: the server refused the change (${response.message}); the text written here was saved to ${saved} and the file now has the server's version`
-		});
-		else this.problem({
-			kind: "refused",
-			path,
-			saved,
-			message: `${path}: the server refused the change (${response.message}); the text written here was saved to ${saved}`
-		});
+			text: context.writer,
+			message: (saved) => `${path}: the server refused the change (${response.message}); the text written here was saved to ${saved}${conflict ? " and the file now has the server's version" : ""}`
+		}]);
 		if ("files" in response && response.files.some((f) => f.path === path)) await this.delivery(path, response.seq);
 	}
 	/**
@@ -1537,60 +1990,33 @@ var SyncClient = class extends EventEmitter {
 		}
 		this.info(path, "merged with changes from other environments");
 	}
-	/** Send a deletion at once, outside the outbox; after a broken connection the same request goes into the outbox, as in sendEdit. */
-	async sendRemove(path, base) {
-		this.forget(path);
-		if (!this.caughtUp) return this.enqueue({
-			kind: "remove",
-			path,
-			base
-		});
-		const id = entryId();
-		const firstSentSeq = this.hubSeq;
-		const request = {
-			protocol: 2,
-			op: "file.remove",
-			input: {
-				path,
-				base
-			},
-			now: requestTime()
-		};
-		const queued = this.queuedIds();
-		this.inflight.set(path, (this.inflight.get(path) ?? 0) + 1);
-		try {
-			let unsent = false;
-			const response = await this.api.send({
-				...request,
-				requestId: id
-			}).catch((error) => {
-				if (!(error instanceof Unreachable)) throw error;
-				unsent = !error.sent;
-				return null;
-			});
-			if (response === null) return this.enqueue({
+	/**
+	* Queue the deletion of `path`, which held `seen` as the client left it: its hash is the deletion's base. Its versions
+	* are forgotten in the hold of the write lock that queues it (I2), while the file is still gone there and the client
+	* still expects `seen`; otherwise, as after an operation that wrote the file since it was read, it is reconciled again.
+	*/
+	async queueRemove(path, seen) {
+		if (await this.enqueue(() => {
+			if (this.expected.get(path)?.hash !== seen.hash || !this.onDisk(path, null)) return null;
+			this.forget(path);
+			return {
 				kind: "remove",
 				path,
-				base
-			}, {
-				queued,
-				...unsent ? {} : { sent: {
-					id,
-					firstSentSeq,
-					sent: request
-				} }
-			});
-			await this.settleRemove(path, response);
-		} finally {
-			this.release(path);
-		}
+				base: seen.hash
+			};
+		}) !== null) return;
+		this.trace(`removal of ${path} changed before it was queued; reconciling it again`);
+		this.schedule(path);
 	}
-	async settleRemove(path, response) {
-		if (!response.ok) return this.problem({
+	async settleRemove(entry, response) {
+		const { path } = entry;
+		if (!response.ok) return this.refuse(entry, [{
 			kind: "refused",
 			path,
-			message: `${path}: the server refused the deletion (${response.message})`
-		});
+			text: null,
+			message: () => `${path}: the server refused the deletion (${response.message})`
+		}]);
+		if (response.files.some((f) => f.path === path && f.kind === "removed")) this.confirmWritten(path, null);
 		for (const notice of response.notices) this.problem({
 			kind: "removal-kept",
 			path: notice.path,
@@ -1599,19 +2025,39 @@ var SyncClient = class extends EventEmitter {
 		if (response.files.some((f) => f.path === path)) await this.delivery(path, response.seq);
 	}
 	/**
-	* What an outbox entry left on disk is what the client expects there. The versions it holds need nothing more: the
-	* outbox is where versions() reads them.
+	* What an outbox entry left on disk is what the client expects there; a displaced text left nothing there, since the
+	* server's version took it off. The versions it holds need nothing more: the outbox is where versions() reads them.
 	*/
 	restoreEntry(entry) {
+		if (entry.refused) {
+			for (const path of entry.refused.paths) {
+				const text = wroteAt(entry, path);
+				if (text !== void 0) this.expected.set(path, text === null ? null : {
+					hash: contentHash(text),
+					text
+				});
+			}
+			return;
+		}
 		if (entry.kind === "op") for (const [path, text] of Object.entries(entry.written)) this.expected.set(path, text === null ? null : {
 			hash: contentHash(text),
 			text
 		});
-		else if (entry.kind === "patch") this.expected.set(entry.path, {
-			hash: contentHash(entry.text),
-			text: entry.text
-		});
-		else this.expected.set(entry.path, null);
+		else if (entry.kind === "patch") {
+			if (!entry.displaced) this.expected.set(entry.path, {
+				hash: contentHash(entry.text),
+				text: entry.text
+			});
+		} else this.expected.set(entry.path, null);
+	}
+	/**
+	* Hold the write lock for `fn`; work stop() abandoned gets an error ('abandoned after stop') instead, so it leaves
+	* the outbox, known.json and the synced files alone. It can still add files under local/sync/ that no run reads as
+	* state: saved texts in conflicts/, lines in notices.jsonl and temporary files in tmp/.
+	*/
+	locked(fn) {
+		if (this.abandoned) throw new Error("abandoned after stop");
+		return underLock(this.root, fn);
 	}
 	/**
 	* Change the outbox: read queue.json, take in the entries other writers appended since it was last read, let `edit`
@@ -1622,13 +2068,14 @@ var SyncClient = class extends EventEmitter {
 	* (resolveBases), before `edit` and after it, so the entry that confirmed it leaves the outbox in the same hold.
 	*/
 	editQueue(edit) {
-		return underLock(this.root, () => this.editHeld(edit));
+		return this.locked(() => this.editHeld(edit));
 	}
 	/** editQueue for a caller that holds the write lock already. */
 	editHeld(edit) {
 		const entries = readQueue(this.root);
 		const known = new Set(this.queue.map((entry) => entry.id));
 		let changed = false;
+		const fresh = [];
 		for (let i = 0; i < entries.length; i++) {
 			const entry = entries[i];
 			if (known.has(entry.id)) continue;
@@ -1640,7 +2087,9 @@ var SyncClient = class extends EventEmitter {
 				changed = true;
 			}
 			this.restoreEntry(entry);
+			if (waiting(entry)) fresh.push(entry);
 		}
+		for (const entry of fresh) for (const path of entryPaths(entry)) if (this.releaseHeld(entries, path, entries.indexOf(entry))) changed = true;
 		if (this.resolveBases(entries)) changed = true;
 		if (edit && edit(entries) !== false) {
 			changed = true;
@@ -1753,7 +2202,7 @@ var SyncClient = class extends EventEmitter {
 	resolveBases(entries) {
 		let changed = false;
 		entries.forEach((entry, at) => {
-			if (entry.kind !== "patch" || entry.base !== null || entry.baseText === void 0 || entry.sent !== void 0) return;
+			if (entry.kind !== "patch" || entry.base !== null || entry.baseText === void 0 || entry.sent !== void 0 || !waiting(entry)) return;
 			const start = this.versions(entry.path, entries, at).find((v) => v.text === entry.baseText);
 			if (start?.server === void 0) return;
 			Object.assign(entry, editOn(entry.path, entry.text, start, null));
@@ -1778,34 +2227,42 @@ var SyncClient = class extends EventEmitter {
 			await sleep$1(500);
 		}
 	}
-	/** queue.json changed, or may have: take in what other writers appended and send it. */
+	/**
+	* queue.json changed, or may have: take in what other writers appended and send it. A writer that does not wait for
+	* the server calls it over the port right after appending (notifyQueued); the watcher of queue.json and the rescan
+	* find an append no writer told of.
+	*/
 	outboxChanged() {
-		const before = this.queue.length;
+		if (this.closing) return;
+		const before = this.queued;
 		this.track(this.whenFree(() => this.syncQueue()).then(() => {
-			if (this.queue.length !== before) this.log(`outbox: ${this.queue.length} waiting`);
-			if (this.online && this.queue.length > 0) this.track(this.flushQueue());
+			if (this.queued !== before) this.log(`outbox: ${this.queued} waiting`);
+			if (this.online && this.queued > 0) this.track(this.flushQueue());
 		}).catch((error) => this.log(`outbox: ${error.message}`)));
 	}
 	/**
-	* Queue a write, as an entry of its own: an edit keeps the base layer 1 chose for it (docs/sync.md "直接改檔的基準").
-	* A write sent outside the outbox (`from`) that could not be answered goes ahead of the entries queued after it was
-	* sent, the order in which it was written, since they may be based on it; `sent` is its request when the connection
-	* broke after sending, queued as it was, under its requestId, so the server answers it again if it took it. Any
-	* other write goes after every write queued already.
+	* Queue a write after every write queued already, as an entry of its own, in one hold of the write lock: `make` runs
+	* once the outbox is taken in, with the outbox as read, and returns the write, or null to queue nothing. What `make`
+	* adopts from disk is adopted in the same hold, so an operation appended since the file was read is taken in first and
+	* compared with what the client expected before (I2). An edit keeps the base layer 1 chose for it (docs/sync.md
+	* "直接改檔的基準"). Returns the entry's id, or null when nothing was queued.
 	*/
-	async enqueue(write, from) {
+	async enqueue(make) {
+		const id = entryId();
+		let write = null;
 		await this.whenFree(() => this.editQueue((entries) => {
-			const entry = {
+			write = make(entries);
+			if (!write) return false;
+			entries.push({
 				...write,
-				id: entryId(),
-				...from?.sent
-			};
-			const at = from ? entries.findIndex((queued) => !from.queued.has(queued.id)) : -1;
-			if (at < 0) entries.push(entry);
-			else entries.splice(at, 0, entry);
+				id
+			});
+			for (const path of entryPaths(write)) this.releaseHeld(entries, path, entries.length - 1);
 		}));
+		if (!write) return null;
 		this.log(`queued ${write.kind} ${entryPaths(write).join(", ")} (${this.queue.length} waiting)`);
 		if (this.online) this.track(this.flushQueue());
+		return id;
 	}
 	/**
 	* Send the outbox in order, one at a time, each after the previous one's response. An answered entry leaves the
@@ -1814,25 +2271,27 @@ var SyncClient = class extends EventEmitter {
 	* sends and its firstSentSeq are written to the outbox (`sent`), so it is sent again as it was even after a restart,
 	* and nothing is merged into it. An edit whose base cannot be moved onto the server's version is not sent.
 	*/
-	async flushQueue() {
-		if (this.flushing) return;
+	flushQueue() {
+		if (this.flushing || this.closing) return Promise.resolve();
+		const run = this.sendOutbox();
+		this.flushRun = run;
+		return run.finally(() => {
+			if (this.flushRun === run) this.flushRun = null;
+		});
+	}
+	async sendOutbox() {
 		this.flushing = true;
 		try {
 			while (this.caughtUp) {
 				let entry;
 				let again = false;
 				let unmergeable = false;
-				let waiting = false;
 				this.editQueue((entries) => {
-					entry = entries[0];
+					entry = entries.find((queued) => waiting(queued) || this.answered.has(queued.id));
 					if (!entry || this.answered.has(entry.id)) return false;
 					again = entry.firstSentSeq !== void 0;
 					if (entry.sent) return false;
 					const request = this.prepare(entry);
-					if (request === "wait") {
-						waiting = true;
-						return false;
-					}
 					if (!request) {
 						unmergeable = true;
 						return false;
@@ -1840,7 +2299,7 @@ var SyncClient = class extends EventEmitter {
 					entry.sent = request;
 					entry.firstSentSeq ??= this.hubSeq;
 				});
-				if (!entry || waiting) break;
+				if (!entry || this.closing) break;
 				if (unmergeable) await this.refuseUnmergeable(entry);
 				else if (!this.answered.has(entry.id)) {
 					this.sending = entry.id;
@@ -1857,18 +2316,20 @@ var SyncClient = class extends EventEmitter {
 	}
 	retryQueue() {
 		clearTimeout(this.queueTimer);
-		if (!this.stopped) this.queueTimer = setTimeout(() => void this.track(this.flushQueue()), 1e3 + Math.random() * 1e3);
+		if (!this.stopped && !this.closing) this.queueTimer = setTimeout(() => void this.track(this.flushQueue()), 1e3 + Math.random() * 1e3);
 	}
 	/**
 	* Take an answered entry out of the outbox, and give the ids the server renumbered to the files written here and
-	* to the entries after it, in one hold of the write lock (docs/sync-protocol.md). Throws while the lock is taken.
+	* to the entries after it, in one hold of the write lock (docs/sync-protocol.md). A refused one stays while a file
+	* holds what it wrote, until the server's version is there (refuse). Throws while the lock is taken.
 	*/
 	finish(entry) {
 		const renumbered = this.renumbering.get(entry.id);
 		this.editQueue((entries) => {
 			if (renumbered) this.renumber(entries, entry, renumbered);
 			const at = entries.findIndex((e) => e.id === entry.id);
-			if (at >= 0) entries.splice(at, 1);
+			if (at >= 0 && waiting(entries[at])) entries.splice(at, 1);
+			else this.dropSettled(entries);
 		});
 		this.answered.delete(entry.id);
 		this.renumbering.delete(entry.id);
@@ -1920,9 +2381,11 @@ var SyncClient = class extends EventEmitter {
 	* stays queued. A connection that broke after sending needs no warning: the request goes again under the same id,
 	* and a server that took it answers with the response it kept. `again` says it may have been sent before, so it
 	* carries firstSentSeq; when the server no longer keeps the responses that far back and cannot tell whether it
-	* applied it, the writer is told and it is sent once more as a new request.
+	* applied it, the writer is told and it is sent once more as a new request. A connection that closed under the
+	* request (`broken`), as a kept one the server closed while idle does, is not waited out: the request goes again at
+	* once, on a connection of its own (`fresh`), as sent again. Once only: a second failure leaves it to the retry.
 	*/
-	async request(entry, request, again) {
+	async request(entry, request, again, fresh = false) {
 		const firstSentSeq = again ? entry.firstSentSeq : void 0;
 		this.trace(`send ${request.op} ${entry.id}${firstSentSeq === void 0 ? "" : ` again, first sent at seq ${firstSentSeq}`}`);
 		let response;
@@ -1934,10 +2397,11 @@ var SyncClient = class extends EventEmitter {
 				...request,
 				requestId: entry.id,
 				firstSentSeq
-			});
+			}, { fresh });
 		} catch (error) {
 			if (!(error instanceof Unreachable)) throw error;
 			this.trace(`send ${entry.id} failed: ${error.message}`);
+			if (error.broken && !fresh && !this.closing) return this.request(entry, request, true, true);
 			return null;
 		}
 		if (!response.ok && response.reason === "uncertain") {
@@ -1947,15 +2411,16 @@ var SyncClient = class extends EventEmitter {
 				path: paths[0] ?? "",
 				message: `${request.op} of ${paths.join(", ")} was sent before without an answer, and the sync server no longer keeps its answers from then (${response.message}); it is sent again as a new request and may apply twice, so check the result for a duplicate`
 			});
-			return this.request(entry, request, false);
+			return this.request(entry, request, false, fresh);
 		}
 		return response;
 	}
 	/**
 	* The request an outbox entry sends, made when it is first sent, from the entry alone: an operation on the current
-	* protocol, a deletion with the time it is first sent, an edit as patchRequest makes it. `wait` for an edit based on
-	* a direct edit still waiting for its answer. Null for an edit that cannot be sent: its base is a write the server
+	* protocol, a deletion with the time it is first sent, an Edit's replacement to be made again on the server's latest
+	* version, an edit as patchRequest makes it. Null for an edit that cannot be sent: its base is a write the server
 	* refused or did not take as it was, so its base never became known, or moving it onto the server's merge overlaps.
+	* Every write ahead of it was answered, so a base still unknown never will be.
 	*/
 	prepare(entry) {
 		if (entry.kind === "op") return currentRequest(entry.request);
@@ -1968,34 +2433,139 @@ var SyncClient = class extends EventEmitter {
 			},
 			now: requestTime()
 		};
+		if (entry.replace) return {
+			protocol: 2,
+			op: "text.replace",
+			path: entry.path,
+			old: entry.replace.old,
+			new: entry.replace.new
+		};
 		const request = patchRequest(entry);
-		if (typeof request === "object") return request;
-		return request === "unresolved" && this.unanswered.get(entry.path)?.includes(entry.baseText) ? "wait" : null;
+		return typeof request === "object" ? request : null;
 	}
 	/** An edit prepare cannot send: its text is saved and the writer told; it is not sent. */
 	async refuseUnmergeable(entry) {
-		const saved = await this.saveConflict(entry.path, entry.text);
 		this.answer(entry);
-		this.problem({
+		await this.refuse(entry, [{
 			kind: "conflict",
 			path: entry.path,
-			saved,
-			message: `${entry.path} was edited on top of a write the server did not take as it was, or the edit overlaps what the server merged into it; the text written here was saved to ${saved}`
+			text: entry.text,
+			message: (saved) => `${entry.path} was edited on top of a write the server did not take as it was, or the edit overlaps what the server merged into it; the text written here was saved to ${saved}`
+		}]);
+	}
+	/**
+	* The server refused `entry`, or it cannot be sent: the writer is told of each of `told` and its text saved, once,
+	* wherever the sync client is killed (src/state.ts). First, in one hold of the write lock, the refusal is written on
+	* the entry: what the writer is told, with the name each text is saved under, and the files that hold what the entry
+	* wrote there as the client left it. Then each text is saved and the writer told. The entry is sent no more; it leaves
+	* the outbox once no file holds what it wrote (releaseHeld), so a restart before the server's version is on disk puts
+	* that version back rather than send the refused text again. An operation's writer is answered with `outcome`.
+	*/
+	async refuse(entry, told, outcome) {
+		const problems = told.map(({ kind, path, text, message }) => {
+			const saved = text === null ? void 0 : this.conflictName(path);
+			return {
+				kind,
+				path,
+				message: message(saved),
+				...saved === void 0 ? {} : { saved }
+			};
 		});
+		let marked;
+		await this.whenFree(() => this.editQueue((entries) => {
+			marked = entries.find((queued) => queued.id === entry.id);
+			if (!marked) return false;
+			marked.refused = {
+				paths: entryPaths(marked).filter((path) => this.leftHere(marked, path)),
+				told: problems,
+				...outcome ? { outcome } : {}
+			};
+		}));
+		this.trace(`refused ${entry.id} holding [${marked?.refused?.paths.join(", ") ?? ""}]`);
+		await this.tell(marked ?? {
+			...entry,
+			refused: {
+				paths: [],
+				told: problems,
+				...outcome ? { outcome } : {}
+			}
+		}, () => false);
+	}
+	/**
+	* Save each text of refused `entry` not saved yet, tell the writer of what `before` says it was not told of, and answer
+	* an operation's writer; the entry may leave the outbox from now on (dropSettled). A text that cannot be saved is
+	* still told of.
+	*/
+	async tell(entry, before) {
+		const refusal = entry.refused;
+		for (const problem of refusal.told) {
+			if (before(problem)) continue;
+			const text = textAt(entry, problem.path);
+			if (problem.saved !== void 0 && typeof text === "string") await this.saveText(problem.saved, text).catch((error) => this.log(`${problem.path}: could not save ${problem.saved}: ${String(error)}`));
+			this.problem(problem, entry.id);
+		}
+		if (refusal.outcome) this.settled(entry.id, {
+			state: "refused",
+			...refusal.outcome,
+			saved: refusal.told.flatMap((problem) => problem.saved ?? [])
+		});
+		this.told.add(entry.id);
+	}
+	/** Whether `path` holds what `entry` wrote there, as the client left it. */
+	leftHere(entry, path) {
+		const text = wroteAt(entry, path);
+		const disk = this.expected.get(path);
+		if (text === void 0 || disk === void 0) return false;
+		return text === null ? disk === null : disk !== null && disk.hash === contentHash(text);
+	}
+	/**
+	* `path` holds a refused write's text no more as the client left it: the server's version is there, or another write,
+	* or a text the client took. Each refused entry before `before` lets it go, and one whose writer was told that no file
+	* holds leaves the outbox. Called under the write lock with the outbox as read; true when it changed it.
+	*/
+	releaseHeld(entries, path, before = entries.length) {
+		let changed = false;
+		for (const entry of entries.slice(0, before)) {
+			if (!entry.refused?.paths.includes(path)) continue;
+			entry.refused.paths = entry.refused.paths.filter((held) => held !== path);
+			changed = true;
+		}
+		return this.dropSettled(entries) || changed;
+	}
+	/** Take out of the outbox each refused entry no file holds whose writer was told; true when it took one out. */
+	dropSettled(entries) {
+		let changed = false;
+		for (let i = entries.length - 1; i >= 0; i--) {
+			const entry = entries[i];
+			if (entry.refused === void 0 || entry.refused.paths.length > 0 || !this.told.has(entry.id)) continue;
+			entries.splice(i, 1);
+			this.told.delete(entry.id);
+			changed = true;
+		}
+		return changed;
+	}
+	/** Whether a refused entry holds `path`, as the outbox was last read. */
+	holds(path) {
+		return this.queue.some((entry) => entry.refused?.paths.includes(path));
+	}
+	/** releaseHeld for a caller without the write lock; nothing when no refused entry holds `path`. */
+	async release(path) {
+		if (this.holds(path)) await this.whenFree(() => this.editQueue((entries) => this.releaseHeld(entries, path)));
 	}
 	/** Send one queued entry as `sent`; false when the server cannot be reached, so it stays queued. `again`: see request. */
 	async sendEntry(entry, again) {
 		const request = entry.sent;
 		const paths = entryPaths(entry);
+		if (!again && entry.kind === "patch" && request.op === "file.patch") this.trace(`patch ${entry.path} ${entry.id} base ${request.base?.slice(0, 7) ?? "null"} text ${short(request.text)} writer ${short(entry.text)} baseText ${short(entry.baseText ?? null)}`);
 		for (const path of paths) this.inflight.set(path, (this.inflight.get(path) ?? 0) + 1);
 		try {
 			const response = await this.request(entry, request, again);
 			if (response === null) return false;
 			this.answer(entry);
 			if (entry.kind === "op") await this.settleQueuedOp(entry, response);
-			else if (request.op === "file.remove") await this.settleRemove(entry.path, response);
-			else if (entry.kind === "patch" && request.op === "text.replace") await this.settleReplace(entry.path, response, entry.text);
-			else if (entry.kind === "patch" && request.op === "file.patch") await this.settleEdit(entry.path, response, {
+			else if (entry.kind === "remove") await this.settleRemove(entry, response);
+			else if (entry.kind === "patch" && request.op === "text.replace") await this.settleReplace(entry, response);
+			else if (entry.kind === "patch" && request.op === "file.patch") await this.settleEdit(entry, response, {
 				writer: entry.text,
 				base: entry.baseText,
 				last: entry.replaced
@@ -2012,25 +2582,16 @@ var SyncClient = class extends EventEmitter {
 	/** A queued operation answered: tie what was written here to the server's versions, or report a refusal. */
 	async settleQueuedOp(entry, response) {
 		if (!response.ok) {
-			const saved = [];
-			for (const [path, text] of Object.entries(entry.written)) {
-				if (text === null) continue;
-				const at = await this.saveConflict(path, text);
-				saved.push(at);
-				this.problem({
-					kind: "refused",
-					path,
-					saved: at,
-					message: `the server refused ${entry.request.op} (${response.message}); ${path} as it was written here was saved to ${at} and the file has the server's version again`
-				});
-			}
-			this.settled(entry.id, {
-				state: "refused",
+			const told = Object.entries(entry.written).flatMap(([path, text]) => text === null ? [] : [{
+				kind: "refused",
+				path,
+				text,
+				message: (saved) => `the server refused ${entry.request.op} (${response.message}); ${path} as it was written here was saved to ${saved} and the file has the server's version again`
+			}]);
+			return this.refuse(entry, told, {
 				reason: response.reason,
-				message: response.message,
-				saved
+				message: response.message
 			});
-			return;
 		}
 		this.settled(entry.id, {
 			state: "applied",
@@ -2041,35 +2602,41 @@ var SyncClient = class extends EventEmitter {
 			if (file.kind !== "file") continue;
 			const written = Object.entries(entry.written).find(([path]) => renumberPath(path, response.renumbered) === file.path)?.[1];
 			const local = written == null ? void 0 : renumberText(written, response.renumbered, scopeOfPath(file.path));
-			if (local !== void 0) this.remember(file.path, {
+			if (local === void 0) continue;
+			this.remember(file.path, {
 				text: local,
 				server: file.text
 			});
+			if (local === written) this.confirmWritten(file.path, local);
 		}
 		await Promise.all(response.files.filter((f) => f.kind !== "dir").map((f) => this.delivery(f.path, response.seq)));
 	}
 	/**
 	* The server gave some of the entry's provisional ids away: rewrite the files written offline, the queued requests
 	* and edits after it, and what the client expects on disk (docs/sync-protocol.md). Called under the write lock with
-	* the outbox as read, so a writer appending meanwhile sees either the old ids everywhere or the new. An entry sent
-	* already (`sent`), such as a direct edit whose answer was lost, stays as the server may have taken it, and so do
-	* the files only it wrote; the server's version of them comes back once it is answered. An edit queued on top of it
-	* keeps that text as its base, so its renumbering is what it changes.
+	* the outbox as read, so a writer appending meanwhile sees either the old ids everywhere or the new. The outbox is
+	* sent in order, so every entry after it is still to be sent; one sent already (`sent`), as an older sync client left
+	* behind an operation when it sent edits outside the outbox, stays as the server may have taken it, and so do the
+	* files only it wrote; the server's version of them comes back once it is answered. An edit queued on top of it
+	* keeps that text as its base, so its renumbering is what it changes, and it puts the server's id there when it
+	* lands. A sent write that names a renumbered id is reported (`stale-id`) unless such an edit follows it: the server
+	* takes the id as sent, where it names another environment's entry, and nothing else after it changes that id there:
+	* an Edit sends only its replacement, an operation only what it does, and an edit on another base leaves the line as
+	* the sent write wrote it. A refused write is no write to send.
 	*/
 	renumber(entries, entry, renumbered) {
-		const rest = entries.filter((queued) => queued.id !== entry.id && queued.sent === void 0);
+		const rest = entries.filter((queued) => queued.id !== entry.id && queued.sent === void 0 && waiting(queued));
 		const offlinePaths = [...entryPaths(entry), ...rest.flatMap(entryPaths)];
-		const storage = this.trackingStorage();
-		this.commitTracked(storage, renumberFiles(storage, offlinePaths, renumbered));
+		this.renumberDisk(offlinePaths, renumbered);
 		const files = (record) => Object.fromEntries(Object.entries(record).map(([path, text]) => {
 			const to = renumberPath(path, renumbered);
 			return [to, text === null ? null : renumberText(text, renumbered, scopeOfPath(to))];
 		}));
 		const sentText = new Set(entries.flatMap((queued) => queued.id !== entry.id && queued.kind === "patch" && queued.sent !== void 0 ? [`${queued.path}\0${queued.text}`] : []));
+		const fixedLater = (queued) => rest.some((later) => later.kind === "patch" && later.path === queued.path && !later.replace && later.baseText === queued.text);
 		for (const queued of entries) {
-			if (queued.id === entry.id || queued.kind !== "patch" || queued.sent === void 0 || offlinePaths.includes(queued.path)) continue;
-			if (renumberText(queued.text, renumbered, scopeOfPath(queued.path)) === queued.text) continue;
-			this.info(queued.path, `sent before ${renumbered.map((r) => `${r.from} → ${r.to}`).join(", ")} was known, so it keeps the ids as the server took them`);
+			if (queued.id === entry.id || queued.kind !== "patch" || !queued.sent || !waiting(queued) || fixedLater(queued)) continue;
+			this.staleIds(queued.path, queued.sent, renumbered);
 		}
 		for (const queued of rest) if (queued.kind === "op") {
 			queued.request = renumberRequest(queued.request, renumbered);
@@ -2081,44 +2648,66 @@ var SyncClient = class extends EventEmitter {
 			if (queued.kind === "patch") {
 				queued.text = renumberText(queued.text, renumbered, scopeOfPath(queued.path));
 				if (queued.replaced !== void 0) queued.replaced = renumberText(queued.replaced, renumbered, scopeOfPath(queued.path));
+				if (queued.replace) queued.replace = {
+					old: renumberText(queued.replace.old, renumbered, scopeOfPath(queued.path)),
+					new: renumberText(queued.replace.new, renumbered, scopeOfPath(queued.path))
+				};
 				if (queued.baseText !== void 0 && !sentText.has(`${from}\0${queued.baseText}`)) queued.baseText = renumberText(queued.baseText, renumbered, scopeOfPath(queued.path));
 			}
 		}
 	}
+	/** A write of `path` sent as `sent` before `renumbered` was known: the writer is told of each id it names. */
+	staleIds(path, sent, renumbered) {
+		const text = sent.op === "file.patch" ? sent.text : sent.op === "text.replace" ? sent.new : null;
+		if (text === null) return;
+		const named = renumbered.filter((r) => renumberText(text, [r], scopeOfPath(path)) !== text);
+		if (named.length === 0) return;
+		const ids = named.map((r) => r.from).join(", ");
+		this.problem({
+			kind: "stale-id",
+			path,
+			renumbered: named,
+			message: `${path} was sent before the sync server renumbered ${named.map((r) => `${r.from} → ${r.to}`).join(", ")}, and the server takes it as it was sent: ${ids} there now names the entry the server gave that id to, another environment's, and the entry meant here is ${named.map((r) => r.to).join(", ")}; change the reference if it meant the entry added here`
+		});
+	}
 	/**
-	* The local files as a hub storage whose writes the client expects, so they are not taken for local edits; the
-	* renumbered outbox holds them as versions. It does not take the write lock: its caller holds it.
+	* Renumber the local files at `paths`, and what the client expects there: what it expected before, renumbered, which
+	* the renumbered outbox holds as versions. A direct edit a file holds that the client has not read yet, written while
+	* the operation waited for its answer, is renumbered on disk with the rest and stays a difference from what the client
+	* expects, so the reconcile after the operation leaves the outbox queues it, instead of taking it for what the outbox
+	* wrote. Only a path whose expected text is unknown takes what the file holds. It does not take the write lock: its
+	* caller holds it.
 	*/
-	trackingStorage() {
-		const base = {
+	renumberDisk(paths, renumbered) {
+		const storage = {
 			...nodeStorage(this.root),
 			lock: (fn) => fn()
 		};
-		const track = (path) => {
-			if (!isSynced(path)) return;
-			const text = base.read(path);
+		const seen = new Map([...new Set(paths)].filter(isSynced).map((path) => [path, this.expected.get(path)]));
+		const changes = renumberFiles(storage, seen.keys(), renumbered);
+		const unknown = /* @__PURE__ */ new Set();
+		for (const [path, disk] of seen) {
+			const to = renumberPath(path, renumbered);
+			if (to !== path) this.expected.set(path, null);
+			if (disk === null) this.expected.set(to, null);
+			else if (disk?.text !== void 0) {
+				const text = renumberText(disk.text, renumbered, scopeOfPath(path));
+				this.expected.set(to, {
+					hash: contentHash(text),
+					text
+				});
+			} else unknown.add(to);
+		}
+		this.commit(storage, changes);
+		for (const path of unknown) {
+			const text = storage.read(path);
 			this.expected.set(path, text === null ? null : {
 				hash: contentHash(text),
 				text
 			});
-		};
-		return {
-			...base,
-			write: (path, text) => {
-				base.write(path, text);
-				track(path);
-			},
-			append: (path, text) => {
-				base.append(path, text);
-				track(path);
-			},
-			remove: (path) => {
-				base.remove(path);
-				track(path);
-			}
-		};
+		}
 	}
-	commitTracked(storage, changes) {
+	commit(storage, changes) {
 		for (const change of changes) if (change.kind === "write") storage.write(change.path, change.text);
 		else if (change.kind === "append") storage.append(change.path, change.text);
 		else if (change.kind === "makeDir") storage.makeDir(change.path);
@@ -2137,7 +2726,7 @@ var SyncClient = class extends EventEmitter {
 		await this.idle(timeoutMs);
 		return {
 			problems: this.drain(),
-			queued: this.queue.length,
+			queued: this.queued,
 			online: this.online
 		};
 	}
@@ -2150,75 +2739,64 @@ var SyncClient = class extends EventEmitter {
 		if (this.caughtUp && isSynced(path) && edit.old !== "") await this.withChain(path, () => this.replayEdit(edit));
 		return this.flush(timeoutMs);
 	}
+	/**
+	* Queue an Edit as its replacement, which the server makes again on its latest version, based as layer 1 knows the
+	* version the Edit changed, the one on disk. One the watcher queued as a whole text already, or that is not the plain
+	* replacement of the version on disk, is left to the flush. The Edit's result is adopted in the hold of the write lock
+	* that queues it (I2); one changed there since it was read, as by an operation written on it, which then has the Edit
+	* queued ahead of it as a direct edit, is reconciled again.
+	*/
 	async replayEdit({ path, old, new: replacement }) {
-		for (let i = 0; i < 400 && this.isBusy(path); i++) await sleep$1(50);
 		const disk = this.expected.get(path);
 		const local = await this.readLocal(path);
 		if (local.kind !== "text" || disk?.text === void 0 || contentHash(local.text) === disk.hash) return;
 		if (disk.text.split(old).length !== 2 || disk.text.replace(old, () => replacement) !== local.text) return;
-		this.expected.set(path, {
-			hash: contentHash(local.text),
-			text: local.text
+		const edited = local.text;
+		const { hash, text } = disk;
+		const id = await this.enqueue((entries) => {
+			if (this.expected.get(path)?.hash !== hash || !this.onDisk(path, edited)) return null;
+			this.expected.set(path, {
+				hash: contentHash(edited),
+				text: edited
+			});
+			const start = this.versions(path, entries).find((v) => v.text === text) ?? {
+				text,
+				server: text
+			};
+			return {
+				...editOn(path, edited, start, hash),
+				replace: {
+					old,
+					new: replacement
+				}
+			};
 		});
-		const write = editOn(path, local.text, this.versions(path).find((v) => v.text === disk.text) ?? {
-			text: disk.text,
-			server: disk.text
-		}, disk.hash);
-		const request = {
-			protocol: 2,
-			op: "text.replace",
-			path,
-			old,
-			new: replacement
-		};
-		const id = entryId();
-		const firstSentSeq = this.hubSeq;
-		this.trace(`replace ${path} ${id}`);
-		this.inflight.set(path, (this.inflight.get(path) ?? 0) + 1);
-		this.awaitAnswer(path, local.text);
-		const queued = this.queuedIds();
-		try {
-			let response;
-			try {
-				response = await this.api.send({
-					...request,
-					requestId: id
-				});
-			} catch (error) {
-				if (!(error instanceof Unreachable)) throw error;
-				return await this.enqueue(write, {
-					queued,
-					...error.sent ? { sent: {
-						id,
-						firstSentSeq,
-						sent: request
-					} } : {}
-				});
-			}
-			await this.settleReplace(path, response, local.text);
-		} finally {
-			this.answeredDirect(path, local.text);
-		}
+		if (id !== null) return this.trace(`replace ${path} ${id}`);
+		this.trace(`replace ${path} changed before it was queued; reconciling it again`);
+		this.schedule(path);
 	}
-	/** What the server answered to an Edit replayed on its version (`writer` is the edited text). */
-	async settleReplace(path, response, writer) {
+	/** What the server answered to Edit `entry` replayed on its version (its text is the edited text). */
+	async settleReplace(entry, response) {
+		const { path, text: writer } = entry;
 		if (response.ok) {
 			const file = response.files.find((f) => f.path === path);
 			const result = file?.kind === "file" ? file.text : this.cloud.get(path) ?? writer;
-			if (typeof result === "string") this.remember(path, {
-				text: writer,
-				server: result
-			});
+			if (typeof result === "string") {
+				this.remember(path, {
+					text: writer,
+					server: result
+				});
+				this.confirmWritten(path, writer);
+			}
 			if (file) await this.delivery(path, response.seq);
 			return;
 		}
-		const saved = await this.saveConflict(path, writer);
-		this.problem({
+		await this.refuse(entry, [{
 			kind: "edit-rejected",
 			path,
-			saved,
-			message: `${path}: the Edit could not be replayed on the latest version (${response.message}); the edited text was saved to ${saved} and the file now has the latest version. Read it and edit again`
-		});
+			text: writer,
+			message: (saved) => `${path}: the Edit could not be replayed on the latest version (${response.message}); the edited text was saved to ${saved} and the file now has the latest version. Read it and edit again`
+		}]);
 		if ("files" in response && response.files.some((f) => f.path === path)) await this.delivery(path, response.seq);
 	}
 	async walk(dir = "") {
@@ -2271,52 +2849,69 @@ var SyncClient = class extends EventEmitter {
 		}
 		if (immediate) await Promise.allSettled(this.chains.values());
 	}
+	/**
+	* Watch the directories that may hold synced files, and local/sync/ for the outbox. The client's own files in the
+	* directories under local/sync/, such as the texts in known/ and the files it prepares in tmp/, are not watched.
+	*/
 	startWatcher() {
-		const timers = /* @__PURE__ */ new Map();
-		try {
-			this.watcher = watch(this.paths.data, { recursive: true }, (_event, name) => {
-				if (!name) return;
-				const path = String(name).split(sep).join("/");
-				if (path === OUTBOX) {
-					clearTimeout(timers.get(path));
-					timers.set(path, setTimeout(() => {
-						timers.delete(path);
-						this.outboxChanged();
-					}, SETTLE_MS));
-					return;
-				}
-				if (!isSynced(path)) return;
+		const timers = this.watchTimers;
+		const changed = (path) => {
+			if (path === OUTBOX) {
 				clearTimeout(timers.get(path));
 				timers.set(path, setTimeout(() => {
 					timers.delete(path);
-					this.track(this.whenSettled(path).then(() => this.schedule(path)));
+					this.outboxChanged();
 				}, SETTLE_MS));
+				return;
+			}
+			if (!isSynced(path)) return;
+			this.trace(`watched ${path}`);
+			clearTimeout(timers.get(path));
+			timers.set(path, setTimeout(() => {
+				timers.delete(path);
+				this.track(this.whenSettled(path).then(() => this.schedule(path)));
+			}, SETTLE_MS));
+		};
+		try {
+			this.watcher = watchTree(this.paths.data, {
+				include: watchedDir,
+				onChange: changed,
+				onError: (error, dir, stopped) => this.log(`file watcher of .mainflow/${dir === "" ? "" : `${dir}/`} ${stopped ? "stopped" : "could not start"}: ${error.message}; the rescan finds its changes`)
 			});
-			this.watcher.on("error", (error) => this.log(`file watcher stopped: ${error.message}; the rescan continues`));
 		} catch (error) {
 			this.log(`no file watcher (${error.message}); relying on the rescan`);
 		}
 	}
+	/** Resolve once two looks at the file SETTLE_POLL_MS apart find the same size and modification time, or after SETTLE_LIMIT_MS. */
 	async whenSettled(path) {
 		const file = join(this.paths.data, path);
 		let previous = "";
-		for (let i = 0; i < 20; i++) {
+		for (let i = 0; i < SETTLE_LIMIT_MS / SETTLE_POLL_MS; i++) {
 			const info = await stat(file).catch(() => null);
 			const signature = info ? `${info.mtimeMs}:${info.size}` : "absent";
 			if (signature === previous) return;
 			previous = signature;
-			await sleep$1(SETTLE_MS / 2);
+			await sleep$1(SETTLE_POLL_MS);
 		}
 	}
-	problem(problem) {
+	/**
+	* Tell the writer: notices.jsonl first, written before anything else, with the outbox entry the problem is about,
+	* which tells a later run what a refusal it finds was told of already (resumeRefusals).
+	*/
+	problem(problem, entry) {
+		try {
+			appendFileSync(this.paths.notices, `${JSON.stringify({
+				at: (/* @__PURE__ */ new Date()).toISOString(),
+				level: "warn",
+				...problem,
+				...entry === void 0 ? {} : { entry }
+			})}\n`);
+		} catch (error) {
+			this.log(`could not write local/sync/notices.jsonl: ${error.message}`);
+		}
 		this.problems.push(problem);
 		this.log(`! ${problem.message}`);
 		this.emit("problem", problem);
-		appendFile(this.paths.notices, `${JSON.stringify({
-			at: (/* @__PURE__ */ new Date()).toISOString(),
-			level: "warn",
-			...problem
-		})}\n`).catch(() => {});
 	}
 	/** Something worth recording that does not concern the writer, such as a merge that only added others' changes. */
 	info(path, message) {
@@ -2331,21 +2926,33 @@ var SyncClient = class extends EventEmitter {
 			message
 		})}\n`).catch(() => {});
 	}
-	async saveConflict(path, text) {
+	/** A new name under local/sync/conflicts/ for a text of `path`, relative to .mainflow/. */
+	conflictName(path) {
 		const name = `${path.split("/").join("__")}.${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.${Math.random().toString(36).slice(2, 6)}`;
-		await mkdir(this.paths.conflicts, { recursive: true });
-		await writeFile(join(this.paths.conflicts, name), text);
 		return relative(this.paths.data, join(this.paths.conflicts, name)).split(sep).join("/");
 	}
+	/** Save `text` as `saved`, relative to .mainflow/; a text saved there already is kept. */
+	async saveText(saved, text) {
+		await mkdir(this.paths.conflicts, { recursive: true });
+		await writeFile(join(this.paths.data, saved), text, { flag: "wx" }).catch((error) => {
+			if (error.code !== "EEXIST") throw error;
+		});
+	}
+	async saveConflict(path, text) {
+		const saved = this.conflictName(path);
+		await this.saveText(saved, text);
+		return saved;
+	}
 	saveKnown() {
 		if (this.knownTimer) return;
 		this.knownTimer = setTimeout(() => this.saveKnownNow(), 200);
 	}
-	saveKnownNow() {
+	saveKnownNow(final = false) {
+		if (this.abandoned && !final) return;
 		clearTimeout(this.knownTimer);
 		this.knownTimer = void 0;
 		const files = {};
-		for (const [path, disk] of this.expected) if (disk) files[path] = disk.hash;
+		for (const [path, disk] of this.confirmed) if (disk) files[path] = disk;
 		try {
 			underLock(this.root, () => writeKnown(this.root, files));
 		} catch (error) {
@@ -2459,6 +3066,10 @@ async function serveIpc(root, client) {
 		}
 		try {
 			if (req.url === "/wait") return reply(200, await client.outcome(String(body.id), typeof body.timeoutMs === "number" ? body.timeoutMs : 0));
+			if (req.url === "/send") {
+				reply(200, {});
+				return client.outboxChanged();
+			}
 			if (req.url === "/flush") {
 				const edit = body.edit;
 				return reply(200, edit ? await client.flushEdit(edit) : await client.flush());
@@ -2655,17 +3266,31 @@ function queueOperation(root, request) {
 		};
 	});
 }
-/** How many writes wait in the outbox, as queue.json says. */
+/** How many writes wait in the outbox for the server, as queue.json says: not the ones it refused (src/state.ts). */
 function queuedCount(root) {
 	const file = syncPaths(root).queue;
 	if (!existsSync(file)) return 0;
 	try {
-		return JSON.parse(readFileSync(file, "utf8")).entries?.length ?? 0;
+		return (JSON.parse(readFileSync(file, "utf8")).entries ?? []).filter(waiting).length;
 	} catch {
 		return 0;
 	}
 }
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** How long a writer waits for the sync client to take its notice; one that does not answer by then finds it anyway. */
+const NOTIFY_MS = 200;
+/**
+* Tell the hub's sync client that the outbox has a new entry, so it sends it now, for a writer that does not wait for
+* the server's answer, such as a hook or the interface. Without a sync client, or one that does not answer, nothing
+* happens: the client's watcher of queue.json and its rescan find the entry, a moment later.
+*/
+async function notifyQueued(root) {
+	const daemon = readDaemon(root);
+	if (!daemon) return;
+	try {
+		await callDaemon(daemon, "/send", {}, NOTIFY_MS);
+	} catch {}
+}
 /**
 * Ask the sync client what became of entry `id`, giving it up to `timeoutMs`. A sync client that is still starting is
 * waited for. `waiting` when it is offline, or the time ran out first.
@@ -2838,7 +3463,10 @@ function hubWriter(root, env = process.env, options = {}) {
 			...queued,
 			stopped: `mainflow sync is not running (${start.reason}); the write waits in .mainflow/local/sync/queue.json until it runs`
 		};
-		if (options.confirmMs === void 0) return queued;
+		if (options.confirmMs === void 0) {
+			await notifyQueued(root);
+			return queued;
+		}
 		const outcome = await awaitOutcome(root, id, options.confirmMs);
 		if (outcome.state === "applied") {
 			const { response } = outcome;