@hydranium/glsp-server 1.0.0-next.16 → 1.0.0-next.160

package/lib/state/full-text-hydranium-glsp-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"full-text-hydranium-glsp-state.d.ts","sourceRoot":"","sources":["../../src/state/full-text-hydranium-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;AAElD,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAEhF,gFAAgF;AAChF,MAAM,WAAW,mBAAmB;IACjC,IAAI,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBACa,0BAA0B,CAAC,KAAK,SAAS,OAAO,CAC1D,SAAQ,0BAA0B,CAAC,KAAK,EAAE,mBAAmB,CAC7D,YAAW,cAAc,CAAC,mBAAmB,CAAC;IAE9C,IAAI,WAAW,IAAI,YAAY,CAAC,mBAAmB,CAAC,CAInD;IAEK,iBAAiB,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;CAQpE"}
+{"version":3,"file":"full-text-hydranium-glsp-state.d.ts","sourceRoot":"","sources":["../../src/state/full-text-hydranium-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;AAElD,OAAO,EAAE,KAAK,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACrF,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAEhF,gFAAgF;AAChF,MAAM,WAAW,mBAAmB;IACjC,IAAI,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBACa,0BAA0B,CAAC,KAAK,SAAS,OAAO,CAC1D,SAAQ,0BAA0B,CAAC,KAAK,EAAE,mBAAmB,CAC7D,YAAW,cAAc,CAAC,mBAAmB,CAAC;IAE9C,IAAI,WAAW,IAAI,YAAY,CAAC,mBAAmB,CAAC,CAInD;IAEK,iBAAiB,CAAC,KAAK,EAAE,mBAAmB,EAAE,OAAO,GAAE,OAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;CAIrG"}

package/lib/state/full-text-hydranium-glsp-state.js

@@ -29,11 +29,11 @@ import { AbstractHydraniumGlspState } from './abstract-hydranium-glsp-state.js';
  *   `serializer.Serializer` reached via `sharedServices.ServiceRegistry`
  *   (so multi-grammar workspaces route to the right serializer). `MaybePromise`
  *   because serialization may be async; the sync fast path is preserved.
- * - {@link updateSourceModel} pushes the text back through
- *   `ModelService.update` (which accepts a raw text payload) and captures the
- *   re-parsed root.
+ * - {@link updateSourceModel} pushes the text back through the diagram's
+ *   session (`update` accepts a raw text payload) and captures the re-parsed
+ *   root, gated on the caller's `basedOn`; it throws without a session.
  *
- * No `baseline` / conflict reconcile: a whole-document model has exactly one
+ * No `base` / conflict reconcile: a whole-document model has exactly one
  * field, so every concurrent edit is a same-field collision and undo / redo
  * degrade to drop-on-divergence. Adopters that need field-level undo use
  * `ReconcilingTransferHydraniumGlspState` instead.
@@ -44,12 +44,8 @@ let FullTextHydraniumGlspState = class FullTextHydraniumGlspState extends Abstra
         const text = serializer.serializeAst(this._sourceRoot);
         return isPromiseLike(text) ? text.then(value => ({ text: value })) : { text };
     }
-    async updateSourceModel(model) {
-        const document = await this.sharedServices.model.ModelService.update({
-            uri: this._sourceUri,
-            model: model.text,
-            clientId: this.clientId
-        });
+    async updateSourceModel(model, basedOn = this.basedOn) {
+        const document = await this.requireModelSession().update({ uri: this._sourceUri, model: model.text, basedOn });
         this.setSourceRoot(this._sourceUri, document.root);
     }
 };

package/lib/state/full-text-hydranium-glsp-state.js.map

