mainflow 0.43.0 → 0.44.0-alpha.2

package/dist/{operation-BhBbGauo.js → operation-CUeOFEaf.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) => ({
@@ -916,6 +920,11 @@ const readKnownDirs = (hub) => {
 	const dirs = readJson(syncPaths(hub).known, {}).dirs;
 	return Array.isArray(dirs) ? dirs.filter((dir) => typeof dir === "string") : [];
 };
+/** The hub's seq known.json names (KnownFile.seq); undefined when it names none, or none that is a seq. */
+const readKnownSeq = (hub) => {
+	const seq = readJson(syncPaths(hub).known, {}).seq;
+	return Number.isInteger(seq) && seq >= 0 ? seq : void 0;
+};
 /** What known.json writes before a binary file's sha256, apart from a text's content hash. */
 const BLOB_PREFIX = "blob:";
 /** The text of the version known.json names by `hash`; undefined when it was not kept, as by a sync client before known/. */
@@ -932,9 +941,9 @@ function readKnownText(dirs, hash) {
 * there yet; the texts of versions it no longer names are removed. A version whose text the client does not have keeps
 * the text known/ holds, if any. The new texts go first, then known.json, then the removals, so a client killed at any
 * step leaves a known.json whose every text is in known/. A binary file is given as its sha256 with BLOB_PREFIX, and no text.
-* `dirs` are the directories it names.
+* `dirs` are the directories it names, and `seq` the hub's seq they are as of, written with them (KnownFile.seq).
 */
-function writeKnown(hub, files, dirs = []) {
+function writeKnown(hub, files, dirs = [], seq) {
 	const dir = syncPaths(hub).knownTexts;
 	mkdirSync(dir, { recursive: true });
 	const named = new Set(Object.values(files).map((file) => file.hash));
@@ -947,7 +956,8 @@ function writeKnown(hub, files, dirs = []) {
 	}
 	const known = {
 		files: Object.fromEntries(Object.entries(files).map(([path, file]) => [path, file.hash])),
-		...dirs.length > 0 ? { dirs } : {}
+		...dirs.length > 0 ? { dirs } : {},
+		...seq === void 0 ? {} : { seq }
 	};
 	writeJson(syncPaths(hub).known, known);
 	for (const name of held) if (!named.has(name)) rmSync(join(dir, name), { force: true });
@@ -1281,6 +1291,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 +1341,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 +1657,34 @@ 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. A run after it starts from known.json instead, which names the seq
+	* (knownSeq, resumeSeq).
+	*/
+	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 hub's seq known.json named when this run started (readKnownSeq): the files it names, its directories and
+	* remote.json are the hub as of it, so the run's first snapshot asks for what changed since, as one after a reconnect
+	* does (holdsHub). Undefined once a snapshot was taken, or when known.json names none or the run cannot take it, as
+	* when a text it names is not in known/.
+	*/
+	resumeSeq;
+	/**
+	* For each path, a seq at or before which the hub held another version than the one the client knows of now (in
+	* `cloud`, or `remote`): a broadcast's own seq, or, for a snapshot's, one after the seq of the version before it. A
+	* path whose known.json version lags behind is changed on the server after the seq known.json is written with
+	* (knownSeq), so what changed since names it.
+	*/
+	changedAt = /* @__PURE__ */ new Map();
 	/** 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();
@@ -1836,6 +1882,7 @@ var SyncClient = class extends EventEmitter {
 	async restoreKnown() {
 		this.copied = !existsSync(this.paths.known);
 		this.blobsCompared = !this.copied && !existsSync(this.paths.copyBlobs);
+		this.resumeSeq = this.blobsCompared ? readKnownSeq(this.dirs) : void 0;
 		for (const dir of readKnownDirs(this.dirs)) this.syncedDirs.add(dir);
 		for (const [path, hash] of Object.entries(readKnown(this.dirs))) {
 			if (hash.startsWith("blob:")) {
@@ -1859,7 +1906,9 @@ var SyncClient = class extends EventEmitter {
 				text,
 				server: text
 			});
+			else if (this.syncs(path)) this.resumeSeq = void 0;
 		}
+		if (this.resumeSeq !== void 0) this.log(`known.json is of the hub's seq ${this.resumeSeq}: the first snapshot asks for what changed since`);
 	}
 	/**
 	* The refusals a run killed before it settled them left in the outbox (src/state.ts): each text not saved yet is saved,
@@ -2091,12 +2140,15 @@ 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.resumeSeq = void 0;
 			this.track(this.resync());
 			return;
 		}
 		for (const event of message.files) if (event.kind === "dir") this.receiveDir(event.path, seq, true);
 		else if (event.kind === "dirRemoved") this.receiveDirRemoved(event.path, seq);
-		else this.receive(event, seq);
+		else this.receive(event, seq, true);
 		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());
@@ -2117,7 +2169,7 @@ var SyncClient = class extends EventEmitter {
 	* that may stay on the server, as a new screenshot of a closed mainline, goes into `remote` instead of being downloaded,
 	* as a listed text does in a snapshot.
 	*/
-	receive(event, seq) {
+	receive(event, seq, live = false) {
 		if (!this.syncs(event.path)) return;
 		const file = event.kind === "file" ? event.text : event.kind === "blob" ? {
 			kind: "blob",
@@ -2130,6 +2182,7 @@ var SyncClient = class extends EventEmitter {
 			this.trace(`older ${event.path} ${label} seq ${seq}, holding seq ${held}`);
 			return;
 		}
+		this.noteChange(event.path, file === null ? null : serverHash(file), live ? seq : held + 1);
 		this.fileSeq.set(event.path, seq);
 		if (this.downloadErrors.has(event.path)) {
 			const before = this.cloud.get(event.path);
@@ -2175,7 +2228,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 +2241,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) {
@@ -2211,6 +2264,16 @@ var SyncClient = class extends EventEmitter {
 	forgetDir(path) {
 		if (this.syncedDirs.delete(path)) this.saveKnown();
 	}
+	/** The hash the client knows the server's file at `path` by: of its version in `cloud`, or `remote`; null for none. */
+	serverView(path) {
+		const file = this.cloud.get(path);
+		if (file !== void 0 && file !== null) return serverHash(file);
+		return this.remote.get(path) ?? null;
+	}
+	/** The server's file at `path` is to be known by `hash` (null for none), a change of the hub at seq `at` or later (changedAt). */
+	noteChange(path, hash, at) {
+		if (this.serverView(path) !== hash) this.changedAt.set(path, at);
+	}
 	/** Whether the client holds `path` as of the hub's `seq` or later. */
 	reached(path, seq) {
 		return this.hubSeq >= seq || (this.fileSeq.get(path) ?? -1) >= seq;
@@ -2248,12 +2311,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 +2340,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 +2411,25 @@ 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. A run's first snapshot asks the same way from the seq known.json names (resumeSeq), taking known.json,
+	* remote.json and the directories known.json names for what the server held as of it (knownCopy).
 	*/
 	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 +2440,25 @@ 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 a seq: hubSeq while the client holds the hub, or the seq
+		* known.json names before the run's first snapshot (resumeSeq). Read once the probe told whether the server keeps
+		* binary files; not once an answer of it failed the digest
+		*/
+		let askChanges = this.holdsHub || this.resumeSeq !== void 0;
 		for (;;) {
 			before = this.hubSeq;
+			const from = !askChanges || this.blobSupport !== true ? null : this.holdsHub ? before >= 0 ? before : null : this.resumeSeq ?? null;
+			const base = from === null ? null : this.holdsHub ? this.serverCopy() : this.knownCopy();
 			({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 +2472,25 @@ var SyncClient = class extends EventEmitter {
 				value: hubDigest(have, dirs),
 				dirs
 			} : void 0;
-			parts = await this.api.snapshot(have, {
+			since = base !== null && from !== null && withBlobs && !dropped ? from : 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 +2518,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 +2526,104 @@ 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;
+		this.resumeSeq = void 0;
+		this.saveKnown();
 		if (withBlobs && !this.blobsCompared) {
 			this.blobsCompared = true;
 			rmSync(this.paths.copyBlobs, { force: true });
@@ -2521,6 +2638,167 @@ var SyncClient = class extends EventEmitter {
 		await this.queueRemovedDirs();
 	}
 	/**
+	* What the client takes the server to hold as of the seq known.json names, before the run's first snapshot
+	* (resumeSeq): the version known.json names of each file, but one only on the server (remote.json), and the
+	* directories it names; with what a broadcast taken in since the run started holds, which is of a later seq.
+	*/
+	knownCopy() {
+		const files = /* @__PURE__ */ new Map();
+		for (const [path, disk] of this.confirmed) {
+			if (!disk || !this.syncs(path) || this.remote.has(path)) continue;
+			if (disk.blob) files.set(path, {
+				kind: "blob",
+				hash: disk.hash
+			});
+			else if (disk.text !== void 0) files.set(path, disk.text);
+		}
+		for (const [path, file] of this.cloud) {
+			if (!this.syncs(path)) continue;
+			if (file === null) files.delete(path);
+			else files.set(path, file);
+		}
+		return {
+			files,
+			remote: new Map(this.remote),
+			dirs: new Set(this.syncedDirs)
+		};
+	}
+	/**
+	* 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 +2810,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() {
@@ -3025,7 +3304,9 @@ var SyncClient = class extends EventEmitter {
 	}
 	/** 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;
+		const held = this.fileSeq.get(path) ?? -1;
+		if (seq <= held) return;
+		this.noteChange(path, hash, held + 1);
 		this.fileSeq.set(path, seq);
 		this.remote.set(path, hash);
 		this.cloud.delete(path);
@@ -5476,12 +5757,39 @@ var SyncClient = class extends EventEmitter {
 		this.knownTimer = void 0;
 		const files = this.knownFiles();
 		const dirs = this.knownDirs();
+		const seq = this.knownSeq();
+		if (seq !== void 0) this.saveRemoteNow(final);
 		try {
-			underLock(this.dirs, () => writeKnown(this.dirs, files, dirs));
+			underLock(this.dirs, () => writeKnown(this.dirs, files, dirs, seq));
 		} catch (error) {
 			this.log(`could not save local/sync/known.json: ${error.message}`);
 		}
 	}
+	/**
+	* The hub's seq known.json is written with (KnownFile.seq): one as of which the files it names, its directories and
+	* remote.json are the hub's, but for paths changed on the server after it, so that what changed since names every
+	* path whose version there differs. Only while the client holds the hub (holdsHub) and no snapshot is under way, as
+	* the files it is taking in are of later seqs; and none while a listed file is being downloaded. It is hubSeq, or
+	* lower when a file's version known.json names is not the server's the client knows of, as one the outbox holds a
+	* write about while the server changed it: one before that change (changedAt). Undefined when there is none.
+	*/
+	knownSeq() {
+		if (!this.holdsHub || this.hubSeq < 0 || this.resyncing !== null || this.awaiting.size > 0) return void 0;
+		const listed = this.listedRemote();
+		let seq = this.hubSeq;
+		for (const path of /* @__PURE__ */ new Set([
+			...this.cloud.keys(),
+			...this.confirmed.keys(),
+			...this.remote.keys()
+		])) {
+			if (!this.syncs(path)) continue;
+			const disk = this.confirmed.get(path);
+			if ((listed.get(path) ?? (disk ? disk.hash : null)) === this.serverView(path)) continue;
+			seq = Math.min(seq, (this.changedAt.get(path) ?? 0) - 1);
+			if (seq < 0) return void 0;
+		}
+		return seq;
+	}
 };
 //#endregion
 //#region ../sync/dist/ipc.js
@@ -5512,30 +5820,75 @@ var DaemonUnavailable = class extends Error {
 };
 /** Another sync client already runs for the hub. */
 var DaemonRunning = class extends Error {};
+/** The answer's body could not be read to its end, after its status came. */
+var BodyUnread = class extends Error {};
+/**
+* One request to the sync client on the loopback interface, with the status and the whole body of its answer. It uses
+* node:http, taken when first called, rather than fetch: fetch loads undici and with it tls, and a process with
+* NODE_USE_SYSTEM_CA set reads the system's certificates when tls loads, which costs every hook that writes about 140 ms.
+* `agent: false` opens a connection for this request alone, so no kept-alive socket holds a short-lived command open.
+* No answer within `timeoutMs` rejects with an error named TimeoutError, which callDaemon takes as a silent sync client;
+* the time running out while the body is read rejects with BodyUnread, as does any failure reading it.
+*/
+function loopbackRequest(port, path, headers, body, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		let answered = false;
+		const request = process.getBuiltinModule("node:http").request({
+			host: "127.0.0.1",
+			port,
+			path,
+			method: body === void 0 ? "GET" : "POST",
+			headers,
+			agent: false
+		}, (response) => {
+			answered = true;
+			const chunks = [];
+			response.on("data", (chunk) => chunks.push(chunk));
+			response.on("end", () => {
+				clearTimeout(timer);
+				resolve({
+					status: response.statusCode ?? 0,
+					text: Buffer.concat(chunks).toString("utf8")
+				});
+			});
+			response.on("error", (error) => {
+				clearTimeout(timer);
+				reject(new BodyUnread(error.message));
+			});
+		});
+		const timer = setTimeout(() => {
+			const error = answered ? new BodyUnread("the answer did not end in time") : Object.assign(/* @__PURE__ */ new Error("The operation was aborted due to timeout"), { name: "TimeoutError" });
+			request.destroy(error);
+			reject(error);
+		}, timeoutMs);
+		request.on("error", (error) => {
+			clearTimeout(timer);
+			reject(answered ? new BodyUnread(error.message) : error);
+		});
+		request.end(body);
+	});
+}
 async function callDaemon(daemon, route, body, timeoutMs = 6e4) {
+	const notSync = () => new DaemonUnavailable(`what answers on port ${daemon.port} is not mainflow sync (pid ${daemon.pid})`);
 	let response;
 	try {
-		response = await fetch(`http://127.0.0.1:${daemon.port}${route}`, {
-			method: body === void 0 ? "GET" : "POST",
-			headers: {
-				[SECRET_HEADER]: daemon.secret,
-				"content-type": "application/json"
-			},
-			body: body === void 0 ? void 0 : JSON.stringify(body),
-			signal: AbortSignal.timeout(timeoutMs)
-		});
+		response = await loopbackRequest(daemon.port, route, {
+			[SECRET_HEADER]: daemon.secret,
+			"content-type": "application/json"
+		}, body === void 0 ? void 0 : JSON.stringify(body), timeoutMs);
 	} catch (error) {
+		if (error instanceof BodyUnread) throw notSync();
 		const silent = error.name === "TimeoutError";
 		throw new DaemonUnavailable(`mainflow sync (pid ${daemon.pid}) does not answer: ${error.message}`, silent);
 	}
 	let parsed;
 	try {
-		parsed = await response.json();
+		parsed = JSON.parse(response.text);
 	} catch {
-		throw new DaemonUnavailable(`what answers on port ${daemon.port} is not mainflow sync (pid ${daemon.pid})`);
+		throw notSync();
 	}
 	if (response.status === 403) throw new DaemonUnavailable(`what answers on port ${daemon.port} is not this hub's mainflow sync (pid ${daemon.pid})`);
-	if (!response.ok) throw new Error(`mainflow sync failed: ${parsed.error}`);
+	if (response.status < 200 || response.status > 299) throw new Error(`mainflow sync failed: ${parsed.error}`);
 	return parsed;
 }
 /** How long a probe waits for the sync client's answer; a client holding the write lock answers after it. */
@@ -5596,7 +5949,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 = [];