texlite 0.6.0 → 0.6.6

package/dist/server/collaboration.js

@@ -8,7 +8,7 @@ import * as encoding from "lib0/encoding";
 import * as decoding from "lib0/decoding";
 import * as syncProtocol from "y-protocols/sync";
 import { Awareness, applyAwarenessUpdate, encodeAwarenessUpdate, modifyAwarenessUpdate, removeAwarenessStates } from "y-protocols/awareness";
-import { listProjectFiles, outputRoot, resolveSourcePath, safeRelativePath } from "./files.js";
+import { listProjectFilesAsync, outputRoot, resolveSourcePath, safeRelativePath, sourceRoot } from "./files.js";
 import { accessibleProject, canEdit } from "./projects.js";
 import { reanchorFileComments } from "./anchors.js";
 const MESSAGE_SYNC = 0;
@@ -16,6 +16,19 @@ const MESSAGE_AWARENESS = 1;
 const MESSAGE_QUERY_AWARENESS = 3;
 const MESSAGE_FLUSH = 4;
 const MESSAGE_PROTOCOL = 5;
+const MESSAGE_MAINTENANCE = 6;
+const MESSAGE_PERMISSION = 7;
+// A small, non-Yjs handshake message used for ephemeral compile metadata.
+// Source text still uses the normal Yjs sync protocol; this message prevents
+// an old IndexedDB metadata entry from being treated as an active compile.
+const MESSAGE_COMPILE_STATES = 8;
+/**
+ * Increment this when a wire-level collaboration change cannot be decoded by
+ * an older browser. The epoch marker is rotated at the same time, which makes
+ * already-open older pages discard their local draft and reload safely.
+ */
+export const COLLABORATION_PROTOCOL_VERSION = 2;
+const VERSIONED_EPOCH_PREFIX = `${COLLABORATION_PROTOCOL_VERSION}:`;
 const SOURCE_PREFIX = "source:";
 const MAX_PROJECT_SESSIONS = 10;
 const MAX_COLLABORATIVE_FILE_BYTES = 5 * 1024 * 1024;
@@ -25,6 +38,7 @@ const META_ORIGIN = Symbol("meta");
 const SAVE_DELAY_MS = 750;
 const STATE_SAVE_DELAY_MS = 750;
 const ROOM_IDLE_MS = 30_000;
