leafrelay 0.2.7 → 0.2.9

package/dist/daemon.js

@@ -1,976 +1,909 @@
-import {
-  ExtendedBaseAPI,
-  HttpRequestScheduler,
-  RemoteProject,
-  SocketIOAPI,
-  getServerSession,
-  normalizeServerUrl,
-  readConfig,
-  readProjectSettings,
-  removeKnownServer,
-  removeServerSession,
-  saveKnownServer,
-  saveServerSession,
-  serverKey,
-  setLogSink,
-  startServe
-} from "./chunk-3TTRDNHP.js";
-
-// ../daemon/src/server.ts
-import { randomBytes, randomUUID as randomUUID2 } from "crypto";
-import { appendFile, chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
-import { createServer } from "net";
-import { formatWithOptions } from "util";
-
+import { c as readConfig, d as removeServerSession, f as saveKnownServer, g as startServe, h as setLogSink, i as SocketIOAPI, l as readProjectSettings, m as serverKey, n as HttpRequestScheduler, o as getServerSession, p as saveServerSession, r as RemoteProject, s as normalizeServerUrl, t as ExtendedBaseAPI, u as removeKnownServer } from "./dist-JyfvbgjD.js";
+import { formatWithOptions } from "node:util";
+import { appendFile, chmod, mkdir, realpath, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { createServer } from "node:net";
+import { ResponseError, SocketMessageReader, SocketMessageWriter, createMessageConnection } from "vscode-jsonrpc/node";
 // ../protocol/dist/index.js
-var LEAFRELAY_PROTOCOL_VERSION = 1;
-var RPC_METHOD = {
-  initialize: "leafrelay/initialize",
-  daemonStatus: "leafrelay/daemon/status",
-  daemonShutdown: "leafrelay/daemon/shutdown",
-  replicaAttach: "leafrelay/replica/attach",
-  replicaDetach: "leafrelay/replica/detach",
-  replicaResolveConflict: "leafrelay/replica/resolveConflict",
-  replicaRetry: "leafrelay/replica/retry",
-  sessionImport: "leafrelay/session/import",
-  sessionLogin: "leafrelay/session/login",
-  sessionLogout: "leafrelay/session/logout",
-  serverList: "leafrelay/server/list",
-  serverAdd: "leafrelay/server/add",
-  serverRemove: "leafrelay/server/remove",
-  serverCall: "leafrelay/server/call",
-  projectOpen: "leafrelay/project/open",
-  projectClose: "leafrelay/project/close",
-  projectCall: "leafrelay/project/call"
+const RPC_METHOD = {
+	initialize: "leafrelay/initialize",
+	daemonStatus: "leafrelay/daemon/status",
+	daemonShutdown: "leafrelay/daemon/shutdown",
+	replicaAttach: "leafrelay/replica/attach",
+	replicaDetach: "leafrelay/replica/detach",
+	replicaResolveConflict: "leafrelay/replica/resolveConflict",
+	replicaRetry: "leafrelay/replica/retry",
+	sessionImport: "leafrelay/session/import",
+	sessionLogin: "leafrelay/session/login",
+	sessionLogout: "leafrelay/session/logout",
+	serverList: "leafrelay/server/list",
+	serverAdd: "leafrelay/server/add",
+	serverRemove: "leafrelay/server/remove",
+	serverCall: "leafrelay/server/call",
+	projectOpen: "leafrelay/project/open",
+	projectClose: "leafrelay/project/close",
+	projectCall: "leafrelay/project/call"
 };
-var RPC_NOTIFICATION = {
-  log: "leafrelay/log",
-  replicaStatus: "leafrelay/replica/status",
-  replicaConflict: "leafrelay/replica/conflict",
-  projectEvent: "leafrelay/project/event"
+const RPC_NOTIFICATION = {
+	log: "leafrelay/log",
+	replicaStatus: "leafrelay/replica/status",
+	replicaConflict: "leafrelay/replica/conflict",
+	projectEvent: "leafrelay/project/event"
 };
-
-// ../daemon/src/server.ts
-import { ResponseError } from "vscode-jsonrpc/node";
-
 // ../daemon/src/paths.ts
-import { createHash } from "crypto";
-import { homedir } from "os";
-import { join, resolve } from "path";
 function daemonPaths(environment = process.env) {
-  const home = environment.LEAFRELAY_HOME ? resolve(environment.LEAFRELAY_HOME) : join(homedir(), ".leafrelay");
-  const socketPath = process.platform === "win32" ? `\\\\.\\pipe\\leafrelay-${createHash("sha256").update(home).digest("hex").slice(0, 16)}` : join(home, "daemon.sock");
-  return {
-    home,
-    socketPath,
-    metadataPath: join(home, "daemon.json"),
-    logPath: join(home, "daemon.log"),
-    startupLockPath: join(home, "daemon.starting")
-  };
+	const home = environment.LEAFRELAY_HOME ? resolve(environment.LEAFRELAY_HOME) : join(homedir(), ".leafrelay");
+	return {
+		home,
+		socketPath: process.platform === "win32" ? `\\\\.\\pipe\\leafrelay-${createHash("sha256").update(home).digest("hex").slice(0, 16)}` : join(home, "daemon.sock"),
+		metadataPath: join(home, "daemon.json"),
+		logPath: join(home, "daemon.log"),
+		startupLockPath: join(home, "daemon.starting")
+	};
 }
-
 // ../daemon/src/codec.ts
 function isEncodedBinary(value) {
-  return typeof value === "object" && value !== null && value.$leafrelay === "bytes" && typeof value.base64 === "string";
+	return typeof value === "object" && value !== null && value.$leafrelay === "bytes" && typeof value.base64 === "string";
 }
 function encodeRpcValue(value) {
-  if (value instanceof Uint8Array) {
-    return { $leafrelay: "bytes", base64: Buffer.from(value).toString("base64") };
-  }
-  if (Array.isArray(value)) {
-    return value.map(encodeRpcValue);
-  }
-  if (typeof value === "object" && value !== null) {
-    return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, encodeRpcValue(child)]));
-  }
-  return value;
+	if (value instanceof Uint8Array) return {
+		$leafrelay: "bytes",
+		base64: Buffer.from(value).toString("base64")
+	};
+	if (Array.isArray(value)) return value.map(encodeRpcValue);
+	if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, encodeRpcValue(child)]));
+	return value;
 }
 function decodeRpcValue(value) {
-  if (isEncodedBinary(value)) {
-    return Uint8Array.from(Buffer.from(value.base64, "base64"));
-  }
-  if (Array.isArray(value)) {
-    return value.map(decodeRpcValue);
-  }
-  if (typeof value === "object" && value !== null) {
-    return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, decodeRpcValue(child)]));
-  }
-  return value;
+	if (isEncodedBinary(value)) return Uint8Array.from(Buffer.from(value.base64, "base64"));
+	if (Array.isArray(value)) return value.map(decodeRpcValue);
+	if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, decodeRpcValue(child)]));
+	return value;
 }
-
 // ../daemon/src/networkRuntime.ts
