@hydranium/protocol 1.0.0-next.25 → 1.0.0-next.250

package/lib/client/data-session.d.ts

@@ -6,84 +6,272 @@
  *
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
-import type { MessageConnection } from 'vscode-jsonrpc';
-import { type DataClientProtocol, type DataServerProtocol } from '../data';
-import { type RpcProxy } from '../rpc';
-import type { TransferDocument } from '../transfer-document';
+import { type Disposable, Emitter, type Event } from 'vscode-jsonrpc';
+import { type Clock } from '../clock';
+import type { DataServerProtocol, DiagnosticOf, TransferDocumentDirtyChangedEvent, TransferDocumentUpdatedEvent } from '../data';
+import { type BaseVersion, type ModelVersion } from '../model-service/base-version';
+import { type ResolvedMessage } from '../messages/primitives';
+import type { OpenModelArgs } from '../model-server';
+import type { MaybePromise } from '../util';
+import type { RpcProxy } from '../rpc';
+import type { TextState, TransferDocument, TransferSavedDocument } from '../transfer-document';
 import type { TransferElement } from '../transfer-element';
-import type { DataPort } from './data-port';
-/** Options for {@link DataSession}. */
-export interface DataSessionOptions {
+/**
+ * A session could not re-open a document it had open after its connection
+ * dropped, and forgot it; or could not write it again for another reason than
+ * a conflict, and keeps its unsaved edits for the next restore.
+ */
+export declare const DATA_SESSION_RESTORE_FAILED: import("../messages/primitives").MessageDefinition<"Could not restore {uri} after reconnecting to the data server: {detail}">;
+/** A write or open of `{uri}` that the data server answered without a model. */
+export declare const DATA_SESSION_ANSWER_WITHOUT_MODEL: import("../messages/primitives").MessageDefinition<"The data server answered a write of {uri} without a model; the session counts that answer as older than every version.">;
+/**
+ * A session re-opened documents after its connection dropped and cannot put
+ * back what it wrote to them since their last save: another client changed
+ * them, even while the session was still connected; the session could not
+ * tell the text its writes started from, or lost another document written with
+ * them; or the write it sent again conflicted. The session's unsaved edits may
+ * be gone, and it no longer holds them.
+ */
+export declare const DATA_SESSION_UNSAVED_LOST: import("../messages/primitives").MessageDefinition<"Unsaved changes to {uris} may have been lost when the connection to the data server dropped.">;
+/**
+ * What one of `TServer`'s document methods takes, minus the `clientId` a
+ * {@link DataSession} stamps itself.
+ *
+ * Read off the SERVER's signature, not off the framework's own arg type: an
+ * adopter server widens these, and a wrapper declared against the narrow
+ * shape rejects the extra field on a fresh object literal, so that call
+ * cannot go through a session at all.
+ */
+export type DataSessionArgs<TMethod extends (args: never) => unknown> = Omit<Parameters<TMethod>[0], 'clientId'>;
+/**
+ * Open a document through a session; the session supplies `clientId`. Only the
+ * URI and the open's options: a session's open reads the file, and the server
+ * ignores the `languageId`, `version` and `text` seeds of `OpenModelArgs`, so
+ * accepting them here would let a caller believe they took effect.
+ */
+export type DataSessionOpenArgs<TTransfer extends TransferElement, TServer extends DataServerProtocol<TTransfer, DiagnosticOf<TServer>> = DataServerProtocol<TTransfer>> = Pick<OpenModelArgs, 'uri' | 'options'>;
+/** Create a document through a session; the session supplies `clientId`. */
+export type DataSessionCreateArgs<TTransfer extends TransferElement, TServer extends DataServerProtocol<TTransfer, DiagnosticOf<TServer>> = DataServerProtocol<TTransfer>> = DataSessionArgs<TServer['createModelDocument']>;
+/** Close a document through a session; the session supplies `clientId`. */
+export type DataSessionCloseArgs<TTransfer extends TransferElement, TServer extends DataServerProtocol<TTransfer, DiagnosticOf<TServer>> = DataServerProtocol<TTransfer>> = DataSessionArgs<TServer['closeModelDocument']>;
+/** Update a document through a session; the session supplies `clientId`. */
+export type DataSessionUpdateArgs<TTransfer extends TransferElement, TServer extends DataServerProtocol<TTransfer, DiagnosticOf<TServer>> = DataServerProtocol<TTransfer>> = DataSessionArgs<TServer['updateModelDocument']>;
+/** Update several documents at once through a session; the session supplies `clientId`. */
+export type DataSessionUpdatesArgs<TTransfer extends TransferElement, TServer extends DataServerProtocol<TTransfer, DiagnosticOf<TServer>> = DataServerProtocol<TTransfer>> = DataSessionArgs<TServer['updateModelDocuments']>;
+/** Persist a document through a session; the session supplies `clientId`. */
+export type DataSessionSaveArgs<TTransfer extends TransferElement, TServer extends DataServerProtocol<TTransfer, DiagnosticOf<TServer>> = DataServerProtocol<TTransfer>> = DataSessionArgs<TServer['saveModelDocument']>;
+/** Persist the text the server holds through a session; the session supplies `clientId`. */
+export type DataSessionPersistArgs<TTransfer extends TransferElement, TServer extends DataServerProtocol<TTransfer, DiagnosticOf<TServer>> = DataServerProtocol<TTransfer>> = DataSessionArgs<TServer['persistModelDocument']>;
+/** The document a session hands back, carrying its server's diagnostic shape. */
+export type DataSessionDocument<TTransfer extends TransferElement, TServer extends DataServerProtocol<TTransfer, DiagnosticOf<TServer>> = DataServerProtocol<TTransfer>> = TransferDocument<TTransfer, DiagnosticOf<TServer>>;
+/**
+ * What a {@link DataSession} keeps of a URI it wrote since the URI's last save,
+ * to write it again after a reconnect that lost it.
+ */
+export interface DataSessionUnsavedWrite<TTransfer extends TransferElement, TServer extends DataServerProtocol<TTransfer, DiagnosticOf<TServer>> = DataServerProtocol<TTransfer>> {
     /**
-     * Wire namespace the server is addressed under. Defaults to the
-     * framework's {@link DATA_SERVER_WIRE_PREFIX}, which is what an unmodified
-     * `DataServer` binds. Override only alongside the server's own
-     * `methodNamespace` option — a mismatch turns every request into
-     * "Unhandled method" rather than failing at wire-up.
+     * The `text.hash` of the text the first of these writes was based on.
+     * `undefined` when the session could not tell, for a write based on
+     * `'any'` or on a version it could not read back, and such a write is
+     * never sent again: the session cannot tell another client's text from the
+     * text it wrote over.
      */
-    readonly methodNamespace?: string;
+    readonly baseHash: string | undefined;
+    /**
+     * The model version the last of these writes was answered with, which
+     * orders its answers, and the `text.hash` of that answer.
+     */
+    readonly answer: {
+        readonly version: ModelVersion;
+        readonly hash?: string;
+    };
+    /**
+     * The call that made the last write, and for an `updateDocuments` call this
+     * URI's index in it. Records whose `updates` is the same object were
+     * written together and are sent again together, so a restore never applies
+     * part of a set.
+     */
+    readonly call: {
+        readonly update: DataSessionUpdateArgs<TTransfer, TServer>;
+    } | {
+        readonly updates: DataSessionUpdatesArgs<TTransfer, TServer>;
+        readonly index: number;
+    };
 }
-/** One connection generation: its connection, its proxy, and its readiness. */
-interface Generation<TTransfer extends TransferElement> {
-    readonly connection: Promise<MessageConnection>;
-    readonly server: RpcProxy<DataServerProtocol<TTransfer>>;
-    /** Set on first use; the shared readiness gate for this generation. */
-    ready?: Promise<void>;
+/**
+ * What a {@link DataSession} needs from the connection that minted it.
+ *
+ * Narrower than the connection itself so the dependency points one way:
+ * `DataConnection` constructs sessions, and nothing here imports it back.
+ */
+export interface DataSessionHost<TTransfer extends TransferElement, TServer extends DataServerProtocol<TTransfer, DiagnosticOf<TServer>>> {
+    /** The connected, READY proxy of the current connection; a new object after each reconnect. */
+    connected(): Promise<RpcProxy<TServer>>;
+    /** Surface a failure no caller is waiting on, such as restoring a document after a reconnect. */
+    reportError?(error: unknown, reported: ResolvedMessage): void;
+    /**
+     * Tell the connection's client the dirty state a restore read, unless it
+     * is what the client was last told of the URI since the URI's last open.
+     */
+    restoreDirty?(event: TransferDocumentDirtyChangedEvent): void;
+    /**
+     * Forget what the client was told of `uri`'s dirty state: an open just
+     * made answered its caller afresh, and the client heard none of it, or a
+     * close leaves nothing to restore. Forgetting a URI another session still
+     * has open costs at most one repeat of a state the client already has.
+     */
+    forgetDirty?(uri: string): void;
+    /**
+     * Fires with each flip of a document's dirty state the server sends. A
+     * session drops the unsaved write it keeps of a document that turns
+     * clean; without this event it keeps it, and a restore after another
+     * client's save of the document can report the write lost.
+     */
+    readonly onDidChangeDirty?: Event<TransferDocumentDirtyChangedEvent>;
+    /**
+     * Fires with each update event the server sends. A session drops the
+     * unsaved write it keeps of a document another client wrote over; without
+     * this event it keeps it, and a restore reports the write lost.
+     */
+    readonly onDidUpdateDocument?: Event<TransferDocumentUpdatedEvent<TTransfer, DiagnosticOf<TServer>>>;
 }
 /**
- * The host-invariant half of talking to the data head: everything above
- * {@link DataPort} that would otherwise be re-derived by every host
- * adapter.
+ * Builds the session `DataConnection.createSession` hands out, for an adopter
+ * that extends {@link DataSession}. The connection has minted `clientId` and
+ * checked it by then.
+ */
+export type DataSessionFactory<TTransfer extends TransferElement, TServer extends DataServerProtocol<TTransfer, DiagnosticOf<TServer>>> = (clientId: string, host: DataSessionHost<TTransfer, TServer>, label: string) => DataSession<TTransfer, TServer>;
+/**
+ * One participant on a data connection: a properties panel, a tree, a form
+ * editor. The client side of a server client session, registered over the
+ * wire under {@link clientId}.
+ *
+ * The session writes only what it has open: the server refuses its update or
+ * save of a document it has not opened with a `DocumentNotOpenError` code.
+ * Every call waits for the registration, so the first can be issued at once.
  *
- * Three jobs, and deliberately no fourth:
+ * Every document operation stamps {@link clientId} itself. A caller that
+ * passed its own could pass another participant's, and the server would
+ * attribute the write and close the document accordingly.
  *
- * 1. **Build the typed proxy** over the port's connection, with the framework's
- *    wire prefix and its drift-proof client-method allowlist.
- * 2. **Own the readiness gate** — `waitForReady` once per connection, shared
- *    across concurrent callers. A socket client can connect before the
- *    workspace walk finishes, and an early request is then answered correctly
- *    from an empty registry, which reads as a broken project tier rather than
- *    as a race.
- * 3. **Own the reconnect policy**, by dropping its connection generation when
- *    the port disposes and building a fresh one on the next request.
+ * {@link closeDocument} and {@link dispose} first wait, up to
+ * {@link settleBeforeCloseMs}, for this session's calls still in flight on the
+ * URI, or on any URI for `dispose`: a save sent just before its close would
+ * otherwise reach the server after it, and fail as not open.
  *
- * It does **not** wrap the protocol methods; callers reach them through
- * {@link connected}. The one exception is {@link openDocument}, which exists
- * because the open/watch *order* is silently wrong the other way round — see
- * its own doc.
+ * After the connection drops, the session registers again under the same id,
+ * re-opens and re-watches what it had open, tells the client of their dirty
+ * state where it changed, and reports the documents whose unsaved edits did
+ * not survive; see {@link restore}. The connection does this at
+ * once for a session with documents open, and again once any later connection
+ * is ready, so a reconnect that failed is not left to the session's own next
+ * call; any session's next call does it too.
  *
- * Generic over the transfer root so this file names no grammar. An adopter
- * binds the concrete root (or the union of them, for a multi-grammar head) at
- * its own edge.
+ * Generic over the transfer root so this file names no grammar.
+ *
+ * `TServer` is bound to a server answering with ITS OWN diagnostic shape, read
+ * back off the parameter being bound. Simplifying that to
+ * `DataServerProtocol<TTransfer>` compiles and costs the wrappers their
+ * return type: every call through `TServer` would resolve against that looser
+ * bound, so an adopter's diagnostics would come back as the framework's and
+ * the document would have to be cast on the way out.
  */
-export declare class DataSession<TTransfer extends TransferElement> {
-    protected readonly port: DataPort;
-    protected readonly client: DataClientProtocol<TTransfer>;
-    protected readonly methodNamespace: string;
-    /** The current generation, or `undefined` before the first request / after a teardown. */
-    protected generation?: Generation<TTransfer>;
-    protected disposed: boolean;
-    protected readonly portDisposeListener: {
-        dispose(): void;
-    };
-    constructor(port: DataPort, client: DataClientProtocol<TTransfer>, options?: DataSessionOptions);
-    /** The identity every request is made under — the port's, not a second one. */
-    get clientId(): string;
+export declare class DataSession<TTransfer extends TransferElement, TServer extends DataServerProtocol<TTransfer, DiagnosticOf<TServer>> = DataServerProtocol<TTransfer>> implements Disposable {
+    readonly clientId: string;
+    protected readonly host: DataSessionHost<TTransfer, TServer>;
+    readonly label: string;
     /**
-     * The connected, READY server proxy.
-     *
-     * Returns the proxy rather than `void` on purpose. A reconnect replaces the
-     * proxy, so a caller that cached one from an earlier call would go on
-     * addressing a dead connection with no error — handing it back per call
-     * makes the stale reference unrepresentable.
+     * How long {@link closeDocument} and {@link dispose} wait for this session's
+     * calls in flight before closing anyway. Long, because the wait only runs
+     * out when a call hangs, and a close sent while a save is still running
+     * fails that save.
+     */
+    protected readonly settleBeforeCloseMs: number;
+    /**
+     * The clock {@link settleBeforeCloseMs} runs on. {@link DataSessionHost}
+     * carries no {@link Clock}, so a subclass replaces this field as it
+     * replaces the bound.
+     */
+    protected readonly clock: Clock;
+    /** URIs this session has open, re-opened after a reconnect. */
+    protected readonly openUris: Set<string>;
+    /**
+     * Per URI in {@link openUris}, the URI the server's last answer to its open
+     * or re-open named. The server keys its notifications by it, and so does
+     * the host's record of what its client was told.
+     */
+    protected readonly serverUris: Map<string, string>;
+    /**
+     * Per URI, how many opens of it this session has under way. Such a URI
+     * counts as open for {@link withOpenDocument}, which would otherwise close
+     * it under the open that is still being made.
+     */
+    protected readonly openingUris: Map<string, number>;
+    /** Per URI written since its last save, what {@link restore} needs to write it again. */
+    protected readonly unsavedWrites: Map<string, DataSessionUnsavedWrite<TTransfer, TServer>>;
+    /**
+     * Per URI this session has open, the text of the last document one of its
+     * own calls was answered with, which spares the read a first unsaved write
+     * otherwise makes for its base; see {@link baseHashOf}.
+     */
+    protected readonly lastAnswers: Map<string, TextState>;
+    /**
+     * Per URI this session has open, the text version its last save or persist
+     * of it wrote, as its answer's `persisted` says; see {@link recordWrite}.
+     * Not the answer's model version, which can carry a write that landed
+     * after the text was taken. Only those set it: an open answers at the
+     * version of a write still in flight as well, and that write is not saved.
+     */
+    protected readonly savedVersions: Map<string, number>;
+    /** Per URI, this session's calls still in flight on it, which a close waits for. */
+    protected readonly inFlight: Map<string, Set<Promise<unknown>>>;
+    /** This session's saves still in flight, which a host's exit waits for; see {@link hasSavesInFlight}. */
+    protected readonly savesInFlight: Set<Promise<unknown>>;
+    protected readonly disposeEmitter: Emitter<void>;
+    /**
+     * Fires once when the session ends, by {@link dispose} or {@link detach}, as
+     * soon as it rejects further calls and before any close is sent. For a
+     * session its connection created, the connection's listener runs first, so
+     * the id is free again on that connection by the time any other listener
+     * runs; the server still holds it until the close arrives, and refuses a new
+     * session under it until then.
      *
-     * Concurrent callers share one readiness promise, so `waitForReady` is
-     * awaited once per generation and not once per caller.
+     * A listener subscribed once the session has ended is never called, so a
+     * late subscriber checks {@link isDisposed} first.
+     */
+    readonly onDidDispose: Event<void>;
+    /**
+     * Sent with every registration, so the server lets this session register
+     * its id again while the dropped connection's session is still live there:
+     * a server that has not yet noticed the drop would otherwise refuse the id
+     * as a duplicate until it does.
+     */
+    protected readonly resumeToken: string;
+    /** The proxy the session is registered on; another one means the connection was replaced. */
+    protected registeredOn?: RpcProxy<TServer>;
+    protected registration?: Promise<void>;
+    protected disposed: boolean;
+    /**
+     * Disposed through {@link detach} rather than {@link dispose}, so nothing may
+     * be sent. Folding it into {@link disposed} would send the session's close
+     * over a connection that is going away.
+     */
+    protected detached: boolean;
+    /** The subscription to the host's `onDidChangeDirty`, disposed with the session. */
+    protected readonly dirtySubscription?: Disposable;
+    /** The subscription to the host's `onDidUpdateDocument`, disposed with the session. */
+    protected readonly updateSubscription?: Disposable;
+    constructor(clientId: string, host: DataSessionHost<TTransfer, TServer>, label: string);
+    /**
+     * The connected, READY server proxy once this session is registered on it,
+     * for protocol methods this session does not wrap. The proxy stamps
+     * nothing: pass this session's {@link clientId} to any method that carries
+     * one.
      */
-    connected(): Promise<RpcProxy<DataServerProtocol<TTransfer>>>;
+    connected(): Promise<RpcProxy<TServer>>;
     /**
-     * Open `uri` for editing and start watching it, in that order, returning
-     * the opened snapshot.
+     * Open `args.uri` for editing and start watching it, in that order,
+     * returning the opened snapshot.
      *
      * **The order is the whole reason this method exists.**
      * `watchModelDocument` baselines its dedup fingerprint from the *current*
@@ -91,39 +279,243 @@ export declare class DataSession<TTransfer extends TransferElement> {
      * baseline, and the first phase event after the open arrives as a spurious
      * `'changed'` — which a widget that resets its in-memory root to the server
      * view misreads as a concurrent third-party write, losing whatever the user
-     * had typed. Nothing about the wrong order fails loudly, so it is encoded
-     * here rather than documented and re-derived.
+     * had typed.
      *
-     * Note that the returned snapshot's empty `diagnostics` does not mean
-     * valid: `open` settles at the integrity landmark, not at validation.
+     * Note that the returned snapshot's model usually has no `diagnostics`:
+     * `open` settles at the integrity landmark, not at validation.
      * Validity arrives asynchronously on `onDocumentUpdated`, or synchronously
      * from `getModelDocument({ includeDiagnostics: true })`.
      */
-    openDocument(uri: string): Promise<TransferDocument<TTransfer>>;
+    openDocument(args: DataSessionOpenArgs<TTransfer, TServer>): Promise<DataSessionDocument<TTransfer, TServer>>;
+    /**
+     * Create a document that exists nowhere yet, open and watched for this
+     * session; it reaches disk with the first {@link saveDocument}. The server
+     * refuses a URI that exists on disk or that any client has open.
+     */
+    createDocument(args: DataSessionCreateArgs<TTransfer, TServer>): Promise<DataSessionDocument<TTransfer, TServer>>;
+    /**
+     * Watch a document this session just opened, and record it as open. A
+     * failed watch closes it again: the caller sees a failed open and so would
+     * never close it.
+     */
+    protected watchOpened(server: RpcProxy<TServer>, uri: string, document: DataSessionDocument<TTransfer, TServer>): Promise<DataSessionDocument<TTransfer, TServer>>;
+    /**
+     * Close `args.uri`, once this session's calls on it have settled or
+     * {@link settleBeforeCloseMs} has passed. The server unwatches implicitly,
+     * so this is the dual of {@link openDocument} and needs no separate unwatch.
+     */
+    closeDocument(args: DataSessionCloseArgs<TTransfer, TServer>): Promise<void>;
     /**
-     * Close `uri`. The server unwatches implicitly, so this is the dual of
-     * {@link openDocument} and needs no separate unwatch.
+     * Open `args.uri`, run `fn` with the opened snapshot, and close it once
+     * `fn` settles, whether it returned or threw. A URI this session already
+     * had open, or is still opening through another call, stays open: the close
+     * undoes only the open this call made.
      */
-    closeDocument(uri: string): Promise<void>;
+    withOpenDocument<T>(args: DataSessionOpenArgs<TTransfer, TServer>, fn: (document: DataSessionDocument<TTransfer, TServer>) => MaybePromise<T>): Promise<T>;
+    /** Write `args.model` back as this session. The session must have `args.uri` open. */
+    updateDocument(args: DataSessionUpdateArgs<TTransfer, TServer>): Promise<DataSessionDocument<TTransfer, TServer>>;
     /**
-     * Whether `event.sourceClientId` identifies this session's own write.
+     * Write several documents this session has open, all or none: the server
+     * refuses the whole set, before any text applies, when one is stale or not
+     * open. Resolves to the documents in the order given.
+     */
+    updateDocuments(args: DataSessionUpdatesArgs<TTransfer, TServer>): Promise<DataSessionDocument<TTransfer, TServer>[]>;
+    /** Persist `args.model` to disk as this session. The session must have `args.uri` open. */
+    saveDocument(args: DataSessionSaveArgs<TTransfer, TServer>): Promise<TransferSavedDocument<TTransfer, DiagnosticOf<TServer>>>;
+    /**
+     * Persist the text the server holds for `args.uri` as this session, with no
+     * model of its own. The session must have `args.uri` open.
+     */
+    persistDocument(args: DataSessionPersistArgs<TTransfer, TServer>): Promise<TransferSavedDocument<TTransfer, DiagnosticOf<TServer>>>;
+    /** Run a save or persist of `uri` and record what it answered as saved. */
+    protected trackSave(uri: string, send: (server: RpcProxy<TServer>) => Promise<TransferSavedDocument<TTransfer, DiagnosticOf<TServer>>>): Promise<TransferSavedDocument<TTransfer, DiagnosticOf<TServer>>>;
+    /** Whether the session has ended, by {@link dispose} or {@link detach}. */
+    get isDisposed(): boolean;
+    /**
+     * Whether a save of this session has not answered yet. Synchronous, for a
+     * host whose exit veto must decide within the tick, such as Theia's
+     * `onWillStop`.
+     */
+    get hasSavesInFlight(): boolean;
+    /**
+     * Resolves once the saves in flight now have answered, or
+     * {@link settleBeforeCloseMs} has passed. Never rejects: a failed save has
+     * answered too.
+     */
+    whenSavesSettled(): Promise<void>;
+    /**
+     * Whether `sourceClientId` identifies this session's own write.
      *
      * Every watcher needs this and the check is one comparison, so getting it
      * wrong is cheap to do and expensive to find: an unfiltered echo looks
      * exactly like a concurrent third-party edit.
      */
     isOwnEcho(sourceClientId: string): boolean;
-    /** Tear down the current connection and stop tracking the port. Idempotent. */
+    /**
+     * End the session: detach it from the connection at once, and once its
+     * calls in flight have settled or {@link settleBeforeCloseMs} has passed,
+     * end it on the server, which closes everything it has open. Idempotent,
+     * and leaves the connection usable by its other sessions.
+     *
+     * Every later call rejects, and so does a call made earlier in the same
+     * tick, which has not reached the wire yet and is never sent. The server
+     * close is not awaited, because a `Disposable` cannot be; a close that fails
+     * leaves the session to the server's connection-close cleanup.
+     */
     dispose(): void;
-    /** The live generation, building one if there is none. */
-    protected currentGeneration(): Generation<TTransfer>;
-    /** Await the connection and the server's startup gate for one generation. */
-    protected awaitReady(generation: Generation<TTransfer>): Promise<void>;
     /**
-     * Discard the current generation, disposing its connection if it opened.
-     * The next {@link connected} builds a fresh one.
+     * Come off the connection because it is going away.
+     *
+     * Sends nothing, unlike {@link dispose}: the server ends every session on a
+     * connection it sees close, and the close would travel over the very
+     * connection being disposed.
+     *
+     * Public because the connection calls it; anyone else ends a session with
+     * {@link dispose}. It fires {@link onDidDispose} only if the session has not
+     * already ended, and after {@link dispose} it still cancels the close that
+     * dispose has not sent yet.
+     */
+    detach(): void;
+    /**
+     * Dispose {@link dirtySubscription} and {@link updateSubscription}, fire
+     * {@link onDidDispose} and dispose its emitter, so a second call fires
+     * nothing.
+     */
+    protected fireDispose(): void;
+    /**
+     * Register again and restore now, after the connection dropped, instead of
+     * on the next call. A no-op for a session with nothing open, which the next
+     * call restores anyway, and for one already registered on the current
+     * connection. A failure is retried on the connection's next ready
+     * generation; a call before then meets it again.
+     */
+    reconnect(): void;
+    /**
+     * Drop the record in {@link unsavedWrites} of a document this session has
+     * open once the server says it turned clean: it holds no unsaved text
+     * then, and a record kept would have a restore report the write lost once
+     * another client's save changed the file.
+     *
+     * The server sends a flip only for a document someone watches, so a
+     * document the session writes without watching it keeps its record, and
+     * can still be reported lost that way.
+     */
+    protected forgetSavedWrite(event: TransferDocumentDirtyChangedEvent): void;
+    /**
+     * Drop the record in {@link unsavedWrites} of a document another client
+     * wrote over while the connection held: its write replaced the session's,
+     * so a restore has nothing of the session's to put back, and a record kept
+     * would have it report the write lost to the reconnect. A write superseded
+     * before its answer needs nothing: the answer names the other client's
+     * text, which the record then holds.
+     *
+     * Only a `'changed'` event from another client counts, and only where the
+     * document no longer holds the write: the session's own echo, and an
+     * integrity repair already in the write's answer, replaced nothing, and a
+     * `'rebuilt'` event carries no new text. Like {@link forgetSavedWrite}, it
+     * depends on the server sending the event, which it does only for a
+     * document someone watches.
+     */
+    protected forgetSupersededWrite(event: TransferDocumentUpdatedEvent<TTransfer, DiagnosticOf<TServer>>): void;
+    /**
+     * Register on `server`, and after a reconnect restore what the ended session
+     * had. Calls issued meanwhile wait for this.
+     */
+    protected register(server: RpcProxy<TServer>, reconnected: boolean): Promise<void>;
+    /**
+     * Re-open and re-watch every document the session had open, write again
+     * what it wrote since their last save where the re-open lost it, and tell
+     * the host which of them lost it for good.
+     *
+     * Decided per document by the re-opened document's `text.hash`,
+     * in {@link restoreOutcome}. Versions cannot decide a write: a revert moves
+     * the version on and a restarted server numbers afresh, so the version the
+     * last write was answered with never matches where a write is needed, and
+     * any other version may be another client's edit, which a write would
+     * overwrite.
+     *
+     * Only what the drop cost is reported: a write another client wrote over
+     * while the connection held has no record left by then, see
+     * {@link forgetSupersededWrite}.
+     *
+     * A write is sent again based on the re-opened version, as an ordinary
+     * write, so an edit arriving in between conflicts, and a conflict is not
+     * retried. Documents last written by one {@link updateDocuments} are sent
+     * again by one, and only when every one of them may be; a document that
+     * could not be re-opened blocks its set.
+     *
+     * No caller is waiting, so the outcomes go through the host: one report
+     * naming every document whose unsaved text is gone, whose record is then
+     * dropped, and one per document that could not be re-opened or written
+     * again for another reason than a conflict. A document that could not be
+     * re-opened is forgotten; a failed write keeps its record, for the next
+     * restore to decide again.
+     *
+     * Each document's dirty state goes to the host too, read once the watch is
+     * in place and any write is sent: a flip while the connection was down, or
+     * between the re-open and the watch, reached no one, and the re-open's own
+     * answer misses the second. Read before the write, it would tell the client
+     * a document is clean that the write is about to make dirty again.
+     */
+    protected restore(server: RpcProxy<TServer>): Promise<void>;
+    /**
+     * Whether the re-opened `document` still holds the session's unsaved
+     * `write` (`'kept'`), holds the text the write started from, so the write
+     * can be sent again (`'resend'`), or holds something else (`'lost'`).
+     *
+     * A document without `text` comes from a server that sends none, and
+     * counts as kept only at the version the write was answered with. One
+     * without a model has no version to send the write again on.
+     */
+    protected restoreOutcome(write: DataSessionUnsavedWrite<TTransfer, TServer>, document: DataSessionDocument<TTransfer, TServer>): 'kept' | 'resend' | 'lost';
+    /**
+     * Write again, in one call and based on their `reopened` versions, the
+     * `members` of one write call that the re-open lost, all or none. Returns
+     * the URIs whose unsaved text is gone, and drops their records, and the
+     * record of a member that could not be re-opened.
+     *
+     * A member whose record is no longer the one the restore started with was
+     * closed, saved or disposed meanwhile, and is left out: writing it would
+     * put back text its caller discarded.
+     */
+    protected reapply(server: RpcProxy<TServer>, members: readonly [string, DataSessionUnsavedWrite<TTransfer, TServer>][], reopened: ReadonlyMap<string, DataSessionDocument<TTransfer, TServer>>): Promise<string[]>;
+    /**
+     * The text hash of the version `baseVersion` names for `uri`, for a write that
+     * starts the URI's record in {@link unsavedWrites}; `undefined` for any
+     * other write, whose record keeps the base it has.
+     *
+     * Taken from {@link lastAnswers} when that is at the version, otherwise
+     * read, and kept only when the read answers that version: a server's text
+     * changes only with its version, so the text at a version is the text the
+     * write, once it passes the gate, was applied to.
+     */
+    protected baseHashOf(server: RpcProxy<TServer>, uri: string, baseVersion: BaseVersion): Promise<string | undefined>;
+    /**
+     * Record `document` as the answer to a write of `uri`, keeping the base of
+     * the URI's record if it has one. An answer numbered below the record's is
+     * ignored: two writes of `uri` in flight at once may answer out of order,
+     * and the record holds the one applied last.
+     *
+     * So is one numbered at or below the URI's entry in {@link savedVersions}.
+     * The save came after that write was applied, so the save persisted its
+     * text or a later write replaced it, and its answer carries the text as it
+     * was when sent, which a restore would report as lost.
+     */
+    protected recordWrite(uri: string, document: DataSessionDocument<TTransfer, TServer>, baseHash: string | undefined, call: DataSessionUnsavedWrite<TTransfer, TServer>['call']): void;
+    /**
+     * What {@link DataSessionUnsavedWrite.answer} keeps of `document`. Every write
+     * and open answers with a model; one without is reported and counted older
+     * than every version, so it never replaces a real answer.
      */
-    protected dropGeneration(): void;
+    protected answerOf(uri: string, document: DataSessionDocument<TTransfer, TServer>): DataSessionUnsavedWrite<TTransfer, TServer>['answer'];
+    /** Keep `document`'s text in {@link lastAnswers}, or forget it for a server that sends none. */
+    protected recordText(uri: string, document: DataSessionDocument<TTransfer, TServer>): void;
+    /** Run `call`, counted as in flight on each of `uris` until it settles. */
+    protected track<T>(uris: readonly string[], call: () => Promise<T>): Promise<T>;
+    /** {@link track} an open of `uri`, counted in {@link openingUris} until it settles. */
+    protected trackOpen<T>(uri: string, call: () => Promise<T>): Promise<T>;
+    /** Wait until `calls` have settled, or {@link settleBeforeCloseMs} has passed. */
+    protected settle(calls: Iterable<Promise<unknown>> | undefined): Promise<void>;
+    protected assertLive(): void;
 }
-export {};
 //# sourceMappingURL=data-session.d.ts.map

package/lib/client/data-session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data-session.d.ts","sourceRoot":"","sources":["../../src/client/data-session.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAyD,KAAK,kBAAkB,EAAE,KAAK,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAClI,OAAO,EAAE,KAAK,QAAQ,EAAkB,MAAM,QAAQ,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,uCAAuC;AACvC,MAAM,WAAW,kBAAkB;IAChC;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACpC;AAED,+EAA+E;AAC/E,UAAU,UAAU,CAAC,SAAS,SAAS,eAAe;IACnD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAChD,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC;IACzD,uEAAuE;IACvE,KAAK,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,WAAW,CAAC,SAAS,SAAS,eAAe;IAQpD,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ;IACjC,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAC,SAAS,CAAC;IAR3D,SAAS,CAAC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IAC3C,0FAA0F;IAC1F,SAAS,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC;IAC7C,SAAS,CAAC,QAAQ,UAAS;IAC3B,SAAS,CAAC,QAAQ,CAAC,mBAAmB,EAAE;QAAE,OAAO,IAAI,IAAI,CAAA;KAAE,CAAC;gBAGtC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,kBAAkB,CAAC,SAAS,CAAC,EACxD,OAAO,GAAE,kBAAuB;IAMnC,+EAA+E;IAC/E,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;;;;;;;;;OAUG;IACG,SAAS,IAAI,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC;IAYnE;;;;;;;;;;;;;;;;;OAiBG;IACG,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC;IAOrE;;;OAGG;IACG,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAK/C;;;;;;OAMG;IACH,SAAS,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO;IAI1C,+EAA+E;IAC/E,OAAO,IAAI,IAAI;IASf,0DAA0D;IAC1D,SAAS,CAAC,iBAAiB,IAAI,UAAU,CAAC,SAAS,CAAC;IAkBpD,6EAA6E;cAC7D,UAAU,CAAC,UAAU,EAAE,UAAU,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAe5E;;;OAGG;IACH,SAAS,CAAC,cAAc,IAAI,IAAI;CAQlC"}
+{"version":3,"file":"data-session.d.ts","sourceRoot":"","sources":["../../src/client/data-session.ts"],"names":[],"mappings":"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"}