mainflow 0.43.0-alpha.4 → 0.44.0-alpha.1

package/dist/{operation-BhBbGauo.js → operation-BmCeGKHw.js}

@@ -1,4 +1,4 @@
-import { $t as WriteError, B as applyOffline, Bt as registeredName, Ct as readsAsText, G as scopeOfPath, Gt as nodeStorage, H as renumberFiles, J as syncedDir, K as hubDigest, Ot as hubRequirements, St as exceedsFileLimit, Tt as textBytes, U as renumberPath, V as renumberRequest, W as renumberText, X as applyOperation, Y as syncedPath, Zt as ConflictError, _t as MAX_FILE_BYTES, bt as VERSION_HEADER, en as contentHash, ht as MAX_BLOB_BYTES, kt as versionMismatch, mt as BLOB_HASH, pt as ACCESS_HEADERS, q as mayHoldSynced, tn as splitFrontMatter, ut as nowMinute, vt as ROUTES, wt as requestTime, xt as comparePaths, yt as SOCKET_MAX_AGE_CLOSE } from "./host-BJvqZy-i.js";
+import { At as hubRequirements, B as applyOffline, Ct as comparePaths, Dt as textBytes, Et as requestTime, G as scopeOfPath, H as renumberFiles, J as syncedDir, Jt as nodeStorage, K as hubDigest, St as VERSION_HEADER, Tt as readsAsText, U as renumberPath, Ut as registeredName, V as renumberRequest, W as renumberText, X as applyOperation, Y as syncedPath, _t as MAX_BLOB_BYTES, an as splitFrontMatter, bt as ROUTES, ft as nowMinute, gt as BLOB_HASH, ht as ACCESS_HEADERS, in as contentHash, jt as versionMismatch, q as mayHoldSynced, rn as WriteError, tn as ConflictError, wt as exceedsFileLimit, xt as SOCKET_MAX_AGE_CLOSE, yt as MAX_FILE_BYTES } from "./host-C74j2Qox.js";
 import { t as CLI_VERSION } from "./version-Dvv4jwF1.js";
 import { createHash, randomBytes } from "node:crypto";
 import { accessSync, appendFileSync, chmodSync, closeSync, constants, copyFileSync, createReadStream, createWriteStream, existsSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, watch, writeFileSync } from "node:fs";
@@ -8,8 +8,6 @@ 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 { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { EventEmitter } from "node:events";
@@ -253,6 +251,12 @@ function decoded(res) {
 	}
 	return decode ? res.pipe(decode()) : res;
 }