@@ -1 +1 @@
-{"version":3,"file":"full-text-hydranium-glsp-state.js","sourceRoot":"","sources":["../../src/state/full-text-hydranium-glsp-state.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;;;;;;;AAGlF,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC,OAAO,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACzC,OAAO,EAAE,aAAa,EAAqB,MAAM,qBAAqB,CAAC;AACvE,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAOhF;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEI,IAAM,0BAA0B,GAAhC,MAAM,0BACV,SAAQ,0BAAsD;IAG9D,IAAI,WAAW;QACZ,MAAM,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC;QACrH,MAAM,IAAI,GAAG,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACvD,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC;IACjF,CAAC;IAED,KAAK,CAAC,iBAAiB,CAAC,KAA0B;QAC/C,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC;YAClE,GAAG,EAAE,IAAI,CAAC,UAAU;YACpB,KAAK,EAAE,KAAK,CAAC,IAAI;YACjB,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACzB,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,IAAa,CAAC,CAAC;IAC/D,CAAC;CACH,CAAA;AAlBY,0BAA0B;IADtC,UAAU,EAAE;GACA,0BAA0B,CAkBtC"}
+{"version":3,"file":"full-text-hydranium-glsp-state.js","sourceRoot":"","sources":["../../src/state/full-text-hydranium-glsp-state.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;;;;;;;AAGlF,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC,OAAO,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACzC,OAAO,EAAgB,aAAa,EAAqB,MAAM,qBAAqB,CAAC;AACrF,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAOhF;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEI,IAAM,0BAA0B,GAAhC,MAAM,0BACV,SAAQ,0BAAsD;IAG9D,IAAI,WAAW;QACZ,MAAM,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC;QACrH,MAAM,IAAI,GAAG,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACvD,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC;IACjF,CAAC;IAED,KAAK,CAAC,iBAAiB,CAAC,KAA0B,EAAE,UAAmB,IAAI,CAAC,OAAO;QAChF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,mBAAmB,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,UAAU,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;QAC/G,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,IAAa,CAAC,CAAC;IAC/D,CAAC;CACH,CAAA;AAdY,0BAA0B;IADtC,UAAU,EAAE;GACA,0BAA0B,CActC"}

package/lib/state/reconcile-source-model-write.d.ts

@@ -6,7 +6,7 @@
  *
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
-import { type ConflictResolver, type Logger } from '@hydranium/protocol';
+import { type BasedOn, type ConflictResolver, type Logger } from '@hydranium/protocol';
 /**
  * The I/O and policy a {@link reconcileSourceModelWrite} call needs. Deliberately
  * a plain record rather than a base class: the states that use it differ in what
@@ -16,15 +16,16 @@ import { type ConflictResolver, type Logger } from '@hydranium/protocol';
  */
 export interface SourceModelWriteHooks<TModel> {
     /**
-     * Write `model` and capture the resulting state. Called with a `baseVersion`
-     * on the first attempt (opting into the `ConflictError` gate) and without one
-     * on the merged / forced retries, where the point is to land the write.
+     * Write `model` and record the resulting state. Called with the caller's own
+     * `basedOn` on the first attempt (opting into the `ConflictError` gate) and
+     * with `'anything'` on the merged / forced retries, where the reconcile has
+     * already decided to win and the point is to land the write.
      */
-    persist(model: TModel, baseVersion?: number): Promise<void>;
+    persist(model: TModel, basedOn: BasedOn): Promise<void>;
     /** Current server-side projection, or `undefined` when unavailable. */
     refetch(): Promise<TModel | undefined>;
-    /** Last in-sync projection the user's intent is measured against. */
-    readonly baseline: TModel | undefined;
+    /** The last in-sync projection the user's intent is measured against. */
+    readonly base: TModel | undefined;
     readonly conflictResolver: ConflictResolver;
     readonly logger: Logger;
     /** Invoked when the edit is dropped, so the caller can resync its own state. */
@@ -39,5 +40,5 @@ export interface SourceModelWriteHooks<TModel> {
  * re-thrown untouched — this function only knows how to handle the specific
  * failure of "the based-on version was superseded".
  */
-export declare function reconcileSourceModelWrite<TModel extends object>(model: TModel, version: number | undefined, hooks: SourceModelWriteHooks<TModel>): Promise<void>;
+export declare function reconcileSourceModelWrite<TModel extends object>(model: TModel, basedOn: BasedOn, hooks: SourceModelWriteHooks<TModel>): Promise<void>;
 //# sourceMappingURL=reconcile-source-model-write.d.ts.map

package/lib/state/reconcile-source-model-write.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reconcile-source-model-write.d.ts","sourceRoot":"","sources":["../../src/state/reconcile-source-model-write.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,MAAM,EAAmB,MAAM,qBAAqB,CAAC;AAE1F;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB,CAAC,MAAM;IAC1C;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,uEAAuE;IACvE,OAAO,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACvC,qEAAqE;IACrE,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IAC5C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,gFAAgF;IAChF,iBAAiB,IAAI,IAAI,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,wBAAsB,yBAAyB,CAAC,MAAM,SAAS,MAAM,EAClE,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,KAAK,EAAE,qBAAqB,CAAC,MAAM,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,CA4Bf"}
+{"version":3,"file":"reconcile-source-model-write.d.ts","sourceRoot":"","sources":["../../src/state/reconcile-source-model-write.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,MAAM,EAAmB,MAAM,qBAAqB,CAAC;AAExG;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB,CAAC,MAAM;IAC1C;;;;;OAKG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,uEAAuE;IACvE,OAAO,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACvC,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IAC5C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,gFAAgF;IAChF,iBAAiB,IAAI,IAAI,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,wBAAsB,yBAAyB,CAAC,MAAM,SAAS,MAAM,EAClE,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,qBAAqB,CAAC,MAAM,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,CA8Bf"}

package/lib/state/reconcile-source-model-write.js

@@ -16,30 +16,30 @@ import { isConflictError } from '@hydranium/protocol';
  * re-thrown untouched — this function only knows how to handle the specific
  * failure of "the based-on version was superseded".
  */
-export async function reconcileSourceModelWrite(model, version, hooks) {
+export async function reconcileSourceModelWrite(model, basedOn, hooks) {
     try {
-        await hooks.persist(model, version);
+        await hooks.persist(model, basedOn);
     }
     catch (err) {
         if (!isConflictError(err)) {
             throw err;
         }
-        const outcome = await hooks.conflictResolver.resolve(hooks.baseline ?? model, model, () => hooks.refetch());
+        const outcome = await hooks.conflictResolver.resolve(hooks.base ?? model, model, () => hooks.refetch());
         switch (outcome.status) {
             case 'merged':
-                await hooks.persist(outcome.merged);
+                await hooks.persist(outcome.merged, 'anything');
                 return;
             case 'no-op':
-                hooks.logger.debug(`updateSourceModel no-op (v${err.expected} → v${err.actual}); already in sync`);
+                hooks.logger.debug(`updateSourceModel no-op (v${err.expectedVersion} → v${err.actualVersion}); already in sync`);
                 return;
             case 'conflict':
-                hooks.logger.warn(`updateSourceModel conflict (v${err.expected} → v${err.actual}); dropping the diagram edit — ` +
+                hooks.logger.warn(`updateSourceModel conflict (v${err.expectedVersion} → v${err.actualVersion}); dropping the diagram edit — ` +
                     'a foreign writer changed the same field');
                 hooks.onConflictDropped();
                 return;
             case 'unavailable':
-                hooks.logger.warn(`updateSourceModel refetch unavailable (v${err.expected} → v${err.actual}); forcing without version`);
-                await hooks.persist(model);
+                hooks.logger.warn(`updateSourceModel refetch unavailable (v${err.expectedVersion} → v${err.actualVersion}); forcing without version`);
+                await hooks.persist(model, 'anything');
                 return;
         }
     }

package/lib/state/reconcile-source-model-write.js.map

@@ -1 +1 @@
-{"version":3,"file":"reconcile-source-model-write.js","sourceRoot":"","sources":["../../src/state/reconcile-source-model-write.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAsC,eAAe,EAAE,MAAM,qBAAqB,CAAC;AA0B1F;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAC5C,KAAa,EACb,OAA2B,EAC3B,KAAoC;IAEpC,IAAI,CAAC;QACF,MAAM,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACvC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACZ,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC;YACzB,MAAM,GAAG,CAAC;QACb,CAAC;QACD,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,IAAI,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QAC5G,QAAQ,OAAO,CAAC,MAAM,EAAE,CAAC;YACtB,KAAK,QAAQ;gBACV,MAAM,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;gBACpC,OAAO;YACV,KAAK,OAAO;gBACT,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,6BAA6B,GAAG,CAAC,QAAQ,OAAO,GAAG,CAAC,MAAM,oBAAoB,CAAC,CAAC;gBACnG,OAAO;YACV,KAAK,UAAU;gBACZ,KAAK,CAAC,MAAM,CAAC,IAAI,CACd,gCAAgC,GAAG,CAAC,QAAQ,OAAO,GAAG,CAAC,MAAM,iCAAiC;oBAC3F,yCAAyC,CAC9C,CAAC;gBACF,KAAK,CAAC,iBAAiB,EAAE,CAAC;gBAC1B,OAAO;YACV,KAAK,aAAa;gBACf,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,2CAA2C,GAAG,CAAC,QAAQ,OAAO,GAAG,CAAC,MAAM,4BAA4B,CAAC,CAAC;gBACxH,MAAM,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;gBAC3B,OAAO;QACb,CAAC;IACJ,CAAC;AACJ,CAAC"}
+{"version":3,"file":"reconcile-source-model-write.js","sourceRoot":"","sources":["../../src/state/reconcile-source-model-write.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAoD,eAAe,EAAE,MAAM,qBAAqB,CAAC;AA2BxG;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAC5C,KAAa,EACb,OAAgB,EAChB,KAAoC;IAEpC,IAAI,CAAC;QACF,MAAM,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACvC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACZ,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC;YACzB,MAAM,GAAG,CAAC;QACb,CAAC;QACD,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,IAAI,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QACxG,QAAQ,OAAO,CAAC,MAAM,EAAE,CAAC;YACtB,KAAK,QAAQ;gBACV,MAAM,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;gBAChD,OAAO;YACV,KAAK,OAAO;gBACT,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,6BAA6B,GAAG,CAAC,eAAe,OAAO,GAAG,CAAC,aAAa,oBAAoB,CAAC,CAAC;gBACjH,OAAO;YACV,KAAK,UAAU;gBACZ,KAAK,CAAC,MAAM,CAAC,IAAI,CACd,gCAAgC,GAAG,CAAC,eAAe,OAAO,GAAG,CAAC,aAAa,iCAAiC;oBACzG,yCAAyC,CAC9C,CAAC;gBACF,KAAK,CAAC,iBAAiB,EAAE,CAAC;gBAC1B,OAAO;YACV,KAAK,aAAa;gBACf,KAAK,CAAC,MAAM,CAAC,IAAI,CACd,2CAA2C,GAAG,CAAC,eAAe,OAAO,GAAG,CAAC,aAAa,4BAA4B,CACpH,CAAC;gBACF,MAAM,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;gBACvC,OAAO;QACb,CAAC;IACJ,CAAC;AACJ,CAAC"}

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

@@ -8,7 +8,8 @@
  ********************************************************************************/
 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 BasedOn, type TransferElement } from '@hydranium/protocol';
 import { AbstractHydraniumGlspState } from './abstract-hydranium-glsp-state.js';
 /**
  * Source model spanning more than one document: the primary document's
@@ -39,43 +40,30 @@ 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
+ * `basedOn`, each secondary on {@link secondaryBasedOn}, 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. A write based on `'anything'` — a
+ * merged retry, an undo or redo replaying a 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.
  */
 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
+     * {@link setSourceRoot}. Same role as the single-document base: the state a
      * forward-write conflict reconciles the user's intent against.
      */
-    protected baseline?: MultiDocumentSourceModel<TPrimary>;
+    protected base?: MultiDocumentSourceModel<TPrimary>;
     /**
      * Projection of the primary plus every registered secondary, in the framework
      * encoder's `'grammar'` mode (authored state only — cross-references as
@@ -93,14 +81,14 @@ export declare class ReconcilingMultiDocumentGlspState<TRoot extends AstNode, TP
      * 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).
+     * 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
+     * `super.setSourceRoot(...)` 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,49 +96,61 @@ 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>, basedOn?: BasedOn): 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 `basedOn`, each secondary on {@link secondaryBasedOn}, or
+     * every document on `'anything'` when `basedOn` is `'anything'`. 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}).
      */
-    protected persist(model: MultiDocumentSourceModel<TPrimary>, baseVersion?: number): Promise<{
+    protected persist(model: MultiDocumentSourceModel<TPrimary>, basedOn: BasedOn): Promise<{
         root: TRoot;
     }>;
     /**
-     * Whether `candidate` differs from the baseline projection of the same
+     * 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 `session.create`: `updateAll` opens nothing.
+     */
+    protected openForWrite(session: ClientSession<AstNode>, uri: string): Promise<void>;
     /**
-     * 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.
+     * What a secondary write declares it was based on. Default: the version the
+     * secondary had when the source root was last read
+     * ({@link AbstractHydraniumGlspState.snapshotVersionOf}), so a foreign edit
+     * to it since is reported as a conflict and reconciled rather than
+     * overwritten; `'anything'` for a secondary with no recorded version.
+     * Return `'anything'` to force secondary writes.
      */
-    protected persistSecondary(uri: string, model: TransferElement): Promise<void>;
+    protected secondaryBasedOn(uri: string): BasedOn;
     /**
-     * Refetch hook — the current settled projection across the write set, used by
-     * the conflict resolver to replay the user's intent against fresh state.
+     * Refetch hook — the current projection across the write set, each document
+     * read through {@link AbstractHydraniumGlspState.readCurrentRoot}: 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.

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":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,KAAK,aAAa,EAA+B,MAAM,iBAAiB,CAAC;AAClF,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACzE,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;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,IAAI,CAAC,EAAE,wBAAwB,CAAC,QAAQ,CAAC,CAAC;IAEpD;;;;;;;;;;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;;;;;OAKG;IACG,iBAAiB,CAAC,KAAK,EAAE,wBAAwB,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAE,OAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IAclH;;;;;;;;;OASG;cACa,OAAO,CAAC,KAAK,EAAE,wBAAwB,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,KAAK,CAAA;KAAE,CAAC;IAqB9G;;;;;;;;;;;;;;;OAeG;IACH,SAAS,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;IAI1E;;;;;OAKG;IACH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAInF;;;;;;;OAOG;IACH,SAAS,CAAC,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIhD;;;;;;;OAOG;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"}

package/lib/state/reconciling-multi-document-glsp-state.js

@@ -28,43 +28,30 @@ import { reconcileSourceModelWrite } from './reconcile-source-model-write.js';
  * 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
+ * `basedOn`, each secondary on {@link secondaryBasedOn}, 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. A write based on `'anything'` — a
+ * merged retry, an undo or redo replaying a 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.
  */
 let ReconcilingMultiDocumentGlspState = class ReconcilingMultiDocumentGlspState extends AbstractHydraniumGlspState {
     /**
      * Last in-sync projection across the whole write set, captured on every
-     * {@link setSourceRoot}. Same role as the single-document baseline: the state a
+     * {@link setSourceRoot}. Same role as the single-document base: the state a
      * forward-write conflict reconciles the user's intent against.
      */
-    baseline;
+    base;
     /**
      * Projection of the primary plus every registered secondary, in the framework
      * encoder's `'grammar'` mode (authored state only — cross-references as
@@ -89,20 +76,20 @@ let ReconcilingMultiDocumentGlspState = class ReconcilingMultiDocumentGlspState
     setSourceRoot(uri, root) {
         super.setSourceRoot(uri, root);
         this.trackWriteSet(uri);
-        this.baseline = this.sourceModel;
+        this.base = this.sourceModel;
     }
     /**
      * 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).
+     * 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
+     * `super.setSourceRoot(...)` 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.
@@ -112,98 +99,113 @@ let ReconcilingMultiDocumentGlspState = class ReconcilingMultiDocumentGlspState
     }
     /**
      * 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.
      */
-    async updateSourceModel(model, version) {
-        return reconcileSourceModelWrite(model, version, {
-            persist: async (candidate, baseVersion) => {
-                const { root } = await this.persist(candidate, baseVersion);
+    async updateSourceModel(model, basedOn = this.basedOn) {
+        return reconcileSourceModelWrite(model, basedOn, {
+            persist: async (candidate, candidateBasedOn) => {
+                const { root } = await this.persist(candidate, candidateBasedOn);
                 this.setSourceRoot(this._sourceUri, root);
             },
             refetch: () => this.refetch(),
-            baseline: this.baseline,
+            base: this.base,
             conflictResolver: this.conflictResolver,
             logger: this.logger,
             onConflictDropped: () => this.refreshSourceRoot()
         });
     }
     /**
-     * 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 `basedOn`, each secondary on {@link secondaryBasedOn}, or
+     * every document on `'anything'` when `basedOn` is `'anything'`. 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}).
      */
-    async persist(model, baseVersion) {
+    async persist(model, basedOn) {
+        const primaryChanged = this.hasChanged(this.base?.primary, model.primary);
+        const updates = primaryChanged
+            ? [{ uri: this._sourceUri, model: model.primary, basedOn }]
+            : [];
         for (const [uri, secondary] of Object.entries(model.secondaries)) {
-            if (this.hasChanged(this.baseline?.secondaries[uri], secondary)) {
-                await this.persistSecondary(uri, secondary);
+            if (this.hasChanged(this.base?.secondaries[uri], secondary)) {
+                updates.push({ uri, model: secondary, basedOn: basedOn === 'anything' ? 'anything' : this.secondaryBasedOn(uri) });
             }
         }
-        if (!this.hasChanged(this.baseline?.primary, model.primary)) {
-            // Nothing to write, so nothing to gate either — return the root already
-            // captured rather than round-tripping the document for no reason.
+        if (updates.length === 0) {
             return { root: this._sourceRoot };
         }
-        return this.persistPrimary(model.primary, baseVersion);
+        const session = this.requireModelSession();
+        for (const update of updates) {
+            await this.openForWrite(session, update.uri);
+        }
+        const documents = await session.updateAll({ updates });
+        return { root: primaryChanged ? documents[0].root : this._sourceRoot };
     }
     /**
-     * Whether `candidate` differs from the baseline projection of the same
+     * 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.
      */
-    hasChanged(baseline, candidate) {
-        return baseline === undefined || JSON.stringify(baseline) !== JSON.stringify(candidate);
+    hasChanged(base, candidate) {
+        return base === undefined || JSON.stringify(base) !== JSON.stringify(candidate);
     }
-    /** Write the primary document, opting into the conflict gate when `baseVersion` is given. */
-    async persistPrimary(model, baseVersion) {
-        const document = await this.sharedServices.model.ModelService.update({
-            uri: this._sourceUri,
-            model,
-            clientId: this.clientId,
-            baseVersion
-        });
-        return document;
+    /**
+     * 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 `session.create`: `updateAll` opens nothing.
+     */
+    openForWrite(session, uri) {
+        return session.open(uri);
     }
     /**
-     * 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.
+     * What a secondary write declares it was based on. Default: the version the
+     * secondary had when the source root was last read
+     * ({@link AbstractHydraniumGlspState.snapshotVersionOf}), so a foreign edit
+     * to it since is reported as a conflict and reconciled rather than
+     * overwritten; `'anything'` for a secondary with no recorded version.
+     * Return `'anything'` to force secondary writes.
      */
-    async persistSecondary(uri, model) {
-        await this.sharedServices.model.ModelService.update({ uri, model, clientId: this.clientId });
+    secondaryBasedOn(uri) {
+        return this.snapshotVersionOf(uri) ?? 'anything';
     }
     /**
-     * Refetch hook — the current settled projection across the write set, used by
-     * the conflict resolver to replay the user's intent against fresh state.
+     * Refetch hook — the current projection across the write set, each document
+     * read through {@link AbstractHydraniumGlspState.readCurrentRoot}: 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.
      */
     async refetch() {
-        const fresh = await this.sharedServices.model.ModelService.validated(this._sourceUri).catch(() => undefined);
-        if (!fresh) {
+        const theirs = await this.readCurrentRoot(this._sourceUri);
+        if (!theirs) {
             return undefined;
         }
         const secondaries = {};
         for (const uri of this.secondaryUris) {
-            const settled = await this.sharedServices.model.ModelService.validated(uri).catch(() => undefined);
-            if (settled) {
-                secondaries[uri] = this.projectRoot(settled.root);
+            const root = await this.readCurrentRoot(uri);
+            if (root) {
+                secondaries[uri] = this.projectRoot(root);
             }
         }
-        return { primary: this.projectRoot(fresh.root), secondaries };
+        return { primary: this.projectRoot(theirs), secondaries };
     }
     /** Project a currently-loaded document's root, or `undefined` when it is not loaded. */
     projectDocument(uri) {