@hydranium/protocol 1.0.0-next.11 → 1.0.0-next.112

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

@@ -6,84 +6,121 @@
  *
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
-import type { MessageConnection } from 'vscode-jsonrpc';
-import { type DataClientProtocol, type DataServerProtocol } from '../data';
-import { type RpcProxy } from '../rpc';
+import type { DataServerProtocol, DiagnosticOf } from '../data';
+import type { RpcProxy } from '../rpc';
 import type { TransferDocument } from '../transfer-document';
 import type { TransferElement } from '../transfer-element';
-import type { DataPort } from './data-port';
-/** Options for {@link DataSession}. */
-export interface DataSessionOptions {
+/**
+ * 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`. */
+export type DataSessionOpenArgs<TTransfer extends TransferElement, TServer extends DataServerProtocol<TTransfer, DiagnosticOf<TServer>> = DataServerProtocol<TTransfer>> = DataSessionArgs<TServer['openModelDocument']>;
+/** 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']>;
+/** 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']>;
+/** 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>>;
+/**
+ * The {@link DataSession.openDocument} calls running against one URI, and
+ * whether any of them has taken a server hold that no open has claimed yet.
+ *
+ * One record per URI rather than per call, because the hold is per
+ * `(uri, clientId)`: the server has one, however many opens are in flight, so
+ * one flag is the accurate model of it.
+ */
+export interface OpeningDocument {
+    /** Opens still running for this URI. The last one out answers for the hold. */
+    inFlight: number;
+    /** An open succeeded, and no open has since claimed the hold via `openUris`. */
+    holdTaken: boolean;
+}
+/**
+ * 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>>> {
+    connected(): Promise<RpcProxy<TServer>>;
+    releaseSession(session: DataSession<TTransfer, TServer>): void;
     /**
-     * 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.
+     * Take over a `(uri, clientId)` hold a session could not release, so it is
+     * retried while the wire is still up.
+     *
+     * A session that has been disposed has already drained and will not read its
+     * own tracking again, so a close it issues and the server refuses leaves the
+     * hold with nobody to answer for it. The host outlives every session it
+     * mints, which is what makes it the one thing that still can.
+     *
+     * Optional so a host predating it keeps working; without it such a hold falls
+     * to the server's connection-close cleanup, which on a shared connection is
+     * as long as every other participant's session.
      */
-    readonly methodNamespace?: string;
-}
-/** 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>;
+    orphanHold?(uri: string, clientId: string): void;
 }
 /**
- * The host-invariant half of talking to the data head: everything above
- * {@link DataPort} that would otherwise be re-derived by every host
- * adapter.
+ * One participant on a data connection: a properties panel, a tree, a
+ * form editor.
  *
- * Three jobs, and deliberately no fourth:
+ * The server keys every hold and watch per `(uri, clientId)`, so the identity
+ * belongs to the participant rather than to the wire — several sessions share
+ * one connection, and two participants forced to share one identity cannot
+ * distinguish each other's writes from their own echoes.
  *
- * 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.
+ * 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 release the hold accordingly.
  *
- * 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.
+ * Generic over the transfer root so this file names no grammar.
  *
- * 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.
+ * `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>> {
+    readonly clientId: string;
+    protected readonly host: DataSessionHost<TTransfer, TServer>;
+    /** URIs this session holds open, so {@link dispose} can release exactly those. */
+    protected readonly openUris: Set<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.
+     * The in-flight {@link openDocument} group per URI, while one is running.
      *
-     * Concurrent callers share one readiness promise, so `waitForReady` is
-     * awaited once per generation and not once per caller.
+     * A hold is one per `(uri, clientId)`, and {@link openUris} is filled only
+     * once an open has fully returned — so overlapping opens of one URI all read
+     * it as unheld and all believe the hold is theirs to release. Tracking the
+     * group lets the last of them answer for it once, knowing what the rest did.
      */
