leafrelay 0.1.6

package/dist/chunk-MNOPLM7M.js

@@ -0,0 +1,2469 @@
+// ../core/dist/index.js
+import { Blob as Blob2 } from "buffer";
+import mime from "mime";
+import { EventEmitter } from "events";
+import { v4 as uuidv4 } from "uuid";
+import { promisify } from "util";
+import { mkdir, readFile, writeFile, chmod } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+import { lstat, mkdir as mkdir2, readFile as readFile2, readdir, rm, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, relative, resolve as resolve2, sep } from "path";
+import { watch } from "chokidar";
+import { readFile as readFile3 } from "fs/promises";
+import { resolve as resolve3 } from "path";
+import { resolve as resolve5 } from "path";
+import { minimatch } from "minimatch";
+import { createHash } from "crypto";
+import { posix } from "path";
+import DiffMatchPatch from "diff-match-patch";
+import { posix as posix2 } from "path";
+import { createHash as createHash2 } from "crypto";
+import { diff3Merge } from "node-diff3";
+import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3, resolve as resolve4 } from "path";
+var 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);
+      break;
+    default:
+      break;
+  }
+  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;
+      break;
+    default:
+      break;
+  }
+  return packet;
+}
+function decodePayload(value) {
+  if (!value.startsWith("\uFFFD")) {
+    return [decodePacket(value)];
+  }
+  const packets = [];
+  let offset = 1;
+  while (offset < value.length) {
+    const separator = value.indexOf("\uFFFD", 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 {
+  constructor(url, options) {
+    this.options = options;
+    this.endpoint = new URL(url);
+    this.origin = options.origin;
+    this.cookie = options.cookie;
+    this.reconnectEnabled = options.reconnect ?? true;
+    void this.connect();
+  }
+  options;
+  events = new EventEmitter();
+  endpoint;
+  origin;
+  cookie;
+  socket;
+  connected = false;
+  explicitlyDisconnected = false;
+  reconnectEnabled;
+  reconnectAttempts = 0;
+  reconnectTimer;
+  inactivityTimer;
+  closeTimeoutMs = 6e4;
+  acknowledgementId = 0;
+  acknowledgements = /* @__PURE__ */ new Map();
+  sendBuffer = [];
+  io = {
+    reconnect: (enabled) => {
+      this.reconnectEnabled = enabled;
+      if (!enabled && this.reconnectTimer) {
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = void 0;
+      }
+    }
+  };
+  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);
+    }
+    this.send(encodePacket({
+      type: "event",
+      id,
+      ack: callback ? "data" : void 0,
+      name: event,
+      args
+    }));
+    return this;
+  }
+  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() {
+    try {
+      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 fetch(handshakeUrl, {
+        headers: { origin: this.origin, cookie: this.cookie },
+        redirect: "manual"
+      });
+      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;
+      this.socket = new WebSocket(websocketUrl, {
+        headers: { origin: this.origin, cookie: this.cookie }
+      });
+      this.socket.addEventListener("open", () => this.events.emit("connecting", "websocket"));
+      this.socket.addEventListener("message", (event) => void this.receive(event.data));
+      this.socket.addEventListener("error", (error2) => this.events.emit("error", error2));
+      this.socket.addEventListener("close", () => this.handleClose());
+    } catch (error2) {
+      this.events.emit("connect_failed", error2);
+      this.events.emit("error", error2);
+      this.scheduleReconnect();
+    }
+  }
+  async receive(data) {
+    this.resetInactivityTimer();
+    const value = typeof data === "string" ? data : data instanceof Blob ? await data.text() : Buffer.from(data).toString("utf8");
+    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");
+        this.flush();
+        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);
+        break;
+      default:
+        break;
+    }
+  }
+  send(packet) {
+    if (!this.connected || this.socket?.readyState !== WebSocket.OPEN) {
+      this.sendBuffer.push(packet);
+      return;
+    }
+    this.socket.send(packet);
+  }
+  flush() {
+    while (this.sendBuffer.length > 0 && this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(this.sendBuffer.shift());
+    }
+  }
+  resetInactivityTimer() {
+    if (this.inactivityTimer) {
+      clearTimeout(this.inactivityTimer);
+    }
+    this.inactivityTimer = setTimeout(() => this.closeSocket("timeout"), this.closeTimeoutMs);
+  }
+  handleClose() {
+    const wasConnected = this.connected;
+    this.connected = false;
+    if (this.inactivityTimer) {
+      clearTimeout(this.inactivityTimer);
+    }
+    if (wasConnected) {
+      this.events.emit("disconnect", "transport close");
+    }
+    this.scheduleReconnect();
+  }
+  closeSocket(reason) {
+    const wasConnected = this.connected;
+    this.connected = false;
+    if (this.inactivityTimer) {
+      clearTimeout(this.inactivityTimer);
+    }
+    const socket = this.socket;
+    this.socket = void 0;
+    socket?.close();
+    if (wasConnected) {
+      this.events.emit("disconnect", reason);
+    }
+    if (!this.explicitlyDisconnected) {
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (!this.reconnectEnabled || this.explicitlyDisconnected || this.reconnectTimer) {
+      return;
+    }
+    const maxAttempts = this.options.maxReconnectionAttempts ?? 10;
+    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;
+      void this.connect();
+    }, delay);
+  }
+};
+var overleafSocketProtocol = { encodePacket, decodePacket, decodePayload };
+var sink;
+function setLogSink(nextSink) {
+  sink = nextSink;
+}
+function write(level, args) {
+  if (sink !== void 0) {
+    sink(level, args);
+    return;
+  }
+  const method = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
+  method(...args);
+}
+function log(...args) {
+  write("info", args);
+}
+function warn(...args) {
+  write("warn", args);
+}
+function error(...args) {
+  write("error", args);
+}
+var globalRequestChain = Promise.resolve();
+var globalNextRequestAt = 0;
+var globalRateLimitedUntil = 0;
+var GLOBAL_MIN_REQUEST_INTERVAL_MS = 300;
+function retryAfterHeaderMs(response) {
+  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;
+}
+async function queuedFetch(url, init) {
+  const previous = globalRequestChain;
+  let release;
+  globalRequestChain = new Promise((resolve6) => {
+    release = resolve6;
+  });
+  await previous;
+  try {
+    const delayMs = Math.max(
+      0,
+      globalNextRequestAt - Date.now(),
+      globalRateLimitedUntil - Date.now()
+    );
+    if (delayMs > 0) {
+      await new Promise((resolve6) => setTimeout(resolve6, delayMs));
+    }
+    globalNextRequestAt = Date.now() + GLOBAL_MIN_REQUEST_INTERVAL_MS;
+    const response = await fetch(url, init);
+    if (response.status === 429) {
+      globalRateLimitedUntil = Math.max(globalRateLimitedUntil, Date.now() + retryAfterHeaderMs(response));
+      log(`Global HTTP request queue entered rate-limit cooldown until ${new Date(globalRateLimitedUntil).toISOString()}.`);
+    }
+    return response;
+  } finally {
+    release();
+  }
+}
+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 {
+  url;
+  identity;
+  historyRequestChain = Promise.resolve();
+  lastHistoryRequestAt = 0;
+  isHistoryRoute(route) {
+    return route.includes("/updates?") || route.includes("/filetree/diff?") || route.includes("/diff?");
+  }
+  async waitForHistoryRequest() {
+    const previous = this.historyRequestChain;
+    let release;
+    this.historyRequestChain = new Promise((resolve6) => {
+      release = resolve6;
+    });
+    await previous;
+    try {
+      const minimumIntervalMs = 3e3;
+      const delayMs = Math.max(0, minimumIntervalMs - (Date.now() - this.lastHistoryRequestAt));
+      if (delayMs > 0) {
+        await new Promise((resolve6) => setTimeout(resolve6, delayMs));
+      }
+      this.lastHistoryRequestAt = Date.now();
+    } finally {
+      release();
+    }
+  }
+  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) {
+    this.url = url;
+  }
+  async getCsrfToken() {
+    const res = await queuedFetch(this.url + "login", {
+      method: "GET",
+      redirect: "manual"
+    });
+    const body = await res.text();
+    const match = body.match(/<input.*name="_csrf".*value="([^"]*)">/);
+    if (!match) {
+      throw new Error("Failed to get CSRF token.");
+    } else {
+      const csrfToken = match[1];
+      const cookies = getSetCookie(res)[0]?.split(";")[0] ?? "";
+      return { csrfToken, cookies };
+    }
+  }
+  async getUserId(cookies) {
+    const res = await queuedFetch(this.url + "project", {
+      method: "GET",
+      redirect: "manual",
+      headers: {
+        "Connection": "keep-alive",
+        "Cookie": cookies
+      }
+    });
+    const body = await res.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];
+      const userEmail = userEmailMatch ? userEmailMatch[1] : "";
+      return { userId, userEmail, csrfToken };
+    } else {
+      return void 0;
+    }
+  }
+  // Reference: "github:overleaf/overleaf/services/web/frontend/js/ide/connection/ConnectionManager.js#L137"
+  _initSocketV0(identity, query) {
+    const url = new URL(this.url).origin + (query ?? "");
+    return new OverleafRealtimeSocket(url, {
+      origin: new URL(this.url).origin,
+      cookie: identity.cookies,
+      reconnect: true,
+      reconnectionDelay: 1e3,
+      reconnectionLimit: 16e3,
+      maxReconnectionAttempts: 10
+    });
+  }
+  async passportLogin(email, password) {
+    const identity = await this.getCsrfToken();
+    const res = await queuedFetch(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 res = await queuedFetch(this.url + "socket.io/socket.io.js", {
+      method: "GET",
+      redirect: "manual",
+      headers: {
+        "Connection": "keep-alive",
+        "Cookie": identity.cookies
+      }
+    });
+    const cookies = getSetCookie(res)[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) {
+    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 {
+        if (this.isHistoryRoute(route)) {
+          await this.waitForHistoryRequest();
+        }
+        let res = void 0;
+        switch (type) {
+          case "GET":
+            res = await queuedFetch(this.url + route, {
+              method: "GET",
+              redirect: "manual",
+              headers: {
+                "Connection": "keep-alive",
+                "Cookie": this.identity.cookies,
+                ...extraHeaders
+              }
+            });
+            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 queuedFetch(this.url + route, {
+              method: "POST",
+              redirect: "manual",
+              headers: {
+                "Connection": "keep-alive",
+                "Cookie": this.identity.cookies,
+                ...content_type,
+                ...extraHeaders
+              },
+              body: raw_body
+            });
+            break;
+          case "PUT":
+            break;
+          case "DELETE":
+            res = await queuedFetch(this.url + route, {
+              method: "DELETE",
+              redirect: "manual",
+              headers: {
+                "Connection": "keep-alive",
+                "Cookie": this.identity.cookies,
+                "X-Csrf-Token": this.identity.csrfToken,
+                ...extraHeaders
+              }
+            });
+            break;
+        }
+        ;
+        if (res && (res.status === 200 || res.status === 204)) {
+          const _res = res.status === 200 ? await res.text() : void 0;
+          const response = callback && callback(_res);
+          return {
+            type: "success",
+            ...response
+          };
+        } 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 ${MAX_HTTP_RETRIES + 1} attempts`
+    };
+  }
+  async download(route) {
+    if (this.identity === void 0) {
+      return Promise.reject();
+    }
+    let content = [];
+    while (true) {
+      const res = await queuedFetch(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) => {
+      const projects = JSON.parse(res).projects;
+      return { projects };
+    });
+  }
+  async projectEntitiesJson(identity, projectId) {
+    this.setIdentity(identity);
+    return this.request("GET", `project/${projectId}/entities`, void 0, (res) => {
+      const entities = JSON.parse(res).entities;
+      return { entities };
+    });
+  }
+  async newProject(identity, projectName, template) {
+    this.setIdentity(identity);
+    return this.request("POST", "project/new", { projectName, template }, (res) => {
+      const message = JSON.parse(res).project_id;
+      return { message };
+    });
+  }
+  async cloneProject(identity, projectId, projectName) {
+    this.setIdentity(identity);
+    return this.request("POST", `project/${projectId}/clone`, { projectName }, (res) => {
+      const message = JSON.parse(res).project_id;
+      return { message };
+    });
+  }
+  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);
+      const entity = { _type: "doc", _id, name: filename };
+      return { entity };
+    }, { "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 Blob2([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 { success, entity_id, entity_type } = JSON.parse(res);
+      const entity = { _type: entity_type, _id: entity_id, name: filename };
+      return { entity };
+    }, { "X-Csrf-Token": identity.csrfToken });
+  }
+  async uploadProject(identity, filename, fileContent) {
+    const uuid = uuidv4();
+    const formData = new FormData();
+    formData.append("qqfile", new Blob2([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) => {
+      const message = JSON.parse(res).project_id;
+      return { message };
+    });
+  }
+  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) => {
+      const entity = JSON.parse(res);
+      return { entity };
+    }, { "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,
+      // file path e.g. "main.tex"
+      stopOnFirstError
+    };
+    this.setIdentity(identity);
+    return this.request("POST", `project/${projectId}/compile?auto_compile=true`, body, (res) => {
+      const compile = JSON.parse(res);
+      return { compile };
+    }, { "X-Csrf-Token": identity.csrfToken });
+  }
+  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) => {
+      const meta = JSON.parse(res);
+      return { meta };
+    });
+  }
+  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) => {
+      const misspellings = JSON.parse(res).misspellings;
+      return { 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, '"')) : [];
+      languages.length && languages.unshift({ name: "Off", code: "" });
+      const compilers = [
+        { code: "pdflatex", name: "pdfLaTex" },
+        { code: "latex", name: "LaTex" },
+        { code: "xelatex", name: "XeLaTex" },
+        { code: "lualatex", name: "LuaLaTex" }
+      ];
+      const settings = { learnedWords, languages, compilers };
+      return { settings };
+    });
+  }
+  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 content2 = await this._downloadAbsolute(cdnUrl, false);
+      return { type: "success", content: new Uint8Array(content2) };
+    }
+    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 queuedFetch(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=${uuidv4()}&buildId=${buildId}`;
+    return this.request(
+      "GET",
+      `project/${projectId}/sync/pdf?page=${page}&h=${h.toFixed(2)}&v=${v.toFixed(2)}&editorId=${uuidv4()}&buildId=${buildId}`,
+      void 0,
+      (res) => {
+        const syncPdf = JSON.parse(res).code[0];
+        return { syncPdf };
+      }
+    );
+  }
+  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=${uuidv4()}&buildId=${buildId}`,
+      void 0,
+      (res) => {
+        const syncCode = JSON.parse(res).pdf;
+        return { syncCode };
+      }
+    );
+  }
+  async getAllTags(identity) {
+    this.setIdentity(identity);
+    return this.request("GET", "tag", void 0, (res) => {
+      const tags = JSON.parse(res);
+      return { tags };
+    });
+  }
+  async createTag(identity, name) {
+    this.setIdentity(identity);
+    return this.request("POST", "tag", { name }, (res) => {
+      const tags = JSON.parse(res);
+      return { tags };
+    });
+  }
+  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) => {
+      const updates = JSON.parse(res);
+      return { updates };
+    });
+  }
+  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) => {
+      const diff = JSON.parse(res);
+      return { diff };
+    });
+  }
+  async proxyToHistoryApiAndGetFileTreeDiff(identity, projectId, from, to) {
+    this.setIdentity(identity);
+    return this.request("GET", `project/${projectId}/filetree/diff?from=${from}&to=${to}`, void 0, (res) => {
+      const treeDiff = JSON.parse(res);
+      return { treeDiff };
+    });
+  }
+  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) => {
+      const labels = JSON.parse(res);
+      return { labels };
+    });
+  }
+  async createLabel(identity, projectId, comment, version) {
+    this.setIdentity(identity);
+    return this.request("POST", `project/${projectId}/labels`, { comment, version }, (res) => {
+      const labels = [JSON.parse(res)];
+      return { labels };
+    });
+  }
+  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) => {
+      const messages = JSON.parse(res);
+      return { messages };
+    }, { "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) => {
+      const message = JSON.parse(res).new_file_id;
+      return { message };
+    }, { "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) => {
+      const message = JSON.parse(res).new_file_id;
+      return { message };
+    }, { "X-Csrf-Token": identity.csrfToken });
+  }
+};
+var SOCKET_OPERATION_TIMEOUT_MS = 15e3;
+function decodePackedUtf8(text) {
+  return Buffer.from(text, "latin1").toString("utf-8");
+}
+var SocketIOAPI = class _SocketIOAPI {
+  constructor(url, api, identity, projectId) {
+    this.url = url;
+    this.api = api;
+    this.identity = identity;
+    this.projectId = projectId;
+    this.scheme = "realtime";
+    this.init();
+  }
+  url;
+  api;
+  identity;
+  projectId;
+  static alternativeSocketFactory;
+  scheme;
+  record;
+  _handlers = [];
+  connectedPublicId;
+  socket;
+  emit;
+  /** Track the scheme used when the socket was last initialized */
+  _socketInitScheme;
+  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;
+        const query = `?projectId=${this.projectId}&t=${Date.now()}`;
+        this.socket = this.api._initSocketV0(this.identity, query);
+        break;
+    }
+    this.socket.emit[promisify.custom] = (event, ...args) => {
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+          reject("timeout");
+        }, SOCKET_OPERATION_TIMEOUT_MS);
+      });
+      const waitPromise = new Promise((resolve6, reject) => {
+        this.socket.emit(event, ...args, (err, ...data) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve6(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 });
+    });
+    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", (error2) => {
+      log("SocketIOAPI: reconnect_failed", { scheme: this.scheme, projectId: this.projectId, error: error2 });
+    });
+    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) => {
+      const message = err?.message || String(err);
+      error(`Overleaf connection error: ${message}`);
+    });
+    if (this.scheme === "realtime") {
+      this.record = new Promise((resolve6, reject) => {
+        this.socket.on("joinProjectResponse", (res) => {
+          const publicId = res.publicId;
+          const project = res.project;
+          this.connectedPublicId = publicId;
+          for (const handler of this._handlers) {
+            handler.onConnectionAccepted?.(publicId);
+          }
+          resolve6(project);
+        });
+        this.socket.on("connectionRejected", (err) => {
+          reject(err?.message || err);
+        });
+      });
+    }
+  }
+  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", () => {
+            handler();
+          });
+          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);
+          });
+          break;
+        default:
+          break;
+      }
+    });
+  }
+  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.record, timeoutPromise]);
+    }
+  }
+  /**
+   * Reference: services/web/frontend/js/ide/editor/Document.js#L500
+   * @param {string} docId - The document id.
+   * @returns {Promise}
+   */
+  async joinDoc(docId) {
+    return this.emit("joinDoc", docId, { encodeRanges: true }).then((returns) => {
+      const [docLinesAscii, version, updates, ranges] = returns;
+      const docLines = docLinesAscii.map((line) => decodePackedUtf8(line));
+      return { docLines, 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.emit("leaveDoc", docId).then(() => {
+      return;
+    });
+  }
+  /**
+   * 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.emit("applyOtUpdate", docId, update);
+    } catch (error2) {
+      let detail;
+      if (error2 instanceof Error) {
+        detail = error2.message;
+      } else if (typeof error2 === "string") {
+        detail = error2;
+      } else {
+        try {
+          detail = JSON.stringify(error2);
+        } catch {
+          detail = String(error2);
+        }
+      }
+      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.emit("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.emit("clientTracking.updatePosition", { row, column, doc_id }).then(() => {
+      return;
+    });
+  }
+};
+var FolderKeys = {
+  folder: "folders",
+  doc: "docs",
+  file: "fileRefs",
+  outputs: "outputs"
+};
+function configPath(environment = process.env) {
+  return environment.LEAFRELAY_CONFIG ? resolve(environment.LEAFRELAY_CONFIG) : 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 (error2) {
+    if (error2.code === "ENOENT") {
+      return { version: 1, servers: {} };
+    }
+    throw error2;
+  }
+}
+async function writeConfig(config, path = configPath()) {
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  await writeFile(path, `${JSON.stringify(config, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+  await chmod(path, 384);
+}
+async function saveServerSession(session, path = configPath()) {
+  const config = await readConfig(path);
+  config.servers[serverKey(session.url)] = session;
+  await writeConfig(config, path);
+}
+async function getServerSession(server, environment = process.env, path = configPath(environment)) {
+  const key = serverKey(server);
+  const config = await readConfig(path);
+  const stored = config.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 = resolve2(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 {
+  constructor(root, ignore) {
+    this.root = root;
+    this.ignore = ignore;
+  }
+  root;
+  ignore;
+  watcher;
+  async listFiles() {
+    const files = [];
+    const visit = async (directory) => {
+      for (const entry of await readdir(directory, { withFileTypes: true })) {
+        const absolute = resolve2(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 void 0;
+      }
+      return new Uint8Array(await readFile2(target));
+    } catch (error2) {
+      if (error2.code === "ENOENT") {
+        return void 0;
+      }
+      throw error2;
+    }
+  }
+  async write(path, content) {
+    const target = projectPath(this.root, path);
+    await mkdir2(dirname2(target), { recursive: true });
+    await writeFile2(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 = resolve3(directory, ".overleaf", "settings.json");
+  const raw = JSON.parse(await readFile3(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 ?? {} }
+  };
+}
+var 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(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 void 0;
+  }
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(content);
+  } catch {
+    return void 0;
+  }
+}
+var RemoteProject = class {
+  constructor(url, projectId, cookies) {
+    this.url = url;
+    this.projectId = projectId;
+    this.cookies = cookies;
+    this.api = new BaseAPI(url);
+  }
+  url;
+  projectId;
+  cookies;
+  api;
+  identity;
+  socket;
+  project;
+  entries = /* @__PURE__ */ new Map();
+  idToPath = /* @__PURE__ */ new Map();
+  changeHandler;
+  async connect() {
+    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.reindex();
+    this.registerEvents();
+  }
+  disconnect() {
+    this.socket?.disconnect();
+  }
+  onChange(handler) {
+    this.changeHandler = handler;
+  }
+  listEntries() {
+    return [...this.entries.values()];
+  }
+  entry(path) {
+    return this.entries.get(normalizePath(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(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(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);
+    const text = textContent(content);
+    if (text !== 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 entity2 = created.entity;
+      entity2._type = "doc";
+      parent.docs.push(entity2);
+      this.reindex();
+      if (content.length !== 0) {
+        await this.writeDocument(entity2, 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(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 void 0;
+    }
+    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}\0${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(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(posix.join(path, child.name)), folder);
+    }
+    for (const child of folder.docs ?? []) {
+      child._type = "doc";
+      const childPath = normalizePath(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(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) {
+    this.changeHandler?.({ path: normalizePath(path), previousPath });
+  }
+  registerEvents() {
+    this.socket.updateEventHandlers({
+      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);
+        }
+      }
+    });
+  }
+};
+var textDecoder = new TextDecoder("utf-8", { fatal: true });
+var textEncoder = new TextEncoder();
+function decodeText(content) {
+  if (content.includes(0)) {
+    return void 0;
+  }
+  try {
+    return textDecoder.decode(content);
+  } catch {
+    return void 0;
+  }
+}
+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(""))
+  };
+}
+var SYNC_STATE_SCHEMA_VERSION = 2;
+function sha256(content) {
+  return createHash2("sha256").update(content).digest("hex");
+}
+function parseSyncState(serialized, projectUri) {
+  try {
+    const state = JSON.parse(serialized);
+    if (state.schemaVersion !== 1 && state.schemaVersion !== SYNC_STATE_SCHEMA_VERSION || state.projectUri !== projectUri || !Number.isInteger(state.remoteVersion) || typeof state.files !== "object" || state.files === null) {
+      return void 0;
+    }
+    return {
+      ...state,
+      schemaVersion: SYNC_STATE_SCHEMA_VERSION,
+      textBases: typeof state.textBases === "object" && state.textBases !== null ? state.textBases : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+function createSyncState(projectUri, remoteVersion) {
+  return {
+    schemaVersion: SYNC_STATE_SCHEMA_VERSION,
+    projectUri,
+    remoteVersion,
+    files: {},
+    textBases: {}
+  };
+}
+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) {
+  for (const checkpointPath of Object.keys(state.files)) {
+    if (checkpointPath === path || checkpointPath.startsWith(`${path}/`)) {
+      delete state.files[checkpointPath];
+      delete state.textBases[checkpointPath];
+    }
+  }
+}
+function readTextBase(state, path) {
+  const textBase = state?.textBases[path];
+  return textBase === void 0 ? void 0 : new TextEncoder().encode(textBase);
+}
+function normalizePath2(path) {
+  return `/${posix2.normalize(path).replace(/^\/+/, "")}`;
+}
+function isRemoteFile(entry) {
+  return entry?.type === "doc" || entry?.type === "file";
+}
+var SyncEngine = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  state;
+  queue = Promise.resolve();
+  conflicts = /* @__PURE__ */ new Set();
+  stopLocalWatch;
+  eventTimers = /* @__PURE__ */ new Map();
+  async start() {
+    this.state = await this.options.stateStore.load();
+    const currentVersion = await this.options.remote.getCurrentVersion();
+    const localFiles = await this.options.local.listFiles();
+    const remoteFiles = this.remoteFilePaths();
+    if (!this.state) {
+      this.state = createSyncState(this.options.projectUri, currentVersion);
+      if (localFiles.length !== 0 && remoteFiles.length !== 0) {
+        throw new Error("Synchronization paused: both the local and Overleaf projects contain files, but no common checkpoint exists.");
+      }
+      const source = localFiles.length === 0 ? "remote" : "local";
+      for (const path of source === "remote" ? remoteFiles : localFiles) {
+        await this.reconcilePath(path, source);
+      }
+      this.state.remoteVersion = currentVersion;
+      await this.options.stateStore.save(this.state);
+    } else {
+      await this.startupReconcile(currentVersion, localFiles, remoteFiles);
+    }
+    this.stopLocalWatch = await this.options.local.watch((path) => this.schedule(path, "local"));
+    this.options.remote.onChange((change) => {
+      if (change.previousPath) {
+        this.schedule(change.previousPath, "remote");
+      }
+      this.schedule(change.path, "remote");
+    });
+    this.options.log(`Synchronization active at Overleaf version ${this.state.remoteVersion}.`);
+  }
+  async stop() {
+    for (const timer of this.eventTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.eventTimers.clear();
+    await this.stopLocalWatch?.();
+    await this.queue;
+  }
+  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 = new Set(localChanged);
+    const knownFiles = /* @__PURE__ */ new Set([...Object.keys(state.files), ...localFiles, ...remoteFiles]);
+    for (const change of remoteDiff.diff) {
+      const paths = [change.pathname, change.newPathname].filter((path) => Boolean(path));
+      for (const changedPath of paths.map(normalizePath2)) {
+        let matched = false;
+        for (const filePath of knownFiles) {
+          if (filePath === changedPath || filePath.startsWith(`${changedPath}/`)) {
+            candidates.add(filePath);
+            matched = true;
+          }
+        }
+        if (!matched) {
+          candidates.add(changedPath);
+        }
+      }
+    }
+    let failed = false;
+    for (const path of [...candidates].sort()) {
+      try {
+        await this.reconcilePath(path, localChanged.has(path) ? "local" : "remote");
+      } catch (error2) {
+        failed = true;
+        this.options.log(`Failed to synchronize ${path}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+      }
+    }
+    if (failed || this.conflicts.size !== 0) {
+      throw new Error(`Synchronization paused for ${failed ? "failed" : "conflicting"} paths; successful paths were checkpointed.`);
+    }
+    state.remoteVersion = currentVersion;
+    await this.options.stateStore.save(state);
+  }
+  schedule(path, source) {
+    const normalized = normalizePath2(path);
+    if (this.shouldIgnore(normalized) || this.conflicts.has(normalized)) {
+      return;
+    }
+    const previous = this.eventTimers.get(normalized);
+    if (previous) {
+      clearTimeout(previous);
+    }
+    this.eventTimers.set(normalized, setTimeout(() => {
+      this.eventTimers.delete(normalized);
+      this.queue = this.queue.then(() => this.reconcilePath(normalized, source)).catch((error2) => {
+        this.options.log(`Failed to synchronize ${normalized}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+      });
+    }, 250));
+  }
+  async reconcilePath(path, source) {
+    const normalized = normalizePath2(path);
+    if (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 localHash = localContent && sha256(localContent);
+    const remoteHash = remoteContent && sha256(remoteContent);
+    if (localHash === remoteHash) {
+      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) {
+      const base = readTextBase(this.state, normalized);
+      if (base && localContent && remoteContent) {
+        const merged = mergeText(base, 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.options.log(`Merged non-overlapping local and Overleaf changes in ${normalized}.`);
+          return;
+        }
+      }
+      this.conflicts.add(normalized);
+      const reason = "Both local and Overleaf content changed since the last synchronized checkpoint.";
+      this.options.onConflict(normalized, reason);
+      return;
+    }
+    if (localChanged || !remoteChanged && source === "local") {
+      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);
+        }
+        updateSyncCheckpoint(this.state, normalized, synchronized);
+      }
+      await this.options.stateStore.save(this.state);
+      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);
+  }
+  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("."));
+  }
+};
+var FileSyncStateStore = class {
+  constructor(directory, projectUri) {
+    this.projectUri = projectUri;
+    this.path = resolve4(directory, ".overleaf", "sync-state.json");
+  }
+  projectUri;
+  path;
+  serialized;
+  async load() {
+    try {
+      const content = await readFile4(this.path, "utf8");
+      const state = parseSyncState(content, this.projectUri);
+      if (state) {
+        this.serialized = `${JSON.stringify(state, null, 2)}
+`;
+      }
+      return state;
+    } catch (error2) {
+      if (error2.code === "ENOENT") {
+        return void 0;
+      }
+      throw error2;
+    }
+  }
+  async save(state) {
+    const serialized = `${JSON.stringify(state, null, 2)}
+`;
+    if (serialized === this.serialized) {
+      return;
+    }
+    await mkdir3(dirname3(this.path), { recursive: true });
+    await writeFile3(this.path, serialized, "utf8");
+    this.serialized = serialized;
+  }
+};
+async function startServe(directory = process.cwd()) {
+  const root = resolve5(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 = process.env.LEAFRELAY_COOKIE || session.identity.cookies;
+  const 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,
+    log,
+    onConflict: (path, reason) => {
+      log(`Conflict paused for ${path}: ${reason}`);
+    }
+  });
+  try {
+    await engine.start();
+  } catch (error2) {
+    remote.disconnect();
+    throw error2;
+  }
+  log(`LeafRelay is serving ${root} (${settings.projectName}).`);
+  return {
+    stop: async () => {
+      await engine.stop();
+      remote.disconnect();
+    }
+  };
+}
+
+export {
+  OverleafRealtimeSocket,
+  overleafSocketProtocol,
+  setLogSink,
+  log,
+  warn,
+  error,
+  BaseAPI,
+  ExtendedBaseAPI,
+  SocketIOAPI,
+  FolderKeys,
+  configPath,
+  normalizeServerUrl,
+  serverKey,
+  readConfig,
+  writeConfig,
+  saveServerSession,
+  getServerSession,
+  NodeReplicaFileSystem,
+  readProjectSettings,
+  DEFAULT_IGNORE_PATTERNS,
+  createIgnoreMatcher,
+  RemoteProject,
+  encodeTextBase,
+  mergeText,
+  SYNC_STATE_SCHEMA_VERSION,
+  sha256,
+  parseSyncState,
+  createSyncState,
+  updateSyncCheckpoint,
+  removeSyncCheckpoint,
+  readTextBase,
+  SyncEngine,
+  FileSyncStateStore,
+  startServe
+};
+//# sourceMappingURL=chunk-MNOPLM7M.js.map