leafrelay 0.2.8 → 0.2.9

package/dist/dist-JyfvbgjD.js

@@ -0,0 +1,2923 @@
+import { Blob as Blob$1 } from "node:buffer";
+import mime from "mime";
+import { EventEmitter } from "node:events";
+import { v4 } from "uuid";
+import { promisify } from "node:util";
+import { chmod, lstat, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, posix, relative, resolve, sep } from "node:path";
+import { watch } from "chokidar";
+import { minimatch } from "minimatch";
+import { createHash, randomUUID } from "node:crypto";
+import DiffMatchPatch from "diff-match-patch";
+import { diff3Merge } from "node-diff3";
+// ../core/dist/index.js
+const PACKET_TYPES = [
+	"disconnect",
+	"connect",
+	"heartbeat",
+	"message",
+	"json",
+	"event",
+	"ack",
+	"error",
+	"noop"
+];
+function encodePacket(packet) {
+	const type = PACKET_TYPES.indexOf(packet.type ?? "noop");
+	const id = packet.id ?? "";
+	let data;
+	switch (packet.type) {
+		case "event":
+			data = JSON.stringify({
+				name: packet.name,
+				args: packet.args ?? []
+			});
+			break;
+		case "ack":
+			data = `${packet.ackId ?? ""}${packet.args?.length ? `+${JSON.stringify(packet.args)}` : ""}`;
+			break;
+		case "message":
+			data = String(packet.data ?? "");
+			break;
+		case "json": data = JSON.stringify(packet.data);
+	}
+	const fields = [
+		String(type),
+		`${id}${packet.ack === "data" ? "+" : ""}`,
+		packet.endpoint ?? ""
+	];
+	if (data !== void 0) fields.push(data);
+	return fields.join(":");
+}
+function decodePacket(value) {
+	const match = value.match(/([^:]+):([0-9]+)?(\+)?:([^:]+)?:?([\s\S]*)?/);
+	if (!match) return {};
+	const packet = {
+		type: PACKET_TYPES[Number(match[1])],
+		endpoint: match[4] || ""
+	};
+	if (match[2]) {
+		packet.id = match[2];
+		packet.ack = match[3] ? "data" : true;
+	}
+	const data = match[5] || "";
+	switch (packet.type) {
+		case "event": {
+			const event = JSON.parse(data);
+			packet.name = event.name;
+			packet.args = event.args ?? [];
+			break;
+		}
+		case "ack": {
+			const ack = data.match(/^([0-9]+)(\+)?([\s\S]*)/);
+			if (ack) {
+				packet.ackId = ack[1];
+				packet.args = ack[3] ? JSON.parse(ack[3]) : [];
+			}
+			break;
+		}
+		case "error": {
+			const [reason, advice] = data.split("+");
+			packet.reason = [
+				"transport not supported",
+				"client not handshaken",
+				"unauthorized"
+			][Number(reason)] ?? "";
+			packet.advice = ["reconnect"][Number(advice)] ?? "";
+			break;
+		}
+		case "json":
+			packet.data = JSON.parse(data);
+			break;
+		case "message": packet.data = data;
+	}
+	return packet;
+}
+function decodePayload(value) {
+	if (!value.startsWith("�")) return [decodePacket(value)];
+	const packets = [];
+	let offset = 1;
+	while (offset < value.length) {
+		const separator = value.indexOf("�", offset);
+		if (separator === -1) break;
+		const length = Number(value.slice(offset, separator));
+		const start = separator + 1;
+		packets.push(decodePacket(value.slice(start, start + length)));
+		offset = start + length + 1;
+	}
+	return packets;
+}
+function mergeCookies(current, additions) {
+	const cookies = /* @__PURE__ */ new Map();
+	for (const value of [current, ...additions.map((cookie) => cookie.split(";", 1)[0])]) for (const part of value.split(";")) {
+		const separator = part.indexOf("=");
+		if (separator === -1) continue;
+		cookies.set(part.slice(0, separator).trim(), part.slice(separator + 1).trim());
+	}
+	return [...cookies].map(([name, value]) => `${name}=${value}`).join("; ");
+}
+var OverleafRealtimeSocket = class {
+	options;
+	events = new EventEmitter();
+	endpoint;
+	origin;
+	cookie;
+	socket;
+	connected = false;
+	projectJoined = false;
+	explicitlyDisconnected = false;
+	reconnectEnabled;
+	reconnectAttempts = 0;
+	reconnectTimer;
+	inactivityTimer;
+	connectionAbort;
+	closeTimeoutMs = 6e4;
+	acknowledgementId = 0;
+	acknowledgements = /* @__PURE__ */ new Map();
+	io = { reconnect: (enabled) => {
+		this.reconnectEnabled = enabled;
+		if (!enabled && this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = void 0;
+		}
+	} };
+	constructor(url, options) {
+		this.options = options;
+		this.endpoint = new URL(url);
+		this.origin = options.origin;
+		this.cookie = options.cookie;
+		this.reconnectEnabled = options.reconnect ?? true;
+		this.connect();
+	}
+	on(event, handler) {
+		this.events.on(event, handler);
+		return this;
+	}
+	once(event, handler) {
+		this.events.once(event, handler);
+		return this;
+	}
+	removeListener(event, handler) {
+		this.events.removeListener(event, handler);
+		return this;
+	}
+	removeAllListeners(event) {
+		this.events.removeAllListeners(event);
+		return this;
+	}
+	emit(event, ...args) {
+		const callback = typeof args.at(-1) === "function" ? args.pop() : void 0;
+		const id = callback ? String(++this.acknowledgementId) : void 0;
+		if (id && callback) this.acknowledgements.set(id, callback);
+		const packet = encodePacket({
+			type: "event",
+			id,
+			ack: callback ? "data" : void 0,
+			name: event,
+			args
+		});
+		if (!this.sendApplicationEvent(packet) && callback) {
+			if (id) this.acknowledgements.delete(id);
+			queueMicrotask(() => callback(/* @__PURE__ */ new Error("The Overleaf project session is not connected.")));
+		}
+		return this;
+	}
+	markProjectJoined() {
+		this.projectJoined = true;
+	}
+	disconnect() {
+		this.explicitlyDisconnected = true;
+		this.reconnectEnabled = false;
+		if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+		if (this.connected) this.send(encodePacket({ type: "disconnect" }));
+		this.closeSocket("booted");
+		return this;
+	}
+	async connect() {
+		if (this.explicitlyDisconnected) return;
+		const controller = new AbortController();
+		this.connectionAbort?.abort();
+		this.connectionAbort = controller;
+		try {
+			this.projectJoined = false;
+			const handshakeUrl = new URL("/socket.io/1/", this.endpoint.origin);
+			for (const [name, value] of this.endpoint.searchParams) handshakeUrl.searchParams.set(name, value);
+			handshakeUrl.searchParams.set("t", String(Date.now()));
+			const response = await (this.options.fetch ?? fetch)(handshakeUrl, {
+				headers: {
+					origin: this.origin,
+					cookie: this.cookie
+				},
+				redirect: "manual",
+				signal: AbortSignal.any([controller.signal, AbortSignal.timeout(15e3)])
+			});
+			if (!response.ok) throw new Error(`Socket.IO handshake failed: HTTP ${response.status} ${await response.text()}`);
+			const setCookies = response.headers.getSetCookie?.() ?? [];
+			this.cookie = mergeCookies(this.cookie, setCookies);
+			const [sessionId, heartbeatTimeout, closeTimeout, transports] = (await response.text()).split(":");
+			if (!sessionId || !transports?.split(",").includes("websocket")) throw new Error("Overleaf did not offer a Socket.IO WebSocket transport.");
+			this.closeTimeoutMs = Math.max(Number(heartbeatTimeout), Number(closeTimeout), 10) * 1e3;
+			const websocketUrl = new URL(`/socket.io/1/websocket/${sessionId}`, this.endpoint.origin);
+			websocketUrl.protocol = websocketUrl.protocol === "https:" ? "wss:" : "ws:";
+			websocketUrl.search = this.endpoint.search;
+			if (controller.signal.aborted) return;
+			const socket = new WebSocket(websocketUrl, { headers: {
+				origin: this.origin,
+				cookie: this.cookie
+			} });
+			this.socket = socket;
+			socket.addEventListener("open", () => {
+				if (this.socket !== socket) return;
+				this.resetInactivityTimer();
+				this.events.emit("connecting", "websocket");
+			});
+			socket.addEventListener("message", (event) => {
+				if (this.socket === socket) this.receive(event.data, socket);
+			});
+			socket.addEventListener("error", (error) => {
+				if (this.socket === socket) this.events.emit("error", error);
+			});
+			socket.addEventListener("close", (event) => {
+				if (this.socket === socket) this.handleClose(event);
+			});
+		} catch (error) {
+			if (controller.signal.aborted) return;
+			this.events.emit("connect_failed", error);
+			this.events.emit("error", error);
+			this.scheduleReconnect();
+		}
+	}
+	async receive(data, socket) {
+		this.resetInactivityTimer();
+		const value = typeof data === "string" ? data : data instanceof Blob ? await data.text() : Buffer.from(data).toString("utf8");
+		if (this.socket !== socket) return;
+		for (const packet of decodePayload(value)) this.handlePacket(packet);
+	}
+	handlePacket(packet) {
+		switch (packet.type) {
+			case "connect": {
+				const wasReconnecting = this.reconnectAttempts > 0;
+				this.connected = true;
+				this.events.emit("connect");
+				if (wasReconnecting) {
+					this.events.emit("reconnect", "websocket", this.reconnectAttempts);
+					this.reconnectAttempts = 0;
+				}
+				break;
+			}
+			case "heartbeat":
+				this.send(encodePacket({ type: "heartbeat" }));
+				break;
+			case "event": {
+				const args = [...packet.args ?? []];
+				if (packet.ack === "data" && packet.id) args.push((...acknowledgement) => {
+					this.send(encodePacket({
+						type: "ack",
+						ackId: packet.id,
+						args: acknowledgement
+					}));
+				});
+				this.events.emit(packet.name ?? "", ...args);
+				break;
+			}
+			case "ack": {
+				const callback = packet.ackId && this.acknowledgements.get(packet.ackId);
+				if (callback && packet.ackId) {
+					this.acknowledgements.delete(packet.ackId);
+					callback(...packet.args ?? []);
+				}
+				break;
+			}
+			case "disconnect":
+				this.closeSocket("booted");
+				break;
+			case "error":
+				this.events.emit("error", packet.reason || "Socket.IO protocol error");
+				if (packet.advice === "reconnect") this.closeSocket("server error");
+				break;
+			case "message":
+			case "json": this.events.emit("message", packet.data);
+		}
+	}
+	send(packet) {
+		if (this.connected && this.socket?.readyState === WebSocket.OPEN) this.socket.send(packet);
+	}
+	sendApplicationEvent(packet) {
+		if (!this.connected || !this.projectJoined || this.socket?.readyState !== WebSocket.OPEN) return false;
+		this.socket.send(packet);
+		return true;
+	}
+	resetInactivityTimer() {
+		if (this.inactivityTimer) clearTimeout(this.inactivityTimer);
+		this.inactivityTimer = setTimeout(() => this.closeSocket("timeout"), this.closeTimeoutMs);
+	}
+	handleClose(event) {
+		const wasConnected = this.connected;
+		this.socket = void 0;
+		this.connected = false;
+		this.projectJoined = false;
+		if (this.inactivityTimer) clearTimeout(this.inactivityTimer);
+		if (wasConnected) {
+			const detail = event.reason ? `: ${event.reason}` : "";
+			const reason = `transport close (code ${event.code})${detail}`;
+			this.failAcknowledgements(reason);
+			this.events.emit("disconnect", reason);
+		}
+		this.scheduleReconnect();
+	}
+	closeSocket(reason) {
+		this.connectionAbort?.abort();
+		this.connectionAbort = void 0;
+		const wasConnected = this.connected;
+		this.connected = false;
+		this.projectJoined = false;
+		if (this.inactivityTimer) clearTimeout(this.inactivityTimer);
+		const socket = this.socket;
+		this.socket = void 0;
+		socket?.close();
+		if (wasConnected) {
+			this.failAcknowledgements(reason);
+			this.events.emit("disconnect", reason);
+		}
+		if (!this.explicitlyDisconnected) this.scheduleReconnect();
+	}
+	failAcknowledgements(reason) {
+		const error = /* @__PURE__ */ new Error(`Overleaf realtime connection closed: ${reason}`);
+		for (const callback of this.acknowledgements.values()) callback(error);
+		this.acknowledgements.clear();
+	}
+	scheduleReconnect() {
+		if (!this.reconnectEnabled || this.explicitlyDisconnected || this.reconnectTimer) return;
+		const maxAttempts = this.options.maxReconnectionAttempts ?? Infinity;
+		if (this.reconnectAttempts >= maxAttempts) {
+			this.events.emit("reconnect_failed");
+			return;
+		}
+		this.reconnectAttempts += 1;
+		const initial = this.options.reconnectionDelay ?? 1e3;
+		const limit = this.options.reconnectionLimit ?? 16e3;
+		const delay = Math.min(initial * 2 ** (this.reconnectAttempts - 1), limit);
+		this.events.emit("reconnecting", delay, this.reconnectAttempts);
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectTimer = void 0;
+			this.connect();
+		}, delay);
+	}
+};
+let sink;
+function setLogSink(nextSink) {
+	sink = nextSink;
+}
+function write(level, args) {
+	if (sink !== void 0) {
+		sink(level, args);
+		return;
+	}
+	(level === "error" ? console.error : level === "warn" ? console.warn : console.log)(...args);
+}
+function log(...args) {
+	write("info", args);
+}
+function error(...args) {
+	write("error", args);
+}
+function retryAfterMilliseconds(response, now) {
+	const retryAfter = response.headers.get("retry-after");
+	if (retryAfter) {
+		const seconds = Number(retryAfter);
+		if (Number.isFinite(seconds)) return Math.max(1e3, seconds * 1e3);
+		const retryAt = Date.parse(retryAfter);
+		if (Number.isFinite(retryAt)) return Math.max(1e3, retryAt - now);
+	}
+	return 5e3;
+}
+var HttpRequestScheduler = class {
+	options;
+	chain = Promise.resolve();
+	nextRequestAt = 0;
+	historyNextRequestAt = 0;
+	rateLimitedUntil = 0;
+	minimumIntervalMs;
+	historyIntervalMs;
+	fetchImplementation;
+	now;
+	wait;
+	constructor(options = {}) {
+		this.options = options;
+		this.minimumIntervalMs = options.minimumIntervalMs ?? 300;
+		this.historyIntervalMs = options.historyIntervalMs ?? 3e3;
+		this.fetchImplementation = options.fetch ?? fetch;
+		this.now = options.now ?? Date.now;
+		this.wait = options.wait ?? ((milliseconds) => new Promise((resolveWait) => setTimeout(resolveWait, milliseconds)));
+	}
+	fetch(input, init, timeoutMs = this.options.requestTimeoutMs ?? 6e4) {
+		const url = input instanceof Request ? input.url : String(input);
+		const history = url.includes("/updates?") || url.includes("/filetree/diff?") || url.includes("/diff?");
+		return this.enqueue(async () => {
+			const now = this.now();
+			const readyAt = Math.max(this.nextRequestAt, this.rateLimitedUntil, history ? this.historyNextRequestAt : 0);
+			if (readyAt > now) await this.wait(readyAt - now);
+			const requestAt = this.now();
+			this.nextRequestAt = requestAt + this.minimumIntervalMs;
+			if (history) this.historyNextRequestAt = requestAt + this.historyIntervalMs;
+			const signals = [
+				AbortSignal.timeout(timeoutMs),
+				init?.signal,
+				input instanceof Request ? input.signal : void 0
+			].filter((signal) => Boolean(signal));
+			let response;
+			try {
+				response = await this.fetchImplementation(input, {
+					...init,
+					signal: AbortSignal.any(signals)
+				});
+			} catch (error$1) {
+				const destination = new URL(url);
+				error("HTTP request failed", {
+					method: init?.method ?? (input instanceof Request ? input.method : "GET"),
+					url: `${destination.origin}${destination.pathname}`,
+					error: error$1
+				});
+				throw error$1;
+			}
+			if (response.status === 429) {
+				this.rateLimitedUntil = Math.max(this.rateLimitedUntil, this.now() + retryAfterMilliseconds(response, this.now()));
+				this.options.onRateLimit?.(this.rateLimitedUntil);
+				log(`HTTP request scheduler entered rate-limit cooldown until ${new Date(this.rateLimitedUntil).toISOString()}.`);
+			}
+			return response;
+		});
+	}
+	enqueue(operation) {
+		const result = this.chain.then(operation);
+		this.chain = result.then(() => void 0, () => void 0);
+		return result;
+	}
+};
+const sharedHttpRequestScheduler = new HttpRequestScheduler();
+/** Extract set-cookie headers from an undici/Response object. */
+function getSetCookie(res) {
+	if (typeof res.headers?.getSetCookie === "function") return res.headers.getSetCookie();
+	const raw = res.headers?.raw?.()?.["set-cookie"];
+	if (raw) return raw;
+	return [];
+}
+var BaseAPI = class {
+	scheduler;
+	url;
+	identity;
+	retryAfterMs(response, attempt) {
+		const retryAfter = response.headers?.get?.("retry-after");
+		if (retryAfter !== void 0 && retryAfter !== null) {
+			const seconds = Number(retryAfter);
+			if (Number.isFinite(seconds)) return Math.max(1e3, seconds * 1e3);
+			const retryAt = Date.parse(retryAfter);
+			if (Number.isFinite(retryAt)) return Math.max(1e3, retryAt - Date.now());
+		}
+		return 5e3 * Math.pow(2, attempt);
+	}
+	constructor(url, scheduler = sharedHttpRequestScheduler) {
+		this.scheduler = scheduler;
+		this.url = url;
+	}
+	async getCsrfToken() {
+		const res = await this.scheduler.fetch(this.url + "login", {
+			method: "GET",
+			redirect: "manual"
+		});
+		const match = (await res.text()).match(/<input.*name="_csrf".*value="([^"]*)">/);
+		if (!match) throw new Error("Failed to get CSRF token.");
+		else return {
+			csrfToken: match[1],
+			cookies: getSetCookie(res)[0]?.split(";")[0] ?? ""
+		};
+	}
+	async getUserId(cookies) {
+		const body = await (await this.scheduler.fetch(this.url + "project", {
+			method: "GET",
+			redirect: "manual",
+			headers: {
+				Connection: "keep-alive",
+				Cookie: cookies
+			}
+		})).text();
+		const userIDMatch = body.match(/<meta\s+name="ol-user_id"\s+content="([^"]*)">/);
+		const userEmailMatch = body.match(/<meta\s+name="ol-usersEmail"\s+content="([^"]*)">/);
+		const csrfTokenMatch = body.match(/<meta\s+name="ol-csrfToken"\s+content="([^"]*)">/);
+		if (userIDMatch !== null && csrfTokenMatch !== null) {
+			const userId = userIDMatch[1];
+			const csrfToken = csrfTokenMatch[1];
+			return {
+				userId,
+				userEmail: userEmailMatch ? userEmailMatch[1] : "",
+				csrfToken
+			};
+		} else return;
+	}
+	_initSocketV0(identity, query) {
+		return new OverleafRealtimeSocket(new URL(this.url).origin + (query ?? ""), {
+			origin: new URL(this.url).origin,
+			cookie: identity.cookies,
+			reconnect: true,
+			reconnectionDelay: 1e3,
+			reconnectionLimit: 16e3,
+			maxReconnectionAttempts: 10,
+			fetch: (input, init) => this.scheduler.fetch(input, init)
+		});
+	}
+	async passportLogin(email, password) {
+		const identity = await this.getCsrfToken();
+		const res = await this.scheduler.fetch(this.url + "login", {
+			method: "POST",
+			redirect: "manual",
+			headers: {
+				Accept: "*/*",
+				"Accept-Encoding": "gzip, deflate, br",
+				Connection: "keep-alive",
+				"Content-Type": "application/json",
+				Cookie: identity.cookies,
+				"X-Csrf-Token": identity.csrfToken
+			},
+			body: JSON.stringify({
+				_csrf: identity.csrfToken,
+				email,
+				password
+			})
+		});
+		if (res.status === 302) {
+			const redirect = (await res.text()).match(/Found. Redirecting to (.*)/)[1];
+			if (redirect === "/project") {
+				const cookies = getSetCookie(res)[0] ?? "";
+				return await this.cookiesLogin(cookies);
+			} else return {
+				type: "error",
+				message: `Redirecting to /${redirect}`
+			};
+		} else if (res.status === 200) return {
+			type: "error",
+			message: (await res.json()).message.message
+		};
+		else if (res.status === 401) return {
+			type: "error",
+			message: (await res.json()).message.text
+		};
+		else return {
+			type: "error",
+			message: `${res.status}: ` + await res.text()
+		};
+	}
+	async cookiesLogin(cookies) {
+		const res = await this.getUserId(cookies);
+		if (res) {
+			const { userId, userEmail, csrfToken } = res;
+			const identity = await this.updateCookies({
+				cookies,
+				csrfToken
+			});
+			return {
+				type: "success",
+				userInfo: {
+					userId,
+					userEmail
+				},
+				identity
+			};
+		} else return {
+			type: "error",
+			message: "Failed to get User ID."
+		};
+	}
+	async updateCookies(identity) {
+		const cookies = getSetCookie(await this.scheduler.fetch(this.url + "socket.io/socket.io.js", {
+			method: "GET",
+			redirect: "manual",
+			headers: {
+				Connection: "keep-alive",
+				Cookie: identity.cookies
+			}
+		}))[0]?.split(";")[0];
+		if (cookies) identity.cookies = `${identity.cookies}; ${cookies}`;
+		return identity;
+	}
+	setIdentity(identity) {
+		this.identity = identity;
+		return this;
+	}
+	/**
+	* Check if an HTTP error is transient (worth retrying).
+	* Retries on: 5xx server errors, network errors (fetch failures), and 429 rate limiting.
+	*/
+	isTransientError(statusCode, errorMessage) {
+		if (statusCode === void 0) return true;
+		if (statusCode >= 500 || statusCode === 429) return true;
+		if (errorMessage && (errorMessage.includes("ECONNRESET") || errorMessage.includes("ETIMEDOUT") || errorMessage.includes("ECONNREFUSED") || errorMessage.includes("ENOTFOUND") || errorMessage.includes("socket hang up"))) return true;
+		return false;
+	}
+	async request(type, route, body, callback, extraHeaders, timeoutMs) {
+		if (this.identity === void 0) return Promise.reject();
+		const MAX_HTTP_RETRIES = 2;
+		let lastError = {};
+		for (let attempt = 0; attempt <= MAX_HTTP_RETRIES; attempt++) try {
+			let res = void 0;
+			switch (type) {
+				case "GET":
+					res = await this.scheduler.fetch(this.url + route, {
+						method: "GET",
+						redirect: "manual",
+						headers: {
+							Connection: "keep-alive",
+							Cookie: this.identity.cookies,
+							...extraHeaders
+						}
+					}, timeoutMs);
+					break;
+				case "POST":
+					const content_type = body instanceof FormData ? void 0 : { "Content-Type": "application/json" };
+					const raw_body = body instanceof FormData ? body : JSON.stringify({
+						_csrf: this.identity.csrfToken,
+						...body
+					});
+					res = await this.scheduler.fetch(this.url + route, {
+						method: "POST",
+						redirect: "manual",
+						headers: {
+							Connection: "keep-alive",
+							Cookie: this.identity.cookies,
+							...content_type,
+							...extraHeaders
+						},
+						body: raw_body
+					}, timeoutMs);
+					break;
+				case "PUT": break;
+				case "DELETE": res = await this.scheduler.fetch(this.url + route, {
+					method: "DELETE",
+					redirect: "manual",
+					headers: {
+						Connection: "keep-alive",
+						Cookie: this.identity.cookies,
+						"X-Csrf-Token": this.identity.csrfToken,
+						...extraHeaders
+					}
+				}, timeoutMs);
+			}
+			if (res && (res.status === 200 || res.status === 204)) {
+				const _res = res.status === 200 ? await res.text() : void 0;
+				return {
+					type: "success",
+					...callback && callback(_res)
+				};
+			} else if (res && this.isTransientError(res.status) && attempt < MAX_HTTP_RETRIES) {
+				const delayMs = res.status === 429 ? this.retryAfterMs(res, attempt) : Math.min(1e3 * Math.pow(2, attempt), 4e3);
+				log(`HTTP ${res.status} on ${route}, retrying in ${delayMs}ms (attempt ${attempt + 1}/${MAX_HTTP_RETRIES})`);
+				lastError = {
+					statusCode: res.status,
+					message: await res.text().catch(() => "")
+				};
+				await new Promise((r) => setTimeout(r, delayMs));
+				continue;
+			} else {
+				const resOrFallback = res || {
+					status: "undefined",
+					text: async () => ""
+				};
+				let errorBody = "";
+				try {
+					errorBody = await resOrFallback.text();
+				} catch {
+					errorBody = "";
+				}
+				return {
+					type: "error",
+					statusCode: typeof resOrFallback.status === "number" ? resOrFallback.status : void 0,
+					message: `${resOrFallback.status}: ${errorBody}`
+				};
+			}
+		} catch (err) {
+			const errMsg = err?.message || String(err);
+			if (this.isTransientError(void 0, errMsg) && attempt < MAX_HTTP_RETRIES) {
+				const delayMs = Math.min(1e3 * Math.pow(2, attempt), 4e3);
+				log(`HTTP fetch error on ${route}: ${errMsg}, retrying in ${delayMs}ms (attempt ${attempt + 1}/${MAX_HTTP_RETRIES})`);
+				await new Promise((r) => setTimeout(r, delayMs));
+				continue;
+			}
+			return {
+				type: "error",
+				statusCode: void 0,
+				message: errMsg
+			};
+		}
+		return {
+			type: "error",
+			statusCode: lastError.statusCode,
+			message: lastError.message || `Request failed after 3 attempts`
+		};
+	}
+	async download(route) {
+		if (this.identity === void 0) return Promise.reject();
+		let content = [];
+		while (true) {
+			const res = await this.scheduler.fetch(this.url + route, {
+				method: "GET",
+				redirect: "manual",
+				headers: {
+					Connection: "keep-alive",
+					Cookie: this.identity.cookies
+				}
+			});
+			if (res.status === 200) {
+				content.push(Buffer.from(await res.arrayBuffer()));
+				break;
+			} else if (res.status === 206) content.push(Buffer.from(await res.arrayBuffer()));
+			else break;
+		}
+		return Buffer.concat(content);
+	}
+	async logout(identity) {
+		this.setIdentity(identity);
+		return this.request("POST", "logout");
+	}
+	async userProjectsJson(identity) {
+		this.setIdentity(identity);
+		return this.request("GET", "user/projects", void 0, (res) => {
+			const projects = JSON.parse(res).projects;
+			projects.forEach((project) => {
+				project.id = project._id;
+				delete project._id;
+			});
+			return { projects };
+		});
+	}
+	async getProjectsJson(identity) {
+		this.setIdentity(identity);
+		return this.request("POST", "api/project", {}, (res) => {
+			return { projects: JSON.parse(res).projects };
+		});
+	}
+	async projectEntitiesJson(identity, projectId) {
+		this.setIdentity(identity);
+		return this.request("GET", `project/${projectId}/entities`, void 0, (res) => {
+			return { entities: JSON.parse(res).entities };
+		});
+	}
+	async newProject(identity, projectName, template) {
+		this.setIdentity(identity);
+		return this.request("POST", "project/new", {
+			projectName,
+			template
+		}, (res) => {
+			return { message: JSON.parse(res).project_id };
+		});
+	}
+	async cloneProject(identity, projectId, projectName) {
+		this.setIdentity(identity);
+		return this.request("POST", `project/${projectId}/clone`, { projectName }, (res) => {
+			return { message: JSON.parse(res).project_id };
+		});
+	}
+	async renameProject(identity, projectId, newProjectName) {
+		this.setIdentity(identity);
+		return this.request("POST", `project/${projectId}/rename`, { newProjectName });
+	}
+	async deleteProject(identity, projectId) {
+		this.setIdentity(identity);
+		return this.request("DELETE", `project/${projectId}`);
+	}
+	async archiveProject(identity, projectId) {
+		this.setIdentity(identity);
+		return this.request("POST", `project/${projectId}/archive`, void 0, void 0, { "X-Csrf-Token": identity.csrfToken });
+	}
+	async unarchiveProject(identity, projectId) {
+		this.setIdentity(identity);
+		return this.request("DELETE", `project/${projectId}/archive`);
+	}
+	async trashProject(identity, projectId) {
+		this.setIdentity(identity);
+		return this.request("POST", `project/${projectId}/trash`, void 0, void 0, { "X-Csrf-Token": identity.csrfToken });
+	}
+	async untrashProject(identity, projectId) {
+		this.setIdentity(identity);
+		return this.request("DELETE", `project/${projectId}/trash`);
+	}
+	async getFile(identity, projectId, fileId) {
+		this.setIdentity(identity);
+		const content = await this.download(`project/${projectId}/file/${fileId}`);
+		return {
+			type: "success",
+			content: new Uint8Array(content)
+		};
+	}
+	async addDoc(identity, projectId, parentFolderId, filename) {
+		this.setIdentity(identity);
+		return this.request("POST", `project/${projectId}/doc`, {
+			parent_folder_id: parentFolderId,
+			name: filename
+		}, (res) => {
+			const { _id } = JSON.parse(res);
+			return { entity: {
+				_type: "doc",
+				_id,
+				name: filename
+			} };
+		}, { "X-Csrf-Token": identity.csrfToken });
+	}
+	async uploadFile(identity, projectId, parentFolderId, filename, fileContent) {
+		const formData = new FormData();
+		const mimeType = mime.getType(filename);
+		formData.append("targetFolderId", parentFolderId);
+		formData.append("name", filename);
+		formData.append("type", mimeType ? mimeType : "text/plain");
+		formData.append("qqfile", new Blob$1([Buffer.from(fileContent)], { type: mimeType ? mimeType : "application/octet-stream" }), filename);
+		this.setIdentity(identity);
+		return this.request("POST", `project/${projectId}/upload?folder_id=${parentFolderId}`, formData, (res) => {
+			const { entity_id, entity_type } = JSON.parse(res);
+			return { entity: {
+				_type: entity_type,
+				_id: entity_id,
+				name: filename
+			} };
+		}, { "X-Csrf-Token": identity.csrfToken });
+	}
+	async uploadProject(identity, filename, fileContent) {
+		const uuid = v4();
+		const formData = new FormData();
+		formData.append("qqfile", new Blob$1([Buffer.from(fileContent)], { type: "application/zip" }), filename);
+		this.setIdentity(identity);
+		return this.request("POST", `project/new/upload?_csrf=${identity.csrfToken}&qquuid=${uuid}&qqfilename=${filename}&qqtotalfilesize=${fileContent.length}`, formData, (res) => {
+			return { message: JSON.parse(res).project_id };
+		});
+	}
+	async addFolder(identity, projectId, folderName, parentFolderId) {
+		const body = {
+			name: folderName,
+			parent_folder_id: parentFolderId
+		};
+		this.setIdentity(identity);
+		return this.request("POST", `project/${projectId}/folder`, body, (res) => {
+			return { entity: JSON.parse(res) };
+		}, { "X-Csrf-Token": identity.csrfToken });
+	}
+	async deleteEntity(identity, projectId, fileType, fileId) {
+		this.setIdentity(identity);
+		return this.request("DELETE", `project/${projectId}/${fileType}/${fileId}`);
+	}
+	async deleteAuxFiles(identity, projectId) {
+		this.setIdentity(identity);
+		return this.request("DELETE", `project/${projectId}/output`);
+	}
+	async renameEntity(identity, projectId, entityType, entityId, name) {
+		this.setIdentity(identity);
+		return this.request("POST", `project/${projectId}/${entityType}/${entityId}/rename`, { name }, void 0, { "X-Csrf-Token": identity.csrfToken });
+	}
+	async moveEntity(identity, projectId, entityType, entityId, newParentFolderId) {
+		this.setIdentity(identity);
+		return this.request("POST", `project/${projectId}/${entityType}/${entityId}/move`, { folder_id: newParentFolderId }, void 0, { "X-Csrf-Token": identity.csrfToken });
+	}
+	async compile(identity, projectId, rootResourcePath, draft = false, stopOnFirstError = false) {
+		const body = {
+			check: "silent",
+			draft,
+			incrementalCompilesEnabled: true,
+			rootResourcePath,
+			stopOnFirstError
+		};
+		this.setIdentity(identity);
+		return this.request("POST", `project/${projectId}/compile?auto_compile=true`, body, (res) => {
+			return { compile: JSON.parse(res) };
+		}, { "X-Csrf-Token": identity.csrfToken }, 3e5);
+	}
+	async stopCompile(identity, projectId) {
+		this.setIdentity(identity);
+		return this.request("POST", `project/${projectId}/compile/stop`, void 0, void 0, { "X-Csrf-Token": identity.csrfToken });
+	}
+	async indexAll(identity, projectId) {
+		this.setIdentity(identity);
+		return this.request("POST", `project/${projectId}/references/indexAll`, { shouldBroadcast: false }, void 0);
+	}
+	async getMetadata(identity, projectId) {
+		this.setIdentity(identity);
+		return this.request("GET", `project/${projectId}/metadata`, void 0, (res) => {
+			return { meta: JSON.parse(res) };
+		});
+	}
+	async proxyRequestToSpellingApi(identity, language, userId, words) {
+		const body = {
+			language,
+			skipLearnedWords: true,
+			token: userId,
+			words
+		};
+		this.setIdentity(identity);
+		return this.request("POST", "spelling/check", body, (res) => {
+			return { misspellings: JSON.parse(res).misspellings };
+		});
+	}
+	async spellingControllerLearn(identity, userId, word) {
+		const body = {
+			token: userId,
+			word
+		};
+		this.setIdentity(identity);
+		return this.request("POST", "spelling/learn", body);
+	}
+	async spellingControllerUnlearn(identity, word) {
+		this.setIdentity(identity);
+		return this.request("POST", "spelling/unlearn", { word }, void 0, { "X-Csrf-Token": identity.csrfToken });
+	}
+	async getProjectSettings(identity, projectId) {
+		this.setIdentity(identity);
+		return this.request("GET", `project/${projectId}`, void 0, (res) => {
+			const body = res || "";
+			const learnedWordsMatch = /<meta\s+name="ol-learnedWords"\s+data-type="json"\s+content="(\[.*?\])">/.exec(body);
+			const learnedWords = learnedWordsMatch !== null ? JSON.parse(learnedWordsMatch[1].replace(/&quot;/g, "\"")) : [];
+			const languagesMatch = /<meta\s+name="ol-languages"\s+data-type="json"\s+content="(\[.*?\])">/.exec(body);
+			const languages = languagesMatch !== null ? JSON.parse(languagesMatch[1].replace(/&quot;/g, "\"")) : [];
+			if (languages.length) languages.unshift({
+				name: "Off",
+				code: ""
+			});
+			return { settings: {
+				learnedWords,
+				languages,
+				compilers: [
+					{
+						code: "pdflatex",
+						name: "pdfLaTex"
+					},
+					{
+						code: "latex",
+						name: "LaTex"
+					},
+					{
+						code: "xelatex",
+						name: "XeLaTex"
+					},
+					{
+						code: "lualatex",
+						name: "LuaLaTex"
+					}
+				]
+			} };
+		});
+	}
+	async updateProjectSettings(identity, projectId, setting) {
+		this.setIdentity(identity);
+		return this.request("POST", `project/${projectId}/settings`, setting);
+	}
+	async getFileFromClsi(identity, url, compileGroup, clsiServerId, pdfDownloadDomain) {
+		if (pdfDownloadDomain && clsiServerId) {
+			const cdnUrl = `${pdfDownloadDomain.replace(/\/+$/, "")}/${url.replace(/^\/+/g, "")}?compileGroup=${encodeURIComponent(compileGroup)}&clsiserverid=${encodeURIComponent(clsiServerId)}&enable_pdf_caching=true`;
+			const content = await this._downloadAbsolute(cdnUrl, false);
+			return {
+				type: "success",
+				content: new Uint8Array(content)
+			};
+		}
+		url = url.replace(/^\/+/g, "");
+		this.setIdentity(identity);
+		const content = await this.download(url);
+		return {
+			type: "success",
+			content: new Uint8Array(content)
+		};
+	}
+	/** Download from an absolute URL, optionally including web frontend cookies. */
+	async _downloadAbsolute(absoluteUrl, includeCookies) {
+		const headers = { Connection: "keep-alive" };
+		if (includeCookies && this.identity) headers["Cookie"] = this.identity.cookies;
+		let content = [];
+		while (true) {
+			const res = await this.scheduler.fetch(absoluteUrl, {
+				method: "GET",
+				redirect: "manual",
+				headers
+			});
+			if (res.status === 200) {
+				content.push(Buffer.from(await res.arrayBuffer()));
+				break;
+			} else if (res.status === 206) content.push(Buffer.from(await res.arrayBuffer()));
+			else break;
+		}
+		return Buffer.concat(content);
+	}
+	async proxySyncPdf(identity, projectId, page, h, v, buildId) {
+		this.setIdentity(identity);
+		const request = `project/${projectId}/sync/pdf?page=${page}&h=${h.toFixed(2)}&v=${v.toFixed(2)}&editorId=${v4()}&buildId=${buildId}`;
+		return this.request("GET", request, void 0, (res) => {
+			return { syncPdf: JSON.parse(res).code[0] };
+		});
+	}
+	async proxySyncCode(identity, projectId, file, line, column, buildId) {
+		this.setIdentity(identity);
+		return this.request("GET", `project/${projectId}/sync/code?file=${file}&line=${line}&column=${column}&editorId=${v4()}&buildId=${buildId}`, void 0, (res) => {
+			return { syncCode: JSON.parse(res).pdf };
+		});
+	}
+	async getAllTags(identity) {
+		this.setIdentity(identity);
+		return this.request("GET", "tag", void 0, (res) => {
+			return { tags: JSON.parse(res) };
+		});
+	}
+	async createTag(identity, name) {
+		this.setIdentity(identity);
+		return this.request("POST", "tag", { name }, (res) => {
+			return { tags: JSON.parse(res) };
+		});
+	}
+	async renameTag(identity, tagId, name) {
+		this.setIdentity(identity);
+		return this.request("POST", `tag/${tagId}/rename`, { name });
+	}
+	async deleteTag(identity, tagId) {
+		this.setIdentity(identity);
+		return this.request("DELETE", `tag/${tagId}`);
+	}
+	async addProjectToTag(identity, tagId, projectId) {
+		this.setIdentity(identity);
+		return this.request("POST", `tag/${tagId}/project/${projectId}`);
+	}
+	async removeProjectFromTag(identity, tagId, projectId) {
+		this.setIdentity(identity);
+		return this.request("DELETE", `tag/${tagId}/project/${projectId}`);
+	}
+	async proxyToHistoryApiAndGetUpdates(identity, projectId, before) {
+		const beforeQuery = before ? `&before=${before}` : "";
+		this.setIdentity(identity);
+		return this.request("GET", `project/${projectId}/updates?min_count=10${beforeQuery}`, void 0, (res) => {
+			return { updates: JSON.parse(res) };
+		});
+	}
+	async proxyToHistoryApiAndGetFileDiff(identity, projectId, pathname, from, to) {
+		this.setIdentity(identity);
+		return this.request("GET", `project/${projectId}/diff?pathname=${pathname}&from=${from}&to=${to}`, void 0, (res) => {
+			return { diff: JSON.parse(res) };
+		});
+	}
+	async proxyToHistoryApiAndGetFileTreeDiff(identity, projectId, from, to) {
+		this.setIdentity(identity);
+		return this.request("GET", `project/${projectId}/filetree/diff?from=${from}&to=${to}`, void 0, (res) => {
+			return { treeDiff: JSON.parse(res) };
+		});
+	}
+	async downloadZipOfVersion(identity, projectId, version) {
+		this.setIdentity(identity);
+		const content = await this.download(`project/${projectId}/version/${version}/zip`);
+		return {
+			type: "success",
+			content: new Uint8Array(content)
+		};
+	}
+	async getLabels(identity, projectId) {
+		this.setIdentity(identity);
+		return this.request("GET", `project/${projectId}/labels`, void 0, (res) => {
+			return { labels: JSON.parse(res) };
+		});
+	}
+	async createLabel(identity, projectId, comment, version) {
+		this.setIdentity(identity);
+		return this.request("POST", `project/${projectId}/labels`, {
+			comment,
+			version
+		}, (res) => {
+			return { labels: [JSON.parse(res)] };
+		});
+	}
+	async deleteLabel(identity, projectId, labelId) {
+		this.setIdentity(identity);
+		return this.request("DELETE", `project/${projectId}/labels/${labelId}`);
+	}
+	async getMessages(identity, projectId, limit = 50) {
+		this.setIdentity(identity);
+		return this.request("GET", `project/${projectId}/messages?limit=${limit}`, void 0, (res) => {
+			return { messages: JSON.parse(res) };
+		}, { "X-Csrf-Token": identity.csrfToken });
+	}
+	async sendMessage(identity, projectId, client_id, content) {
+		this.setIdentity(identity);
+		return this.request("POST", `project/${projectId}/messages`, {
+			client_id,
+			content
+		}, void 0, { "X-Csrf-Token": identity.csrfToken });
+	}
+};
+var ExtendedBaseAPI = class extends BaseAPI {
+	async refreshLinkedFile(identity, project_id, file_id) {
+		this.setIdentity(identity);
+		return await this.request("POST", `project/${project_id}/linked_file/${file_id}/refresh`, { shouldReindexReferences: false }, (res) => {
+			return { message: JSON.parse(res).new_file_id };
+		}, { "X-Csrf-Token": identity.csrfToken });
+	}
+	async createLinkedFile(identity, project_id, parent_folder_id, name, provider, data) {
+		this.setIdentity(identity);
+		return await this.request("POST", `project/${project_id}/linked_file`, {
+			name,
+			parent_folder_id,
+			provider,
+			data
+		}, (res) => {
+			return { message: JSON.parse(res).new_file_id };
+		}, { "X-Csrf-Token": identity.csrfToken });
+	}
+};
+const SOCKET_OPERATION_TIMEOUT_MS = 15e3;
+function decodePackedUtf8(text) {
+	return Buffer.from(text, "latin1").toString("utf-8");
+}
+var SocketIOAPI = class SocketIOAPI {
+	url;
+	api;
+	identity;
+	projectId;
+	static alternativeSocketFactory;
+	scheme;
+	record;
+	joinedProject;
+	pendingProjectJoin;
+	_handlers = [];
+	connectedPublicId;
+	socket;
+	emit;
+	/** Track the scheme used when the socket was last initialized */
+	_socketInitScheme;
+	constructor(url, api, identity, projectId) {
+		this.url = url;
+		this.api = api;
+		this.identity = identity;
+		this.projectId = projectId;
+		this.scheme = "realtime";
+		this.init();
+	}
+	static setAlternativeSocketFactory(factory) {
+		SocketIOAPI.alternativeSocketFactory = factory;
+	}
+	init() {
+		if (this.socket) try {
+			if (typeof this.socket.removeAllListeners === "function") this.socket.removeAllListeners();
+			if (typeof this.socket.disconnect === "function") this.socket.disconnect();
+		} catch {}
+		switch (this.scheme) {
+			case "Alt":
+				if (!SocketIOAPI.alternativeSocketFactory) throw new Error("The alternative Overleaf connection is not available in this runtime.");
+				this.socket = SocketIOAPI.alternativeSocketFactory(this.url, this.api, this.identity, this.projectId, this.record);
+				break;
+			case "realtime":
+				this.record = void 0;
+				this.joinedProject = void 0;
+				this.resetProjectJoin(/* @__PURE__ */ new Error("The realtime connection was replaced."));
+				const query = `?projectId=${this.projectId}&t=${Date.now()}`;
+				this.socket = this.api._initSocketV0(this.identity, query);
+		}
+		this.socket.emit[promisify.custom] = (event, ...args) => {
+			const timeoutPromise = new Promise((_, reject) => {
+				setTimeout(() => {
+					reject("timeout");
+				}, SOCKET_OPERATION_TIMEOUT_MS);
+			});
+			const waitPromise = new Promise((resolve, reject) => {
+				this.socket.emit(event, ...args, (err, ...data) => {
+					if (err) reject(err);
+					else resolve(data);
+				});
+			});
+			return Promise.race([waitPromise, timeoutPromise]);
+		};
+		this.emit = promisify(this.socket.emit).bind(this.socket);
+		this.initInternalHandlers();
+		this.resumeEventHandlers(this._handlers);
+		this._socketInitScheme = this.scheme;
+	}
+	/** Returns true if the socket needs re-initialization (scheme changed, or socket was never init'd) */
+	get needsReinit() {
+		return this._socketInitScheme !== this.scheme || !this.socket;
+	}
+	get connectionScheme() {
+		return this.scheme;
+	}
+	initInternalHandlers() {
+		this.socket.on("connect", () => {
+			log("SocketIOAPI: connected", {
+				scheme: this.scheme,
+				projectId: this.projectId
+			});
+		});
+		this.socket.on("connect_failed", (connectionError) => {
+			log("SocketIOAPI: connect_failed", {
+				scheme: this.scheme,
+				projectId: this.projectId,
+				error: connectionError
+			});
+		});
+		this.socket.on("disconnect", (reason) => {
+			log("SocketIOAPI: disconnect event", {
+				scheme: this.scheme,
+				projectId: this.projectId,
+				reason
+			});
+			if (this.scheme === "realtime") {
+				this.joinedProject = void 0;
+				this.connectedPublicId = void 0;
+				this.resetProjectJoin(/* @__PURE__ */ new Error(`Overleaf realtime connection closed: ${String(reason ?? "unknown")}`));
+			}
+		});
+		this.socket.on("reconnecting", (delay, attempt) => {
+			log("SocketIOAPI: reconnecting", {
+				scheme: this.scheme,
+				projectId: this.projectId,
+				delay,
+				attempt
+			});
+		});
+		this.socket.on("reconnect", (transport, attempts) => {
+			log("SocketIOAPI: reconnected", {
+				scheme: this.scheme,
+				projectId: this.projectId,
+				transport,
+				attempts
+			});
+		});
+		this.socket.on("reconnect_failed", (error) => {
+			log("SocketIOAPI: reconnect_failed", {
+				scheme: this.scheme,
+				projectId: this.projectId,
+				error
+			});
+		});
+		this.socket.on("forceDisconnect", (message, delay = 10) => {
+			log("SocketIOAPI: forceDisconnect", {
+				message,
+				delay,
+				projectId: this.projectId
+			});
+		});
+		this.socket.on("connectionRejected", (err) => {
+			log("SocketIOAPI: connectionRejected", {
+				scheme: this.scheme,
+				projectId: this.projectId,
+				error: err
+			});
+			if (this.socket.io && typeof this.socket.io.reconnect === "function") this.socket.io.reconnect(false);
+		});
+		this.socket.on("error", (err) => {
+			error(`Overleaf connection error: ${err?.message || String(err)}`);
+		});
+		if (this.scheme === "realtime") {
+			this.pendingProjectJoin ??= this.createProjectJoin();
+			this.socket.on("joinProjectResponse", (res) => {
+				const publicId = res.publicId;
+				const project = res.project;
+				this.socket.markProjectJoined?.();
+				log("SocketIOAPI: project joined", {
+					scheme: this.scheme,
+					projectId: this.projectId,
+					publicId
+				});
+				this.connectedPublicId = publicId;
+				this.joinedProject = project;
+				this.pendingProjectJoin?.resolve(project);
+				for (const handler of this._handlers) {
+					handler.onProjectJoined?.(project);
+					handler.onConnectionAccepted?.(publicId);
+				}
+			});
+			this.socket.on("connectionRejected", (err) => {
+				this.pendingProjectJoin?.reject(err?.message || err);
+			});
+		}
+	}
+	createProjectJoin() {
+		let resolve;
+		let reject;
+		const promise = new Promise((resolveProject, rejectProject) => {
+			resolve = resolveProject;
+			reject = rejectProject;
+		});
+		promise.catch(() => void 0);
+		return {
+			promise,
+			resolve,
+			reject
+		};
+	}
+	resetProjectJoin(reason) {
+		if (reason !== void 0) this.pendingProjectJoin?.reject(reason);
+		this.pendingProjectJoin = this.createProjectJoin();
+	}
+	waitForRealtimeProject() {
+		return this.joinedProject ? Promise.resolve(this.joinedProject) : this.pendingProjectJoin.promise;
+	}
+	async emitProjectEvent(event, ...args) {
+		if (this.scheme === "realtime") await this.waitForRealtimeProject();
+		return this.emit(event, ...args);
+	}
+	disconnect() {
+		this.socket.disconnect();
+	}
+	get handlers() {
+		return this._handlers;
+	}
+	get isUsingAlternativeConnectionScheme() {
+		return this.scheme === "Alt";
+	}
+	toggleAlternativeConnectionScheme(url, updatedRecord) {
+		this.scheme = this.scheme === "Alt" ? "realtime" : "Alt";
+		if (updatedRecord) {
+			this.url = url;
+			this.record = Promise.resolve(updatedRecord);
+		}
+	}
+	resumeEventHandlers(handlers) {
+		this._handlers = [];
+		handlers.forEach((handler) => {
+			this.updateEventHandlers(handler);
+		});
+	}
+	updateEventHandlers(handlers) {
+		this._handlers.push(handlers);
+		Object.values(handlers).forEach((handler) => {
+			switch (handler) {
+				case handlers.onFileCreated:
+					this.socket.on("reciveNewDoc", (parentFolderId, doc) => {
+						handler(parentFolderId, "doc", doc);
+					});
+					this.socket.on("reciveNewFile", (parentFolderId, file) => {
+						handler(parentFolderId, "file", file);
+					});
+					this.socket.on("reciveNewFolder", (parentFolderId, folder) => {
+						handler(parentFolderId, "folder", folder);
+					});
+					break;
+				case handlers.onFileRenamed:
+					this.socket.on("reciveEntityRename", (entityId, newName) => {
+						handler(entityId, newName);
+					});
+					break;
+				case handlers.onFileRemoved:
+					this.socket.on("removeEntity", (entityId) => {
+						handler(entityId);
+					});
+					break;
+				case handlers.onFileMoved:
+					this.socket.on("reciveEntityMove", (entityId, folderId) => {
+						handler(entityId, folderId);
+					});
+					break;
+				case handlers.onFileChanged:
+					this.socket.on("otUpdateApplied", (update) => {
+						handler(update);
+					});
+					break;
+				case handlers.onDisconnected:
+					this.socket.on("disconnect", (reason) => {
+						handler(reason);
+					});
+					break;
+				case handlers.onProjectJoined: break;
+				case handlers.onConnectionAccepted:
+					this.socket.on("connectionAccepted", (_, publicId) => {
+						handler(publicId);
+					});
+					if (this.connectedPublicId !== void 0) queueMicrotask(() => handler(this.connectedPublicId));
+					break;
+				case handlers.onClientUpdated:
+					this.socket.on("clientTracking.clientUpdated", (user) => {
+						handler(user);
+					});
+					break;
+				case handlers.onClientDisconnected:
+					this.socket.on("clientTracking.clientDisconnected", (id) => {
+						handler(id);
+					});
+					break;
+				case handlers.onReceivedMessage:
+					this.socket.on("new-chat-message", (message) => {
+						handler(message);
+					});
+					break;
+				case handlers.onSpellCheckLanguageUpdated:
+					this.socket.on("spellCheckLanguageUpdated", (language) => {
+						handler(language);
+					});
+					break;
+				case handlers.onCompilerUpdated:
+					this.socket.on("compilerUpdated", (compiler) => {
+						handler(compiler);
+					});
+					break;
+				case handlers.onRootDocUpdated: this.socket.on("rootDocUpdated", (rootDocId) => {
+					handler(rootDocId);
+				});
+			}
+		});
+	}
+	get unSyncFileChanges() {
+		return this.scheme === "Alt" ? this.socket.unSyncedChanges : 0;
+	}
+	async syncFileChanges() {
+		if (this.scheme === "Alt") return await this.socket.uploadToVFS();
+	}
+	/**
+	* Reference: services/web/frontend/js/ide/connection/ConnectionManager.js#L427
+	* @param {string} projectId - The project id.
+	* @returns {Promise}
+	*/
+	async joinProject(project_id) {
+		const timeoutPromise = new Promise((_, reject) => {
+			setTimeout(() => {
+				reject("timeout");
+			}, SOCKET_OPERATION_TIMEOUT_MS);
+		});
+		switch (this.scheme) {
+			case "Alt": return Promise.race([this.emit("joinProject", { project_id }).then((returns) => returns[0]), timeoutPromise]);
+			case "realtime": return Promise.race([this.waitForRealtimeProject(), timeoutPromise]);
+		}
+	}
+	/**
+	* Reference: services/web/frontend/js/ide/editor/Document.js#L500
+	* @param {string} docId - The document id.
+	* @returns {Promise}
+	*/
+	async joinDoc(docId) {
+		return this.emitProjectEvent("joinDoc", docId, { encodeRanges: true }).then((returns) => {
+			const [docLinesAscii, version, updates, ranges] = returns;
+			return {
+				docLines: docLinesAscii.map((line) => decodePackedUtf8(line)),
+				version,
+				updates,
+				ranges
+			};
+		});
+	}
+	/**
+	* Reference: services/web/frontend/js/ide/editor/Document.js#L591
+	* @param {string} docId - The document id.
+	* @returns {Promise}
+	*/
+	async leaveDoc(docId) {
+		return this.emitProjectEvent("leaveDoc", docId).then(() => {});
+	}
+	/**
+	* Reference: services/web/frontend/js/ide/editor/ShareJsDocs.js#L78
+	* @param {string} docId - The document id.
+	* @param {any} update - The changes.
+	* @returns {Promise}
+	*/
+	async applyOtUpdate(docId, update) {
+		try {
+			await this.emitProjectEvent("applyOtUpdate", docId, update);
+		} catch (error) {
+			let detail;
+			if (error instanceof Error) detail = error.message;
+			else if (typeof error === "string") detail = error;
+			else try {
+				detail = JSON.stringify(error);
+			} catch {
+				detail = String(error);
+			}
+			throw new Error(`Overleaf document update rejected: ${detail}`);
+		}
+	}
+	/**
+	* Reference: services/web/frontend/js/ide/online-users/OnlineUserManager.js#L42
+	* @returns {Promise}
+	*/
+	async getConnectedUsers() {
+		return this.emitProjectEvent("clientTracking.getConnectedUsers").then((returns) => {
+			const [connectedUsers] = returns;
+			return connectedUsers;
+		});
+	}
+	/**
+	* Reference: services/web/frontend/js/ide/online-users/OnlineUserManager.js#L150
+	* @param {string} docId - The document id.
+	* @returns {Promise}
+	*/
+	async updatePosition(doc_id, row, column) {
+		return this.emitProjectEvent("clientTracking.updatePosition", {
+			row,
+			column,
+			doc_id
+		}).then(() => {});
+	}
+};
+function configPath(environment = process.env) {
+	return environment.LEAFRELAY_CONFIG ? resolve(environment.LEAFRELAY_CONFIG) : join(environment.LEAFRELAY_HOME ? resolve(environment.LEAFRELAY_HOME) : join(homedir(), ".leafrelay"), "config.json");
+}
+function normalizeServerUrl(value) {
+	const url = new URL(value.includes("://") ? value : `https://${value}`);
+	url.pathname = "/";
+	url.search = "";
+	url.hash = "";
+	return url.href;
+}
+function serverKey(value) {
+	return new URL(normalizeServerUrl(value)).host;
+}
+async function readConfig(path = configPath()) {
+	try {
+		const parsed = JSON.parse(await readFile(path, "utf8"));
+		if (parsed.version !== 1 || typeof parsed.servers !== "object" || parsed.servers === null) throw new Error(`Unsupported LeafRelay configuration in ${path}`);
+		return parsed;
+	} catch (error) {
+		if (error.code === "ENOENT") return {
+			version: 1,
+			servers: {},
+			knownServers: {}
+		};
+		throw error;
+	}
+}
+async function writeConfig(config, path = configPath()) {
+	await mkdir(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, {
+		encoding: "utf8",
+		mode: 384
+	});
+	await chmod(path, 384);
+}
+async function saveServerSession(session, path = configPath()) {
+	const config = await readConfig(path);
+	const key = serverKey(session.url);
+	config.servers[key] = session;
+	config.knownServers ??= {};
+	config.knownServers[key] ??= {
+		name: key,
+		url: session.url
+	};
+	await writeConfig(config, path);
+}
+async function saveKnownServer(name, url, path = configPath()) {
+	const config = await readConfig(path);
+	const key = serverKey(url);
+	config.knownServers ??= {};
+	config.knownServers[key] = {
+		name,
+		url: normalizeServerUrl(url)
+	};
+	await writeConfig(config, path);
+}
+async function removeKnownServer(server, path = configPath()) {
+	const config = await readConfig(path);
+	const key = serverKey(server);
+	delete config.servers[key];
+	delete config.knownServers?.[key];
+	await writeConfig(config, path);
+}
+async function removeServerSession(server, path = configPath()) {
+	const config = await readConfig(path);
+	delete config.servers[serverKey(server)];
+	await writeConfig(config, path);
+}
+async function getServerSession(server, environment = process.env, path = configPath(environment)) {
+	const key = serverKey(server);
+	const stored = (await readConfig(path)).servers[key];
+	const cookie = environment.LEAFRELAY_COOKIE;
+	if (!cookie) return stored;
+	return {
+		url: stored?.url ?? normalizeServerUrl(server),
+		userId: stored?.userId ?? "",
+		userEmail: stored?.userEmail ?? "",
+		identity: {
+			cookies: cookie,
+			csrfToken: stored?.identity.csrfToken ?? ""
+		},
+		updatedAt: stored?.updatedAt ?? (/* @__PURE__ */ new Date(0)).toISOString()
+	};
+}
+function projectPath(root, path) {
+	const target = resolve(root, path.replace(/^\/+/, ""));
+	const relativePath = relative(root, target);
+	if (relativePath.startsWith("..") || relativePath === "..") throw new Error(`Path escapes the local project: ${path}`);
+	return target;
+}
+function syncPath(root, path) {
+	return `/${relative(root, path).split(sep).join("/")}`;
+}
+var NodeReplicaFileSystem = class {
+	root;
+	ignore;
+	watcher;
+	constructor(root, ignore) {
+		this.root = root;
+		this.ignore = ignore;
+	}
+	async listFiles() {
+		const files = [];
+		const visit = async (directory) => {
+			for (const entry of await readdir(directory, { withFileTypes: true })) {
+				const absolute = resolve(directory, entry.name);
+				const path = syncPath(this.root, absolute);
+				if (this.ignore(path) || entry.name.startsWith(".") || entry.isSymbolicLink()) continue;
+				if (entry.isDirectory()) await visit(absolute);
+				else if (entry.isFile()) files.push(path);
+			}
+		};
+		await visit(this.root);
+		return files.sort();
+	}
+	async read(path) {
+		const target = projectPath(this.root, path);
+		try {
+			const stat = await lstat(target);
+			if (!stat.isFile() || stat.isSymbolicLink()) return;
+			return new Uint8Array(await readFile(target));
+		} catch (error) {
+			if (error.code === "ENOENT") return;
+			throw error;
+		}
+	}
+	async write(path, content) {
+		const target = projectPath(this.root, path);
+		await mkdir(dirname(target), { recursive: true });
+		await writeFile(target, content);
+	}
+	async remove(path) {
+		await rm(projectPath(this.root, path), {
+			force: true,
+			recursive: true
+		});
+	}
+	async watch(onChange) {
+		this.watcher = watch(this.root, {
+			ignoreInitial: true,
+			followSymlinks: false,
+			ignored: (path) => {
+				const relativePath = relative(this.root, path);
+				if (!relativePath) return false;
+				const normalized = `/${relativePath.split(sep).join("/")}`;
+				return this.ignore(normalized) || normalized.split("/").some((part) => part.startsWith("."));
+			},
+			awaitWriteFinish: {
+				stabilityThreshold: 200,
+				pollInterval: 50
+			}
+		});
+		const handler = (path) => onChange(syncPath(this.root, path));
+		this.watcher.on("add", handler).on("change", handler).on("unlink", handler);
+		await new Promise((resolveReady, reject) => {
+			this.watcher.once("ready", resolveReady).once("error", reject);
+		});
+		return async () => {
+			await this.watcher?.close();
+		};
+	}
+};
+function parseProjectUri(value) {
+	const uri = new URL(value);
+	const decodedQuery = decodeURIComponent(uri.search.slice(1));
+	const query = new URLSearchParams(decodedQuery);
+	const projectId = query.get("project");
+	if (!projectId) throw new Error("The project URI in .overleaf/settings.json does not contain a project ID.");
+	return {
+		serverName: uri.host,
+		projectId,
+		projectName: decodeURIComponent(uri.pathname.split("/").filter(Boolean)[0] ?? ""),
+		userId: query.get("user") ?? void 0
+	};
+}
+async function readProjectSettings(directory) {
+	const settingsPath = resolve(directory, ".overleaf", "settings.json");
+	const raw = JSON.parse(await readFile(settingsPath, "utf8"));
+	if (typeof raw.uri !== "string") throw new Error(`${settingsPath} does not contain a valid project URI.`);
+	const parsed = parseProjectUri(raw.uri);
+	const serverName = typeof raw.serverName === "string" ? raw.serverName : parsed.serverName;
+	const localReplica = raw.localReplica;
+	return {
+		uri: raw.uri,
+		serverName,
+		serverUrl: typeof raw.serverUrl === "string" ? raw.serverUrl : `https://${serverName}/`,
+		projectId: parsed.projectId,
+		projectName: typeof raw.projectName === "string" ? raw.projectName : parsed.projectName,
+		userId: parsed.userId,
+		localReplica: { settings: localReplica?.settings ?? {} }
+	};
+}
+const DEFAULT_IGNORE_PATTERNS = [
+	"**/.*",
+	"**/.*/**",
+	"**/*.aux",
+	"**/__latexindent*",
+	"**/*.bbl",
+	"**/*.bcf",
+	"**/*.blg",
+	"**/*.fdb_latexmk",
+	"**/*.fls",
+	"**/*.lof",
+	"**/*.log",
+	"**/*.lot",
+	"**/*.out",
+	"**/*.run.xml",
+	"**/*.synctex(busy)",
+	"**/*.synctex.gz",
+	"**/*.toc",
+	"**/*.xdv",
+	"**/main.pdf",
+	"**/output.pdf"
+];
+function createIgnoreMatcher(patterns) {
+	const configured = Array.isArray(patterns) ? patterns.filter((pattern) => typeof pattern === "string") : [];
+	const allPatterns = [...DEFAULT_IGNORE_PATTERNS, ...configured];
+	return (path) => {
+		const normalized = path.replace(/^\/+/, "");
+		return normalized.split("/").some((part) => part.startsWith(".")) || allPatterns.some((pattern) => minimatch(normalized, pattern, { dot: true }));
+	};
+}
+function normalizePath$1(path) {
+	const normalized = `/${posix.normalize(path).replace(/^\/+/, "")}`;
+	if (normalized.includes("/../") || normalized.endsWith("/..")) throw new Error(`Invalid project path: ${path}`);
+	return normalized;
+}
+function textContent(content) {
+	if (content.includes(0)) return;
+	try {
+		return new TextDecoder("utf-8", { fatal: true }).decode(content);
+	} catch {
+		return;
+	}
+}
+var RemoteProject = class {
+	url;
+	projectId;
+	cookies;
+	api;
+	identity;
+	socket;
+	project;
+	entries = /* @__PURE__ */ new Map();
+	idToPath = /* @__PURE__ */ new Map();
+	collaboratorNames = /* @__PURE__ */ new Map();
+	changeHandler;
+	reconnectHandler;
+	externalTransport;
+	constructor(url, projectId, cookies, transport) {
+		this.url = url;
+		this.projectId = projectId;
+		this.cookies = cookies;
+		this.externalTransport = transport;
+		this.api = transport?.api ?? new BaseAPI(url);
+	}
+	async connect() {
+		if (this.externalTransport) {
+			this.identity = this.externalTransport.identity;
+			this.socket = this.externalTransport.socket;
+		} else {
+			const login = await this.api.cookiesLogin(this.cookies);
+			if (login.type !== "success" || !login.identity) throw new Error(login.message || `Authentication to ${this.url} failed.`);
+			this.identity = login.identity;
+			this.socket = new SocketIOAPI(this.url, this.api, this.identity, this.projectId);
+		}
+		this.project = await this.socket.joinProject(this.projectId);
+		this.indexCollaborators();
+		this.reindex();
+		this.registerEvents();
+	}
+	disconnect() {
+		if (!this.externalTransport) this.socket?.disconnect();
+	}
+	onChange(handler) {
+		this.changeHandler = handler;
+		return () => {
+			if (this.changeHandler === handler) this.changeHandler = void 0;
+		};
+	}
+	onReconnect(handler) {
+		this.reconnectHandler = handler;
+		return () => {
+			if (this.reconnectHandler === handler) this.reconnectHandler = void 0;
+		};
+	}
+	listEntries() {
+		return [...this.entries.values()];
+	}
+	entry(path) {
+		return this.entries.get(normalizePath$1(path));
+	}
+	async read(path) {
+		const entry = this.requireEntry(path);
+		if (entry.type === "doc") {
+			const result = await this.socket.joinDoc(entry.entity._id);
+			return new TextEncoder().encode(result.docLines.join("\n"));
+		}
+		if (entry.type === "file") {
+			const result = await this.api.getFile(this.identity, this.projectId, entry.entity._id);
+			if (result.type === "success" && result.content) return result.content;
+			throw new Error(`Could not download ${path}.`);
+		}
+		throw new Error(`${path} is not a file.`);
+	}
+	async mkdir(path) {
+		const normalized = normalizePath$1(path);
+		if (this.entries.has(normalized)) return;
+		const { parent, name } = await this.ensureParent(normalized);
+		const result = await this.api.addFolder(this.identity, this.projectId, name, parent._id);
+		if (result.type !== "success" || !result.entity) throw new Error(result.message || `Could not create ${normalized}.`);
+		const folder = result.entity;
+		folder._type = "folder";
+		folder.docs ??= [];
+		folder.fileRefs ??= [];
+		folder.folders ??= [];
+		parent.folders.push(folder);
+		this.reindex();
+	}
+	async write(path, content) {
+		const normalized = normalizePath$1(path);
+		const existing = this.entries.get(normalized);
+		if (existing?.type === "folder") throw new Error(`${normalized} is a directory.`);
+		if (existing?.type === "doc") {
+			await this.writeDocument(existing.entity, content);
+			return;
+		}
+		if (existing) await this.remove(normalized);
+		const { parent, name } = await this.ensureParent(normalized);
+		if (textContent(content) !== void 0) {
+			const created = await this.api.addDoc(this.identity, this.projectId, parent._id, name);
+			if (created.type !== "success" || !created.entity) throw new Error(created.message || `Could not create ${normalized}.`);
+			const entity = created.entity;
+			entity._type = "doc";
+			parent.docs.push(entity);
+			this.reindex();
+			if (content.length !== 0) await this.writeDocument(entity, content);
+			return;
+		}
+		const uploaded = await this.api.uploadFile(this.identity, this.projectId, parent._id, name, content);
+		if (uploaded.type !== "success" || !uploaded.entity) throw new Error(uploaded.message || `Could not upload ${normalized}.`);
+		const entity = uploaded.entity;
+		entity._type = "file";
+		parent.fileRefs.push(entity);
+		this.reindex();
+	}
+	async remove(path) {
+		const normalized = normalizePath$1(path);
+		const entry = this.requireEntry(normalized);
+		if (!entry.parent) throw new Error("The project root cannot be removed.");
+		const result = await this.api.deleteEntity(this.identity, this.projectId, entry.type, entry.entity._id);
+		if (result.type !== "success") throw new Error(result.message || `Could not remove ${normalized}.`);
+		this.removeFromParent(entry);
+		this.reindex();
+	}
+	async getCurrentVersion() {
+		const response = await this.api.proxyToHistoryApiAndGetUpdates(this.identity, this.projectId);
+		const version = response.updates?.updates.at(0)?.toV ?? 0;
+		if (response.type !== "success" || !Number.isInteger(version)) throw new Error(response.message || "Could not determine the current Overleaf project version.");
+		return version;
+	}
+	async getFileTreeDiff(from, to) {
+		if (from >= to) return { diff: [] };
+		const response = await this.api.proxyToHistoryApiAndGetFileTreeDiff(this.identity, this.projectId, from, to);
+		if (response.type === "success") return response.treeDiff;
+		if (response.statusCode === 404) return;
+		throw new Error(response.message || "Could not load the Overleaf file-tree history.");
+	}
+	async writeDocument(entity, content) {
+		const text = textContent(content);
+		if (text === void 0) {
+			const path = this.idToPath.get(entity._id);
+			await this.remove(path);
+			await this.write(path, content);
+			return;
+		}
+		const remote = await this.socket.joinDoc(entity._id);
+		const previous = remote.docLines.join("\n");
+		if (previous === text) return;
+		let position = 0;
+		const operations = [];
+		for (const part of new DiffMatchPatch().diff_main(previous, text)) {
+			const start = position;
+			if (part[0] !== -1) position += part[1].length;
+			if (part[0] === 1) operations.push({
+				p: start,
+				i: part[1]
+			});
+			if (part[0] === -1) operations.push({
+				p: start,
+				d: part[1]
+			});
+		}
+		const update = {
+			doc: entity._id,
+			v: remote.version,
+			hash: createHash("sha1").update(`blob ${text.length}\x00${text}`).digest("hex"),
+			op: operations
+		};
+		await this.socket.applyOtUpdate(entity._id, update);
+	}
+	async ensureParent(path) {
+		const name = posix.basename(path);
+		const parentPath = posix.dirname(path);
+		if (parentPath !== "/" && !this.entries.has(parentPath)) await this.mkdir(parentPath);
+		const parentEntry = parentPath === "/" ? this.entries.get("/") : this.entries.get(parentPath);
+		if (!parentEntry || parentEntry.type !== "folder") throw new Error(`Parent directory ${parentPath} does not exist.`);
+		return {
+			parent: parentEntry.entity,
+			name
+		};
+	}
+	requireEntry(path) {
+		const normalized = normalizePath$1(path);
+		const entry = this.entries.get(normalized);
+		if (!entry) throw new Error(`Remote path not found: ${normalized}`);
+		return entry;
+	}
+	reindex() {
+		this.entries.clear();
+		this.idToPath.clear();
+		const root = this.project.rootFolder[0];
+		root._type = "folder";
+		this.indexFolder(root, "/");
+	}
+	indexFolder(folder, path, parent) {
+		this.entries.set(path, {
+			path,
+			type: "folder",
+			entity: folder,
+			parent
+		});
+		this.idToPath.set(folder._id, path);
+		for (const child of folder.folders ?? []) {
+			child._type = "folder";
+			this.indexFolder(child, normalizePath$1(posix.join(path, child.name)), folder);
+		}
+		for (const child of folder.docs ?? []) {
+			child._type = "doc";
+			const childPath = normalizePath$1(posix.join(path, child.name));
+			this.entries.set(childPath, {
+				path: childPath,
+				type: "doc",
+				entity: child,
+				parent: folder
+			});
+			this.idToPath.set(child._id, childPath);
+		}
+		for (const child of folder.fileRefs ?? []) {
+			child._type = "file";
+			const childPath = normalizePath$1(posix.join(path, child.name));
+			this.entries.set(childPath, {
+				path: childPath,
+				type: "file",
+				entity: child,
+				parent: folder
+			});
+			this.idToPath.set(child._id, childPath);
+		}
+	}
+	folderById(id) {
+		const path = this.idToPath.get(id);
+		const entry = path ? this.entries.get(path) : void 0;
+		return entry?.type === "folder" ? entry.entity : void 0;
+	}
+	removeFromParent(entry) {
+		if (!entry.parent) return;
+		const collection = entry.type === "folder" ? entry.parent.folders : entry.type === "doc" ? entry.parent.docs : entry.parent.fileRefs;
+		const index = collection.findIndex((item) => item._id === entry.entity._id);
+		if (index !== -1) collection.splice(index, 1);
+	}
+	emitChange(path, previousPath, actor) {
+		this.changeHandler?.({
+			path: normalizePath$1(path),
+			previousPath,
+			actor
+		});
+	}
+	indexCollaborators() {
+		for (const member of [this.project.owner, ...this.project.members]) {
+			if (!member?._id) continue;
+			const name = [member.first_name, member.last_name].filter(Boolean).join(" ").trim();
+			if (name) this.collaboratorNames.set(member._id, name);
+		}
+	}
+	actor(userId) {
+		if (!userId) return;
+		const name = this.collaboratorNames.get(userId);
+		return name ? `${name} (Overleaf)` : `Overleaf user ${userId}`;
+	}
+	registerEvents() {
+		this.socket.updateEventHandlers({
+			onProjectJoined: (project) => {
+				this.project = project;
+				this.indexCollaborators();
+				this.reindex();
+				this.reconnectHandler?.();
+			},
+			onClientUpdated: (user) => {
+				if (user.user_id && user.name) this.collaboratorNames.set(user.user_id, user.name);
+			},
+			onFileCreated: (parentId, type, entity) => {
+				const parent = this.folderById(parentId);
+				if (!parent || type === "outputs") return;
+				if (this.idToPath.has(entity._id)) return;
+				entity._type = type;
+				if (type === "folder") {
+					const folder = entity;
+					folder.docs ??= [];
+					folder.fileRefs ??= [];
+					folder.folders ??= [];
+					parent.folders.push(folder);
+				} else if (type === "doc") parent.docs.push(entity);
+				else parent.fileRefs.push(entity);
+				const parentPath = this.idToPath.get(parentId) ?? "/";
+				this.reindex();
+				this.emitChange(posix.join(parentPath, entity.name));
+			},
+			onFileRenamed: (entityId, newName) => {
+				const previousPath = this.idToPath.get(entityId);
+				if (!previousPath) return;
+				this.entries.get(previousPath).entity.name = newName;
+				this.reindex();
+				this.emitChange(this.idToPath.get(entityId), previousPath);
+			},
+			onFileRemoved: (entityId) => {
+				const previousPath = this.idToPath.get(entityId);
+				if (!previousPath) return;
+				const entry = this.entries.get(previousPath);
+				this.removeFromParent(entry);
+				this.reindex();
+				this.emitChange(previousPath);
+			},
+			onFileMoved: (entityId, parentId) => {
+				const previousPath = this.idToPath.get(entityId);
+				const nextParent = this.folderById(parentId);
+				if (!previousPath || !nextParent) return;
+				const entry = this.entries.get(previousPath);
+				this.removeFromParent(entry);
+				if (entry.type === "folder") nextParent.folders.push(entry.entity);
+				else if (entry.type === "doc") nextParent.docs.push(entry.entity);
+				else nextParent.fileRefs.push(entry.entity);
+				this.reindex();
+				this.emitChange(this.idToPath.get(entityId), previousPath);
+			},
+			onFileChanged: (update) => {
+				const path = this.idToPath.get(update.doc);
+				if (path) this.emitChange(path, void 0, this.actor(update.meta?.user_id));
+			}
+		});
+	}
+};
+const decoder = new TextDecoder("utf-8", { fatal: true });
+function decode(content) {
+	if (content === void 0) return "";
+	if (content.includes(0)) return;
+	try {
+		return decoder.decode(content);
+	} catch {
+		return;
+	}
+}
+function lineStarts(content) {
+	const starts = [0];
+	for (let index = 0; index < content.length; index++) if (content[index] === "\n" && index + 1 < content.length) starts.push(index + 1);
+	return starts;
+}
+function lineAt(starts, offset) {
+	let low = 0;
+	let high = starts.length;
+	while (low < high) {
+		const middle = Math.floor((low + high) / 2);
+		if (starts[middle] <= offset) low = middle + 1;
+		else high = middle;
+	}
+	return Math.max(1, low);
+}
+function toLineRange(content, start, end) {
+	const starts = lineStarts(content);
+	const safeStart = Math.min(start, Math.max(0, content.length - 1));
+	const safeEnd = Math.min(Math.max(start, end - 1), Math.max(0, content.length - 1));
+	return {
+		start: lineAt(starts, safeStart),
+		end: lineAt(starts, safeEnd)
+	};
+}
+function mergeRanges(ranges) {
+	const merged = [];
+	for (const range of ranges.sort((a, b) => a.start - b.start)) {
+		const previous = merged.at(-1);
+		if (previous && range.start <= previous.end + 1) previous.end = Math.max(previous.end, range.end);
+		else merged.push({ ...range });
+	}
+	return merged;
+}
+function formatRanges(ranges) {
+	const shown = ranges.slice(0, 3).map((range) => range.start === range.end ? String(range.start) : `${range.start}-${range.end}`);
+	return `${shown.join(", ")}${ranges.length > shown.length ? ` (+${ranges.length - shown.length} more)` : ""}`;
+}
+function describeContentChange(before, after) {
+	if (before && after && Buffer.from(before).equals(Buffer.from(after))) return;
+	const oldText = decode(before);
+	const newText = decode(after);
+	if (oldText === void 0 || newText === void 0) return `binary bytes ${before?.byteLength ?? 0} -> ${after?.byteLength ?? 0}`;
+	if (oldText.length === 0 && newText.length === 0) return;
+	if (oldText.length === 0) {
+		const count = lineStarts(newText).length;
+		return `added lines ${count === 1 ? "1" : `1-${count}`}`;
+	}
+	if (newText.length === 0) {
+		const count = lineStarts(oldText).length;
+		return `removed lines ${count === 1 ? "1" : `1-${count}`}`;
+	}
+	const changes = [];
+	let oldOffset = 0;
+	let newOffset = 0;
+	let current;
+	const finish = () => {
+		if (current) {
+			changes.push(current);
+			current = void 0;
+		}
+	};
+	for (const [operation, value] of new DiffMatchPatch().diff_main(oldText, newText)) {
+		if (operation === 0) {
+			finish();
+			oldOffset += value.length;
+			newOffset += value.length;
+			continue;
+		}
+		current ??= {
+			oldStart: oldOffset,
+			oldEnd: oldOffset,
+			newStart: newOffset,
+			newEnd: newOffset
+		};
+		if (operation === -1) oldOffset += value.length;
+		if (operation === 1) newOffset += value.length;
+		current.oldEnd = oldOffset;
+		current.newEnd = newOffset;
+	}
+	finish();
+	const ranges = mergeRanges(changes.map((change) => change.newEnd > change.newStart ? toLineRange(newText, change.newStart, change.newEnd) : toLineRange(oldText, change.oldStart, change.oldEnd)));
+	return ranges.length === 0 ? void 0 : `lines ${formatRanges(ranges)}`;
+}
+const textDecoder = new TextDecoder("utf-8", { fatal: true });
+const textEncoder = new TextEncoder();
+function decodeText(content) {
+	if (content.includes(0)) return;
+	try {
+		return textDecoder.decode(content);
+	} catch {
+		return;
+	}
+}
+function splitLines(content) {
+	return content.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+}
+function encodeTextBase(content) {
+	return decodeText(content);
+}
+function mergeText(baseContent, localContent, remoteContent) {
+	const base = decodeText(baseContent);
+	const local = decodeText(localContent);
+	const remote = decodeText(remoteContent);
+	if (base === void 0 || local === void 0 || remote === void 0) return { status: "binary" };
+	const regions = diff3Merge(splitLines(local), splitLines(base), splitLines(remote), { excludeFalseConflicts: true });
+	if (regions.some((region) => region.conflict !== void 0)) return { status: "conflict" };
+	return {
+		status: "merged",
+		content: textEncoder.encode(regions.flatMap((region) => region.ok ?? []).join(""))
+	};
+}
+function sha256(content) {
+	return createHash("sha256").update(content).digest("hex");
+}
+function createSyncState(projectUri, remoteVersion, initialized = true) {
+	return {
+		schemaVersion: 1,
+		projectUri,
+		remoteVersion,
+		initialized,
+		files: {},
+		textBases: {},
+		conflicts: {}
+	};
+}
+function updateSyncCheckpoint(state, path, content) {
+	state.files[path] = sha256(content);
+	const textBase = encodeTextBase(content);
+	if (textBase === void 0) delete state.textBases[path];
+	else state.textBases[path] = textBase;
+}
+function removeSyncCheckpoint(state, path) {
+	const checkpointPaths = /* @__PURE__ */ new Set([...Object.keys(state.files), ...Object.keys(state.conflicts)]);
+	for (const checkpointPath of checkpointPaths) if (checkpointPath === path || checkpointPath.startsWith(`${path}/`)) {
+		delete state.files[checkpointPath];
+		delete state.textBases[checkpointPath];
+		delete state.conflicts[checkpointPath];
+	}
+}
+function readTextBase(state, path) {
+	const textBase = state?.textBases[path];
+	return textBase === void 0 ? void 0 : new TextEncoder().encode(textBase);
+}
+function normalizePath(path) {
+	return `/${posix.normalize(path).replace(/^\/+/, "")}`;
+}
+function isRemoteFile(entry) {
+	return entry?.type === "doc" || entry?.type === "file";
+}
+var SyncEngine = class {
+	options;
+	state;
+	queue = Promise.resolve();
+	conflicts = /* @__PURE__ */ new Set();
+	stopLocalWatch;
+	stopRemoteChange;
+	stopRemoteReconnect;
+	eventTimers = /* @__PURE__ */ new Map();
+	stopped = false;
+	failedPaths = /* @__PURE__ */ new Map();
+	retryTimer;
+	retryDelayMs = 3e4;
+	pendingRemoteVersion;
+	pendingInitialization = false;
+	get syncError() {
+		if (this.failedPaths.size === 0) return;
+		const [path, failure] = this.failedPaths.entries().next().value;
+		return `${this.failedPaths.size} path(s) could not synchronize, including ${path}: ${failure.message}. Other paths remain active; failed paths will retry automatically.`;
+	}
+	constructor(options) {
+		this.options = options;
+	}
+	async start() {
+		this.stopped = false;
+		const startup = this.enqueue(() => this.initialize());
+		try {
+			await startup;
+		} catch (error) {
+			await this.stop();
+			throw error;
+		}
+	}
+	async initialize() {
+		this.state = await this.options.stateStore.load();
+		this.stopLocalWatch = await this.options.local.watch((path) => this.schedule(path, "local"));
+		this.stopRemoteChange = this.options.remote.onChange((change) => {
+			if (this.stopped) return;
+			if (change.previousPath) this.schedule(change.previousPath, "remote", change.actor);
+			this.schedule(change.path, "remote", change.actor);
+		});
+		this.stopRemoteReconnect = this.options.remote.onReconnect?.(() => {
+			if (this.stopped) return;
+			this.queue = this.queue.then(() => this.reconcileAfterReconnect()).catch((error) => {
+				this.options.log(`Failed to reconcile after reconnecting: ${error instanceof Error ? error.message : String(error)}`);
+			});
+		});
+		const currentVersion = await this.options.remote.getCurrentVersion();
+		const localFiles = await this.options.local.listFiles();
+		const remoteFiles = this.remoteFilePaths();
+		this.options.log(`Checking replica at Overleaf version ${currentVersion}: ${localFiles.length} local file(s), ${remoteFiles.length} remote file(s).`);
+		if (!this.state || !this.state.initialized) await this.initializeState(currentVersion, localFiles, remoteFiles);
+		else {
+			this.restoreConflicts();
+			await this.startupReconcile(currentVersion, localFiles, remoteFiles);
+		}
+		this.options.log(this.syncError ? `Synchronization active with pending retries. ${this.syncError}` : `Synchronization active at Overleaf version ${this.state.remoteVersion}.`);
+	}
+	async stop() {
+		this.stopped = true;
+		if (this.retryTimer) {
+			clearTimeout(this.retryTimer);
+			this.retryTimer = void 0;
+		}
+		this.stopRemoteChange?.();
+		this.stopRemoteChange = void 0;
+		this.stopRemoteReconnect?.();
+		this.stopRemoteReconnect = void 0;
+		for (const pending of this.eventTimers.values()) clearTimeout(pending.timer);
+		this.eventTimers.clear();
+		await this.stopLocalWatch?.();
+		this.stopLocalWatch = void 0;
+		await this.queue;
+	}
+	getConflicts() {
+		return [...this.conflicts].sort();
+	}
+	async resolveConflict(path, winner) {
+		const normalized = normalizePath(path);
+		if (!this.conflicts.has(normalized)) throw new Error(`No unresolved conflict exists for ${normalized}.`);
+		await this.enqueue(async () => {
+			const remoteEntry = this.options.remote.entry(normalized);
+			if (winner === "local") {
+				const localContent = await this.options.local.read(normalized);
+				if (localContent) {
+					await this.options.remote.write(normalized, localContent);
+					const synchronized = await this.options.remote.read(normalized);
+					if (sha256(synchronized) !== sha256(localContent)) await this.options.local.write(normalized, synchronized);
+					updateSyncCheckpoint(this.state, normalized, synchronized);
+				} else {
+					if (remoteEntry) await this.options.remote.remove(normalized);
+					removeSyncCheckpoint(this.state, normalized);
+				}
+			} else if (isRemoteFile(remoteEntry)) {
+				const remoteContent = await this.options.remote.read(normalized);
+				await this.options.local.write(normalized, remoteContent);
+				updateSyncCheckpoint(this.state, normalized, remoteContent);
+			} else {
+				await this.options.local.remove(normalized);
+				removeSyncCheckpoint(this.state, normalized);
+			}
+			this.conflicts.delete(normalized);
+			delete this.state.conflicts[normalized];
+			await this.options.stateStore.save(this.state);
+			this.options.log(`Resolved ${normalized} using ${winner === "local" ? "local" : "Overleaf"} content.`);
+		});
+	}
+	async retry(path) {
+		const normalized = normalizePath(path);
+		const reason = this.state.conflicts[normalized];
+		this.conflicts.delete(normalized);
+		delete this.state.conflicts[normalized];
+		try {
+			await this.enqueue(() => this.reconcilePath(normalized, "local"));
+		} catch (error) {
+			if (reason !== void 0) {
+				this.conflicts.add(normalized);
+				this.state.conflicts[normalized] = reason;
+				await this.options.stateStore.save(this.state);
+			}
+			throw error;
+		}
+	}
+	async initializeState(currentVersion, localFiles, remoteFiles) {
+		if (!this.state) {
+			this.state = createSyncState(this.options.projectUri, currentVersion, false);
+			await this.options.stateStore.save(this.state);
+		}
+		this.restoreConflicts();
+		this.pendingRemoteVersion = currentVersion;
+		this.pendingInitialization = true;
+		const paths = /* @__PURE__ */ new Set([
+			...localFiles,
+			...remoteFiles,
+			...Object.keys(this.state.files)
+		]);
+		for (const path of [...paths].sort()) {
+			const normalized = normalizePath(path);
+			if (this.conflicts.has(normalized)) continue;
+			try {
+				if (this.state.files[normalized] !== void 0) await this.synchronizePath(normalized, "local");
+				else await this.initializePath(normalized);
+			} catch (error) {
+				this.recordFailure(normalized, "local", error);
+			}
+		}
+		await this.finishRemoteBatch();
+		if (this.conflicts.size !== 0) this.options.log(`Synchronization remains active; ${this.conflicts.size} conflicting path(s) are paused.`);
+	}
+	async initializePath(path) {
+		const remoteEntry = this.options.remote.entry(path);
+		if (remoteEntry?.type === "folder") return;
+		const localContent = await this.options.local.read(path);
+		const remoteContent = isRemoteFile(remoteEntry) ? await this.options.remote.read(path) : void 0;
+		if ((localContent && sha256(localContent)) === (remoteContent && sha256(remoteContent))) {
+			if (localContent) {
+				updateSyncCheckpoint(this.state, path, localContent);
+				await this.options.stateStore.save(this.state);
+			}
+			return;
+		}
+		if (!localContent && remoteContent) {
+			await this.options.local.write(path, remoteContent);
+			updateSyncCheckpoint(this.state, path, remoteContent);
+			await this.options.stateStore.save(this.state);
+			this.logChange("pull", "add", path, void 0, remoteContent);
+			return;
+		}
+		await this.recordConflict(path, remoteContent ? "Local and Overleaf content differ, but no common checkpoint exists." : "The local path has no matching Overleaf file and no common checkpoint exists.");
+	}
+	restoreConflicts() {
+		for (const [path, reason] of Object.entries(this.state.conflicts)) {
+			if (this.conflicts.has(path)) continue;
+			this.conflicts.add(path);
+			this.options.onConflict(path, reason);
+		}
+	}
+	async recordConflict(path, reason) {
+		this.conflicts.add(path);
+		this.state.conflicts[path] = reason;
+		await this.options.stateStore.save(this.state);
+		this.options.onConflict(path, reason);
+	}
+	async startupReconcile(currentVersion, localFiles, remoteFiles) {
+		const state = this.state;
+		if (state.remoteVersion > currentVersion) throw new Error("Synchronization paused: the local checkpoint is newer than the Overleaf project history.");
+		const localHashes = /* @__PURE__ */ new Map();
+		for (const path of localFiles) {
+			const content = await this.options.local.read(path);
+			if (content) localHashes.set(path, sha256(content));
+		}
+		const localChanged = /* @__PURE__ */ new Set();
+		for (const path of /* @__PURE__ */ new Set([...Object.keys(state.files), ...localFiles])) if (state.files[path] !== localHashes.get(path)) localChanged.add(path);
+		let remoteDiff = { diff: [] };
+		if (state.remoteVersion < currentVersion) {
+			remoteDiff = await this.options.remote.getFileTreeDiff(state.remoteVersion, currentVersion);
+			if (!remoteDiff) throw new Error("Synchronization paused: Overleaf history is unavailable, so remote changes cannot be distinguished safely.");
+		}
+		const candidates = /* @__PURE__ */ new Set([...localChanged, ...this.failedPaths.keys()]);
+		const knownFiles = /* @__PURE__ */ new Set([
+			...Object.keys(state.files),
+			...localFiles,
+			...remoteFiles
+		]);
+		for (const path of [...localFiles, ...remoteFiles]) if (state.files[path] === void 0) candidates.add(path);
+		for (const change of remoteDiff.diff) {
+			if (!change.operation) continue;
+			const paths = [change.pathname, change.newPathname].filter((path) => Boolean(path));
+			for (const changedPath of paths.map(normalizePath)) {
+				let matched = false;
+				for (const filePath of knownFiles) if (filePath === changedPath || filePath.startsWith(`${changedPath}/`)) {
+					candidates.add(filePath);
+					matched = true;
+				}
+				if (!matched) candidates.add(changedPath);
+			}
+		}
+		this.pendingRemoteVersion = currentVersion;
+		this.options.log(`Reconciling ${candidates.size} changed path(s).`);
+		for (const path of [...candidates].sort()) {
+			if (this.stopped) return;
+			try {
+				await this.synchronizePath(path, localChanged.has(path) ? "local" : "remote");
+			} catch (error) {
+				this.recordFailure(path, localChanged.has(path) ? "local" : "remote", error);
+			}
+		}
+		await this.finishRemoteBatch();
+		if (this.conflicts.size !== 0) this.options.log(`Synchronization remains active; ${this.conflicts.size} conflicting path(s) are paused.`);
+	}
+	async reconcileAfterReconnect() {
+		if (this.stopped) return;
+		const currentVersion = await this.options.remote.getCurrentVersion();
+		await this.startupReconcile(currentVersion, await this.options.local.listFiles(), this.remoteFilePaths());
+		this.options.log(this.syncError ? `Realtime connection restored; ${this.syncError}` : `Realtime connection restored at Overleaf version ${currentVersion}.`);
+	}
+	schedule(path, source, actor) {
+		const normalized = normalizePath(path);
+		if (this.stopped || this.shouldIgnore(normalized) || this.conflicts.has(normalized)) return;
+		const previous = this.eventTimers.get(normalized);
+		if (previous) clearTimeout(previous.timer);
+		const actors = previous?.actors ?? /* @__PURE__ */ new Set();
+		let unknownRemoteActor = previous?.unknownRemoteActor ?? false;
+		if (source === "remote") {
+			if (actor) actors.add(actor);
+			else unknownRemoteActor = true;
+		}
+		const pending = {
+			source: previous?.source === "local" || source === "local" ? "local" : "remote",
+			actors,
+			unknownRemoteActor,
+			timer: setTimeout(() => {
+				this.eventTimers.delete(normalized);
+				if (this.stopped) return;
+				const remoteActor = pending.unknownRemoteActor ? void 0 : pending.actors.size === 1 ? [...pending.actors][0] : pending.actors.size > 1 ? "multiple Overleaf collaborators" : void 0;
+				this.queue = this.queue.then(() => this.synchronizePath(normalized, pending.source, remoteActor)).catch((error) => {
+					this.recordFailure(normalized, pending.source, error, remoteActor);
+				});
+			}, 250)
+		};
+		this.eventTimers.set(normalized, pending);
+	}
+	async synchronizePath(path, source, actor) {
+		if (this.pendingInitialization && this.state.files[path] === void 0) await this.initializePath(path);
+		else await this.reconcilePath(path, source, actor);
+		if (this.failedPaths.delete(path)) this.options.onSyncError?.(this.syncError);
+	}
+	recordFailure(path, source, error, actor) {
+		const message = error instanceof Error ? error.message : String(error);
+		this.failedPaths.set(path, {
+			source,
+			actor,
+			message
+		});
+		this.options.log(`Failed to synchronize ${path}: ${message}; retrying without stopping other paths.`);
+		this.options.onSyncError?.(this.syncError);
+		this.scheduleRetry();
+	}
+	scheduleRetry() {
+		if (this.stopped || this.retryTimer || this.failedPaths.size === 0) return;
+		this.retryTimer = setTimeout(() => {
+			this.retryTimer = void 0;
+			this.enqueue(async () => {
+				if (this.stopped) return;
+				for (const [path, failure] of Array.from(this.failedPaths)) {
+					if (this.stopped) return;
+					try {
+						await this.synchronizePath(path, failure.source, failure.actor);
+						this.options.log(`Recovered synchronization for ${path}.`);
+					} catch (error) {
+						const message = error instanceof Error ? error.message : String(error);
+						this.failedPaths.set(path, {
+							...failure,
+							message
+						});
+						this.options.log(`Retry failed for ${path}: ${message}`);
+					}
+				}
+				await this.finishRemoteBatch();
+			}).catch((error) => this.options.log(`Could not checkpoint retry batch: ${String(error)}`)).finally(() => {
+				this.retryDelayMs = this.failedPaths.size ? Math.min(this.retryDelayMs * 2, 12e4) : 3e4;
+				this.scheduleRetry();
+			});
+		}, this.retryDelayMs);
+	}
+	async finishRemoteBatch() {
+		if (this.stopped || this.failedPaths.size || this.pendingRemoteVersion === void 0) return;
+		this.state.remoteVersion = this.pendingRemoteVersion;
+		if (this.pendingInitialization) this.state.initialized = true;
+		await this.options.stateStore.save(this.state);
+		this.pendingRemoteVersion = void 0;
+		this.pendingInitialization = false;
+	}
+	enqueue(operation) {
+		const result = this.queue.then(operation);
+		this.queue = result.then(() => void 0, () => void 0);
+		return result;
+	}
+	async reconcilePath(path, source, actor) {
+		const normalized = normalizePath(path);
+		if (this.stopped || this.shouldIgnore(normalized) || this.conflicts.has(normalized)) return;
+		const remoteEntry = this.options.remote.entry(normalized);
+		if (remoteEntry?.type === "folder") return;
+		const localContent = await this.options.local.read(normalized);
+		const remoteContent = isRemoteFile(remoteEntry) ? await this.options.remote.read(normalized) : void 0;
+		const baseHash = this.state.files[normalized];
+		const baseContent = readTextBase(this.state, normalized);
+		const localHash = localContent && sha256(localContent);
+		const remoteHash = remoteContent && sha256(remoteContent);
+		if (localHash === remoteHash) {
+			if (localHash !== baseHash) {
+				if (localContent) updateSyncCheckpoint(this.state, normalized, localContent);
+				else removeSyncCheckpoint(this.state, normalized);
+				await this.options.stateStore.save(this.state);
+			}
+			return;
+		}
+		const localChanged = localHash !== baseHash;
+		const remoteChanged = remoteHash !== baseHash;
+		if (localChanged && remoteChanged) {
+			if (baseContent && localContent && remoteContent) {
+				const merged = mergeText(baseContent, localContent, remoteContent);
+				if (merged.status === "merged" && merged.content) {
+					await this.options.local.write(normalized, merged.content);
+					await this.options.remote.write(normalized, merged.content);
+					updateSyncCheckpoint(this.state, normalized, merged.content);
+					await this.options.stateStore.save(this.state);
+					this.logChange("merge", "update", normalized, baseContent, merged.content, actor);
+					return;
+				}
+			}
+			await this.recordConflict(normalized, "Both local and Overleaf content changed since the last synchronized checkpoint.");
+			return;
+		}
+		if (source === "remote" && localChanged && !remoteChanged) return;
+		if (localChanged || !remoteChanged && source === "local") {
+			let pushedContent = localContent;
+			if (!localContent) {
+				if (remoteEntry) await this.options.remote.remove(normalized);
+				removeSyncCheckpoint(this.state, normalized);
+			} else {
+				await this.options.remote.write(normalized, localContent);
+				const synchronized = await this.options.remote.read(normalized);
+				if (sha256(synchronized) !== sha256(localContent)) await this.options.local.write(normalized, synchronized);
+				pushedContent = synchronized;
+				updateSyncCheckpoint(this.state, normalized, synchronized);
+			}
+			await this.options.stateStore.save(this.state);
+			if (!localContent && remoteEntry) this.logChange("push", "delete", normalized, baseContent ?? remoteContent, void 0, actor);
+			else if (localContent) this.logChange("push", remoteEntry ? "update" : "add", normalized, baseContent ?? remoteContent, pushedContent, actor);
+			return;
+		}
+		if (!remoteContent) {
+			if (localContent) await this.options.local.remove(normalized);
+			removeSyncCheckpoint(this.state, normalized);
+		} else {
+			await this.options.local.write(normalized, remoteContent);
+			updateSyncCheckpoint(this.state, normalized, remoteContent);
+		}
+		await this.options.stateStore.save(this.state);
+		if (!remoteContent && localContent) this.logChange("pull", "delete", normalized, baseContent ?? localContent, void 0, actor);
+		else if (remoteContent) this.logChange("pull", localContent ? "update" : "add", normalized, baseContent ?? localContent, remoteContent, actor);
+	}
+	logChange(direction, operation, path, before, after, actor) {
+		const summary = describeContentChange(before, after);
+		const source = direction === "push" ? "local filesystem" : direction === "pull" ? actor ?? "Overleaf" : `local filesystem + ${actor ?? "Overleaf"}`;
+		this.options.log([
+			`[${direction}] ${operation} ${JSON.stringify(path)}`,
+			summary,
+			`source=${source}`
+		].filter(Boolean).join("; "));
+	}
+	remoteFilePaths() {
+		return this.options.remote.listEntries().filter((entry) => isRemoteFile(entry) && !this.shouldIgnore(entry.path)).map((entry) => entry.path);
+	}
+	shouldIgnore(path) {
+		return this.options.ignore(path) || path.split("/").some((part) => part.startsWith("."));
+	}
+};
+const HASH_PATTERN = /^[a-f0-9]{64}$/;
+const encoder = new TextEncoder();
+function json(value) {
+	return `${JSON.stringify(value, null, 2)}\n`;
+}
+function pathKey(path) {
+	return sha256(encoder.encode(path));
+}
+async function readJson(path) {
+	return JSON.parse(await readFile(path, "utf8"));
+}
+async function listFiles(directory) {
+	const result = [];
+	const visit = async (current) => {
+		let entries;
+		try {
+			entries = await readdir(current, { withFileTypes: true });
+		} catch (error) {
+			if (error.code === "ENOENT") return;
+			throw error;
+		}
+		for (const entry of entries) {
+			const path = join(current, entry.name);
+			if (entry.isDirectory()) await visit(path);
+			else if (entry.isFile()) result.push(path);
+		}
+	};
+	await visit(directory);
+	return result;
+}
+async function atomicWrite(path, content) {
+	await mkdir(dirname(path), { recursive: true });
+	const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		await writeFile(temporary, content);
+		await rename(temporary, path);
+	} finally {
+		await rm(temporary, { force: true });
+	}
+}
+function parseFormat(value, projectUri) {
+	if (typeof value !== "object" || value === null) return false;
+	const format = value;
+	return format.schemaVersion === 1 && format.projectUri === projectUri;
+}
+function parseCursor(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const cursor = value;
+	return Number.isInteger(cursor.remoteVersion) && cursor.remoteVersion >= 0 && typeof cursor.initialized === "boolean";
+}
+function parsePathRecord(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	if (typeof record.path !== "string" || !record.path.startsWith("/")) return false;
+	if (record.hash !== void 0 && (typeof record.hash !== "string" || !HASH_PATTERN.test(record.hash))) return false;
+	if (record.baseHash !== void 0 && (typeof record.baseHash !== "string" || !HASH_PATTERN.test(record.baseHash) || record.hash !== record.baseHash)) return false;
+	if (record.conflict !== void 0 && typeof record.conflict !== "string") return false;
+	return record.hash !== void 0 || record.conflict !== void 0;
+}
+function createRecord(state, path) {
+	const hash = state.files[path];
+	const textBase = state.textBases[path];
+	const conflict = state.conflicts[path];
+	if (hash === void 0 && conflict === void 0) return;
+	return {
+		path,
+		...hash === void 0 ? {} : { hash },
+		...textBase === void 0 ? {} : { baseHash: hash },
+		...conflict === void 0 ? {} : { conflict }
+	};
+}
+var FileSyncStateStore = class {
+	projectUri;
+	legacyPath;
+	syncDirectory;
+	formatPath;
+	cursorPath;
+	pathsDirectory;
+	basesDirectory;
+	persistedRecords = /* @__PURE__ */ new Map();
+	persistedCursor;
+	invalidRecordPaths = /* @__PURE__ */ new Set();
+	initialized = false;
+	constructor(directory, projectUri) {
+		this.projectUri = projectUri;
+		const overleafDirectory = resolve(directory, ".overleaf");
+		this.legacyPath = join(overleafDirectory, "sync-state.json");
+		this.syncDirectory = join(overleafDirectory, "sync");
+		this.formatPath = join(this.syncDirectory, "format.json");
+		this.cursorPath = join(this.syncDirectory, "cursor.json");
+		this.pathsDirectory = join(this.syncDirectory, "paths");
+		this.basesDirectory = join(this.syncDirectory, "bases");
+	}
+	async load() {
+		this.invalidRecordPaths.clear();
+		try {
+			const format = await readJson(this.formatPath);
+			const cursor = await readJson(this.cursorPath);
+			if (!parseFormat(format, this.projectUri) || !parseCursor(cursor)) return;
+			const state = {
+				schemaVersion: 1,
+				projectUri: this.projectUri,
+				remoteVersion: cursor.remoteVersion,
+				initialized: cursor.initialized,
+				files: {},
+				textBases: {},
+				conflicts: {}
+			};
+			const records = /* @__PURE__ */ new Map();
+			const referencedBases = /* @__PURE__ */ new Set();
+			let stateIncomplete = false;
+			for (const recordPath of await listFiles(this.pathsDirectory)) {
+				const record = await this.loadRecord(recordPath);
+				if (!record) {
+					if (recordPath.endsWith(".json")) {
+						this.invalidRecordPaths.add(recordPath);
+						stateIncomplete = true;
+					} else await rm(recordPath, { force: true });
+					continue;
+				}
+				if (record.hash !== void 0) state.files[record.path] = record.hash;
+				if (record.baseHash !== void 0) {
+					let textBase;
+					try {
+						textBase = await readFile(this.basePath(record.baseHash), "utf8");
+					} catch (error) {
+						if (error.code === "ENOENT") {
+							this.invalidRecordPaths.add(recordPath);
+							stateIncomplete = true;
+							delete state.files[record.path];
+							continue;
+						}
+						throw error;
+					}
+					if (sha256(encoder.encode(textBase)) !== record.baseHash) {
+						this.invalidRecordPaths.add(recordPath);
+						stateIncomplete = true;
+						delete state.files[record.path];
+						continue;
+					}
+					state.textBases[record.path] = textBase;
+					referencedBases.add(record.baseHash);
+				}
+				if (record.conflict !== void 0) state.conflicts[record.path] = record.conflict;
+				records.set(record.path, json(record));
+			}
+			if (stateIncomplete) state.initialized = false;
+			await this.removeOrphanBases(referencedBases);
+			this.persistedRecords = records;
+			this.persistedCursor = json(cursor);
+			this.initialized = true;
+			return state;
+		} catch (error) {
+			if (error.code === "ENOENT" || error instanceof SyntaxError) return;
+			throw error;
+		}
+	}
+	async save(state) {
+		if (state.projectUri !== this.projectUri || state.schemaVersion !== 1) throw new Error("Cannot persist synchronization state for a different project or schema.");
+		if (!this.initialized) await this.initializeStorage();
+		const paths = /* @__PURE__ */ new Set([
+			...this.persistedRecords.keys(),
+			...Object.keys(state.files),
+			...Object.keys(state.conflicts)
+		]);
+		const obsoleteBases = /* @__PURE__ */ new Set();
+		for (const path of [...paths].sort()) {
+			const record = createRecord(state, path);
+			const serialized = record && json(record);
+			const previous = this.persistedRecords.get(path);
+			if (serialized === previous) continue;
+			if (previous) {
+				const previousRecord = JSON.parse(previous);
+				if (previousRecord.baseHash) obsoleteBases.add(previousRecord.baseHash);
+			}
+			if (!record || !serialized) {
+				await rm(this.recordPath(path), { force: true });
+				this.persistedRecords.delete(path);
+				continue;
+			}
+			if (record.baseHash) {
+				const textBase = state.textBases[path];
+				if (textBase === void 0 || sha256(encoder.encode(textBase)) !== record.baseHash) throw new Error(`Text checkpoint does not match its content hash: ${path}`);
+				await this.writeBase(record.baseHash, textBase);
+			}
+			const destination = this.recordPath(path);
+			await atomicWrite(destination, serialized);
+			this.invalidRecordPaths.delete(destination);
+			this.persistedRecords.set(path, serialized);
+		}
+		const cursor = json({
+			remoteVersion: state.remoteVersion,
+			initialized: state.initialized
+		});
+		if (cursor !== this.persistedCursor) {
+			await atomicWrite(this.cursorPath, cursor);
+			this.persistedCursor = cursor;
+		}
+		if (state.initialized) {
+			await Promise.all([...this.invalidRecordPaths].map((path) => rm(path, { force: true })));
+			this.invalidRecordPaths.clear();
+		}
+		await rm(this.legacyPath, { force: true });
+		await this.removeObsoleteBases(state, obsoleteBases);
+	}
+	async initializeStorage() {
+		await rm(this.syncDirectory, {
+			recursive: true,
+			force: true
+		});
+		await mkdir(this.pathsDirectory, { recursive: true });
+		await mkdir(this.basesDirectory, { recursive: true });
+		await atomicWrite(this.formatPath, json({
+			schemaVersion: 1,
+			projectUri: this.projectUri
+		}));
+		this.persistedRecords.clear();
+		this.persistedCursor = void 0;
+		this.invalidRecordPaths.clear();
+		this.initialized = true;
+	}
+	recordPath(path) {
+		const key = pathKey(path);
+		return join(this.pathsDirectory, key.slice(0, 2), `${key}.json`);
+	}
+	async loadRecord(recordPath) {
+		if (!recordPath.endsWith(".json")) return;
+		try {
+			const record = await readJson(recordPath);
+			if (!parsePathRecord(record) || recordPath !== this.recordPath(record.path)) return;
+			return record;
+		} catch (error) {
+			if (error.code === "ENOENT" || error instanceof SyntaxError) return;
+			throw error;
+		}
+	}
+	basePath(hash) {
+		return join(this.basesDirectory, hash.slice(0, 2), `${hash}.txt`);
+	}
+	async writeBase(hash, content) {
+		const path = this.basePath(hash);
+		try {
+			if (sha256(encoder.encode(await readFile(path, "utf8"))) === hash) return;
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		await atomicWrite(path, content);
+	}
+	async removeObsoleteBases(state, candidates) {
+		if (candidates.size === 0) return;
+		const referenced = /* @__PURE__ */ new Set();
+		for (const [path, textBase] of Object.entries(state.textBases)) if (textBase !== void 0 && state.files[path] !== void 0) referenced.add(state.files[path]);
+		for (const hash of candidates) if (!referenced.has(hash)) await rm(this.basePath(hash), { force: true });
+	}
+	async removeOrphanBases(referencedHashes) {
+		const referencedPaths = new Set([...referencedHashes].map((hash) => this.basePath(hash)));
+		for (const path of await listFiles(this.basesDirectory)) if (!referencedPaths.has(path)) await rm(path, { force: true });
+	}
+};
+async function startServe(directory = process.cwd(), options = {}) {
+	const root = resolve(directory);
+	const settings = await readProjectSettings(root);
+	const session = await getServerSession(settings.serverName);
+	if (!session) throw new Error(`No login is stored for ${settings.serverName}. Run: leafrelay login ${settings.serverName}`);
+	const cookie = options.cookie || process.env.LEAFRELAY_COOKIE || session.identity.cookies;
+	const remote = options.remote ?? new RemoteProject(session.url || settings.serverUrl, settings.projectId, cookie);
+	await remote.connect();
+	const configuredPatterns = settings.localReplica.settings["ignore-patterns"];
+	const ignore = createIgnoreMatcher(configuredPatterns);
+	const local = new NodeReplicaFileSystem(root, ignore);
+	const engine = new SyncEngine({
+		projectUri: settings.uri,
+		local,
+		remote,
+		stateStore: new FileSyncStateStore(root, settings.uri),
+		ignore,
+		onSyncError: options.onSyncError,
+		log: options.log ?? log,
+		onConflict: options.onConflict ?? ((path, reason) => {
+			(options.log ?? log)(`Conflict paused for ${path}: ${reason}`);
+		})
+	});
+	try {
+		await engine.start();
+	} catch (error) {
+		remote.disconnect();
+		throw error;
+	}
+	(options.log ?? log)(`LeafRelay is serving ${root} (${settings.projectName}).`);
+	return {
+		root,
+		serverName: settings.serverName,
+		projectId: settings.projectId,
+		projectName: settings.projectName,
+		syncError: () => engine.syncError,
+		conflicts: () => engine.getConflicts(),
+		resolveConflict: (path, winner) => engine.resolveConflict(path, winner),
+		retry: (path) => engine.retry(path),
+		stop: async () => {
+			await engine.stop();
+			remote.disconnect();
+		}
+	};
+}
+export { configPath as a, readConfig as c, removeServerSession as d, saveKnownServer as f, startServe as g, setLogSink as h, SocketIOAPI as i, readProjectSettings as l, serverKey as m, HttpRequestScheduler as n, getServerSession as o, saveServerSession as p, RemoteProject as r, normalizeServerUrl as s, ExtendedBaseAPI as t, removeKnownServer as u };
+
+//# sourceMappingURL=dist-JyfvbgjD.js.map