@adecore/lsp 0.23.1 → 0.24.0

package/dist/document.d.ts

@@ -6,9 +6,10 @@ export declare class LspDocument {
     readonly languageId: string;
     readonly ready: Promise<void>;
     private revision;
-    private content;
+    private readonly content;
     private closed;
     private synced;
+    private sendFullText?;
     private closePromise?;
     private readonly inFlight;
     private readonly latest;
@@ -60,5 +61,6 @@ export declare class LspDocument {
     private remember;
     private assertOpen;
     private assertCurrent;
+    private queueFullText;
     private cancelRequests;
 }

package/dist/document.js

@@ -1,5 +1,8 @@
 import { ErrorCodes, LspError, StaleResultError } from './connection.js';
-import { applyContentChanges, minimalChange } from './edits.js';
+import { minimalChange } from './edits.js';
+import { TextMirror } from './text-mirror.js';
+/* The delay of the VS Code language client for servers with full sync. */
+const FULL_SYNC_DELAY_MS = 200;
 /*
  * One open text document in one session. It owns the version: every change raises it by one, and a
  * result that arrives for an older version is refused, so nothing computed for a text that is gone
@@ -14,6 +17,7 @@ export class LspDocument {
     content;
     closed = false;
     synced;
+    sendFullText;
     closePromise;
     inFlight = new Set();
     latest = new Map();
@@ -24,7 +28,7 @@ export class LspDocument {
         this.session = session;
         this.uri = item.uri;
         this.languageId = item.languageId;
-        this.content = item.text;
+        this.content = new TextMirror(item.text);
         this.revision = item.version ?? 1;
         if (!Number.isSafeInteger(this.revision) || this.revision < 0) {
             throw new LspError('Invalid document version');
@@ -39,7 +43,7 @@ export class LspDocument {
         return this.revision;
     }
     get text() {
-        return this.content;
+        return this.content.text;
     }
     get isClosed() {
         return this.closed;
@@ -47,14 +51,16 @@ export class LspDocument {
     /* Sends the difference to the text as the one range that changed, or the whole text to a server that wants no ranges. */
     updateText(text) {
         this.assertOpen();
-        if (text === this.content) {
+        const current = this.content.text;
+        if (text === current) {
             return this.synced;
         }
-        return this.applyChanges([minimalChange(this.content, text)]);
+        return this.applyChanges([minimalChange(current, text)]);
     }
     /*
      * Applies `didChange` entries in order, which a server that negotiated incremental sync gets as
-     * they are. The version goes up by one even when the text ends up the same.
+     * they are. The version goes up by one even when the text ends up the same. A server with full
+     * sync gets the whole text once the changes pause, or before the next request, save or close.
      */
     applyChanges(changes) {
         this.assertOpen();
@@ -62,17 +68,18 @@ export class LspDocument {
         if (!kind) {
             return Promise.reject(new LspError('Server did not negotiate document changes', ErrorCodes.MethodNotFound));
         }
-        let next;
         try {
-            next = applyContentChanges(this.content, changes);
+            this.content.applyChanges(changes);
         }
         catch (error) {
             return Promise.reject(error);
         }
-        this.content = next;
         const version = ++this.revision;
         this.cancelRequests();
-        const contentChanges = kind === 1 ? [{ text: next }] : changes.map((change) => ({ ...change }));
+        if (kind === 1) {
+            return this.queueFullText();
+        }
+        const contentChanges = changes.map((change) => ({ ...change }));
         this.synced = this.synced.then(() => this.session.connection.notify('textDocument/didChange', { textDocument: { uri: this.uri, version }, contentChanges }));
         void this.synced.catch((error) => this.session.connection.reportError(error));
         return this.synced;
@@ -82,6 +89,7 @@ export class LspDocument {
         this.assertOpen();
         const version = this.version;
         const text = this.text;
+        this.sendFullText?.();
         await this.synced;
         this.assertCurrent(version);
         const save = this.session.syncOptions.save;
@@ -201,6 +209,7 @@ export class LspDocument {
         }
         this.closed = true;
         this.cancelRequests();
+        this.sendFullText?.();
         this.closePromise = this.synced
             .then(async () => {
             if (!this.session.connection.isClosed && this.session.syncOptions.openClose) {
@@ -214,6 +223,7 @@ export class LspDocument {
     disconnect() {
         this.closed = true;
         this.cancelRequests();
+        this.sendFullText?.();
         this.session.forgetDocument(this);
     }
     feature(method, params, options) {
@@ -244,6 +254,7 @@ export class LspDocument {
             abort();
         }
         try {
+            this.sendFullText?.();
             await this.synced;
             this.assertCurrent(version);
             const result = await this.session.request(method, params, { signal: controller.signal, timeoutMs: options.timeoutMs });
@@ -288,6 +299,32 @@ export class LspDocument {
             throw new StaleResultError(this.uri);
         }
     }
+    /* Changes that arrive while the whole text waits go out with it, under the newest version. */
+    queueFullText() {
+        if (this.sendFullText) {
+            return this.synced;
+        }
+        const due = new Promise((resolve) => {
+            const timer = setTimeout(resolve, this.session.options.fullSyncDelayMs ?? FULL_SYNC_DELAY_MS);
+            this.sendFullText = () => {
+                clearTimeout(timer);
+                resolve();
+            };
+        });
+        this.synced = this.synced
+            .then(() => due)
+            .then(async () => {
+            this.sendFullText = undefined;
+            if (!this.session.connection.isClosed) {
+                await this.session.connection.notify('textDocument/didChange', {
+                    textDocument: { uri: this.uri, version: this.revision },
+                    contentChanges: [{ text: this.content.text }]
+                });
+            }
+        });
+        void this.synced.catch((error) => this.session.connection.reportError(error));
+        return this.synced;
+    }
     cancelRequests() {
         for (const controller of this.inFlight) {
             controller.abort();

package/dist/edits.js

@@ -1,11 +1,14 @@
 import { ErrorCodes, LspError } from './connection.js';
 const CR = 13;
 const LF = 10;
-/* A line ends at `\n`, `\r\n` or a lone `\r`, which is how the protocol counts lines. */
-export function offsetAt(text, position) {
+function checkPosition(position) {
     if (!Number.isInteger(position.line) || !Number.isInteger(position.character) || position.line < 0 || position.character < 0) {
         throw new LspError('Invalid edit position');
     }
+}
+/* A line ends at `\n`, `\r\n` or a lone `\r`, which is how the protocol counts lines. */
+export function offsetAt(text, position) {
+    checkPosition(position);
     let line = 0;
     let offset = 0;
     while (line < position.line && offset < text.length) {
@@ -64,12 +67,40 @@ export function positionAt(text, offset) {
 export function endPosition(text) {
     return positionAt(text, text.length);
 }
+/* `offsetAt` for many positions in one text: the starts of its lines are found once instead of on every call. */
+function offsetsIn(text) {
+    const starts = [0];
+    for (let i = 0; i < text.length; i++) {
+        const code = text.charCodeAt(i);
+        if (code === CR && text.charCodeAt(i + 1) === LF) {
+            i++;
+            starts.push(i + 1);
+        }
+        else if (code === CR || code === LF) {
+            starts.push(i + 1);
+        }
+    }
+    return (position) => {
+        checkPosition(position);
+        const start = starts[position.line];
+        if (start === undefined) {
+            throw new LspError('Edit line is outside the document');
+        }
+        const next = starts[position.line + 1];
+        const end = next === undefined ? text.length : next - (text.charCodeAt(next - 1) === LF && text.charCodeAt(next - 2) === CR ? 2 : 1);
+        if (start + position.character > end) {
+            throw new LspError('Edit character is outside the line');
+        }
+        return start + position.character;
+    };
+}
 /* Edits are simultaneous and in the coordinates of `text`; two inserts at one place keep their order. */
 export function applyTextEdits(text, edits) {
+    const offsetOf = offsetsIn(text);
     const spans = edits
         .map((edit, index) => ({
-        start: offsetAt(text, edit.range.start),
-        end: offsetAt(text, edit.range.end),
+        start: offsetOf(edit.range.start),
+        end: offsetOf(edit.range.end),
         text: edit.newText,
         index
     }))

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export { planWorkspaceOperations, type PlannedCreateStep, type PlannedDeleteStep
 export { createsTaken, deletesTaken, renamesTaken, type CreatedFile, type DeletedFile, type RenamedFile } from './file-operations.ts';
 export { watchesFile, type FileChangeType } from './watched-files.ts';
 export { LspSession, type LspSessionOptions, type SessionState } from './session.ts';
+export { TextMirror } from './text-mirror.ts';
 export type { DiagnosticsReport, LanguageDocument, LanguageRequestOptions, LanguageService } from './service.ts';
 export { ContentLengthDecoder, connectWebSocket, createMemoryTransportPair, createStreamTransport, encodeMessage, type ByteStream, type WebSocketTransportOptions } from './transport.ts';
 export { globMatch } from './glob.ts';

package/dist/index.js

@@ -6,6 +6,7 @@ export { planWorkspaceOperations } from './workspace-operations.js';
 export { createsTaken, deletesTaken, renamesTaken } from './file-operations.js';
 export { watchesFile } from './watched-files.js';
 export { LspSession } from './session.js';
+export { TextMirror } from './text-mirror.js';
 export { ContentLengthDecoder, connectWebSocket, createMemoryTransportPair, createStreamTransport, encodeMessage } from './transport.js';
 export { globMatch } from './glob.js';
 export { fileUriToPath, pathToFileUri } from './uris.js';

package/dist/session.d.ts

@@ -14,6 +14,7 @@ export interface LspSessionOptions {
         version?: string;
     };
     timeoutMs?: number;
+    fullSyncDelayMs?: number;
     snippetSupport?: boolean;
     insertTextModes?: readonly (1 | 2)[];
     completionItemDefaults?: readonly string[];

package/dist/test-transport.d.ts

@@ -1,4 +1,4 @@
-import { LspSession } from './session.ts';
+import { LspSession, type LspSessionOptions } from './session.ts';
 import type { LspTransport, RpcMessage, ServerCapabilities } from './protocol.ts';
 export declare class ScriptedTransport implements LspTransport {
     sent: RpcMessage[];
@@ -26,7 +26,7 @@ export declare const origin: {
     line: number;
     character: number;
 };
-export declare function sessionWith(capabilities?: ServerCapabilities): Promise<{
+export declare function sessionWith(capabilities?: ServerCapabilities, options?: LspSessionOptions): Promise<{
     transport: ScriptedTransport;
     session: LspSession;
 }>;

package/dist/test-transport.js

@@ -57,10 +57,10 @@ export async function flush() {
     }
 }
 export const origin = { line: 0, character: 0 };
-export async function sessionWith(capabilities = {}) {
+export async function sessionWith(capabilities = {}, options) {
     const transport = new ScriptedTransport();
     transport.autoInitialize = { textDocumentSync: 2, ...capabilities };
-    const session = new LspSession(transport);
+    const session = new LspSession(transport, options);
     await session.initialize();
     return { transport, session };
 }

package/dist/text-mirror.d.ts

@@ -0,0 +1,12 @@
+import type { ContentChange } from './protocol.ts';
+export declare class TextMirror {
+    private lines;
+    private joined;
+    constructor(text?: string);
+    get text(): string;
+    get lineCount(): number;
+    applyChanges(changes: readonly ContentChange[]): void;
+    private applyRange;
+    private lineAt;
+    private replace;
+}

package/dist/text-mirror.js

@@ -0,0 +1,118 @@
+import { LspError } from './connection.js';
+const CR = 13;
+const LF = 10;
+/* Past this many lines a spread into `splice` could exceed the engine's argument limit. */
+const SPREAD_LIMIT = 10_000;
+/* Each line keeps its own break, so the last one is the only line without. */
+function splitLines(text) {
+    const lines = [];
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        const code = text.charCodeAt(i);
+        if (code === CR || code === LF) {
+            if (code === CR && text.charCodeAt(i + 1) === LF) {
+                i++;
+            }
+            lines.push(text.slice(start, i + 1));
+            start = i + 1;
+        }
+    }
+    lines.push(text.slice(start));
+    return lines;
+}
+function breakLength(line) {
+    const last = line.charCodeAt(line.length - 1);
+    if (last === LF) {
+        return line.charCodeAt(line.length - 2) === CR ? 2 : 1;
+    }
+    return last === CR ? 1 : 0;
+}
+/*
+ * The text of a document as its lines, kept up to date with `didChange` entries. A change costs the
+ * lines it touches instead of the whole text, and the text is joined only when it is read.
+ */
+export class TextMirror {
+    lines;
+    joined;
+    constructor(text = '') {
+        this.lines = splitLines(text);
+        this.joined = text;
+    }
+    get text() {
+        this.joined ??= this.lines.join('');
+        return this.joined;
+    }
+    get lineCount() {
+        return this.lines.length;
+    }
+    /* Applies the entries in order, each in the text the one before it left. When one does not fit, it throws and the text stays as it was. */
+    applyChanges(changes) {
+        const applied = [];
+        try {
+            for (const change of changes) {
+                applied.push(change.range
+                    ? this.applyRange(change.range.start, change.range.end, change.text)
+                    : this.replace(0, this.lines.length, splitLines(change.text)));
+                this.joined = change.range ? null : change.text;
+            }
+        }
+        catch (error) {
+            for (const splice of applied.reverse()) {
+                this.replace(splice.start, splice.inserted, splice.removed);
+            }
+            this.joined = null;
+            throw error;
+        }
+    }
+    applyRange(start, end, text) {
+        const startLine = this.lineAt(start);
+        const endLine = this.lineAt(end);
+        if (end.line < start.line || (end.line === start.line && end.character < start.character)) {
+            throw new LspError('Change range is reversed');
+        }
+        const inserted = splitLines(text);
+        const last = inserted.length - 1;
+        let suffix = endLine.slice(end.character);
+        // An inserted `\r` and the `\n` after the range become one break.
+        if (text.charCodeAt(text.length - 1) === CR && suffix.charCodeAt(0) === LF) {
+            inserted[last - 1] += '\n';
+            suffix = suffix.slice(1);
+        }
+        inserted[last] += suffix;
+        inserted[0] = startLine.slice(0, start.character) + inserted[0];
+        if (inserted[last] === '' && end.line < this.lines.length - 1) {
+            inserted.pop();
+        }
+        let first = start.line;
+        // A line that ends in a lone `\r` takes a `\n` that now follows it as the rest of its break.
+        if (inserted[0] === '\n' && first > 0 && this.lines[first - 1].charCodeAt(this.lines[first - 1].length - 1) === CR) {
+            first--;
+            inserted[0] = this.lines[first] + '\n';
+        }
+        return this.replace(first, end.line - first + 1, inserted);
+    }
+    lineAt(position) {
+        if (!Number.isInteger(position.line) || !Number.isInteger(position.character) || position.line < 0 || position.character < 0) {
+            throw new LspError('Invalid edit position');
+        }
+        const line = this.lines[position.line];
+        if (line === undefined) {
+            throw new LspError('Edit line is outside the document');
+        }
+        if (position.character > line.length - breakLength(line)) {
+            throw new LspError('Edit character is outside the line');
+        }
+        return line;
+    }
+    replace(start, count, lines) {
+        let removed;
+        if (lines.length <= SPREAD_LIMIT) {
+            removed = this.lines.splice(start, count, ...lines);
+        }
+        else {
+            removed = this.lines.slice(start, start + count);
+            this.lines = [...this.lines.slice(0, start), ...lines, ...this.lines.slice(start + count)];
+        }
+        return { start, removed, inserted: lines.length };
+    }
+}

package/dist/transport.js

@@ -191,11 +191,14 @@ export function createMemoryTransportPair() {
     return [end(left, right), end(right, left)];
 }
 const MAX_SOCKET_BUFFER_BYTES = 8 * 1024 * 1024;
+/* A socket has no event for a drained buffer, so a send that waits looks again this often. */
+const DRAIN_POLL_MS = 10;
 /* JSON text frames over a WebSocket, which a browser can open and a daemon can serve. */
 export async function connectWebSocket(url, options = {}) {
     if (options.signal?.aborted) {
         throw new Error('WebSocket connection cancelled');
     }
+    const timeoutMs = options.timeoutMs ?? 10_000;
     const socket = options.createWebSocket ? options.createWebSocket(url, options.protocols) : new WebSocket(url, options.protocols);
     const events = new TransportEvents();
     socket.addEventListener('message', (event) => {
@@ -213,7 +216,7 @@ export async function connectWebSocket(url, options = {}) {
     socket.addEventListener('close', (event) => events.finish(event.code === 1000 ? undefined : new Error(`LSP WebSocket closed (${event.code})`)));
     socket.addEventListener('error', () => events.finish(new Error('LSP WebSocket failed')));
     await new Promise((resolve, reject) => {
-        const timer = setTimeout(() => fail(new Error('LSP WebSocket connection timed out')), options.timeoutMs ?? 10_000);
+        const timer = setTimeout(() => fail(new Error('LSP WebSocket connection timed out')), timeoutMs);
         const cleanup = () => {
             clearTimeout(timer);
             socket.removeEventListener('open', open);
@@ -241,13 +244,17 @@ export async function connectWebSocket(url, options = {}) {
     return {
         onMessage: (listener) => events.onMessage(listener),
         onClose: (listener) => events.onClose(listener),
-        send(message) {
+        async send(message) {
+            const deadline = Date.now() + timeoutMs;
+            while (!events.closed && socket.readyState === 1 && socket.bufferedAmount > MAX_SOCKET_BUFFER_BYTES) {
+                if (Date.now() >= deadline) {
+                    throw new Error('LSP WebSocket send buffer is full');
+                }
+                await new Promise((resolve) => setTimeout(resolve, DRAIN_POLL_MS));
+            }
             if (events.closed || socket.readyState !== 1) {
                 throw new Error('LSP WebSocket is closed');
             }
-            if (socket.bufferedAmount > MAX_SOCKET_BUFFER_BYTES) {
-                throw new Error('LSP WebSocket send buffer is full');
-            }
             socket.send(JSON.stringify(message));
         },
         close() {

package/dist/uris.js

@@ -1,18 +1,26 @@
 function isWindowsDrive(segment) {
     return /^[A-Za-z]:$/.test(segment);
 }
-/* An absolute path, POSIX or with a Windows drive, as the `file:` URI a language server names it by. */
+/* An absolute path, POSIX, with a Windows drive or UNC, as the `file:` URI a language server names it by. */
 export function pathToFileUri(path) {
-    const normalized = path.replaceAll('\\', '/');
+    // A backslash separates only in a Windows path; in a POSIX one it is part of a name.
+    const windows = /^[A-Za-z]:[\\/]/.test(path) || path.startsWith('\\\\');
+    const normalized = windows ? path.replaceAll('\\', '/') : path;
+    if (windows && normalized.startsWith('//')) {
+        const [host = '', ...segments] = normalized.slice(2).split('/');
+        return `file://${encodeURIComponent(host)}/${segments.map(encodeURIComponent).join('/')}`;
+    }
     const rooted = normalized.startsWith('/') ? normalized : `/${normalized}`;
     const segments = rooted.split('/').map((segment, index) => (index === 1 && isWindowsDrive(segment) ? segment : encodeURIComponent(segment)));
     return `file://${segments.join('/')}`;
 }
-/* The path behind a `file:` URI, in the form of the machine it names, or null for any other kind of URI. */
+/* The path behind a `file:` URI, in the form of the machine it names, or null for any other kind of URI or one that does not decode. */
 export function fileUriToPath(uri) {
     let url;
+    let path;
     try {
         url = new URL(uri);
+        path = decodeURIComponent(url.pathname);
     }
     catch {
         return null;
@@ -20,7 +28,10 @@ export function fileUriToPath(uri) {
     if (url.protocol !== 'file:') {
         return null;
     }
-    const path = decodeURIComponent(url.pathname);
+    // A server in the URI names a UNC share, which only Windows reads as a path.
+    if (url.hostname !== '' && url.hostname !== 'localhost') {
+        return `\\\\${url.hostname}${path.replaceAll('/', '\\')}`;
+    }
     if (/^\/[A-Za-z]:/.test(path)) {
         return path.slice(1).replaceAll('/', '\\');
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/lsp",
-  "version": "0.23.1",
+  "version": "0.24.0",
   "type": "module",
   "exports": {
     ".": {

package/src/document.ts

@@ -1,6 +1,7 @@
 import { ErrorCodes, LspError, StaleResultError } from './connection.ts';
-import { applyContentChanges, minimalChange } from './edits.ts';
+import { minimalChange } from './edits.ts';
 import type { LspSession } from './session.ts';
+import { TextMirror } from './text-mirror.ts';
 import type {
     CallHierarchyIncomingCall,
     CallHierarchyItem,
@@ -36,6 +37,9 @@ import type {
     WorkspaceEdit
 } from './protocol.ts';
 
+/* The delay of the VS Code language client for servers with full sync. */
+const FULL_SYNC_DELAY_MS = 200;
+
 /*
  * One open text document in one session. It owns the version: every change raises it by one, and a
  * result that arrives for an older version is refused, so nothing computed for a text that is gone
@@ -47,9 +51,10 @@ export class LspDocument {
     readonly languageId: string;
     readonly ready: Promise<void>;
     private revision: number;
-    private content: string;
+    private readonly content: TextMirror;
     private closed = false;
     private synced: Promise<void>;
+    private sendFullText?: () => void;
     private closePromise?: Promise<void>;
     private readonly inFlight = new Set<AbortController>();
     private readonly latest = new Map<string, AbortController>();
@@ -61,7 +66,7 @@ export class LspDocument {
         this.session = session;
         this.uri = item.uri;
         this.languageId = item.languageId;
-        this.content = item.text;
+        this.content = new TextMirror(item.text);
         this.revision = item.version ?? 1;
         if (!Number.isSafeInteger(this.revision) || this.revision < 0) {
             throw new LspError('Invalid document version');
@@ -78,7 +83,7 @@ export class LspDocument {
     }
 
     get text(): string {
-        return this.content;
+        return this.content.text;
     }
 
     get isClosed(): boolean {
@@ -88,15 +93,17 @@ export class LspDocument {
     /* Sends the difference to the text as the one range that changed, or the whole text to a server that wants no ranges. */
     updateText(text: string): Promise<void> {
         this.assertOpen();
-        if (text === this.content) {
+        const current = this.content.text;
+        if (text === current) {
             return this.synced;
         }
-        return this.applyChanges([minimalChange(this.content, text)]);
+        return this.applyChanges([minimalChange(current, text)]);
     }
 
     /*
      * Applies `didChange` entries in order, which a server that negotiated incremental sync gets as
-     * they are. The version goes up by one even when the text ends up the same.
+     * they are. The version goes up by one even when the text ends up the same. A server with full
+     * sync gets the whole text once the changes pause, or before the next request, save or close.
      */
     applyChanges(changes: readonly ContentChange[]): Promise<void> {
         this.assertOpen();
@@ -104,16 +111,17 @@ export class LspDocument {
         if (!kind) {
             return Promise.reject(new LspError('Server did not negotiate document changes', ErrorCodes.MethodNotFound));
         }
-        let next: string;
         try {
-            next = applyContentChanges(this.content, changes);
+            this.content.applyChanges(changes);
         } catch (error) {
             return Promise.reject(error);
         }
-        this.content = next;
         const version = ++this.revision;
         this.cancelRequests();
-        const contentChanges = kind === 1 ? [{ text: next }] : changes.map((change) => ({ ...change }));
+        if (kind === 1) {
+            return this.queueFullText();
+        }
+        const contentChanges = changes.map((change) => ({ ...change }));
         this.synced = this.synced.then(() =>
             this.session.connection.notify('textDocument/didChange', { textDocument: { uri: this.uri, version }, contentChanges })
         );
@@ -126,6 +134,7 @@ export class LspDocument {
         this.assertOpen();
         const version = this.version;
         const text = this.text;
+        this.sendFullText?.();
         await this.synced;
         this.assertCurrent(version);
         const save = this.session.syncOptions.save;
@@ -278,6 +287,7 @@ export class LspDocument {
         }
         this.closed = true;
         this.cancelRequests();
+        this.sendFullText?.();
         this.closePromise = this.synced
             .then(async () => {
                 if (!this.session.connection.isClosed && this.session.syncOptions.openClose) {
@@ -292,6 +302,7 @@ export class LspDocument {
     disconnect(): void {
         this.closed = true;
         this.cancelRequests();
+        this.sendFullText?.();
         this.session.forgetDocument(this);
     }
 
@@ -325,6 +336,7 @@ export class LspDocument {
             abort();
         }
         try {
+            this.sendFullText?.();
             await this.synced;
             this.assertCurrent(version);
             const result = await this.session.request<T>(method, params, { signal: controller.signal, timeoutMs: options.timeoutMs });
@@ -370,6 +382,33 @@ export class LspDocument {
         }
     }
 
+    /* Changes that arrive while the whole text waits go out with it, under the newest version. */
+    private queueFullText(): Promise<void> {
+        if (this.sendFullText) {
+            return this.synced;
+        }
+        const due = new Promise<void>((resolve) => {
+            const timer = setTimeout(resolve, this.session.options.fullSyncDelayMs ?? FULL_SYNC_DELAY_MS);
+            this.sendFullText = () => {
+                clearTimeout(timer);
+                resolve();
+            };
+        });
+        this.synced = this.synced
+            .then(() => due)
+            .then(async () => {
+                this.sendFullText = undefined;
+                if (!this.session.connection.isClosed) {
+                    await this.session.connection.notify('textDocument/didChange', {
+                        textDocument: { uri: this.uri, version: this.revision },
+                        contentChanges: [{ text: this.content.text }]
+                    });
+                }
+            });
+        void this.synced.catch((error) => this.session.connection.reportError(error));
+        return this.synced;
+    }
+
     private cancelRequests(): void {
         for (const controller of this.inFlight) {
             controller.abort();

package/src/edits.ts

@@ -18,11 +18,15 @@ export interface PlannedDocumentEdit {
 const CR = 13;
 const LF = 10;
 
-/* A line ends at `\n`, `\r\n` or a lone `\r`, which is how the protocol counts lines. */
-export function offsetAt(text: string, position: Position): number {
+function checkPosition(position: Position): void {
     if (!Number.isInteger(position.line) || !Number.isInteger(position.character) || position.line < 0 || position.character < 0) {
         throw new LspError('Invalid edit position');
     }
+}
+
+/* A line ends at `\n`, `\r\n` or a lone `\r`, which is how the protocol counts lines. */
+export function offsetAt(text: string, position: Position): number {
+    checkPosition(position);
     let line = 0;
     let offset = 0;
     while (line < position.line && offset < text.length) {
@@ -81,12 +85,40 @@ export function endPosition(text: string): Position {
     return positionAt(text, text.length);
 }
 
+/* `offsetAt` for many positions in one text: the starts of its lines are found once instead of on every call. */
+function offsetsIn(text: string): (position: Position) => number {
+    const starts = [0];
+    for (let i = 0; i < text.length; i++) {
+        const code = text.charCodeAt(i);
+        if (code === CR && text.charCodeAt(i + 1) === LF) {
+            i++;
+            starts.push(i + 1);
+        } else if (code === CR || code === LF) {
+            starts.push(i + 1);
+        }
+    }
+    return (position) => {
+        checkPosition(position);
+        const start = starts[position.line];
+        if (start === undefined) {
+            throw new LspError('Edit line is outside the document');
+        }
+        const next = starts[position.line + 1];
+        const end = next === undefined ? text.length : next - (text.charCodeAt(next - 1) === LF && text.charCodeAt(next - 2) === CR ? 2 : 1);
+        if (start + position.character > end) {
+            throw new LspError('Edit character is outside the line');
+        }
+        return start + position.character;
+    };
+}
+
 /* Edits are simultaneous and in the coordinates of `text`; two inserts at one place keep their order. */
 export function applyTextEdits(text: string, edits: readonly TextEdit[]): string {
+    const offsetOf = offsetsIn(text);
     const spans = edits
         .map((edit, index) => ({
-            start: offsetAt(text, edit.range.start),
-            end: offsetAt(text, edit.range.end),
+            start: offsetOf(edit.range.start),
+            end: offsetOf(edit.range.end),
             text: edit.newText,
             index
         }))

package/src/index.ts

@@ -27,6 +27,7 @@ export {
 export { createsTaken, deletesTaken, renamesTaken, type CreatedFile, type DeletedFile, type RenamedFile } from './file-operations.ts';
 export { watchesFile, type FileChangeType } from './watched-files.ts';
 export { LspSession, type LspSessionOptions, type SessionState } from './session.ts';
+export { TextMirror } from './text-mirror.ts';
 export type { DiagnosticsReport, LanguageDocument, LanguageRequestOptions, LanguageService } from './service.ts';
 export {
     ContentLengthDecoder,

package/src/session.ts

@@ -39,6 +39,8 @@ export interface LspSessionOptions {
     configuration?: Record<string, unknown>;
     clientInfo?: { name: string; version?: string };
     timeoutMs?: number;
+    /* How long the changes for a server with full sync gather before the whole text goes out; 200 by default. */
+    fullSyncDelayMs?: number;
     snippetSupport?: boolean;
     insertTextModes?: readonly (1 | 2)[];
     completionItemDefaults?: readonly string[];

package/src/test-transport.ts

@@ -1,4 +1,4 @@
-import { LspSession } from './session.ts';
+import { LspSession, type LspSessionOptions } from './session.ts';
 import type { LspTransport, RpcMessage, ServerCapabilities } from './protocol.ts';
 
 /* A transport that records what is sent and lets a test say what comes back, for tests that assert on the exact wire. */
@@ -73,10 +73,10 @@ export async function flush(): Promise<void> {
 
 export const origin = { line: 0, character: 0 };
 
-export async function sessionWith(capabilities: ServerCapabilities = {}) {
+export async function sessionWith(capabilities: ServerCapabilities = {}, options?: LspSessionOptions) {
     const transport = new ScriptedTransport();
     transport.autoInitialize = { textDocumentSync: 2, ...capabilities };
-    const session = new LspSession(transport);
+    const session = new LspSession(transport, options);
     await session.initialize();
     return { transport, session };
 }

package/src/text-mirror.ts

@@ -0,0 +1,137 @@
+import { LspError } from './connection.ts';
+import type { ContentChange, Position } from './protocol.ts';
+
+const CR = 13;
+const LF = 10;
+
+/* Past this many lines a spread into `splice` could exceed the engine's argument limit. */
+const SPREAD_LIMIT = 10_000;
+
+/* Each line keeps its own break, so the last one is the only line without. */
+function splitLines(text: string): string[] {
+    const lines: string[] = [];
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        const code = text.charCodeAt(i);
+        if (code === CR || code === LF) {
+            if (code === CR && text.charCodeAt(i + 1) === LF) {
+                i++;
+            }
+            lines.push(text.slice(start, i + 1));
+            start = i + 1;
+        }
+    }
+    lines.push(text.slice(start));
+    return lines;
+}
+
+function breakLength(line: string): number {
+    const last = line.charCodeAt(line.length - 1);
+    if (last === LF) {
+        return line.charCodeAt(line.length - 2) === CR ? 2 : 1;
+    }
+    return last === CR ? 1 : 0;
+}
+
+interface Splice {
+    start: number;
+    removed: string[];
+    inserted: number;
+}
+
+/*
+ * The text of a document as its lines, kept up to date with `didChange` entries. A change costs the
+ * lines it touches instead of the whole text, and the text is joined only when it is read.
+ */
+export class TextMirror {
+    private lines: string[];
+    private joined: string | null;
+
+    constructor(text = '') {
+        this.lines = splitLines(text);
+        this.joined = text;
+    }
+
+    get text(): string {
+        this.joined ??= this.lines.join('');
+        return this.joined;
+    }
+
+    get lineCount(): number {
+        return this.lines.length;
+    }
+
+    /* Applies the entries in order, each in the text the one before it left. When one does not fit, it throws and the text stays as it was. */
+    applyChanges(changes: readonly ContentChange[]): void {
+        const applied: Splice[] = [];
+        try {
+            for (const change of changes) {
+                applied.push(
+                    change.range
+                        ? this.applyRange(change.range.start, change.range.end, change.text)
+                        : this.replace(0, this.lines.length, splitLines(change.text))
+                );
+                this.joined = change.range ? null : change.text;
+            }
+        } catch (error) {
+            for (const splice of applied.reverse()) {
+                this.replace(splice.start, splice.inserted, splice.removed);
+            }
+            this.joined = null;
+            throw error;
+        }
+    }
+
+    private applyRange(start: Position, end: Position, text: string): Splice {
+        const startLine = this.lineAt(start);
+        const endLine = this.lineAt(end);
+        if (end.line < start.line || (end.line === start.line && end.character < start.character)) {
+            throw new LspError('Change range is reversed');
+        }
+        const inserted = splitLines(text);
+        const last = inserted.length - 1;
+        let suffix = endLine.slice(end.character);
+        // An inserted `\r` and the `\n` after the range become one break.
+        if (text.charCodeAt(text.length - 1) === CR && suffix.charCodeAt(0) === LF) {
+            inserted[last - 1] += '\n';
+            suffix = suffix.slice(1);
+        }
+        inserted[last] += suffix;
+        inserted[0] = startLine.slice(0, start.character) + inserted[0];
+        if (inserted[last] === '' && end.line < this.lines.length - 1) {
+            inserted.pop();
+        }
+        let first = start.line;
+        // A line that ends in a lone `\r` takes a `\n` that now follows it as the rest of its break.
+        if (inserted[0] === '\n' && first > 0 && this.lines[first - 1].charCodeAt(this.lines[first - 1].length - 1) === CR) {
+            first--;
+            inserted[0] = this.lines[first] + '\n';
+        }
+        return this.replace(first, end.line - first + 1, inserted);
+    }
+
+    private lineAt(position: Position): string {
+        if (!Number.isInteger(position.line) || !Number.isInteger(position.character) || position.line < 0 || position.character < 0) {
+            throw new LspError('Invalid edit position');
+        }
+        const line = this.lines[position.line];
+        if (line === undefined) {
+            throw new LspError('Edit line is outside the document');
+        }
+        if (position.character > line.length - breakLength(line)) {
+            throw new LspError('Edit character is outside the line');
+        }
+        return line;
+    }
+
+    private replace(start: number, count: number, lines: string[]): Splice {
+        let removed: string[];
+        if (lines.length <= SPREAD_LIMIT) {
+            removed = this.lines.splice(start, count, ...lines);
+        } else {
+            removed = this.lines.slice(start, start + count);
+            this.lines = [...this.lines.slice(0, start), ...lines, ...this.lines.slice(start + count)];
+        }
+        return { start, removed, inserted: lines.length };
+    }
+}

package/src/transport.ts

@@ -218,17 +218,21 @@ export function createMemoryTransportPair(): [LspTransport, LspTransport] {
 export interface WebSocketTransportOptions {
     protocols?: string[];
     signal?: AbortSignal;
+    /* How long the socket may take to open, and how long a send waits for a full buffer to drain. */
     timeoutMs?: number;
     createWebSocket?: (url: string, protocols?: string[]) => WebSocket;
 }
 
 const MAX_SOCKET_BUFFER_BYTES = 8 * 1024 * 1024;
+/* A socket has no event for a drained buffer, so a send that waits looks again this often. */
+const DRAIN_POLL_MS = 10;
 
 /* JSON text frames over a WebSocket, which a browser can open and a daemon can serve. */
 export async function connectWebSocket(url: string, options: WebSocketTransportOptions = {}): Promise<LspTransport> {
     if (options.signal?.aborted) {
         throw new Error('WebSocket connection cancelled');
     }
+    const timeoutMs = options.timeoutMs ?? 10_000;
     const socket = options.createWebSocket ? options.createWebSocket(url, options.protocols) : new WebSocket(url, options.protocols);
     const events = new TransportEvents();
     socket.addEventListener('message', (event) => {
@@ -245,7 +249,7 @@ export async function connectWebSocket(url: string, options: WebSocketTransportO
     socket.addEventListener('close', (event) => events.finish(event.code === 1000 ? undefined : new Error(`LSP WebSocket closed (${event.code})`)));
     socket.addEventListener('error', () => events.finish(new Error('LSP WebSocket failed')));
     await new Promise<void>((resolve, reject) => {
-        const timer = setTimeout(() => fail(new Error('LSP WebSocket connection timed out')), options.timeoutMs ?? 10_000);
+        const timer = setTimeout(() => fail(new Error('LSP WebSocket connection timed out')), timeoutMs);
         const cleanup = (): void => {
             clearTimeout(timer);
             socket.removeEventListener('open', open);
@@ -273,13 +277,17 @@ export async function connectWebSocket(url: string, options: WebSocketTransportO
     return {
         onMessage: (listener) => events.onMessage(listener),
         onClose: (listener) => events.onClose(listener),
-        send(message) {
+        async send(message) {
+            const deadline = Date.now() + timeoutMs;
+            while (!events.closed && socket.readyState === 1 && socket.bufferedAmount > MAX_SOCKET_BUFFER_BYTES) {
+                if (Date.now() >= deadline) {
+                    throw new Error('LSP WebSocket send buffer is full');
+                }
+                await new Promise((resolve) => setTimeout(resolve, DRAIN_POLL_MS));
+            }
             if (events.closed || socket.readyState !== 1) {
                 throw new Error('LSP WebSocket is closed');
             }
-            if (socket.bufferedAmount > MAX_SOCKET_BUFFER_BYTES) {
-                throw new Error('LSP WebSocket send buffer is full');
-            }
             socket.send(JSON.stringify(message));
         },
         close() {

package/src/uris.ts

@@ -2,26 +2,37 @@ function isWindowsDrive(segment: string): boolean {
     return /^[A-Za-z]:$/.test(segment);
 }
 
-/* An absolute path, POSIX or with a Windows drive, as the `file:` URI a language server names it by. */
+/* An absolute path, POSIX, with a Windows drive or UNC, as the `file:` URI a language server names it by. */
 export function pathToFileUri(path: string): string {
-    const normalized = path.replaceAll('\\', '/');
+    // A backslash separates only in a Windows path; in a POSIX one it is part of a name.
+    const windows = /^[A-Za-z]:[\\/]/.test(path) || path.startsWith('\\\\');
+    const normalized = windows ? path.replaceAll('\\', '/') : path;
+    if (windows && normalized.startsWith('//')) {
+        const [host = '', ...segments] = normalized.slice(2).split('/');
+        return `file://${encodeURIComponent(host)}/${segments.map(encodeURIComponent).join('/')}`;
+    }
     const rooted = normalized.startsWith('/') ? normalized : `/${normalized}`;
     const segments = rooted.split('/').map((segment, index) => (index === 1 && isWindowsDrive(segment) ? segment : encodeURIComponent(segment)));
     return `file://${segments.join('/')}`;
 }
 
-/* The path behind a `file:` URI, in the form of the machine it names, or null for any other kind of URI. */
+/* The path behind a `file:` URI, in the form of the machine it names, or null for any other kind of URI or one that does not decode. */
 export function fileUriToPath(uri: string): string | null {
     let url: URL;
+    let path: string;
     try {
         url = new URL(uri);
+        path = decodeURIComponent(url.pathname);
     } catch {
         return null;
     }
     if (url.protocol !== 'file:') {
         return null;
     }
-    const path = decodeURIComponent(url.pathname);
+    // A server in the URI names a UNC share, which only Windows reads as a path.
+    if (url.hostname !== '' && url.hostname !== 'localhost') {
+        return `\\\\${url.hostname}${path.replaceAll('/', '\\')}`;
+    }
     if (/^\/[A-Za-z]:/.test(path)) {
         return path.slice(1).replaceAll('/', '\\');
     }