mainflow 0.32.0 → 0.32.1

package/dist/{operation-CuWhNoIa.js → operation-C0dUHUHg.js}

@@ -1,4 +1,4 @@
-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 { $ 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, at as requestTime, dt as DATA_DIR, et as MAX_FILE_BYTES, ft as WriteError, it as exceedsFileLimit, mt as splitFrontMatter, nt as SOCKET_MAX_AGE_CLOSE, ot as textBytes, pt as contentHash, rt as comparePaths, tt as ROUTES, ut as ConflictError, z as applyOperation } from "./host-C7GKIjSc.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";
@@ -12,6 +12,7 @@ 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";
+import ignore from "ignore";
 //#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";
@@ -373,7 +374,8 @@ var ServerApi = class {
 	* 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.
+	* 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.
 	*/
@@ -390,6 +392,7 @@ var ServerApi = class {
 				const { seq, files, next } = await this.batch({
 					protocol: 3,
 					have: range,
+					unknown: true,
 					...after === void 0 ? {} : { after },
 					...options.listOnly?.length ? { listOnly: options.listOnly } : {}
 				});
@@ -561,6 +564,135 @@ function mergeThreeWay(current, base, incoming) {
 	};
 }
 //#endregion
+//#region ../sync/dist/scope.js
+/** The name of a file of ignore rules. */
+const GITIGNORE = ".gitignore";
+const decoder$1 = new TextDecoder("utf-8", { fatal: true });
+/** The text of the file at `file`, or null when there is none or it cannot be read. */
+function readText(file) {
+	try {
+		return readFileSync(file, "utf8");
+	} catch {
+		return null;
+	}
+}
+/** The hub's ignore rules, by the directory of each .gitignore, as last read. */
+var SyncScope = class {
+	/** Each .gitignore's text and rules by its directory, relative to .mainflow/ with `/`, '' for .mainflow/ itself */
+	rules = /* @__PURE__ */ new Map();
+	/** Whether each path, a directory's ending in `/`, is ignored under the rules as they are */
+	decided = /* @__PURE__ */ new Map();
+	changes = 0;
+	/** How many times the rules changed: a caller that noted it tells whether they changed since. */
+	get generation() {
+		return this.changes;
+	}
+	/** The text of `dir`'s .gitignore as the rules have it, null for none. */
+	text(dir) {
+		return this.rules.get(dir)?.text ?? null;
+	}
+	/** Take `text` as the .gitignore of `dir`, null for none; true when that changes the rules. */
+	set(dir, text) {
+		if ((this.rules.get(dir)?.text ?? null) === text) return false;
+		if (text === null) this.rules.delete(dir);
+		else this.rules.set(dir, {
+			text,
+			matcher: ignore().add(text)
+		});
+		this.decided.clear();
+		this.changes++;
+		return true;
+	}
+	/** Forget the rules of every directory but `dirs`, as when a scan of the whole hub no longer finds the others. */
+	keepOnly(dirs) {
+		for (const dir of this.rules.keys()) if (!dirs.has(dir)) this.set(dir, null);
+	}
+	/** Whether the file at `path`, relative to .mainflow/, is synced: by the sync client's own rules, and not ignored. */
+	synced(path) {
+		return isSynced(path) && !this.ignored(path, false);
+	}
+	/** Whether a scan walks into the directory at `path`: one that may hold synced files, and not ignored. */
+	walks(path) {
+		return mayHoldSynced(path) && !this.ignored(path, true);
+	}
+	/** Whether git leaves the file or directory (`dir`) at `path` out: it, or a directory above it, is ignored. */
+	ignored(path, dir) {
+		if (path === "local" || path.startsWith("local/")) return false;
+		const parts = path.split("/");
+		if (parts.some((part) => part === "" || part === "." || part === "..")) return true;
+		const key = dir ? `${path}/` : path;
+		const known = this.decided.get(key);
+		if (known !== void 0) return known;
+		let out = false;
+		for (let n = 1; n <= parts.length && !out; n++) out = this.matches(parts, n, n < parts.length || dir);
+		this.decided.set(key, out);
+		return out;
+	}
+	/**
+	* Whether the rules ignore the first `n` parts of a path, a directory's when `dir`: each .gitignore above it in turn,
+	* from .mainflow/ down, the last one with a pattern that matches deciding.
+	*/
+	matches(parts, n, dir) {
+		if (parts[n - 1] === ".git") return true;
+		let out = false;
+		for (let depth = 0; depth < n; depth++) {
+			const rules = this.rules.get(parts.slice(0, depth).join("/"));
+			if (!rules) continue;
+			const test = rules.matcher.test(`${parts.slice(depth, n).join("/")}${dir ? "/" : ""}`);
+			if (test.ignored) out = true;
+			else if (test.unignored) out = false;
+		}
+		return out;
+	}
+	/**
+	* Read every .gitignore under `data`, the hub's .mainflow/, again, and return the synced files there; it walks only into
+	* the directories the rules leave in, as git does. Synchronous, for a start and for `mainflow check`.
+	*/
+	load(data) {
+		const files = [];
+		const dirs = /* @__PURE__ */ new Set();
+		const visit = (dir) => {
+			let entries;
+			try {
+				entries = readdirSync(join(data, dir), { withFileTypes: true });
+			} catch {
+				return;
+			}
+			dirs.add(dir);
+			this.set(dir, entries.some((entry) => entry.name === ".gitignore" && entry.isFile()) ? readText(join(data, dir, GITIGNORE)) : null);
+			for (const entry of entries) {
+				const path = dir ? `${dir}/${entry.name}` : entry.name;
+				if (entry.isDirectory()) {
+					if (this.walks(path)) visit(path);
+				} else if (entry.isFile() && this.synced(path)) files.push(path);
+			}
+		};
+		visit("");
+		this.keepOnly(dirs);
+		return files;
+	}
+};
+/**
+* The synced files of the hub at `root` larger than the sync server keeps (MAX_FILE_BYTES): UTF-8 text the hub's
+* .gitignore files leave in. The sync client leaves them out of sync; `mainflow check` warns of them.
+*/
+function oversizedFiles(root) {
+	const data = join(root, DATA_DIR);
+	const out = [];
+	for (const path of new SyncScope().load(data)) {
+		const file = join(data, path);
+		try {
+			if (statSync(file).size <= 19e5) continue;
+			const bytes = textBytes(decoder$1.decode(readFileSync(file)));
+			if (bytes > 19e5) out.push({
+				path,
+				bytes
+			});
+		} catch {}
+	}
+	return out;
+}
+//#endregion
 //#region ../sync/dist/state.js
 /** Whether `entry` waits for the server: not one it refused. */
 const waiting = (entry) => entry.refused === void 0;
@@ -1094,14 +1226,17 @@ function patchRequest(entry) {
 		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. */
+/**
+* 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 or unknown.
+*/
 function holdsFiles(parts, held) {
-	const removed = /* @__PURE__ */ new Set();
+	const missing = /* @__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);
+		if (event.kind === "removed" || event.kind === "unknown") missing.add(event.path);
 	}
-	return [...held.keys()].some((path) => !removed.has(path));
+	return [...held.keys()].some((path) => !missing.has(path));
 }
 var SyncClient = class extends EventEmitter {
 	opts;
@@ -1141,6 +1276,22 @@ var SyncClient = class extends EventEmitter {
 	copied = false;
 	/** The server has no copy of the hub, which this environment, downloading on demand, does not upload (snapshotNow) */
 	uploadWanted = false;
+	/** Why the server refused the upload of this environment's copy, as last reported (snapshotNow); null once it holds the hub */
+	uploadRefusal = null;
+	/** The hub's .gitignore files, which leave a file out of sync as they leave it out of git (src/scope.ts) */
+	scope = new SyncScope();
+	/**
+	* The generation of the rules (SyncScope.generation) the last snapshot was asked for under. A file the rules left out
+	* then was not taken in, whatever the server sent, nor a broadcast of it since; rules changed after it may let such a
+	* file in, so the snapshot is taken again (walk), and a file not taken in from the server waits for it (scopeStale).
+	*/
+	scopeTaken = -1;
+	/**
+	* The paths the server last named `unknown`: it holds no file there and never removed one. A file here at such a path
+	* is new to the server, whatever known.json says, as when another environment uploaded the hub to a new server
+	* without it; it is sent as new, never removed here. Only `removed` removes a file here.
+	*/
+	unheld = /* @__PURE__ */ new Set();
 	/** 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 */
@@ -1151,7 +1302,8 @@ var SyncClient = class extends EventEmitter {
 	inflight = /* @__PURE__ */ new Map();
 	chains = /* @__PURE__ */ new Map();
 	work = /* @__PURE__ */ new Set();
-	binaries = /* @__PURE__ */ new Set();
+	/** The files left out of sync and reported, by kind, path and content hash, so each is reported once */
+	skipped = /* @__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.
@@ -1241,6 +1393,20 @@ var SyncClient = class extends EventEmitter {
 	get online() {
 		return this.connected && !this.stopped;
 	}
+	/**
+	* Whether the file at `path` is synced: by the sync client's own rules (src/paths.ts) and the hub's .gitignore files as
+	* last read (src/scope.ts). Anything else is left as it is here, whatever the server holds.
+	*/
+	syncs(path) {
+		return this.scope.synced(path);
+	}
+	/**
+	* Whether the hub's .gitignore files changed since the last snapshot was asked for: a file they let in since may be on
+	* the server although the client took nothing of it in.
+	*/
+	get scopeStale() {
+		return this.scope.generation !== this.scopeTaken;
+	}
 	/** Writes waiting in the outbox for the server: not the ones it refused, which wait for nothing (src/state.ts). */
 	get queued() {
 		return this.queue.filter(waiting).length;
@@ -1289,6 +1455,7 @@ var SyncClient = class extends EventEmitter {
 				this.info("", `atomic exchange unavailable, writing with a rename: ${swapper.reason}`);
 			}
 		}
+		this.scope.load(this.paths.data);
 		await this.restoreKnown();
 		this.restoreRemote();
 		await this.whenFree(() => this.syncQueue());
@@ -1424,7 +1591,7 @@ var SyncClient = class extends EventEmitter {
 			this.connected = true;
 			this.rejoining = false;
 			this.current = false;
-			if (!this.uploadWanted) this.backoff = 500;
+			if (!this.uploadWanted && this.uploadRefusal === null) this.backoff = 500;
 			this.lastPong = Date.now();
 			clearInterval(this.pingTimer);
 			this.pingTimer = setInterval(() => this.ping(ws), 15e3);
@@ -1562,10 +1729,10 @@ var SyncClient = class extends EventEmitter {
 	*/
 	receive(event, seq) {
 		if (event.kind === "dir") {
-			if (event.path.split("/")[0] !== "local" || event.path === "local/sessions") this.track(mkdir(join(this.paths.data, event.path), { recursive: true }));
+			if ((event.path.split("/")[0] !== "local" || event.path === "local/sessions") && !this.scope.ignored(event.path, true)) this.track(mkdir(join(this.paths.data, event.path), { recursive: true }));
 			return;
 		}
-		if (!isSynced(event.path)) return;
+		if (!this.syncs(event.path)) return;
 		const text = event.kind === "file" ? event.text : null;
 		const held = this.fileSeq.get(event.path) ?? -1;
 		if (seq <= held) {
@@ -1573,6 +1740,8 @@ var SyncClient = class extends EventEmitter {
 			return;
 		}
 		this.fileSeq.set(event.path, seq);
+		if (event.kind === "unknown") this.unheld.add(event.path);
+		else this.unheld.delete(event.path);
 		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);
@@ -1630,9 +1799,10 @@ var SyncClient = class extends EventEmitter {
 	* reconciled: the server broadcasts a change after storing it, so a snapshot asked for later holds it. One that
 	* still does not, and brought nothing newer, is asked for again after a pause; after STALLED_SNAPSHOTS of them the
 	* server is taken to have lost those changes, as when its storage was replaced: the versions the client holds from
-	* after the gap are forgotten and the snapshot is taken once more, as it is. 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.
+	* after the gap are forgotten and the snapshot is taken once more, as it is. So is it when the hub's .gitignore files
+	* changed after it was asked for (scopeStale): a file they let in since was not taken in. The connection has its
+	* snapshot once one ends while it is open (I1); one that fails leaves it without, and the client reconnects to take a
+	* fresh one, rather than send on the snapshot of an earlier connection.
 	*/
 	resync() {
 		if (this.closing) return Promise.resolve();
@@ -1661,7 +1831,7 @@ var SyncClient = class extends EventEmitter {
 					this.log(`missed the hub's changes ${missing} while taking the snapshot; reloading it`);
 					if (stalled > 0) await sleep$1(250 * 2 ** (stalled - 1));
 					this.resyncAgain = true;
-				} while (this.resyncAgain && !this.closing);
+				} while ((this.resyncAgain || this.scopeStale) && !this.closing);
 				this.current = this.connected && !this.closing;
 			} catch (error) {
 				this.current = false;
@@ -1680,8 +1850,14 @@ var SyncClient = class extends EventEmitter {
 	* 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.
+	* newer than either; each file keeps whichever version has the higher seq. A path the server never held a file at
+	* (`unknown`) is one it has no file at: a file here, even one never synced or one known.json names, is sent as new and
+	* never removed (reconcile, unheld). What the
+	* client does not sync (syncs), as a file the hub's .gitignore leaves out, is not taken in, whatever the server sends.
+	*
+	* A server without the hub first gets the local one. When it refuses the upload and still holds no file, the snapshot
+	* fails without taking anything in: an empty hub would tell a copy without known.json to remove every file it holds.
+	* The writer is told why once, and the next connection tries again.
 	*
 	* 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
@@ -1698,14 +1874,20 @@ var SyncClient = class extends EventEmitter {
 		let held;
 		let have;
 		let before;
-		for (let upload = 0;; upload++) {
+		/** Whether the hub was uploaded, and why the server refused the upload; asked again, the snapshot may hold the hub */
+		let uploaded = false;
+		let refusal = null;
+		/** The rules' generation the snapshot is asked for under: what it holds is taken in as they leave it in */
+		let asked;
+		for (;;) {
 			before = this.hubSeq;
 			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);
+			asked = this.scope.generation;
 			parts = await this.api.snapshot(have, { listOnly: this.listOnly(this.copied && !this.synced) });
-			if (upload > 0 || holdsFiles(parts, have)) break;
+			if (uploaded || holdsFiles(parts, have)) break;
 			if (this.opts.settings.onDemand === true) {
 				if (!this.uploadWanted) {
 					this.uploadWanted = true;
@@ -1717,10 +1899,18 @@ var SyncClient = class extends EventEmitter {
 				}
 				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 (refusal !== null) {
+				this.refusedUpload(refusal);
+				throw new Error(`the sync server has no copy of the hub and refused its upload (${refusal}); nothing was taken in, and the next connection tries again`);
+			}
+			const answer = await this.uploadIfEmpty();
+			if (answer === null) break;
+			if (answer.ok) uploaded = true;
+			else refusal = answer.message;
 		}
-		if (this.uploadWanted) {
+		if (this.uploadWanted || this.uploadRefusal !== null) {
 			this.uploadWanted = false;
+			this.uploadRefusal = null;
 			this.backoff = 500;
 		}
 		if (this.closing) return;
@@ -1738,6 +1928,7 @@ var SyncClient = class extends EventEmitter {
 		this.snapshotAnswers.clear();
 		const fromCopy = this.copied && !this.synced;
 		for (const part of parts) for (const event of part.files) {
+			if (event.kind !== "dir" && !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);
@@ -1772,10 +1963,11 @@ var SyncClient = class extends EventEmitter {
 				text
 			}, seq);
 		}
-		for (const path of /* @__PURE__ */ new Set([...this.cloud.keys(), ...this.expected.keys()])) if (!present.has(path) && !named.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) && this.syncs(path)) this.receive({
 			kind: "removed",
 			path
 		}, seq);
+		this.scopeTaken = asked;
 		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;
@@ -1789,16 +1981,17 @@ var SyncClient = class extends EventEmitter {
 	* 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.
+	* since a file the server leaves out holds the text named for it; a file larger than the server keeps is not synced,
+	* so it is not named either.
 	*/
 	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, text] of this.cloud) if (typeof text === "string" && this.syncs(path)) held.set(path, text);
+		for (const [path, disk] of this.confirmed) if (!held.has(path) && disk?.text !== void 0 && this.syncs(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);
+			if (local.kind === "text" && !exceedsFileLimit(local.text)) held.set(path, local.text);
 		}
 		return held;
 	}
@@ -1814,9 +2007,11 @@ var SyncClient = class extends EventEmitter {
 		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).
+	* A server without the hub gets the local one: what the server answered, or null when there is nothing here to upload.
+	* 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). A file the client does not sync,
+	* or larger than the server keeps, stays out, so the server takes the rest. A refusal before the hub, such as a 400,
+	* is answered as a refusal; the server out of reach throws (Unreachable).
 	*/
 	async uploadIfEmpty() {
 		const files = {};
@@ -1826,23 +2021,46 @@ var SyncClient = class extends EventEmitter {
 			for (const [path, before] of Object.entries(entry.before ?? {})) if (!outbox.has(path)) outbox.set(path, before);
 		}
 		for (const path of /* @__PURE__ */ new Set([...await this.walk(), ...outbox.keys()])) {
+			if (!this.syncs(path)) continue;
 			if (outbox.has(path)) {
 				const before = outbox.get(path);
-				if (typeof before === "string") files[path] = before;
+				if (typeof before === "string" && !exceedsFileLimit(before)) files[path] = before;
 				continue;
 			}
 			const local = await this.readLocal(path);
-			if (local.kind === "text") files[path] = local.text;
+			if (local.kind === "text" && !exceedsFileLimit(local.text)) files[path] = local.text;
 		}
-		if (Object.keys(files).length === 0) return false;
+		if (Object.keys(files).length === 0) return null;
 		const dirs = await this.walkDirs();
-		const result = await this.api.upload(files, dirs);
+		let result;
+		try {
+			result = await this.api.upload(files, dirs);
+		} catch (error) {
+			if (!(error instanceof ServerError)) throw error;
+			result = {
+				ok: false,
+				message: error.message
+			};
+		}
 		if (!result.ok) {
 			this.log(`upload refused: ${result.message}`);
-			return false;
+			return {
+				ok: false,
+				message: result.message
+			};
 		}
 		this.log(`uploaded the hub: ${result.files} files`);
-		return true;
+		return { ok: true };
+	}
+	/** Tell the writer, once for each reason, that the server has no copy of the hub and refused this one (snapshotNow). */
+	refusedUpload(message) {
+		if (this.uploadRefusal === message) return;
+		this.uploadRefusal = message;
+		this.problem({
+			kind: "upload-refused",
+			path: "",
+			message: `the sync server has no copy of hub ${this.opts.settings.hub} and refused the upload of this environment's copy: ${message}. Nothing was taken in, removed or sent here; fix what the refusal names, and the next connection uploads the hub again`
+		});
 	}
 	/** Reconcile `path` after whatever earlier work on it has finished; nothing once stopping. */
 	schedule(path) {
@@ -1893,6 +2111,7 @@ 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.syncs(path)) return;
 		if (this.awaiting.has(path)) return;
 		if (this.remote.has(path)) return this.reconcileRemote(path);
 		const local = await this.readLocal(path);
@@ -1902,6 +2121,7 @@ var SyncClient = class extends EventEmitter {
 			if (again.kind !== "binary" || again.hash !== local.hash) return this.schedule(path);
 			return this.skipBinary(path, local.hash);
 		}
+		if (local.kind === "text" && exceedsFileLimit(local.text)) return this.skipLarge(path, local.text);
 		const seen = this.expected.get(path);
 		if (seen === void 0 ? local.kind !== "absent" : !this.matches(seen, local)) {
 			await this.whenFree(() => this.syncQueue());
@@ -1910,15 +2130,16 @@ var SyncClient = class extends EventEmitter {
 			const after = this.expected.get(path);
 			if (after !== seen && after !== void 0 && this.matches(after, local)) return this.schedule(path);
 		}
-		const target = this.cloud.has(path) ? this.cloud.get(path) : this.synced ? null : void 0;
+		const target = this.cloud.has(path) ? this.cloud.get(path) : this.synced && !this.scopeStale ? null : void 0;
 		const disk = this.expected.get(path);
+		const unheld = target === null && this.unheld.has(path);
 		if (disk === void 0) {
 			if (local.kind === "absent") {
 				if (typeof target === "string") await this.replace(path, target);
 				return;
 			}
 			if (target === local.text) return this.adopt(path, local.text);
-			if (!this.synced) return;
+			if (!this.synced || target === void 0) return;
 			const answer = this.snapshotAnswers.get(path);
 			if (answer?.text === local.text && !this.pending(path)) {
 				this.snapshotAnswers.delete(path);
@@ -1949,7 +2170,7 @@ var SyncClient = class extends EventEmitter {
 					const again = await this.readLocal(path);
 					if (again.kind !== "text" || again.text !== "") return this.schedule(path);
 				}
-				return this.queueLocal(path, local.text);
+				return this.queueLocal(path, local.text, unheld ? { start: null } : {});
 			}
 			if (target === null || disk === null) {
 				this.forget(path);
@@ -1968,6 +2189,7 @@ var SyncClient = class extends EventEmitter {
 			return this.release(path);
 		}
 		if (this.pending(path)) return;
+		if (unheld && local.kind === "text") return this.queueUnheld(path, local.text);
 		await this.replace(path, target);
 	}
 	/**
@@ -2039,15 +2261,25 @@ var SyncClient = class extends EventEmitter {
 		this.history.set(path, list);
 	}
 	skipBinary(path, hash) {
-		const key = `${path}:${hash}`;
-		if (this.binaries.has(key)) return;
-		this.binaries.add(key);
+		const key = `binary:${path}:${hash}`;
+		if (this.skipped.has(key)) return;
+		this.skipped.add(key);
 		this.problem({
 			kind: "skipped-binary",
 			path,
 			message: `${path} is not UTF-8 text, so it is not synced and not overwritten; other environments do not see it`
 		});
 	}
+	skipLarge(path, text) {
+		const key = `large:${path}:${contentHash(text)}`;
+		if (this.skipped.has(key)) return;
+		this.skipped.add(key);
+		this.problem({
+			kind: "skipped-large",
+			path,
+			message: `${path} is larger than the ${MAX_FILE_BYTES} bytes the sync server keeps of a file, so it is not synced and not overwritten; other environments do not see it. Split it, or add it to .mainflow/.gitignore`
+		});
+	}
 	/**
 	* 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.
@@ -2157,7 +2389,7 @@ var SyncClient = class extends EventEmitter {
 	* 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 sorted = [...new Set(targets)].filter((path) => this.syncs(path)).sort(comparePaths);
 		const again = /* @__PURE__ */ new Set();
 		if (sorted.length === 0 || this.closing) return {
 			fetched: [],
@@ -2169,7 +2401,7 @@ var SyncClient = class extends EventEmitter {
 		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, text] of this.cloud) if (typeof text === "string" && !want.has(path) && this.syncs(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];
@@ -2192,6 +2424,7 @@ var SyncClient = class extends EventEmitter {
 					continue;
 				}
 				mentioned.add(event.path);
+				if (!this.syncs(event.path)) continue;
 				if (event.kind === "listed") {
 					if (want.has(event.path)) continue;
 					if (this.mayStay(event.path)) this.keepRemote(event.path, event.hash, part.seq);
@@ -2307,7 +2540,7 @@ var SyncClient = class extends EventEmitter {
 		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);
+		for (const [path, hash] of Object.entries(readRemote(this.root))) if (this.syncs(path) && artifactOf(path) !== null && this.expected.get(path) === void 0) this.remote.set(path, hash);
 	}
 	saveRemote() {
 		if (this.remoteTimer) return;
@@ -2628,6 +2861,24 @@ var SyncClient = class extends EventEmitter {
 		this.trace(`local ${path} ${short(text)} changed before it was queued; reconciling it again`);
 		this.schedule(path);
 	}
+	/**
+	* Queue `path`, which holds `text` as the client left it there, as a new file: the server never held a file at it
+	* (`unheld`). Under the write lock that queues it, the file must still hold it and the server still have no text of
+	* it; otherwise it is reconciled again.
+	*/
+	async queueUnheld(path, text) {
+		if (await this.enqueue(() => {
+			if (this.expected.get(path)?.hash !== contentHash(text) || !this.onDisk(path, text) || !this.unheld.has(path) || typeof this.cloud.get(path) === "string") return null;
+			return {
+				kind: "patch",
+				path,
+				text,
+				base: null
+			};
+		}) !== null) return;
+		this.trace(`new ${path} changed before it was queued; reconciling it again`);
+		this.schedule(path);
+	}
 	/** What the response to queued edit `entry` means for the writer (layer 2), then wait for the broadcast it caused. */
 	async settleEdit(entry, response, context, sent) {
 		const { path } = entry;
@@ -3397,7 +3648,7 @@ var SyncClient = class extends EventEmitter {
 			...nodeStorage(this.root),
 			lock: (fn) => fn()
 		};
-		const seen = new Map([...new Set(paths)].filter(isSynced).map((path) => [path, this.expected.get(path)]));
+		const seen = new Map([...new Set(paths)].filter((path) => this.syncs(path)).map((path) => [path, this.expected.get(path)]));
 		const changes = renumberFiles(storage, seen.keys(), renumbered);
 		const unknown = /* @__PURE__ */ new Set();
 		for (const [path, disk] of seen) {
@@ -3450,7 +3701,7 @@ var SyncClient = class extends EventEmitter {
 	*/
 	async flushEdit(edit, timeoutMs = 2e4) {
 		const { path } = edit;
-		if (this.caughtUp && isSynced(path) && edit.old !== "") await this.withChain(path, () => this.replayEdit(edit));
+		if (this.caughtUp && this.syncs(path) && edit.old !== "") await this.withChain(path, () => this.replayEdit(edit));
 		return this.flush(timeoutMs);
 	}
 	/**
@@ -3513,28 +3764,61 @@ var SyncClient = class extends EventEmitter {
 		}]);
 		if ("files" in response && response.files.some((f) => f.path === path)) await this.delivery(path, response.seq);
 	}
-	async walk(dir = "") {
+	/**
+	* The synced files here, by path. Each directory's .gitignore is read again on the way, before what the directory
+	* holds, so a change to one takes effect from the next scan on; a directory the rules leave out is not walked into.
+	* Rules changed since the last snapshot was asked for take it again: a file they let in that is on the server, as
+	* another environment sent it while the rules here left it out, comes then, not only on the next connection. A walk
+	* of a snapshot being taken leaves that to it (resync).
+	*/
+	async walk() {
 		const out = [];
-		let entries;
-		try {
-			entries = await readdir(join(this.paths.data, dir), { withFileTypes: true });
-		} catch {
-			return out;
-		}
-		for (const entry of entries) {
-			const path = dir ? `${dir}/${entry.name}` : entry.name;
-			if (entry.isDirectory()) {
-				if (mayHoldSynced(path)) out.push(...await this.walk(path));
-			} else if (entry.isFile() && isSynced(path)) out.push(path);
+		const dirs = /* @__PURE__ */ new Set();
+		const visit = async (dir) => {
+			let entries;
+			try {
+				entries = await readdir(join(this.paths.data, dir), { withFileTypes: true });
+			} catch {
+				return;
+			}
+			dirs.add(dir);
+			this.scope.set(dir, entries.some((entry) => entry.name === ".gitignore" && entry.isFile()) ? await this.readRules(dir) : null);
+			for (const entry of entries) {
+				const path = dir ? `${dir}/${entry.name}` : entry.name;
+				if (entry.isDirectory()) {
+					if (this.scope.walks(path)) await visit(path);
+				} else if (entry.isFile() && this.syncs(path)) out.push(path);
+			}
+		};
+		await visit("");
+		this.scope.keepOnly(dirs);
+		if (this.scopeStale && this.synced && this.connected && this.resyncing === null && !this.closing) {
+			this.log("the hub's .gitignore changed; reloading the snapshot for the files it lets in");
+			this.track(this.resync().catch((error) => this.log(`could not reload the snapshot: ${error.message}`)));
 		}
 		return out;
 	}
+	/**
+	* The text of the .gitignore in `dir`, which is there, as walk takes it. A text other than the rules have may be one
+	* being written, as `cat >` empties a file before it fills it, and a rule missing for a moment would let its files in,
+	* to be sent: it is read again after EMPTY_RECHECK_MS and taken only when it reads the same, empty too. Until then, and
+	* while the file cannot be read, the rules stay as they were; the next walk reads it again.
+	*/
+	async readRules(dir) {
+		const held = this.scope.text(dir);
+		const read = () => readFile(join(this.paths.data, dir, GITIGNORE), "utf8").catch(() => null);
+		const text = await read();
+		if (text === null || text === held) return held;
+		await sleep$1(EMPTY_RECHECK_MS);
+		return await read() === text ? text : held;
+	}
+	/** The directories an upload holds: every one outside local/ that the hub's .gitignore files leave in. */
 	async walkDirs(dir = "") {
 		const out = [];
 		const entries = await readdir(join(this.paths.data, dir), { withFileTypes: true }).catch(() => []);
 		for (const entry of entries) {
 			const path = dir ? `${dir}/${entry.name}` : entry.name;
-			if (!entry.isDirectory() || path === "local" || path.startsWith("local/")) continue;
+			if (!entry.isDirectory() || path === "local" || path.startsWith("local/") || this.scope.ignored(path, true)) continue;
 			out.push(path, ...await this.walkDirs(path));
 		}
 		return out;
@@ -3557,7 +3841,7 @@ var SyncClient = class extends EventEmitter {
 			if (!baseline) this.schedule(path);
 		}
 		if (baseline) return;
-		for (const [path, disk] of this.expected) if (disk !== null && !seen.has(path)) {
+		for (const [path, disk] of this.expected) if (disk !== null && !seen.has(path) && this.syncs(path)) {
 			this.signatures.delete(path);
 			this.schedule(path);
 		}
@@ -3578,12 +3862,13 @@ var SyncClient = class extends EventEmitter {
 				}, SETTLE_MS));
 				return;
 			}
-			if (!isSynced(path)) return;
+			const rules = path === ".gitignore" || path.endsWith(`/.gitignore`);
+			if (!rules && !this.syncs(path)) return;
 			this.trace(`watched ${path}`);
 			clearTimeout(timers.get(path));
 			timers.set(path, setTimeout(() => {
 				timers.delete(path);
-				this.track(this.whenSettled(path).then(() => this.schedule(path)));
+				this.track(this.whenSettled(path).then(() => rules ? this.scan(true) : this.schedule(path)));
 			}, SETTLE_MS));
 		};
 		try {
@@ -4208,4 +4493,4 @@ function hubWriter(root, env = process.env, options = {}) {
 	};
 }
 //#endregion
-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 };
+export { hubName as C, isSynced as D, SYNC_DIR as E, syncPaths as O, earlierToken as S, SETTINGS_FILE as T, readRemote as _, remoteMode as a, ServerError 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, oversizedFiles as v, syncSettings as w, ENV as x, ServerApi as y };