mainflow 0.28.0 → 0.29.0

package/dist/operation-Bp4U2bx3.js

@@ -0,0 +1,2862 @@
+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 { 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 { 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 { EventEmitter } from "node:events";
+import { appendFile, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { diff3Merge } from "node-diff3";
+//#region ../sync/dist/api.js
+/**
+* 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.
+*/
+var Unreachable = class extends Error {
+	sent;
+	constructor(message, sent) {
+		super(message);
+		this.sent = sent;
+	}
+};
+/** The server refused before the hub (401, 400, 404) or failed (500). */
+var ServerError = class extends Error {
+	status;
+	constructor(message, status) {
+		super(message);
+		this.status = status;
+	}
+};
+/** Error codes of a connection that never carried the request. */
+const NOT_SENT = /* @__PURE__ */ new Set([
+	"ECONNREFUSED",
+	"ENOTFOUND",
+	"EAI_AGAIN",
+	"EHOSTUNREACH",
+	"ENETUNREACH",
+	"UND_ERR_CONNECT_TIMEOUT",
+	"ECONNECT_TIMEOUT"
+]);
+/** Error codes of a pooled connection the server had already closed. */
+const STALE = /* @__PURE__ */ new Set([
+	"UND_ERR_SOCKET",
+	"ECONNRESET",
+	"EPIPE"
+]);
+const causeCode = (error) => {
+	for (let cause = error; cause; cause = cause.cause) if (typeof cause.code === "string") return cause.code;
+};
+var ServerApi = class {
+	settings;
+	timeoutMs;
+	constructor(settings, timeoutMs = 3e4) {
+		this.settings = settings;
+		this.timeoutMs = timeoutMs;
+	}
+	get headers() {
+		return {
+			[AUTHORIZATION]: `Bearer ${this.settings.token}`,
+			"content-type": "application/json"
+		};
+	}
+	async call(method, route, body) {
+		const url = `${this.settings.url}${route}`;
+		let answer;
+		try {
+			answer = method === "GET" ? await this.fetchGet(url) : await this.freshRequest(method, url, JSON.stringify(body));
+		} 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)));
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(answer.text);
+		} catch {
+			throw new Unreachable(`the sync server answered ${answer.status} without a readable body`, true);
+		}
+		if (answer.status >= 500) throw new Unreachable(`the sync server failed (${answer.status})`, true);
+		const refused = parsed;
+		if (answer.status === 401 || answer.status === 404 || refused.reason === "malformed") throw new ServerError(`the sync server refused: ${refused.message ?? answer.status}`, answer.status);
+		return {
+			status: answer.status,
+			body: parsed
+		};
+	}
+	/** A read may go on a pooled connection: one the server closed meanwhile fails at once, and the read is repeated. */
+	async fetchGet(url) {
+		for (let attempt = 0;; attempt++) try {
+			const response = await fetch(url, {
+				headers: this.headers,
+				signal: AbortSignal.timeout(this.timeoutMs)
+			});
+			return {
+				status: response.status,
+				text: await response.text()
+			};
+		} catch (error) {
+			if (attempt > 0 || !STALE.has(causeCode(error) ?? "")) throw error;
+		}
+	}
+	/**
+	* 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.
+	*/
+	freshRequest(method, url, body) {
+		const send = url.startsWith("https:") ? request$1 : request;
+		return new Promise((resolve, reject) => {
+			const req = send(url, {
+				method,
+				agent: false,
+				headers: {
+					...this.headers,
+					"content-length": Buffer.byteLength(body)
+				},
+				timeout: this.timeoutMs
+			}, (res) => {
+				const chunks = [];
+				res.on("data", (chunk) => chunks.push(chunk));
+				res.on("end", () => resolve({
+					status: res.statusCode ?? 0,
+					text: Buffer.concat(chunks).toString("utf8")
+				}));
+				res.on("error", reject);
+			});
+			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);
+		});
+	}
+	/** 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;
+	}
+	/** Every file of the hub, as of the hub's `seq`. */
+	async snapshot() {
+		const { body } = await this.call("GET", `${ROUTES.snapshot(this.settings.hub)}?protocol=2`);
+		if (!body.ok) throw new ServerError(`the sync server refused the snapshot: ${body.message}`, body.status);
+		return {
+			seq: body.seq,
+			files: body.files
+		};
+	}
+	/** Upload a whole hub; refused with 409 when the server already holds one and `replace` is not set. */
+	async upload(files, dirs, replace = false) {
+		const { body } = await this.call("PUT", ROUTES.snapshot(this.settings.hub), {
+			protocol: 2,
+			files,
+			dirs,
+			replace
+		});
+		return body;
+	}
+	/** Open the hub's broadcast connection. */
+	socket() {
+		const url = `${this.settings.url.replace(/^http/, "ws")}${ROUTES.socket(this.settings.hub)}?protocol=2`;
+		return new WebSocket(url, { headers: { [AUTHORIZATION]: `Bearer ${this.settings.token}` } });
+	}
+};
+//#endregion
+//#region ../sync/dist/lines.js
+const split = (text) => text.split("\n");
+/**
+* Which lines of `a` and of `b` belong to a longest common subsequence of the two, after the common prefix
+* and suffix, which always belong to it. `keptA[i]` is true when line i of a is in b, and likewise `keptB`.
+*/
+function alignLines(a, b) {
+	const keptA = Array.from({ length: a.length }, () => false);
+	const keptB = Array.from({ length: b.length }, () => false);
+	let start = 0;
+	while (start < a.length && start < b.length && a[start] === b[start]) {
+		keptA[start] = keptB[start] = true;
+		start++;
+	}
+	let endA = a.length;
+	let endB = b.length;
+	while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) keptA[--endA] = keptB[--endB] = true;
+	const n = endA - start;
+	const m = endB - start;
+	if (n === 0 || m === 0) return {
+		keptA,
+		keptB
+	};
+	const width = m + 1;
+	const lengths = new Uint32Array((n + 1) * width);
+	for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) lengths[i * width + j] = a[start + i] === b[start + j] ? lengths[(i + 1) * width + j + 1] + 1 : Math.max(lengths[(i + 1) * width + j], lengths[i * width + j + 1]);
+	for (let i = 0, j = 0; i < n && j < m;) if (a[start + i] === b[start + j]) {
+		keptA[start + i] = keptB[start + j] = true;
+		i++;
+		j++;
+	} else if (lengths[(i + 1) * width + j] >= lengths[i * width + j + 1]) i++;
+	else j++;
+	return {
+		keptA,
+		keptB
+	};
+}
+/** How many lines differ between two texts: the lines only in a plus the lines only in b. */
+function lineDistance(a, b) {
+	if (a === b) return 0;
+	const { keptA, keptB } = alignLines(split(a), split(b));
+	return keptA.filter((kept) => !kept).length + keptB.filter((kept) => !kept).length;
+}
+//#endregion
+//#region ../sync/dist/merge.js
+/**
+* Merge `incoming` into `current`, both descended from `base`. Where both sides only added lines at the same
+* place, both are kept, the current side first, as git's union merge does; any other overlap fails.
+*/
+function mergeThreeWay(current, base, incoming) {
+	const regions = diff3Merge(current.split("\n"), base.split("\n"), incoming.split("\n"), { excludeFalseConflicts: true });
+	const lines = [];
+	for (const region of regions) {
+		if (region.ok) {
+			lines.push(...region.ok);
+			continue;
+		}
+		const conflict = region.conflict;
+		if (conflict.o.length > 0) return { ok: false };
+		lines.push(...conflict.a, ...conflict.b);
+	}
+	return {
+		ok: true,
+		text: lines.join("\n")
+	};
+}
+//#endregion
+//#region ../sync/dist/paths.js
+/** The sync client's own directory, inside local/ so it is neither synced nor committed. */
+const SYNC_DIR = "local/sync";
+/** The settings a machine keeps instead of the environment variables: { url, token }. Never synced or committed. */
+const SETTINGS_FILE = "local/sync.json";
+const syncPaths = (root) => {
+	const data = join(root, DATA_DIR);
+	const own = join(data, SYNC_DIR);
+	return {
+		data,
+		own,
+		tmp: join(own, "tmp"),
+		conflicts: join(own, "conflicts"),
+		known: join(own, "known.json"),
+		queue: join(own, "queue.json"),
+		notices: join(own, "notices.jsonl"),
+		daemon: join(own, "daemon.json"),
+		/** The sync client a mainflow write last started in the background: { pid, at } */
+		started: join(own, "started.json"),
+		/** What a sync client started in the background prints */
+		log: join(own, "sync.log")
+	};
+};
+/** Names programs leave behind while writing: editor swap and backup files, temporary files, Finder's. */
+const TRANSIENT = [
+	/\.tmp$/,
+	/\.sw[a-p]$/,
+	/\.swx$/,
+	/~$/,
+	/^\.#/,
+	/^4913$/,
+	/\.crswap$/,
+	/^\.DS_Store$/
+];
+/** Whether a file at `path` (relative to .mainflow/) is synced. */
+function isSynced(path) {
+	const parts = path.split("/");
+	if (parts.some((part) => part === "" || part === "." || part === "..")) return false;
+	if (parts[0] === "local" && !(parts[1] === "sessions" && parts.length === 3)) return false;
+	const name = parts.at(-1);
+	return !TRANSIENT.some((pattern) => pattern.test(name));
+}
+/** 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;
+//#endregion
+//#region ../sync/dist/state.js
+/** A new entry's id. */
+const entryId = () => randomBytes(8).toString("hex");
+const entryPaths = (entry) => entry.kind === "op" ? Object.keys(entry.written) : [entry.path];
+/** A local minute without an offset, the `now` of protocol 1 */
+const LOCAL_MINUTE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})$/;
+/**
+* A queued operation on the current protocol. One a command of mainflow before the upgrade queued is sent on the
+* current one: protocol 1 differs only in `now`, a minute in this machine's time zone without its offset, which gets
+* the offset this machine has at that minute. The outbox is this machine's, so the time zone is the one it was
+* written in. Any other protocol is sent as it is, and a server on another version refuses it with both versions.
+*
+* 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
+* hour a spring change skips would move an hour forward, but a local clock never shows one, so none is queued.
+*/
+function currentRequest(request) {
+	if (request.protocol !== 1) return request;
+	const local = LOCAL_MINUTE.exec(request.now);
+	const now = local ? requestTime(new Date(Number(local[1]), Number(local[2]) - 1, Number(local[3]), Number(local[4]), Number(local[5]))) : request.now;
+	return {
+		...request,
+		protocol: 2,
+		now
+	};
+}
+function readJson(file, fallback) {
+	if (!existsSync(file)) return fallback;
+	try {
+		return JSON.parse(readFileSync(file, "utf8"));
+	} catch {
+		return fallback;
+	}
+}
+function writeJson(file, value) {
+	mkdirSync(dirname(file), { recursive: true });
+	const temp = `${file}.${process.pid}.tmp`;
+	writeFileSync(temp, JSON.stringify(value, null, 1));
+	renameSync(temp, file);
+}
+const readKnown = (root) => readJson(syncPaths(root).known, {}).files ?? {};
+const writeKnown = (root, files) => writeJson(syncPaths(root).known, { files });
+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) {
+	const entries = readJson(syncPaths(root).queue, {}).entries ?? [];
+	if (entries.every((entry) => typeof entry.id === "string")) return entries;
+	const named = entries.map((entry) => ({
+		...entry,
+		id: entry.id ?? entryId()
+	}));
+	writeQueue(root, named);
+	return named;
+}
+/** Run `fn` under the hub's write lock, the one every mainflow writer of this machine takes. */
+const underLock = (root, fn) => nodeStorage(root).lock(fn);
+//#endregion
+//#region ../sync/dist/swap-helper.js
+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. */
+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() {
+	const here = dirname(fileURLToPath(import.meta.url));
+	return [
+		join(here, "native"),
+		join(here, "../dist/native"),
+		join(here, "../native")
+	];
+}
+const works = (file) => {
+	try {
+		return execFileSync(file, ["--version"], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			timeout: 5e3
+		}).trim() === HELPER_PROTOCOL;
+	} catch {
+		return false;
+	}
+};
+const cacheDir = () => join(process.env.XDG_CACHE_HOME || join(homedir(), ".cache"), "mainflow");
+/** Compile the shipped source into the cache directory; null when there is no source or no working compiler. */
+function compile(source) {
+	const text = readFileSync(source);
+	const target = join(cacheDir(), `${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`;
+	try {
+		execFileSync(process.env.CC ?? "cc", [
+			"-O2",
+			"-o",
+			temp,
+			source
+		], {
+			stdio: "ignore",
+			timeout: 6e4
+		});
+		renameSync(temp, target);
+		return works(target) ? target : null;
+	} catch {
+		rmSync(temp, { force: true });
+		return null;
+	}
+}
+/** Find a working helper for this machine; see the top of this file for the order. */
+function findHelper(env = process.env) {
+	if (process.platform !== "darwin" && process.platform !== "linux") return {
+		path: null,
+		source: "none"
+	};
+	const fromEnv = env.MAINFLOW_SWAP_HELPER;
+	if (fromEnv) return works(fromEnv) ? {
+		path: fromEnv,
+		source: "env"
+	} : {
+		path: null,
+		source: "none"
+	};
+	const names = [prebuiltName(process.platform, process.arch), prebuiltName(process.platform, "universal")];
+	for (const dir of nativeDirs()) for (const name of names) {
+		const file = join(dir, name);
+		if (existsSync(file) && works(file)) return {
+			path: file,
+			source: "prebuilt"
+		};
+	}
+	for (const dir of nativeDirs()) {
+		const source = join(dir, HELPER_SOURCE);
+		if (!existsSync(source)) continue;
+		const compiled = compile(source);
+		if (compiled) return {
+			path: compiled,
+			source: "compiled"
+		};
+	}
+	return {
+		path: null,
+		source: "none"
+	};
+}
+//#endregion
+//#region ../sync/dist/swap.js
+/** The helper, run once per exchange. */
+var SwapHelper = class {
+	path;
+	constructor(path) {
+		this.path = path;
+	}
+	/** Exchange two existing paths; throws on an answer other than ok, missing or unsupported. */
+	swap(a, b) {
+		if (/[\t\n]/.test(a + b)) throw new Error("a path with a tab or a line break cannot be sent to the swap helper");
+		const run = spawnSync(this.path, [], {
+			input: `${a}\t${b}\n`,
+			encoding: "utf8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"ignore"
+			],
+			timeout: 5e3
+		});
+		if (run.error) throw run.error;
+		const answer = run.stdout.split("\n")[0] ?? "";
+		if (answer === "ok" || answer === "missing" || answer === "unsupported") return answer;
+		throw new Error(answer || `the swap helper exited with ${run.status}`);
+	}
+};
+/**
+* Find the helper and check that it really exchanges in `dir`, the directory the client prepares files in, on
+* the hub's own file system: some file systems refuse the exchange, and a FUSE file system may ignore the flag and
+* overwrite instead, which would look like success.
+*/
+function startSwapper(dir, env = process.env) {
+	const lookup = findHelper(env);
+	if (!lookup.path) return {
+		helper: null,
+		lookup,
+		reason: `no atomic exchange helper for ${process.platform}-${process.arch}: none is shipped and none could be compiled`
+	};
+	const helper = new SwapHelper(lookup.path);
+	const a = join(dir, `swap-test-${process.pid}-a`);
+	const b = join(dir, `swap-test-${process.pid}-b`);
+	try {
+		writeFileSync(a, "a");
+		writeFileSync(b, "b");
+		const answer = helper.swap(a, b);
+		if (answer === "ok" && readFileSync(a, "utf8") === "b" && readFileSync(b, "utf8") === "a") return {
+			helper,
+			lookup
+		};
+		return {
+			helper: null,
+			lookup,
+			reason: `the file system of ${dir} does not exchange files atomically (the helper answered ${answer})`
+		};
+	} catch (error) {
+		return {
+			helper: null,
+			lookup,
+			reason: `the atomic exchange helper failed its check: ${error.message}`
+		};
+	} finally {
+		rmSync(a, { force: true });
+		rmSync(b, { force: true });
+	}
+}
+//#endregion
+//#region ../sync/dist/client.js
+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;
+/**
+* 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
+*/
+const STALLED_SNAPSHOTS = 4;
+/** How long after a read that is not UTF-8 the file is read again before it counts as binary */
+const BINARY_RECHECK_MS = 150;
+/**
+* How long after a file that held text reads empty it is read again before the empty file counts as written: a
+* program that rewrites a file as `cat >` does empties it first and fills it a moment later
+*/
+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;
+/** 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));
+const decoder = new TextDecoder("utf-8", { fatal: true });
+const sameLocal = (a, b) => a.kind === b.kind && (a.kind !== "text" || a.text === b.text) && (a.kind !== "binary" || a.hash === b.hash);
+/**
+* The queued edit of `path` to the writer's `text` that started from `start` (src/state.ts): on the server's version
+* that holds a confirmed start, waiting for an unconfirmed one, or, without a start, on `base`, the hash of the version
+* last on disk, null for a new file. `replaced`, what the file held before, is kept when the writer wrote its start
+* back unchanged, for layer 2.
+*/
+function editOn(path, text, start, base, replaced) {
+	if (!start) return {
+		kind: "patch",
+		path,
+		text,
+		base
+	};
+	const undone = start.text === text && replaced !== void 0 && replaced !== text ? { replaced } : {};
+	if (start.server === void 0) return {
+		kind: "patch",
+		path,
+		text,
+		base: null,
+		baseText: start.text,
+		...undone
+	};
+	return {
+		kind: "patch",
+		path,
+		text,
+		base: contentHash(start.server),
+		baseText: start.text,
+		...start.server === start.text ? {} : { serverBase: start.server },
+		...undone
+	};
+}
+/** The confirmed version a queued edit's base is, when its base is known: its baseText and the server's text of `base`. */
+function heldBase(entry) {
+	if (entry.base === null || entry.baseText === void 0) return void 0;
+	const server = entry.serverBase ?? entry.baseText;
+	return contentHash(server) === entry.base ? {
+		text: entry.baseText,
+		server
+	} : 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.
+*/
+function patchRequest(entry) {
+	if (entry.base === null && entry.baseText !== void 0) return "unresolved";
+	let text = entry.text;
+	if (entry.serverBase !== void 0 && entry.baseText !== void 0) {
+		const merged = mergeThreeWay(entry.serverBase, entry.baseText, entry.text);
+		if (!merged.ok) return "overlap";
+		text = merged.text;
+	}
+	return {
+		protocol: 2,
+		op: "file.patch",
+		path: entry.path,
+		base: entry.base,
+		text
+	};
+}
+var SyncClient = class extends EventEmitter {
+	opts;
+	root;
+	paths;
+	api;
+	problems = [];
+	reported = 0;
+	expected = /* @__PURE__ */ new Map();
+	/** 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();
+	/** The hub's seq up to which the client has taken in every change: the last snapshot and the broadcasts after it */
+	hubSeq = -1;
+	/** The seqs of the broadcasts on the current connection above hubSeq with a change between that never arrived */
+	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();
+	signatures = /* @__PURE__ */ new Map();
+	/** The outbox as last read from queue.json, which every writer of this machine appends to */
+	queue = [];
+	/** What the server answered for the operations this run sent, by outbox id, for writers that wait */
+	outcomes = /* @__PURE__ */ new Map();
+	/** Outbox entries the server answered that are not out of the outbox yet; they are never sent again */
+	answered = /* @__PURE__ */ new Set();
+	/** The ids the server renumbered for an answered operation, given to the files when it leaves the outbox */
+	renumbering = /* @__PURE__ */ new Map();
+	/** The outbox entry on its way to the server */
+	sending = null;
+	ws = null;
+	connected = false;
+	stopped = false;
+	flushing = false;
+	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;
+	rescanTimer;
+	queueTimer;
+	watcher;
+	swapper = null;
+	/** Settles once the first connection attempt synced or failed */
+	firstContact;
+	backoff = 500;
+	lastPong = 0;
+	knownTimer;
+	constructor(opts) {
+		super();
+		this.opts = opts;
+		this.root = opts.root;
+		this.paths = syncPaths(opts.root);
+		this.api = new ServerApi(opts.settings);
+		this.firstContact = new Promise((resolve) => {
+			this.once("synced", resolve);
+			this.once("offline", resolve);
+		});
+	}
+	trace(line) {
+		this.opts.trace?.(line);
+	}
+	log(line) {
+		this.opts.log?.(line);
+		this.emit("log", line);
+	}
+	get online() {
+		return this.connected && !this.stopped;
+	}
+	get queued() {
+		return this.queue.length;
+	}
+	/** Whether the local files have every change the server has: online, with the snapshot taken and not being retaken. */
+	get caughtUp() {
+		return this.online && this.synced && this.resyncing === null;
+	}
+	/** Whether files are written with the atomic exchange. */
+	get swapping() {
+		return this.swapper !== null;
+	}
+	/**
+	* The file at `path` as the server last had it to this client's knowledge: its text, null when the server has no such
+	* file, or undefined when the client has not heard of it, such as before the first snapshot.
+	*/
+	serverText(path) {
+		return this.cloud.has(path) ? this.cloud.get(path) : this.synced ? null : void 0;
+	}
+	/** Start: restore what the last run left, watch the files, connect, and resolve once synced or found offline. */
+	async start() {
+		await mkdir(this.paths.tmp, { recursive: true });
+		await mkdir(this.paths.conflicts, { recursive: true });
+		if (this.opts.swap !== false) {
+			const swapper = startSwapper(this.paths.tmp);
+			this.swapper = swapper.helper;
+			if (swapper.helper) this.log(`atomic exchange: ${swapper.lookup.source} helper ${swapper.lookup.path}`);
+			else {
+				this.log(`atomic exchange unavailable, writing with a rename: ${swapper.reason}`);
+				this.info("", `atomic exchange unavailable, writing with a rename: ${swapper.reason}`);
+			}
+		}
+		await this.restoreKnown();
+		await this.whenFree(() => this.syncQueue());
+		if (this.opts.watch !== false) this.startWatcher();
+		await this.scan(true, true);
+		const every = this.opts.rescanMs ?? 2e3;
+		if (every > 0) this.rescanTimer = setInterval(() => void this.scan(false).then(() => this.outboxChanged()).catch((error) => this.log(`rescan failed: ${String(error)}`)), every);
+		this.connect();
+		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.
+	*/
+	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 });
+		}
+	}
+	async stop() {
+		this.stopped = true;
+		clearTimeout(this.reconnectTimer);
+		clearInterval(this.pingTimer);
+		clearInterval(this.rescanTimer);
+		clearTimeout(this.queueTimer);
+		this.watcher?.close();
+		this.ws?.close();
+		await Promise.allSettled(this.chains.values());
+		this.saveKnownNow();
+	}
+	/** Test hook: drop the connection as a lost network would, and stay offline until reconnect(). */
+	disconnect() {
+		clearTimeout(this.reconnectTimer);
+		this.stopped = true;
+		this.ws?.close();
+		this.markOffline();
+	}
+	/** Test hook: the network is back. */
+	async reconnect() {
+		this.stopped = false;
+		await new Promise((resolve) => {
+			this.once("synced", resolve);
+			this.once("offline", resolve);
+			this.connect();
+		});
+	}
+	/** Resolve once nothing is being sent, applied or waited for, and the queue is empty or cannot be sent. */
+	async idle(timeoutMs = 3e4) {
+		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 (Date.now() > deadline) return false;
+			await (this.work.size > 0 ? Promise.race([Promise.allSettled(this.work), sleep$1(50)]) : sleep$1(50));
+		}
+	}
+	connect() {
+		if (this.stopped) return;
+		const ws = this.api.socket();
+		this.ws = ws;
+		this.ahead.clear();
+		let opened = false;
+		ws.addEventListener("open", () => {
+			opened = true;
+			this.diagnosed = false;
+			this.connected = true;
+			this.backoff = 500;
+			this.lastPong = Date.now();
+			clearInterval(this.pingTimer);
+			this.pingTimer = setInterval(() => this.ping(ws), 15e3);
+			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();
+			}));
+		});
+		ws.addEventListener("message", (event) => {
+			if (this.ws === ws) this.onMessage(String(event.data));
+		});
+		const lost = () => {
+			if (this.ws !== ws) return;
+			this.ws = null;
+			if (opened) this.log("connection lost");
+			else if (!this.diagnosed) this.diagnose();
+			this.markOffline();
+			if (this.stopped) return;
+			this.reconnectTimer = setTimeout(() => this.connect(), this.backoff * (.5 + Math.random()));
+			this.backoff = Math.min(this.backoff * 2, 1e4);
+		};
+		ws.addEventListener("close", lost);
+		ws.addEventListener("error", lost);
+	}
+	diagnosed = false;
+	/** A connection refused before it opened says nothing about why; one plain request tells a wrong token apart. */
+	diagnose() {
+		this.diagnosed = true;
+		this.api.snapshot().then(() => this.log("the WebSocket was refused although the server answers; retrying"), (error) => this.log(`cannot connect: ${error.message}; retrying`));
+	}
+	markOffline() {
+		const was = this.connected;
+		this.connected = false;
+		clearInterval(this.pingTimer);
+		for (const waiter of this.waiters) waiter.done();
+		this.waiters.clear();
+		if (was) this.log("offline");
+		this.emit("offline");
+	}
+	/** A connection that stops answering pings is dead even when no close arrives, as after a server restart. */
+	ping(ws) {
+		if (Date.now() - this.lastPong > 4e4) {
+			this.log("no answer to pings; reconnecting");
+			ws.close();
+			if (this.ws === ws) {
+				this.ws = null;
+				this.markOffline();
+				this.reconnectTimer = setTimeout(() => this.connect(), 500);
+			}
+			return;
+		}
+		try {
+			ws.send("ping");
+		} catch {}
+	}
+	onMessage(data) {
+		if (data === "pong") {
+			this.lastPong = Date.now();
+			return;
+		}
+		this.lastPong = Date.now();
+		let message;
+		try {
+			message = JSON.parse(data);
+		} catch {
+			return;
+		}
+		if (!Number.isInteger(message.seq)) return;
+		const seq = message.seq;
+		if (seq === this.hubSeq + 1) this.takenUpTo(seq);
+		else if (seq > this.hubSeq + 1) this.ahead.add(seq);
+		if ("reload" in message && message.reload) {
+			this.track(this.resync());
+			return;
+		}
+		if (this.ahead.size > 0 && this.synced && this.resyncing === null) {
+			this.log(`missed the hub's changes ${this.hubSeq + 1} to ${Math.min(...this.ahead) - 1}; reloading the snapshot`);
+			this.track(this.resync());
+		}
+		for (const event of message.files) this.receive(event, seq);
+		this.wake();
+	}
+	/** The client has every change up to `seq`: hubSeq moves there, and on over the broadcasts that came after it in a row. */
+	takenUpTo(seq) {
+		this.hubSeq = Math.max(this.hubSeq, seq);
+		for (const held of this.ahead) if (held <= this.hubSeq) this.ahead.delete(held);
+		while (this.ahead.delete(this.hubSeq + 1)) this.hubSeq++;
+	}
+	/**
+	* One file as the server has it as of the hub's `seq`, from a broadcast or a snapshot. A version no newer than the
+	* one the client holds, such as a broadcast that arrives after a later snapshot, is left out.
+	*/
+	receive(event, seq) {
+		if (event.kind === "dir") {
+			if (event.path.split("/")[0] !== "local" || event.path === "local/sessions") this.track(mkdir(join(this.paths.data, event.path), { recursive: true }));
+			return;
+		}
+		if (!isSynced(event.path)) return;
+		const text = event.kind === "file" ? event.text : null;
+		const held = this.fileSeq.get(event.path) ?? -1;
+		if (seq <= held) {
+			this.trace(`older ${event.path} ${short(text)} seq ${seq}, holding seq ${held}`);
+			return;
+		}
+		this.trace(`receive ${event.path} ${short(text)} seq ${seq}`);
+		this.fileSeq.set(event.path, seq);
+		this.cloud.set(event.path, text);
+		this.schedule(event.path);
+	}
+	/** Whether the client holds `path` as of the hub's `seq` or later. */
+	reached(path, seq) {
+		return this.hubSeq >= seq || (this.fileSeq.get(path) ?? -1) >= seq;
+	}
+	/** Release the waiters whose seq the client has reached. */
+	wake() {
+		for (const waiter of this.waiters) {
+			if (!this.reached(waiter.path, waiter.seq)) continue;
+			this.waiters.delete(waiter);
+			waiter.done();
+		}
+	}
+	/**
+	* Wait until the client holds `path` as of the hub's `seq`, the seq of a response about it: the server broadcasts
+	* before it responds, but on the other connection, so the broadcast may still be on its way. Without a connection,
+	* or after 10 s, the snapshot settles it instead.
+	*/
+	async delivery(path, seq) {
+		if (this.reached(path, seq)) return;
+		if (!this.online) return;
+		let done;
+		const arrived = new Promise((resolve) => done = resolve);
+		const waiter = {
+			path,
+			seq,
+			done
+		};
+		this.waiters.add(waiter);
+		const timer = setTimeout(() => {
+			this.waiters.delete(waiter);
+			this.log(`no broadcast of ${path} after its response; reloading the snapshot`);
+			this.resync().catch(() => {}).finally(done);
+		}, 1e4);
+		await arrived;
+		clearTimeout(timer);
+	}
+	/**
+	* Take the server's whole hub and reconcile every path; a request made while one runs runs once more after it. So
+	* does a change still missing among the broadcasts once the snapshot is in, including ones that came while it was
+	* 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.
+	*/
+	resync() {
+		if (this.resyncing) {
+			this.resyncAgain = true;
+			return this.resyncing;
+		}
+		this.resyncing = (async () => {
+			try {
+				let stalled = 0;
+				do {
+					this.resyncAgain = false;
+					const held = this.hubSeq;
+					await this.takeSnapshot();
+					if (this.ahead.size === 0) continue;
+					stalled = this.hubSeq > held ? 0 : stalled + 1;
+					const missing = `${this.hubSeq + 1} to ${Math.min(...this.ahead) - 1}`;
+					if (stalled >= STALLED_SNAPSHOTS) {
+						this.log(`the sync server's snapshot stays without the hub's changes ${missing}; taking it as complete`);
+						this.ahead.clear();
+						for (const [path, seq] of this.fileSeq) if (seq > this.hubSeq) this.fileSeq.delete(path);
+						stalled = 0;
+						this.resyncAgain = true;
+						continue;
+					}
+					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);
+			} finally {
+				this.resyncing = null;
+				if (this.connected && this.queue.length > 0) this.track(this.flushQueue());
+			}
+		})();
+		return this.resyncing;
+	}
+	/**
+	* Take the hub as of the snapshot's seq. A broadcast arriving meanwhile may be older or newer than the snapshot; each
+	* file keeps whichever version has the higher seq. A server without the hub first gets the local one.
+	*/
+	async takeSnapshot() {
+		let snapshot;
+		let before;
+		for (let upload = 0;; upload++) {
+			before = this.hubSeq;
+			snapshot = await this.api.snapshot();
+			if (upload > 0 || snapshot.files.some((event) => event.kind === "file") || !await this.uploadIfEmpty()) break;
+		}
+		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`);
+			this.fileSeq.clear();
+			this.hubSeq = -1;
+			this.ahead.clear();
+		}
+		const present = /* @__PURE__ */ new Set();
+		for (const event of files) {
+			if (event.kind === "file") present.add(event.path);
+			this.receive(event, seq);
+		}
+		for (const path of /* @__PURE__ */ new Set([...this.cloud.keys(), ...this.expected.keys()])) if (!present.has(path) && isSynced(path)) this.receive({
+			kind: "removed",
+			path
+		}, seq);
+		this.takenUpTo(seq);
+		this.synced = true;
+		await this.settleUnsynced();
+		this.wake();
+		for (const path of await this.walk()) this.schedule(path);
+	}
+	/**
+	* A server without the hub gets the local one; true when it was uploaded and a reload follows. The local files
+	* already hold what the outbox's operations did, which the server does when they are sent, so a file an operation
+	* changed is uploaded as it was before the first one that did (d017).
+	*/
+	async uploadIfEmpty() {
+		const files = {};
+		const outbox = /* @__PURE__ */ new Map();
+		for (const entry of await this.whenFree(() => this.syncQueue())) {
+			if (entry.kind !== "op") continue;
+			for (const [path, before] of Object.entries(entry.before ?? {})) if (!outbox.has(path)) outbox.set(path, before);
+		}
+		for (const path of /* @__PURE__ */ new Set([...await this.walk(), ...outbox.keys()])) {
+			if (outbox.has(path)) {
+				const before = outbox.get(path);
+				if (typeof before === "string") files[path] = before;
+				continue;
+			}
+			const local = await this.readLocal(path);
+			if (local.kind === "text") files[path] = local.text;
+		}
+		if (Object.keys(files).length === 0) return false;
+		const dirs = await this.walkDirs();
+		const result = await this.api.upload(files, dirs);
+		if (!result.ok) {
+			this.log(`upload refused: ${result.message}`);
+			return false;
+		}
+		this.log(`uploaded the hub: ${result.files} files`);
+		return true;
+	}
+	/** Reconcile `path` after whatever earlier work on it has finished. */
+	schedule(path) {
+		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(() => {
+			if (this.chains.get(path) === next) this.chains.delete(path);
+		});
+	}
+	track(promise) {
+		this.work.add(promise);
+		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));
+	}
+	async readLocal(path) {
+		let bytes;
+		try {
+			bytes = await readFile(join(this.paths.data, path));
+		} catch (error) {
+			const code = error.code;
+			if (code === "ENOENT" || code === "ENOTDIR" || code === "EISDIR") return { kind: "absent" };
+			throw error;
+		}
+		try {
+			return {
+				kind: "text",
+				text: decoder.decode(bytes)
+			};
+		} catch {
+			return {
+				kind: "binary",
+				hash: contentHash(bytes.toString("latin1"))
+			};
+		}
+	}
+	/**
+	* 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.
+	*/
+	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);
+			const again = await this.readLocal(path);
+			if (again.kind !== "binary" || again.hash !== local.hash) return this.schedule(path);
+			return this.skipBinary(path, local.hash);
+		}
+		const seen = this.expected.get(path);
+		if (seen === void 0 ? local.kind !== "absent" : !this.matches(seen, local)) {
+			await this.whenFree(() => this.syncQueue());
+			const now = await this.readLocal(path);
+			if (!sameLocal(now, local)) return this.schedule(path);
+			const after = this.expected.get(path);
+			if (after !== seen && after !== void 0 && this.matches(after, local)) return this.schedule(path);
+		}
+		const target = this.cloud.has(path) ? this.cloud.get(path) : this.synced ? null : void 0;
+		const disk = this.expected.get(path);
+		if (disk === void 0) {
+			if (local.kind === "absent") {
+				if (typeof target === "string") await this.replace(path, target);
+				return;
+			}
+			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 : {
+				text: local.text,
+				server: local.text
+			} });
+		}
+		if (!this.matches(disk, local)) {
+			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);
+			}
+			if (target === null || disk === null) return this.forget(path);
+			return this.sendRemove(path, disk.hash);
+		}
+		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;
+		}
+		await this.replace(path, target);
+	}
+	matches(disk, local) {
+		if (disk === null) return local.kind === "absent";
+		return local.kind === "text" && disk.hash === contentHash(local.text);
+	}
+	adopt(path, text) {
+		this.expected.set(path, {
+			hash: contentHash(text),
+			text
+		});
+		this.remember(path, {
+			text,
+			server: text
+		});
+		this.saveKnown();
+	}
+	/** 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);
+		this.saveKnown();
+	}
+	/** 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);
+		list.push(version);
+		if (list.length > HISTORY) list.shift();
+		this.history.set(path, list);
+	}
+	skipBinary(path, hash) {
+		const key = `${path}:${hash}`;
+		if (this.binaries.has(key)) return;
+		this.binaries.add(key);
+		this.problem({
+			kind: "skipped-binary",
+			path,
+			message: `${path} is not UTF-8 text, so it is not synced and not overwritten; other environments do not see it`
+		});
+	}
+	tempName() {
+		return join(this.paths.tmp, `${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2)}`);
+	}
+	/**
+	* Put the server's version of `path` on disk. An existing file is exchanged with the prepared one in one step,
+	* so whatever a local program wrote just before ends up in the prepared path and is sent, not lost; it is read
+	* again shortly after, for a program that still held the old file open. A new file is linked into place, which
+	* fails rather than overwrite a file created meanwhile; a removed file is first moved aside and checked.
+	*/
+	async replace(path, target) {
+		const file = join(this.paths.data, path);
+		const temp = this.tempName();
+		this.trace(`replacing ${path} with ${short(target)}`);
+		if (target !== null) {
+			await mkdir(dirname(file), { recursive: true });
+			await writeFile(temp, target);
+		}
+		let step;
+		try {
+			step = await this.whenFree(() => underLock(this.root, () => 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 === "removed") {
+			if (step.moved !== null && step.disk && contentHash(step.moved) !== step.disk.hash) {
+				const saved = await this.saveConflict(path, step.moved);
+				this.problem({
+					kind: "conflict",
+					path,
+					saved,
+					message: `${path} was removed by another environment while it was being written here; the text written here was saved to ${saved}`
+				});
+			}
+			return;
+		}
+		const { displaced, swapped, from } = step;
+		this.trace(`wrote ${path} ${short(target)}${swapped ? " (exchanged)" : ""}; displaced ${short(displaced)}`);
+		const changed = displaced !== null && contentHash(displaced) !== from.over.hash;
+		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 });
+		}
+		if (swapped) this.track(this.recheck(path, temp, later ? null : displaced, from));
+		else await rm(temp, { force: true });
+	}
+	/**
+	* 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).
+	*/
+	replaceHeld(path, file, temp, target) {
+		this.editHeld();
+		const disk = this.expected.get(path);
+		const read = (at) => {
+			try {
+				return readFileSync(at, "utf8");
+			} catch {
+				return null;
+			}
+		};
+		if (target === null) {
+			try {
+				renameSync(file, temp);
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+			}
+			this.forget(path);
+			const moved = read(temp);
+			rmSync(temp, { force: true });
+			return {
+				kind: "removed",
+				moved,
+				disk
+			};
+		}
+		if (!disk) {
+			try {
+				linkSync(temp, file);
+			} catch (error) {
+				rmSync(temp, { force: true });
+				if (error.code !== "EEXIST") throw error;
+				return { kind: "exists" };
+			}
+			rmSync(temp, { force: true });
+			this.wrote(path, target);
+			return { kind: "linked" };
+		}
+		let displaced = null;
+		let swapped = false;
+		let hooked = false;
+		if (this.swapper) {
+			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";
+			}
+			if (answer === "missing") {
+				rmSync(temp, { force: true });
+				return { kind: "missing" };
+			}
+			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) {
+			displaced = read(file);
+			if (!hooked) this.opts.beforeReplace?.(file);
+			renameSync(temp, file);
+		}
+		const among = new Set(this.versions(path).map((v) => v.text));
+		this.wrote(path, target);
+		return {
+			kind: "written",
+			displaced,
+			swapped,
+			from: {
+				over: disk,
+				among
+			}
+		};
+	}
+	/**
+	* A program that held the old file open may write into it after the exchange; what it wrote is sent. `taken` is the
+	* displaced text replace sent or found unchanged; null when it sent nothing, as for an empty file, which is read
+	* again only after EMPTY_RECHECK_MS and sent as it is then, empty too. The old file held `taken`, so what was written
+	* into it later may be based on it; the server's versions written since the exchange stay out.
+	*/
+	async recheck(path, temp, taken, from) {
+		await sleep$1(taken === null ? EMPTY_RECHECK_MS : LATE_WRITE_MS);
+		const later = await readFile(temp, "utf8").catch(() => null);
+		await rm(temp, { force: true });
+		if (later !== null && later !== taken && contentHash(later) !== from.over.hash) {
+			this.log(`${path}: a late write into the replaced file; sending it`);
+			const held = taken === null ? from : {
+				...from,
+				among: /* @__PURE__ */ new Set([...from.among, taken])
+			};
+			await this.withChain(path, () => this.sendLocal(path, later, { displaced: held }));
+		}
+	}
+	withChain(path, fn) {
+		const next = (this.chains.get(path) ?? Promise.resolve()).then(fn).catch((error) => this.log(`${path}: ${String(error)}`));
+		this.chains.set(path, next);
+		return this.track(next);
+	}
+	wrote(path, text) {
+		this.expected.set(path, {
+			hash: contentHash(text),
+			text
+		});
+		this.remember(path, {
+			text,
+			server: text
+		});
+		this.saveKnown();
+	}
+	/**
+	* 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.
+	*/
+	versions(path, entries = this.queue, upto = entries.length) {
+		const out = /* @__PURE__ */ new Map();
+		for (const version of this.history.get(path) ?? []) out.set(version.text, version);
+		const ahead = entries.slice(0, upto);
+		for (const entry of ahead) {
+			const held = entry.kind === "patch" && entry.path === path ? heldBase(entry) : void 0;
+			if (held && !out.has(held.text)) out.set(held.text, held);
+		}
+		for (const entry of ahead) {
+			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()];
+	}
+	/**
+	* Layer 1: the version `text` most likely started from, among versions() up to `upto` and, when given, in `among`:
+	* the one with the fewest differing lines, the newest on a tie; undefined when there is none.
+	*/
+	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;
+	}
+	/**
+	* 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.
+	*/
+	async sendLocal(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, {
+				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}`
+			});
+		}
+		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);
+		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) {
+		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 (file) await this.delivery(path, response.seq);
+			return;
+		}
+		const saved = await this.saveConflict(path, context.writer);
+		if (response.reason === "conflict") this.problem({
+			kind: "conflict",
+			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}`
+		});
+		if ("files" in response && response.files.some((f) => f.path === path)) await this.delivery(path, response.seq);
+	}
+	/**
+	* Layer 2. Report only when the writer's own content may be lost: lines it added that the result lacks, or lines
+	* it removed that the result still has. A writer that rewrote an older version unchanged, while the disk had
+	* other environments' additions, is taken as deleting those additions, which were kept. A result that only adds
+	* other environments' changes to the writer's text is information.
+	*/
+	classify(path, context, result) {
+		const { writer, base, last } = context;
+		if (result === writer) return;
+		const w = writer.split("\n");
+		const r = result.split("\n");
+		const inResult = alignLines(w, r).keptA;
+		if (base === void 0) {
+			const lost = w.filter((line, i) => !inResult[i] && line.trim() !== "");
+			if (lost.length) return this.problem({
+				kind: "merge-lost",
+				path,
+				message: `${path}: the merged file lacks ${lost.length} line(s) of the text written here, such as "${lost[0]}"; read it and redo what is missing`
+			});
+			return this.info(path, "merged with changes from other environments");
+		}
+		const b = base.split("\n");
+		const own = alignLines(b, w);
+		const added = w.filter((line, i) => !own.keptB[i] && !inResult[i] && line.trim() !== "");
+		if (added.length) return this.problem({
+			kind: "merge-lost",
+			path,
+			message: `${path}: the merged file lacks ${added.length} line(s) of the text written here, such as "${added[0]}"; read it and redo what is missing`
+		});
+		const baseInResult = alignLines(b, r).keptA;
+		const undone = b.filter((line, i) => !own.keptA[i] && baseInResult[i] && line.trim() !== "");
+		if (undone.length) return this.problem({
+			kind: "deletion-undone",
+			path,
+			message: `${path}: ${undone.length} line(s) removed here are still in the merged file, such as "${undone[0]}"; delete through a mainflow command or the Edit tool`
+		});
+		if (writer === base && last !== void 0 && last !== writer) {
+			const onDisk = last.split("\n");
+			const dropped = alignLines(onDisk, w).keptA;
+			const kept = alignLines(onDisk, r).keptA;
+			const reverted = onDisk.filter((line, i) => !dropped[i] && kept[i] && line.trim() !== "");
+			if (reverted.length) return this.problem({
+				kind: "deletion-undone",
+				path,
+				message: `${path}: the write removed ${reverted.length} line(s) another environment added, such as "${reverted[0]}"; they were kept. Delete through a mainflow command or the Edit tool`
+			});
+		}
+		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({
+				kind: "remove",
+				path,
+				base
+			}, {
+				queued,
+				...unsent ? {} : { sent: {
+					id,
+					firstSentSeq,
+					sent: request
+				} }
+			});
+			await this.settleRemove(path, response);
+		} finally {
+			this.release(path);
+		}
+	}
+	async settleRemove(path, response) {
+		if (!response.ok) return this.problem({
+			kind: "refused",
+			path,
+			message: `${path}: the server refused the deletion (${response.message})`
+		});
+		for (const notice of response.notices) this.problem({
+			kind: "removal-kept",
+			path: notice.path,
+			message: `${notice.message} (deleted here; the file is back)`
+		});
+		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.
+	*/
+	restoreEntry(entry) {
+		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);
+	}
+	/**
+	* Change the outbox: read queue.json, take in the entries other writers appended since it was last read, let `edit`
+	* change the list, and write it back, all under the hub's write lock; `edit` returns false when it changed nothing.
+	* Without `edit` it only writes back what it changed itself. The files an appended operation wrote become what the
+	* client expects on disk, so they are not sent again as edits; a direct edit they held before it, not sent yet, goes
+	* ahead of it. Every hold fills in the base of the queued edits whose base the server has confirmed since
+	* (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));
+	}
+	/** 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;
+		for (let i = 0; i < entries.length; i++) {
+			const entry = entries[i];
+			if (known.has(entry.id)) continue;
+			if (entry.kind === "op" && !entry.checked) {
+				const ahead = this.editsBefore(entries, i);
+				entries.splice(i, 0, ...ahead);
+				i += ahead.length;
+				entry.checked = true;
+				changed = true;
+			}
+			this.restoreEntry(entry);
+		}
+		if (this.resolveBases(entries)) changed = true;
+		if (edit && edit(entries) !== false) {
+			changed = true;
+			this.resolveBases(entries);
+		}
+		if (changed) writeQueue(this.root, entries);
+		this.queue = entries;
+		return entries;
+	}
+	/**
+	* A file never synced here, as it was before an operation, against the server's version: nothing when they are the
+	* same; otherwise sent as reconcile sends such a file, with its own text as the base, so the server keeps its version
+	* when it holds this text among its recent ones and refuses it otherwise, which saves it and reports.
+	*/
+	firstEdit(path, before) {
+		const target = this.cloud.get(path) ?? null;
+		if (target === before) return null;
+		return target === null ? {
+			kind: "patch",
+			path,
+			text: before,
+			base: null
+		} : {
+			kind: "patch",
+			path,
+			text: before,
+			base: contentHash(before),
+			baseText: before
+		};
+	}
+	/**
+	* After the snapshot, before anything is sent: the comparisons editsBefore left in the outbox for files never synced
+	* here (`unsettled`), made now that the server's versions are known. A hub the server did not have was uploaded as
+	* it was before the outbox (uploadIfEmpty), so they are the same and nothing is added.
+	*/
+	async settleUnsynced() {
+		if (!this.queue.some((entry) => entry.kind === "op" && entry.unsettled?.length)) return;
+		await this.whenFree(() => this.editQueue((entries) => {
+			for (let i = 0; i < entries.length; i++) {
+				const entry = entries[i];
+				if (entry.kind !== "op" || !entry.unsettled?.length) continue;
+				const ahead = [];
+				for (const path of entry.unsettled) {
+					const before = entry.before?.[path];
+					const write = typeof before === "string" ? this.firstEdit(path, before) : null;
+					if (!write) continue;
+					this.trace(`direct edit ${path} ${short(before)} ahead of ${entry.request.op} ${entry.id}: ${write.kind} (never synced here)`);
+					this.log(`${path}: it held a direct edit when ${entry.request.op} was written; the edit is sent first`);
+					ahead.push({
+						...write,
+						id: entryId()
+					});
+				}
+				delete entry.unsettled;
+				entries.splice(i, 0, ...ahead);
+				i += ahead.length;
+			}
+		}));
+	}
+	/**
+	* The direct edits an operation's files held when it was applied and the client had not sent: each file whose
+	* content before the operation is not what the client expected there. They go ahead of the operation, so the server
+	* has them when it applies it and the version it broadcasts back includes them (docs/sync.md "寫入的遠端模式").
+	*/
+	editsBefore(entries, at) {
+		const entry = entries[at];
+		const out = [];
+		for (const [path, before] of Object.entries(entry.before ?? {})) {
+			const seen = this.expected.get(path);
+			let write = null;
+			if (seen === void 0) {
+				if (before === null) continue;
+				if (!this.synced) {
+					entry.unsettled = [...entry.unsettled ?? [], path];
+					continue;
+				}
+				write = this.firstEdit(path, before);
+			} else if (before === null) {
+				if (seen !== null) write = {
+					kind: "remove",
+					path,
+					base: seen.hash
+				};
+			} else if (seen === null) write = {
+				kind: "patch",
+				path,
+				text: before,
+				base: null
+			};
+			else if (seen.hash !== contentHash(before)) write = editOn(path, before, this.startOf(path, before, seen, {
+				entries,
+				upto: at
+			}), seen.hash, seen.text);
+			if (!write) continue;
+			this.trace(`direct edit ${path} ${short(before)} ahead of ${entry.request.op} ${entry.id}: ${write.kind}`);
+			this.log(`${path}: it held a direct edit when ${entry.request.op} was written; the edit is sent first`);
+			out.push({
+				...write,
+				id: entryId()
+			});
+		}
+		return out;
+	}
+	/**
+	* Fill in the base of each queued edit based on a local text the server has confirmed since (src/state.ts): the hash
+	* of the server's version that holds it, and that version's text when the server merged it with other changes. Only
+	* the writes ahead of an edit and the confirmed versions count, since its base can come from nothing later. An edit
+	* whose base the server refused keeps a null base, and is refused when it is first sent. True when it changed one.
+	*/
+	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;
+			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));
+			this.trace(`based ${entry.id} on ${short(start.server)}`);
+			changed = true;
+		});
+		return changed;
+	}
+	syncQueue() {
+		return this.editQueue();
+	}
+	/**
+	* Run `fn`, which takes the write lock, again after a moment while another writer holds the lock longer than a
+	* writer waits for it. A lock left behind by a writer that died goes after LOCK_STALE_MS (core), so this ends.
+	*/
+	async whenFree(fn) {
+		for (;;) try {
+			return fn();
+		} catch (error) {
+			if (!(error instanceof WriteError) || this.stopped) throw error;
+			this.log(`${error.message}; trying again`);
+			await sleep$1(500);
+		}
+	}
+	/** queue.json changed, or may have: take in what other writers appended and send it. */
+	outboxChanged() {
+		const before = this.queue.length;
+		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());
+		}).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.
+	*/
+	async enqueue(write, from) {
+		await this.whenFree(() => this.editQueue((entries) => {
+			const entry = {
+				...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);
+		}));
+		this.log(`queued ${write.kind} ${entryPaths(write).join(", ")} (${this.queue.length} waiting)`);
+		if (this.online) this.track(this.flushQueue());
+	}
+	/**
+	* Send the outbox in order, one at a time, each after the previous one's response. An answered entry leaves the
+	* outbox under the write lock; while another writer holds the lock longer than a writer waits for it, the entry
+	* stays and is taken out on a later try, without being sent again. Before an entry is first sent, the request it
+	* 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;
+		this.flushing = true;
+		try {
+			while (this.caughtUp) {
+				let entry;
+				let again = false;
+				let unmergeable = false;
+				let waiting = false;
+				this.editQueue((entries) => {
+					entry = entries[0];
+					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;
+					}
+					entry.sent = request;
+					entry.firstSentSeq ??= this.hubSeq;
+				});
+				if (!entry || waiting) break;
+				if (unmergeable) await this.refuseUnmergeable(entry);
+				else if (!this.answered.has(entry.id)) {
+					this.sending = entry.id;
+					if (!await this.sendEntry(entry, again).finally(() => this.sending = null)) return this.retryQueue();
+				}
+				this.finish(entry);
+			}
+		} catch (error) {
+			this.log(`outbox: ${error.message}; trying again shortly`);
+			this.retryQueue();
+		} finally {
+			this.flushing = false;
+		}
+	}
+	retryQueue() {
+		clearTimeout(this.queueTimer);
+		if (!this.stopped) 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.
+	*/
+	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);
+		});
+		this.answered.delete(entry.id);
+		this.renumbering.delete(entry.id);
+		if (renumbered) this.log(`renumbered ${renumbered.map((r) => `${r.from} → ${r.to}`).join(", ")}`);
+		for (const path of entryPaths(entry)) this.schedule(path);
+		this.emit("settled", entry.id);
+	}
+	/**
+	* What became of outbox entry `id`, waiting up to `timeoutMs` while it is still in the outbox and the client is
+	* online: the server's answer for an operation this run sent, waiting when offline or out of time, or unknown for
+	* one that left the outbox otherwise.
+	*/
+	async outcome(id, timeoutMs) {
+		const deadline = Date.now() + timeoutMs;
+		const answered = () => this.outcomes.get(id);
+		if (answered()) return answered();
+		try {
+			this.syncQueue();
+		} catch {}
+		if (!this.queue.some((entry) => entry.id === id)) return { state: "unknown" };
+		await Promise.race([this.firstContact, sleep$1(timeoutMs)]);
+		if (!this.online || Date.now() >= deadline) return answered() ?? { state: "waiting" };
+		this.track(this.flushQueue());
+		return new Promise((resolve) => {
+			const finish = (outcome) => {
+				clearTimeout(timer);
+				this.off("settled", done);
+				this.off("offline", away);
+				resolve(outcome);
+			};
+			const done = (settled) => settled === id && finish(answered() ?? { state: "unknown" });
+			const away = () => finish({ state: "waiting" });
+			const timer = setTimeout(() => finish(answered() ?? { state: "waiting" }), deadline - Date.now());
+			this.on("settled", done);
+			this.on("offline", away);
+		});
+	}
+	settled(id, outcome) {
+		this.outcomes.set(id, outcome);
+		if (this.outcomes.size > 500) this.outcomes.delete(this.outcomes.keys().next().value);
+	}
+	/** The server answered an outbox entry, or it was settled without sending: it is not sent again. */
+	answer(entry) {
+		this.answered.add(entry.id);
+		this.trace(`answered ${entry.id}`);
+	}
+	/**
+	* Send one write of the outbox under the entry's id as its requestId; null when the server cannot be reached, so it
+	* 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.
+	*/
+	async request(entry, request, again) {
+		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;
+		try {
+			response = await this.api.send(firstSentSeq === void 0 ? {
+				...request,
+				requestId: entry.id
+			} : {
+				...request,
+				requestId: entry.id,
+				firstSentSeq
+			});
+		} catch (error) {
+			if (!(error instanceof Unreachable)) throw error;
+			this.trace(`send ${entry.id} failed: ${error.message}`);
+			return null;
+		}
+		if (!response.ok && response.reason === "uncertain") {
+			const paths = entryPaths(entry);
+			this.problem({
+				kind: "uncertain",
+				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 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
+	* refused or did not take as it was, so its base never became known, or moving it onto the server's merge overlaps.
+	*/
+	prepare(entry) {
+		if (entry.kind === "op") return currentRequest(entry.request);
+		if (entry.kind === "remove") return {
+			protocol: 2,
+			op: "file.remove",
+			input: {
+				path: entry.path,
+				base: entry.base
+			},
+			now: requestTime()
+		};
+		const request = patchRequest(entry);
+		if (typeof request === "object") return request;
+		return request === "unresolved" && this.unanswered.get(entry.path)?.includes(entry.baseText) ? "wait" : 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({
+			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}`
+		});
+	}
+	/** 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);
+		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, {
+				writer: entry.text,
+				base: entry.baseText,
+				last: entry.replaced
+			}, request.text);
+			return true;
+		} finally {
+			for (const path of paths) {
+				const count = (this.inflight.get(path) ?? 1) - 1;
+				if (count > 0) this.inflight.set(path, count);
+				else this.inflight.delete(path);
+			}
+		}
+	}
+	/** 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",
+				reason: response.reason,
+				message: response.message,
+				saved
+			});
+			return;
+		}
+		this.settled(entry.id, {
+			state: "applied",
+			response
+		});
+		if (response.renumbered.length > 0) this.renumbering.set(entry.id, response.renumbered);
+		for (const file of response.files) {
+			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, {
+				text: local,
+				server: file.text
+			});
+		}
+		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.
+	*/
+	renumber(entries, entry, renumbered) {
+		const rest = entries.filter((queued) => queued.id !== entry.id && queued.sent === void 0);
+		const offlinePaths = [...entryPaths(entry), ...rest.flatMap(entryPaths)];
+		const storage = this.trackingStorage();
+		this.commitTracked(storage, renumberFiles(storage, 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}`] : []));
+		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`);
+		}
+		for (const queued of rest) if (queued.kind === "op") {
+			queued.request = renumberRequest(queued.request, renumbered);
+			queued.written = files(queued.written);
+			if (queued.before) queued.before = files(queued.before);
+		} else {
+			const from = queued.path;
+			queued.path = renumberPath(queued.path, renumbered);
+			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.baseText !== void 0 && !sentText.has(`${from}\0${queued.baseText}`)) queued.baseText = renumberText(queued.baseText, renumbered, scopeOfPath(queued.path));
+			}
+		}
+	}
+	/**
+	* 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.
+	*/
+	trackingStorage() {
+		const base = {
+			...nodeStorage(this.root),
+			lock: (fn) => fn()
+		};
+		const track = (path) => {
+			if (!isSynced(path)) return;
+			const text = base.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) {
+		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);
+		else storage.remove(change.path);
+	}
+	/** Problems no caller has been given yet; the watcher may have sent a change before the hook asked. */
+	drain() {
+		const out = this.problems.slice(this.reported);
+		this.reported = this.problems.length;
+		return out;
+	}
+	/** After a tool ran: find every change now, wait for the server, and return what went wrong. */
+	async flush(timeoutMs = 2e4) {
+		await this.scan(true);
+		this.outboxChanged();
+		await this.idle(timeoutMs);
+		return {
+			problems: this.drain(),
+			queued: this.queue.length,
+			online: this.online
+		};
+	}
+	/**
+	* After an Edit: replay the replacement on the server's latest version, so an Edit made while a broadcast was on
+	* its way is not mistaken for a rewrite of the older file. Anything else is flushed as usual.
+	*/
+	async flushEdit(edit, timeoutMs = 2e4) {
+		const { path } = edit;
+		if (this.caughtUp && isSynced(path) && edit.old !== "") await this.withChain(path, () => this.replayEdit(edit));
+		return this.flush(timeoutMs);
+	}
+	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 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);
+		}
+	}
+	/** What the server answered to an Edit replayed on its version (`writer` is the edited text). */
+	async settleReplace(path, response, writer) {
+		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 (file) await this.delivery(path, response.seq);
+			return;
+		}
+		const saved = await this.saveConflict(path, writer);
+		this.problem({
+			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`
+		});
+		if ("files" in response && response.files.some((f) => f.path === path)) await this.delivery(path, response.seq);
+	}
+	async walk(dir = "") {
+		const out = [];
+		let entries;
+		try {
+			entries = await readdir(join(this.paths.data, dir), { withFileTypes: true });
+		} catch {
+			return out;
+		}
+		for (const entry of entries) {
+			const path = dir ? `${dir}/${entry.name}` : entry.name;
+			if (entry.isDirectory()) {
+				if (mayHoldSynced(path)) out.push(...await this.walk(path));
+			} else if (entry.isFile() && isSynced(path)) out.push(path);
+		}
+		return out;
+	}
+	async walkDirs(dir = "") {
+		const out = [];
+		const entries = await readdir(join(this.paths.data, dir), { withFileTypes: true }).catch(() => []);
+		for (const entry of entries) {
+			const path = dir ? `${dir}/${entry.name}` : entry.name;
+			if (!entry.isDirectory() || path === "local" || path.startsWith("local/")) continue;
+			out.push(path, ...await this.walkDirs(path));
+		}
+		return out;
+	}
+	/**
+	* Compare every synced file's size, modification time and inode with the last scan and reconcile what changed,
+	* plus every file expected on disk that is gone. A file modified in the last moment may still be being written,
+	* so it waits for the next scan unless `immediate`. `baseline` only records what is there.
+	*/
+	async scan(immediate, baseline = false) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const path of await this.walk()) {
+			seen.add(path);
+			const info = await stat(join(this.paths.data, path)).catch(() => null);
+			if (!info) continue;
+			const signature = `${info.mtimeMs}:${info.size}:${info.ino}`;
+			if (this.signatures.get(path) === signature) continue;
+			if (!baseline && !immediate && Date.now() - info.mtimeMs < 150) continue;
+			this.signatures.set(path, signature);
+			if (!baseline) this.schedule(path);
+		}
+		if (baseline) return;
+		for (const [path, disk] of this.expected) if (disk !== null && !seen.has(path)) {
+			this.signatures.delete(path);
+			this.schedule(path);
+		}
+		if (immediate) await Promise.allSettled(this.chains.values());
+	}
+	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;
+				clearTimeout(timers.get(path));
+				timers.set(path, setTimeout(() => {
+					timers.delete(path);
+					this.track(this.whenSettled(path).then(() => this.schedule(path)));
+				}, SETTLE_MS));
+			});
+			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`);
+		}
+	}
+	async whenSettled(path) {
+		const file = join(this.paths.data, path);
+		let previous = "";
+		for (let i = 0; i < 20; 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);
+		}
+	}
+	problem(problem) {
+		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) {
+		this.emit("info", {
+			path,
+			message
+		});
+		appendFile(this.paths.notices, `${JSON.stringify({
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			level: "info",
+			path,
+			message
+		})}\n`).catch(() => {});
+	}
+	async saveConflict(path, text) {
+		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("/");
+	}
+	saveKnown() {
+		if (this.knownTimer) return;
+		this.knownTimer = setTimeout(() => this.saveKnownNow(), 200);
+	}
+	saveKnownNow() {
+		clearTimeout(this.knownTimer);
+		this.knownTimer = void 0;
+		const files = {};
+		for (const [path, disk] of this.expected) if (disk) files[path] = disk.hash;
+		try {
+			underLock(this.root, () => writeKnown(this.root, files));
+		} catch (error) {
+			this.log(`could not save local/sync/known.json: ${error.message}`);
+		}
+	}
+};
+//#endregion
+//#region ../sync/dist/ipc.js
+const SECRET_HEADER = "x-mainflow-sync";
+/** The running sync client of the hub at `root`, or null when none runs. */
+function readDaemon(root) {
+	const file = syncPaths(root).daemon;
+	if (!existsSync(file)) return null;
+	try {
+		const info = JSON.parse(readFileSync(file, "utf8"));
+		process.kill(info.pid, 0);
+		return info;
+	} catch {
+		return null;
+	}
+}
+/**
+* The client could not be reached, though daemon.json names it; the caller works without it. `silent` when the port
+* took the request but gave no answer in time, as a sync client busy for a moment does; otherwise nothing that
+* answers as the hub's sync client is there, such as when its process ended and another took its pid.
+*/
+var DaemonUnavailable = class extends Error {
+	silent;
+	constructor(message, silent = false) {
+		super(message);
+		this.silent = silent;
+	}
+};
+/** Another sync client already runs for the hub. */
+var DaemonRunning = class extends Error {};
+async function callDaemon(daemon, route, body, timeoutMs = 6e4) {
+	let response;
+	try {
+		response = await fetch(`http://127.0.0.1:${daemon.port}${route}`, {
+			method: body === void 0 ? "GET" : "POST",
+			headers: {
+				[SECRET_HEADER]: daemon.secret,
+				"content-type": "application/json"
+			},
+			body: body === void 0 ? void 0 : JSON.stringify(body),
+			signal: AbortSignal.timeout(timeoutMs)
+		});
+	} catch (error) {
+		const silent = error.name === "TimeoutError";
+		throw new DaemonUnavailable(`mainflow sync (pid ${daemon.pid}) does not answer: ${error.message}`, silent);
+	}
+	let parsed;
+	try {
+		parsed = await response.json();
+	} catch {
+		throw new DaemonUnavailable(`what answers on port ${daemon.port} is not mainflow sync (pid ${daemon.pid})`);
+	}
+	if (response.status === 403) throw new DaemonUnavailable(`what answers on port ${daemon.port} is not this hub's mainflow sync (pid ${daemon.pid})`);
+	if (!response.ok) throw new Error(`mainflow sync failed: ${parsed.error}`);
+	return parsed;
+}
+/** How long a probe waits for the sync client's answer; a client holding the write lock answers after it. */
+const PROBE_MS = 2e3;
+/** The sync client daemon.json names, asked whether it runs; null without daemon.json or a live process at its pid. */
+async function probeDaemon(root, timeoutMs = PROBE_MS) {
+	const daemon = readDaemon(root);
+	if (!daemon) return null;
+	try {
+		return {
+			state: "running",
+			daemon,
+			status: await callDaemon(daemon, "/status", void 0, timeoutMs)
+		};
+	} catch (error) {
+		if (!(error instanceof DaemonUnavailable)) return {
+			state: "running",
+			daemon
+		};
+		return {
+			state: error.silent ? "silent" : "gone",
+			daemon
+		};
+	}
+}
+/** What to do about a sync client whose port takes requests and does not answer. */
+const silentHint = (daemon) => `its port ${daemon.port} takes requests and does not answer; if it stays so, stop pid ${daemon.pid} or delete .mainflow/local/sync/daemon.json`;
+const sameDaemon = (a, b) => a !== null && a.pid === b.pid && a.port === b.port && a.secret === b.secret;
+/**
+* Remove daemon.json when it still says what `gone` said, under the write lock, so a sync client that claimed the hub
+* meanwhile keeps it. Call holding the lock.
+*/
+function forgetDaemon(root, gone) {
+	if (!sameDaemon(readDaemon(root), gone)) return false;
+	rmSync(syncPaths(root).daemon, { force: true });
+	return true;
+}
+/** Serve `client` to this machine's mainflow commands until closed. */
+async function serveIpc(root, client) {
+	const secret = randomBytes(16).toString("hex");
+	const server = createServer(async (req, res) => {
+		const reply = (status, value) => res.writeHead(status, { "content-type": "application/json" }).end(JSON.stringify(value));
+		if (req.headers["x-mainflow-sync"] !== secret) return reply(403, { error: "wrong secret" });
+		const chunks = [];
+		for await (const chunk of req) chunks.push(chunk);
+		let body = {};
+		try {
+			body = chunks.length ? JSON.parse(Buffer.concat(chunks).toString("utf8")) : {};
+		} catch {
+			return reply(400, { error: "the body is not JSON" });
+		}
+		try {
+			if (req.url === "/wait") return reply(200, await client.outcome(String(body.id), typeof body.timeoutMs === "number" ? body.timeoutMs : 0));
+			if (req.url === "/flush") {
+				const edit = body.edit;
+				return reply(200, edit ? await client.flushEdit(edit) : await client.flush());
+			}
+			if (req.url === "/status") return reply(200, {
+				online: client.online,
+				caughtUp: client.caughtUp,
+				queued: client.queued,
+				swapping: client.swapping,
+				problems: client.problems.length
+			});
+			if (req.url === "/file") return reply(200, { text: client.serverText(String(body.path)) });
+			return reply(404, { error: `no route ${req.url}` });
+		} catch (error) {
+			return reply(500, { error: error.message });
+		}
+	});
+	await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+	const port = server.address().port;
+	const file = syncPaths(root).daemon;
+	const probe = await probeDaemon(root);
+	const other = underLock(root, () => {
+		const running = readDaemon(root);
+		const reused = running !== null && probe?.state === "gone" && sameDaemon(running, probe.daemon);
+		if (running && running.pid !== process.pid && !reused) return running;
+		mkdirSync(syncPaths(root).own, { recursive: true });
+		writeFileSync(file, JSON.stringify({
+			pid: process.pid,
+			port,
+			secret
+		}), { mode: 384 });
+		return null;
+	});
+	if (other) {
+		server.closeAllConnections();
+		await new Promise((resolve) => server.close(() => resolve()));
+		throw new DaemonRunning(`mainflow sync already runs for this hub (pid ${other.pid})${probe?.state === "silent" && sameDaemon(other, probe.daemon) ? `; ${silentHint(other)}` : ""}`);
+	}
+	return {
+		port,
+		close: async () => {
+			try {
+				if (JSON.parse(readFileSync(file, "utf8")).pid === process.pid) rmSync(file, { force: true });
+			} catch {}
+			server.closeAllConnections();
+			await new Promise((resolve) => server.close(() => resolve()));
+		}
+	};
+}
+//#endregion
+//#region ../sync/dist/daemon.js
+async function startDaemon(options) {
+	const client = new SyncClient(options);
+	const ipc = await serveIpc(options.root, client);
+	try {
+		await client.start();
+	} catch (error) {
+		await ipc.close();
+		throw error;
+	}
+	return {
+		client,
+		stop: async () => {
+			await ipc.close();
+			await client.stop();
+		}
+	};
+}
+//#endregion
+//#region ../sync/dist/hook.js
+/** Tools that write the one file named in file_path. */
+const FILE_TOOLS = /* @__PURE__ */ new Set([
+	"Edit",
+	"Write",
+	"MultiEdit",
+	"NotebookEdit"
+]);
+/**
+* What to flush after the tool in `payload` ran in the hub at `root`. A file tool outside the hub's synced files
+* needs nothing; an Edit of one replacement is replayed on the latest version; anything else, such as a Bash
+* command that may have written any file, rescans every file.
+*/
+function planFlush(root, payload) {
+	const tool = payload.tool_name ?? "";
+	if (!FILE_TOOLS.has(tool)) return { skip: false };
+	const input = payload.tool_input ?? {};
+	if (typeof input.file_path !== "string") return { skip: false };
+	const file = isAbsolute(input.file_path) ? input.file_path : resolve(payload.cwd ?? process.cwd(), input.file_path);
+	const path = relative(join(root, DATA_DIR), file).split(sep).join("/");
+	if (path.startsWith("../") || path === ".." || isAbsolute(path) || !isSynced(path)) return { skip: true };
+	if (tool === "Edit" && input.replace_all !== true && typeof input.old_string === "string" && typeof input.new_string === "string") return {
+		skip: false,
+		edit: {
+			path,
+			old: input.old_string,
+			new: input.new_string
+		}
+	};
+	return { skip: false };
+}
+/** The PostToolUse answer: block with the problems as the reason, or nothing when the change went through as written. */
+function hookAnswer(result) {
+	if (result.problems.length === 0) return null;
+	const reason = [
+		"mainflow sync: a change to .mainflow/ did not reach the hub as it was written.",
+		...result.problems.map((p) => `- ${p.message}`),
+		"Read the affected files again, check that they hold your change and the other environments' changes, and redo what is missing."
+	].join("\n");
+	return JSON.stringify({
+		decision: "block",
+		reason
+	});
+}
+//#endregion
+//#region ../sync/dist/settings.js
+const ENV = {
+	url: "MAINFLOW_SYNC_URL",
+	token: "MAINFLOW_SYNC_TOKEN"
+};
+/** The hub's name as config.yaml gives it. */
+function hubName(root) {
+	const config = parse$1(readFileSync(join(root, DATA_DIR, "config.yaml"), "utf8"));
+	if (typeof config?.hub !== "string") throw new Error(`${join(root, DATA_DIR, "config.yaml")} names no hub`);
+	return config.hub;
+}
+/** The sync settings of the hub at `root`, or null when either the server or the token is missing. */
+function syncSettings(root, env = process.env) {
+	const file = join(root, DATA_DIR, SETTINGS_FILE);
+	let stored = {};
+	if (existsSync(file)) try {
+		stored = JSON.parse(readFileSync(file, "utf8")) ?? {};
+	} catch (error) {
+		throw new Error(`${file} is not JSON: ${error.message}`);
+	}
+	const url = env[ENV.url] || (typeof stored.url === "string" ? stored.url : "");
+	const token = env[ENV.token] || (typeof stored.token === "string" ? stored.token : "");
+	if (!url || !token) return null;
+	return {
+		url: url.replace(/\/+$/, ""),
+		token,
+		hub: hubName(root)
+	};
+}
+//#endregion
+//#region ../sync/dist/outbox.js
+/** Whether the hub at `root` writes through the sync server. */
+function remoteMode(root, env = process.env) {
+	return readDaemon(root) !== null || syncSettings(root, env) !== null;
+}
+/** Refusals of an operation by the local files, as opposed to a write lock held too long; thrown as they are. */
+const refusals = /* @__PURE__ */ new WeakSet();
+/** Whether `error`, thrown by queueOperation, is the operation's refusal by the local files. */
+const refusedHere = (error) => error instanceof Error && refusals.has(error);
+/**
+* Apply `request` to the local files and append it to the outbox, under one hold of the hub's write lock. The sync
+* client reads the outbox under the same lock, so it never sees the files this changed without the entry that
+* explains them, and never takes them for an edit to send. A refusal here is thrown, and nothing is queued.
+*/
+function queueOperation(root, request) {
+	const storage = nodeStorage(root);
+	return storage.lock(() => {
+		const before = {};
+		const keep = (path) => {
+			if (isSynced(path) && !(path in before)) before[path] = storage.read(path);
+		};
+		const held = {
+			...storage,
+			lock: (fn) => fn(),
+			write: (path, text) => (keep(path), storage.write(path, text)),
+			append: (path, text) => (keep(path), storage.append(path, text)),
+			remove: (path) => (keep(path), storage.remove(path))
+		};
+		let applied;
+		try {
+			applied = applyOffline(held, request);
+		} catch (error) {
+			if (error instanceof WriteError) refusals.add(error);
+			throw error;
+		}
+		const { result, pending } = applied;
+		const written = {};
+		for (const change of result.changes) if (change.kind !== "makeDir" && isSynced(change.path)) written[change.path] = held.read(change.path);
+		const id = entryId();
+		writeQueue(root, [...readQueue(root), {
+			id,
+			kind: "op",
+			request: pending,
+			before: Object.fromEntries(Object.keys(written).map((path) => [path, before[path] ?? null])),
+			written
+		}]);
+		return {
+			id,
+			result
+		};
+	});
+}
+/** How many writes wait in the outbox, as queue.json says. */
+function queuedCount(root) {
+	const file = syncPaths(root).queue;
+	if (!existsSync(file)) return 0;
+	try {
+		return JSON.parse(readFileSync(file, "utf8")).entries?.length ?? 0;
+	} catch {
+		return 0;
+	}
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+* 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.
+*/
+async function awaitOutcome(root, id, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	for (;;) {
+		const left = deadline - Date.now();
+		if (left <= 0) return { state: "waiting" };
+		const daemon = readDaemon(root);
+		if (daemon) try {
+			return await callDaemon(daemon, "/wait", {
+				id,
+				timeoutMs: left
+			}, left + 1e3);
+		} catch (error) {
+			if (!(error instanceof DaemonUnavailable)) throw error;
+		}
+		await sleep(Math.min(100, left));
+	}
+}
+//#endregion
+//#region src/remote/start.ts
+/** How long a sync client started in the background may take to claim the hub, its first request to the server included. */
+const STARTING_MS = 6e4;
+const alive = (pid) => {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+};
+/**
+* Make sure the hub at `root` has a running sync client, starting `mainflow sync` in the background when it has
+* none. `env` gives the sync server and token as the environment variables do; for a hub other than the one this
+* process was started in it is `{}`, so the process started reads that hub's own .mainflow/local/sync.json.
+*/
+async function startSyncInBackground(root, env = process.env) {
+	const probe = await probeDaemon(root);
+	if (probe && probe.state !== "gone") return { state: "running" };
+	const paths = syncPaths(root);
+	const cli = process.argv[1];
+	if (process.env.MAINFLOW_NO_BACKGROUND_SYNC === "1") return {
+		state: "failed",
+		reason: "starting it in the background is turned off by MAINFLOW_NO_BACKGROUND_SYNC"
+	};
+	if (!cli) return {
+		state: "failed",
+		reason: "this process cannot tell where the mainflow CLI is"
+	};
+	const log = relative(root, paths.log);
+	return nodeStorage(root).lock(() => {
+		const reused = probe?.state === "gone" && forgetDaemon(root, probe.daemon) ? probe.daemon.pid : void 0;
+		if (reused === void 0 && readDaemon(root)) return { state: "starting" };
+		let previous = null;
+		try {
+			previous = existsSync(paths.started) ? JSON.parse(readFileSync(paths.started, "utf8")) : null;
+		} catch {
+			previous = null;
+		}
+		const since = typeof previous?.at === "string" ? Date.now() - Date.parse(previous.at) : Infinity;
+		if (reused === void 0 && typeof previous?.pid === "number" && alive(previous.pid) && since < STARTING_MS) return { state: "starting" };
+		mkdirSync(paths.own, { recursive: true });
+		const out = openSync(paths.log, "a");
+		let pid;
+		try {
+			const child = spawn(process.execPath, [cli, "sync"], {
+				cwd: root,
+				detached: true,
+				stdio: [
+					"ignore",
+					out,
+					out
+				],
+				env: {
+					...process.env,
+					[ENV.url]: env[ENV.url] ?? "",
+					[ENV.token]: env[ENV.token] ?? ""
+				}
+			});
+			child.on("error", () => {});
+			child.unref();
+			pid = child.pid;
+		} finally {
+			closeSync(out);
+		}
+		if (pid === void 0) return {
+			state: "failed",
+			reason: `could not start mainflow sync; see ${log}`
+		};
+		writeFileSync(paths.started, JSON.stringify({
+			pid,
+			at: (/* @__PURE__ */ new Date()).toISOString()
+		}));
+		if (reused !== void 0) return {
+			state: "restarted",
+			reason: `.mainflow/local/sync/daemon.json named pid ${reused}, which is not mainflow sync; started mainflow sync`
+		};
+		if (previous) return {
+			state: "restarted",
+			reason: `the last mainflow sync started for this hub stopped (see ${log}); started it again`
+		};
+		return { state: "started" };
+	});
+}
+//#endregion
+//#region src/remote/operation.ts
+/** Added to a write the local files refused, unless the sync client runs with the server's latest state. */
+const STALE_COPY = "the local copy may not have caught up with the sync server yet; retry once mainflow sync has caught up (mainflow sync status)";
+/** Whether the hub's sync client runs and has the server's latest state, asked with a short wait. */
+async function caughtUp(root) {
+	const daemon = readDaemon(root);
+	if (!daemon) return false;
+	try {
+		return (await callDaemon(daemon, "/status", void 0, 2e3)).caughtUp === true;
+	} catch {
+		return false;
+	}
+}
+/** How long a writing command waits for the server's answer before it ends with its write in the outbox. */
+const CONFIRM_MS = 15e3;
+const QUEUED_LINE = "(queued: written here and waiting in the outbox; mainflow sync sends it once connected, and the sync server may give new entries other ids)";
+/** The lines a command prints after a write's value; a line starting with "!" is a warning. */
+function writtenLines(written) {
+	return [
+		...written.notices.map((notice) => `! ${notice.message}`),
+		...written.renumbered.map((r) => `! the sync server gave ${r.from} to another entry; this one is ${r.to}`),
+		...written.restarted ? [`! ${written.restarted}`] : [],
+		...written.stopped ? [`! ${written.stopped}`] : [],
+		...written.queued ? [QUEUED_LINE] : []
+	];
+}
+/**
+* The writer for the hub at `root`. `env` gives the sync server and token as the environment variables do; a hub
+* other than the one this process was started in, such as another hub the interface shows, passes `{}`, so only its
+* own .mainflow/local/sync.json and sync client count.
+*/
+function hubWriter(root, env = process.env, options = {}) {
+	const startSync = options.startSync ?? startSyncInBackground;
+	return async (op, input) => {
+		if (!remoteMode(root, env)) return {
+			value: applyOperation(nodeStorage(root), op, input, { now: nowMinute() }).value,
+			queued: false,
+			renumbered: [],
+			notices: []
+		};
+		let queuedOp;
+		try {
+			queuedOp = queueOperation(root, {
+				protocol: 2,
+				op,
+				input,
+				now: requestTime()
+			});
+		} catch (error) {
+			if (refusedHere(error) && !await caughtUp(root)) error.message += `; ${STALE_COPY}`;
+			throw error;
+		}
+		const { id, result } = queuedOp;
+		const start = await startSync(root, env);
+		const queued = {
+			value: result.value,
+			queued: true,
+			renumbered: [],
+			notices: result.notices,
+			...start.state === "restarted" ? { restarted: start.reason } : {}
+		};
+		if (start.state === "failed") return {
+			...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;
+		const outcome = await awaitOutcome(root, id, options.confirmMs);
+		if (outcome.state === "applied") {
+			const { response } = outcome;
+			return {
+				...queued,
+				value: response.value,
+				queued: false,
+				renumbered: response.renumbered,
+				notices: response.notices
+			};
+		}
+		if (outcome.state === "refused") {
+			const saved = outcome.saved.length ? `; what it wrote here was saved to ${outcome.saved.join(", ")} and the files have the server's version again` : "";
+			const message = `the sync server refused ${op}: ${outcome.message}${saved}${queued.restarted ? `; ${queued.restarted}` : ""}`;
+			throw outcome.reason === "conflict" ? new ConflictError(message) : new WriteError(message);
+		}
+		return queued;
+	};
+}
+//#endregion
+export { ServerError as C, ServerApi as S, silentHint as _, remoteMode as a, isSynced as b, syncSettings as c, startDaemon as d, DaemonRunning as f, readDaemon as g, probeDaemon as h, queuedCount as i, hookAnswer as l, callDaemon as m, hubWriter as n, ENV as o, DaemonUnavailable as p, writtenLines as r, hubName as s, CONFIRM_MS as t, planFlush as u, SETTINGS_FILE as v, syncPaths as x, SYNC_DIR as y };