mainflow 0.30.0-alpha.1 → 0.31.0-alpha.1

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

@@ -1,4 +1,4 @@
-import { $ as AUTHORIZATION, F as renumberFiles, I as renumberPath, L as renumberText, N as applyOffline, P as renumberRequest, Q as nodeStorage, R as scopeOfPath, X as nowMinute, at as ConflictError, ct as contentHash, et as ROUTES, ot as DATA_DIR, st as WriteError, tt as requestTime, z as applyOperation } from "./host-DmVNYRql.js";
+import { $ as ACCESS_HEADERS, F as renumberFiles, I as renumberPath, L as renumberText, N as applyOffline, P as renumberRequest, Q as nodeStorage, R as scopeOfPath, X as nowMinute, ct as DATA_DIR, dt as splitFrontMatter, et as ROUTES, lt as WriteError, nt as comparePaths, rt as requestTime, st as ConflictError, tt as SOCKET_MAX_AGE_CLOSE, ut as contentHash, z as applyOperation } from "./host-CdB_vDY_.js";
 import { createHash, randomBytes } from "node:crypto";
 import { accessSync, appendFileSync, chmodSync, closeSync, constants, copyFileSync, existsSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
@@ -6,11 +6,139 @@ 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 { createBrotliDecompress, createGunzip, createInflate, createZstdDecompress } from "node:zlib";
 import { Agent, createServer, request } from "node:http";
 import { Agent as Agent$1, request as request$1 } from "node:https";
 import { EventEmitter } from "node:events";
 import { appendFile, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { diff3Merge } from "node-diff3";
+//#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, clientId, clientSecret }. 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"),
+		/** The files only on the server, the artifacts of closed mainlines not downloaded here, by their content hash */
+		remote: join(own, "remote.json"),
+		/** The text of each version known.json names, in a file named by its content hash */
+		knownTexts: join(own, "known"),
+		queue: join(own, "queue.json"),
+		notices: join(own, "notices.jsonl"),
+		daemon: join(own, "daemon.json"),
+		/** 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;
+/**
+* Whether the client's file watcher watches inside the directory at `path`: one that may hold synced files, and
+* local/sync/ itself for the outbox; the directories under local/sync/ hold only the client's own files.
+*/
+const watchedDir = (path) => path === "local/sync" || mayHoldSynced(path);
+/** An artifact of a mainline or of one of its tasks: `mainlines/<mainline>/artifacts/...` or `.../tasks/<task>/artifacts/...`. */
+const ARTIFACT = /^mainlines\/([^/]+)\/(?:tasks\/[^/]+\/)?artifacts\/./;
+/**
+* The directory of the mainline whose artifact `path` is, such as `m001-sync`; null for any other path. Only such a file
+* may stay on the server until it is used, when its mainline is closed (docs/sync.md "按需下載").
+*/
+const artifactOf = (path) => ARTIFACT.exec(path)?.[1] ?? null;
+//#endregion
+//#region ../sync/dist/settings.js
+const ENV = {
+	url: "MAINFLOW_SYNC_URL",
+	clientId: "MAINFLOW_SYNC_CLIENT_ID",
+	clientSecret: "MAINFLOW_SYNC_CLIENT_SECRET",
+	onDemand: "MAINFLOW_SYNC_ON_DEMAND"
+};
+/** The values of MAINFLOW_SYNC_ON_DEMAND that turn it on; any other value that is not empty turns it off. */
+const ON = /* @__PURE__ */ new Set([
+	"1",
+	"true",
+	"on"
+]);
+/** 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;
+}
+const text = (value) => typeof value === "string" ? value : "";
+/** What .mainflow/local/sync.json holds, nothing when there is no such file. */
+function stored(root) {
+	const file = join(root, DATA_DIR, SETTINGS_FILE);
+	if (!existsSync(file)) return {};
+	try {
+		return JSON.parse(readFileSync(file, "utf8")) ?? {};
+	} catch (error) {
+		throw new Error(`${file} is not JSON: ${error.message}`);
+	}
+}
+/**
+* The sync settings of the hub at `root`, or null when the server or either half of the token is missing. Each value
+* comes from its environment variable, or from sync.json when the variable is unset or empty.
+*/
+function syncSettings(root, env = process.env) {
+	const saved = stored(root);
+	const url = env[ENV.url] || text(saved.url);
+	const clientId = env[ENV.clientId] || text(saved.clientId);
+	const clientSecret = env[ENV.clientSecret] || text(saved.clientSecret);
+	if (!url || !clientId || !clientSecret) return null;
+	const onDemand = env[ENV.onDemand] ? ON.has(env[ENV.onDemand].trim().toLowerCase()) : saved.onDemand === true;
+	return {
+		url: url.replace(/\/+$/, ""),
+		clientId,
+		clientSecret,
+		hub: hubName(root),
+		onDemand
+	};
+}
+/** The environment variable and the sync.json key that held the token before Cloudflare Access let requests through. */
+const EARLIER_TOKEN = {
+	env: "MAINFLOW_SYNC_TOKEN",
+	key: "token"
+};
+/**
+* What to tell the user when the hub at `root` has no sync settings but keeps the token of an earlier version, which
+* nothing reads now: where that token is and which two values to set instead, never the token itself. Null when the
+* settings are whole or no earlier token is kept, so a hub that never synced writes to its local files without a word.
+*/
+function earlierToken(root, env = process.env) {
+	if (syncSettings(root, env)) return null;
+	const where = [...env[EARLIER_TOKEN.env] ? [EARLIER_TOKEN.env] : [], ...text(stored(root)[EARLIER_TOKEN.key]) ? [`the ${EARLIER_TOKEN.key} key of .mainflow/${SETTINGS_FILE}`] : []];
+	if (where.length === 0) return null;
+	return `${where.join(" and ")} ${where.length > 1 ? "are" : "is"} no longer read, so mainflow does not write through the sync server; set ${ENV.clientId} and ${ENV.clientSecret}, or clientId and clientSecret in .mainflow/${SETTINGS_FILE}, to a Cloudflare Access service token`;
+}
+//#endregion
 //#region ../sync/dist/api.js
 /**
 * The server could not be reached, or the connection broke. `sent` says whether the request may have reached the
@@ -27,7 +155,7 @@ var Unreachable = class extends Error {
 		this.broken = broken;
 	}
 };
-/** The server refused before the hub (401, 400, 404) or failed (500). */
+/** The server refused before the hub (400, 404) or failed (500), or Cloudflare Access in front of it refused (AccessRefused). */
 var ServerError = class extends Error {
 	status;
 	constructor(message, status) {
@@ -35,6 +163,8 @@ var ServerError = class extends Error {
 		this.status = status;
 	}
 };
+/** Cloudflare Access refused the request: no service token, a wrong or revoked one, or a policy that does not admit it. */
+var AccessRefused = class extends ServerError {};
 /** Error codes of a connection that never carried the request. */
 const NOT_SENT = /* @__PURE__ */ new Set([
 	"ECONNREFUSED",
@@ -55,6 +185,16 @@ const STALE = /* @__PURE__ */ new Set([
 const WARM_MS = 1e4;
 /** How long keeping the connection open waits for its answer. */
 const WARM_TIMEOUT_MS = 5e3;
+/** Snapshots in a row whose batches went back in seq, as when the server's storage was replaced midway, before giving up */
+const SNAPSHOT_ATTEMPTS = 3;
+/** The encodings an answer may come in, by Content-Encoding, best first; Cloudflare's free plan sends Zstandard. */
+const DECODERS = {
+	zstd: createZstdDecompress,
+	br: createBrotliDecompress,
+	gzip: createGunzip,
+	deflate: createInflate
+};
+const ACCEPT_ENCODING = Object.keys(DECODERS).join(", ");
 const causeCode = (error) => {
 	for (let cause = error; cause; cause = cause.cause) if (typeof cause.code === "string") return cause.code;
 };
@@ -66,35 +206,56 @@ var ServerApi = class {
 	* connection at a time, since the client sends one write at a time; a request waits for the one before it.
 	*/
 	agent;
+	/** The connections snapshots go on, apart from the writes', so a snapshot never waits behind a write or holds one up */
+	reads;
 	/** Requests on `agent` not answered yet */
 	busy = 0;
+	transfer = {
+		batches: 0,
+		files: 0,
+		wire: 0,
+		body: 0,
+		sent: 0,
+		listed: 0
+	};
 	constructor(settings, timeoutMs = 3e4) {
 		this.settings = settings;
 		this.timeoutMs = timeoutMs;
-		const options = {
+		const Agent$2 = settings.url.startsWith("https:") ? Agent$1 : Agent;
+		this.agent = new Agent$2({
 			keepAlive: true,
 			maxSockets: 1,
 			maxFreeSockets: 1
-		};
-		this.agent = settings.url.startsWith("https:") ? new Agent$1(options) : new Agent(options);
+		});
+		this.reads = new Agent$2({
+			keepAlive: true,
+			maxSockets: 2,
+			maxFreeSockets: 1
+		});
 	}
-	get headers() {
+	/** The service token's headers, which every request and the WebSocket's upgrade carry. Never logged. */
+	get access() {
 		return {
-			[AUTHORIZATION]: `Bearer ${this.settings.token}`,
-			"content-type": "application/json"
+			[ACCESS_HEADERS.clientId]: this.settings.clientId,
+			[ACCESS_HEADERS.clientSecret]: this.settings.clientSecret
 		};
 	}
-	async call(method, route, body, fresh = false) {
+	async call(method, route, body, connection) {
 		const url = `${this.settings.url}${route}`;
+		const text = JSON.stringify(body);
 		let answer;
 		try {
-			answer = method === "GET" ? await this.fetchGet(url) : await this.write(method, url, JSON.stringify(body), fresh);
+			answer = connection === "read" ? await this.read(method, url, text) : await this.write(method, url, text, connection === "fresh");
 		} catch (error) {
 			const code = causeCode(error);
 			const detail = [code, error.cause?.message ?? error.message].filter(Boolean).join(": ");
 			const sent = !(code && NOT_SENT.has(code));
 			throw new Unreachable(`cannot reach the sync server at ${this.settings.url}${detail ? ` (${detail})` : ""}`, sent, sent && STALE.has(code ?? ""));
 		}
+		if (answer.status === 401 || answer.status === 403 || answer.status >= 300 && answer.status < 400) {
+			const to = answer.location ? ` to ${new URL(answer.location, url).origin}` : "";
+			throw new AccessRefused(`Cloudflare Access in front of the sync server refused the request (HTTP ${answer.status}${to}); check the service token in ${ENV.clientId} and ${ENV.clientSecret}, or clientId and clientSecret in .mainflow/${SETTINGS_FILE}`, answer.status);
+		}
 		let parsed;
 		try {
 			parsed = JSON.parse(answer.text);
@@ -103,23 +264,22 @@ var ServerApi = class {
 		}
 		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);
+		if (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
+			body: parsed,
+			wire: answer.wire,
+			size: Buffer.byteLength(answer.text),
+			sent: Buffer.byteLength(text)
 		};
 	}
-	/** A read may go on a pooled connection: one the server closed meanwhile fails at once, and the read is repeated. */
-	async fetchGet(url) {
+	/**
+	* A read goes on a connection of the reads: one the server closed meanwhile fails at once, and the read is repeated,
+	* since asking for a snapshot again changes nothing.
+	*/
+	async read(method, url, body) {
 		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()
-			};
+			return await this.exchange(method, url, body, this.reads, this.timeoutMs);
 		} catch (error) {
 			if (attempt > 0 || !STALE.has(causeCode(error) ?? "")) throw error;
 		}
@@ -131,14 +291,19 @@ var ServerApi = class {
 	* the response it kept if it took the request after all. Keeping the connection busy (warm) makes that rare.
 	*/
 	write(method, url, body, fresh) {
-		return this.exchange(method, url, {
-			...this.headers,
-			"content-length": String(Buffer.byteLength(body))
-		}, body, fresh ? false : this.agent, this.timeoutMs);
+		return this.exchange(method, url, body, fresh ? false : this.agent, this.timeoutMs);
 	}
-	exchange(method, url, headers, body, agent, timeoutMs) {
+	exchange(method, url, body, agent, timeoutMs) {
 		const send = url.startsWith("https:") ? request$1 : request;
-		if (agent) this.busy++;
+		const headers = {
+			...this.access,
+			"accept-encoding": ACCEPT_ENCODING
+		};
+		if (body !== void 0) Object.assign(headers, {
+			"content-type": "application/json",
+			"content-length": String(Buffer.byteLength(body))
+		});
+		if (agent === this.agent) this.busy++;
 		return new Promise((resolve, reject) => {
 			const req = send(url, {
 				method,
@@ -146,19 +311,31 @@ var ServerApi = class {
 				headers,
 				timeout: timeoutMs
 			}, (res) => {
+				let wire = 0;
+				res.on("data", (chunk) => wire += chunk.length);
+				const encoding = String(res.headers["content-encoding"] ?? "identity").toLowerCase();
+				const decode = DECODERS[encoding];
+				if (!decode && encoding !== "identity") {
+					res.resume();
+					return reject(/* @__PURE__ */ new Error(`the answer came in content-encoding ${encoding}, which this client cannot read`));
+				}
+				const stream = decode ? res.pipe(decode()) : res;
 				const chunks = [];
-				res.on("data", (chunk) => chunks.push(chunk));
-				res.on("end", () => resolve({
+				stream.on("data", (chunk) => chunks.push(chunk));
+				stream.on("end", () => resolve({
 					status: res.statusCode ?? 0,
-					text: Buffer.concat(chunks).toString("utf8")
+					text: Buffer.concat(chunks).toString("utf8"),
+					location: res.headers.location,
+					wire
 				}));
+				stream.on("error", reject);
 				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);
 		}).finally(() => {
-			if (agent) this.busy--;
+			if (agent === this.agent) this.busy--;
 		});
 	}
 	/**
@@ -168,25 +345,76 @@ var ServerApi = class {
 	async warm() {
 		if (this.busy > 0) return;
 		try {
-			await this.exchange("GET", `${this.settings.url}${ROUTES.version}`, {}, void 0, this.agent, WARM_TIMEOUT_MS);
+			await this.exchange("GET", `${this.settings.url}${ROUTES.version}`, void 0, this.agent, WARM_TIMEOUT_MS);
 		} catch {}
 	}
-	/** Close the kept connection; a later request opens another. */
+	/** Close the kept connections; a later request opens others. */
 	close() {
 		this.agent.destroy();
+		this.reads.destroy();
 	}
 	/** Send one request; the response is the hub's answer, applied or refused. */
 	async send(request, options = {}) {
-		return (await this.call("POST", ROUTES.request(this.settings.hub), request, options.fresh === true)).body;
+		return (await this.call("POST", ROUTES.request(this.settings.hub), request, options.fresh === true ? "fresh" : "write")).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`);
+	/** One batch of the snapshot, refused with a ServerError. */
+	async batch(request) {
+		const { body, wire, size, sent } = await this.call("POST", ROUTES.snapshot(this.settings.hub), request, "read");
 		if (!body.ok) throw new ServerError(`the sync server refused the snapshot: ${body.message}`, body.status);
-		return {
-			seq: body.seq,
-			files: body.files
-		};
+		this.transfer.batches++;
+		this.transfer.files += body.files.filter((entry) => entry.kind === "file").length;
+		this.transfer.listed += body.files.filter((entry) => entry.kind === "listed").length;
+		this.transfer.wire += wire;
+		this.transfer.body += size;
+		this.transfer.sent += sent;
+		return body;
+	}
+	/**
+	* The hub's snapshot, batch by batch (docs/sync-protocol.md "快照與整份上傳"). `have` gives the content hash of the
+	* text the client holds of each file, so the server sends only the files that differ, and names the ones of `have` it
+	* does not hold as removed; each batch is sent only the part of `have` in its own range. A path of `have` that no
+	* batch mentions is a file the server holds with that text. The batches are in order, each with its seq; one whose seq
+	* is below the batch before, as when the server's storage was replaced meanwhile, starts the snapshot over.
+	* `listOnly` asks for the files under those prefixes as `listed`, without their text. A part of the hub alone is taken
+	* from `after` on, and ends with the batch that covers `through`; only the paths of that range are told of.
+	*/
+	async snapshot(have = /* @__PURE__ */ new Map(), options = {}) {
+		const paths = [...have.keys()].sort(comparePaths);
+		const { through } = options;
+		for (let attempt = 1;; attempt++) {
+			const parts = [];
+			let after = options.after;
+			let start = 0;
+			for (;;) {
+				while (after !== void 0 && start < paths.length && comparePaths(paths[start], after) <= 0) start++;
+				const range = Object.fromEntries(paths.slice(start).map((path) => [path, have.get(path)]));
+				const { seq, files, next } = await this.batch({
+					protocol: 3,
+					have: range,
+					...after === void 0 ? {} : { after },
+					...options.listOnly?.length ? { listOnly: options.listOnly } : {}
+				});
+				if (parts.length > 0 && seq < parts.at(-1).seq) break;
+				parts.push({
+					seq,
+					files
+				});
+				if (next === null || through !== void 0 && comparePaths(next, through) >= 0) return parts;
+				if (after !== void 0 && comparePaths(next, after) <= 0) throw new Unreachable(`the sync server's snapshot did not move past ${after}`, true);
+				after = next;
+			}
+			if (attempt >= SNAPSHOT_ATTEMPTS) throw new Unreachable(`the sync server's seq went back while the snapshot was taken, ${SNAPSHOT_ATTEMPTS} times in a row`, true);
+		}
+	}
+	/**
+	* Whether the server takes this client's requests for the hub: the service token, the protocol version and the hub's
+	* name. One batch of at most one file, so the hub's size does not matter; a refusal is a ServerError.
+	*/
+	async check() {
+		await this.batch({
+			protocol: 3,
+			limit: 1
+		});
 	}
 	/**
 	* Upload a whole hub; refused with 409 when the server already holds one and `replace` is not set. It goes on a
@@ -194,17 +422,17 @@ var ServerApi = class {
 	*/
 	async upload(files, dirs, replace = false) {
 		const { body } = await this.call("PUT", ROUTES.snapshot(this.settings.hub), {
-			protocol: 2,
+			protocol: 3,
 			files,
 			dirs,
 			replace
-		}, true);
+		}, "fresh");
 		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}` } });
+		const url = `${this.settings.url.replace(/^http/, "ws")}${ROUTES.socket(this.settings.hub)}?protocol=3`;
+		return new WebSocket(url, { headers: this.access });
 	}
 };
 //#endregion
@@ -334,58 +562,6 @@ function mergeThreeWay(current, base, incoming) {
 	};
 }
 //#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"),
-		/** The text of each version known.json names, in a file named by its content hash */
-		knownTexts: join(own, "known"),
-		queue: join(own, "queue.json"),
-		notices: join(own, "notices.jsonl"),
-		daemon: join(own, "daemon.json"),
-		/** 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;
-/**
-* Whether the client's file watcher watches inside the directory at `path`: one that may hold synced files, and
-* local/sync/ itself for the outbox; the directories under local/sync/ hold only the client's own files.
-*/
-const watchedDir = (path) => path === "local/sync" || mayHoldSynced(path);
-//#endregion
 //#region ../sync/dist/state.js
 /** Whether `entry` waits for the server: not one it refused. */
 const waiting = (entry) => entry.refused === void 0;
@@ -394,11 +570,14 @@ 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})$/;
+/** Protocols whose write requests read the same as the current one's: protocol 3 changed only how a snapshot is taken. */
+const SAME_WRITES = /* @__PURE__ */ new Set([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.
+* current one: protocol 2 writes the same requests, and 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
@@ -407,15 +586,26 @@ const LOCAL_MINUTE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})$/;
 * 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;
+	if (request.protocol !== 1) return onCurrentProtocol(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,
+		protocol: 3,
 		now
 	};
 }
+/**
+* A request an earlier version sent, or kept in `sent`, as it goes out now: on the current protocol when that protocol's
+* write requests read the same. The server leaves `protocol` out when it compares a request sent again with the first
+* (docs/sync-protocol.md "請求編號"), so it still answers it with the response it kept.
+*/
+function onCurrentProtocol(request) {
+	return SAME_WRITES.has(request.protocol) ? {
+		...request,
+		protocol: 3
+	} : request;
+}
 function readJson(file, fallback) {
 	if (!existsSync(file)) return fallback;
 	try {
@@ -462,6 +652,8 @@ function writeKnown(root, files) {
 	for (const name of held) if (!named.has(name)) rmSync(join(dir, name), { force: true });
 }
 const writeQueue = (root, entries) => writeJson(syncPaths(root).queue, { entries });
+const readRemote = (root) => readJson(syncPaths(root).remote, {}).files ?? {};
+const writeRemote = (root, files) => writeJson(syncPaths(root).remote, { files });
 /** 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 ?? [];
@@ -786,6 +978,10 @@ function exists(file) {
 	}
 }
 const HISTORY = 20;
+/** The statuses of a closed mainline, whose artifacts stay on the server until they are used */
+const CLOSED = /* @__PURE__ */ new Set(["done", "dropped"]);
+/** A mainline's own file, whose status says whether its artifacts stay on the server */
+const MAINLINE_FILE = /^mainlines\/([^/]+)\/mainline\.md$/;
 /** A text's short content hash, for traces. */
 const short = (text) => text == null ? String(text) : contentHash(text).slice(0, 7);
 /** How long after the file watcher's last event for a path the path is looked at, so a write in progress is not sent half done */
@@ -892,13 +1088,22 @@ function patchRequest(entry) {
 		text = merged.text;
 	}
 	return {
-		protocol: 2,
+		protocol: 3,
 		op: "file.patch",
 		path: entry.path,
 		base: entry.base,
 		text
 	};
 }
+/** Whether the server holds any file, by a snapshot taken with `held` named: one it sent, or one of `held` it did not name removed. */
+function holdsFiles(parts, held) {
+	const removed = /* @__PURE__ */ new Set();
+	for (const part of parts) for (const event of part.files) {
+		if (event.kind === "file" || event.kind === "listed") return true;
+		if (event.kind === "removed") removed.add(event.path);
+	}
+	return [...held.keys()].some((path) => !removed.has(path));
+}
 var SyncClient = class extends EventEmitter {
 	opts;
 	root;
@@ -921,6 +1126,22 @@ var SyncClient = class extends EventEmitter {
 	/** The confirmed versions of each path, oldest first, at most HISTORY; versions() adds what the outbox holds */
 	history = /* @__PURE__ */ new Map();
 	cloud = /* @__PURE__ */ new Map();
+	/** The content hash last worked out for a text the client named in a snapshot request, by path */
+	hashes = /* @__PURE__ */ new Map();
+	/**
+	* The text the last snapshot request named for each path, with what the server made of it: left out, as the same text
+	* it holds, or named removed. A file this client never synced, as one in a hub taken with git, that still holds that
+	* text holds the server's version, or one the server removed since; not a text written here (reconcile).
+	*/
+	snapshotAnswers = /* @__PURE__ */ new Map();
+	/**
+	* Whether this run started without known.json, as in a hub taken with git that never synced here. Only then does the
+	* first snapshot's `removed` for a file the client named tell of a file the server removed since the copy: the server
+	* names removed every path it does not have, so later, or with known.json, such a file is one created here.
+	*/
+	copied = false;
+	/** The server has no copy of the hub, which this environment, downloading on demand, does not upload (snapshotNow) */
+	uploadWanted = false;
 	/** 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 */
@@ -932,6 +1153,21 @@ var SyncClient = class extends EventEmitter {
 	chains = /* @__PURE__ */ new Map();
 	work = /* @__PURE__ */ new Set();
 	binaries = /* @__PURE__ */ new Set();
+	/**
+	* The files only on the server, by the hash of the server's text: artifacts of closed mainlines this client never
+	* had on disk and has not downloaded (onDemand). remote.json keeps them.
+	*/
+	remote = /* @__PURE__ */ new Map();
+	/**
+	* Files whose server text is on its way: listed by a snapshot although this client holds them, or being downloaded.
+	* No reconcile runs on them until the text is in, since the server has them and the client does not know what.
+	*/
+	awaiting = /* @__PURE__ */ new Set();
+	/** The status each mainline's file gives, by the file's text, read once per text */
+	statuses = /* @__PURE__ */ new Map();
+	/** The snapshot or download under way: one at a time, so neither takes in what the other holds a stale view of */
+	reading = Promise.resolve();
+	remoteTimer;
 	signatures = /* @__PURE__ */ new Map();
 	/** The outbox as last read from queue.json, which every writer of this machine appends to */
 	queue = [];
@@ -945,6 +1181,8 @@ var SyncClient = class extends EventEmitter {
 	sending = null;
 	ws = null;
 	connected = false;
+	/** The server closed the connection at its maximum age and the next one is opening (rejoin); not offline yet */
+	rejoining = false;
 	/** Whether a snapshot was taken on the current connection; cleared when a connection opens or is lost, and when one fails */
 	current = false;
 	/** No reconnecting: stop() or the test hook disconnect() */
@@ -1021,11 +1259,24 @@ var SyncClient = class extends EventEmitter {
 	}
 	/**
 	* 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.
+	* file, or undefined when the client does not know it, such as before the first snapshot, or for a file only on the
+	* server, whose text is not here.
 	*/
 	serverText(path) {
+		if (this.remote.has(path) || this.awaiting.has(path)) return void 0;
 		return this.cloud.has(path) ? this.cloud.get(path) : this.synced ? null : void 0;
 	}
+	/** How many files are only on the server, not downloaded here (onDemand). */
+	get remoteCount() {
+		return this.remote.size;
+	}
+	/**
+	* Whether the sync server has no copy of the hub and this environment, downloading on demand, waits for one that keeps
+	* every file to upload it.
+	*/
+	get waitingForUpload() {
+		return this.uploadWanted;
+	}
 	/** 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 });
@@ -1040,6 +1291,7 @@ var SyncClient = class extends EventEmitter {
 			}
 		}
 		await this.restoreKnown();
+		this.restoreRemote();
 		await this.whenFree(() => this.syncQueue());
 		await this.resumeRefusals();
 		if (this.opts.watch !== false) this.startWatcher();
@@ -1058,6 +1310,7 @@ var SyncClient = class extends EventEmitter {
 	* a file that still holds it gives it. What the outbox wrote, refused writes included, is read after it (restoreEntry).
 	*/
 	async restoreKnown() {
+		this.copied = !existsSync(this.paths.known);
 		for (const [path, hash] of Object.entries(readKnown(this.root))) {
 			const local = await this.readLocal(path);
 			const text = local.kind === "text" && contentHash(local.text) === hash ? local.text : readKnownText(this.root, hash);
@@ -1129,6 +1382,7 @@ var SyncClient = class extends EventEmitter {
 		clearTimeout(timer);
 		this.api.close();
 		this.saveKnownNow(true);
+		this.saveRemoteNow(true);
 	}
 	/** Test hook: drop the connection as a lost network would, and stay offline until reconnect(). */
 	disconnect() {
@@ -1162,13 +1416,16 @@ var SyncClient = class extends EventEmitter {
 		this.ws = ws;
 		this.ahead.clear();
 		let opened = false;
+		let openedAt = 0;
 		ws.addEventListener("open", () => {
 			if (this.closing) return ws.close();
 			opened = true;
+			openedAt = Date.now();
 			this.diagnosed = false;
 			this.connected = true;
+			this.rejoining = false;
 			this.current = false;
-			this.backoff = 500;
+			if (!this.uploadWanted) this.backoff = 500;
 			this.lastPong = Date.now();
 			clearInterval(this.pingTimer);
 			this.pingTimer = setInterval(() => this.ping(ws), 15e3);
@@ -1179,8 +1436,16 @@ var SyncClient = class extends EventEmitter {
 			this.track(this.resync().then(() => this.flushQueue()).then(() => this.emit("synced")).catch((error) => this.log(`could not sync: ${error.message}`)));
 		});
 		ws.addEventListener("message", (event) => {
-			if (this.ws === ws) this.onMessage(String(event.data));
+			if (this.ws === ws) this.onMessage(String(event.data), () => atMaxAge());
 		});
+		const atMaxAge = () => {
+			if (this.ws !== ws) return;
+			const age = Date.now() - openedAt;
+			if (age >= (this.opts.rejoinMinAgeMs ?? 1e4)) return this.rejoin(ws);
+			this.log(`the sync server closed a connection ${age} ms old at its maximum age; reconnecting after a pause`);
+			ws.close();
+			lost();
+		};
 		const lost = () => {
 			if (this.ws !== ws) return;
 			this.ws = null;
@@ -1191,23 +1456,46 @@ var SyncClient = class extends EventEmitter {
 			this.reconnectTimer = setTimeout(() => this.connect(), this.backoff * (.5 + Math.random()));
 			this.backoff = Math.min(this.backoff * 2, 1e4);
 		};
-		ws.addEventListener("close", lost);
+		ws.addEventListener("close", (event) => opened && event.code === SOCKET_MAX_AGE_CLOSE.code ? atMaxAge() : lost());
 		ws.addEventListener("error", lost);
 	}
+	/**
+	* The server closed the connection at its maximum age (SOCKET_MAX_AGE_CLOSE), told by its SocketClosing message or by
+	* the close, whichever comes first, on `ws`, the client's connection (connect's atMaxAge); the close itself may come
+	* seconds later, and does nothing then, as `ws` is no longer the client's connection. The next connection opens at once,
+	* through Cloudflare Access again, and its snapshot brings what changed meanwhile, as after any reconnect. The server
+	* was not lost: nothing is reported, and writers waiting for the server's answer keep waiting. Only when the next
+	* connection fails, as when Access refuses a revoked service token, is the client offline (markOffline).
+	*/
+	rejoin(ws) {
+		this.ws = null;
+		this.log("the sync server closed the connection at its maximum age; reconnecting");
+		ws.close();
+		this.markOffline(!this.stopped);
+		if (this.stopped) return;
+		clearTimeout(this.reconnectTimer);
+		this.connect();
+	}
 	diagnosed = false;
-	/** A connection refused before it opened says nothing about why; one plain request tells a wrong token apart. */
+	/** A connection refused before it opened says nothing about why; one plain request tells a refused service 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`));
+		this.api.check().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;
+	/**
+	* The connection is gone, so nothing is sent before the next one has its snapshot. With `rejoining` the next one is
+	* opening at once (rejoin): the client is not reported offline until that one fails too.
+	*/
+	markOffline(rejoining = false) {
+		const was = this.connected || this.rejoining;
 		this.connected = false;
+		this.rejoining = rejoining;
 		this.current = false;
 		clearInterval(this.pingTimer);
 		clearInterval(this.warmTimer);
 		for (const waiter of this.waiters) waiter.done();
 		this.waiters.clear();
+		if (rejoining) return;
 		if (was) this.log("offline");
 		this.emit("offline");
 	}
@@ -1227,7 +1515,8 @@ var SyncClient = class extends EventEmitter {
 			ws.send("ping");
 		} catch {}
 	}
-	onMessage(data) {
+	/** A message on the current connection; `atMaxAge` runs when it says the server is closing it at its maximum age. */
+	onMessage(data, atMaxAge) {
 		if (this.closing) return;
 		if (data === "pong") {
 			this.lastPong = Date.now();
@@ -1240,6 +1529,11 @@ var SyncClient = class extends EventEmitter {
 		} catch {
 			return;
 		}
+		if (typeof message !== "object" || message === null) return;
+		if ("closing" in message) {
+			if (message.closing?.code === SOCKET_MAX_AGE_CLOSE.code) atMaxAge();
+			return;
+		}
 		if (!Number.isInteger(message.seq)) return;
 		const seq = message.seq;
 		if (seq === this.hubSeq + 1) this.takenUpTo(seq);
@@ -1248,11 +1542,11 @@ var SyncClient = class extends EventEmitter {
 			this.track(this.resync());
 			return;
 		}
+		for (const event of message.files) this.receive(event, seq);
 		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. */
@@ -1263,7 +1557,9 @@ var SyncClient = class extends EventEmitter {
 	}
 	/**
 	* 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.
+	* one the client holds, such as a broadcast that arrives after a later snapshot, is left out. A file only on the
+	* server whose mainline is still closed gets its new hash, or leaves `remote` when removed; nothing is written here.
+	* A mainline's file that opens it again brings its artifacts here.
 	*/
 	receive(event, seq) {
 		if (event.kind === "dir") {
@@ -1277,10 +1573,21 @@ var SyncClient = class extends EventEmitter {
 			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);
+		if (this.remote.has(event.path) && !this.awaiting.has(event.path) && (text === null || this.staysRemote(event.path))) {
+			this.trace(`remote ${event.path} ${short(text)} seq ${seq}`);
+			if (text === null) this.remote.delete(event.path);
+			else this.remote.set(event.path, contentHash(text));
+			this.saveRemote();
+			return;
+		}
+		if (this.remote.delete(event.path)) this.saveRemote();
+		this.trace(`receive ${event.path} ${short(text)} seq ${seq}`);
+		this.awaiting.delete(event.path);
 		this.cloud.set(event.path, text);
 		this.schedule(event.path);
+		const mainline = MAINLINE_FILE.exec(event.path)?.[1];
+		if (mainline !== void 0 && this.remote.size > 0) this.fetchOpened(mainline);
 	}
 	/** Whether the client holds `path` as of the hub's `seq` or later. */
 	reached(path, seq) {
@@ -1369,41 +1676,145 @@ var SyncClient = class extends EventEmitter {
 		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.
+	* Take the hub as of the snapshot's seq, asking only for what differs from what the client holds (holdings). The
+	* snapshot comes in batches, each as of its own seq; the WebSocket was open before the first, so every change after
+	* it comes as a broadcast, and the first batch's seq is the one the whole snapshot is as of. A file the server sent,
+	* or named removed, is taken at its batch's seq; a file it left out holds what the client named, as of the first
+	* batch's seq; a file neither named nor sent is not on the server. A broadcast arriving meanwhile may be older or
+	* newer than either; each file keeps whichever version has the higher seq. A server without the hub first gets the
+	* local one.
+	*
+	* With onDemand, the artifacts of mainlines not known to be open come `listed` (listOnly), and the files only on the
+	* server are named by their hash, so one that has not changed is not mentioned. A listed file this client has no
+	* text of and never left on disk stays on the server (`remote`); any other listed file, as one held here, is
+	* downloaded before the snapshot ends, with the files only on the server whose mainline is open now. The first
+	* snapshot of a hub without known.json lists all of mainlines/, since the client may not know a mainline or its
+	* status yet: the mainlines' own files are downloaded after, then the artifacts of the open ones.
 	*/
-	async takeSnapshot() {
-		let snapshot;
+	takeSnapshot() {
+		return this.exclusive(() => this.snapshotNow());
+	}
+	async snapshotNow() {
+		let parts;
+		let held;
+		let have;
 		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;
+			held = await this.holdings();
+			for (const path of this.remote.keys()) if (held.has(path) || this.expected.get(path) !== void 0) this.remote.delete(path);
+			have = new Map([...held].map(([path, text]) => [path, this.hashOf(path, text)]));
+			for (const [path, hash] of this.remote) have.set(path, hash);
+			parts = await this.api.snapshot(have, { listOnly: this.listOnly(this.copied && !this.synced) });
+			if (upload > 0 || holdsFiles(parts, have)) break;
+			if (this.opts.settings.onDemand === true) {
+				if (!this.uploadWanted) {
+					this.uploadWanted = true;
+					this.problem({
+						kind: "upload-needed",
+						path: "",
+						message: `the sync server has no copy of hub ${this.opts.settings.hub}; this environment downloads on demand and may lack files, so it does not upload its copy. Run mainflow sync, with on-demand downloads off, in an environment that keeps every file of the hub, such as the one that commits it with git, to upload it; this one waits and syncs once the hub is there`
+					});
+				}
+				throw new Error("the sync server has no copy of the hub, and this environment downloads on demand, so it waits for one that keeps every file to upload it");
+			}
+			if (!await this.uploadIfEmpty()) break;
+		}
+		if (this.uploadWanted) {
+			this.uploadWanted = false;
+			this.backoff = 500;
 		}
 		if (this.closing) return;
-		const { seq, files } = snapshot;
+		const seq = parts[0].seq;
 		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 named = /* @__PURE__ */ new Set();
 		const present = /* @__PURE__ */ new Set();
-		for (const event of files) {
-			if (event.kind === "file") present.add(event.path);
-			this.receive(event, seq);
+		const wanted = /* @__PURE__ */ new Set();
+		let sent = 0;
+		this.snapshotAnswers.clear();
+		const fromCopy = this.copied && !this.synced;
+		for (const part of parts) for (const event of part.files) {
+			if (event.kind === "listed") {
+				named.add(event.path);
+				if (this.mayStay(event.path, held)) this.keepRemote(event.path, event.hash, part.seq);
+				else {
+					wanted.add(event.path);
+					this.awaiting.add(event.path);
+					if (part.seq > (this.fileSeq.get(event.path) ?? -1)) this.fileSeq.set(event.path, part.seq);
+				}
+				continue;
+			}
+			named.add(event.path);
+			if (event.kind === "file") {
+				present.add(event.path);
+				sent++;
+			}
+			if (event.kind === "removed" && fromCopy && held.has(event.path)) this.snapshotAnswers.set(event.path, {
+				text: held.get(event.path),
+				removed: true
+			});
+			this.receive(event, part.seq);
+		}
+		for (const [path, text] of held) {
+			if (named.has(path)) continue;
+			present.add(path);
+			this.snapshotAnswers.set(path, {
+				text,
+				removed: false
+			});
+			this.receive({
+				kind: "file",
+				path,
+				text
+			}, seq);
 		}
-		for (const path of /* @__PURE__ */ new Set([...this.cloud.keys(), ...this.expected.keys()])) if (!present.has(path) && isSynced(path)) this.receive({
+		for (const path of /* @__PURE__ */ new Set([...this.cloud.keys(), ...this.expected.keys()])) if (!present.has(path) && !named.has(path) && isSynced(path)) this.receive({
 			kind: "removed",
 			path
 		}, seq);
+		this.log(`took the snapshot at seq ${seq} in ${parts.length} batch${parts.length === 1 ? "" : "es"}: ${sent} files sent, ${present.size - sent} already held here${this.remote.size > 0 ? `, ${this.remote.size} only on the server` : ""}`);
 		this.takenUpTo(seq);
 		this.synced = true;
+		this.saveRemote();
+		await this.fetchWanted(wanted);
 		await this.settleUnsynced();
 		this.wake();
 		for (const path of await this.walk()) this.schedule(path);
 	}
 	/**
+	* The text the client holds of each synced file, which a snapshot request names by hash so the server leaves out what
+	* is the same (SnapshotRequest.have): the server's version this run last took in, else the version known.json names,
+	* else the file on disk, as in a hub cloned with git that never synced here. Only a text the client has is named,
+	* since a file the server leaves out holds the text named for it.
+	*/
+	async holdings() {
+		const held = /* @__PURE__ */ new Map();
+		for (const [path, text] of this.cloud) if (typeof text === "string" && isSynced(path)) held.set(path, text);
+		for (const [path, disk] of this.confirmed) if (!held.has(path) && disk?.text !== void 0 && isSynced(path)) held.set(path, disk.text);
+		for (const path of await this.walk()) {
+			if (held.has(path)) continue;
+			const local = await this.readLocal(path);
+			if (local.kind === "text") held.set(path, local.text);
+		}
+		return held;
+	}
+	/** The content hash of `text`, the one `path` was named with, worked out once per text. */
+	hashOf(path, text) {
+		const known = this.hashes.get(path);
+		if (known?.text === text) return known.hash;
+		const hash = contentHash(text);
+		this.hashes.set(path, {
+			text,
+			hash
+		});
+		return hash;
+	}
+	/**
 	* 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).
@@ -1483,6 +1894,8 @@ var SyncClient = class extends EventEmitter {
 	* each write an entry of its own; the server's version waits while the outbox has a write about the file (I4).
 	*/
 	async reconcile(path) {
+		if (this.awaiting.has(path)) return;
+		if (this.remote.has(path)) return this.reconcileRemote(path);
 		const local = await this.readLocal(path);
 		if (local.kind === "binary") {
 			await sleep$1(BINARY_RECHECK_MS);
@@ -1506,7 +1919,21 @@ var SyncClient = class extends EventEmitter {
 				return;
 			}
 			if (target === local.text) return this.adopt(path, local.text);
-			if (target === void 0) return;
+			if (!this.synced) return;
+			const answer = this.snapshotAnswers.get(path);
+			if (answer?.text === local.text && !this.pending(path)) {
+				this.snapshotAnswers.delete(path);
+				if (!answer.removed) {
+					this.adopt(path, local.text);
+					return this.schedule(path);
+				}
+				const saved = await this.saveConflict(path, local.text);
+				this.expected.set(path, {
+					hash: contentHash(local.text),
+					text: local.text
+				});
+				return this.replace(path, null, saved);
+			}
 			return this.queueLocal(path, local.text, { start: target === null ? null : {
 				text: local.text,
 				server: local.text
@@ -1622,16 +2049,294 @@ var SyncClient = class extends EventEmitter {
 			message: `${path} is not UTF-8 text, so it is not synced and not overwritten; other environments do not see it`
 		});
 	}
+	/**
+	* Whether mainline `dir` is open, closed (done or dropped) or of a status the client does not know, by its
+	* mainline.md: the server's text the client took in, else the file here.
+	*/
+	mainlineState(dir) {
+		const path = `mainlines/${dir}/mainline.md`;
+		const taken = this.cloud.get(path);
+		let text;
+		if (typeof taken === "string") text = taken;
+		else if (taken === void 0) try {
+			text = readFileSync(join(this.paths.data, path), "utf8");
+		} catch {
+			text = void 0;
+		}
+		if (text === void 0) return "unknown";
+		let known = this.statuses.get(dir);
+		if (known?.text !== text) {
+			let status = null;
+			try {
+				const data = splitFrontMatter(text).data;
+				if (typeof data?.status === "string") status = data.status;
+			} catch {}
+			known = {
+				text,
+				status
+			};
+			this.statuses.set(dir, known);
+		}
+		return known.status === null ? "unknown" : CLOSED.has(known.status) ? "closed" : "open";
+	}
+	/**
+	* Whether `path`, a file only on the server, stays there: with onDemand on, an artifact of a mainline not known to be
+	* open. One whose mainline.md tells no status, or is not there, stays too; sync fetch downloads it.
+	*/
+	staysRemote(path) {
+		const mainline = artifactOf(path);
+		return this.opts.settings.onDemand === true && mainline !== null && this.mainlineState(mainline) !== "open";
+	}
+	/**
+	* Whether a file a snapshot listed may stay on the server: an artifact of a mainline not known to be open, of which
+	* the client holds no text (`held`, the server's text taken in), never left a file on disk, and has no write about.
+	*/
+	mayStay(path, held) {
+		if (!this.staysRemote(path)) return false;
+		return !(held?.has(path) ?? false) && typeof this.cloud.get(path) !== "string" && this.expected.get(path) === void 0 && !this.pending(path);
+	}
+	/** Note `path` as only on the server, with the hash of the server's text as of `seq`, unless a newer version came. */
+	keepRemote(path, hash, seq) {
+		if (seq <= (this.fileSeq.get(path) ?? -1)) return;
+		this.fileSeq.set(path, seq);
+		this.remote.set(path, hash);
+		this.cloud.delete(path);
+		this.awaiting.delete(path);
+		this.trace(`remote ${path} ${hash.slice(0, 7)} seq ${seq}`);
+	}
+	/**
+	* The prefixes a snapshot asks to list (SnapshotRequest.listOnly): the artifacts directories of every mainline not
+	* known to be open, its own and each task's the client knows of, or all of mainlines/ when `broad`. None without
+	* onDemand.
+	*/
+	listOnly(broad) {
+		if (this.opts.settings.onDemand !== true) return void 0;
+		if (broad) return ["mainlines/"];
+		const prefixes = /* @__PURE__ */ new Set();
+		const states = /* @__PURE__ */ new Map();
+		for (const path of /* @__PURE__ */ new Set([
+			...this.cloud.keys(),
+			...this.remote.keys(),
+			...this.expected.keys()
+		])) {
+			const match = /^mainlines\/([^/]+)\/(tasks\/[^/]+\/)?/.exec(path);
+			if (!match) continue;
+			const [, mainline, task] = match;
+			if (!states.has(mainline)) states.set(mainline, this.mainlineState(mainline));
+			if (states.get(mainline) === "open") continue;
+			prefixes.add(`mainlines/${mainline}/artifacts/`);
+			if (task) prefixes.add(`mainlines/${mainline}/${task}artifacts/`);
+		}
+		return [...prefixes].sort(comparePaths);
+	}
+	/** Run `fn`, a snapshot or a download, after the one before it, so neither takes in a range the other changed under it. */
+	exclusive(fn) {
+		const run = this.reading.then(fn, fn);
+		this.reading = run.catch(() => {});
+		return run;
+	}
+	/**
+	* Download what a snapshot listed although it may not stay on the server (`listed`), with the files only on the
+	* server that do not stay there: their mainline is known to be open now, or onDemand is off. A download may tell the status of
+	* more mainlines, as the mainlines' own files a first snapshot only listed do, so it is repeated while it finds more,
+	* three times at most; what is left waits for the next snapshot.
+	*/
+	async fetchWanted(listed) {
+		let wanted = listed;
+		for (let round = 0; round < 3 && !this.closing; round++) {
+			for (const path of this.remote.keys()) if (!this.staysRemote(path)) wanted.add(path);
+			if (wanted.size === 0) return;
+			this.log(`downloading ${wanted.size} file${wanted.size === 1 ? "" : "s"} the snapshot only listed or left on the server`);
+			wanted = (await this.fetchNow([...wanted])).again;
+		}
+	}
+	/**
+	* Download `targets` in one part of the snapshot, from the directory of the first to the last, naming every other
+	* file the client knows by its hash, so the server sends the targets and only what changed of the rest; the artifacts
+	* of closed mainlines other than the targets' stay listed. What comes is taken in as a broadcast of its batch's seq
+	* is: a target's text is written here, and a target named nowhere is not on the server, since the range covers it
+	* and `have` does not name it. Returns, besides, the files of other paths listed that may not stay on the server.
+	*/
+	async fetchNow(targets) {
+		const sorted = [...new Set(targets)].filter(isSynced).sort(comparePaths);
+		const again = /* @__PURE__ */ new Set();
+		if (sorted.length === 0 || this.closing) return {
+			fetched: [],
+			gone: [],
+			again
+		};
+		const want = new Set(sorted);
+		for (const path of sorted) this.awaiting.add(path);
+		let done = false;
+		try {
+			const have = /* @__PURE__ */ new Map();
+			for (const [path, text] of this.cloud) if (typeof text === "string" && !want.has(path) && isSynced(path)) have.set(path, this.hashOf(path, text));
+			for (const [path, hash] of this.remote) if (!want.has(path)) have.set(path, hash);
+			const listOnly = this.listOnly(false)?.filter((prefix) => !sorted.some((path) => path.startsWith(prefix)));
+			const first = sorted[0];
+			const after = first.includes("/") ? first.slice(0, first.lastIndexOf("/")) : void 0;
+			const parts = await this.api.snapshot(have, {
+				listOnly,
+				after,
+				through: sorted.at(-1)
+			});
+			if (this.closing) return {
+				fetched: [],
+				gone: [],
+				again
+			};
+			const mentioned = /* @__PURE__ */ new Set();
+			const fetched = [];
+			for (const part of parts) for (const event of part.files) {
+				if (event.kind === "dir") {
+					this.receive(event, part.seq);
+					continue;
+				}
+				mentioned.add(event.path);
+				if (event.kind === "listed") {
+					if (want.has(event.path)) continue;
+					if (this.mayStay(event.path)) this.keepRemote(event.path, event.hash, part.seq);
+					else again.add(event.path);
+					continue;
+				}
+				if (want.has(event.path)) {
+					this.remote.delete(event.path);
+					if ((this.fileSeq.get(event.path) ?? -1) <= part.seq) this.fileSeq.delete(event.path);
+					if (event.kind === "file") fetched.push(event.path);
+				}
+				this.receive(event, part.seq);
+			}
+			const gone = [];
+			for (const path of sorted) {
+				if (mentioned.has(path)) continue;
+				if (this.remote.delete(path)) gone.push(path);
+				else this.receive({
+					kind: "removed",
+					path
+				}, parts[0].seq);
+			}
+			this.saveRemote();
+			done = true;
+			if (fetched.length + gone.length > 0) this.log(`downloaded ${fetched.length} file${fetched.length === 1 ? "" : "s"}${gone.length > 0 ? `; ${gone.length} no longer on the server` : ""}`);
+			return {
+				fetched,
+				gone,
+				again
+			};
+		} finally {
+			for (const path of sorted) {
+				if (done || this.remote.has(path)) this.awaiting.delete(path);
+				this.schedule(path);
+			}
+		}
+	}
+	/**
+	* Download the files only on the server that `specs` name: a path, or a directory with every such file under it.
+	* `opened` downloads only the ones that no longer stay on the server, as the artifacts of a mainline opened again.
+	*/
+	fetchPaths(specs, opened = false) {
+		return this.exclusive(async () => {
+			const covers = (spec, path) => path === spec || path.startsWith(spec.endsWith("/") ? spec : `${spec}/`);
+			const targets = [...this.remote.keys()].filter((path) => specs.some((spec) => covers(spec, path)) && !(opened && this.staysRemote(path)));
+			const none = specs.filter((spec) => !targets.some((path) => covers(spec, path)));
+			if (targets.length === 0) return {
+				fetched: [],
+				gone: [],
+				none
+			};
+			const { fetched, gone } = await this.fetchNow(targets);
+			return {
+				fetched,
+				gone,
+				none
+			};
+		});
+	}
+	/**
+	* Download the files only on the server that `specs` name (fetchPaths), and resolve once each is written here: for
+	* `mainflow sync fetch` and the PreToolUse hook. Offline, or when the server cannot be reached, nothing is
+	* downloaded and `error` says why.
+	*/
+	async fetch(specs) {
+		const covers = (spec) => [...this.remote.keys(), ...this.awaiting].some((path) => path === spec || path.startsWith(spec.endsWith("/") ? spec : `${spec}/`));
+		if (!specs.some(covers)) return {
+			fetched: [],
+			gone: [],
+			none: specs
+		};
+		if (!this.online) return {
+			fetched: [],
+			gone: [],
+			none: [],
+			error: "mainflow sync is offline: the sync server cannot be reached now"
+		};
+		let result;
+		try {
+			result = await this.fetchPaths(specs);
+		} catch (error) {
+			return {
+				fetched: [],
+				gone: [],
+				none: [],
+				error: error.message
+			};
+		}
+		await Promise.allSettled(result.fetched.map((path) => this.chains.get(path) ?? Promise.resolve()));
+		return {
+			fetched: result.fetched.filter((path) => existsSync(join(this.paths.data, path))),
+			gone: result.gone,
+			none: result.none
+		};
+	}
+	/** Mainline `dir`'s file came: when it opens the mainline, its artifacts only on the server come here. */
+	fetchOpened(dir) {
+		if (this.closing || this.opts.settings.onDemand === true && this.mainlineState(dir) !== "open") return;
+		const prefix = `mainlines/${dir}/`;
+		if (![...this.remote.keys()].some((path) => path.startsWith(prefix))) return;
+		this.track(this.fetchPaths([prefix], true).catch((error) => this.log(`could not download the artifacts of ${dir}: ${error.message}; the next snapshot does`)));
+	}
+	/**
+	* A file only on the server that a program wrote here, without downloading it first. Its text is downloaded, so it is
+	* reconciled as a file never synced here is: kept when the server holds that text among its recent ones, and
+	* otherwise refused, saved and reported, never sent over the server's text unseen. Offline, it waits: the next
+	* snapshot names the file here by its own hash and downloads the server's text.
+	*/
+	async reconcileRemote(path) {
+		if ((await this.readLocal(path)).kind === "absent") return;
+		if (!this.caughtUp) return;
+		this.log(`${path}: written here while only on the server; downloading the server's text first`);
+		await this.fetchPaths([path]).catch((error) => this.log(`${path}: could not download it: ${error.message}`));
+	}
+	restoreRemote() {
+		for (const [path, hash] of Object.entries(readRemote(this.root))) if (isSynced(path) && artifactOf(path) !== null && this.expected.get(path) === void 0) this.remote.set(path, hash);
+	}
+	saveRemote() {
+		if (this.remoteTimer) return;
+		this.remoteTimer = setTimeout(() => this.saveRemoteNow(), 200);
+	}
+	saveRemoteNow(final = false) {
+		if (this.abandoned && !final) return;
+		clearTimeout(this.remoteTimer);
+		this.remoteTimer = void 0;
+		if (this.remote.size === 0 && !existsSync(this.paths.remote)) return;
+		try {
+			writeRemote(this.root, Object.fromEntries([...this.remote].sort(([a], [b]) => comparePaths(a, b))));
+		} catch (error) {
+			this.log(`could not save local/sync/remote.json: ${error.message}`);
+		}
+	}
 	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.
+	* Put the server's version of `path` on disk, or remove the file for null. 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. `unsynced` names where the text of a never synced file the server no longer has was saved: the writer is
+	* told of it once the file is removed, and it is deleted again when a write in the outbox keeps the file instead.
 	*/
-	async replace(path, target) {
+	async replace(path, target, unsynced) {
 		const file = join(this.paths.data, path);
 		const temp = this.tempName();
 		this.trace(`replacing ${path} with ${short(target)}`);
@@ -1647,8 +2352,18 @@ var SyncClient = class extends EventEmitter {
 			throw error;
 		}
 		if (step.kind === "exists" || step.kind === "missing") return this.schedule(path);
-		if (step.kind === "linked" || step.kind === "kept") return;
+		if (step.kind === "kept") {
+			if (unsynced !== void 0) await rm(join(this.paths.data, unsynced), { force: true });
+			return;
+		}
+		if (step.kind === "linked") return;
 		if (step.kind === "removed") {
+			if (unsynced !== void 0) this.problem({
+				kind: "removed-unsynced",
+				path,
+				saved: unsynced,
+				message: `${path} was never synced here and the sync server no longer has it, so it was removed here too; its text was saved to ${unsynced}`
+			});
 			if (step.moved !== null && step.disk && contentHash(step.moved) !== step.disk.hash) {
 				const saved = await this.saveConflict(path, step.moved);
 				this.problem({
@@ -2351,7 +3066,7 @@ var SyncClient = class extends EventEmitter {
 		} 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" };
+		if (!(this.online || this.rejoining) || Date.now() >= deadline) return answered() ?? { state: "waiting" };
 		this.track(this.flushQueue());
 		return new Promise((resolve) => {
 			const finish = (outcome) => {
@@ -2425,7 +3140,7 @@ var SyncClient = class extends EventEmitter {
 	prepare(entry) {
 		if (entry.kind === "op") return currentRequest(entry.request);
 		if (entry.kind === "remove") return {
-			protocol: 2,
+			protocol: 3,
 			op: "file.remove",
 			input: {
 				path: entry.path,
@@ -2434,7 +3149,7 @@ var SyncClient = class extends EventEmitter {
 			now: requestTime()
 		};
 		if (entry.replace) return {
-			protocol: 2,
+			protocol: 3,
 			op: "text.replace",
 			path: entry.path,
 			old: entry.replace.old,
@@ -2554,7 +3269,7 @@ var SyncClient = class extends EventEmitter {
 	}
 	/** 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 request = onCurrentProtocol(entry.sent);
 		const paths = entryPaths(entry);
 		if (!again && entry.kind === "patch" && request.op === "file.patch") this.trace(`patch ${entry.path} ${entry.id} base ${request.base?.slice(0, 7) ?? "null"} text ${short(request.text)} writer ${short(entry.text)} baseText ${short(entry.baseText ?? null)}`);
 		for (const path of paths) this.inflight.set(path, (this.inflight.get(path) ?? 0) + 1);
@@ -3079,8 +3794,11 @@ async function serveIpc(root, client) {
 				caughtUp: client.caughtUp,
 				queued: client.queued,
 				swapping: client.swapping,
-				problems: client.problems.length
+				problems: client.problems.length,
+				remote: client.remoteCount,
+				waitingForUpload: client.waitingForUpload
 			});
+			if (req.url === "/fetch") return reply(200, await client.fetch(Array.isArray(body.paths) ? body.paths.map(String) : []));
 			if (req.url === "/file") return reply(200, { text: client.serverText(String(body.path)) });
 			return reply(404, { error: `no route ${req.url}` });
 		} catch (error) {
@@ -3147,6 +3865,22 @@ const FILE_TOOLS = /* @__PURE__ */ new Set([
 	"MultiEdit",
 	"NotebookEdit"
 ]);
+/** Tools that read or write the one file named in file_path, which must be here before they run. */
+const FETCH_TOOLS = /* @__PURE__ */ new Set([
+	"Read",
+	"Edit",
+	"Write",
+	"MultiEdit"
+]);
+/** The file of the hub at `root` that `payload` names in file_path, relative to .mainflow/; null outside it. */
+function hubPath(root, payload) {
+	const input = payload.tool_input ?? {};
+	if (typeof input.file_path !== "string") return null;
+	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)) return null;
+	return path;
+}
 /**
 * 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
@@ -3157,9 +3891,8 @@ function planFlush(root, payload) {
 	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 };
+	const path = hubPath(root, payload);
+	if (path === null || !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: {
@@ -3183,36 +3916,26 @@ function hookAnswer(result) {
 		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;
+/**
+* What to download before the tool in `payload` runs in the hub at `root`: the artifact it reads or writes, when the file
+* is not here, so it may be only on the sync server. Null for anything else, which needs nothing.
+*/
+function planFetch(root, payload) {
+	const tool = payload.tool_name ?? "";
+	if (!FETCH_TOOLS.has(tool)) return null;
+	const path = hubPath(root, payload);
+	if (path === null || !isSynced(path) || artifactOf(path) === null || existsSync(join(root, ".mainflow", path))) return null;
 	return {
-		url: url.replace(/\/+$/, ""),
-		token,
-		hub: hubName(root)
+		path,
+		write: tool !== "Read"
 	};
 }
+/** The PreToolUse answer that stops the tool, with `reason` for the agent. */
+const fetchDenial = (reason) => JSON.stringify({ hookSpecificOutput: {
+	hookEventName: "PreToolUse",
+	permissionDecision: "deny",
+	permissionDecisionReason: `mainflow sync: ${reason}`
+} });
 //#endregion
 //#region ../sync/dist/outbox.js
 /** Whether the hub at `root` writes through the sync server. */
@@ -3326,7 +4049,7 @@ const alive = (pid) => {
 };
 /**
 * 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
+* none. `env` gives the sync server and service 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) {
@@ -3368,8 +4091,7 @@ async function startSyncInBackground(root, env = process.env) {
 				],
 				env: {
 					...process.env,
-					[ENV.url]: env[ENV.url] ?? "",
-					[ENV.token]: env[ENV.token] ?? ""
+					...Object.fromEntries(Object.values(ENV).map((name) => [name, env[name] ?? ""]))
 				}
 			});
 			child.on("error", () => {});
@@ -3425,7 +4147,7 @@ function writtenLines(written) {
 	];
 }
 /**
-* The writer for the hub at `root`. `env` gives the sync server and token as the environment variables do; a hub
+* The writer for the hub at `root`. `env` gives the sync server and service 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.
 */
@@ -3441,7 +4163,7 @@ function hubWriter(root, env = process.env, options = {}) {
 		let queuedOp;
 		try {
 			queuedOp = queueOperation(root, {
-				protocol: 2,
+				protocol: 3,
 				op,
 				input,
 				now: requestTime()
@@ -3487,4 +4209,4 @@ function hubWriter(root, env = process.env, options = {}) {
 	};
 }
 //#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 };
+export { syncSettings as C, syncPaths as D, isSynced as E, hubName as S, SYNC_DIR as T, readRemote as _, remoteMode as a, ENV as b, planFetch as c, DaemonRunning as d, DaemonUnavailable as f, silentHint as g, readDaemon as h, queuedCount as i, planFlush as l, probeDaemon as m, hubWriter as n, fetchDenial as o, callDaemon as p, writtenLines as r, hookAnswer as s, CONFIRM_MS as t, startDaemon as u, ServerApi as v, SETTINGS_FILE as w, earlierToken as x, ServerError as y };