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

package/lib/storage/hydranium-glsp-storage.d.ts

@@ -9,10 +9,60 @@
 import { type Action, ActionDispatcher, type ClientSession, type ClientSessionListener, ClientSessionManager, type DefaultCommandStack, type Disposable, Logger as GlspLogger, type MaybePromise, ModelValidator, type RequestModelAction, type SaveModelAction, type SourceModelStorage } from '@eclipse-glsp/server';
 import { Debouncer, DisposableCollection } from '@hydranium/protocol';
 import { type AstNode } from '@hydranium/langium';
-import { AstDocument, type AstDocumentSavedEvent, type AstDocumentUpdatedEvent, type ServerSharedServices } from '@hydranium/core';
+import { AstDocument, type AstDocumentSavedEvent, type AstDocumentUpdatedEvent, type ClientSession as ModelClientSession, type DocumentDirtyChangedEvent, type ServerSharedServices } from '@hydranium/core';
 import { type AbstractHydraniumGlspState } from '../state/abstract-hydranium-glsp-state.js';
 import { type HydraniumGlspSubmissionHandler } from '../submission/hydranium-glsp-submission-handler.js';
-import { SaveConflictPolicy } from './save-conflict-policy.js';
+import { SaveDeliveryPolicy } from './save-delivery-policy.js';
+/**
+ * A save action arrived with nowhere to write to. A save action carries no
+ * request id, so it falls through to the error handler and `message` becomes
+ * the toast text.
+ *
+ * Rendered at the raise site rather than by a carrier method, because GLSP's
+ * action protocol has no slot for an identity anywhere — every member of its
+ * message, status and reject actions is prose or an enum, and
+ * `MessageAction.details` is not a substitute since it is prose populated from
+ * `cause?.toString?.()`, and a Theia host shows it to a user on demand. So the
+ * throw is the last place that still knows which message this is.
+ */
+export declare const SAVE_TARGET_UNKNOWN: import("@hydranium/protocol").MessageDefinition<"Could not determine where to save this model">;
+/**
+ * A model request arrived without the source URI it is required to carry.
+ * Rendered at the raise site, like its save-path sibling and for the same
+ * reason.
+ */
+export declare const SOURCE_URI_MISSING: import("@hydranium/protocol").MessageDefinition<"Could not open this model: the request did not say which document to load">;
+/**
+ * Why the canvas has stopped accepting edits.
+ *
+ * **A READONLY canvas is otherwise indistinguishable from a broken one.** The
+ * client's answer to {@link SetEditModeAction} is to withdraw the tool palette,
+ * so the surface a reader was working in silently loses the only control it had,
+ * with the cause — a syntax error in a document that may not even be open —
+ * nowhere on screen. The mode flip is the mechanism; this is the only part of it
+ * a user can see.
+ *
+ * Rendered at the raise site, like its two siblings above and for the same
+ * reason: every member of GLSP's status action is prose or an enum.
+ *
+ * It names the recovery rather than the fault, because the fault already has a
+ * surface — the squiggle and the problems list, both of which say WHICH
+ * character — and repeating it here would put a second, less precise account of
+ * the same error on screen. What no other surface says is that the diagram is
+ * waiting on it.
+ */
+export declare const DIAGRAM_READONLY_PARSE_ERROR: import("@hydranium/protocol").MessageDefinition<"Read-only: this document has a syntax error. Fix it to edit the diagram again.">;
+/**
+ * The diagram's GLSP client id is still live as another participant's client
+ * id once the load has waited for it to free, so the diagram does not load.
+ *
+ * Rendered at the raise site, as {@link SAVE_TARGET_UNKNOWN} is and for the
+ * same reason, and dispatched to the client as a message of its own: a model
+ * request fails as a rejection whose detail is the English cause, which no user
+ * sees. It names the recovery: a host that numbers its diagram clients gives a
+ * reopened diagram a fresh id.
+ */
+export declare const DIAGRAM_SESSION_REFUSED: import("@hydranium/protocol").MessageDefinition<"Could not open this diagram: its identifier is still in use by another editor. Close the diagram and open it again.">;
 /**
  * GLSP source-model storage base shared by all hydranium adopters.
  * Provides the DI signature, the {@link ClientSessionListener} +
@@ -33,17 +83,24 @@ import { SaveConflictPolicy } from './save-conflict-policy.js';
  *
  * Adopters with richer needs override the seams ({@link isStructurallyBroken},
  * {@link onParseErrorChanged}, {@link onSourceModelSettled}) rather than the
- * whole flow, and select a {@link SaveConflictPolicy} via the bound option to
- * tune how {@link saveSourceModel} reacts to a concurrent edit.
+ * whole flow, and select a {@link SaveDeliveryPolicy} via the bound option to
+ * tune how {@link saveSourceModel} delivers its result.
+ *
+ * **One client session per GLSP client session.** `init` registers the GLSP
+ * client id as a client session ({@link registerModelSession}) and hands it to
+ * the state as `modelSession`. The primary is opened through it on load, and
+ * every document that joins the write set as it joins
+ * ({@link openSecondary}); a document that leaves the write set stays open
+ * until the next save, so leaving never reverts the diagram's unsaved edits to
+ * it. Disposing the storage ends the session, which closes everything it has
+ * open.
  *
- * **Default `saveSourceModel` flow.** Delegates to `ModelService.save`, which
- * serialises through the language-specific `Serializer` bound at
- * `services.serializer.Serializer` (resolved per-URI via `ServiceRegistry`),
- * updates the multi-client text-document store, drives a rebuild, and writes the
- * result via the `WritableFileSystemProvider`. The bound
- * {@link SaveConflictPolicy} (default {@link DEFAULT_SAVE_CONFLICT_POLICY},
- * `overwrite`) decides the based-on-version guard, await-vs-fire-and-forget, and
- * failure handling.
+ * **Default `saveSourceModel` flow.** Flushes the stored text of every
+ * document the diagram's session has open via `AstDocumentManager.save`, with
+ * no serializer in the path — the update path already put the settled text in
+ * the store. The bound {@link SaveDeliveryPolicy} (default
+ * {@link DEFAULT_SAVE_DELIVERY_POLICY}, `await`) decides
+ * await-vs-fire-and-forget and failure handling.
  *
  * **tempId filter.** GLSP's `DefaultGlobalActionProvider` spins up a
  * throwaway per-diagram-type container with upstream's {@link TEMPORARY_CLIENT_ID}
@@ -54,9 +111,9 @@ import { SaveConflictPolicy } from './save-conflict-policy.js';
  * **Lifecycle ordering.** `init` runs after DI resolution and parks the
  * secondary-write-set watch, which outlives any single load.
  * {@link sessionDisposed} calls {@link dispose}, which drains
- * {@link toDispose} idempotently. Every transient subscription created in
- * {@link doLoadSourceModel} is parked on {@link toDispose} so the drain catches
- * them on client-detach.
+ * {@link toDispose} idempotently and then ends the client session. Every
+ * transient subscription created in {@link doLoadSourceModel} is parked on
+ * {@link toDispose} so the drain catches them on client-detach.
  */
 export declare class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string> implements SourceModelStorage, ClientSessionListener, Disposable {
     protected readonly logger: GlspLogger;
@@ -75,14 +132,13 @@ export declare class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel =
      */
     protected readonly modelValidator?: ModelValidator;
     /**
-     * Selected {@link SaveConflictPolicy} for {@link saveSourceModel}. Bind the
-     * {@link SaveConflictPolicy} token in a `DiagramModule` to choose a policy;
-     * left unbound it resolves to {@link DEFAULT_SAVE_CONFLICT_POLICY}
-     * (`overwrite`, last-write-wins). Read via {@link saveConflictPolicy} so the
-     * fallback is applied even when inversify injects `undefined` for an unbound
-     * `@optional()` member.
+     * Selected {@link SaveDeliveryPolicy} for {@link saveSourceModel}. Bind the
+     * {@link SaveDeliveryPolicy} token in a `DiagramModule` to choose a policy;
+     * left unbound it resolves to {@link DEFAULT_SAVE_DELIVERY_POLICY}. Read via
+     * {@link saveDeliveryPolicy} so the fallback is applied even when inversify
+     * injects `undefined` for an unbound `@optional()` member.
      */
-    protected readonly boundSaveConflictPolicy?: SaveConflictPolicy;
+    protected readonly boundSaveDeliveryPolicy?: SaveDeliveryPolicy;
     /** Disposables created during {@link doLoadSourceModel}; drained on session disposal. */
     protected toDispose: DisposableCollection;
     /**
@@ -94,6 +150,24 @@ export declare class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel =
      * with it rather than linger until the client detaches.
      */
     protected readonly secondarySubscriptions: Map<string, Disposable>;
+    /**
+     * Documents that left the write set since the last save. They stay open in
+     * the diagram's session until that save has persisted them, and are closed
+     * after it: closing a document as it leaves would revert the diagram's
+     * unsaved edits to it where the diagram was its last client.
+     */
+    protected readonly departedSecondaries: Set<string>;
+    /**
+     * How long a load waits for a client id another participant holds to free
+     * before refusing. A reloaded client can reconnect under its old id before
+     * the server has noticed the old connection close, which ends that
+     * connection's sessions a moment later.
+     */
+    protected readonly sessionWaitMs: number;
+    /** Set by {@link dispose}; a disposed storage registers no session again. */
+    protected disposed: boolean;
+    /** Saves of the diagram's own that GLSP's save handler awaits; see {@link handleDirtyChanged}. */
+    protected ownSavesPending: number;
     /**
      * Whether an external resubmit has ever been dispatched. Gates the
      * keep-the-last-valid-GModel branch, which needs to know a canvas is already
@@ -111,8 +185,36 @@ export declare class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel =
      */
     protected resubmitDebouncer: Debouncer;
     /** Latest event document awaiting the debounced resubmit; read by {@link flushResubmit} (last write wins). */
-    protected pendingResubmitDocument?: AstDocument<AstNode, unknown>;
+    protected pendingResubmitDocument?: AstDocument<AstNode>;
     protected init(): void;
+    /**
+     * Register the diagram's client session under the GLSP client id, or
+     * `undefined` when another participant holds that id, which is logged.
+     *
+     * The diagram then refuses to load ({@link requireModelSession}). Taking
+     * the id over would end the other participant's session under it, and
+     * working without a session would share that participant's opens and
+     * echoes, so its close would take the diagram's documents with it.
+     *
+     * A client id the framework reserves throws `ReservedClientIdError`:
+     * whoever chose the GLSP client id has a bug, and no later registration can
+     * succeed.
+     */
+    protected registerModelSession(): ModelClientSession<AstNode> | undefined;
+    /**
+     * The diagram's client session, registering it again when the id was held
+     * earlier. Throws `SessionClosedError` once the storage is disposed, and the
+     * refusal when the id is still held.
+     */
+    protected requireModelSession(): ModelClientSession<AstNode>;
+    /**
+     * {@link requireModelSession} for the load: while the id is held, wait up to
+     * {@link sessionWaitMs} for its holder to end before refusing, and tell the
+     * user when it does not.
+     */
+    protected awaitModelSession(): Promise<ModelClientSession<AstNode>>;
+    /** Resolve once the client session under `clientId` ends, or after `timeoutMs`. */
+    protected waitForSessionEnd(clientId: string, timeoutMs: number): Promise<void>;
     /**
      * Default load flow — {@link doLoadSourceModel}. Adopters whose load flow
      * needs more than the seams allow override this method.
@@ -120,12 +222,29 @@ export declare class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel =
     loadSourceModel(action: RequestModelAction): MaybePromise<void>;
     protected doLoadSourceModel(action: RequestModelAction): Promise<void>;
     /**
-     * Capture the initial settled root and apply the initial edit mode. `settled()`
-     * strips diagnostics by phase contract, so the first edit mode is `EDITABLE`;
-     * the first {@link handleModelUpdated} (at `Validated`, with diagnostics) flips
-     * it READONLY if the document has structural parse errors. Edit-mode +
-     * settle-hook actions are dispatched on a macrotask so the initial
+     * Capture the initial settled root and apply the initial edit mode. Edit-mode
+     * + settle-hook actions are dispatched on a macrotask so the initial
      * `requestModel → setModel` handshake isn't perturbed.
+     *
+     * **Whether the settled document carries diagnostics depends on how far it
+     * had already got, so the initial edit mode has two correct outcomes rather
+     * than one.** `settled()` strips nothing: it resolves AT OR ABOVE the
+     * integrity landmark and hands back the live document's own array. Its
+     * `AstDocument<TAst, never>` return type asserts emptiness for a document the
+     * wait had to DRIVE to that landmark, which is pre-validation — and for that
+     * one the mode here is `EDITABLE` and the flip to READONLY arrives with the
+     * first {@link handleModelUpdated}. A document already past `Validated` when
+     * the session opened resolves immediately with its diagnostics intact, and is
+     * decided correctly here with no later update owed. Any host that validates
+     * its workspace before a diagram is opened produces the second case, so
+     * neither is exceptional.
+     *
+     * **A correct decision is not a delivered one.** This dispatch happens inside
+     * the initial `requestModel`, before the client has the model — so the UI
+     * extensions that answer {@link onParseErrorChanged}'s actions are not yet
+     * constructed, and a canvas that opens READONLY over a broken document shows
+     * none of that feedback. The same timer carries {@link onSourceModelSettled},
+     * so an adopter's own initial actions have it too.
      */
     protected captureSettledRoot(rootUri: string, document: AstDocument<AstNode, never>): Promise<void>;
     /**
@@ -146,14 +265,22 @@ export declare class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel =
      * piece is a subscription, not an invalidation.
      */
     protected reconcileSecondarySubscriptions(): void;
+    /**
+     * Open a document that joined the write set through the diagram's session,
+     * where it stays open until the diagram's next save after it leaves the set,
+     * or the diagram's end. A document that does not exist yet is left to the
+     * write that creates it, and a failed open is logged: the write that needs
+     * the document opens it again and fails there.
+     */
+    protected openSecondary(uri: string): void;
     /**
      * React to a rebuild of a SECONDARY document by resubmitting the diagram, so
      * an external edit to (say) a layout file reaches the canvas.
      *
-     * Reuses {@link handleModelUpdated}'s authorship guard, and that is the load-
-     * bearing half rather than the resubmit: a diagram interaction that writes a
+     * Applies {@link handleModelUpdated}'s guard, and that is the load-bearing
+     * half rather than the resubmit: a diagram interaction that writes a
      * secondary — a drag persisting bounds to a layout file — comes back through
-     * this listener as the client's own `changed` edit, and resubmitting on it
+     * this listener caused by the client's own write, and resubmitting on it
      * fights the optimistic client-side move the user is still holding.
      *
      * Schedules the PRIMARY's current document, never the secondary's.
@@ -171,27 +298,35 @@ export declare class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel =
      * drag this client authors — the guard above gates the resubmit, not the
      * markers.
      */
-    protected handleSecondaryUpdated(uri: string, event: AstDocumentUpdatedEvent<AstNode, unknown>): void;
+    protected handleSecondaryUpdated(uri: string, event: AstDocumentUpdatedEvent<AstNode>): void;
     /**
      * The primary document's current state, or `undefined` when it is not
      * registered.
      *
      * Synchronous by construction — the phase-agnostic lookup door plus the shared
      * projection — so reacting to a secondary neither waits nor can force a build.
-     * `settled()` is not an alternative: it strips diagnostics by phase contract,
-     * and diagnostics are the reason {@link doUpdateAndSubmit} takes a separate
-     * event document at all.
+     * `settled()` is not an alternative: besides being asynchronous, it cannot be
+     * relied on to carry diagnostics — a document it has to drive to the landmark
+     * arrives pre-validation with an empty array — and diagnostics are the reason
+     * {@link doUpdateAndSubmit} takes a separate event document at all.
      */
-    protected currentPrimaryDocument(): AstDocument<AstNode, unknown> | undefined;
+    protected currentPrimaryDocument(): AstDocument<AstNode> | undefined;
     /**
      * React to an external rebuild reaching `Validated`. Self-cleans if the
      * session has vanished but this listener leaked (neither `sessionDisposed`
-     * nor `onClientClosed` fired on tab close). Resubmits for any change not
-     * authored by this client's own optimistic `changed` edit, then refreshes
-     * diagnostic markers for every update — including own edits, which skip
-     * the resubmit but can still change diagnostics.
+     * nor `onClientClosed` fired on tab close). Resubmits for any update this
+     * client's own write did not cause alone, then refreshes diagnostic markers
+     * for every update — including own writes, which skip the resubmit but can
+     * still change diagnostics. An event without `causedBy` is resubmitted.
+     *
+     * Own writes include a primary that the build of a write to a secondary
+     * swept in, which arrives `rebuilt`. Skipping it loses nothing the canvas
+     * shows: the operation behind the write submits once the write has
+     * answered, and a build steps its whole batch through each phase, so that
+     * submit already renders the relinked primary. What the later `Validated`
+     * adds are diagnostics, which the marker refresh carries.
      */
-    protected handleModelUpdated(rootUri: string, event: AstDocumentUpdatedEvent<AstNode, unknown>): Promise<void>;
+    protected handleModelUpdated(rootUri: string, event: AstDocumentUpdatedEvent<AstNode>): Promise<void>;
     /**
      * Whether this storage has outlived its session — disposing it as a side
      * effect when so. Checked from every subscription entry point because GLSP's
@@ -206,7 +341,7 @@ export declare class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel =
      * {@link resubmitDebouncer}, so a burst of rebuilds runs
      * {@link doUpdateAndSubmit} once with the most recent document.
      */
-    protected scheduleUpdateAndSubmit(document: AstDocument<AstNode, unknown>): void;
+    protected scheduleUpdateAndSubmit(document: AstDocument<AstNode>): void;
     /**
      * Debouncer callback: run the resubmit for the latest pending document
      * against this storage's (invariant) source URI and dispatch the result.
@@ -214,24 +349,45 @@ export declare class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel =
      */
     protected flushResubmit(): void;
     /**
-     * Coordinate the command stack when another client persists the document:
-     * mark our stack clean so the editor doesn't prompt to re-save identical
-     * content. Our own saves already settle the stack through the save flow.
+     * For a diagram module on GLSP's own command stack, which counts commands:
+     * mark it clean when another client persists the document.
+     * `HydraniumGlspCommandStack` reads the text store instead, and this does
+     * not move it.
+     */
+    protected handleModelSaved(event: AstDocumentSavedEvent<AstNode>): void;
+    /**
+     * Send the diagram's dirty state when a document it has open turns dirty or
+     * clean, the answer being the command stack's. GLSP sends it only with a
+     * model submission or a save of the diagram's own, so a save by another
+     * client, an editor included, or an edit that changes nothing the diagram
+     * shows would otherwise leave the client's marker wrong until the next
+     * gesture. A flip the diagram's own operation causes is sent twice, once
+     * here and once with the submission, and the client keeps the one state.
+     *
+     * Nothing is sent while a save of the diagram's own is awaited: GLSP's save
+     * handler sends the state once the save settles, reason `save`, and GLSP's
+     * client keeps a state only when it changes, so the save's own flip sent
+     * here first would leave that answer changing nothing. GLSP's saveable
+     * waits for exactly that answer, and times out without it.
      */
-    protected handleModelSaved(event: AstDocumentSavedEvent<AstNode, unknown>): void;
+    protected handleDirtyChanged(event: DocumentDirtyChangedEvent): void;
+    /** Send the command stack's dirty state, reason `external`. */
+    protected sendDirtyState(): void;
     /**
      * Re-settle to a guaranteed fully-linked + reprojected root, capture it, and
      * (unless suppressed) resubmit a deduped external GModel. Diagnostics for the
-     * edit-mode decision come from the event document (`settled()` strips them by
-     * phase contract).
+     * edit-mode decision come from the event document, because the re-settled one
+     * cannot be relied on to have any: a document driven to the landmark arrives
+     * pre-validation, and this path re-settles precisely to escape a transient
+     * mid-rebuild snapshot.
      */
-    protected doUpdateAndSubmit(rootUri: string, eventDocument: AstDocument<AstNode, unknown>): Promise<Action[]>;
+    protected doUpdateAndSubmit(rootUri: string, eventDocument: AstDocument<AstNode>): Promise<Action[]>;
     /**
      * Recompute the desired edit mode from the document's structural-error state,
      * flip {@link AbstractHydraniumGlspState.editMode}, and — only on a transition —
      * return the {@link onParseErrorChanged} actions. No transition → no actions.
      */
-    protected refreshEditMode(document: AstDocument<AstNode, unknown>): Action[];
+    protected refreshEditMode(document: AstDocument<AstNode>): Action[];
     /**
      * Seam: is the AST structurally broken (lexing/parsing errors)? Drives both
      * READONLY mode and the GModel resubmit skip — keeping the last valid canvas
@@ -239,46 +395,96 @@ export declare class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel =
      * carrying a Langium `lexing-error` / `parsing-error` code. Adopters override
      * to compose additional break reasons.
      */
-    protected isStructurallyBroken(document: AstDocument<AstNode, unknown>): boolean;
+    protected isStructurallyBroken(document: AstDocument<AstNode>): boolean;
     /**
-     * Seam: actions to emit when the structural-broken state transitions. Default:
-     * a single {@link SetEditModeAction} toggling READONLY ↔ EDITABLE — editing is
-     * disabled while the syntax is broken but re-enabled once it parses, a sound
-     * generic for any Langium-backed diagram. Adopters override to add or replace
-     * the transition feedback. The {@link AbstractHydraniumGlspState.editMode}
-     * flip itself is owned by {@link refreshEditMode}.
+     * Seam: actions to emit when the structural-broken state transitions.
+     * Default: a {@link SetEditModeAction} toggling READONLY ↔ EDITABLE — editing
+     * is disabled while the syntax is broken but re-enabled once it parses, a
+     * sound generic for any Langium-backed diagram — plus the
+     * {@link DIAGRAM_READONLY_PARSE_ERROR} band that says why, cleared on the way
+     * back. Adopters override to add or replace the transition feedback. The
+     * {@link AbstractHydraniumGlspState.editMode} flip itself is owned by
+     * {@link refreshEditMode}.
+     *
+     * **Both actions or neither, which is why they are one seam rather than
+     * two.** The mode flip removes the tool palette and the band is the only
+     * account of that, so an override that keeps one and drops the other produces
+     * either an unexplained loss of the palette or a warning about a restriction
+     * that is not in force.
+     *
+     * **The status is dispatched with no `timeout`, so it persists** — a
+     * time-limited band would describe a condition that outlasts it.
+     *
+     * **The slot is SHARED, and the other writer wins on one path.**
+     * `ModelSubmissionHandler`'s live validation writes the same slot, clearing
+     * it with `severity: 'NONE'` when it finishes, and an adopter dispatching its
+     * own `StatusAction` replaces this one too. Nothing re-asserts it. That is
+     * harmless while a document is being edited, because a resubmit is skipped
+     * once the AST is broken (see {@link doUpdateAndSubmit}) — but NOT at load:
+     * the initial `requestModel` submit is not that skipped path, so a diagram
+     * opened on an already-broken document shows this band and then loses it to
+     * the validation clear a moment later. Measured on a browser host, polling the
+     * overlay: no element, empty, the sentence, empty again.
      */
-    protected onParseErrorChanged(_document: AstDocument<AstNode, unknown>, broken: boolean): Action[];
+    protected onParseErrorChanged(_document: AstDocument<AstNode>, broken: boolean): Action[];
     /**
      * Seam: extra actions to dispatch right after the initial settled root is
      * captured (e.g. an adopter-specific status or palette refresh). Default: none.
      */
     protected onSourceModelSettled(_document: AstDocument<AstNode, never>): Action[];
-    /** The effective {@link SaveConflictPolicy}: the bound option, or {@link DEFAULT_SAVE_CONFLICT_POLICY} when unbound. */
-    protected get saveConflictPolicy(): SaveConflictPolicy;
-    /**
-     * Default save flow: route through `ModelService.save`. The framework
-     * serialise-and-persist machinery handles serialisation (via the
-     * language-specific `Serializer` bound at `services.serializer.Serializer`),
-     * the multi-client text-document update, the rebuild, and the eventual
-     * `WritableFileSystemProvider.writeFile`.
+    /** The effective {@link SaveDeliveryPolicy}: the bound option, or {@link DEFAULT_SAVE_DELIVERY_POLICY} when unbound. */
+    protected get saveDeliveryPolicy(): SaveDeliveryPolicy;
+    /**
+     * Default save flow: persist the store's current text for every document the
+     * diagram's session has open.
+     *
+     * **A save persists, it does not author.** Every diagram gesture already
+     * reached the store through the diagram's session, so the store holds the
+     * settled text and disk is the only thing behind. Re-serializing from the AST
+     * here cannot improve on that text and can only damage it: a serializer
+     * normalises formatting, and the comments the write path carries over keep
+     * none of the hand-formatting around them, so a save would reflow a document
+     * nothing changed — which is what a pure bounds drag does to the semantic
+     * file when only its layout moved.
+     *
+     * **What is saved is the primary, every tracked secondary
+     * (`AbstractHydraniumGlspState.trackSecondaryDocument`) and every document
+     * that left the write set since the last save**, so a document the diagram
+     * wrote is persisted whether or not it is the one the client named. One the
+     * diagram's session does not have open is skipped, even when another client
+     * has it open: that client's unsaved edits are not the diagram's to persist.
+     *
+     * **A save therefore names documents the gesture did not aim at**, which is
+     * why an unchanged one is not rewritten even though the user asked for a
+     * save: the mtime would move on a file they never touched.
+     * `AstDocumentManager.save` decides that per document and announces the save
+     * either way.
      *
-     * The configured {@link SaveConflictPolicy} (see {@link saveConflictPolicy})
-     * decides how a concurrent edit that advanced the document is handled:
-     * - `overwrite` (default): no based-on guard, await, propagate failures —
-     *   last-write-wins, correct for a single-editor head.
-     * - `reject`: guard on the captured `state.version`, await, surface a
-     *   `ConflictError` (and any other failure) to the GLSP save action.
-     * - `drop-and-log`: guard, fire-and-forget, log + swallow failures — a stale
-     *   diagram save is dropped because a concurrent form/code edit already wrote
-     *   the truth, and GLSP exposes no save-failure back-channel.
+     * The configured {@link SaveDeliveryPolicy} (see {@link saveDeliveryPolicy})
+     * decides await-vs-fire-and-forget and failure handling. It carries no
+     * based-on guard: the guard exists to stop a stale writer overwriting a newer
+     * document, and a flush persists the store — which already holds every other
+     * client's change, including the one that advanced the version.
      *
      * Returns `MaybePromise<void>` to match upstream `SourceModelStorage`:
-     * resolves with the persist under `overwrite`/`reject`, returns synchronously
-     * under `drop-and-log`. Adopters that bypass `ModelService` (writing through
-     * `WritableFileSystemProvider` directly) still override the whole method.
+     * resolves with the flush under `await`, returns synchronously under
+     * `fire-and-forget`. Adopters that bypass `AstDocumentManager` (writing
+     * through `WritableFileSystemProvider` directly) still override the whole
+     * method.
      */
     saveSourceModel(action: SaveModelAction): MaybePromise<void>;
+    /**
+     * Save the stored text of `primaryUri`, every tracked secondary and every
+     * document that left the write set since the last save, each only where
+     * the diagram's session has it open; then close those that left.
+     *
+     * Deduplicated, because a state that tracks its own primary as a secondary
+     * would otherwise save it twice and fire two save notifications for one
+     * save. Every save is called in one synchronous step, so each takes its text
+     * before anything can close a document of the set: saved one after another,
+     * a GLSP session ending during the first write closes the rest unsaved.
+     */
+    protected flushWriteSet(primaryUri: string): Promise<void>;
     /**
      * Normalise GLSP's `sourceUri` — which may be a filesystem PATH or a URI
      * string — to the URI string the workspace keys documents by.
@@ -305,6 +511,17 @@ export declare class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel =
      *
      * Returns it VERBATIM, in whatever form the client sent;
      * {@link toSourceModelUri} is what normalises it.
+     *
+     * A model request DOES carry a request id, so a throw here takes the
+     * client-request path rather than the toast path — and on that path `detail`
+     * comes from `cause?.toString?.()`. A single-argument throw therefore reaches
+     * neither the server log nor the client console: both print `undefined`. So
+     * the two readers are addressed separately, as on the save path: `message`
+     * names what failed in the user's terms and is rendered, `cause` names the
+     * action and the option key that was missing and stays English. On THIS path
+     * the cause reaches only logs — `RejectAction.detail` is read by nothing but
+     * the client action-dispatcher's `logger.warn` — which is not what makes it
+     * English; its content is.
      */
     protected getSourceUri(action: RequestModelAction): string;
     /**
@@ -314,12 +531,18 @@ export declare class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel =
      * {@link AbstractHydraniumGlspState.setSourceRoot}.
      *
      * A save action carries no request id, so a throw here reaches the user as a
-     * toast built from `message`, with `cause` behind its details control. The
-     * two therefore address different readers and must not be collapsed: the
-     * message names what failed in the user's terms, and the cause names which
-     * lookups came back empty for whom. Neither can name the URI — not having
-     * one IS the failure, and both sources are written together, so the typed
-     * `sourceUri` is equally empty whenever this fires.
+     * toast built from `message`, while `cause` travels in
+     * `MessageAction.details` — **which a Theia host DOES put in front of a
+     * user**, as a "Show details" button on the toast opening a dialog. So the
+     * two are not split by reachability; they are split by AUDIENCE, which is
+     * the older rule and the one that holds here. The message names what failed
+     * in the user's terms and is rendered; the cause names which lookups came
+     * back empty for whom, and stays English because a wire action kind, an
+     * option key and a client id address whoever composes the system — a
+     * translated developer string is a worse outcome than an untranslated one.
+     * Neither can name the URI — not having one IS the failure, and both sources
+     * are written together, so the typed `sourceUri` is equally empty whenever
+     * this fires.
      */
     protected getFileUri(action: SaveModelAction): string;
     /**
@@ -338,10 +561,14 @@ export declare class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel =
     refreshDiagnosticMarkers(): Promise<void>;
     sessionDisposed(_clientSession: ClientSession): void;
     /**
-     * Cancel any pending resubmit and drain every subscription — those registered
+     * Cancel any pending resubmit, drain every subscription — those registered
      * during {@link doLoadSourceModel} and the per-secondary ones, which live
-     * outside {@link toDispose} because they come and go with the write set.
+     * outside {@link toDispose} because they come and go with the write set —
+     * and end the diagram's client session, closing everything it has open.
      * Idempotent.
+     *
+     * The session ends last, once the detach listener is gone: its closes would
+     * otherwise report this storage's own teardown as a client detaching.
      */
     dispose(): void;
 }

