@hydranium/protocol 1.0.0-next.33 → 1.0.0-next.330

package/lib/clock.d.ts

@@ -12,9 +12,11 @@ import { Disposable } from './util';
  * there is no `start` — you create it at the moment timing begins.
  *
  * Backed by a monotonic source (`performance.now`), so it is sub-millisecond
- * precise and immune to wall-clock jumps (NTP/DST adjustments can make a
- * `Date.now` delta go backwards; a stopwatch cannot). Use this for durations
- * and {@link Clock.now} for "what time is it" (timestamps, TTLs).
+ * precise and immune to wall-clock steps (a time sync or a manual change can
+ * make a `Date.now` delta go backwards; a stopwatch cannot). In Node on Linux
+ * it also leaves out time the system spends suspended, so a duration spanning
+ * a suspend reads as the awake time only. Use this for every duration, a TTL
+ * included, and {@link Clock.now} for "what time is it".
  *
  * It holds no scheduled resource and is therefore NOT a {@link Disposable} —
  * the disposable thing is a {@link Clock.setTimer}. Reads are lazy, so a fake
@@ -42,16 +44,16 @@ export interface Stopwatch {
  * testable instead of waiting on real wall-clock. The {@link SystemClock}
  * default delegates to the platform; tests bind `makeFakeClock`.
  *
- * Two distinct readings on purpose: {@link now} is wall-clock (for timestamps
- * and TTLs that compare against a file's mtime), while {@link stopwatch}
- * measures durations off a monotonic source. They are different clocks; do not
- * subtract two {@link now} readings to measure a duration.
+ * Two distinct readings on purpose: {@link now} is wall-clock, for a
+ * timestamp, while {@link stopwatch} measures durations off a monotonic
+ * source. They are different clocks; do not subtract two {@link now} readings
+ * to measure a duration. Framework code reads time only through a `Clock`, so
+ * a platform workaround lives in one place.
  *
  * A cross-head contract, so it carries no platform or DI-framework coupling.
  *
- * Note: the runtime health monitors (event-loop, memory) intentionally keep
- * the real wall-clock rather than taking a `Clock` — faking the time they
- * measure would invert their meaning.
+ * Note: code that measures real CPU, heap or event-loop time never takes the
+ * bound `Clock`: faking the time it measures would invert its meaning.
  */
 export interface Clock {
     /** Current wall-clock time in milliseconds (the `Date.now` reading). */
@@ -73,7 +75,28 @@ export interface Clock {
      */
     measure<T>(callback: () => Promise<T>): Promise<Timed<T>>;
     measure<T>(callback: () => T): Timed<T>;
+    /**
+     * Settle with `promise`, or with {@link TIMED_OUT} once `ms` have elapsed
+     * first. A promise that rejects first rejects this one; one that rejects
+     * after the timer is ignored. The timer is disposed the moment `promise`
+     * settles, so a won race leaves nothing scheduled, but `promise` itself
+     * runs on: nothing here can cancel it.
+     *
+     * Unlike VS Code's `raceTimeout`, this settles with a sentinel rather than
+     * `undefined`, so a promise resolving to `undefined` is not taken for a
+     * timeout; the caller branches on the result instead of passing an
+     * `onTimeout`.
+     *
+     * A custom implementation extends {@link SystemClock}, whose race runs over
+     * the subclass's {@link setTimer}.
+     */
+    raceTimer<T>(promise: Promise<T>, ms: number): Promise<T | typeof TIMED_OUT>;
 }
+/**
+ * What {@link Clock.raceTimer} settles with when its timer fires first.
+ * Registered under a global key, so two copies of this package agree on it.
+ */
+export declare const TIMED_OUT: unique symbol;
 /**
  * The result of {@link Clock.measure}: a callback's return value paired with
  * its elapsed wall-time in milliseconds. A plain value object — no methods, no
@@ -100,6 +123,10 @@ export interface Timed<T> {
  * Default {@link Clock}: delegates to the platform's `Date.now`,
  * `performance.now`, and `setTimeout`/`clearTimeout`. Bound everywhere in
  * production; swapped for `makeFakeClock` in tests.
+ *
+ * {@link measure} and {@link raceTimer} run over {@link stopwatch} and
+ * {@link setTimer}, so a clock that extends this one and replaces those
+ * measures and races on its own time, as the test clock does.
  */
 export declare class SystemClock implements Clock {
     now(): number;
@@ -107,5 +134,18 @@ export declare class SystemClock implements Clock {
     stopwatch(): Stopwatch;
     measure<T>(callback: () => Promise<T>): Promise<Timed<T>>;
     measure<T>(callback: () => T): Timed<T>;
+    /**
+     * The timer settles the race one microtask after it fires. A real timer
+     * runs only once pending resolutions are delivered, while a fake one fires
+     * inside its `advance`, so settling at once would let a promise already
+     * resolved when `advance` runs lose to a timer it beats in production. The
+     * deferral covers only that promise: one that settles through further
+     * chained reactions, such as a `.then` chain, an async function or
+     * `Promise.allSettled`, can still lose to an `advance` in the same turn,
+     * while it wins on the platform's timer. The handlers go on `promise`
+     * before {@link setTimer} runs, so a `setTimer` that throws still leaves
+     * `promise` observed.
+     */
+    raceTimer<T>(promise: Promise<T>, ms: number): Promise<T | typeof TIMED_OUT>;
 }
 //# sourceMappingURL=clock.d.ts.map

package/lib/clock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clock.d.ts","sourceRoot":"","sources":["../src/clock.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEpC;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,SAAS;IACvB,mFAAmF;IACnF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,GAAG,IAAI,MAAM,CAAC;IACd;;;;OAIG;IACH,IAAI,IAAI,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,KAAK;IACnB,wEAAwE;IACxE,GAAG,IAAI,MAAM,CAAC;IACd;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,CAAC;IACvD,yDAAyD;IACzD,SAAS,IAAI,SAAS,CAAC;IACvB;;;;;;OAMG;IACH,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1D,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;CAC1C;AAED;;;;;GAKG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC;IACrB;;;;;OAKG;IACH,MAAM,EAAE,CAAC,CAAC;IACV;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAC;CACpB;AAyCD;;;;GAIG;AACH,qBAAa,WAAY,YAAW,KAAK;IACtC,GAAG,IAAI,MAAM;IAIb,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU;IAMtD,SAAS,IAAI,SAAS;IAItB,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACzD,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;CASzC"}
+{"version":3,"file":"clock.d.ts","sourceRoot":"","sources":["../src/clock.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEpC;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,SAAS;IACvB,mFAAmF;IACnF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,GAAG,IAAI,MAAM,CAAC;IACd;;;;OAIG;IACH,IAAI,IAAI,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,KAAK;IACnB,wEAAwE;IACxE,GAAG,IAAI,MAAM,CAAC;IACd;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,CAAC;IACvD,yDAAyD;IACzD,SAAS,IAAI,SAAS,CAAC;IACvB;;;;;;OAMG;IACH,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1D,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IACxC;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,OAAO,SAAS,CAAC,CAAC;CAC/E;AAED;;;GAGG;AACH,eAAO,MAAM,SAAS,eAA6C,CAAC;AAEpE;;;;;GAKG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC;IACrB;;;;;OAKG;IACH,MAAM,EAAE,CAAC,CAAC;IACV;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAC;CACpB;AAyCD;;;;;;;;GAQG;AACH,qBAAa,WAAY,YAAW,KAAK;IACtC,GAAG,IAAI,MAAM,CAEZ;IAED,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,CAIrD;IAED,SAAS,IAAI,SAAS,CAErB;IAED,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1D,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAUxC;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,OAAO,SAAS,CAAC,CAgB3E;CACH"}

package/lib/clock.js

@@ -8,8 +8,13 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SystemClock = void 0;
+exports.SystemClock = exports.TIMED_OUT = void 0;
 const util_1 = require("./util");
+/**
+ * What {@link Clock.raceTimer} settles with when its timer fires first.
+ * Registered under a global key, so two copies of this package agree on it.
+ */
+exports.TIMED_OUT = Symbol.for('hydranium/protocol/timed-out');
 class SystemStopwatch {
     start = performance.now();
     lastLap = this.start;
@@ -48,6 +53,10 @@ function unrefTimer(handle) {
  * Default {@link Clock}: delegates to the platform's `Date.now`,
  * `performance.now`, and `setTimeout`/`clearTimeout`. Bound everywhere in
  * production; swapped for `makeFakeClock` in tests.
+ *
+ * {@link measure} and {@link raceTimer} run over {@link stopwatch} and
+ * {@link setTimer}, so a clock that extends this one and replaces those
+ * measures and races on its own time, as the test clock does.
  */
 class SystemClock {
     now() {
@@ -69,6 +78,32 @@ class SystemClock {
         }
         return { result: result, elapsedMs: stopwatch.elapsedMs };
     }
+    /**
+     * The timer settles the race one microtask after it fires. A real timer
+     * runs only once pending resolutions are delivered, while a fake one fires
+     * inside its `advance`, so settling at once would let a promise already
+     * resolved when `advance` runs lose to a timer it beats in production. The
+     * deferral covers only that promise: one that settles through further
+     * chained reactions, such as a `.then` chain, an async function or
+     * `Promise.allSettled`, can still lose to an `advance` in the same turn,
+     * while it wins on the platform's timer. The handlers go on `promise`
+     * before {@link setTimer} runs, so a `setTimer` that throws still leaves
+     * `promise` observed.
+     */
+    raceTimer(promise, ms) {
+        return new Promise((resolve, reject) => {
+            // eslint-disable-next-line prefer-const -- with a `const`, a `setTimer` that throws leaves it uninitialised, and the handlers' later read of it is an unhandled ReferenceError
+            let timer;
+            promise.then(value => {
+                timer?.dispose();
+                resolve(value);
+            }, (err) => {
+                timer?.dispose();
+                reject(err);
+            });
+            timer = this.setTimer(() => void Promise.resolve().then(() => resolve(exports.TIMED_OUT)), ms);
+        });
+    }
 }
 exports.SystemClock = SystemClock;
 //# sourceMappingURL=clock.js.map

package/lib/clock.js.map

@@ -1 +1 @@
-{"version":3,"file":"clock.js","sourceRoot":"","sources":["../src/clock.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;AAElF,iCAAoC;AA8FpC,MAAM,eAAe;IACC,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;IACnC,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC;IACrB,OAAO,CAAqB;IAEtC,IAAI,SAAS;QACV,OAAO,CAAC,IAAI,CAAC,OAAO,IAAI,WAAW,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC;IAC3D,CAAC;IAED,GAAG;QACA,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,IAAI,WAAW,CAAC,GAAG,EAAE,CAAC;QAC7C,MAAM,KAAK,GAAG,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;QAChC,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QAClB,OAAO,KAAK,CAAC;IAChB,CAAC;IAED,IAAI;QACD,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAC9B,IAAI,CAAC,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QACpC,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC;IACpC,CAAC;CACH;AAED;;;;;;;;;;GAUG;AACH,SAAS,UAAU,CAAC,MAA8B;IAC/C,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC;AACpB,CAAC;AAED;;;;GAIG;AACH,MAAa,WAAW;IACrB,GAAG;QACA,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC;IACrB,CAAC;IAED,QAAQ,CAAC,QAAoB,EAAE,EAAU;QACtC,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QACxC,UAAU,CAAC,MAAM,CAAC,CAAC;QACnB,OAAO,iBAAU,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;IACxD,CAAC;IAED,SAAS;QACN,OAAO,IAAI,eAAe,EAAE,CAAC;IAChC,CAAC;IAID,OAAO,CAAI,QAA8B;QACtC,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QACnC,MAAM,MAAM,GAAG,QAAQ,EAAE,CAAC;QAC1B,IAAI,MAAM,YAAY,OAAO,EAAE,CAAC;YAC7B,OAAQ,MAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;QACpG,CAAC;QACD,OAAO,EAAE,MAAM,EAAE,MAAW,EAAE,SAAS,EAAE,SAAS,CAAC,SAAS,EAAE,CAAC;IAClE,CAAC;CACH;AAzBD,kCAyBC"}
+{"version":3,"file":"clock.js","sourceRoot":"","sources":["../src/clock.ts"],"names":[],"mappings":"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"}

package/lib/console-logger.d.ts

@@ -0,0 +1,23 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import { AbstractLogger } from './abstract-logger';
+import { type LogLevel, type Logger } from './logger';
+/**
+ * {@link Logger} that writes each line to `console`, at the method matching its
+ * level: the framework's `[Label - time] [component]` prefix and the message,
+ * then any trailing arguments as they are, so a browser console can expand
+ * them. For a browser page, webview or extension host, which has no other sink
+ * to hand. On Node, `info` and `debug` reach stdout, so a process whose stdout
+ * carries a protocol stream must not use it.
+ */
+export declare class ConsoleLogger extends AbstractLogger implements Logger {
+    protected emit(level: LogLevel, label: string, message: string, args: readonly unknown[]): void;
+    protected derive(component: string): this;
+}
+//# sourceMappingURL=console-logger.d.ts.map

package/lib/console-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-logger.d.ts","sourceRoot":"","sources":["../src/console-logger.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AAWtD;;;;;;;GAOG;AACH,qBAAa,aAAc,SAAQ,cAAe,YAAW,MAAM;IAChE,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI,CAE9F;IAED,SAAS,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAGxC;CACH"}

package/lib/console-logger.js

@@ -0,0 +1,39 @@
+"use strict";
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = void 0;
+const abstract_logger_1 = require("./abstract-logger");
+/** `console.trace` prints a stack with every line, so `trace` goes out at `debug`. */
+const CONSOLE_METHODS = {
+    error: 'error',
+    warn: 'warn',
+    info: 'info',
+    debug: 'debug',
+    trace: 'debug'
+};
+/**
+ * {@link Logger} that writes each line to `console`, at the method matching its
+ * level: the framework's `[Label - time] [component]` prefix and the message,
+ * then any trailing arguments as they are, so a browser console can expand
+ * them. For a browser page, webview or extension host, which has no other sink
+ * to hand. On Node, `info` and `debug` reach stdout, so a process whose stdout
+ * carries a protocol stream must not use it.
+ */
+class ConsoleLogger extends abstract_logger_1.AbstractLogger {
+    emit(level, label, message, args) {
+        console[CONSOLE_METHODS[level]](`${this.formatLinePrefix(label)} ${message}`, ...args);
+    }
+    derive(component) {
+        const Subclass = this.constructor;
+        return new Subclass(component);
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
+//# sourceMappingURL=console-logger.js.map

package/lib/console-logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-logger.js","sourceRoot":"","sources":["../src/console-logger.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;AAElF,uDAAmD;AAGnD,sFAAsF;AACtF,MAAM,eAAe,GAA0D;IAC5E,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;CAChB,CAAC;AAEF;;;;;;;GAOG;AACH,mBAA2B,SAAQ,gCAAc;IACpC,IAAI,CAAC,KAAe,EAAE,KAAa,EAAE,OAAe,EAAE,IAAwB;QACrF,OAAO,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,IAAI,OAAO,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC;IAC1F,CAAC;IAES,MAAM,CAAC,SAAiB;QAC/B,MAAM,QAAQ,GAAG,IAAI,CAAC,WAA+C,CAAC;QACtE,OAAO,IAAI,QAAQ,CAAC,SAAS,CAAC,CAAC;IAClC,CAAC;CACH"}

package/lib/data/data-protocol-methods.d.ts

@@ -7,7 +7,7 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 /** Request-method names on {@link DocumentServerProtocol}. */
-export declare const DOCUMENT_SERVER_PROTOCOL_METHODS: readonly ["openModelDocument", "closeModelDocument", "getModelDocument", "updateModelDocument", "saveModelDocument", "watchModelDocument", "unwatchModelDocument", "waitForReady"];
+export declare const DOCUMENT_SERVER_PROTOCOL_METHODS: readonly ["createSession", "closeSession", "createModelDocument", "updateModelDocuments", "openModelDocument", "closeModelDocument", "getModelDocument", "updateModelDocument", "saveModelDocument", "persistModelDocument", "deleteModelDocument", "watchModelDocument", "unwatchModelDocument", "waitForReady"];
 /** Request-method names on {@link ProjectServerProtocol}. */
 export declare const PROJECT_SERVER_PROTOCOL_METHODS: readonly ["getProjects", "getProjectForUri"];
 /**
@@ -16,7 +16,7 @@ export declare const PROJECT_SERVER_PROTOCOL_METHODS: readonly ["getProjects", "
  * constraint makes the array typed against the interface — stale names (typos,
  * renamed methods) fail to typecheck.
  */
-export declare const DATA_SERVER_PROTOCOL_METHODS: readonly ["openModelDocument", "closeModelDocument", "getModelDocument", "updateModelDocument", "saveModelDocument", "watchModelDocument", "unwatchModelDocument", "waitForReady", "getProjects", "getProjectForUri"];
+export declare const DATA_SERVER_PROTOCOL_METHODS: readonly ["createSession", "closeSession", "createModelDocument", "updateModelDocuments", "openModelDocument", "closeModelDocument", "getModelDocument", "updateModelDocument", "saveModelDocument", "persistModelDocument", "deleteModelDocument", "watchModelDocument", "unwatchModelDocument", "waitForReady", "getProjects", "getProjectForUri"];
 /**
  * Request-method names on {@link ReferenceServerProtocol}. NOT part of
  * {@link DATA_SERVER_PROTOCOL_METHODS} — adopters that compose the reference
@@ -25,7 +25,7 @@ export declare const DATA_SERVER_PROTOCOL_METHODS: readonly ["openModelDocument"
  */
 export declare const REFERENCE_SERVER_PROTOCOL_METHODS: readonly ["findReferenceCandidates", "resolveReference", "findNextName"];
 /** Notification-method names on {@link DocumentClientProtocol}. */
-export declare const DOCUMENT_CLIENT_PROTOCOL_METHODS: readonly ["onDocumentUpdated", "onDocumentSaved"];
+export declare const DOCUMENT_CLIENT_PROTOCOL_METHODS: readonly ["onDocumentUpdated", "onDocumentSaved", "onDocumentDirtyChanged", "onDocumentDeleted", "onDocumentsBuilt"];
 /** Notification-method names on {@link ProjectClientProtocol}. */
 export declare const PROJECT_CLIENT_PROTOCOL_METHODS: readonly ["onProjectsChanged"];
 /**
@@ -35,5 +35,5 @@ export declare const PROJECT_CLIENT_PROTOCOL_METHODS: readonly ["onProjectsChang
  * data head's connection routes `<methodNamespace>onDocumentUpdated` etc. to
  * the bound client target.
  */
-export declare const DATA_CLIENT_PROTOCOL_METHODS: readonly ["onDocumentUpdated", "onDocumentSaved", "onProjectsChanged"];
+export declare const DATA_CLIENT_PROTOCOL_METHODS: readonly ["onDocumentUpdated", "onDocumentSaved", "onDocumentDirtyChanged", "onDocumentDeleted", "onDocumentsBuilt", "onProjectsChanged"];
 //# sourceMappingURL=data-protocol-methods.d.ts.map

package/lib/data/data-protocol-methods.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data-protocol-methods.d.ts","sourceRoot":"","sources":["../../src/data/data-protocol-methods.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAalF,8DAA8D;AAC9D,eAAO,MAAM,gCAAgC,oLAS6C,CAAC;AAE3F,6DAA6D;AAC7D,eAAO,MAAM,+BAA+B,8CAE3C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,uNAG6C,CAAC;AAEvF;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,0EAI6C,CAAC;AAE5F,mEAAmE;AACnE,eAAO,MAAM,gCAAgC,mDAE5C,CAAC;AAEF,kEAAkE;AAClE,eAAO,MAAM,+BAA+B,gCAA+F,CAAC;AAE5I;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,wEAG6C,CAAC"}
+{"version":3,"file":"data-protocol-methods.d.ts","sourceRoot":"","sources":["../../src/data/data-protocol-methods.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAalF,8DAA8D;AAC9D,eAAO,MAAM,gCAAgC,mTAe6C,CAAC;AAE3F,6DAA6D;AAC7D,eAAO,MAAM,+BAA+B,8CAE3C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,sVAG6C,CAAC;AAEvF;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,0EAI4B,CAAC;AAE3E,mEAAmE;AACnE,eAAO,MAAM,gCAAgC,sHAM6C,CAAC;AAE3F,kEAAkE;AAClE,eAAO,MAAM,+BAA+B,gCAA+F,CAAC;AAE5I;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,2IAG6C,CAAC"}

package/lib/data/data-protocol-methods.js

@@ -11,11 +11,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DATA_CLIENT_PROTOCOL_METHODS = exports.PROJECT_CLIENT_PROTOCOL_METHODS = exports.DOCUMENT_CLIENT_PROTOCOL_METHODS = exports.REFERENCE_SERVER_PROTOCOL_METHODS = exports.DATA_SERVER_PROTOCOL_METHODS = exports.PROJECT_SERVER_PROTOCOL_METHODS = exports.DOCUMENT_SERVER_PROTOCOL_METHODS = void 0;
 /** Request-method names on {@link DocumentServerProtocol}. */
 exports.DOCUMENT_SERVER_PROTOCOL_METHODS = [
+    'createSession',
+    'closeSession',
+    'createModelDocument',
+    'updateModelDocuments',
     'openModelDocument',
     'closeModelDocument',
     'getModelDocument',
     'updateModelDocument',
     'saveModelDocument',
+    'persistModelDocument',
+    'deleteModelDocument',
     'watchModelDocument',
     'unwatchModelDocument',
     'waitForReady'
@@ -44,7 +50,13 @@ exports.REFERENCE_SERVER_PROTOCOL_METHODS = [
     'findNextName'
 ];
 /** Notification-method names on {@link DocumentClientProtocol}. */
-exports.DOCUMENT_CLIENT_PROTOCOL_METHODS = ['onDocumentUpdated', 'onDocumentSaved'];
+exports.DOCUMENT_CLIENT_PROTOCOL_METHODS = [
+    'onDocumentUpdated',
+    'onDocumentSaved',
+    'onDocumentDirtyChanged',
+    'onDocumentDeleted',
+    'onDocumentsBuilt'
+];
 /** Notification-method names on {@link ProjectClientProtocol}. */
 exports.PROJECT_CLIENT_PROTOCOL_METHODS = ['onProjectsChanged'];
 /**

package/lib/data/data-protocol-methods.js.map

@@ -1 +1 @@
-{"version":3,"file":"data-protocol-methods.js","sourceRoot":"","sources":["../../src/data/data-protocol-methods.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;AAalF,8DAA8D;AACjD,QAAA,gCAAgC,GAAG;IAC7C,mBAAmB;IACnB,oBAAoB;IACpB,kBAAkB;IAClB,qBAAqB;IACrB,mBAAmB;IACnB,oBAAoB;IACpB,sBAAsB;IACtB,cAAc;CACyE,CAAC;AAE3F,6DAA6D;AAChD,QAAA,+BAA+B,GAAG,CAAC,aAAa,EAAE,kBAAkB,CAEhF,CAAC;AAEF;;;;;GAKG;AACU,QAAA,4BAA4B,GAAG;IACzC,GAAG,wCAAgC;IACnC,GAAG,uCAA+B;CACiD,CAAC;AAEvF;;;;;GAKG;AACU,QAAA,iCAAiC,GAAG;IAC9C,yBAAyB;IACzB,kBAAkB;IAClB,cAAc;CAC0E,CAAC;AAE5F,mEAAmE;AACtD,QAAA,gCAAgC,GAAG,CAAC,mBAAmB,EAAE,iBAAiB,CAEtF,CAAC;AAEF,kEAAkE;AACrD,QAAA,+BAA+B,GAAG,CAAC,mBAAmB,CAAwE,CAAC;AAE5I;;;;;;GAMG;AACU,QAAA,4BAA4B,GAAG;IACzC,GAAG,wCAAgC;IACnC,GAAG,uCAA+B;CACiD,CAAC"}
+{"version":3,"file":"data-protocol-methods.js","sourceRoot":"","sources":["../../src/data/data-protocol-methods.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;AAalF,8DAA8D;AACjD,QAAA,gCAAgC,GAAG;IAC7C,eAAe;IACf,cAAc;IACd,qBAAqB;IACrB,sBAAsB;IACtB,mBAAmB;IACnB,oBAAoB;IACpB,kBAAkB;IAClB,qBAAqB;IACrB,mBAAmB;IACnB,sBAAsB;IACtB,qBAAqB;IACrB,oBAAoB;IACpB,sBAAsB;IACtB,cAAc;CACyE,CAAC;AAE3F,6DAA6D;AAChD,QAAA,+BAA+B,GAAG,CAAC,aAAa,EAAE,kBAAkB,CAEhF,CAAC;AAEF;;;;;GAKG;AACU,QAAA,4BAA4B,GAAG;IACzC,GAAG,QAAA,gCAAgC;IACnC,GAAG,QAAA,+BAA+B;CACiD,CAAC;AAEvF;;;;;GAKG;AACU,QAAA,iCAAiC,GAAG;IAC9C,yBAAyB;IACzB,kBAAkB;IAClB,cAAc;CACyD,CAAC;AAE3E,mEAAmE;AACtD,QAAA,gCAAgC,GAAG;IAC7C,mBAAmB;IACnB,iBAAiB;IACjB,wBAAwB;IACxB,mBAAmB;IACnB,kBAAkB;CACqE,CAAC;AAE3F,kEAAkE;AACrD,QAAA,+BAA+B,GAAG,CAAC,mBAAmB,CAAwE,CAAC;AAE5I;;;;;;GAMG;AACU,QAAA,4BAA4B,GAAG;IACzC,GAAG,QAAA,gCAAgC;IACnC,GAAG,QAAA,+BAA+B;CACiD,CAAC"}

package/lib/data/data-server-protocol.d.ts

@@ -9,11 +9,11 @@
 import type { TransferDiagnostic } from '../transfer-diagnostic';
 import type { TransferElement } from '../transfer-element';
 import type { Project } from '../project';
-import type { TransferDocument } from '../transfer-document';
+import type { TransferCreatedDocument, TransferDocument, TransferSavedDocument, TransferWatchedDocument } from '../transfer-document';
 import type { CloseModelArgs, FindNextNameArgs, OpenModelArgs, ReferenceContext, ReferenceRequest } from '../model-server';
 import type { ReferenceCandidate, ReferenceTarget } from '../model-service/reference-candidate';
-import type { ProjectsChangedEvent, TransferDocumentSavedEvent, TransferDocumentUpdatedEvent } from './events';
-import type { GetModelDocumentArgs, GetProjectForUriArgs, TransferSaveDocumentArgs, WatchModelDocumentArgs, TransferUpdateDocumentArgs } from './requests';
+import type { ProjectsChangedEvent, TransferDocumentDeletedEvent, TransferDocumentDirtyChangedEvent, TransferDocumentSavedEvent, TransferDocumentsBuiltEvent, TransferDocumentUpdatedEvent } from './events';
+import type { CloseSessionArgs, CreateModelDocumentArgs, CreateSessionArgs, GetModelDocumentArgs, GetProjectForUriArgs, TransferDeleteDocumentArgs, TransferPersistDocumentArgs, TransferSaveDocumentArgs, WatchModelDocumentArgs, TransferUpdateDocumentArgs, TransferUpdateDocumentsArgs } from './requests';
 /**
  * Document-scoped slice of the data-server wire contract: the per-document
  * lifecycle (get / update / save), the per-`(uri, clientId)` watch
@@ -32,34 +32,74 @@ import type { GetModelDocumentArgs, GetProjectForUriArgs, TransferSaveDocumentAr
  */
 export interface DocumentServerProtocol<TTransfer extends TransferElement, TDiagnostic extends TransferDiagnostic = TransferDiagnostic> {
     /**
-     * Open a document for an editor session and return its current state.
-     * Registers `(uri, clientId)` with the multi-client document manager
-     * (so concurrent editors share one built document) and returns the
-     * document at the server's configured target phase — the same shape
-     * {@link getModelDocument} returns, except that `version` is taken from
-     * the text-document store so the caller's first `baseVersion` write
-     * cannot self-conflict. Idempotent in registration terms: opening an
-     * already-open document refreshes the client registration. Note it does
-     * NOT avoid a rebuild — a second client attaching triggers
-     * `refreshContent`, which fires a change event, so mounting a form on a
-     * document already open in a text editor rebuilds it.
+     * Register `args.clientId` as a client session owned by this connection.
+     * Rejects with a `DuplicateClientIdError` code when the id is live anywhere
+     * in the server process, and with a `ReservedClientIdError` code when the
+     * framework reserves it.
      *
-     * The default `DataServer` impl delegates to `ModelService.open` then
-     * reads the built state. Pair with {@link watchModelDocument} to receive
-     * subsequent build-phase events (open returns a one-shot snapshot;
-     * later validation diagnostics arrive on the watch channel).
+     * A request carrying a registered id acts as that session: it writes only
+     * what the session has open, failing with a `DocumentNotOpenError` code
+     * otherwise, and opens nothing implicitly; its open reads the file and takes
+     * no `languageId`, `version` or `text` seed. The session ends with
+     * {@link closeSession} or when the connection closes, and either closes
+     * every document it has open.
+     *
+     * A registration carrying the `resumeToken` an earlier registration of the
+     * same id carried ends that session first, from any connection, so a client
+     * whose connection dropped can register again before the server notices.
+     */
+    createSession(args: CreateSessionArgs): Promise<void>;
+    /**
+     * End a session this connection registered: close every document it has
+     * open, drop its watches, and free its id. A no-op for an id this
+     * connection did not register.
      */
-    openModelDocument(args: OpenModelArgs): Promise<TransferDocument<TTransfer, TDiagnostic>>;
+    closeSession(args: CloseSessionArgs): Promise<void>;
     /**
-     * Close an editor session for `(uri, clientId)`. Counterpart to
-     * {@link openModelDocument}; the underlying document stays built until
-     * every registered client has closed. The default `DataServer` impl
-     * delegates to `ModelService.close` and ALSO releases any watch for the
-     * same `(uri, clientId)` (closing a session frees its own watch — a
-     * forgotten {@link unwatchModelDocument} would otherwise leak dispatch;
-     * the implicit unwatch is idempotent). `watchModelDocument` is NOT
-     * coupled the other way: opening does not force a watch, so a snapshot
-     * reader can open without streaming.
+     * Create a document with `args.text`, open for the session, and return it
+     * as {@link openModelDocument} does, with the version the create made in
+     * `created`. The answer is read after the create, so it can already hold
+     * another client's write or an integrity repair; a write based on
+     * `created.version` then conflicts. It reaches disk with the first save.
+     * Fails when the file exists or any client has the URI open, and with a
+     * `SessionClosedError` code when `args.clientId` is not a session
+     * registered on this connection.
+     */
+    createModelDocument(args: CreateModelDocumentArgs): Promise<TransferCreatedDocument<TTransfer, TDiagnostic>>;
+    /**
+     * Write several documents the session has open, all or none: a conflict or
+     * a document not open fails the whole set before any text applies.
+     * Resolves to the documents in the order given, once the language client
+     * has answered the push of each, or the server-side bound on that wait
+     * passes, as {@link updateModelDocument} does. Only for a session
+     * registered on this connection.
+     */
+    updateModelDocuments(args: TransferUpdateDocumentsArgs<TTransfer>): Promise<TransferDocument<TTransfer, TDiagnostic>[]>;
+    /**
+     * Open a document for the client session `clientId` and return its current
+     * state. `clientId` must be a session this connection registered with
+     * {@link createSession}; any other id fails with the closed-session code,
+     * as every document request here does. The document is read from disk
+     * unless a client has it open already, so the request carries no
+     * `languageId`, `version` or `text` seed. Returns the document at
+     * the server's configured target phase, as {@link getModelDocument} does.
+     * A repeat open changes nothing.
+     *
+     * Pair with {@link watchModelDocument} to receive subsequent build-phase
+     * events (open returns a one-shot snapshot; later validation diagnostics
+     * arrive on the watch channel).
+     */
+    openModelDocument(args: Pick<OpenModelArgs, 'uri' | 'clientId' | 'options'>): Promise<TransferDocument<TTransfer, TDiagnostic>>;
+    /**
+     * Close the session's open of `uri`. Counterpart to
+     * {@link openModelDocument}; the document stays open until every client
+     * has closed it, and then the server releases it, by default reverting it
+     * to disk. The default
+     * `DataServer` impl ALSO releases any watch for the same
+     * `(uri, clientId)` (a forgotten {@link unwatchModelDocument} would
+     * otherwise leak dispatch; the implicit unwatch is idempotent).
+     * `watchModelDocument` is NOT coupled the other way: opening does not force
+     * a watch, so a snapshot reader can open without streaming.
      */
     closeModelDocument(args: CloseModelArgs): Promise<void>;
     /**
@@ -70,32 +110,68 @@ export interface DocumentServerProtocol<TTransfer extends TransferElement, TDiag
      */
     getModelDocument(args: GetModelDocumentArgs): Promise<TransferDocument<TTransfer, TDiagnostic>>;
     /**
-     * Update a document's content. The response carries the latest built
-     * state including diagnostics; callers observe convergence via that
-     * response.
+     * Update a document's content as the session `clientId`, which must have
+     * it open. The response carries the latest built state including
+     * diagnostics; callers observe convergence via that response. It is sent
+     * once the language client has answered the push of the text, or the
+     * server-side bound on that wait passes, as {@link saveModelDocument}'s
+     * is, so an editor already shows the write when it arrives.
      */
     updateModelDocument(args: TransferUpdateDocumentArgs<TTransfer>): Promise<TransferDocument<TTransfer, TDiagnostic>>;
     /**
-     * Persist a document to disk. The response is the post-save document
-     * state (matches the file on disk). Save semantics depend on the
-     * filesystem-provider wiring; rejection paths surface as awaited
+     * Write a document as the session `clientId`, which must have it open, and
+     * persist it to disk. The response is the build of the text written, with
+     * its version in `persisted`, sent once the language client has answered
+     * the push of that text, applied or refused, or a server-side bound on
+     * that wait passes; it does not wait again for a push that wait already
+     * gave up on and the client has not answered since. Save semantics depend
+     * on the filesystem-provider wiring; rejection paths surface as awaited
      * promise rejections.
      */
-    saveModelDocument(args: TransferSaveDocumentArgs<TTransfer>): Promise<TransferDocument<TTransfer, TDiagnostic>>;
+    saveModelDocument(args: TransferSaveDocumentArgs<TTransfer>): Promise<TransferSavedDocument<TTransfer, TDiagnostic>>;
+    /**
+     * Persist the text the server holds for a document the session `clientId`
+     * has open, as it is: no update and no serialisation, so another client's
+     * unsaved text keeps its formatting. `baseVersion` is checked in the step
+     * that takes the text, so text that moved on fails with a `ConflictError`
+     * code. The saved event names this session, whoever wrote the text.
+     * Answers after the same language-client wait as {@link saveModelDocument},
+     * with the document's latest build, read after that wait, so another
+     * session's write during it shows; `persisted` carries the version written.
+     */
+    persistModelDocument(args: TransferPersistDocumentArgs): Promise<TransferSavedDocument<TTransfer, TDiagnostic>>;
+    /**
+     * Delete a document the session `clientId` has open, at once: its file,
+     * then the document, as a deletion a file watcher reports removes it. Every
+     * session's open of it closes and every client hears
+     * {@link DocumentClientProtocol.onDocumentDeleted} naming this session; the
+     * session's own watch is released, as {@link closeModelDocument} releases
+     * it. `baseVersion` is checked in the step that marks the document for
+     * deletion, so text that moved on fails with a `ConflictError` code. A file
+     * already gone deletes only the document; a file that cannot be removed
+     * fails the call and changes nothing. Resolves once the build that removes
+     * the document has run; a read then answers the URI without a model, unless
+     * an editor still has it open, whose buffer the document is built from.
+     */
+    deleteModelDocument(args: TransferDeleteDocumentArgs): Promise<void>;
     /**
      * Start watching `(uri, clientId)`. The server starts dispatching
      * {@link DocumentClientProtocol.onDocumentUpdated} on the paired wire
      * for every build-phase event on `uri`.
      *
-     * Returns `Promise<void>` — the bidirectional pattern means the event
-     * channel is the client interface, not a returned handle. Callers fan
-     * out a single inbound `onDocumentUpdated` to multiple local listeners
-     * with their own `Emitter<T>` (matching Theia's pattern). Pair every
-     * `watchModelDocument` with {@link unwatchModelDocument} when no longer
-     * needed; the server holds the watch record until the matching unwatch
-     * lands.
+     * Answers with the key the watch's events name the document by, whether
+     * a document exists, taken once the watch is in place and the document
+     * is loaded as a read loads it, the text held at that moment, and the
+     * position of the last update or deletion event sent as of it, so an event
+     * the client heard while the watch was in flight tells by its own position
+     * whether it is newer than the answer. No handle: the event channel is the
+     * client interface. Callers fan out a single inbound `onDocumentUpdated` to
+     * multiple local listeners with their own `Emitter<T>` (matching Theia's
+     * pattern). Pair every `watchModelDocument` with
+     * {@link unwatchModelDocument} when no longer needed; the server holds the
+     * watch record until the matching unwatch lands.
      */
-    watchModelDocument(args: WatchModelDocumentArgs): Promise<void>;
+    watchModelDocument(args: WatchModelDocumentArgs): Promise<TransferWatchedDocument>;
     /**
      * Stop watching `(uri, clientId)` previously started by
      * {@link watchModelDocument}. Idempotent — unwatching twice is a no-op.
@@ -171,6 +247,19 @@ export interface ProjectServerProtocol<TProject extends Project = Project> {
  */
 export interface DataServerProtocol<TTransfer extends TransferElement, TDiagnostic extends TransferDiagnostic = TransferDiagnostic, TProject extends Project = Project> extends DocumentServerProtocol<TTransfer, TDiagnostic>, ProjectServerProtocol<TProject> {
 }
+/**
+ * The diagnostic shape a server answers with, read back off its own
+ * declaration.
+ *
+ * This is what lets a client tier stay generic over the server alone and still
+ * describe what it hands back. Both parameters must be inferred: naming
+ * {@link TransferElement} for the transfer instead fails to match while that
+ * parameter is still generic, and a default declared against the constraint
+ * then stops satisfying it.
+ */
+export type DiagnosticOf<TServer> = TServer extends DocumentServerProtocol<infer _TTransfer, infer TDiagnostic> ? TDiagnostic : TransferDiagnostic;
+/** The project shape a server answers with, read back off its own declaration. */
+export type ProjectOf<TServer> = TServer extends ProjectServerProtocol<infer TProject> ? TProject : Project;
 /**
  * Cross-reference / naming slice of the server surface — scope-aware
  * queries that resolve against the language's reference services. NOT part
@@ -181,11 +270,11 @@ export interface DataServerProtocol<TTransfer extends TransferElement, TDiagnost
  * source/URI (an `ElementSource` with no URI resolves to the sole
  * registered language; a multi-language workspace overrides).
  *
- * Generic over the transfer root type only — the resolution result
- * ({@link ReferenceTarget}) carries the resolved node's encoded subtree;
- * candidates and names are diagnostic-free.
+ * Not generic over a server's root type: {@link resolveReference} answers with
+ * a node a reference names, which is no document root, and candidates and
+ * names are diagnostic-free.
  */
-export interface ReferenceServerProtocol<TTransfer extends TransferElement> {
+export interface ReferenceServerProtocol {
     /**
      * List the reference candidates reachable for the property named in `ctx`
      * from its (possibly synthetic) source. Backed by the language's
@@ -197,8 +286,11 @@ export interface ReferenceServerProtocol<TTransfer extends TransferElement> {
      * target's document URI, display fields, and the resolved node's encoded
      * transfer subtree. Resolves via the language's reference services;
      * `undefined` when the reference does not resolve.
+     *
+     * `TElement` is the caller's claim about the target node's type; nothing
+     * checks it, so leave it at the default unless the reference names one type.
      */
-    resolveReference(ref: ReferenceRequest): Promise<ReferenceTarget<TTransfer> | undefined>;
+    resolveReference<TElement extends TransferElement = TransferElement>(ref: ReferenceRequest): Promise<ReferenceTarget<TElement> | undefined>;
     /**
      * Compute the next free name for a new element of `args.type` based on
      * `args.proposal`, unique within the `args.tier` scope (default
@@ -235,6 +327,36 @@ export interface DocumentClientProtocol<TTransfer extends TransferElement, TDiag
      * codepath, not a subscription codepath).
      */
     onDocumentSaved(event: TransferDocumentSavedEvent<TTransfer, TDiagnostic>): void;
+    /**
+     * Delivered when a subscribed document's text starts or stops differing
+     * from its file, as the server last knew it. Gated like
+     * {@link onDocumentSaved}; the answer at any one moment is the `dirty` of
+     * the documents the server sends. After a reconnect, a `DataSession`
+     * delivers here the answer of each document it restored, when that differs
+     * from the last this client was told: the flips while the connection was
+     * down reached no one.
+     */
+    onDocumentDirtyChanged(event: TransferDocumentDirtyChangedEvent): void;
+    /**
+     * Delivered when a document's backing file was removed. Separate from
+     * {@link onDocumentUpdated} for the same reason as {@link onDocumentSaved},
+     * and more strongly: there is no built state to deliver, and the build-phase
+     * path cannot report a deletion at all.
+     *
+     * Ungated, because on a browser host — where the workspace lives behind the
+     * head — no other source can observe a file disappearing. Recipients that
+     * only care about their own documents filter by URI.
+     */
+    onDocumentDeleted(event: TransferDocumentDeletedEvent): void;
+    /**
+     * Delivered once per build, naming the documents that reached the
+     * subscription phase and that
+     * nobody on this connection watches — chiefly the ones rebuilt as a cascade
+     * from a dependency's change, which no filesystem watcher can see because
+     * their own files did not change. The complement of
+     * {@link onDocumentUpdated}; carries URIs and no documents.
+     */
+    onDocumentsBuilt(event: TransferDocumentsBuiltEvent): void;
 }
 /**
  * Project-scoped slice of the client surface — the project-registry change