leafrelay 0.2.7 → 0.2.9

package/dist/chunk-3TTRDNHP.js

@@ -1,3333 +0,0 @@
-// ../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 DiffMatchPatch2 from "diff-match-patch";
-import { createHash as createHash2 } from "crypto";
-import { diff3Merge } from "node-diff3";
-import { randomUUID } from "crypto";
-import { mkdir as mkdir3, readFile as readFile4, readdir as readdir2, rename, rm as rm2, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname3, join as join2, 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;
-  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;
-      }
-    }
-  };
-  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(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) {
-          void this.receive(event.data, socket);
-        }
-      });
-      socket.addEventListener("error", (error2) => {
-        if (this.socket === socket) {
-          this.events.emit("error", error2);
-        }
-      });
-      socket.addEventListener("close", (event) => {
-        if (this.socket === socket) {
-          this.handleClose(event);
-        }
-      });
-    } catch (error2) {
-      if (controller.signal.aborted) {
-        return;
-      }
-      this.events.emit("connect_failed", error2);
-      this.events.emit("error", error2);
-      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);
-        break;
-      default:
-        break;
-    }
-  }
-  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 error2 = new Error(`Overleaf realtime connection closed: ${reason}`);
-    for (const callback of this.acknowledgements.values()) {
-      callback(error2);
-    }
-    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;
-      void this.connect();
-    }, delay);
-  }
-};
-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 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 {
-  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)));
-  }
-  options;
-  chain = Promise.resolve();
-  nextRequestAt = 0;
-  historyNextRequestAt = 0;
-  rateLimitedUntil = 0;
-  minimumIntervalMs;
-  historyIntervalMs;
-  fetchImplementation;
-  now;
-  wait;
-  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 timeout = AbortSignal.timeout(timeoutMs);
-      const signals = [timeout, 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 (error2) {
-        const destination = new URL(url);
-        error("HTTP request failed", {
-          method: init?.method ?? (input instanceof Request ? input.method : "GET"),
-          url: `${destination.origin}${destination.pathname}`,
-          error: error2
-        });
-        throw error2;
-      }
-      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;
-  }
-};
-var sharedHttpRequestScheduler = new HttpRequestScheduler();
-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 {
-  constructor(url, scheduler = sharedHttpRequestScheduler) {
-    this.scheduler = scheduler;
-    this.url = url;
-  }
-  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);
-  }
-  async getCsrfToken() {
-    const res = await this.scheduler.fetch(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 this.scheduler.fetch(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,
-      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 res = await this.scheduler.fetch(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, 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);
-            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 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) => {
-      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 }, 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) => {
-      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 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=${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;
-  joinedProject;
-  pendingProjectJoin;
-  _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;
-        this.joinedProject = void 0;
-        this.resetProjectJoin(new Error("The realtime connection was replaced."));
-        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 });
-      if (this.scheme === "realtime") {
-        this.joinedProject = void 0;
-        this.connectedPublicId = void 0;
-        this.resetProjectJoin(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", (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.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 resolve6;
-    let reject;
-    const promise = new Promise((resolveProject, rejectProject) => {
-      resolve6 = resolveProject;
-      reject = rejectProject;
-    });
-    void promise.catch(() => void 0);
-    return { promise, resolve: resolve6, 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);
-          });
-          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.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;
-      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.emitProjectEvent("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.emitProjectEvent("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.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(() => {
-      return;
-    });
-  }
-};
-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 (error2) {
-    if (error2.code === "ENOENT") {
-      return { version: 1, servers: {}, knownServers: {} };
-    }
-    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);
-  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 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, transport) {
-    this.url = url;
-    this.projectId = projectId;
-    this.cookies = cookies;
-    this.externalTransport = transport;
-    this.api = transport?.api ?? new BaseAPI(url);
-  }
-  url;
-  projectId;
-  cookies;
-  api;
-  identity;
-  socket;
-  project;
-  entries = /* @__PURE__ */ new Map();
-  idToPath = /* @__PURE__ */ new Map();
-  collaboratorNames = /* @__PURE__ */ new Map();
-  changeHandler;
-  reconnectHandler;
-  externalTransport;
-  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(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, actor) {
-    this.changeHandler?.({ path: normalizePath(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 void 0;
-    }
-    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));
-        }
-      }
-    });
-  }
-};
-var decoder = new TextDecoder("utf-8", { fatal: true });
-function decode(content) {
-  if (content === void 0) {
-    return "";
-  }
-  if (content.includes(0)) {
-    return void 0;
-  }
-  try {
-    return decoder.decode(content);
-  } catch {
-    return void 0;
-  }
-}
-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 void 0;
-  }
-  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 void 0;
-  }
-  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 DiffMatchPatch2().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)}`;
-}
-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 = 1;
-function sha256(content) {
-  return createHash2("sha256").update(content).digest("hex");
-}
-function createSyncState(projectUri, remoteVersion, initialized = true) {
-  return {
-    schemaVersion: SYNC_STATE_SCHEMA_VERSION,
-    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 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;
-  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 void 0;
-    }
-    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.`;
-  }
-  async start() {
-    this.stopped = false;
-    const startup = this.enqueue(() => this.initialize());
-    try {
-      await startup;
-    } catch (error2) {
-      await this.stop();
-      throw error2;
-    }
-  }
-  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((error2) => {
-        this.options.log(`Failed to reconcile after reconnecting: ${error2 instanceof Error ? error2.message : String(error2)}`);
-      });
-    });
-    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 = normalizePath2(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 = normalizePath2(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 (error2) {
-      if (reason !== void 0) {
-        this.conflicts.add(normalized);
-        this.state.conflicts[normalized] = reason;
-        await this.options.stateStore.save(this.state);
-      }
-      throw error2;
-    }
-  }
-  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 = normalizePath2(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 (error2) {
-        this.recordFailure(normalized, "local", error2);
-      }
-    }
-    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;
-    const localHash = localContent && sha256(localContent);
-    const remoteHash = remoteContent && sha256(remoteContent);
-    if (localHash === remoteHash) {
-      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(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);
-        }
-      }
-    }
-    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 (error2) {
-        this.recordFailure(path, localChanged.has(path) ? "local" : "remote", error2);
-      }
-    }
-    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 = normalizePath2(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((error2) => {
-          this.recordFailure(normalized, pending.source, error2, 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, error2, actor) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    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;
-      void this.enqueue(async () => {
-        if (this.stopped) {
-          return;
-        }
-        for (const [path, failure] of [...this.failedPaths]) {
-          if (this.stopped) {
-            return;
-          }
-          try {
-            await this.synchronizePath(path, failure.source, failure.actor);
-            this.options.log(`Recovered synchronization for ${path}.`);
-          } catch (error2) {
-            const message = error2 instanceof Error ? error2.message : String(error2);
-            this.failedPaths.set(path, { ...failure, message });
-            this.options.log(`Retry failed for ${path}: ${message}`);
-          }
-        }
-        await this.finishRemoteBatch();
-      }).catch((error2) => this.options.log(`Could not checkpoint retry batch: ${String(error2)}`)).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 = normalizePath2(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;
-        }
-      }
-      const reason = "Both local and Overleaf content changed since the last synchronized checkpoint.";
-      await this.recordConflict(normalized, reason);
-      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("."));
-  }
-};
-var HASH_PATTERN = /^[a-f0-9]{64}$/;
-var encoder = new TextEncoder();
-function json(value) {
-  return `${JSON.stringify(value, null, 2)}
-`;
-}
-function pathKey(path) {
-  return sha256(encoder.encode(path));
-}
-async function readJson(path) {
-  return JSON.parse(await readFile4(path, "utf8"));
-}
-async function listFiles(directory) {
-  const result = [];
-  const visit = async (current) => {
-    let entries;
-    try {
-      entries = await readdir2(current, { withFileTypes: true });
-    } catch (error2) {
-      if (error2.code === "ENOENT") {
-        return;
-      }
-      throw error2;
-    }
-    for (const entry of entries) {
-      const path = join2(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 mkdir3(dirname3(path), { recursive: true });
-  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
-  try {
-    await writeFile3(temporary, content);
-    await rename(temporary, path);
-  } finally {
-    await rm2(temporary, { force: true });
-  }
-}
-function parseFormat(value, projectUri) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const format = value;
-  return format.schemaVersion === SYNC_STATE_SCHEMA_VERSION && 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 void 0;
-  }
-  return {
-    path,
-    ...hash === void 0 ? {} : { hash },
-    ...textBase === void 0 ? {} : { baseHash: hash },
-    ...conflict === void 0 ? {} : { conflict }
-  };
-}
-var FileSyncStateStore = class {
-  constructor(directory, projectUri) {
-    this.projectUri = projectUri;
-    const overleafDirectory = resolve4(directory, ".overleaf");
-    this.legacyPath = join2(overleafDirectory, "sync-state.json");
-    this.syncDirectory = join2(overleafDirectory, "sync");
-    this.formatPath = join2(this.syncDirectory, "format.json");
-    this.cursorPath = join2(this.syncDirectory, "cursor.json");
-    this.pathsDirectory = join2(this.syncDirectory, "paths");
-    this.basesDirectory = join2(this.syncDirectory, "bases");
-  }
-  projectUri;
-  legacyPath;
-  syncDirectory;
-  formatPath;
-  cursorPath;
-  pathsDirectory;
-  basesDirectory;
-  persistedRecords = /* @__PURE__ */ new Map();
-  persistedCursor;
-  invalidRecordPaths = /* @__PURE__ */ new Set();
-  initialized = false;
-  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 void 0;
-      }
-      const state = {
-        schemaVersion: SYNC_STATE_SCHEMA_VERSION,
-        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 rm2(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 readFile4(this.basePath(record.baseHash), "utf8");
-          } catch (error2) {
-            if (error2.code === "ENOENT") {
-              this.invalidRecordPaths.add(recordPath);
-              stateIncomplete = true;
-              delete state.files[record.path];
-              continue;
-            }
-            throw error2;
-          }
-          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 (error2) {
-      if (error2.code === "ENOENT" || error2 instanceof SyntaxError) {
-        return void 0;
-      }
-      throw error2;
-    }
-  }
-  async save(state) {
-    if (state.projectUri !== this.projectUri || state.schemaVersion !== SYNC_STATE_SCHEMA_VERSION) {
-      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 rm2(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) => rm2(path, { force: true })));
-      this.invalidRecordPaths.clear();
-    }
-    await rm2(this.legacyPath, { force: true });
-    await this.removeObsoleteBases(state, obsoleteBases);
-  }
-  async initializeStorage() {
-    await rm2(this.syncDirectory, { recursive: true, force: true });
-    await mkdir3(this.pathsDirectory, { recursive: true });
-    await mkdir3(this.basesDirectory, { recursive: true });
-    await atomicWrite(this.formatPath, json({
-      schemaVersion: SYNC_STATE_SCHEMA_VERSION,
-      projectUri: this.projectUri
-    }));
-    this.persistedRecords.clear();
-    this.persistedCursor = void 0;
-    this.invalidRecordPaths.clear();
-    this.initialized = true;
-  }
-  recordPath(path) {
-    const key = pathKey(path);
-    return join2(this.pathsDirectory, key.slice(0, 2), `${key}.json`);
-  }
-  async loadRecord(recordPath) {
-    if (!recordPath.endsWith(".json")) {
-      return void 0;
-    }
-    try {
-      const record = await readJson(recordPath);
-      if (!parsePathRecord(record) || recordPath !== this.recordPath(record.path)) {
-        return void 0;
-      }
-      return record;
-    } catch (error2) {
-      if (error2.code === "ENOENT" || error2 instanceof SyntaxError) {
-        return void 0;
-      }
-      throw error2;
-    }
-  }
-  basePath(hash) {
-    return join2(this.basesDirectory, hash.slice(0, 2), `${hash}.txt`);
-  }
-  async writeBase(hash, content) {
-    const path = this.basePath(hash);
-    try {
-      if (sha256(encoder.encode(await readFile4(path, "utf8"))) === hash) {
-        return;
-      }
-    } catch (error2) {
-      if (error2.code !== "ENOENT") {
-        throw error2;
-      }
-    }
-    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 rm2(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 rm2(path, { force: true });
-      }
-    }
-  }
-};
-async function startServe(directory = process.cwd(), options = {}) {
-  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 = 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 (error2) {
-    remote.disconnect();
-    throw error2;
-  }
-  (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 {
-  setLogSink,
-  HttpRequestScheduler,
-  ExtendedBaseAPI,
-  SocketIOAPI,
-  configPath,
-  normalizeServerUrl,
-  serverKey,
-  readConfig,
-  saveServerSession,
-  saveKnownServer,
-  removeKnownServer,
-  removeServerSession,
-  getServerSession,
-  readProjectSettings,
-  RemoteProject,
-  startServe
-};
-//# sourceMappingURL=chunk-3TTRDNHP.js.map