package/lib/storage/hydranium-glsp-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hydranium-glsp-storage.d.ts","sourceRoot":"","sources":["../../src/storage/hydranium-glsp-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAGlF,OAAO,EACJ,KAAK,MAAM,EACX,gBAAgB,EAChB,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,oBAAoB,EAEpB,KAAK,mBAAmB,EACxB,KAAK,UAAU,EAGf,MAAM,IAAI,UAAU,EACpB,KAAK,YAAY,EAGjB,cAAc,EACd,KAAK,kBAAkB,EAEvB,KAAK,eAAe,EAEpB,KAAK,kBAAkB,EAEzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAEtE,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,WAAW,EAAE,KAAK,qBAAqB,EAAE,KAAK,uBAAuB,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEnI,OAAO,EAAE,KAAK,0BAA0B,EAAE,MAAM,2CAA2C,CAAC;AAC5F,OAAO,EAAE,KAAK,8BAA8B,EAAE,MAAM,oDAAoD,CAAC;AAEzG,OAAO,EAAgC,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AA8B7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,qBACa,oBAAoB,CAAC,KAAK,SAAS,OAAO,EAAE,YAAY,GAAG,MAAM,CAC3E,YAAW,kBAAkB,EAAE,qBAAqB,EAAE,UAAU;IAE5C,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAG,UAAU,CAAC;IAChB,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAG,oBAAoB,CAAC;IAChF,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAG,0BAA0B,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IACjE,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAG,oBAAoB,CAAC;IAC7D,SAAS,CAAC,QAAQ,CAAC,gBAAgB,EAAG,gBAAgB,CAAC;IACjD,SAAS,CAAC,QAAQ,CAAC,iBAAiB,EAAG,8BAA8B,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IACrG,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAG,mBAAmB,CAAC;IAE5E;;;;;;OAMG;IACiC,SAAS,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;IAEvF;;;;;;;OAOG;IACqC,SAAS,CAAC,QAAQ,CAAC,uBAAuB,CAAC,EAAE,kBAAkB,CAAC;IAExG,yFAAyF;IACzF,SAAS,CAAC,SAAS,uBAA8B;IAEjD;;;;;;;OAOG;IACH,SAAS,CAAC,QAAQ,CAAC,sBAAsB,0BAAiC;IAE1E;;;;;;OAMG;IACH,SAAS,CAAC,sBAAsB,UAAS;IAEzC;;;;;;OAMG;IACH,SAAS,CAAC,iBAAiB,EAAG,SAAS,CAAC;IAExC,8GAA8G;IAC9G,SAAS,CAAC,uBAAuB,CAAC,EAAE,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAGlE,SAAS,CAAC,IAAI,IAAI,IAAI;IAetB;;;OAGG;IACH,eAAe,CAAC,MAAM,EAAE,kBAAkB,GAAG,YAAY,CAAC,IAAI,CAAC;cAI/C,iBAAiB,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IA8B5E;;;;;;;OAOG;cACa,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAUzG;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,+BAA+B,IAAI,IAAI;IAkBjD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SAAS,CAAC,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,uBAAuB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,IAAI;IAerG;;;;;;;;;OASG;IACH,SAAS,CAAC,sBAAsB,IAAI,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,SAAS;IAK7E;;;;;;;OAOG;cACa,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,uBAAuB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAUpH;;;;;;;OAOG;IACH,SAAS,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IASlD;;;;OAIG;IACH,SAAS,CAAC,uBAAuB,CAAC,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,IAAI;IAKhF;;;;OAIG;IACH,SAAS,CAAC,aAAa,IAAI,IAAI;IAY/B;;;;OAIG;IACH,SAAS,CAAC,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,IAAI;IAMhF;;;;;OAKG;cACa,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAiCnH;;;;OAIG;IACH,SAAS,CAAC,eAAe,CAAC,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,MAAM,EAAE;IAU5E;;;;;;OAMG;IACH,SAAS,CAAC,oBAAoB,CAAC,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,OAAO;IAIhF;;;;;;;OAOG;IACH,SAAS,CAAC,mBAAmB,CAAC,SAAS,EAAE,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,EAAE;IAIlG;;;OAGG;IACH,SAAS,CAAC,oBAAoB,CAAC,SAAS,EAAE,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,MAAM,EAAE;IAIhF,wHAAwH;IACxH,SAAS,KAAK,kBAAkB,IAAI,kBAAkB,CAErD;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,eAAe,CAAC,MAAM,EAAE,eAAe,GAAG,YAAY,CAAC,IAAI,CAAC;IA4B5D;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIrD;;;;;;;;OAQG;IACH,SAAS,CAAC,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM;IAQ1D;;;;;;;;;;;;;OAaG;IACH,SAAS,CAAC,UAAU,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM;IAWrD;;;;;;;;;;;;OAYG;IACG,wBAAwB,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ/C,eAAe,CAAC,cAAc,EAAE,aAAa,GAAG,IAAI;IAIpD;;;;;OAKG;IACH,OAAO,IAAI,IAAI;CAQjB"}
+{"version":3,"file":"hydranium-glsp-storage.d.ts","sourceRoot":"","sources":["../../src/storage/hydranium-glsp-storage.ts"],"names":[],"mappings":"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"}