+/**
+* node:http and node:https load node:tls, which reads the system certificates when NODE_USE_SYSTEM_CA is set and
+* costs about 220 ms. Load them on the first request so commands that never reach the server do not pay for it.
+*/
+const http = () => process.getBuiltinModule("node:http");
+const https = () => process.getBuiltinModule("node:https");
 var ServerApi = class {
 	settings;
 	timeoutMs;
@@ -260,14 +264,14 @@ var ServerApi = class {
 	* The connection writes go on, kept open between them: opening one costs two round trips, for TCP and TLS. One
 	* connection at a time, since the client sends one write at a time; a request waits for the one before it.
 	*/
-	agent;
+	writeAgent;
 	/** The connections snapshots go on, apart from the writes', so a snapshot never waits behind a write or holds one up */
-	reads;
+	readAgent;
 	/**
 	* The connections binary files' contents go up and down on, apart from the writes' and the snapshots', so a large file
 	* holds neither up; a few at a time, as the files of a snapshot are downloaded side by side.
 	*/
-	transfers;
+	transferAgent;
 	/** Requests on `agent` not answered yet */
 	busy = 0;
 	transfer = {
@@ -277,28 +281,30 @@ var ServerApi = class {
 		body: 0,
 		sent: 0,
 		listed: 0,
-		unchanged: 0
+		unchanged: 0,
+		changes: 0
 	};
 	constructor(settings, timeoutMs = 3e4) {
 		this.settings = settings;
 		this.timeoutMs = timeoutMs;
-		const Agent$2 = settings.url.startsWith("https:") ? Agent$1 : Agent;
-		this.agent = new Agent$2({
-			keepAlive: true,
-			maxSockets: 1,
-			maxFreeSockets: 1
-		});
-		this.reads = new Agent$2({
-			keepAlive: true,
-			maxSockets: 2,
-			maxFreeSockets: 1
-		});
-		this.transfers = new Agent$2({
+	}
+	makeAgent(maxSockets) {
+		const { Agent } = this.settings.url.startsWith("https:") ? https() : http();
+		return new Agent({
 			keepAlive: true,
-			maxSockets: 4,
+			maxSockets,
 			maxFreeSockets: 1
 		});
 	}
+	get agent() {
+		return this.writeAgent ??= this.makeAgent(1);
+	}
+	get reads() {
+		return this.readAgent ??= this.makeAgent(2);
+	}
+	get transfers() {
+		return this.transferAgent ??= this.makeAgent(4);
+	}
 	/**
 	* The service token's headers, and the CLI's version when the settings name it (VERSION_HEADER), which every request
 	* and the WebSocket's upgrade carry. Never logged.
@@ -380,7 +386,7 @@ var ServerApi = class {
 	* the raw bytes of a stream, or nothing; `headers` add to the token's and say what the body is.
 	*/
 	open(method, url, body, headers, agent, timeoutMs) {
-		const send = url.startsWith("https:") ? request$1 : request;
+		const send = url.startsWith("https:") ? https().request : http().request;
 		return new Promise((resolve, reject) => {
 			const req = send(url, {
 				method,
@@ -406,7 +412,7 @@ var ServerApi = class {
 			"content-type": "application/json",
 			"content-length": String(Buffer.byteLength(body))
 		} : {};
-		if (agent === this.agent) this.busy++;
+		if (agent === this.writeAgent) this.busy++;
 		try {
 			const res = await this.open(method, url, body, {
 				...kind,
@@ -434,7 +440,7 @@ var ServerApi = class {
 				stream.on("error", reject);
 			});
 		} finally {
-			if (agent === this.agent) this.busy--;
+			if (agent === this.writeAgent) this.busy--;
 		}
 	}
 	/**
@@ -553,9 +559,9 @@ var ServerApi = class {
 	}
 	/** Close the kept connections; a later request opens others. */
 	close() {
-		this.agent.destroy();
-		this.reads.destroy();
-		this.transfers.destroy();
+		this.writeAgent?.destroy();
+		this.readAgent?.destroy();
+		this.transferAgent?.destroy();
 	}
 	/** Send one request; the response is the hub's answer, applied or refused. */
 	async send(request, options = {}) {
@@ -568,26 +574,13 @@ var ServerApi = class {
 		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;
-		if (body.unchanged === true) this.transfer.unchanged++;
+		if ("unchanged" in body && body.unchanged === true) this.transfer.unchanged++;
+		if ("changes" in body && body.changes === true) this.transfer.changes++;
 		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. A path of
-	* `have` the server never held a file at comes as `unknown` rather than `removed`, from a server that tells them apart.
-	* `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. `blobs` takes
-	* the binary files too, each that differs from `have` as `blob`; `have` names a binary file by its sha256 then.
-	* `digest` names the digest of `have` and the directories the client holds (hubDigest), asked on the first batch of a
-	* whole hub's snapshot with `blobs`: a server whose hub it is the digest of answers that nothing differs, and the
-	* snapshot is that one batch, with the client's directories as the entries, as the server would have listed them.
-	*/
 	async snapshot(have = /* @__PURE__ */ new Map(), options = {}) {
 		const paths = [...have.keys()].sort(comparePaths);
 		const { through } = options;
@@ -599,15 +592,26 @@ var ServerApi = class {
 				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 asking = options.digest !== void 0 && options.blobs === true && after === void 0;
-				const { seq, files, next, unchanged } = await this.batch({
+				const since = options.since !== void 0 && options.blobs === true && after === void 0 && attempt === 1 ? options.since : void 0;
+				const answer = await this.batch({
 					protocol: 3,
 					have: range,
 					unknown: true,
 					...after === void 0 ? {} : { after },
 					...asking ? { digest: options.digest.value } : {},
+					...since === void 0 ? {} : { since },
 					...options.listOnly?.length ? { listOnly: options.listOnly } : {},
 					...options.blobs ? { blobs: true } : {}
 				});
+				if ("changes" in answer && answer.changes === true) {
+					if (since === void 0) throw new Unreachable("the sync server answered a snapshot that named no since with what changed since", true);
+					return {
+						seq: answer.seq,
+						files: answer.files,
+						digest: answer.digest
+					};
+				}
+				const { seq, files, next, unchanged } = answer;
 				if (unchanged === true && asking) return [{
 					seq,
 					files: options.digest.dirs.map((path) => ({
@@ -1281,6 +1285,8 @@ function exists(file) {
 const isBlob = (file) => typeof file === "object" && file !== null && file.kind === "blob";
 /** The hash the server names a file of its by: a text's content hash, a binary file's sha256. */
 const serverHash = (file) => typeof file === "string" ? contentHash(file) : file.hash;
+/** Whether the client holds `held` as the server's version of a path, the same file as `file`. */
+const sameServerFile = (held, file) => held !== void 0 && held !== null && (typeof held === "string" ? held === file : isBlob(file) && held.hash === file.hash);
 /** Whether two tool calls are of one session, the same subagent in it or both of the session itself. */
 const sameCaller = (a, b) => a !== void 0 && b !== void 0 && a.session === b.session && a.agent === b.agent;
 /** Whether `edit` makes `to` of `from`, as the Edit tool makes it (applyEdit). */
@@ -1329,6 +1335,12 @@ const BINARY_RECHECK_MS = 150;
 * program that rewrites a file as `cat >` does empties it first and fills it a moment later
 */
 const EMPTY_RECHECK_MS = 300;
+/**
+* How long taking in what changed since a seq (takeChanges) waits for one step to be done on disk before the next, when
+* a path changes kind: the files removed before the directories, those before the directories made, and those before
+* the files written. A step that takes longer, as a file whose removal waits for the write lock, is not waited out.
+*/
+const CHANGES_STEP_MS = 5e3;
 /** How long after the exchange the displaced file is read again, for a program that still held it open */
 const LATE_WRITE_MS = 150;
 /**
@@ -1639,6 +1651,19 @@ var SyncClient = class extends EventEmitter {
 	dirCheck = null;
 	/** The hub's seq up to which the client has taken in every change: the last snapshot and the broadcasts after it */
 	hubSeq = -1;
+	/**
+	* Whether `cloud` and `remote` hold every file the server holds as of hubSeq, binary files included, and syncedDirs
+	* every directory, but for the paths changed after it: a whole snapshot with binary files was taken in this run, and
+	* nothing since made the client unsure of what it holds, as a server that stopped keeping binary files, or a hub
+	* reloaded. Only then is a snapshot asked for what changed since hubSeq (`since`), as a path the answer does not name
+	* holds what the client takes the server to hold. Not kept across runs: known.json names no seq.
+	*/
+	holdsHub = false;
+	/**
+	* How many reload broadcasts came (the hub replaced, migrated or restored): a snapshot under way when one comes does
+	* not leave the client holding the hub (holdsHub), whatever it took in, so the next one is whole.
+	*/
+	reloads = 0;
 	/** 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();
@@ -2091,6 +2116,8 @@ var SyncClient = class extends EventEmitter {
 		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.reloads++;
+			this.holdsHub = false;
 			this.track(this.resync());
 			return;
 		}
@@ -2175,7 +2202,7 @@ var SyncClient = class extends EventEmitter {
 			return;
 		}
 		this.knowDir(path);
-		this.track(mkdir(dir, { recursive: true }));
+		return this.track(mkdir(dir, { recursive: true }));
 	}
 	/**
 	* The server removed the directory at `path` as of the hub's `seq`, as a broadcast tells, or a snapshot that no longer
@@ -2188,7 +2215,7 @@ var SyncClient = class extends EventEmitter {
 		this.dirSeq.set(path, seq);
 		this.forgetDir(path);
 		this.trace(`dir ${path} removed seq ${seq}`);
-		this.track(this.whenFree(() => this.locked(() => this.removeEmptyDir(path))).catch((error) => this.log(`${path}/: ${error.message}`)));
+		return this.track(this.whenFree(() => this.locked(() => this.removeEmptyDir(path))).catch((error) => this.log(`${path}/: ${error.message}`)));
 	}
 	/** Remove the directory at `path` when nothing is in it; one gone already, or holding anything, stays as it is. True when it went. */
 	removeEmptyDir(path) {
@@ -2248,12 +2275,13 @@ var SyncClient = class extends EventEmitter {
 		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
+	* Take the server's hub, or only what changed in it since hubSeq (takeSnapshot), 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. The connection has its
+	* after the gap are forgotten and the snapshot is taken once more, whole, as it is. The connection has its
 	* snapshot once one ends while it is open (I1); one that fails leaves it without, and the client reconnects to take a
 	* fresh one, rather than send on the snapshot of an earlier connection.
 	*/
@@ -2276,6 +2304,7 @@ var SyncClient = class extends EventEmitter {
 					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();
+						this.holdsHub = false;
 						for (const [path, seq] of this.fileSeq) if (seq > this.hubSeq) this.fileSeq.delete(path);
 						for (const [path, seq] of this.dirSeq) if (seq > this.hubSeq) this.dirSeq.delete(path);
 						stalled = 0;
@@ -2346,12 +2375,24 @@ var SyncClient = class extends EventEmitter {
 	* upload (forgetBinaries), so they are files never synced here, sent as new even when this snapshot fails or the
 	* client is killed; and in the snapshot after the upload, a binary file of the client's the server names removed, as
 	* when it once held one there, is taken as one it never held (unheld), also in a run that started without known.json.
+	*
+	* Once a whole snapshot with binary files was taken in this run (holdsHub), the client holds every file and directory
+	* the server holds as of hubSeq, and the next snapshot, after a reconnect or a missed broadcast, asks for what changed
+	* since hubSeq alone (`since`). A server whose change log tells answers with the paths changed (SnapshotDelta): taken
+	* in over what the client holds once they make the hub's digest (changesHold, takeChanges), and else dropped for the
+	* whole snapshot. A server that cannot tell, or one from before it, answers the first batch, and the snapshot goes on
+	* whole as ever.
 	*/
 	takeSnapshot() {
 		return this.exclusive(() => this.snapshotNow());
 	}
 	async snapshotNow() {
-		let parts;
+		let parts = [];
+		/** What changed since `since`, when the server answered with it and it makes the hub's digest */
+		let delta = null;
+		let since;
+		/** What the client took the server to hold as of `since`, which `delta` is taken in over */
+		let deltaBase = null;
 		let held;
 		let heldBlobs;
 		let have;
@@ -2362,10 +2403,23 @@ var SyncClient = class extends EventEmitter {
 		/** Whether the snapshot is asked for with the binary files */
 		let withBlobs = false;
 		if (!this.probed) await this.probeBlobs();
+		/** The reload broadcasts that came before this snapshot: one that comes while it runs leaves the next one whole */
+		const reloads = this.reloads;
+		/**
+		* Whether the snapshot may ask for what changed since hubSeq, read once the probe told whether the server keeps
+		* binary files; not once an answer of it failed the digest
+		*/
+		let askChanges = this.holdsHub;
 		for (;;) {
 			before = this.hubSeq;
+			const base = askChanges && this.blobSupport === true && before >= 0 ? this.serverCopy() : null;
 			({texts: held, blobs: heldBlobs} = await this.holdings());
-			for (const path of this.remote.keys()) if (held.has(path) || heldBlobs.has(path) || this.expected.get(path) !== void 0) this.remote.delete(path);
+			let dropped = false;
+			for (const path of this.remote.keys()) {
+				if (!(held.has(path) || heldBlobs.has(path) || this.expected.get(path) !== void 0)) continue;
+				this.remote.delete(path);
+				dropped = true;
+			}
 			have = new Map([...held].map(([path, text]) => [path, this.hashOf(path, text)]));
 			for (const [path, blob] of heldBlobs) have.set(path, blob.hash);
 			for (const [path, hash] of this.remote) have.set(path, hash);
@@ -2379,11 +2433,25 @@ var SyncClient = class extends EventEmitter {
 				value: hubDigest(have, dirs),
 				dirs
 			} : void 0;
-			parts = await this.api.snapshot(have, {
+			since = base !== null && withBlobs && !dropped ? before : void 0;
+			const taken = await this.api.snapshot(have, {
 				listOnly: this.listOnly(this.copied && !this.synced),
-				blobs: this.blobSupport === true,
+				blobs: withBlobs,
+				since,
 				...digest ? { digest } : {}
 			});
+			if (!Array.isArray(taken)) {
+				const verdict = this.changesHold(taken, base);
+				if (verdict === "held") {
+					delta = taken;
+					deltaBase = base;
+					break;
+				}
+				this.log(verdict === "differs" ? `what changed since seq ${since} does not make the hub's digest; taking the whole snapshot` : `what changed since seq ${since} leaves the hub without files; taking the whole snapshot`);
+				askChanges = false;
+				continue;
+			}
+			parts = taken;
 			if (uploaded || holdsFiles(parts, have)) break;
 			if (this.opts.settings.onDemand === true) {
 				if (!this.uploadWanted) {
@@ -2411,7 +2479,7 @@ var SyncClient = class extends EventEmitter {
 			this.backoff = 500;
 		}
 		if (this.closing) return;
-		const seq = parts[0].seq;
+		const seq = delta !== null ? delta.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();
@@ -2419,94 +2487,102 @@ var SyncClient = class extends EventEmitter {
 			this.hubSeq = -1;
 			this.ahead.clear();
 		}
-		const named = /* @__PURE__ */ new Set();
-		const present = /* @__PURE__ */ new Set();
-		const wanted = /* @__PURE__ */ new Set();
-		let sent = 0;
-		this.snapshotAnswers.clear();
-		const fromCopy = this.copied && !this.synced;
-		const blobsFromCopy = withBlobs && !this.blobsCompared;
-		/** The directories the snapshot names: every one the server holds */
-		const dirs = /* @__PURE__ */ new Set();
-		for (const part of parts) for (const event of part.files) {
-			if (event.kind === "dir") {
-				named.add(event.path);
-				dirs.add(event.path);
-				this.receiveDir(event.path, part.seq, false);
-				continue;
-			}
-			if (!this.syncs(event.path)) continue;
-			if (event.kind === "listed") {
+		let wanted = /* @__PURE__ */ new Set();
+		if (delta !== null) {
+			const taken = await this.takeChanges(delta, deltaBase, held);
+			if (this.closing) return;
+			wanted = taken.wanted;
+			this.log(`took what changed since seq ${since} at seq ${seq}: ${delta.files.length} path${delta.files.length === 1 ? "" : "s"}, ${taken.sent} files sent${this.remote.size > 0 ? `, ${this.remote.size} only on the server` : ""}`);
+		} else {
+			const named = /* @__PURE__ */ new Set();
+			const present = /* @__PURE__ */ new Set();
+			let sent = 0;
+			this.snapshotAnswers.clear();
+			const fromCopy = this.copied && !this.synced;
+			const blobsFromCopy = withBlobs && !this.blobsCompared;
+			/** The directories the snapshot names: every one the server holds */
+			const dirs = /* @__PURE__ */ new Set();
+			for (const part of parts) for (const event of part.files) {
+				if (event.kind === "dir") {
+					named.add(event.path);
+					dirs.add(event.path);
+					this.receiveDir(event.path, part.seq, false);
+					continue;
+				}
+				if (!this.syncs(event.path)) continue;
+				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 (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);
+				if (event.kind === "file" || event.kind === "blob") {
+					present.add(event.path);
+					if (event.kind === "file") sent++;
 				}
-				continue;
-			}
-			named.add(event.path);
-			if (event.kind === "file" || event.kind === "blob") {
-				present.add(event.path);
-				if (event.kind === "file") sent++;
+				if (uploaded && event.kind === "removed" && heldBlobs.has(event.path)) {
+					this.receive({
+						kind: "unknown",
+						path: event.path
+					}, part.seq);
+					continue;
+				}
+				if (event.kind === "removed" && (held.has(event.path) ? fromCopy : blobsFromCopy && heldBlobs.has(event.path))) {
+					const text = held.get(event.path);
+					this.snapshotAnswers.set(event.path, {
+						hash: text === void 0 ? heldBlobs.get(event.path).hash : this.hashOf(event.path, text),
+						removed: true
+					});
+				}
+				this.receive(event, part.seq);
 			}
-			if (uploaded && event.kind === "removed" && heldBlobs.has(event.path)) {
+			for (const [path, text] of held) {
+				if (named.has(path)) continue;
+				present.add(path);
+				this.snapshotAnswers.set(path, {
+					hash: this.hashOf(path, text),
+					removed: false
+				});
 				this.receive({
-					kind: "unknown",
-					path: event.path
-				}, part.seq);
-				continue;
+					kind: "file",
+					path,
+					text
+				}, seq);
 			}
-			if (event.kind === "removed" && (held.has(event.path) ? fromCopy : blobsFromCopy && heldBlobs.has(event.path))) {
-				const text = held.get(event.path);
-				this.snapshotAnswers.set(event.path, {
-					hash: text === void 0 ? heldBlobs.get(event.path).hash : this.hashOf(event.path, text),
-					removed: true
+			for (const [path, blob] of heldBlobs) {
+				if (named.has(path)) continue;
+				present.add(path);
+				this.snapshotAnswers.set(path, {
+					hash: blob.hash,
+					removed: false
 				});
+				this.receive({
+					kind: "blob",
+					path,
+					hash: blob.hash,
+					size: blob.size ?? 0
+				}, seq);
 			}
-			this.receive(event, part.seq);
-		}
-		for (const [path, text] of held) {
-			if (named.has(path)) continue;
-			present.add(path);
-			this.snapshotAnswers.set(path, {
-				hash: this.hashOf(path, text),
-				removed: false
-			});
-			this.receive({
-				kind: "file",
-				path,
-				text
-			}, seq);
-		}
-		for (const [path, blob] of heldBlobs) {
-			if (named.has(path)) continue;
-			present.add(path);
-			this.snapshotAnswers.set(path, {
-				hash: blob.hash,
-				removed: false
-			});
-			this.receive({
-				kind: "blob",
-				path,
-				hash: blob.hash,
-				size: blob.size ?? 0
-			}, seq);
-		}
-		const blind = this.blobSupport !== true;
-		for (const path of /* @__PURE__ */ new Set([...this.cloud.keys(), ...this.expected.keys()])) {
-			if (present.has(path) || named.has(path) || !this.syncs(path)) continue;
-			if (blind && this.knownBinary(path)) continue;
-			this.receive({
-				kind: "removed",
-				path
-			}, seq);
+			const blind = this.blobSupport !== true;
+			for (const path of /* @__PURE__ */ new Set([...this.cloud.keys(), ...this.expected.keys()])) {
+				if (present.has(path) || named.has(path) || !this.syncs(path)) continue;
+				if (blind && this.knownBinary(path)) continue;
+				this.receive({
+					kind: "removed",
+					path
+				}, seq);
+			}
+			for (const path of this.syncedDirs) if (!dirs.has(path)) this.receiveDirRemoved(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` : ""}`);
 		}
-		for (const path of this.syncedDirs) if (!dirs.has(path)) this.receiveDirRemoved(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.holdsHub = withBlobs && this.reloads === reloads;
 		if (withBlobs && !this.blobsCompared) {
 			this.blobsCompared = true;
 			rmSync(this.paths.copyBlobs, { force: true });
@@ -2521,6 +2597,141 @@ var SyncClient = class extends EventEmitter {
 		await this.queueRemovedDirs();
 	}
 	/**
+	* What the client takes the server to hold, while it holds the hub (holdsHub): the server's version of each file it
+	* took in, a binary file's included, the hash of each file only on the server, and the directories the server holds.
+	* A file here the server never had is not among them, though a snapshot request names it.
+	*/
+	serverCopy() {
+		const files = /* @__PURE__ */ new Map();
+		for (const [path, file] of this.cloud) if (file !== null && this.syncs(path)) files.set(path, file);
+		return {
+			files,
+			remote: new Map(this.remote),
+			dirs: new Set(this.syncedDirs)
+		};
+	}
+	/**
+	* Whether the changes the server answered with (SnapshotDelta), taken in over what the client took it to hold as of
+	* `since` (`base`), make the hub's digest as of their seq (`held`), so they are the hub's whole difference; `differs`
+	* when they do not, as when the server's storage was put back to an earlier point; `empty` when they leave no file,
+	* which a whole snapshot tells apart from a server without the hub. A `dir`, `file` or `blob` replaces whatever kind
+	* the path held; `removed`, `unknown` and `dirRemoved` leave nothing there.
+	*/
+	changesHold(delta, base) {
+		const files = /* @__PURE__ */ new Map();
+		for (const [path, file] of base.files) files.set(path, isBlob(file) ? file.hash : this.hashOf(path, file));
+		for (const [path, hash] of base.remote) files.set(path, hash);
+		const dirs = new Set(base.dirs);
+		for (const entry of delta.files) {
+			const { path } = entry;
+			if (entry.kind === "file") files.set(path, contentHash(entry.text));
+			else if (entry.kind === "blob" || entry.kind === "listed") files.set(path, entry.hash);
+			else files.delete(path);
+			if (entry.kind === "dir") dirs.add(path);
+			else dirs.delete(path);
+		}
+		if (hubDigest(files, dirs) !== delta.digest) return "differs";
+		return [...files.keys()].some((path) => this.syncs(path)) ? "held" : "empty";
+	}
+	/**
+	* Take in what changed since the `since` a snapshot named (SnapshotDelta), once its digest showed that the client's
+	* copy with these changes is the hub as of their seq (changesHold). Only what the answer names changes: a path it does
+	* not name holds what the client took the server to hold (`base`), so nothing is made of a file here the answer does
+	* not name, as a whole snapshot makes of one it does not name. The changes are taken in in the order the server puts
+	* a hub back in (docs/sync-protocol.md "增量快照"): files removed, a file that turned into a directory among them;
+	* then directories removed, the deepest first, a directory that turned into a file among them; then directories made,
+	* the shallowest first; then files written, and binary files downloaded. When a directory comes or goes, each step
+	* waits for the one before to be done on disk, at most CHANGES_STEP_MS. An `unknown` path is not removed: a file here
+	* there is new to the server (receive). A path the answer does not name keeps the version `base` holds as of the
+	* answer's seq, as a whole snapshot's file left out as held does: a broadcast that changed it meanwhile and is no
+	* newer is undone, as it was undone on the server too, and an older one arriving later is not taken in. Returns the
+	* listed files to download, and how many texts came.
+	*/
+	async takeChanges(delta, base, held) {
+		const { seq } = delta;
+		const wanted = /* @__PURE__ */ new Set();
+		let sent = 0;
+		const depth = (path) => path.split("/").length;
+		const named = new Set(delta.files.map((entry) => entry.path));
+		for (const [path, file] of base.files) {
+			if (named.has(path) || (this.fileSeq.get(path) ?? -1) > seq) continue;
+			if (sameServerFile(this.cloud.get(path), file)) this.fileSeq.set(path, seq);
+			else this.receive(isBlob(file) ? {
+				kind: "blob",
+				path,
+				hash: file.hash,
+				size: file.size ?? 0
+			} : {
+				kind: "file",
+				path,
+				text: file
+			}, seq);
+		}
+		for (const [path, hash] of base.remote) {
+			if (named.has(path) || (this.fileSeq.get(path) ?? -1) > seq) continue;
+			if (this.remote.get(path) === hash) this.fileSeq.set(path, seq);
+			else this.keepRemote(path, hash, seq);
+		}
+		for (const path of base.dirs) {
+			if (named.has(path) || (this.dirSeq.get(path) ?? -1) > seq) continue;
+			if (this.syncedDirs.has(path)) this.dirSeq.set(path, seq);
+			else this.receiveDir(path, seq, false);
+		}
+		const gone = delta.files.flatMap((entry) => entry.kind === "dirRemoved" || (entry.kind === "file" || entry.kind === "blob" || entry.kind === "listed") && this.syncedDirs.has(entry.path) ? [entry.path] : []);
+		const made = delta.files.flatMap((entry) => entry.kind === "dir" ? [entry.path] : []);
+		const steps = gone.length > 0 || made.length > 0;
+		const done = (work) => steps && work.length > 0 ? Promise.race([Promise.allSettled(work), sleep$1(CHANGES_STEP_MS)]) : Promise.resolve();
+		const removed = [];
+		const isFile = (path) => (this.cloud.get(path) ?? null) !== null || this.remote.has(path);
+		for (const entry of delta.files) {
+			if (!this.syncs(entry.path)) continue;
+			if (entry.kind === "removed" || entry.kind === "unknown") this.receive(entry, seq);
+			else if (entry.kind === "dir" && isFile(entry.path)) this.receive({
+				kind: "removed",
+				path: entry.path
+			}, seq);
+			else continue;
+			removed.push(entry.path);
+		}
+		await done(removed.map((path) => this.chains.get(path)));
+		if (this.closing) return {
+			wanted,
+			sent
+		};
+		const rmdirs = [];
+		for (const path of gone.sort((a, b) => depth(b) - depth(a) || comparePaths(a, b))) rmdirs.push(this.receiveDirRemoved(path, seq));
+		await done(rmdirs);
+		if (this.closing) return {
+			wanted,
+			sent
+		};
+		const mkdirs = [];
+		for (const path of made.sort((a, b) => depth(a) - depth(b) || comparePaths(a, b))) mkdirs.push(this.receiveDir(path, seq, false));
+		await done(mkdirs);
+		if (this.closing) return {
+			wanted,
+			sent
+		};
+		for (const entry of delta.files) {
+			if (!this.syncs(entry.path)) continue;
+			if (entry.kind === "listed") {
+				if (this.mayStay(entry.path, held)) this.keepRemote(entry.path, entry.hash, seq);
+				else {
+					wanted.add(entry.path);
+					this.awaiting.add(entry.path);
+					if (seq > (this.fileSeq.get(entry.path) ?? -1)) this.fileSeq.set(entry.path, seq);
+				}
+			} else if (entry.kind === "file" || entry.kind === "blob") {
+				if (entry.kind === "file") sent++;
+				this.receive(entry, seq);
+			}
+		}
+		return {
+			wanted,
+			sent
+		};
+	}
+	/**
 	* Ask the server whether it keeps binary files (blobSupport), once per connection, before its snapshot. A probe that
 	* fails leaves what the last one found, null on a first connection, so the texts sync all the same and binary files
 	* wait as they are here: the snapshot is taken again after PROBE_RETRY_MS, doubling up to PROBE_RETRY_MAX_MS while it
@@ -2532,6 +2743,7 @@ var SyncClient = class extends EventEmitter {
 			await this.askBlobs();
 		} finally {
 			if (had !== true && this.blobSupport === true) this.fileSeq.clear();
+			if (had !== this.blobSupport) this.holdsHub = false;
 		}
 	}
 	async askBlobs() {
@@ -5596,7 +5808,7 @@ function callIn(body) {
 /** Serve `client` to this machine's mainflow commands until closed. */
 async function serveIpc(dirs, client) {
 	const secret = randomBytes(16).toString("hex");
-	const server = createServer(async (req, res) => {
+	const server = process.getBuiltinModule("node:http").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 = [];