-    connected(): Promise<RpcProxy<DataServerProtocol<TTransfer>>>;
+    protected readonly openingUris: Map<string, OpeningDocument>;
+    protected disposed: boolean;
+    /**
+     * Disposed through {@link detach} rather than {@link dispose}, so nothing may
+     * be sent. Folding it into {@link disposed} costs {@link openDocument} the
+     * distinction, and its close would then go out on a detached session.
+     */
+    protected detached: boolean;
+    constructor(clientId: string, host: DataSessionHost<TTransfer, TServer>);
+    /**
+     * The connected, READY server proxy, for protocol methods this session does
+     * not wrap — the ones carrying no `clientId`, so no identity can be got
+     * wrong through them.
+     */
+    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*
@@ -98,32 +135,73 @@ export declare class DataSession<TTransfer extends TransferElement> {
      * valid: `open` settles at the integrity landmark, not at validation.
      * Validity arrives asynchronously on `onDocumentUpdated`, or synchronously
      * from `getModelDocument({ includeDiagnostics: true })`.
+     *
+     * A dispose landing between the two awaits is handled here rather than in
+     * {@link dispose}, which cannot release a hold that does not exist yet: it
+     * reads {@link openUris}, and this method fills it only once both calls have
+     * returned. Left to `dispose`, the hold and its watch outlive the participant
+     * and go only when the connection closes.
+     *
+     * A watch that REJECTS is the same problem arriving by a different door: the
+     * open already took a hold, and the caller sees only a failed open, so
+     * nothing on its side will ever issue the close.
+     *
+     * Which call releases it is decided by {@link finishOpening} rather than by
+     * the one that failed, because a hold is per `(uri, clientId)` and any number
+     * of this session's opens share it. A failing open that closed on its own
+     * behalf would revoke a peer's; one that deferred to a peer would leak the
+     * hold whenever that peer fails at its OWN open, having then taken no hold to
+     * roll back and having no rollback path to run. Making the last open for the
+     * URI answer for it is the only rule that holds in both directions.
      */
-    openDocument(uri: string): Promise<TransferDocument<TTransfer>>;
+    openDocument(args: DataSessionOpenArgs<TTransfer, TServer>): Promise<DataSessionDocument<TTransfer, TServer>>;
+    /** Join (or start) the in-flight group for `uri`, counting this call into it. */
+    protected beginOpening(uri: string): OpeningDocument;
     /**
-     * Close `uri`. The server unwatches implicitly, so this is the dual of
+     * Count this call out of the in-flight group for `uri` and, if it was the
+     * last one, answer for whatever hold the group took.
+     *
+     * The last call is the only one that can see the group's whole outcome, which
+     * is what makes it the right one to decide. A hold that some open took and no
+     * open claimed — `openUris` is the claim — belongs to nobody, and closing it
+     * here is the only release that will ever be issued for it.
+     */
+    protected finishOpening(uri: string, server: RpcProxy<TServer>): Promise<void>;
+    /**
+     * Close `args.uri`. The server unwatches implicitly, so this is the dual of
      * {@link openDocument} and needs no separate unwatch.
      */
-    closeDocument(uri: string): Promise<void>;
+    closeDocument(args: DataSessionCloseArgs<TTransfer, TServer>): Promise<void>;
+    /** Write `args.model` back as this session. */
+    updateDocument(args: DataSessionUpdateArgs<TTransfer, TServer>): Promise<DataSessionDocument<TTransfer, TServer>>;
+    /** Persist `args.model` to disk as this session. */
+    saveDocument(args: DataSessionSaveArgs<TTransfer, TServer>): Promise<DataSessionDocument<TTransfer, TServer>>;
     /**
-     * Whether `event.sourceClientId` identifies this session's own write.
+     * 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. */
+    /**
+     * Release this session's holds and detach it from the connection.
+     * Idempotent, and leaves the connection usable by its other sessions.
+     *
+     * The closes are fired without being awaited, because a `Disposable` cannot
+     * be: a host disposing a widget has nowhere to put the promise. A close
+     * that fails is no worse than the leak this exists to prevent, so the
+     * rejection is swallowed rather than surfaced from a teardown.
+     */
     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 no close, unlike {@link dispose}: the server releases every hold on
+     * a connection it sees close, and the close would travel over the very
+     * connection being disposed.
      */
-    protected dropGeneration(): void;
+    detach(): 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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"}