-var SERVER_OPERATIONS = /* @__PURE__ */ new Set([
-  "userProjectsJson",
-  "getProjectsJson",
-  "projectEntitiesJson",
-  "newProject",
-  "cloneProject",
-  "renameProject",
-  "deleteProject",
-  "archiveProject",
-  "unarchiveProject",
-  "trashProject",
-  "untrashProject",
-  "getFile",
-  "addDoc",
-  "uploadFile",
-  "uploadProject",
-  "addFolder",
-  "deleteEntity",
-  "deleteAuxFiles",
-  "renameEntity",
-  "moveEntity",
-  "compile",
-  "stopCompile",
-  "indexAll",
-  "getMetadata",
-  "proxyRequestToSpellingApi",
-  "spellingControllerLearn",
-  "spellingControllerUnlearn",
-  "getProjectSettings",
-  "updateProjectSettings",
-  "getFileFromClsi",
-  "proxySyncPdf",
-  "proxySyncCode",
-  "getAllTags",
-  "createTag",
-  "renameTag",
-  "deleteTag",
-  "addProjectToTag",
-  "removeProjectFromTag",
-  "proxyToHistoryApiAndGetUpdates",
-  "proxyToHistoryApiAndGetFileDiff",
-  "proxyToHistoryApiAndGetFileTreeDiff",
-  "downloadZipOfVersion",
-  "getLabels",
-  "createLabel",
-  "deleteLabel",
-  "getMessages",
-  "sendMessage",
-  "refreshLinkedFile",
-  "createLinkedFile"
+const SERVER_OPERATIONS = /* @__PURE__ */ new Set([
+	"userProjectsJson",
+	"getProjectsJson",
+	"projectEntitiesJson",
+	"newProject",
+	"cloneProject",
+	"renameProject",
+	"deleteProject",
+	"archiveProject",
+	"unarchiveProject",
+	"trashProject",
+	"untrashProject",
+	"getFile",
+	"addDoc",
+	"uploadFile",
+	"uploadProject",
+	"addFolder",
+	"deleteEntity",
+	"deleteAuxFiles",
+	"renameEntity",
+	"moveEntity",
+	"compile",
+	"stopCompile",
+	"indexAll",
+	"getMetadata",
+	"proxyRequestToSpellingApi",
+	"spellingControllerLearn",
+	"spellingControllerUnlearn",
+	"getProjectSettings",
+	"updateProjectSettings",
+	"getFileFromClsi",
+	"proxySyncPdf",
+	"proxySyncCode",
+	"getAllTags",
+	"createTag",
+	"renameTag",
+	"deleteTag",
+	"addProjectToTag",
+	"removeProjectFromTag",
+	"proxyToHistoryApiAndGetUpdates",
+	"proxyToHistoryApiAndGetFileDiff",
+	"proxyToHistoryApiAndGetFileTreeDiff",
+	"downloadZipOfVersion",
+	"getLabels",
+	"createLabel",
+	"deleteLabel",
+	"getMessages",
+	"sendMessage",
+	"refreshLinkedFile",
+	"createLinkedFile"
 ]);
-var PROJECT_OPERATIONS = /* @__PURE__ */ new Set([
-  "init",
-  "joinProject",
-  "joinDoc",
-  "leaveDoc",
-  "applyOtUpdate",
-  "getConnectedUsers",
-  "updatePosition",
-  "syncFileChanges"
+const PROJECT_OPERATIONS = /* @__PURE__ */ new Set([
+	"init",
+	"joinProject",
+	"joinDoc",
+	"leaveDoc",
+	"applyOtUpdate",
+	"getConnectedUsers",
+	"updatePosition",
+	"syncFileChanges"
 ]);
-var REMOTE_PROJECT_OPERATIONS = /* @__PURE__ */ new Set([
-  "entry",
-  "listEntries",
-  "read",
-  "write",
-  "mkdir",
-  "remove",
-  "getCurrentVersion",
-  "getFileTreeDiff"
+const REMOTE_PROJECT_OPERATIONS = /* @__PURE__ */ new Set([
+	"entry",
+	"listEntries",
+	"read",
+	"write",
+	"mkdir",
+	"remove",
+	"getCurrentVersion",
+	"getFileTreeDiff"
 ]);
 var NetworkRuntimeRegistry = class {
-  constructor(events) {
-    this.events = events;
-  }
-  events;
-  servers = /* @__PURE__ */ new Map();
-  projects = /* @__PURE__ */ new Map();
-  get projectCount() {
-    return this.projects.size;
-  }
-  async listServers() {
-    const config = await readConfig();
-    const keys = /* @__PURE__ */ new Set([...Object.keys(config.knownServers ?? {}), ...Object.keys(config.servers)]);
-    if (keys.size === 0) {
-      keys.add("www.overleaf.com");
-    }
-    return [...keys].sort().map((key) => {
-      const session = config.servers[key];
-      const known = config.knownServers?.[key];
-      return {
-        name: known?.name ?? key,
-        url: known?.url ?? session?.url ?? normalizeServerUrl(key),
-        loggedIn: Boolean(session),
-        userId: session?.userId,
-        userEmail: session?.userEmail
-      };
-    });
-  }
-  async addServer(name, url) {
-    await saveKnownServer(name, url);
-  }
-  async removeServer(server2) {
-    const key = serverKey(server2);
-    for (const project of this.projects.values()) {
-      if (project.server.key === key) {
-        await this.stopProject(project);
-      }
-    }
-    this.servers.delete(key);
-    await removeKnownServer(server2);
-  }
-  async login(params) {
-    const url = normalizeServerUrl(params.server);
-    const scheduler = new HttpRequestScheduler({
-      onRateLimit: (until) => this.events.log("warn", `${serverKey(url)} is rate limited until ${new Date(until).toISOString()}.`)
-    });
-    const api = new ExtendedBaseAPI(url, scheduler);
-    const response = params.cookie ? await api.cookiesLogin(params.cookie) : await api.passportLogin(params.email ?? "", params.password ?? "");
-    if (response.type !== "success" || !response.identity || !response.userInfo) {
-      throw new Error(response.message || `Login to ${url} failed.`);
-    }
-    const session = {
-      url,
-      userId: response.userInfo.userId,
-      userEmail: response.userInfo.userEmail || params.email || "",
-      identity: response.identity,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    await saveServerSession(session);
-    this.servers.set(serverKey(url), { key: serverKey(url), session, scheduler, api });
-    return { userId: session.userId, userEmail: session.userEmail };
-  }
-  async importSession(params) {
-    const result = await this.login({ server: params.url, cookie: params.identity.cookies });
-    await saveKnownServer(params.name, params.url);
-    return result;
-  }
-  async logout(server2) {
-    const runtime = await this.requireServer(server2);
-    await runtime.api.logout(runtime.session.identity);
-    await removeServerSession(server2);
-    this.servers.delete(runtime.key);
-  }
-  async callServer(server2, operation, args) {
-    if (!SERVER_OPERATIONS.has(operation)) {
-      throw new Error(`Unsupported server operation: ${operation}.`);
-    }
-    const runtime = await this.requireServer(server2);
-    const method = runtime.api[operation];
-    if (typeof method !== "function") {
-      throw new Error(`Server operation ${operation} is unavailable.`);
-    }
-    return method.call(runtime.api, runtime.session.identity, ...args);
-  }
-  async openProject(clientId, server2, projectId) {
-    const runtime = await this.getOrCreateProject(server2, projectId);
-    const shared = runtime.owners.size !== 0 || runtime.replicaReferences !== 0;
-    runtime.owners.add(clientId);
-    await runtime.ready;
-    return { projectKey: runtime.key, shared };
-  }
-  closeProject(clientId, projectKey) {
-    const runtime = this.requireProject(projectKey);
-    runtime.owners.delete(clientId);
-    this.scheduleProjectStop(runtime);
-  }
-  async callProject(projectKey, operation, args) {
-    const runtime = this.requireProject(projectKey);
-    await runtime.ready;
-    if (operation.startsWith("remote.")) {
-      const remoteOperation = operation.slice("remote.".length);
-      if (!REMOTE_PROJECT_OPERATIONS.has(remoteOperation)) {
-        throw new Error(`Unsupported remote project operation: ${remoteOperation}.`);
-      }
-      const method2 = runtime.remote[remoteOperation];
-      if (typeof method2 !== "function") {
-        throw new Error(`Remote project operation ${remoteOperation} is unavailable.`);
-      }
-      return this.enqueueProjectOperation(runtime, () => method2.apply(runtime.remote, args));
-    }
-    if (!PROJECT_OPERATIONS.has(operation)) {
-      throw new Error(`Unsupported project operation: ${operation}.`);
-    }
-    const method = runtime.socket[operation];
-    if (typeof method !== "function") {
-      throw new Error(`Project operation ${operation} is unavailable.`);
-    }
-    return method.apply(runtime.socket, args);
-  }
-  async acquireReplica(server2, projectId) {
-    const runtime = await this.getOrCreateProject(server2, projectId);
-    runtime.replicaReferences += 1;
-    await runtime.ready;
-    let released = false;
-    return {
-      remote: this.replicaRemote(runtime),
-      release: () => {
-        if (released) {
-          return;
-        }
-        released = true;
-        runtime.replicaReferences -= 1;
-        this.scheduleProjectStop(runtime);
-      }
-    };
-  }
-  detachClient(clientId) {
-    for (const runtime of this.projects.values()) {
-      if (runtime.owners.delete(clientId)) {
-        this.scheduleProjectStop(runtime);
-      }
-    }
-  }
-  async stopAll() {
-    await Promise.all([...this.projects.values()].map((runtime) => this.stopProject(runtime)));
-    this.servers.clear();
-  }
-  async requireServer(server2) {
-    const key = serverKey(server2);
-    const existing = this.servers.get(key);
-    if (existing) {
-      return existing;
-    }
-    const session = await getServerSession(server2);
-    if (!session) {
-      throw new Error(`Not logged in to ${key}.`);
-    }
-    const scheduler = new HttpRequestScheduler({
-      onRateLimit: (until) => this.events.log("warn", `${key} is rate limited until ${new Date(until).toISOString()}.`)
-    });
-    const runtime = { key, session, scheduler, api: new ExtendedBaseAPI(session.url, scheduler) };
-    this.servers.set(key, runtime);
-    return runtime;
-  }
-  async getOrCreateProject(server2, projectId) {
-    const serverRuntime = await this.requireServer(server2);
-    const key = `${serverRuntime.key}:${projectId}`;
-    const existing = this.projects.get(key);
-    if (existing) {
-      return existing;
-    }
-    const socket = new SocketIOAPI(serverRuntime.session.url, serverRuntime.api, serverRuntime.session.identity, projectId);
-    const remote = new RemoteProject(
-      serverRuntime.session.url,
-      projectId,
-      serverRuntime.session.identity.cookies,
-      { api: serverRuntime.api, identity: serverRuntime.session.identity, socket }
-    );
-    const runtime = {
-      key,
-      server: serverRuntime,
-      projectId,
-      socket,
-      remote,
-      ready: Promise.resolve(),
-      owners: /* @__PURE__ */ new Set(),
-      replicaReferences: 0,
-      operationQueue: Promise.resolve()
-    };
-    runtime.ready = remote.connect().then(() => this.registerProjectEvents(runtime)).catch((error) => {
-      this.projects.delete(key);
-      socket.disconnect();
-      throw error;
-    });
-    this.projects.set(key, runtime);
-    return runtime;
-  }
-  registerProjectEvents(runtime) {
-    const emit = (event, ...args) => this.events.projectEvent(runtime.owners, {
-      projectKey: runtime.key,
-      event,
-      args
-    });
-    runtime.socket.updateEventHandlers({
-      onFileCreated: (...args) => emit("onFileCreated", ...args),
-      onFileRenamed: (...args) => emit("onFileRenamed", ...args),
-      onFileRemoved: (...args) => emit("onFileRemoved", ...args),
-      onFileMoved: (...args) => emit("onFileMoved", ...args),
-      onFileChanged: (...args) => emit("onFileChanged", ...args),
-      onDisconnected: (reason) => emit("onDisconnected", reason),
-      onConnectionAccepted: (...args) => emit("onConnectionAccepted", ...args),
-      onClientUpdated: (...args) => emit("onClientUpdated", ...args),
-      onClientDisconnected: (...args) => emit("onClientDisconnected", ...args),
-      onReceivedMessage: (...args) => emit("onReceivedMessage", ...args),
-      onSpellCheckLanguageUpdated: (...args) => emit("onSpellCheckLanguageUpdated", ...args),
-      onCompilerUpdated: (...args) => emit("onCompilerUpdated", ...args),
-      onRootDocUpdated: (...args) => emit("onRootDocUpdated", ...args)
-    });
-  }
-  requireProject(projectKey) {
-    const runtime = this.projects.get(projectKey);
-    if (!runtime) {
-      throw new Error(`Unknown project runtime ${projectKey}.`);
-    }
-    return runtime;
-  }
-  replicaRemote(runtime) {
-    return {
-      connect: async () => {
-      },
-      disconnect: () => {
-      },
-      listEntries: () => runtime.remote.listEntries(),
-      entry: (path) => runtime.remote.entry(path),
-      read: (path) => this.enqueueProjectOperation(runtime, () => runtime.remote.read(path)),
-      write: (path, content) => this.enqueueProjectOperation(runtime, () => runtime.remote.write(path, content)),
-      remove: (path) => this.enqueueProjectOperation(runtime, () => runtime.remote.remove(path)),
-      getCurrentVersion: () => this.enqueueProjectOperation(runtime, () => runtime.remote.getCurrentVersion()),
-      getFileTreeDiff: (from, to) => this.enqueueProjectOperation(runtime, () => runtime.remote.getFileTreeDiff(from, to)),
-      onChange: (handler) => runtime.remote.onChange(handler),
-      onReconnect: (handler) => runtime.remote.onReconnect(handler)
-    };
-  }
-  enqueueProjectOperation(runtime, operation) {
-    const result = runtime.operationQueue.then(operation);
-    runtime.operationQueue = result.then(() => void 0, () => void 0);
-    return result;
-  }
-  scheduleProjectStop(runtime) {
-    if (runtime.owners.size !== 0 || runtime.replicaReferences !== 0) {
-      return;
-    }
-    void this.stopProject(runtime);
-  }
-  async stopProject(runtime) {
-    if (!this.projects.delete(runtime.key)) {
-      return;
-    }
-    runtime.socket.disconnect();
-  }
+	events;
+	servers = /* @__PURE__ */ new Map();
+	projects = /* @__PURE__ */ new Map();
+	constructor(events) {
+		this.events = events;
+	}
+	get projectCount() {
+		return this.projects.size;
+	}
+	async listServers() {
+		const config = await readConfig();
+		const keys = /* @__PURE__ */ new Set([...Object.keys(config.knownServers ?? {}), ...Object.keys(config.servers)]);
+		if (keys.size === 0) keys.add("www.overleaf.com");
+		return [...keys].sort().map((key) => {
+			const session = config.servers[key];
+			const known = config.knownServers?.[key];
+			return {
+				name: known?.name ?? key,
+				url: known?.url ?? session?.url ?? normalizeServerUrl(key),
+				loggedIn: Boolean(session),
+				userId: session?.userId,
+				userEmail: session?.userEmail
+			};
+		});
+	}
+	async addServer(name, url) {
+		await saveKnownServer(name, url);
+	}
+	async removeServer(server) {
+		const key = serverKey(server);
+		for (const project of this.projects.values()) if (project.server.key === key) await this.stopProject(project);
+		this.servers.delete(key);
+		await removeKnownServer(server);
+	}
+	async login(params) {
+		const url = normalizeServerUrl(params.server);
+		const scheduler = new HttpRequestScheduler({ onRateLimit: (until) => this.events.log("warn", `${serverKey(url)} is rate limited until ${new Date(until).toISOString()}.`) });
+		const api = new ExtendedBaseAPI(url, scheduler);
+		const response = params.cookie ? await api.cookiesLogin(params.cookie) : await api.passportLogin(params.email ?? "", params.password ?? "");
+		if (response.type !== "success" || !response.identity || !response.userInfo) throw new Error(response.message || `Login to ${url} failed.`);
+		const session = {
+			url,
+			userId: response.userInfo.userId,
+			userEmail: response.userInfo.userEmail || params.email || "",
+			identity: response.identity,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await saveServerSession(session);
+		this.servers.set(serverKey(url), {
+			key: serverKey(url),
+			session,
+			scheduler,
+			api
+		});
+		return {
+			userId: session.userId,
+			userEmail: session.userEmail
+		};
+	}
+	async importSession(params) {
+		const result = await this.login({
+			server: params.url,
+			cookie: params.identity.cookies
+		});
+		await saveKnownServer(params.name, params.url);
+		return result;
+	}
+	async logout(server) {
+		const runtime = await this.requireServer(server);
+		await runtime.api.logout(runtime.session.identity);
+		await removeServerSession(server);
+		this.servers.delete(runtime.key);
+	}
+	async callServer(server, operation, args) {
+		if (!SERVER_OPERATIONS.has(operation)) throw new Error(`Unsupported server operation: ${operation}.`);
+		const runtime = await this.requireServer(server);
+		const method = runtime.api[operation];
+		if (typeof method !== "function") throw new Error(`Server operation ${operation} is unavailable.`);
+		return method.call(runtime.api, runtime.session.identity, ...args);
+	}
+	async openProject(clientId, server, projectId) {
+		const runtime = await this.getOrCreateProject(server, projectId);
+		const shared = runtime.owners.size !== 0 || runtime.replicaReferences !== 0;
+		runtime.owners.add(clientId);
+		await runtime.ready;
+		return {
+			projectKey: runtime.key,
+			shared
+		};
+	}
+	closeProject(clientId, projectKey) {
+		const runtime = this.requireProject(projectKey);
+		runtime.owners.delete(clientId);
+		this.scheduleProjectStop(runtime);
+	}
+	async callProject(projectKey, operation, args) {
+		const runtime = this.requireProject(projectKey);
+		await runtime.ready;
+		if (operation.startsWith("remote.")) {
+			const remoteOperation = operation.slice(7);
+			if (!REMOTE_PROJECT_OPERATIONS.has(remoteOperation)) throw new Error(`Unsupported remote project operation: ${remoteOperation}.`);
+			const method = runtime.remote[remoteOperation];
+			if (typeof method !== "function") throw new Error(`Remote project operation ${remoteOperation} is unavailable.`);
+			return this.enqueueProjectOperation(runtime, () => method.apply(runtime.remote, args));
+		}
+		if (!PROJECT_OPERATIONS.has(operation)) throw new Error(`Unsupported project operation: ${operation}.`);
+		const method = runtime.socket[operation];
+		if (typeof method !== "function") throw new Error(`Project operation ${operation} is unavailable.`);
+		return method.apply(runtime.socket, args);
+	}
+	async acquireReplica(server, projectId) {
+		const runtime = await this.getOrCreateProject(server, projectId);
+		runtime.replicaReferences += 1;
+		await runtime.ready;
+		let released = false;
+		return {
+			remote: this.replicaRemote(runtime),
+			release: () => {
+				if (released) return;
+				released = true;
+				runtime.replicaReferences -= 1;
+				this.scheduleProjectStop(runtime);
+			}
+		};
+	}
+	detachClient(clientId) {
+		for (const runtime of this.projects.values()) if (runtime.owners.delete(clientId)) this.scheduleProjectStop(runtime);
+	}
+	async stopAll() {
+		await Promise.all([...this.projects.values()].map((runtime) => this.stopProject(runtime)));
+		this.servers.clear();
+	}
+	async requireServer(server) {
+		const key = serverKey(server);
+		const existing = this.servers.get(key);
+		if (existing) return existing;
+		const session = await getServerSession(server);
+		if (!session) throw new Error(`Not logged in to ${key}.`);
+		const scheduler = new HttpRequestScheduler({ onRateLimit: (until) => this.events.log("warn", `${key} is rate limited until ${new Date(until).toISOString()}.`) });
+		const runtime = {
+			key,
+			session,
+			scheduler,
+			api: new ExtendedBaseAPI(session.url, scheduler)
+		};
+		this.servers.set(key, runtime);
+		return runtime;
+	}
+	async getOrCreateProject(server, projectId) {
+		const serverRuntime = await this.requireServer(server);
+		const key = `${serverRuntime.key}:${projectId}`;
+		const existing = this.projects.get(key);
+		if (existing) return existing;
+		const socket = new SocketIOAPI(serverRuntime.session.url, serverRuntime.api, serverRuntime.session.identity, projectId);
+		const remote = new RemoteProject(serverRuntime.session.url, projectId, serverRuntime.session.identity.cookies, {
+			api: serverRuntime.api,
+			identity: serverRuntime.session.identity,
+			socket
+		});
+		const runtime = {
+			key,
+			server: serverRuntime,
+			projectId,
+			socket,
+			remote,
+			ready: Promise.resolve(),
+			owners: /* @__PURE__ */ new Set(),
+			replicaReferences: 0,
+			operationQueue: Promise.resolve()
+		};
+		runtime.ready = remote.connect().then(() => this.registerProjectEvents(runtime)).catch((error) => {
+			this.projects.delete(key);
+			socket.disconnect();
+			throw error;
+		});
+		this.projects.set(key, runtime);
+		return runtime;
+	}
+	registerProjectEvents(runtime) {
+		const emit = (event, ...args) => this.events.projectEvent(runtime.owners, {
+			projectKey: runtime.key,
+			event,
+			args
+		});
+		runtime.socket.updateEventHandlers({
+			onFileCreated: (...args) => emit("onFileCreated", ...args),
+			onFileRenamed: (...args) => emit("onFileRenamed", ...args),
+			onFileRemoved: (...args) => emit("onFileRemoved", ...args),
+			onFileMoved: (...args) => emit("onFileMoved", ...args),
+			onFileChanged: (...args) => emit("onFileChanged", ...args),
+			onDisconnected: (reason) => emit("onDisconnected", reason),
+			onConnectionAccepted: (...args) => emit("onConnectionAccepted", ...args),
+			onClientUpdated: (...args) => emit("onClientUpdated", ...args),
+			onClientDisconnected: (...args) => emit("onClientDisconnected", ...args),
+			onReceivedMessage: (...args) => emit("onReceivedMessage", ...args),
+			onSpellCheckLanguageUpdated: (...args) => emit("onSpellCheckLanguageUpdated", ...args),
+			onCompilerUpdated: (...args) => emit("onCompilerUpdated", ...args),
+			onRootDocUpdated: (...args) => emit("onRootDocUpdated", ...args)
+		});
+	}
+	requireProject(projectKey) {
+		const runtime = this.projects.get(projectKey);
+		if (!runtime) throw new Error(`Unknown project runtime ${projectKey}.`);
+		return runtime;
+	}
+	replicaRemote(runtime) {
+		return {
+			connect: async () => {},
+			disconnect: () => {},
+			listEntries: () => runtime.remote.listEntries(),
+			entry: (path) => runtime.remote.entry(path),
+			read: (path) => this.enqueueProjectOperation(runtime, () => runtime.remote.read(path)),
+			write: (path, content) => this.enqueueProjectOperation(runtime, () => runtime.remote.write(path, content)),
+			remove: (path) => this.enqueueProjectOperation(runtime, () => runtime.remote.remove(path)),
+			getCurrentVersion: () => this.enqueueProjectOperation(runtime, () => runtime.remote.getCurrentVersion()),
+			getFileTreeDiff: (from, to) => this.enqueueProjectOperation(runtime, () => runtime.remote.getFileTreeDiff(from, to)),
+			onChange: (handler) => runtime.remote.onChange(handler),
+			onReconnect: (handler) => runtime.remote.onReconnect(handler)
+		};
+	}
+	enqueueProjectOperation(runtime, operation) {
+		const result = runtime.operationQueue.then(operation);
+		runtime.operationQueue = result.then(() => void 0, () => void 0);
+		return result;
+	}
+	scheduleProjectStop(runtime) {
+		if (runtime.owners.size !== 0 || runtime.replicaReferences !== 0) return;
+		this.stopProject(runtime);
+	}
+	async stopProject(runtime) {
+		if (!this.projects.delete(runtime.key)) return;
+		runtime.socket.disconnect();
+	}
 };
-
 // ../daemon/src/replicaRegistry.ts
-import { randomUUID } from "crypto";
-import { realpath } from "fs/promises";
-import { resolve as resolve2 } from "path";
 var ReplicaAlreadyActiveError = class extends Error {
-  constructor(projectId, activeRoot, requestedRoot) {
-    super(`Overleaf project ${projectId} is already synchronized by ${activeRoot}; ${requestedRoot} cannot become a second writable replica.`);
-    this.projectId = projectId;
-    this.activeRoot = activeRoot;
-    this.requestedRoot = requestedRoot;
-  }
-  projectId;
-  activeRoot;
-  requestedRoot;
-  code = "ReplicaAlreadyActive";
+	projectId;
+	activeRoot;
+	requestedRoot;
+	code = "ReplicaAlreadyActive";
+	constructor(projectId, activeRoot, requestedRoot) {
+		super(`Overleaf project ${projectId} is already synchronized by ${activeRoot}; ${requestedRoot} cannot become a second writable replica.`);
+		this.projectId = projectId;
+		this.activeRoot = activeRoot;
+		this.requestedRoot = requestedRoot;
+	}
 };
 var ReplicaRegistry = class {
-  constructor(events, start = startServe) {
-    this.events = events;
-    this.start = start;
-  }
-  events;
-  start;
-  byId = /* @__PURE__ */ new Map();
-  byRoot = /* @__PURE__ */ new Map();
-  byProject = /* @__PURE__ */ new Map();
-  projectOperations = /* @__PURE__ */ new Map();
-  clients = /* @__PURE__ */ new Set();
-  get size() {
-    return this.byId.size;
-  }
-  registerClient(clientId) {
-    this.clients.add(clientId);
-  }
-  async attach(clientId, params) {
-    const root = await realpath(resolve2(params.directory));
-    const settings = await readProjectSettings(root);
-    const projectKey = `${settings.serverName}\0${settings.projectId}`;
-    return this.withProjectLock(projectKey, () => this.attachResolved(clientId, params, root, settings, projectKey));
-  }
-  async attachResolved(clientId, params, root, settings, projectKey) {
-    if (!this.clients.has(clientId)) {
-      throw new Error("The replica client disconnected before attachment started.");
-    }
-    const rootEntry = this.byRoot.get(root);
-    if (rootEntry) {
-      if (rootEntry.projectKey !== projectKey) {
-        throw new Error(`${root} is already registered for another Overleaf project.`);
-      }
-      this.addOwner(rootEntry, clientId);
-      return this.result(rootEntry, true);
-    }
-    const projectEntry = this.byProject.get(projectKey);
-    if (projectEntry) {
-      throw new ReplicaAlreadyActiveError(settings.projectId, projectEntry.root, root);
-    }
-    const id = randomUUID();
-    const owners = /* @__PURE__ */ new Set([clientId]);
-    const status = { state: "starting" };
-    let entry;
-    this.events.status(owners, { replicaId: id, status });
-    this.events.log(`[${settings.projectName}] Starting synchronization for ${root}.`);
-    try {
-      const running = await this.start(root, {
-        cookie: params.cookie,
-        onSyncError: (message) => {
-          if (!entry) {
-            return;
-          }
-          entry.status = message ? { state: "error", message } : entry.running.conflicts().length ? { state: "paused" } : { state: "active" };
-          this.events.status(entry.owners, { replicaId: id, status: entry.status });
-        },
-        log: (message) => this.events.log(`[${settings.projectName}] ${message}`),
-        onConflict: (path, reason) => {
-          if (!entry) {
-            return;
-          }
-          entry.status = { state: "paused", message: `Conflict in ${path}` };
-          this.events.conflict(entry.owners, {
-            replicaId: entry.id,
-            path,
-            reason,
-            conflicts: entry.running.conflicts()
-          });
-          this.events.status(entry.owners, { replicaId: entry.id, status: entry.status });
-        }
-      });
-      if (!this.clients.has(clientId)) {
-        await running.stop();
-        this.events.empty();
-        throw new Error("The replica client disconnected before attachment completed.");
-      }
-      entry = {
-        id,
-        root,
-        projectKey,
-        serverName: settings.serverName,
-        projectId: settings.projectId,
-        projectName: settings.projectName,
-        owners,
-        running,
-        status: running.syncError() ? { state: "error", message: running.syncError() } : running.conflicts().length === 0 ? { state: "active" } : { state: "paused" }
-      };
-      this.byId.set(id, entry);
-      this.byRoot.set(root, entry);
-      this.byProject.set(projectKey, entry);
-      this.events.status(owners, { replicaId: id, status: entry.status });
-      return this.result(entry, false);
-    } catch (error) {
-      const failed = { state: "error", message: error instanceof Error ? error.message : String(error) };
-      this.events.status(owners, { replicaId: id, status: failed });
-      throw error;
-    }
-  }
-  async detach(clientId, replicaId) {
-    const entry = this.require(replicaId);
-    await this.withProjectLock(entry.projectKey, async () => {
-      entry.owners.delete(clientId);
-      if (entry.owners.size === 0) {
-        await this.stop(entry);
-      }
-    });
-  }
-  async detachClient(clientId) {
-    this.clients.delete(clientId);
-    const owned = [...this.byId.values()].filter((entry) => entry.owners.has(clientId));
-    await Promise.all(owned.map((entry) => this.withProjectLock(entry.projectKey, async () => {
-      entry.owners.delete(clientId);
-      if (entry.owners.size === 0) {
-        await this.stop(entry);
-      }
-    })));
-  }
-  async resolveConflict(replicaId, path, winner) {
-    const entry = this.require(replicaId);
-    await entry.running.resolveConflict(path, winner);
-    entry.status = entry.running.syncError() ? { state: "error", message: entry.running.syncError() } : entry.running.conflicts().length === 0 ? { state: "active" } : { state: "paused" };
-    this.events.status(entry.owners, { replicaId, status: entry.status });
-  }
-  async retry(replicaId, path) {
-    const entry = this.require(replicaId);
-    await entry.running.retry(path);
-    entry.status = entry.running.syncError() ? { state: "error", message: entry.running.syncError() } : entry.running.conflicts().length === 0 ? { state: "active" } : { state: "paused" };
-    this.events.status(entry.owners, { replicaId, status: entry.status });
-  }
-  list() {
-    return [...this.byId.values()].map((entry) => ({
-      id: entry.id,
-      root: entry.root,
-      serverName: entry.serverName,
-      projectId: entry.projectId,
-      projectName: entry.projectName,
-      clients: entry.owners.size,
-      status: entry.status,
-      conflicts: entry.running.conflicts()
-    }));
-  }
-  async stopAll() {
-    await Promise.all([...this.byId.values()].map((entry) => this.stop(entry)));
-  }
-  addOwner(entry, clientId) {
-    entry.owners.add(clientId);
-  }
-  async stop(entry) {
-    if (!this.byId.delete(entry.id)) {
-      return;
-    }
-    this.byRoot.delete(entry.root);
-    this.byProject.delete(entry.projectKey);
-    entry.status = { state: "stopping" };
-    this.events.status(entry.owners, { replicaId: entry.id, status: entry.status });
-    await entry.running.stop();
-    this.events.empty();
-  }
-  require(replicaId) {
-    const entry = this.byId.get(replicaId);
-    if (!entry) {
-      throw new Error(`Unknown replica ${replicaId}.`);
-    }
-    return entry;
-  }
-  result(entry, shared) {
-    return {
-      replicaId: entry.id,
-      root: entry.root,
-      serverName: entry.serverName,
-      projectId: entry.projectId,
-      projectName: entry.projectName,
-      shared,
-      status: entry.status,
-      conflicts: entry.running.conflicts()
-    };
-  }
-  async withProjectLock(projectKey, operation) {
-    const previous = this.projectOperations.get(projectKey) ?? Promise.resolve();
-    let release;
-    const current = new Promise((resolveOperation) => {
-      release = resolveOperation;
-    });
-    this.projectOperations.set(projectKey, current);
-    await previous;
-    try {
-      return await operation();
-    } finally {
-      release();
-      if (this.projectOperations.get(projectKey) === current) {
-        this.projectOperations.delete(projectKey);
-      }
-    }
-  }
+	events;
+	start;
+	byId = /* @__PURE__ */ new Map();
+	byRoot = /* @__PURE__ */ new Map();
+	byProject = /* @__PURE__ */ new Map();
+	projectOperations = /* @__PURE__ */ new Map();
+	clients = /* @__PURE__ */ new Set();
+	constructor(events, start = startServe) {
+		this.events = events;
+		this.start = start;
+	}
+	get size() {
+		return this.byId.size;
+	}
+	registerClient(clientId) {
+		this.clients.add(clientId);
+	}
+	async attach(clientId, params) {
+		const root = await realpath(resolve(params.directory));
+		const settings = await readProjectSettings(root);
+		const projectKey = `${settings.serverName}\0${settings.projectId}`;
+		return this.withProjectLock(projectKey, () => this.attachResolved(clientId, params, root, settings, projectKey));
+	}
+	async attachResolved(clientId, params, root, settings, projectKey) {
+		if (!this.clients.has(clientId)) throw new Error("The replica client disconnected before attachment started.");
+		const rootEntry = this.byRoot.get(root);
+		if (rootEntry) {
+			if (rootEntry.projectKey !== projectKey) throw new Error(`${root} is already registered for another Overleaf project.`);
+			this.addOwner(rootEntry, clientId);
+			return this.result(rootEntry, true);
+		}
+		const projectEntry = this.byProject.get(projectKey);
+		if (projectEntry) throw new ReplicaAlreadyActiveError(settings.projectId, projectEntry.root, root);
+		const id = randomUUID();
+		const owners = /* @__PURE__ */ new Set([clientId]);
+		const status = { state: "starting" };
+		let entry;
+		this.events.status(owners, {
+			replicaId: id,
+			status
+		});
+		this.events.log(`[${settings.projectName}] Starting synchronization for ${root}.`);
+		try {
+			const running = await this.start(root, {
+				cookie: params.cookie,
+				onSyncError: (message) => {
+					if (!entry) return;
+					entry.status = message ? {
+						state: "error",
+						message
+					} : entry.running.conflicts().length ? { state: "paused" } : { state: "active" };
+					this.events.status(entry.owners, {
+						replicaId: id,
+						status: entry.status
+					});
+				},
+				log: (message) => this.events.log(`[${settings.projectName}] ${message}`),
+				onConflict: (path, reason) => {
+					if (!entry) return;
+					entry.status = {
+						state: "paused",
+						message: `Conflict in ${path}`
+					};
+					this.events.conflict(entry.owners, {
+						replicaId: entry.id,
+						path,
+						reason,
+						conflicts: entry.running.conflicts()
+					});
+					this.events.status(entry.owners, {
+						replicaId: entry.id,
+						status: entry.status
+					});
+				}
+			});
+			if (!this.clients.has(clientId)) {
+				await running.stop();
+				this.events.empty();
+				throw new Error("The replica client disconnected before attachment completed.");
+			}
+			entry = {
+				id,
+				root,
+				projectKey,
+				serverName: settings.serverName,
+				projectId: settings.projectId,
+				projectName: settings.projectName,
+				owners,
+				running,
+				status: running.syncError() ? {
+					state: "error",
+					message: running.syncError()
+				} : running.conflicts().length === 0 ? { state: "active" } : { state: "paused" }
+			};
+			this.byId.set(id, entry);
+			this.byRoot.set(root, entry);
+			this.byProject.set(projectKey, entry);
+			this.events.status(owners, {
+				replicaId: id,
+				status: entry.status
+			});
+			return this.result(entry, false);
+		} catch (error) {
+			const failed = {
+				state: "error",
+				message: error instanceof Error ? error.message : String(error)
+			};
+			this.events.status(owners, {
+				replicaId: id,
+				status: failed
+			});
+			throw error;
+		}
+	}
+	async detach(clientId, replicaId) {
+		const entry = this.require(replicaId);
+		await this.withProjectLock(entry.projectKey, async () => {
+			entry.owners.delete(clientId);
+			if (entry.owners.size === 0) await this.stop(entry);
+		});
+	}
+	async detachClient(clientId) {
+		this.clients.delete(clientId);
+		const owned = [...this.byId.values()].filter((entry) => entry.owners.has(clientId));
+		await Promise.all(owned.map((entry) => this.withProjectLock(entry.projectKey, async () => {
+			entry.owners.delete(clientId);
+			if (entry.owners.size === 0) await this.stop(entry);
+		})));
+	}
+	async resolveConflict(replicaId, path, winner) {
+		const entry = this.require(replicaId);
+		await entry.running.resolveConflict(path, winner);
+		entry.status = entry.running.syncError() ? {
+			state: "error",
+			message: entry.running.syncError()
+		} : entry.running.conflicts().length === 0 ? { state: "active" } : { state: "paused" };
+		this.events.status(entry.owners, {
+			replicaId,
+			status: entry.status
+		});
+	}
+	async retry(replicaId, path) {
+		const entry = this.require(replicaId);
+		await entry.running.retry(path);
+		entry.status = entry.running.syncError() ? {
+			state: "error",
+			message: entry.running.syncError()
+		} : entry.running.conflicts().length === 0 ? { state: "active" } : { state: "paused" };
+		this.events.status(entry.owners, {
+			replicaId,
+			status: entry.status
+		});
+	}
+	list() {
+		return [...this.byId.values()].map((entry) => ({
+			id: entry.id,
+			root: entry.root,
+			serverName: entry.serverName,
+			projectId: entry.projectId,
+			projectName: entry.projectName,
+			clients: entry.owners.size,
+			status: entry.status,
+			conflicts: entry.running.conflicts()
+		}));
+	}
+	async stopAll() {
+		await Promise.all([...this.byId.values()].map((entry) => this.stop(entry)));
+	}
+	addOwner(entry, clientId) {
+		entry.owners.add(clientId);
+	}
+	async stop(entry) {
+		if (!this.byId.delete(entry.id)) return;
+		this.byRoot.delete(entry.root);
+		this.byProject.delete(entry.projectKey);
+		entry.status = { state: "stopping" };
+		this.events.status(entry.owners, {
+			replicaId: entry.id,
+			status: entry.status
+		});
+		await entry.running.stop();
+		this.events.empty();
+	}
+	require(replicaId) {
+		const entry = this.byId.get(replicaId);
+		if (!entry) throw new Error(`Unknown replica ${replicaId}.`);
+		return entry;
+	}
+	result(entry, shared) {
+		return {
+			replicaId: entry.id,
+			root: entry.root,
+			serverName: entry.serverName,
+			projectId: entry.projectId,
+			projectName: entry.projectName,
+			shared,
+			status: entry.status,
+			conflicts: entry.running.conflicts()
+		};
+	}
+	async withProjectLock(projectKey, operation) {
+		const previous = this.projectOperations.get(projectKey) ?? Promise.resolve();
+		let release;
+		const current = new Promise((resolveOperation) => {
+			release = resolveOperation;
+		});
+		this.projectOperations.set(projectKey, current);
+		await previous;
+		try {
+			return await operation();
+		} finally {
+			release();
+			if (this.projectOperations.get(projectKey) === current) this.projectOperations.delete(projectKey);
+		}
+	}
 };
-
 // ../daemon/src/transport.ts
-import {
-  createMessageConnection,
-  SocketMessageReader,
-  SocketMessageWriter
-} from "vscode-jsonrpc/node";
-var CLOSED_SOCKET_ERRORS = /* @__PURE__ */ new Set([
-  "EPIPE",
-  "ECONNRESET",
-  "ERR_SOCKET_CLOSED",
-  "ERR_STREAM_DESTROYED",
-  "ERR_STREAM_WRITE_AFTER_END"
+const CLOSED_SOCKET_ERRORS = /* @__PURE__ */ new Set([
+	"EPIPE",
+	"ECONNRESET",
+	"ERR_SOCKET_CLOSED",
+	"ERR_STREAM_DESTROYED",
+	"ERR_STREAM_WRITE_AFTER_END"
 ]);
 var LeafRelaySocketWriter = class extends SocketMessageWriter {
-  constructor(transportSocket) {
-    super(transportSocket);
-    this.transportSocket = transportSocket;
-  }
-  transportSocket;
-  async write(message) {
-    try {
-      await super.write(message);
-    } catch (error) {
-      const code = error.code;
-      if (this.transportSocket.destroyed || this.transportSocket.writableEnded || code && CLOSED_SOCKET_ERRORS.has(code)) {
-        return;
-      }
-      throw error;
-    }
-  }
+	transportSocket;
+	constructor(transportSocket) {
+		super(transportSocket);
+		this.transportSocket = transportSocket;
+	}
+	async write(message) {
+		try {
+			await super.write(message);
+		} catch (error) {
+			const code = error.code;
+			if (this.transportSocket.destroyed || this.transportSocket.writableEnded || code && CLOSED_SOCKET_ERRORS.has(code)) return;
+			throw error;
+		}
+	}
 };
 function createSocketRpcConnection(socket) {
-  return createMessageConnection(new SocketMessageReader(socket), new LeafRelaySocketWriter(socket));
+	return createMessageConnection(new SocketMessageReader(socket), new LeafRelaySocketWriter(socket));
 }
-
 // ../daemon/src/server.ts
-var IDLE_EXIT_MS = 6e4;
-var REPLICA_ALREADY_ACTIVE = -32010;
-var daemonVersion = true ? "0.2.7" : "development";
+const IDLE_EXIT_MS = 6e4;
+const REPLICA_ALREADY_ACTIVE = -32010;
+const daemonVersion = "0.2.9";
 var LeafRelayDaemonServer = class {
-  constructor(options = {}) {
-    this.options = options;
-    this.paths = options.paths ?? daemonPaths();
-    this.token = options.token ?? randomBytes(32).toString("hex");
-    this.network = new NetworkRuntimeRegistry({
-      projectEvent: (owners, notification) => this.notifyOwners(owners, RPC_NOTIFICATION.projectEvent, notification),
-      log: (level, message) => void this.log(level, message)
-    });
-    this.replicas = new ReplicaRegistry({
-      status: (owners, notification) => this.notifyOwners(owners, RPC_NOTIFICATION.replicaStatus, notification),
-      conflict: (owners, notification) => this.notifyOwners(owners, RPC_NOTIFICATION.replicaConflict, notification),
-      empty: () => this.scheduleIdleExit(),
-      log: (message) => void this.log("info", message)
-    }, async (directory, startOptions) => {
-      const settings = await readProjectSettings(directory);
-      const lease = await this.network.acquireReplica(settings.serverName, settings.projectId);
-      try {
-        const running = await startServe(directory, { ...startOptions, remote: lease.remote });
-        return {
-          ...running,
-          stop: async () => {
-            await running.stop();
-            lease.release();
-          }
-        };
-      } catch (error) {
-        lease.release();
-        throw error;
-      }
-    });
-  }
-  options;
-  paths;
-  token;
-  startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  clients = /* @__PURE__ */ new Set();
-  network;
-  replicas;
-  server;
-  idleTimer;
-  stopping;
-  async start() {
-    await mkdir(this.paths.home, { recursive: true, mode: 448 });
-    setLogSink((level, args) => void this.log(level, formatWithOptions({ depth: 5, breakLength: Infinity }, ...args)));
-    if (process.platform !== "win32") {
-      await rm(this.paths.socketPath, { force: true });
-    }
-    this.server = createServer((socket) => this.accept(socket));
-    await new Promise((resolveListen, reject) => {
-      this.server.once("error", reject);
-      this.server.listen(this.paths.socketPath, () => {
-        this.server.off("error", reject);
-        resolveListen();
-      });
-    });
-    if (process.platform !== "win32") {
-      await chmod(this.paths.socketPath, 384);
-    }
-    const metadata = {
-      pid: process.pid,
-      socketPath: this.paths.socketPath,
-      token: this.token,
-      protocolVersion: LEAFRELAY_PROTOCOL_VERSION,
-      version: daemonVersion,
-      startedAt: this.startedAt
-    };
-    await writeFile(this.paths.metadataPath, `${JSON.stringify(metadata, null, 2)}
-`, { encoding: "utf8", mode: 384 });
-    await chmod(this.paths.metadataPath, 384);
-    await this.log("info", `Daemon ${daemonVersion} listening on ${this.paths.socketPath}.`);
-    this.scheduleIdleExit();
-    return metadata;
-  }
-  async stop() {
-    if (this.stopping) {
-      return this.stopping;
-    }
-    this.stopping = this.performStop();
-    return this.stopping;
-  }
-  status() {
-    return {
-      pid: process.pid,
-      version: daemonVersion,
-      protocolVersion: LEAFRELAY_PROTOCOL_VERSION,
-      startedAt: this.startedAt,
-      clients: this.clients.size,
-      projects: this.network.projectCount,
-      replicas: this.replicas.list()
-    };
-  }
-  accept(socket) {
-    this.cancelIdleExit();
-    const rpc = createSocketRpcConnection(socket);
-    const client = { leaseId: randomUUID2(), socket, rpc, initialized: false };
-    this.clients.add(client);
-    rpc.onRequest(RPC_METHOD.initialize, (params) => this.initialize(client, params));
-    rpc.onRequest(RPC_METHOD.daemonStatus, () => this.authorized(client, () => this.status()));
-    rpc.onRequest(RPC_METHOD.daemonShutdown, () => this.authorized(client, async () => {
-      setTimeout(() => void this.stop(), 25);
-      return null;
-    }));
-    rpc.onRequest(RPC_METHOD.replicaAttach, (params) => this.authorized(client, async () => {
-      try {
-        return await this.replicas.attach(client.leaseId, params);
-      } catch (error) {
-        if (error instanceof ReplicaAlreadyActiveError) {
-          throw new ResponseError(REPLICA_ALREADY_ACTIVE, error.message, {
-            code: error.code,
-            projectId: error.projectId,
-            activeRoot: error.activeRoot,
-            requestedRoot: error.requestedRoot
-          });
-        }
-        throw error;
-      }
-    }));
-    rpc.onRequest(RPC_METHOD.replicaDetach, (params) => this.authorized(client, async () => {
-      await this.replicas.detach(client.leaseId, params.replicaId);
-      return null;
-    }));
-    rpc.onRequest(RPC_METHOD.replicaResolveConflict, (params) => this.authorized(client, async () => {
-      await this.replicas.resolveConflict(params.replicaId, params.path, params.winner);
-      return null;
-    }));
-    rpc.onRequest(RPC_METHOD.replicaRetry, (params) => this.authorized(client, async () => {
-      await this.replicas.retry(params.replicaId, params.path);
-      return null;
-    }));
-    rpc.onRequest(RPC_METHOD.serverList, () => this.authorized(client, () => this.network.listServers()));
-    rpc.onRequest(RPC_METHOD.serverAdd, (params) => this.authorized(client, async () => {
-      await this.network.addServer(params.name, params.url);
-      return null;
-    }));
-    rpc.onRequest(RPC_METHOD.serverRemove, (params) => this.authorized(client, async () => {
-      await this.network.removeServer(params.server);
-      return null;
-    }));
-    rpc.onRequest(RPC_METHOD.sessionLogin, (params) => this.authorized(client, () => this.network.login(params)));
-    rpc.onRequest(RPC_METHOD.sessionImport, (params) => this.authorized(client, () => this.network.importSession(params)));
-    rpc.onRequest(RPC_METHOD.sessionLogout, (params) => this.authorized(client, async () => {
-      await this.network.logout(params.server);
-      return null;
-    }));
-    rpc.onRequest(RPC_METHOD.serverCall, (params) => this.authorized(client, async () => {
-      const result = await this.network.callServer(params.server, params.operation, decodeRpcValue(params.args));
-      return encodeRpcValue(result);
-    }));
-    rpc.onRequest(RPC_METHOD.projectOpen, (params) => this.authorized(client, () => this.network.openProject(client.leaseId, params.server, params.projectId)));
-    rpc.onRequest(RPC_METHOD.projectClose, (params) => this.authorized(client, () => {
-      this.network.closeProject(client.leaseId, params.projectKey);
-      return null;
-    }));
-    rpc.onRequest(RPC_METHOD.projectCall, (params) => this.authorized(client, async () => {
-      const result = await this.network.callProject(params.projectKey, params.operation, decodeRpcValue(params.args));
-      return encodeRpcValue(await result);
-    }));
-    rpc.onClose(() => void this.closeClient(client));
-    rpc.onError((error) => void this.log("error", `JSON-RPC connection error: ${String(error[0])}`));
-    rpc.listen();
-  }
-  initialize(client, params) {
-    if (params.token !== this.token) {
-      throw new ResponseError(-32001, "Daemon authentication failed.");
-    }
-    if (params.protocolVersion !== LEAFRELAY_PROTOCOL_VERSION) {
-      throw new ResponseError(-32002, `Protocol ${params.protocolVersion} is incompatible with daemon protocol ${LEAFRELAY_PROTOCOL_VERSION}.`);
-    }
-    if (!params.clientId) {
-      throw new ResponseError(-32602, "clientId is required.");
-    }
-    client.clientId = params.clientId;
-    client.initialized = true;
-    this.replicas.registerClient(client.leaseId);
-    void this.log("info", `${params.clientName} ${params.clientVersion} connected (${params.clientId}).`);
-    return {
-      daemonVersion,
-      protocolVersion: LEAFRELAY_PROTOCOL_VERSION,
-      pid: process.pid,
-      startedAt: this.startedAt
-    };
-  }
-  async authorized(client, operation) {
-    if (!client.initialized) {
-      throw new ResponseError(-32001, "Initialize the daemon connection first.");
-    }
-    try {
-      return await operation();
-    } catch (error) {
-      if (error instanceof ResponseError) {
-        throw error;
-      }
-      const message = error instanceof Error ? error.message : String(error);
-      await this.log("error", `RPC operation failed: ${formatWithOptions({ depth: 5, breakLength: Infinity }, error)}`);
-      throw new ResponseError(-32603, message);
-    }
-  }
-  async closeClient(client) {
-    if (!this.clients.delete(client)) {
-      return;
-    }
-    if (client.clientId) {
-      try {
-        await this.replicas.detachClient(client.leaseId);
-      } catch (error) {
-        await this.log("error", `Failed to stop replicas for a disconnected client: ${error instanceof Error ? error.message : String(error)}`);
-      } finally {
-        this.network.detachClient(client.leaseId);
-      }
-    }
-    this.scheduleIdleExit();
-  }
-  notifyOwners(owners, method, notification) {
-    for (const client of this.clients) {
-      if (owners.has(client.leaseId)) {
-        this.notifyClient(client, method, notification);
-      }
-    }
-  }
-  async log(level, message) {
-    const notification = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), level, message };
-    await appendFile(this.paths.logPath, `${notification.timestamp} [${level}] ${message}
-`, { encoding: "utf8", mode: 384 });
-    for (const client of this.clients) {
-      if (client.initialized) {
-        this.notifyClient(client, RPC_NOTIFICATION.log, notification);
-      }
-    }
-  }
-  notifyClient(client, method, notification) {
-    if (!this.clients.has(client) || client.socket.destroyed) {
-      return;
-    }
-    void client.rpc.sendNotification(method, notification).catch(() => this.closeClient(client));
-  }
-  scheduleIdleExit() {
-    if (this.options.exitOnIdle === false || this.clients.size !== 0 || this.replicas.size !== 0 || this.idleTimer) {
-      return;
-    }
-    this.idleTimer = setTimeout(() => void this.stop(), IDLE_EXIT_MS);
-    this.idleTimer.unref();
-  }
-  cancelIdleExit() {
-    if (this.idleTimer) {
-      clearTimeout(this.idleTimer);
-      this.idleTimer = void 0;
-    }
-  }
-  async performStop() {
-    this.cancelIdleExit();
-    await this.replicas.stopAll();
-    await this.network.stopAll();
-    setLogSink(void 0);
-    for (const client of this.clients) {
-      client.rpc.dispose();
-      client.socket.destroy();
-    }
-    this.clients.clear();
-    if (this.server) {
-      await new Promise((resolveClose) => this.server.close(() => resolveClose()));
-    }
-    await rm(this.paths.metadataPath, { force: true });
-    if (process.platform !== "win32") {
-      await rm(this.paths.socketPath, { force: true });
-    }
-  }
+	options;
+	paths;
+	token;
+	startedAt = (/* @__PURE__ */ new Date()).toISOString();
+	clients = /* @__PURE__ */ new Set();
+	network;
+	replicas;
+	server;
+	idleTimer;
+	stopping;
+	constructor(options = {}) {
+		this.options = options;
+		this.paths = options.paths ?? daemonPaths();
+		this.token = options.token ?? randomBytes(32).toString("hex");
+		this.network = new NetworkRuntimeRegistry({
+			projectEvent: (owners, notification) => this.notifyOwners(owners, RPC_NOTIFICATION.projectEvent, notification),
+			log: (level, message) => void this.log(level, message)
+		});
+		this.replicas = new ReplicaRegistry({
+			status: (owners, notification) => this.notifyOwners(owners, RPC_NOTIFICATION.replicaStatus, notification),
+			conflict: (owners, notification) => this.notifyOwners(owners, RPC_NOTIFICATION.replicaConflict, notification),
+			empty: () => this.scheduleIdleExit(),
+			log: (message) => void this.log("info", message)
+		}, async (directory, startOptions) => {
+			const settings = await readProjectSettings(directory);
+			const lease = await this.network.acquireReplica(settings.serverName, settings.projectId);
+			try {
+				const running = await startServe(directory, {
+					...startOptions,
+					remote: lease.remote
+				});
+				return {
+					...running,
+					stop: async () => {
+						await running.stop();
+						lease.release();
+					}
+				};
+			} catch (error) {
+				lease.release();
+				throw error;
+			}
+		});
+	}
+	async start() {
+		await mkdir(this.paths.home, {
+			recursive: true,
+			mode: 448
+		});
+		setLogSink((level, args) => void this.log(level, formatWithOptions({
+			depth: 5,
+			breakLength: Infinity
+		}, ...args)));
+		if (process.platform !== "win32") await rm(this.paths.socketPath, { force: true });
+		this.server = createServer((socket) => this.accept(socket));
+		await new Promise((resolveListen, reject) => {
+			this.server.once("error", reject);
+			this.server.listen(this.paths.socketPath, () => {
+				this.server.off("error", reject);
+				resolveListen();
+			});
+		});
+		if (process.platform !== "win32") await chmod(this.paths.socketPath, 384);
+		const metadata = {
+			pid: process.pid,
+			socketPath: this.paths.socketPath,
+			token: this.token,
+			protocolVersion: 1,
+			version: daemonVersion,
+			startedAt: this.startedAt
+		};
+		await writeFile(this.paths.metadataPath, `${JSON.stringify(metadata, null, 2)}\n`, {
+			encoding: "utf8",
+			mode: 384
+		});
+		await chmod(this.paths.metadataPath, 384);
+		await this.log("info", `Daemon ${daemonVersion} listening on ${this.paths.socketPath}.`);
+		this.scheduleIdleExit();
+		return metadata;
+	}
+	async stop() {
+		if (this.stopping) return this.stopping;
+		this.stopping = this.performStop();
+		return this.stopping;
+	}
+	status() {
+		return {
+			pid: process.pid,
+			version: daemonVersion,
+			protocolVersion: 1,
+			startedAt: this.startedAt,
+			clients: this.clients.size,
+			projects: this.network.projectCount,
+			replicas: this.replicas.list()
+		};
+	}
+	accept(socket) {
+		this.cancelIdleExit();
+		const rpc = createSocketRpcConnection(socket);
+		const client = {
+			leaseId: randomUUID(),
+			socket,
+			rpc,
+			initialized: false
+		};
+		this.clients.add(client);
+		rpc.onRequest(RPC_METHOD.initialize, (params) => this.initialize(client, params));
+		rpc.onRequest(RPC_METHOD.daemonStatus, () => this.authorized(client, () => this.status()));
+		rpc.onRequest(RPC_METHOD.daemonShutdown, () => this.authorized(client, async () => {
+			setTimeout(() => void this.stop(), 25);
+			return null;
+		}));
+		rpc.onRequest(RPC_METHOD.replicaAttach, (params) => this.authorized(client, async () => {
+			try {
+				return await this.replicas.attach(client.leaseId, params);
+			} catch (error) {
+				if (error instanceof ReplicaAlreadyActiveError) throw new ResponseError(REPLICA_ALREADY_ACTIVE, error.message, {
+					code: error.code,
+					projectId: error.projectId,
+					activeRoot: error.activeRoot,
+					requestedRoot: error.requestedRoot
+				});
+				throw error;
+			}
+		}));
+		rpc.onRequest(RPC_METHOD.replicaDetach, (params) => this.authorized(client, async () => {
+			await this.replicas.detach(client.leaseId, params.replicaId);
+			return null;
+		}));
+		rpc.onRequest(RPC_METHOD.replicaResolveConflict, (params) => this.authorized(client, async () => {
+			await this.replicas.resolveConflict(params.replicaId, params.path, params.winner);
+			return null;
+		}));
+		rpc.onRequest(RPC_METHOD.replicaRetry, (params) => this.authorized(client, async () => {
+			await this.replicas.retry(params.replicaId, params.path);
+			return null;
+		}));
+		rpc.onRequest(RPC_METHOD.serverList, () => this.authorized(client, () => this.network.listServers()));
+		rpc.onRequest(RPC_METHOD.serverAdd, (params) => this.authorized(client, async () => {
+			await this.network.addServer(params.name, params.url);
+			return null;
+		}));
+		rpc.onRequest(RPC_METHOD.serverRemove, (params) => this.authorized(client, async () => {
+			await this.network.removeServer(params.server);
+			return null;
+		}));
+		rpc.onRequest(RPC_METHOD.sessionLogin, (params) => this.authorized(client, () => this.network.login(params)));
+		rpc.onRequest(RPC_METHOD.sessionImport, (params) => this.authorized(client, () => this.network.importSession(params)));
+		rpc.onRequest(RPC_METHOD.sessionLogout, (params) => this.authorized(client, async () => {
+			await this.network.logout(params.server);
+			return null;
+		}));
+		rpc.onRequest(RPC_METHOD.serverCall, (params) => this.authorized(client, async () => {
+			return encodeRpcValue(await this.network.callServer(params.server, params.operation, decodeRpcValue(params.args)));
+		}));
+		rpc.onRequest(RPC_METHOD.projectOpen, (params) => this.authorized(client, () => this.network.openProject(client.leaseId, params.server, params.projectId)));
+		rpc.onRequest(RPC_METHOD.projectClose, (params) => this.authorized(client, () => {
+			this.network.closeProject(client.leaseId, params.projectKey);
+			return null;
+		}));
+		rpc.onRequest(RPC_METHOD.projectCall, (params) => this.authorized(client, async () => {
+			return encodeRpcValue(await await this.network.callProject(params.projectKey, params.operation, decodeRpcValue(params.args)));
+		}));
+		rpc.onClose(() => void this.closeClient(client));
+		rpc.onError((error) => void this.log("error", `JSON-RPC connection error: ${String(error[0])}`));
+		rpc.listen();
+	}
+	initialize(client, params) {
+		if (params.token !== this.token) throw new ResponseError(-32001, "Daemon authentication failed.");
+		if (params.protocolVersion !== 1) throw new ResponseError(-32002, `Protocol ${params.protocolVersion} is incompatible with daemon protocol 1.`);
+		if (!params.clientId) throw new ResponseError(-32602, "clientId is required.");
+		client.clientId = params.clientId;
+		client.initialized = true;
+		this.replicas.registerClient(client.leaseId);
+		this.log("info", `${params.clientName} ${params.clientVersion} connected (${params.clientId}).`);
+		return {
+			daemonVersion,
+			protocolVersion: 1,
+			pid: process.pid,
+			startedAt: this.startedAt
+		};
+	}
+	async authorized(client, operation) {
+		if (!client.initialized) throw new ResponseError(-32001, "Initialize the daemon connection first.");
+		try {
+			return await operation();
+		} catch (error) {
+			if (error instanceof ResponseError) throw error;
+			const message = error instanceof Error ? error.message : String(error);
+			await this.log("error", `RPC operation failed: ${formatWithOptions({
+				depth: 5,
+				breakLength: Infinity
+			}, error)}`);
+			throw new ResponseError(-32603, message);
+		}
+	}
+	async closeClient(client) {
+		if (!this.clients.delete(client)) return;
+		if (client.clientId) try {
+			await this.replicas.detachClient(client.leaseId);
+		} catch (error) {
+			await this.log("error", `Failed to stop replicas for a disconnected client: ${error instanceof Error ? error.message : String(error)}`);
+		} finally {
+			this.network.detachClient(client.leaseId);
+		}
+		this.scheduleIdleExit();
+	}
+	notifyOwners(owners, method, notification) {
+		for (const client of this.clients) if (owners.has(client.leaseId)) this.notifyClient(client, method, notification);
+	}
+	async log(level, message) {
+		const notification = {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			level,
+			message
+		};
+		await appendFile(this.paths.logPath, `${notification.timestamp} [${level}] ${message}\n`, {
+			encoding: "utf8",
+			mode: 384
+		});
+		for (const client of this.clients) if (client.initialized) this.notifyClient(client, RPC_NOTIFICATION.log, notification);
+	}
+	notifyClient(client, method, notification) {
+		if (!this.clients.has(client) || client.socket.destroyed) return;
+		client.rpc.sendNotification(method, notification).catch(() => this.closeClient(client));
+	}
+	scheduleIdleExit() {
+		if (this.options.exitOnIdle === false || this.clients.size !== 0 || this.replicas.size !== 0 || this.idleTimer) return;
+		this.idleTimer = setTimeout(() => void this.stop(), IDLE_EXIT_MS);
+		this.idleTimer.unref();
+	}
+	cancelIdleExit() {
+		if (this.idleTimer) {
+			clearTimeout(this.idleTimer);
+			this.idleTimer = void 0;
+		}
+	}
+	async performStop() {
+		this.cancelIdleExit();
+		await this.replicas.stopAll();
+		await this.network.stopAll();
+		setLogSink(void 0);
+		for (const client of this.clients) {
+			client.rpc.dispose();
+			client.socket.destroy();
+		}
+		this.clients.clear();
+		if (this.server) await new Promise((resolveClose) => this.server.close(() => resolveClose()));
+		await rm(this.paths.metadataPath, { force: true });
+		if (process.platform !== "win32") await rm(this.paths.socketPath, { force: true });
+	}
 };
-
 // ../daemon/src/main.ts
-var server = new LeafRelayDaemonServer();
-var stop = () => {
-  process.off("SIGINT", stop);
-  process.off("SIGTERM", stop);
-  void server.stop().finally(() => process.exit(0));
+const server = new LeafRelayDaemonServer();
+const stop = () => {
+	process.off("SIGINT", stop);
+	process.off("SIGTERM", stop);
+	server.stop().finally(() => process.exit(0));
 };
 process.on("SIGINT", stop);
 process.on("SIGTERM", stop);
 process.on("uncaughtException", (error) => {
-  console.error(error);
-  void server.stop().finally(() => process.exit(1));
+	console.error(error);
+	server.stop().finally(() => process.exit(1));
 });
 process.on("unhandledRejection", (error) => {
-  console.error(error);
-  void server.stop().finally(() => process.exit(1));
+	console.error(error);
+	server.stop().finally(() => process.exit(1));
 });
-void server.start().catch((error) => {
-  console.error(error);
-  process.exit(1);
+server.start().catch((error) => {
+	console.error(error);
+	process.exit(1);
 });
+export {};
+
 //# sourceMappingURL=daemon.js.map