@hydranium/glsp-server 1.0.0-next.31 → 1.0.0-next.315

package/lib/state/reconciling-multi-document-glsp-state.d.ts

@@ -8,8 +8,10 @@
  ********************************************************************************/
 import { type JsonModelState } from '@eclipse-glsp/server';
 import { type AstNode } from '@hydranium/langium';
-import { type TransferElement } from '@hydranium/protocol';
+import { type ClientSession } from '@hydranium/core';
+import { type BaseVersion, type ModelVersion, type TextVersion, type TransferElement, type VersionedModel } from '@hydranium/protocol';
 import { AbstractHydraniumGlspState } from './abstract-hydranium-glsp-state.js';
+import { type OperationTransition } from '../command/hydranium-glsp-operation-command.js';
 /**
  * Source model spanning more than one document: the primary document's
  * projection plus one per registered secondary, keyed by URI.
@@ -26,6 +28,10 @@ export interface MultiDocumentSourceModel<TPrimary extends TransferElement = Tra
     /** Projection of each registered secondary document, keyed by its URI. */
     secondaries: Record<string, TransferElement>;
 }
+/** A write set, with the version of each secondary's text it was projected from, keyed by URI. */
+export interface VersionedMultiDocumentSourceModel<TPrimary extends TransferElement = TransferElement> extends VersionedModel<MultiDocumentSourceModel<TPrimary>> {
+    readonly secondaryVersions: Readonly<Record<string, ModelVersion>>;
+}
 /**
  * Editable GLSP state for a diagram whose edits span SEVERAL Langium documents —
  * a diagram file plus the semantic file it references, say, where creating a node
@@ -39,43 +45,33 @@ export interface MultiDocumentSourceModel<TPrimary extends TransferElement = Tra
  * defines them over the primary plus the secondary write set registered through
  * {@link AbstractHydraniumGlspState.trackSecondaryDocument}.
  *
- * **Writes are NOT atomic, deliberately, and the window is real.** Each document
- * goes through its own `ModelService.update`, so a failure after the first write
- * has landed leaves the set inconsistent on disk. There is no multi-document
- * transaction to lean on: `WorkspaceLock` serialises builds but does not roll
- * back, and the document store commits per URI. An adopter that cannot accept the
- * window should not span documents in one operation.
+ * **The write set is written all or none.** {@link persist} hands every
+ * changed document to one `ClientSession.updateAll` on the diagram's session,
+ * so a conflict on any document leaves every document of the set as it was,
+ * and write order carries no meaning.
  *
- * **What makes the window tolerable is write ORDER, and the rule is
- * referenced-before-referencing** — not "secondaries first" as such. Write the
- * document whose content the others point AT before the documents that point at
- * it, so a partial write leaves an unreferenced element (inert, and the direction
- * an integrity rule can repair) rather than a reference to something that does
- * not exist (a linking error). {@link persist} implements that as
- * secondaries-then-primary, which is correct for the common shape where the
- * primary is the DIAGRAM and the semantics it references are secondaries: the
- * user opened the diagram, so it is also the document the conflict gate should
- * guard. **An adopter whose primary is the referenced document — a semantic file
- * as the diagram source, with layout in a secondary — has the ordering backwards
- * and must override {@link persist} to write the primary first.** Overriding it
- * is the supported route; the base order is a default for the common case, not an
- * invariant of the class.
+ * **Every document of the set is gated.** The primary on the caller's
+ * `baseVersion`, each secondary on {@link secondaryBaseVersion}, by default the version
+ * it had when the source root was last read. A conflict on any of them is
+ * reconciled against the whole write set, and the merged retry is gated on
+ * the versions its refetch read. A write based on `'any'` — an undo or redo
+ * applying a recorded patch — forces every document of the set.
  *
- * **The conflict gate covers the primary only.** Secondaries are written without
- * a based-on version, so a concurrent foreign edit to one is overwritten rather
- * than reconciled. Gating them too would need a per-document reconcile whose
- * outcomes can disagree (merge one, conflict another) with no way to un-write the
- * merged one — the atomicity problem again, one layer up. The captured versions
- * ARE available via {@link AbstractHydraniumGlspState.capturedVersionOf}, so an
- * adopter that wants a coarser check can compare before writing.
+ * A secondary is written only while the diagram's session has it open. The
+ * storage opens it as it joins the write set, and {@link openForWrite} opens it
+ * again before each write; an adopter whose write set can name a document that
+ * does not exist yet overrides {@link openForWrite} to create it through
+ * {@link createSecondaryDocument}.
  */
 export declare class ReconcilingMultiDocumentGlspState<TRoot extends AstNode, TPrimary extends TransferElement = TransferElement> extends AbstractHydraniumGlspState<TRoot, MultiDocumentSourceModel<TPrimary>> implements JsonModelState<MultiDocumentSourceModel<TPrimary>> {
     /**
-     * Last in-sync projection across the whole write set, captured on every
-     * {@link setSourceRoot}. Same role as the single-document baseline: the state a
-     * forward-write conflict reconciles the user's intent against.
+     * The projection across the whole write set that a forward-write conflict
+     * reconciles the user's intent from, taken from the built roots on every
+     * capture.
      */
-    protected baseline?: MultiDocumentSourceModel<TPrimary>;
+    protected base: MultiDocumentSourceModel<TPrimary>;
+    /** The documents {@link createSecondaryDocument} created for the {@link persist} under way, with the version each was created at. */
+    protected readonly createdForWrite: Map<string, number>;
     /**
      * Projection of the primary plus every registered secondary, in the framework
      * encoder's `'grammar'` mode (authored state only — cross-references as
@@ -88,19 +84,40 @@ export declare class ReconcilingMultiDocumentGlspState<TRoot extends AstNode, TP
      * persist as a deletion of content the state simply could not see.
      */
     get sourceModel(): MultiDocumentSourceModel<TPrimary>;
-    setSourceRoot(uri: string, root: TRoot): void;
+    protected captureSourceRoot(uri: string, root: TRoot): void;
+    /**
+     * Each document whose ends differ, either end serialized for its URI and
+     * parsed back; a document equal on both ends is left as it is, since it
+     * stays out of the transition's patch anyway.
+     */
+    normalizeTransition(transition: OperationTransition<MultiDocumentSourceModel<TPrimary>>): Promise<OperationTransition<MultiDocumentSourceModel<TPrimary>>>;
+    /**
+     * Also takes a secondary first tracked during an operation into the base
+     * and into the operation's projection from before its command, both from
+     * the root its version was read from: a conflict on it reconciles from the
+     * revision the operation's copy describes, and undoing the operation
+     * restores it. A document that does not exist yet has no projection to
+     * restore, so an undo leaves what the operation wrote into it.
+     */
+    trackSecondaryDocument(uri: string): void;
+    /**
+     * During an operation, also drops the untracked documents from its
+     * projection from before its command: they are not written, so the
+     * operation's undo and redo leave them as they are.
+     */
+    untrackSecondaryDocuments(): void;
     /**
      * Register the secondary documents that belong to the primary at `uri`, via
      * {@link AbstractHydraniumGlspState.trackSecondaryDocument}. Called on every
-     * {@link setSourceRoot}, after the primary is captured (so `sourceUri` is
-     * current) and BEFORE the baseline is taken (so the baseline includes them).
+     * capture, after the primary is captured (so `sourceUri` is current) and
+     * BEFORE the base is taken (so the base includes them).
      * Default: no secondaries.
      *
      * This hook exists because that ordering is a trap an adopter would otherwise
-     * hit silently. Registering from an overridden `setSourceRoot` *after*
-     * `super.setSourceRoot(...)` runs too late — the baseline has already been
+     * hit silently. Registering from an overridden `captureSourceRoot` *after*
+     * `super.captureSourceRoot(...)` runs too late — the base has already been
      * captured without the secondaries, so the first conflict reconcile measures
-     * the user's intent against a baseline missing half the write set and the
+     * the user's intent against a base missing half the write set and the
      * secondary edits look like foreign changes. Registering *before* the super
      * call is too early for a URI derived from the new primary. Overriding this
      * instead removes the choice.
@@ -108,55 +125,94 @@ export declare class ReconcilingMultiDocumentGlspState<TRoot extends AstNode, TP
     protected trackWriteSet(_uri: string): void;
     /**
      * Persist the whole write set, then capture the resulting primary root. On a
-     * `ConflictError` from the primary, reconcile via the injected policy exactly
-     * as the single-document state does — the orchestration is shared.
+     * `ConflictError` from any document of the set, reconcile via the injected
+     * policy exactly as the single-document state does — the orchestration is
+     * shared.
      */
-    updateSourceModel(model: MultiDocumentSourceModel<TPrimary>, version?: number): Promise<void>;
+    updateSourceModel(model: MultiDocumentSourceModel<TPrimary>, baseVersion?: BaseVersion): Promise<void>;
     /**
-     * Write hook — secondaries first (ungated), primary last (gated on
-     * `baseVersion`). The order is the failure-mode choice documented on the
-     * class, not incidental: override this when the primary is the document the
-     * others REFERENCE, since then this order writes the references first.
+     * Write hook — every document of `model` that changed, opened first through
+     * {@link openForWrite}, in one `updateAll` on the diagram's session: the
+     * primary gated on `baseVersion`, each secondary on its entry in
+     * `secondaryVersions` (a refetch's) or else {@link secondaryBaseVersion}, or
+     * every document on `'any'` when `baseVersion` is `'any'`. Resolves to
+     * the primary's root, the one already captured when the primary did not
+     * change. A write that bypasses `updateAll` gives up the all-or-none
+     * guarantee the class describes. Throws without a session
+     * ({@link requireModelSession}). An override that serializes otherwise than
+     * `ModelService.modelToText` overrides {@link normalizeTransition} alongside.
+     *
+     * A write that fails closes every document {@link createSecondaryDocument}
+     * created for it that {@link closesCreatedDocument} accepts.
      */
-    protected persist(model: MultiDocumentSourceModel<TPrimary>, baseVersion?: number): Promise<{
+    protected persist(model: MultiDocumentSourceModel<TPrimary>, baseVersion: BaseVersion, secondaryVersions?: Readonly<Record<string, ModelVersion>>): Promise<{
         root: TRoot;
     }>;
     /**
-     * Whether `candidate` differs from the baseline projection of the same
+     * Whether a write that failed closes `uri`, which
+     * {@link createSecondaryDocument} created for it at `createdVersion`.
+     * Default: while it still holds the text it was created with. Left open, it
+     * would stay in the diagram's session, and the diagram's next save would
+     * write it to disk though no write landed in it. One whose text moved on,
+     * because the set failed after applying or another client wrote to it,
+     * stays open: closing it would drop that text.
+     */
+    protected closesCreatedDocument(uri: string, createdVersion: TextVersion): boolean;
+    /**
+     * Whether `candidate` differs from the base projection of the same
      * document, and therefore needs writing.
      *
      * **Skipping unchanged documents is correctness, not an optimisation.** A
-     * write goes through `ModelService.update`, which re-serializes from the AST —
-     * so writing a document that did not change still rewrites its text, and a
-     * serializer is free to normalise formatting and cannot preserve comments.
-     * Persisting the whole write set unconditionally therefore means a pure layout
-     * drag reflows the semantic file and strips its comments, which is a data
-     * loss the user never asked for and would struggle to attribute.
+     * write re-serializes from the AST, so writing a document that did not
+     * change still rewrites its text in the serializer's own layout. Persisting
+     * the whole write set unconditionally therefore means a pure layout drag
+     * reflows the semantic file, a change the user never asked for and would
+     * struggle to attribute. Comments survive that rewrite, but the
+     * hand-formatting around them does not.
      *
      * Compared by serialised form. Both sides come from the same encoder walking
      * the same shape, so key order is stable and a string compare is sound here;
      * it is also cheap enough to run per document per write.
      */
-    protected hasChanged(baseline: object | undefined, candidate: object): boolean;
-    /** Write the primary document, opting into the conflict gate when `baseVersion` is given. */
-    protected persistPrimary(model: TPrimary, baseVersion?: number): Promise<{
-        root: TRoot;
-    }>;
+    protected hasChanged(base: object | undefined, candidate: object): boolean;
+    /**
+     * Make sure the diagram's session has `uri` open before the write set is
+     * written. Default: open it, a no-op for a document the session already
+     * has open. Override to create a document the write set names before it
+     * exists, through {@link createSecondaryDocument}: `updateAll` opens nothing.
+     */
+    protected openForWrite(session: ClientSession<AstNode>, uri: string): Promise<void>;
+    /**
+     * Create the secondary `uri` holding `text` through `session.create`, and
+     * base its write on the version the created document took. The version
+     * recorded while it did not exist matches no write, so the write conflicts.
+     * Make `text` with `ModelService.modelToText`, not the bare serializer,
+     * which leaves the file without the ending a write would give it.
+     */
+    protected createSecondaryDocument(session: ClientSession<AstNode>, uri: string, text: string): Promise<void>;
+    /**
+     * What a secondary write declares it was based on. Default: the version the
+     * secondary had when the source root was last read
+     * ({@link AbstractHydraniumGlspState.baseVersionOf}), so a foreign edit
+     * to it since is reported as a conflict and reconciled rather than
+     * overwritten; `'any'` for a secondary with no recorded version.
+     * Return `'any'` to force secondary writes.
+     */
+    protected secondaryBaseVersion(uri: string): BaseVersion;
     /**
-     * Write one secondary document. Ungated by design (see the class doc); override
-     * alongside {@link persistPrimary} when the round-trip differs per document
-     * role — a layout file and a semantic file need not share a serializer.
+     * Refetch hook — the current projection across the write set, each document
+     * read through {@link AbstractHydraniumGlspState.readCurrentRoot}, with the
+     * versions read alongside: theirs, which the conflict resolver replays the
+     * user's intent onto. Returns `undefined` when the PRIMARY cannot be read,
+     * since a reconcile without it has nothing to merge into; an unreadable
+     * secondary is omitted the same way {@link sourceModel} omits one.
      */
-    protected persistSecondary(uri: string, model: TransferElement): Promise<void>;
+    protected refetch(): Promise<VersionedMultiDocumentSourceModel<TPrimary> | undefined>;
     /**
-     * Refetch hook — the current settled projection across the write set, used by
-     * the conflict resolver to replay the user's intent against fresh state.
-     * Returns `undefined` when the PRIMARY cannot be read, since a reconcile
-     * without it has nothing to merge into; an unreadable secondary is omitted the
-     * same way {@link sourceModel} omits one.
+     * Project a currently-loaded document's root, or `undefined` when it is not
+     * loaded: the open operation's copy of it when there is one, which is where
+     * a handler's edit of it is, else the root its version was read from.
      */
-    protected refetch(): Promise<MultiDocumentSourceModel<TPrimary> | undefined>;
-    /** Project a currently-loaded document's root, or `undefined` when it is not loaded. */
     protected projectDocument(uri: string): TransferElement | undefined;
     /** Grammar-mode transfer projection of one AST root. The single projection seam. */
     protected projectRoot<T extends TransferElement = TransferElement>(root: AstNode): T;

package/lib/state/reconciling-multi-document-glsp-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reconciling-multi-document-glsp-state.d.ts","sourceRoot":"","sources":["../../src/state/reconciling-multi-document-glsp-state.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAGhF;;;;;;;;;GASG;AACH,MAAM,WAAW,wBAAwB,CAAC,QAAQ,SAAS,eAAe,GAAG,eAAe;IACzF,gFAAgF;IAChF,OAAO,EAAE,QAAQ,CAAC;IAClB,0EAA0E;IAC1E,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CAC/C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,qBACa,iCAAiC,CAAC,KAAK,SAAS,OAAO,EAAE,QAAQ,SAAS,eAAe,GAAG,eAAe,CACrH,SAAQ,0BAA0B,CAAC,KAAK,EAAE,wBAAwB,CAAC,QAAQ,CAAC,CAC5E,YAAW,cAAc,CAAC,wBAAwB,CAAC,QAAQ,CAAC,CAAC;IAE7D;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,EAAE,wBAAwB,CAAC,QAAQ,CAAC,CAAC;IAExD;;;;;;;;;;OAUG;IACH,IAAI,WAAW,IAAI,wBAAwB,CAAC,QAAQ,CAAC,CASpD;IAEQ,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI;IAMtD;;;;;;;;;;;;;;;OAeG;IACH,SAAS,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI3C;;;;OAIG;IACG,iBAAiB,CAAC,KAAK,EAAE,wBAAwB,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAcnG;;;;;OAKG;cACa,OAAO,CAAC,KAAK,EAAE,wBAAwB,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,KAAK,CAAA;KAAE,CAAC;IAclH;;;;;;;;;;;;;;;OAeG;IACH,SAAS,CAAC,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;IAI9E,6FAA6F;cAC7E,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,KAAK,CAAA;KAAE,CAAC;IAU/F;;;;OAIG;cACa,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpF;;;;;;OAMG;cACa,OAAO,IAAI,OAAO,CAAC,wBAAwB,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC;IAelF,wFAAwF;IACxF,SAAS,CAAC,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAKnE,oFAAoF;IACpF,SAAS,CAAC,WAAW,CAAC,CAAC,SAAS,eAAe,GAAG,eAAe,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC;CAGtF"}
+{"version":3,"file":"reconciling-multi-document-glsp-state.d.ts","sourceRoot":"","sources":["../../src/state/reconciling-multi-document-glsp-state.ts"],"names":[],"mappings":"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"}