@hydranium/protocol 1.0.0-next.39 → 1.0.0-next.390

package/lib/client/working-copy.d.ts

@@ -0,0 +1,420 @@
+/********************************************************************************
+ * 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 { type Disposable, Emitter, type Event } from 'vscode-jsonrpc';
+import { type Clock } from '../clock';
+import { type ModelVersion } from '../model-service/base-version';
+import { type ConflictResolver } from '../patch-merge';
+import { PendingWorkTracker } from '../pending-work-tracker';
+import { type ReconcileWriteOutcome, type VersionedModel } from '../reconcile-write';
+import type { TransferDiagnostic } from '../transfer-diagnostic';
+import { type LoadedTransferDocument, type TextState, TransferDocument, type TransferSavedDocument } from '../transfer-document';
+import type { TransferElement } from '../transfer-element';
+import { Deferred } from '../util';
+import type { DataEvents } from './data-events';
+import type { DataSession, DataSessionRestoreEvent } from './data-session';
+/** What the write that carried an {@link WorkingCopy.edit} did. */
+export type WorkingCopyEditOutcome = 
+/** The write landed against an unchanged document. */
+{
+    readonly status: 'applied';
+}
+/** The write raced a foreign edit to other paths, and both landed. */
+ | {
+    readonly status: 'merged';
+}
+/**
+ * The edit raced a foreign edit of the same path, or kept racing foreign
+ * edits, and was dropped, or wrote a path an edit before it lost that way.
+ * The copy shows the server's value, unless the read after the last race
+ * failed.
+ */
+ | {
+    readonly status: 'conflict';
+}
+/** Nothing was written: the server already held the edit, or it changed nothing. */
+ | {
+    readonly status: 'unchanged';
+}
+/**
+ * Nothing was written, because the copy was closed, its file deleted, a
+ * restore could not open it again or its open's second read failed, before
+ * a write carried the edit.
+ */
+ | {
+    readonly status: 'unavailable';
+};
+/**
+ * One open of a {@link WorkingCopy}, from the answer to its first read until a
+ * close, a deletion or a failure ends it. A request records its answer only
+ * while the open it was sent under is still the copy's, so nothing of an
+ * ended open reaches the next.
+ */
+export interface WorkingCopyOpen<TTransfer extends TransferElement> {
+    /** The last document the server sent. */
+    snapshot: TransferDocument<TTransfer>;
+    /** The copy's restores heard when {@link snapshot} was taken. */
+    snapshotRestores: number;
+    /**
+     * Whether {@link snapshot} was taken while a write was out, so it may hold
+     * the edits {@link sending} applies again. A base made on it then is
+     * unconfirmed, so its first write is reconciled, not sent.
+     */
+    snapshotUnderWrite?: boolean;
+    /** Edits not yet written, in edit order, each until the write that carries it answers. */
+    queued: {
+        readonly change: (root: TTransfer) => TTransfer;
+        readonly outcome: Deferred<WorkingCopyEditOutcome>;
+    }[];
+    /**
+     * The root the first queued edit was made on, the write in flight
+     * included, and the snapshot version their write is gated on. A foreign
+     * update that lands while they wait then conflicts and is reconciled,
+     * instead of being written over, and the copy's own write does not.
+     * `restores` is the copy's restores heard when that root was taken. A base
+     * from before a restore conflicts on its first write. `unconfirmed` marks
+     * a base whose write before a conflict dropped edits from. The root is then
+     * the one that write was made on with only the edits it kept, so an edit
+     * restating a dropped value conflicts, and its first write conflicts too.
+     * It also marks a base made on a {@link snapshotUnderWrite}. `dropped`
+     * makes any edit of a path a dropped edit wrote conflict, a revert to the
+     * value before it included.
+     */
+    base?: VersionedModel<TTransfer> & {
+        readonly restores: number;
+        readonly unconfirmed?: boolean;
+        /** The root the user saw before a conflict dropped edits, and the paths those edits wrote. */
+        readonly dropped?: {
+            readonly seen: TTransfer;
+            readonly paths: readonly string[];
+        };
+    };
+    /** Edits of the write in flight, in edit order. */
+    sending: WorkingCopyOpen<TTransfer>['queued'];
+    /** Whether a write loop runs. */
+    writing: boolean;
+    /** The server's dirty flag, as last sent. */
+    serverDirty: boolean;
+    /** Requests out whose answer replaces the snapshot. */
+    snapshotRequests: number;
+    /**
+     * The newest document the server sent while a request is out, held until a
+     * request answers with no write out, or for
+     * {@link WorkingCopy.settleWritesMs} at most.
+     */
+    held?: TransferDocument<TTransfer>;
+    /** Takes {@link held} once it has waited {@link WorkingCopy.settleWritesMs}. */
+    holdTimer?: Disposable;
+    /** The text version of the dirty flag last taken, so an answer built earlier does not undo a later save. */
+    dirtyVersion?: number;
+    /** Whether that flag came as a dirty event, which a document at its version does not undo. */
+    dirtyFromEvent: boolean;
+}
+/**
+ * The client's working copy of one data-server document: the server's latest
+ * snapshot of it, plus the edits the server has not confirmed yet.
+ *
+ * - **Follows the server.** Another client's update replaces the snapshot and
+ *   fires {@link onDidChange}. This session's own echoes are skipped while a
+ *   write is out, since the write's answer carries them. A document the
+ *   server sends while a write, a save, a reread or the open's second read is
+ *   out waits. The newest is taken when one of them answers and no write is
+ *   out, or once the first of them has waited {@link settleWritesMs}. A write
+ *   still out then has its edits applied to a document that may hold them
+ *   already, so an edit that does not give the same root twice may show twice
+ *   until its write answers. A batch made on that document has its first
+ *   write reconciled, so the edit is not written twice.
+ * - **Batches edits behind a write.** An edit goes out at once when no write
+ *   is out. The edits made while one is out go out after it, as one write of
+ *   the whole root, gated on the version of the snapshot the first of them
+ *   was made on, or of the answer to the copy's write before when that was
+ *   built from the write's own text or holds its model unchanged. Each edit
+ *   resolves to a {@link WorkingCopyEditOutcome}, its batch's unless the
+ *   batch splits on a conflict.
+ * - **Reconciles.** A write that meets a newer version goes through
+ *   `reconcileWrite`: the edits are replayed onto the refetched root, and a
+ *   same-path collision drops the edit that made it in favour of the
+ *   server's value. The other edits of its batch are still written.
+ * - **Counts its own edits as dirty.** {@link dirty} is the server's flag, or
+ *   true while an edit is unanswered, so a host never shows clean text with
+ *   an edit still on its way.
+ *
+ * Its session's own writes of the document are taken as echoes while a
+ * write is out, so the copy is the only writer of the document on its
+ * session. One heard with none out is taken, as a late write of a copy
+ * before it may be.
+ *
+ * One URI per copy, for its whole life. Opening another document is a new
+ * copy, so no queued edit can land on a document it was not made for. Open a
+ * new copy of the same document on the same session only once the last one's
+ * {@link close} has settled, since the copy does not check it. The session
+ * holds one open per document, so a close sent later would end the new copy's
+ * open too.
+ *
+ * An edit is a function of the root and runs again on every newer snapshot
+ * until its write answers, so it must be pure. Running it once and keeping the
+ * result would hide a foreign update behind the edit's stale copy of the root.
+ * One that throws on a newer root makes {@link root} throw too, until its
+ * write answers.
+ */
+export declare class WorkingCopy<TTransfer extends TransferElement> {
+    protected readonly session: DataSession<TTransfer>;
+    protected readonly events: DataEvents<TTransfer>;
+    /** The document followed, as the caller spells it, which the session keys its open by. */
+    readonly uri: string;
+    protected readonly changeEmitter: Emitter<void>;
+    /** Fires whenever {@link root} or {@link diagnostics} may have changed. */
+    readonly onDidChange: Event<void>;
+    protected readonly dirtyEmitter: Emitter<void>;
+    /** Fires whenever {@link dirty} changes. Apart from {@link onDidChange}, since a save changes no content. */
+    readonly onDidChangeDirty: Event<void>;
+    /** Asked for each conflicting write, see {@link reconcile}. */
+    protected readonly conflictResolver: ConflictResolver;
+    /**
+     * Writes of one reconcile, the first included, before a still-conflicting
+     * one is dropped. A first write the copy refuses unsent, on a base from
+     * before a restore or one a conflict dropped edits from, counts too. A
+     * split batch reconciles twice, so one batch makes at most twice the cap
+     * less one writes. Absent, `reconcileWrite`'s default applies.
+     */
+    protected readonly maxWrites?: number;
+    /**
+     * How long {@link save}, {@link close} and {@link whenWritesSettled} wait
+     * for the copy's edits before going on anyway, and how long a document the
+     * server sends is held for a request at most.
+     */
+    protected readonly settleWritesMs: number;
+    /** The clock of {@link settleWritesMs}. */
+    protected readonly clock: Clock;
+    /**
+     * The open the copy follows. A close, a deletion or a failure ends it, and a
+     * request sent under an earlier one neither counts nor answers.
+     */
+    protected current?: WorkingCopyOpen<TTransfer>;
+    /** Restores heard that may have renumbered the versions, see {@link handleDocumentRestored}. */
+    protected restores: number;
+    /** Every edit until its write answers, so a settle waits on rereads after a conflict too. */
+    protected readonly editsInFlight: PendingWorkTracker;
+    /** {@link dirty} as last announced. */
+    protected announcedDirty: boolean;
+    /** Requests being settled, during which {@link onDidChangeDirty} waits, since their answer is not taken yet. */
+    protected settling: number;
+    /** The open, under way or done, which a later call shares until a deletion or a failure clears it. */
+    protected opening?: Promise<void>;
+    /** The close, once called. The copy does not open again after it. */
+    protected closing?: Promise<void>;
+    /** The listeners on the session and its events, ended once {@link dispose} ran and the edits have answered. */
+    protected readonly subscriptions: Disposable[];
+    /** Set by {@link dispose}, after which nothing is announced. */
+    protected disposed: boolean;
+    /** Set once {@link close} stopped waiting for the open, which then ends when it answers. */
+    protected openAbandoned: boolean;
+    constructor(session: DataSession<TTransfer>, events: DataEvents<TTransfer>, 
+    /** The document followed, as the caller spells it, which the session keys its open by. */
+    uri: string);
+    /** The last document the server sent, without the edits it has not confirmed. `undefined` before {@link open}. */
+    get snapshot(): TransferDocument<TTransfer> | undefined;
+    /** The version of {@link snapshot}. A write is gated on the version its batch was made on, see the class doc. */
+    get version(): ModelVersion | undefined;
+    /** The server's root with every unconfirmed edit applied. `undefined` when no document is loaded. */
+    get root(): TTransfer | undefined;
+    /**
+     * Diagnostics as of the last snapshot. A write answers once its document is
+     * validated, so they hold for the copy's own edits without an update push.
+     * After a reconnect the ones from before stay until the copy's reread
+     * answers, or the next update when it fails.
+     */
+    get diagnostics(): readonly TransferDiagnostic[];
+    /** Whether the server's text differs from the file, or an edit has not been confirmed. */
+    get dirty(): boolean;
+    /** Whether an edit has not answered yet. Synchronous, for an unload guard. */
+    get hasWritesInFlight(): boolean;
+    /**
+     * Open and watch the document, then read it again with diagnostics. The
+     * open settles before validation, so without the second read a document
+     * that was never edited reports no problems. Fires a change once both reads
+     * have answered and the open stands, and before that only for a document a
+     * restore hands over meanwhile. Repeated calls share the first one, and a
+     * failed open may be retried. Rejects once {@link close} was called, and
+     * with a `DocumentNotOpenError` when the file is gone by the second read. A
+     * failed second read rejects once the session is connected, so after a
+     * dropped connection it waits for the reconnect, and resolves when the
+     * restore took the document over.
+     */
+    open(): Promise<void>;
+    /**
+     * Queue `change` for the next write. The edit shows in {@link root} at once.
+     * Resolves to the outcome of the write that carried it, and rejects when
+     * that write fails for another reason than a conflict, as with a
+     * `DocumentSyntaxError` while the document does not parse. Rejects with a
+     * `DocumentNotOpenError` when the copy follows no document, and with what
+     * `change` throws on {@link root}, queueing nothing. A change that throws
+     * only on a later root rejects every edit of the write that carries it.
+     */
+    edit(change: (root: TTransfer) => TTransfer): Promise<WorkingCopyEditOutcome>;
+    /**
+     * Wait for every edit to answer, those made during the wait included, and
+     * persist the server's text when it differs from the file, whoever wrote
+     * it. Resolves to what the persist answered, or `undefined` when nothing
+     * needed saving. Rejects with a `DocumentNotOpenError` when the copy
+     * follows no document, at the call or once the edits have answered, or
+     * follows one opened again meanwhile. Rejects with a `ConflictError` when
+     * the text moved past the copy's version or the copy's document is from
+     * before the latest restore, and with a `SaveFailedError` when an edit has
+     * not answered within {@link settleWritesMs}.
+     */
+    save(): Promise<TransferSavedDocument<TTransfer> | undefined>;
+    /**
+     * Resolve to `true` once no edit is pending, those made during the wait
+     * included, or to `false` once {@link settleWritesMs} has passed first.
+     * Never rejects.
+     */
+    whenWritesSettled(): Promise<boolean>;
+    /**
+     * Resolve to `true` once `opening` has settled and no edit is pending, those
+     * made during the wait included, or to `false` once {@link settleWritesMs}
+     * has passed first.
+     */
+    protected whenEditsIdle(opening?: Promise<void>): Promise<boolean>;
+    /**
+     * Wait for an open under way and the edits, those made during the wait
+     * included, up to {@link settleWritesMs}, and close the document. Final:
+     * the copy does not open again, and a later call shares this one.
+     */
+    close(): Promise<void>;
+    /** The work of {@link close}, after the open it ends and the edits, within one bound. */
+    protected closeAfter(opening: Promise<void> | undefined): Promise<void>;
+    /**
+     * Announce nothing more. Unanswered edits are still written while the
+     * session lives, since dropping them would lose what the user typed, and
+     * the copy follows the document until they have answered, so their writes
+     * still heed a restore or a deletion. A host that ends the session as well
+     * waits for {@link whenWritesSettled} first.
+     */
+    dispose(): void;
+    /** Both reads of {@link open}. */
+    protected load(): Promise<void>;
+    /** Write the batches of `open` until none is left, one at a time, so each can be based on the answer to the last. */
+    protected writeQueued(open: WorkingCopyOpen<TTransfer>): Promise<void>;
+    /**
+     * Write one batch, made on `base`, and settle its edits. The batch leaves
+     * {@link root} before the server's answer is taken and the one change is
+     * fired for it, since a reader would otherwise apply it again over an
+     * answer that holds or refused it.
+     */
+    protected writeBatch(open: WorkingCopyOpen<TTransfer>, batch: WorkingCopyOpen<TTransfer>['queued'], base: WorkingCopyOpen<TTransfer>['base']): Promise<void>;
+    /**
+     * Replay a conflicting batch onto `theirs` one edit at a time, each as the
+     * change from the root before it, and write the edits that do not collide.
+     * One edit's collision then drops only that edit.
+     */
+    protected splitConflict(open: WorkingCopyOpen<TTransfer>, roots: readonly TTransfer[], theirs: LoadedTransferDocument<TTransfer>, restores: number): Promise<{
+        answer?: TransferDocument<TTransfer>;
+        outcomes: (WorkingCopyEditOutcome | Promise<never>)[];
+    }>;
+    /**
+     * Write `ours`, based on `base`, and reconcile a conflict. Resolves to the
+     * last document the write and its rereads answered, which {@link writeBatch}
+     * takes, so the copy shows the server's value for an edit the reconcile
+     * dropped. `restores` is {@link restores} when its last reread was taken.
+     *
+     * A base from before a restore is not sent but refused as a conflict, so
+     * the write is reconciled against the restarted server's document. Its
+     * version could match that server's by chance and the write would land.
+     * An unconfirmed base is refused the same way. Only a batch's own write,
+     * `whole`, can move the base of the edits queued meanwhile.
+     *
+     * A merged write comes back as `persisted` when it was gated on a reread
+     * that equals the root the edit was made on, since it raced no foreign
+     * edit. It then carries no `conflict` or `writes`.
+     */
+    protected reconcile(open: WorkingCopyOpen<TTransfer>, base: NonNullable<WorkingCopyOpen<TTransfer>['base']>, ours: TTransfer, whole: boolean): Promise<{
+        readonly outcome: ReconcileWriteOutcome;
+        readonly answer?: TransferDocument<TTransfer>;
+        readonly restores: number;
+    }>;
+    /** The outcome an edit reports for what {@link reconcile} did. */
+    protected toEditOutcome(outcome: ReconcileWriteOutcome): WorkingCopyEditOutcome;
+    /** Drop the snapshot when the document's file is removed, so no edit is based on a document the server no longer has. */
+    protected handleDocumentDeleted(event: {
+        uri: string;
+    }): void;
+    /** End the open as a deletion does, and settle the edits not yet written as `unavailable`. */
+    protected dropDocument(): void;
+    /**
+     * Drop the document and every edit not yet written, and return those edits
+     * for the caller to settle. Made on the document that went, they never
+     * reach one opened again. Requests still out answer to nothing, since a
+     * late answer would bring the document back.
+     */
+    protected unload(): WorkingCopyOpen<TTransfer>['queued'];
+    /**
+     * Follow the document again after a reconnect. A restarted server numbers
+     * versions afresh, so the versions held from before compare with nothing,
+     * and a change made while the connection was down sent no event. Queued
+     * edits keep their base, so their write is reconciled against what the
+     * restarted server holds and a field changed meanwhile conflicts. A restore
+     * that finds the snapshot's text at its version is not counted, as in the
+     * session, so a brief drop costs no conflict.
+     */
+    protected handleDocumentRestored(event: DataSessionRestoreEvent<TTransfer>): void;
+    /** Read the document of `open` again with diagnostics, and take the answer. */
+    protected reread(open: WorkingCopyOpen<TTransfer>): Promise<void>;
+    /** Follow a server push for the document. */
+    protected handleDocumentUpdated(event: {
+        document: TransferDocument<TTransfer>;
+        sourceClientId: string;
+    }): void;
+    /**
+     * Take the dirty flag of a document the server sent, and the document itself
+     * unless a request is out. A document older than the snapshot is skipped.
+     */
+    protected offer(open: WorkingCopyOpen<TTransfer>, document: TransferDocument<TTransfer>, announce: boolean): void;
+    /**
+     * Hold `document` until a request answers. A document first held
+     * {@link settleWritesMs} ago is taken then, so a request that hangs does
+     * not hide other clients' changes for longer.
+     */
+    protected hold(open: WorkingCopyOpen<TTransfer>, document: TransferDocument<TTransfer>): void;
+    /** Stop holding a document for `open`, and return the one it held. */
+    protected unhold(open: WorkingCopyOpen<TTransfer>): TransferDocument<TTransfer> | undefined;
+    /**
+     * Take `document` as the new snapshot. Fires a change unless the model's
+     * hash is the one held, which also means equally validated, or `announce`
+     * is false, as for a write's answers, which {@link writeBatch} announces
+     * once the write's edits are off {@link root}.
+     */
+    protected adopt(open: WorkingCopyOpen<TTransfer>, document: TransferDocument<TTransfer>, announce?: boolean): void;
+    /**
+     * End a request, and take the newest document the server sent while
+     * requests were out, its answer included. None is taken while a write is
+     * out, since it may already hold that write's edits, which {@link root}
+     * would then apply again. Versions are compared only within that window,
+     * and a restore clears what it held, since a restarted server numbers
+     * afresh. {@link dirty} is announced once the answer is taken.
+     */
+    protected settleRequest(open: WorkingCopyOpen<TTransfer>, answer: TransferDocument<TTransfer> | undefined, announce?: boolean): void;
+    /** {@link settleRequest} past its check that `open` is followed, without announcing {@link dirty}. */
+    protected settleAnswer(open: WorkingCopyOpen<TTransfer>, answer: TransferDocument<TTransfer> | undefined, announce: boolean): void;
+    /**
+     * Take a dirty flag the server sent, `announced` when it came as a dirty
+     * event. While a request is out, one decided on older text than the last
+     * is skipped, and so is a document's at the version of the last event,
+     * since a save changes the flag but not the version, and that document may
+     * have been built before it. Outside that window any is taken, as after a
+     * restart that numbers versions afresh.
+     */
+    protected takeDirty(open: WorkingCopyOpen<TTransfer>, text: (Pick<TextState, 'dirty'> & Partial<Pick<TextState, 'version'>>) | undefined, announced?: boolean): void;
+    /** Fire {@link onDidChangeDirty} when {@link dirty} differs from what was last announced, unless a request is being settled. */
+    protected announceDirty(): void;
+    /** The open the copy follows, or a throw when it follows none. */
+    protected requireOpen(): WorkingCopyOpen<TTransfer>;
+    /** Throw once {@link dispose} ran. */
+    protected assertLive(): void;
+}
+//# sourceMappingURL=working-copy.d.ts.map

package/lib/client/working-copy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"working-copy.d.ts","sourceRoot":"","sources":["../../src/client/working-copy.ts"],"names":[],"mappings":"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"}