+const EPHEMERAL_META_KEYS = ["compileStates", "filesEvent", "commentsRevision", "dictionaryRevision"];
 const COLORS = [
     ["#1677c8", "#1677c833"], ["#d65745", "#d6574533"], ["#16866a", "#16866a33"],
     ["#9a58b5", "#9a58b533"], ["#d27b18", "#d27b1833"], ["#3f7d20", "#3f7d2033"],
@@ -36,51 +50,149 @@ export class CollaborationService {
     db;
     onPersist;
     rooms = new Map();
+    maintenanceProjects = new Map();
+    roomInitializations = new Map();
+    projectGenerations = new Map();
+    snapshotBarriers = new Map();
+    pendingConnections = new Map();
+    closed = false;
     constructor(config, db, onPersist) {
         this.config = config;
         this.db = db;
         this.onPersist = onPersist;
     }
-    connect(socket, projectId, user) {
+    async connect(socket, projectId, user) {
+        if (this.closed) {
+            socket.close(1012, "Collaboration service is shutting down");
+            return;
+        }
         const project = accessibleProject(this.db, projectId, user);
         if (!project) {
             socket.close(1008, "Project access denied");
             return;
         }
-        const room = this.getRoom(projectId);
-        if (room.connections.size >= MAX_PROJECT_SESSIONS) {
-            socket.close(1013, "Project collaboration room is full");
+        const maintenanceReason = this.maintenanceProjects.get(projectId);
+        if (maintenanceReason) {
+            socket.close(1013, `Project is temporarily unavailable: ${maintenanceReason}`);
             return;
         }
-        if (room.cleanupTimer) {
-            clearTimeout(room.cleanupTimer);
-            room.cleanupTimer = null;
+        const existing = this.rooms.get(projectId);
+        if (existing) {
+            this.attachConnection(existing, socket, user);
+            return;
         }
-        const connection = {
-            socket, user, awarenessClientId: null, protocolVerified: false, protocolTimer: null
-        };
-        room.connections.add(connection);
-        socket.binaryType = "arraybuffer";
-        socket.on("message", (data) => {
-            try {
-                this.handleMessage(room, connection, rawData(data));
+        const generation = this.projectGeneration(projectId);
+        const pendingKey = this.pendingConnectionKey(projectId, generation);
+        const pending = this.pendingConnections.get(pendingKey) ?? 0;
+        if (pending >= MAX_PROJECT_SESSIONS) {
+            socket.close(1013, "Project collaboration room is full");
+            return;
+        }
+        this.pendingConnections.set(pendingKey, pending + 1);
+        const initialization = this.roomInitializations.get(projectId) ?? this.initializeRoom(projectId, generation);
+        try {
+            const room = await initialization;
+            const currentMaintenance = this.maintenanceProjects.get(projectId);
+            if (currentMaintenance) {
+                this.disposeRoom(room);
+                socket.close(1013, `Project is temporarily unavailable: ${currentMaintenance}`);
             }
-            catch {
-                socket.close(1003, "Invalid collaboration message");
+            else if (this.projectGeneration(projectId) !== generation) {
+                socket.close(1013, "Collaboration state changed; retry required");
             }
-        });
-        socket.on("close", () => this.disconnect(room, connection));
-        socket.on("error", () => this.disconnect(room, connection));
-        connection.protocolTimer = setTimeout(() => {
-            if (!connection.protocolVerified)
-                socket.close(4001, "Reload required");
-        }, 10_000);
-        send(socket, protocolMessage(room.epoch));
+            else if (socket.readyState === WebSocket.OPEN) {
+                this.attachConnection(room, socket, user);
+            }
+            else {
+                socket.close(1000, "Collaboration connection closed during initialization");
+            }
+        }
+        catch {
+            socket.close(1011, "Unable to initialize collaboration room");
+        }
+        finally {
+            const count = (this.pendingConnections.get(pendingKey) ?? 1) - 1;
+            if (count > 0)
+                this.pendingConnections.set(pendingKey, count);
+            else
+                this.pendingConnections.delete(pendingKey);
+        }
+    }
+    /** Wait for an in-flight cold-room load before reading or replacing sources. */
+    async waitForReady(projectId) {
+        const initialization = this.roomInitializations.get(projectId);
+        if (!initialization)
+            return;
+        try {
+            await initialization;
+        }
+        catch { /* Source files remain authoritative if recovery fails. */ }
     }
     flushProject(projectId) {
         const room = this.rooms.get(projectId);
-        if (room)
-            this.flushRoom(room);
+        return room ? this.flushRoom(room) : null;
+    }
+    /**
+     * Prevent collaboration autosaves from changing the source tree while a
+     * compiler is copying an immutable snapshot. Yjs updates remain accepted in
+     * memory and are flushed when the outermost barrier is released.
+     */
+    beginSnapshotBarrier(projectId) {
+        const depth = (this.snapshotBarriers.get(projectId) ?? 0) + 1;
+        this.snapshotBarriers.set(projectId, depth);
+        const room = this.rooms.get(projectId);
+        if (!room)
+            return;
+        room.snapshotBarrierDepth = depth;
+        if (depth === 1 && room.cleanupTimer) {
+            clearTimeout(room.cleanupTimer);
+            room.cleanupTimer = null;
+        }
+    }
+    /**
+     * Release a snapshot barrier and persist edits that arrived while the
+     * source tree was protected. The returned receipt describes the post-barrier
+     * disk revision, allowing callers to label a snapshot that predates edits
+     * without treating that consistent snapshot as invalid.
+     */
+    endSnapshotBarrier(projectId) {
+        const depth = this.snapshotBarriers.get(projectId) ?? 0;
+        if (depth <= 0)
+            return this.rooms.get(projectId) ? this.currentReceipt(this.rooms.get(projectId)) : null;
+        const nextDepth = depth - 1;
+        if (nextDepth > 0) {
+            this.snapshotBarriers.set(projectId, nextDepth);
+            const nestedRoom = this.rooms.get(projectId);
+            if (nestedRoom)
+                nestedRoom.snapshotBarrierDepth = nextDepth;
+            return nestedRoom ? this.currentReceipt(nestedRoom) : null;
+        }
+        this.snapshotBarriers.delete(projectId);
+        const room = this.rooms.get(projectId);
+        if (!room)
+            return null;
+        room.snapshotBarrierDepth = 0;
+        const shouldFlush = room.snapshotFlushPending || room.dirtyPaths.size > 0;
+        room.snapshotFlushPending = false;
+        let receipt;
+        try {
+            receipt = shouldFlush ? this.flushRoom(room) : this.currentReceipt(room);
+        }
+        catch (error) {
+            // A state-file or source-file I/O failure must still complete any
+            // browser flush requests waiting behind the barrier. The caller should
+            // receive the original server error, while editors receive a durable
+            // negative receipt instead of timing out.
+            receipt = this.currentReceipt(room, false, [...room.dirtyPaths]);
+            if (room.dirtyPaths.size > 0)
+                this.scheduleSave(room);
+            this.resolvePendingFlushes(room, receipt);
+            this.scheduleRoomCleanup(room);
+            throw error;
+        }
+        this.resolvePendingFlushes(room, receipt);
+        this.scheduleRoomCleanup(room);
+        return receipt;
     }
     stats() {
         let sessions = 0;
@@ -89,23 +201,132 @@ export class CollaborationService {
             sessions += room.connections.size;
             dirtyFiles += room.dirtyPaths.size;
         }
-        return { rooms: this.rooms.size, sessions, dirtyFiles };
+        return { rooms: this.rooms.size, sessions, dirtyFiles, initializing: this.roomInitializations.size };
     }
     updateFile(projectId, filePathInput, content, userId) {
         const room = this.rooms.get(projectId);
-        if (!room || !isCollaborativeTextFile(filePathInput))
+        if (!room) {
+            this.invalidateProject(projectId);
+            return;
+        }
+        if (!isCollaborativeTextFile(filePathInput)) {
+            this.invalidateProject(projectId);
             return;
+        }
         const filePath = safeRelativePath(filePathInput);
         room.allowedPaths.add(filePath);
         room.persistedContent.set(filePath, content);
         room.doc.transact(() => replaceText(this.trackedText(room, filePath), content), HTTP_ORIGIN);
         room.lastModifiedUserId = userId;
+        room.persistedRevision += 1;
+        room.persistedAt = new Date().toISOString();
         this.bumpFiles(room, { kind: "update", path: filePath });
     }
-    movePath(projectId, sourceInput, destinationInput, userId) {
+    /**
+     * Mark a project as undergoing an exclusive source-tree operation. Existing
+     * clients are told to stop editing and are disconnected when the operation
+     * completes by endMaintenance(), which forces a fresh Yjs epoch.
+     */
+    beginMaintenance(projectId, reason) {
+        const normalizedReason = reason.slice(0, 200);
+        const existingMaintenance = this.maintenanceProjects.get(projectId);
+        if (existingMaintenance)
+            throw new Error("Project is already undergoing a maintenance operation");
+        const room = this.rooms.get(projectId);
+        if (room?.maintenanceReason)
+            throw new Error("Project is already undergoing a maintenance operation");
+        this.maintenanceProjects.set(projectId, normalizedReason);
+        if (!room)
+            return;
+        room.maintenanceReason = normalizedReason;
+        const message = maintenanceMessage(room.maintenanceReason);
+        for (const connection of room.connections) {
+            send(connection.socket, message);
+            // Close immediately after the notice. This prevents local edits from
+            // accumulating while a source-tree replacement is in flight; the epoch
+            // reset in endMaintenance will make the client reload authoritative data.
+            connection.socket.close(4002, `Project maintenance: ${normalizedReason}`);
+        }
+    }
+    endMaintenance(projectId) {
+        this.maintenanceProjects.delete(projectId);
+        const room = this.rooms.get(projectId);
+        if (room)
+            room.maintenanceReason = null;
+        // A project-level replacement cannot safely merge edits made while the
+        // operation was in flight. Resetting the epoch makes every client reload
+        // the authoritative source tree instead of replaying stale local drafts.
+        this.resetProject(projectId);
+    }
+    notifyPermissionChanged(projectId, userId, permission) {
+        const room = this.rooms.get(projectId);
+        if (!room)
+            return;
+        const encoder = encoding.createEncoder();
+        encoding.writeVarUint(encoder, MESSAGE_PERMISSION);
+        encoding.writeVarString(encoder, userId);
+        encoding.writeVarString(encoder, permission);
+        const message = encoding.toUint8Array(encoder);
+        for (const connection of room.connections) {
+            if (connection.user.id === userId)
+                send(connection.socket, message);
+        }
+    }
+    disconnectUser(userId, reason = "User access revoked") {
+        const encoder = encoding.createEncoder();
+        encoding.writeVarUint(encoder, MESSAGE_PERMISSION);
+        encoding.writeVarString(encoder, userId);
+        encoding.writeVarString(encoder, "revoked");
+        const message = encoding.toUint8Array(encoder);
+        for (const room of this.rooms.values()) {
+            for (const connection of [...room.connections]) {
+                if (connection.user.id === userId) {
+                    send(connection.socket, message);
+                    connection.socket.close(1008, reason);
+                    this.disconnect(room, connection);
+                }
+            }
+        }
+    }
+    currentRevision(projectId) {
+        return this.rooms.get(projectId)?.persistedRevision ?? null;
+    }
+    /** Return the durable collaborative text currently held by a live room. */
+    fileContent(projectId, filePathInput) {
         const room = this.rooms.get(projectId);
         if (!room)
+            return null;
+        const filePath = safeRelativePath(filePathInput);
+        if (!room.allowedPaths.has(filePath))
+            return null;
+        return this.trackedText(room, filePath).toString();
+    }
+    /**
+     * Returns the current source-tree epoch.  Exclusive filesystem operations
+     * increment this value, allowing callers to cheaply distinguish a request
+     * admitted before and after a project replacement without reading files.
+     */
+    currentGeneration(projectId) {
+        return this.projectGeneration(projectId);
+    }
+    hasPendingChanges(projectId) {
+        return Boolean(this.rooms.get(projectId)?.dirtyPaths.size);
+    }
+    isMaintaining(projectId) {
+        return this.maintenanceProjects.has(projectId);
+    }
+    isStable(projectId, revision) {
+        const room = this.rooms.get(projectId);
+        return room
+            ? room.maintenanceReason === null && room.persistedRevision === revision && room.dirtyPaths.size === 0
+            : revision === null;
+    }
+    movePath(projectId, sourceInput, destinationInput, userId) {
+        const room = this.rooms.get(projectId);
+        if (!room) {
+            this.invalidateProject(projectId);
             return;
+        }
         this.flushRoom(room);
         const source = safeRelativePath(sourceInput);
         const destination = safeRelativePath(destinationInput);
@@ -123,12 +344,16 @@ export class CollaborationService {
             }
         }, HTTP_ORIGIN);
         room.lastModifiedUserId = userId;
+        room.persistedRevision += 1;
+        room.persistedAt = new Date().toISOString();
         this.bumpFiles(room, { kind: "move", source, destination });
     }
     removePath(projectId, filePathInput) {
         const room = this.rooms.get(projectId);
-        if (!room)
+        if (!room) {
+            this.invalidateProject(projectId);
             return;
+        }
         const filePath = safeRelativePath(filePathInput);
         const removed = [...room.allowedPaths].filter((candidate) => candidate === filePath || candidate.startsWith(`${filePath}/`));
         room.doc.transact(() => {
@@ -139,8 +364,18 @@ export class CollaborationService {
                 room.dirtyPaths.delete(candidate);
             }
         }, HTTP_ORIGIN);
+        room.persistedRevision += 1;
+        room.persistedAt = new Date().toISOString();
         this.bumpFiles(room, { kind: "delete", path: filePath });
     }
+    invalidateSourceTree(projectId, filePathInput) {
+        this.invalidateProject(projectId);
+        const room = this.rooms.get(projectId);
+        if (!room)
+            return;
+        const filePath = filePathInput ? safeRelativePath(filePathInput) : "";
+        this.bumpFiles(room, { kind: "update", path: filePath });
+    }
     signalComments(projectId) {
         const room = this.rooms.get(projectId);
         if (!room)
@@ -167,7 +402,102 @@ export class CollaborationService {
             .slice(0, 20));
         room.doc.transact(() => room.meta.set("compileStates", retained), META_ORIGIN);
     }
+    /**
+     * Drop compile states that no longer describe an active database run.
+     *
+     * `compileStates` is intentionally only a live UI signal. A browser can
+     * nevertheless replay an old IndexedDB update while reconnecting, so the
+     * server must not let an old `queued`/`running` value become authoritative
+     * again after a restart. Completed states are retained for the current room
+     * because they are useful to the UI and cannot disable a new compile.
+     */
+    sanitizeCompileStates(room) {
+        const current = room.meta.get("compileStates");
+        if (!current || typeof current !== "object" || Array.isArray(current)) {
+            if (current !== undefined)
+                room.doc.transact(() => room.meta.delete("compileStates"), META_ORIGIN);
+            return;
+        }
+        const retained = {};
+        let changed = false;
+        for (const [mainFile, value] of Object.entries(current)) {
+            if (!isSharedCompileState(mainFile, value)) {
+                changed = true;
+                continue;
+            }
+            if (value.status === "queued" || value.status === "running") {
+                const run = this.db.prepare(`SELECT status, main_file FROM compile_runs
+          WHERE id = ? AND project_id = ?`).get(value.runId, room.projectId);
+                if (!run || run.main_file !== mainFile || (run.status !== "queued" && run.status !== "running")) {
+                    changed = true;
+                    continue;
+                }
+            }
+            retained[mainFile] = value;
+        }
+        if (!changed && Object.keys(retained).length === Object.keys(current).length)
+            return;
+        room.doc.transact(() => {
+            if (Object.keys(retained).length)
+                room.meta.set("compileStates", retained);
+            else
+                room.meta.delete("compileStates");
+        }, META_ORIGIN);
+    }
+    sendCompileStates(room, socket) {
+        const payload = this.compileStatesForClient(room);
+        const encoder = encoding.createEncoder();
+        encoding.writeVarUint(encoder, MESSAGE_COMPILE_STATES);
+        encoding.writeVarString(encoder, JSON.stringify(payload));
+        send(socket, encoding.toUint8Array(encoder));
+    }
+    /**
+     * Include active database runs even when no live room existed when the run
+     * was queued. This keeps the handshake authoritative without making every
+     * compile request persist a duplicate Yjs metadata update.
+     */
+    compileStatesForClient(room) {
+        const current = room.meta.get("compileStates");
+        const states = isCompileStateMap(current) ? { ...current } : {};
+        const activeRuns = this.db.prepare(`SELECT run.id, run.main_file, run.status, run.requested_by,
+      run.created_at, user.username AS requested_by_username, user.display_name AS requested_by_name
+      FROM compile_runs run LEFT JOIN users user ON user.id = run.requested_by
+      WHERE run.project_id = ? AND run.status IN ('queued', 'running')
+      ORDER BY CASE run.status WHEN 'running' THEN 0 ELSE 1 END, run.created_at DESC`).all(room.projectId);
+        for (const run of activeRuns) {
+            if (states[run.main_file]?.status === "running" && run.status === "queued")
+                continue;
+            states[run.main_file] = {
+                mainFile: run.main_file,
+                runId: run.id,
+                status: run.status,
+                requestedBy: {
+                    id: run.requested_by ?? "deleted-user",
+                    username: run.requested_by_username ?? "deleted-user",
+                    name: run.requested_by_name ?? "Deleted User"
+                },
+                updatedAt: run.created_at
+            };
+        }
+        return Object.fromEntries(Object.entries(states)
+            .sort((left, right) => Date.parse(right[1].updatedAt) - Date.parse(left[1].updatedAt))
+            .slice(0, 20));
+    }
+    clearRecoveredMetadata(room) {
+        let changed = false;
+        room.doc.transact(() => {
+            for (const key of EPHEMERAL_META_KEYS) {
+                if (!room.meta.has(key))
+                    continue;
+                room.meta.delete(key);
+                changed = true;
+            }
+        }, META_ORIGIN);
+        return changed;
+    }
     closeProject(projectId) {
+        this.invalidateProject(projectId);
+        this.snapshotBarriers.delete(projectId);
         const room = this.rooms.get(projectId);
         if (!room)
             return;
@@ -176,6 +506,8 @@ export class CollaborationService {
         this.destroyRoom(room);
     }
     resetProject(projectId) {
+        this.invalidateProject(projectId);
+        this.snapshotBarriers.delete(projectId);
         const room = this.rooms.get(projectId);
         if (room) {
             for (const connection of room.connections)
@@ -186,19 +518,127 @@ export class CollaborationService {
         fs.rmSync(collaborationEpochPath(this.config, projectId), { force: true });
     }
     destroy() {
+        this.closed = true;
         for (const room of [...this.rooms.values()])
             this.destroyRoom(room);
+        this.roomInitializations.clear();
+        this.snapshotBarriers.clear();
+        this.pendingConnections.clear();
     }
-    getRoom(projectId) {
+    initializeRoom(projectId, generation) {
         const existing = this.rooms.get(projectId);
         if (existing)
+            return Promise.resolve(existing);
+        const pending = this.roomInitializations.get(projectId);
+        if (pending)
+            return pending;
+        const request = this.loadRoomBootstrap(projectId)
+            .then((bootstrap) => {
+            if (this.closed || this.projectGeneration(projectId) !== generation) {
+                bootstrap.doc.destroy();
+                throw new Error("Collaboration room initialization was invalidated");
+            }
+            return this.createRoom(projectId, bootstrap);
+        })
+            .finally(() => {
+            if (this.roomInitializations.get(projectId) === request)
+                this.roomInitializations.delete(projectId);
+        });
+        this.roomInitializations.set(projectId, request);
+        return request;
+    }
+    /** Read the potentially large source tree without blocking the event loop. */
+    async loadRoomBootstrap(projectId) {
+        let doc = new Y.Doc();
+        try {
+            let recoveredState = false;
+            let persistedState = null;
+            try {
+                persistedState = await fs.promises.readFile(collaborationStatePath(this.config, projectId));
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+            if (persistedState) {
+                try {
+                    Y.applyUpdate(doc, persistedState, DISK_ORIGIN);
+                    recoveredState = true;
+                }
+                catch {
+                    // Malformed Yjs data is recoverable because source files remain the
+                    // authority. Start with a pristine document in case applyUpdate()
+                    // partially mutated the original before rejecting the payload.
+                    doc.destroy();
+                    doc = new Y.Doc();
+                }
+            }
+            const epoch = await collaborationEpochAsync(this.config, projectId, recoveredState);
+            const files = await this.readCollaborativeFiles(projectId);
+            return { doc, recoveredState, epoch, files };
+        }
+        catch (error) {
+            doc.destroy();
+            throw error;
+        }
+    }
+    /**
+     * Recheck file metadata after reading. This closes the small race where an
+     * upload or autosave changes a file while the cold room is being hydrated.
+     */
+    async readCollaborativeFiles(projectId) {
+        const assertSourceRoot = async () => {
+            const stats = await fs.promises.lstat(sourceRoot(this.config, projectId));
+            if (stats.isSymbolicLink())
+                throw new Error("Collaborative source root cannot be a symbolic link");
+            if (!stats.isDirectory())
+                throw new Error("Collaborative source root is not a directory");
+        };
+        let lastFailure = "Unable to obtain a stable collaborative source snapshot";
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            await assertSourceRoot();
+            const entries = (await listProjectFilesAsync(this.config, projectId))
+                .filter((entry) => entry.type === "file" && isCollaborativeTextFile(entry.path)
+                && (entry.size ?? 0) <= maxCollaborativeFileBytes(this.config));
+            const files = [];
+            const failedPaths = [];
+            for (let offset = 0; offset < entries.length; offset += 8) {
+                const batch = entries.slice(offset, offset + 8);
+                const loaded = await Promise.all(batch.map(async (entry) => {
+                    try {
+                        return { path: entry.path, content: await fs.promises.readFile(resolveSourcePath(this.config, projectId, entry.path), "utf8") };
+                    }
+                    catch {
+                        failedPaths.push(entry.path);
+                        return null;
+                    }
+                }));
+                files.push(...loaded.filter((file) => file !== null));
+            }
+            const currentEntries = (await listProjectFilesAsync(this.config, projectId))
+                .filter((entry) => entry.type === "file" && isCollaborativeTextFile(entry.path)
+                && (entry.size ?? 0) <= maxCollaborativeFileBytes(this.config));
+            await assertSourceRoot();
+            const before = entries.map(collaborativeEntrySignature).sort().join("\n");
+            const after = currentEntries.map(collaborativeEntrySignature).sort().join("\n");
+            if (before === after && failedPaths.length === 0)
+                return files;
+            if (failedPaths.length)
+                lastFailure = `Unable to read collaborative source files: ${failedPaths.join(", ")}`;
+        }
+        throw new Error(lastFailure);
+    }
+    createRoom(projectId, bootstrap) {
+        const existing = this.rooms.get(projectId);
+        if (existing) {
+            bootstrap.doc.destroy();
             return existing;
-        const doc = new Y.Doc();
+        }
         const room = {
             projectId,
-            doc,
-            awareness: new Awareness(doc),
-            meta: doc.getMap("texlite:meta"),
+            doc: bootstrap.doc,
+            awareness: new Awareness(bootstrap.doc),
+            meta: bootstrap.doc.getMap("texlite:meta"),
             connections: new Set(),
             awarenessOwners: new Map(),
             allowedPaths: new Set(),
@@ -209,58 +649,68 @@ export class CollaborationService {
             stateSaveTimer: null,
             cleanupTimer: null,
             lastModifiedUserId: null,
-            epoch: "",
+            epoch: bootstrap.epoch,
             persistedRevision: 0,
-            persistedAt: new Date().toISOString()
+            persistedAt: new Date().toISOString(),
+            maintenanceReason: this.maintenanceProjects.get(projectId) ?? null,
+            snapshotBarrierDepth: this.snapshotBarriers.get(projectId) ?? 0,
+            snapshotFlushPending: false,
+            pendingFlushes: [],
+            rejectedPaths: new Set(),
+            compileMetaValidationPending: false
         };
         room.awareness.setLocalState(null);
-        const persistedState = collaborationStatePath(this.config, projectId);
-        let recoveredState = false;
+        // A recovered Yjs document may contain metadata from a process that no
+        // longer exists. The database/source tree are authoritative after a
+        // restart; clear the markers before any browser can sync them back.
+        const recoveredMetadataChanged = bootstrap.recoveredState && this.clearRecoveredMetadata(room);
+        this.sanitizeCompileStates(room);
         let recoveredDirty = false;
-        if (fs.existsSync(persistedState)) {
-            try {
-                Y.applyUpdate(doc, fs.readFileSync(persistedState), DISK_ORIGIN);
-                recoveredState = true;
-            }
-            catch {
-                // A corrupt state file is ignored; the source files remain authoritative.
-            }
-        }
-        room.epoch = collaborationEpoch(this.config, projectId, recoveredState);
         const diskPaths = new Set();
-        doc.transact(() => {
-            for (const entry of listProjectFiles(this.config, projectId)) {
-                if (entry.type !== "file" || !isCollaborativeTextFile(entry.path) || (entry.size ?? 0) > MAX_COLLABORATIVE_FILE_BYTES)
-                    continue;
-                const content = fs.readFileSync(resolveSourcePath(this.config, projectId, entry.path), "utf8");
-                diskPaths.add(entry.path);
-                room.allowedPaths.add(entry.path);
-                room.persistedContent.set(entry.path, content);
-                const name = typeName(entry.path);
-                // Yjs decodes top-level shared types lazily as AbstractType instances;
-                // the stable source: namespace identifies text more reliably than
-                // instanceof before getText() materializes the public type.
-                const hasRecoveredText = recoveredState && doc.share.has(name);
-                const text = this.trackedText(room, entry.path);
-                if (hasRecoveredText && text.toString() !== content) {
-                    room.dirtyPaths.add(entry.path);
+        room.doc.transact(() => {
+            for (const file of bootstrap.files) {
+                diskPaths.add(file.path);
+                room.allowedPaths.add(file.path);
+                room.persistedContent.set(file.path, file.content);
+                const name = typeName(file.path);
+                // Yjs decodes top-level shared types lazily; the source: namespace is
+                // the stable identifier before getText() materializes the public type.
+                const hasRecoveredText = bootstrap.recoveredState && room.doc.share.has(name);
+                const text = this.trackedText(room, file.path);
+                if (hasRecoveredText && text.toString() !== file.content) {
+                    room.dirtyPaths.add(file.path);
                     recoveredDirty = true;
                 }
                 else {
-                    replaceText(text, content);
+                    replaceText(text, file.content);
                 }
             }
-            for (const name of doc.share.keys()) {
+            for (const name of room.doc.share.keys()) {
                 if (!name.startsWith(SOURCE_PREFIX))
                     continue;
                 const filePath = name.slice(SOURCE_PREFIX.length);
                 if (!diskPaths.has(filePath))
-                    replaceText(doc.getText(name), "");
+                    replaceText(room.doc.getText(name), "");
             }
         }, DISK_ORIGIN);
-        doc.on("update", (update, origin) => {
+        const rejectedRecoveredPaths = this.rejectOversizedTexts(room);
+        recoveredDirty = room.dirtyPaths.size > 0;
+        room.meta.observe((_event, transaction) => {
+            if (isConnectionOrigin(transaction.origin))
+                room.compileMetaValidationPending = true;
+        });
+        room.doc.on("update", (update, origin) => {
             this.broadcast(room, syncUpdateMessage(update), origin instanceof Object && "socket" in origin ? origin : null);
-            this.scheduleStateSave(room);
+            // Compile state, file-list revisions, and comment/dictionary revision
+            // markers are ephemeral metadata. They are reconstructed from SQLite
+            // and the source tree after a restart, so do not encode and synchronously
+            // rewrite the complete Yjs document for every metadata-only event.
+            if (origin !== META_ORIGIN)
+                this.scheduleStateSave(room);
+            if (room.compileMetaValidationPending) {
+                room.compileMetaValidationPending = false;
+                this.sanitizeCompileStates(room);
+            }
             if (origin !== DISK_ORIGIN && origin !== HTTP_ORIGIN && origin !== META_ORIGIN) {
                 if (origin && typeof origin === "object" && "user" in origin) {
                     room.lastModifiedUserId = origin.user.id;
@@ -283,13 +733,65 @@ export class CollaborationService {
                 }
             }
         });
+        try {
+            // Persist a corrected state even when an oversized recovered document was
+            // reverted to the source file and no source write remains dirty.
+            if (recoveredDirty || rejectedRecoveredPaths.length > 0)
+                this.flushRoom(room);
+            else if (recoveredMetadataChanged)
+                this.scheduleStateSave(room);
+        }
+        catch (error) {
+            this.disposeRoom(room);
+            throw error;
+        }
         this.rooms.set(projectId, room);
-        if (recoveredDirty)
-            this.flushRoom(room);
-        else
-            this.persistRoomState(room);
+        // A fresh room has no unsaved Yjs state yet. Delaying state persistence
+        // avoids a large synchronous write on the first connection; subsequent
+        // updates schedule the normal atomic save.
         return room;
     }
+    attachConnection(room, socket, user) {
+        if (socket.readyState !== WebSocket.OPEN)
+            return;
+        if (!accessibleProject(this.db, room.projectId, user)) {
+            socket.close(1008, "Project access denied");
+            return;
+        }
+        const maintenanceReason = this.maintenanceProjects.get(room.projectId);
+        if (maintenanceReason) {
+            socket.close(1013, `Project is temporarily unavailable: ${maintenanceReason}`);
+            return;
+        }
+        if (room.connections.size >= MAX_PROJECT_SESSIONS) {
+            socket.close(1013, "Project collaboration room is full");
+            return;
+        }
+        if (room.cleanupTimer) {
+            clearTimeout(room.cleanupTimer);
+            room.cleanupTimer = null;
+        }
+        const connection = {
+            socket, user, awarenessClientId: null, protocolVerified: false, protocolTimer: null
+        };
+        room.connections.add(connection);
+        socket.binaryType = "arraybuffer";
+        socket.on("message", (data) => {
+            try {
+                this.handleMessage(room, connection, rawData(data));
+            }
+            catch {
+                socket.close(1003, "Invalid collaboration message");
+            }
+        });
+        socket.on("close", () => this.disconnect(room, connection));
+        socket.on("error", () => this.disconnect(room, connection));
+        connection.protocolTimer = setTimeout(() => {
+            if (!connection.protocolVerified)
+                socket.close(4001, "Reload required");
+        }, 10_000);
+        send(socket, protocolMessage(room.epoch));
+    }
     trackedText(room, filePath) {
         const text = room.doc.getText(typeName(filePath));
         if (room.textObservers.has(filePath))
@@ -312,25 +814,50 @@ export class CollaborationService {
         return text;
     }
     handleMessage(room, connection, bytes) {
-        const current = accessibleProject(this.db, room.projectId, connection.user);
+        const refreshedUser = this.db.prepare("SELECT * FROM users WHERE id = ?").get(connection.user.id);
+        if (!refreshedUser || refreshedUser.disabled) {
+            connection.socket.close(1008, "Project access revoked");
+            this.disconnect(room, connection);
+            return;
+        }
+        connection.user = refreshedUser;
+        const current = accessibleProject(this.db, room.projectId, refreshedUser);
         if (!current) {
             connection.socket.close(1008, "Project access revoked");
             return;
         }
         const decoder = decoding.createDecoder(bytes);
         const messageType = decoding.readVarUint(decoder);
+        if (room.maintenanceReason && messageType !== MESSAGE_PROTOCOL && messageType !== MESSAGE_QUERY_AWARENESS) {
+            return;
+        }
         if (messageType === MESSAGE_PROTOCOL) {
             const epoch = decoding.readVarString(decoder);
+            const clientProtocolVersion = decoding.hasContent(decoder)
+                ? decoding.readVarUint(decoder)
+                : null;
             if (epoch !== room.epoch) {
                 connection.socket.close(4001, "Collaboration state changed; reload required");
                 return;
             }
+            // A pre-versioning client cannot safely decode the durable FLUSH
+            // response introduced in the previous release. Send a protocol marker
+            // that deliberately differs from the room epoch; the existing client
+            // handler treats it as a state change and reloads before it can edit.
+            // New clients append their version to the otherwise-compatible handshake.
+            if (clientProtocolVersion !== COLLABORATION_PROTOCOL_VERSION) {
+                send(connection.socket, protocolMessage(`${room.epoch}:reload`));
+                connection.socket.close(4001, "Collaboration protocol upgrade required");
+                return;
+            }
             if (!connection.protocolVerified) {
                 connection.protocolVerified = true;
                 if (connection.protocolTimer)
                     clearTimeout(connection.protocolTimer);
                 connection.protocolTimer = null;
+                this.sanitizeCompileStates(room);
                 this.sendSyncStep1(room, connection.socket);
+                this.sendCompileStates(room, connection.socket);
                 this.sendAwareness(room, connection.socket);
             }
             return;
@@ -344,10 +871,17 @@ export class CollaborationService {
             if (syncType === syncProtocol.messageYjsSyncStep1) {
                 syncProtocol.readSyncStep1(decoder, encoder, room.doc);
             }
-            else if (canEdit(current)) {
-                if (syncType === syncProtocol.messageYjsSyncStep2)
+            else if (syncType === syncProtocol.messageYjsSyncStep2) {
+                // Read-only browsers may still carry a stale IndexedDB document. Do
+                // not apply their source updates, but always send the authoritative
+                // ephemeral compile state back to them.
+                if (canEdit(current))
                     syncProtocol.readSyncStep2(decoder, room.doc, connection);
-                else if (syncType === syncProtocol.messageYjsUpdate)
+                this.sanitizeCompileStates(room);
+                this.sendCompileStates(room, connection.socket);
+            }
+            else if (canEdit(current)) {
+                if (syncType === syncProtocol.messageYjsUpdate)
                     syncProtocol.readUpdate(decoder, room.doc, connection);
             }
             if (encoding.length(encoder) > 1)
@@ -362,13 +896,24 @@ export class CollaborationService {
             const requestId = decoding.readVarString(decoder).slice(0, 128);
             if (!canEdit(current))
                 return;
-            const receipt = this.flushRoom(room);
-            const encoder = encoding.createEncoder();
-            encoding.writeVarUint(encoder, MESSAGE_FLUSH);
-            encoding.writeVarString(encoder, requestId);
-            encoding.writeVarUint(encoder, receipt.revision);
-            encoding.writeVarString(encoder, receipt.persistedAt);
-            send(connection.socket, encoding.toUint8Array(encoder));
+            if (room.snapshotBarrierDepth > 0 || (this.snapshotBarriers.get(room.projectId) ?? 0) > 0) {
+                // Do not report the intentionally deferred flush as a failure. The
+                // request is completed by endSnapshotBarrier() after the source tree
+                // is released and the pending edits have been persisted.
+                room.pendingFlushes.push({ connection, requestId });
+                room.snapshotFlushPending = room.dirtyPaths.size > 0 || room.snapshotFlushPending;
+                return;
+            }
+            let receipt;
+            try {
+                receipt = this.flushRoom(room);
+            }
+            catch {
+                receipt = this.currentReceipt(room, false, [...room.dirtyPaths]);
+                if (room.dirtyPaths.size > 0)
+                    this.scheduleSave(room);
+            }
+            this.sendFlushReceipt(connection, requestId, receipt);
             return;
         }
         if (messageType !== MESSAGE_AWARENESS)
@@ -401,6 +946,7 @@ export class CollaborationService {
     disconnect(room, connection) {
         if (!room.connections.delete(connection))
             return;
+        room.pendingFlushes = room.pendingFlushes.filter((pending) => pending.connection !== connection);
         if (connection.protocolTimer)
             clearTimeout(connection.protocolTimer);
         connection.protocolTimer = null;
@@ -408,9 +954,7 @@ export class CollaborationService {
             removeAwarenessStates(room.awareness, [connection.awarenessClientId], connection);
             room.awarenessOwners.delete(connection.awarenessClientId);
         }
-        if (room.connections.size === 0 && !room.cleanupTimer) {
-            room.cleanupTimer = setTimeout(() => this.destroyRoom(room), ROOM_IDLE_MS);
-        }
+        this.scheduleRoomCleanup(room);
     }
     sendSyncStep1(room, socket) {
         const encoder = encoding.createEncoder();
@@ -428,6 +972,11 @@ export class CollaborationService {
             if (connection !== except)
                 send(connection.socket, message);
     }
+    scheduleRoomCleanup(room) {
+        if (room.connections.size === 0 && !room.cleanupTimer) {
+            room.cleanupTimer = setTimeout(() => this.destroyRoom(room), ROOM_IDLE_MS);
+        }
+    }
     scheduleSave(room) {
         if (room.saveTimer)
             clearTimeout(room.saveTimer);
@@ -456,6 +1005,7 @@ export class CollaborationService {
         if (room.stateSaveTimer)
             clearTimeout(room.stateSaveTimer);
         room.stateSaveTimer = null;
+        this.rejectOversizedTexts(room);
         const target = collaborationStatePath(this.config, room.projectId);
         const temporary = `${target}.tmp`;
         fs.mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 });
@@ -463,13 +1013,23 @@ export class CollaborationService {
         fs.renameSync(temporary, target);
     }
     flushRoom(room) {
+        if (room.snapshotBarrierDepth > 0 || (this.snapshotBarriers.get(room.projectId) ?? 0) > 0) {
+            if (room.saveTimer)
+                clearTimeout(room.saveTimer);
+            room.saveTimer = null;
+            if (room.dirtyPaths.size > 0)
+                room.snapshotFlushPending = true;
+            return this.currentReceipt(room, room.dirtyPaths.size === 0, []);
+        }
         const startedAt = performance.now();
         if (room.saveTimer)
             clearTimeout(room.saveTimer);
         room.saveTimer = null;
+        this.rejectOversizedTexts(room);
         this.persistRoomState(room);
         let changed = false;
         const changedPaths = [];
+        const failedPaths = [...room.rejectedPaths];
         const dirtyPaths = [...room.dirtyPaths];
         for (const filePath of dirtyPaths) {
             if (!room.allowedPaths.has(filePath)) {
@@ -482,11 +1042,18 @@ export class CollaborationService {
                 room.dirtyPaths.delete(filePath);
                 continue;
             }
-            if (Buffer.byteLength(next, "utf8") > this.config.maxUploadBytes)
-                throw new Error(`Collaborative file exceeds upload limit: ${filePath}`);
+            if (Buffer.byteLength(next, "utf8") > maxCollaborativeFileBytes(this.config)) {
+                failedPaths.push(filePath);
+                continue;
+            }
             const absolute = resolveSourcePath(this.config, room.projectId, filePath);
-            if (!fs.existsSync(absolute))
-                throw new Error(`Collaborative source path disappeared: ${filePath}`);
+            try {
+                fs.mkdirSync(path.dirname(absolute), { recursive: true, mode: 0o700 });
+            }
+            catch {
+                failedPaths.push(filePath);
+                continue;
+            }
             const temporary = `${absolute}.collaboration-${process.pid}-${randomUUID()}.tmp`;
             try {
                 fs.writeFileSync(temporary, next, { encoding: "utf8", mode: 0o600 });
@@ -494,7 +1061,8 @@ export class CollaborationService {
             }
             catch (error) {
                 fs.rmSync(temporary, { force: true });
-                throw error;
+                failedPaths.push(filePath);
+                continue;
             }
             room.persistedContent.set(filePath, next);
             room.dirtyPaths.delete(filePath);
@@ -517,9 +1085,34 @@ export class CollaborationService {
             }
             catch { /* Source durability must not depend on optional history bookkeeping. */ }
         }
-        room.persistedRevision += 1;
-        room.persistedAt = new Date().toISOString();
-        return { revision: room.persistedRevision, persistedAt: room.persistedAt };
+        const ok = failedPaths.length === 0 && room.dirtyPaths.size === 0;
+        if (changed)
+            room.persistedRevision += 1;
+        if (ok) {
+            room.persistedAt = new Date().toISOString();
+        }
+        else if (!room.saveTimer && room.dirtyPaths.size > 0) {
+            // Retry with backoff if dirty files remain unpersisted
+            room.saveTimer = setTimeout(() => {
+                try {
+                    this.flushRoom(room);
+                }
+                catch {
+                    room.saveTimer = null;
+                }
+            }, 2000);
+        }
+        const receipt = this.currentReceipt(room, ok, [...new Set(failedPaths)]);
+        room.rejectedPaths.clear();
+        return receipt;
+    }
+    currentReceipt(room, ok = true, failedPaths = []) {
+        return {
+            revision: room.persistedRevision,
+            persistedAt: room.persistedAt,
+            ok: ok && room.dirtyPaths.size === 0,
+            failedPaths
+        };
     }
     bumpFiles(room, event) {
         room.doc.transact(() => room.meta.set("filesEvent", { ...event, revision: randomUUID() }), META_ORIGIN);
@@ -527,13 +1120,6 @@ export class CollaborationService {
     destroyRoom(room, persist = true) {
         if (this.rooms.get(room.projectId) !== room)
             return;
-        if (room.cleanupTimer)
-            clearTimeout(room.cleanupTimer);
-        for (const connection of room.connections) {
-            if (connection.protocolTimer)
-                clearTimeout(connection.protocolTimer);
-            connection.protocolTimer = null;
-        }
         if (persist) {
             try {
                 this.flushRoom(room);
@@ -545,18 +1131,74 @@ export class CollaborationService {
                 catch { /* Keep shutdown best-effort. */ }
             }
         }
-        else {
-            if (room.saveTimer)
-                clearTimeout(room.saveTimer);
-            if (room.stateSaveTimer)
-                clearTimeout(room.stateSaveTimer);
+        this.disposeRoom(room);
+        this.rooms.delete(room.projectId);
+    }
+    disposeRoom(room) {
+        if (room.cleanupTimer)
+            clearTimeout(room.cleanupTimer);
+        if (room.saveTimer)
+            clearTimeout(room.saveTimer);
+        if (room.stateSaveTimer)
+            clearTimeout(room.stateSaveTimer);
+        for (const connection of room.connections) {
+            if (connection.protocolTimer)
+                clearTimeout(connection.protocolTimer);
+            connection.protocolTimer = null;
         }
+        room.connections.clear();
+        room.pendingFlushes.splice(0);
+        room.rejectedPaths.clear();
+        room.awarenessOwners.clear();
         for (const [filePath, observer] of room.textObservers) {
             room.doc.getText(typeName(filePath)).unobserve(observer);
         }
         room.awareness.destroy();
         room.doc.destroy();
-        this.rooms.delete(room.projectId);
+    }
+    rejectOversizedTexts(room) {
+        const rejected = [];
+        const limit = maxCollaborativeFileBytes(this.config);
+        for (const filePath of [...room.dirtyPaths]) {
+            const text = this.trackedText(room, filePath);
+            if (Buffer.byteLength(text.toString(), "utf8") <= limit)
+                continue;
+            const previous = room.persistedContent.get(filePath) ?? "";
+            room.doc.transact(() => replaceText(text, previous), DISK_ORIGIN);
+            room.dirtyPaths.delete(filePath);
+            room.rejectedPaths.add(filePath);
+            rejected.push(filePath);
+        }
+        return rejected;
+    }
+    sendFlushReceipt(connection, requestId, receipt) {
+        const encoder = encoding.createEncoder();
+        encoding.writeVarUint(encoder, MESSAGE_FLUSH);
+        encoding.writeVarString(encoder, requestId);
+        encoding.writeVarUint(encoder, receipt.ok ? 1 : 0);
+        encoding.writeVarUint(encoder, receipt.revision);
+        encoding.writeVarString(encoder, receipt.persistedAt);
+        encoding.writeVarUint(encoder, receipt.failedPaths?.length ?? 0);
+        for (const failed of receipt.failedPaths ?? [])
+            encoding.writeVarString(encoder, failed);
+        send(connection.socket, encoding.toUint8Array(encoder));
+    }
+    resolvePendingFlushes(room, receipt) {
+        const pending = room.pendingFlushes.splice(0);
+        for (const request of pending) {
+            if (room.connections.has(request.connection))
+                this.sendFlushReceipt(request.connection, request.requestId, receipt);
+        }
+    }
+    projectGeneration(projectId) {
+        return this.projectGenerations.get(projectId) ?? 0;
+    }
+    pendingConnectionKey(projectId, generation) {
+        return `${projectId}\0${generation}`;
+    }
+    invalidateProject(projectId) {
+        this.projectGenerations.set(projectId, this.projectGeneration(projectId) + 1);
+        this.roomInitializations.delete(projectId);
     }
 }
 export function collaborationStatePath(config, projectId) {
@@ -565,23 +1207,42 @@ export function collaborationStatePath(config, projectId) {
 export function collaborationEpochPath(config, projectId) {
     return path.join(outputRoot(config, projectId), ".texlite", "collaboration.epoch");
 }
-function collaborationEpoch(config, projectId, recoveredState) {
+export function maxCollaborativeFileBytes(config) {
+    return Math.min(config.maxUploadBytes, MAX_COLLABORATIVE_FILE_BYTES);
+}
+export function isCollaborativeTextFile(filePath) {
+    return /(?:\.tex|\.bib|\.sty|\.cls|\.txt|\.md|latexmkrc)$/i.test(filePath);
+}
+function collaborativeEntrySignature(entry) {
+    return `${entry.path}\0${entry.size ?? 0}\0${entry.mtimeMs ?? 0}`;
+}
+async function collaborationEpochAsync(config, projectId, recoveredState) {
     const target = collaborationEpochPath(config, projectId);
-    if (recoveredState && fs.existsSync(target)) {
-        const existing = fs.readFileSync(target, "utf8").trim();
-        if (/^[a-f0-9-]{36}$/i.test(existing))
-            return existing;
+    if (recoveredState) {
+        try {
+            const existing = (await fs.promises.readFile(target, "utf8")).trim();
+            if (new RegExp(`^${COLLABORATION_PROTOCOL_VERSION}:[a-f0-9-]{36}$`, "i").test(existing))
+                return existing;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            // Generate a fresh epoch when the previous marker is missing.
+        }
+    }
+    const epoch = `${VERSIONED_EPOCH_PREFIX}${randomUUID()}`;
+    const temporary = `${target}.${process.pid}-${randomUUID()}.tmp`;
+    await fs.promises.mkdir(path.dirname(target), { recursive: true, mode: 0o700 });
+    try {
+        await fs.promises.writeFile(temporary, epoch, { encoding: "utf8", mode: 0o600 });
+        await fs.promises.rename(temporary, target);
+    }
+    catch (error) {
+        await fs.promises.rm(temporary, { force: true });
+        throw error;
     }
-    const epoch = randomUUID();
-    const temporary = `${target}.tmp`;
-    fs.mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 });
-    fs.writeFileSync(temporary, epoch, { encoding: "utf8", mode: 0o600 });
-    fs.renameSync(temporary, target);
     return epoch;
 }
-function isCollaborativeTextFile(filePath) {
-    return /(?:\.tex|\.bib|\.sty|\.cls|\.txt|\.md|latexmkrc)$/i.test(filePath);
-}
 function typeName(filePath) {
     return `${SOURCE_PREFIX}${filePath}`;
 }
@@ -611,6 +1272,36 @@ function protocolMessage(epoch) {
     encoding.writeVarString(encoder, epoch);
     return encoding.toUint8Array(encoder);
 }
+function isConnectionOrigin(origin) {
+    return Boolean(origin && typeof origin === "object" && "socket" in origin);
+}
+function isSharedCompileState(mainFile, value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const state = value;
+    const requestedBy = state.requestedBy;
+    return state.mainFile === mainFile
+        && typeof state.runId === "string" && state.runId.length > 0
+        && (state.status === "queued" || state.status === "running" || state.status === "succeeded"
+            || state.status === "failed" || state.status === "cleaned")
+        && (state.status !== "cleaned" || state.cleanMode === "cache" || state.cleanMode === "artifacts")
+        && (state.stale === undefined || typeof state.stale === "boolean")
+        && typeof state.updatedAt === "string"
+        && Boolean(requestedBy && typeof requestedBy === "object"
+            && typeof requestedBy.id === "string" && typeof requestedBy.username === "string"
+            && typeof requestedBy.name === "string");
+}
+function isCompileStateMap(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    return Object.entries(value).every(([mainFile, state]) => isSharedCompileState(mainFile, state));
+}
+function maintenanceMessage(reason) {
+    const encoder = encoding.createEncoder();
+    encoding.writeVarUint(encoder, MESSAGE_MAINTENANCE);
+    encoding.writeVarString(encoder, reason);
+    return encoding.toUint8Array(encoder);
+}
 function awarenessClientIds(update) {
     const decoder = decoding.createDecoder(update);
     const count = decoding.readVarUint(decoder);