@hydranium/glsp-server 1.0.0-next.123 → 1.0.0-next.127

package/src/browser/start-glsp-server-in-worker.ts

@@ -14,43 +14,38 @@ import {
    WorkerServerLauncher,
    createAppModule
 } from '@eclipse-glsp/server/browser.js';
-import { Container, type ContainerModule } from 'inversify';
-import type { Logger } from '@hydranium/protocol';
+import { Container, injectable, type ContainerModule } from 'inversify';
+import { createMessagePortTransport, type Logger, type TransferredMessagePort } from '@hydranium/protocol';
+import { createMessageConnection, type MessageConnection } from 'vscode-jsonrpc/browser';
 import type { IntegratedServer } from '@hydranium/core';
 import { createGlspFrameworkOverrides } from '../launcher/glsp-framework-overrides.js';
 import { createGlspServerOverrides } from '../launcher/glsp-server-overrides.js';
 
+// Re-exported so the type of this head's `context` still resolves from here.
+export type { TransferredMessagePort } from '@hydranium/protocol';
+
 /**
- * A `MessagePort` the host transferred into the worker, described structurally.
- *
- * This package inherits `tsconfig.base.json`'s `lib: ["ES2022"]` and so compiles
- * without the DOM lib, which is what keeps `document` / `window` compile errors
- * here — so `MessagePort` has no name either and the contract has to be spelled
- * out.
- *
- * **The member set is chosen to admit a `MessagePort` and REJECT a `Worker` or
- * the worker global**, both of which the launcher's own reader would otherwise
- * accept. Only a port needs starting, so `start` is what tells the three apart,
- * and naming it here turns "never bind a head to the global" from a rule in a
- * document into a compile error at the call site.
+ * The worker launcher every {@link startGlspServerInWorker} head runs on: GLSP's
+ * own, with its connection built over `createMessagePortTransport` rather than
+ * over `BrowserMessageReader`/`BrowserMessageWriter`, which never report a
+ * close. So the client disposing its connection closes this one, and upstream
+ * disposes the server instance, and with it every client session, as it does
+ * when a socket closes.
  *
- * **That compile error happens at the ADOPTER, not here.** This project resolves
- * neither `MessagePort` nor `Worker` as a type, so nothing in this package can
- * demonstrate the rejection; a host compiling its worker against `lib.webworker`
- * (or a page against `lib.dom`) is where the names resolve and the guard bites.
- * Measured there: passing the worker global fails with `Property 'start' is
- * missing in type 'DedicatedWorkerGlobalScope'`.
+ * Requires `context`: unlike upstream it never falls back to the worker global.
  *
- * `addEventListener` is not a discriminator — `postMessage` plus `start` already
- * excludes the other two — and nothing in this module calls any of the three
- * (the reader assigns `onmessage`, which starts a port implicitly). It is listed
- * because it is part of what the reader uses, so the interface reads as the
- * contract rather than as a minimal trick.
+ * **The install needs a single `vscode-jsonrpc`.** The connection comes from
+ * this package's copy, and GLSP's request and notification types from the copy
+ * `@eclipse-glsp/protocol` resolves. With two copies, a typed notification or
+ * request GLSP sends throws `Unknown parameter structure auto`, because the
+ * connection compares the type's parameter-structure marker by identity.
  */
-export interface TransferredMessagePort {
-   postMessage(message: unknown): void;
-   addEventListener(type: 'message', listener: (event: unknown) => void, options?: unknown): void;
-   start(): void;
+@injectable()
+export class HydraniumGlspWorkerServerLauncher extends WorkerServerLauncher {
+   protected override createConnection(options: WorkerLaunchOptions): MessageConnection {
+      const transport = createMessagePortTransport(options.context as unknown as TransferredMessagePort);
+      return createMessageConnection(transport.reader, transport.writer);
+   }
 }
 
 /**
@@ -66,14 +61,15 @@ export interface BrowserGlspServerOptions {
    /**
     * The port the host transferred into the worker for this head.
     *
-    * **Required, and that is the whole point.** GLSP's
-    * `WorkerServerLauncher.createConnection` falls back to the worker global
-    * when it is omitted, and a head on the global receives every other head's
-    * traffic — `BrowserMessageReader` filters nothing, so this is not a race
-    * under load but every message delivered to the wrong reader. The global is
-    * unusable even for a single head, because the launcher posts its startup
-    * string through the global `postMessage` regardless of the connection it
-    * was given, and no JSON-RPC reader can parse that.
+    * **Required: the worker global is no substitute.** A head on the global
+    * receives every other head's traffic — a reader filters nothing, so this is
+    * not a race under load but every message delivered to the wrong reader — and
+    * GLSP's launcher posts its startup string through the global `postMessage`
+    * regardless of the connection it was given, which no JSON-RPC reader parses.
+    * Unlike upstream's, this head's launcher never falls back to the global.
+    *
+    * The page's end must connect through `createMessagePortTransport` as well:
+    * the head reads its close signal from the port, and posts one on it.
     */
    readonly context: TransferredMessagePort;
    /**
@@ -126,8 +122,9 @@ export interface BrowserGlspServerOptions {
  *   below. There is no transport handshake to wait on: the port arrived live,
  *   and the launcher's own readiness signal is a string it posts on the worker
  *   global, which nothing here reads.
- * - `stopped` resolves when the connection closes, and rejects on a connection
- *   error.
+ * - `stopped` resolves when the connection closes, which the client disposing
+ *   its connection causes, and rejects on a connection error. Nothing reports a
+ *   page that dies, because the port cannot.
  */
 export function startGlspServerInWorker(options: BrowserGlspServerOptions): IntegratedServer {
    const lifecycle = options.logger;
@@ -145,7 +142,7 @@ export function startGlspServerInWorker(options: BrowserGlspServerOptions): Inte
    const appContainer = new Container();
    appContainer.load(glspAppModule, createGlspFrameworkOverrides(options.createLogger), ...(options.appModules ?? []));
 
-   const launcher = appContainer.resolve<WorkerServerLauncher>(WorkerServerLauncher);
+   const launcher = appContainer.resolve<WorkerServerLauncher>(HydraniumGlspWorkerServerLauncher);
    // Additional module rather than an app-container binding, as on Node: the
    // launcher loads these into the per-connection SERVER container, the only
    // tier where the adopter's `ServerModule` binding of `GLSPServer` is
@@ -153,10 +150,10 @@ export function startGlspServerInWorker(options: BrowserGlspServerOptions): Inte
    launcher.configure(options.serverModule, createGlspServerOverrides());
 
    try {
-      // Upstream declares `WorkerLaunchOptions.context` as `Worker`, narrower
-      // than the `MessagePort | Worker | DedicatedWorkerGlobalScope` its own
-      // `BrowserMessageReader` accepts — so the value that is CORRECT here is
-      // the one the declaration names as wrong.
+      // Upstream declares `WorkerLaunchOptions.context` as `Worker`, and
+      // `HydraniumGlspWorkerServerLauncher.createConnection` reads it as a
+      // port — so the value that is CORRECT here is the one the declaration
+      // names as wrong.
       //
       // **The cast is currently redundant, and is kept deliberately.** `Worker`
       // does not resolve under this package's `lib`, so `skipLibCheck` leaves

package/src/command/hydranium-glsp-command-stack.ts

@@ -0,0 +1,36 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import { DefaultCommandStack, ModelState } from '@eclipse-glsp/server';
+import { type ServerSharedServices } from '@hydranium/core';
+import { inject, injectable } from 'inversify';
+import { HydraniumTypes } from '../state/hydranium-shared-core-services.js';
+
+/**
+ * GLSP's command stack with the diagram's dirty state read from the text store:
+ * dirty while any document the diagram's client session has open differs from
+ * its file, as the store last knew the file. Undo and redo are GLSP's.
+ *
+ * GLSP's own answer counts the diagram's commands since its last save, so it
+ * misses every change the diagram did not make: another client's unsaved edit
+ * leaves it clean, and a save it did not make of a document other than the
+ * diagram's own leaves it dirty. Every `SetDirtyStateAction` GLSP sends reads
+ * this answer.
+ */
+@injectable()
+export class HydraniumGlspCommandStack extends DefaultCommandStack {
+   @inject(ModelState) protected readonly modelState!: ModelState;
+   @inject(HydraniumTypes.SharedCoreServices) protected readonly sharedServices!: ServerSharedServices;
+
+   override get isDirty(): boolean {
+      const textDocuments = this.sharedServices.workspace.TextDocuments;
+      const clientId = this.modelState.clientId;
+      return textDocuments.openDocuments().some(open => open.clients.includes(clientId) && textDocuments.isDirty(open.uri));
+   }
+}

package/src/command/index.ts

@@ -8,3 +8,4 @@
  ********************************************************************************/
 
 export * from './hydranium-glsp-recording-command.js';
+export * from './hydranium-glsp-command-stack.js';

package/src/launcher/abstract-hydranium-glsp-diagram-module.ts

@@ -7,11 +7,19 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { DiagramModule } from '@eclipse-glsp/server';
+import {
+   type ActionHandlerConstructor,
+   type BindingTarget,
+   type CommandStack,
+   DiagramModule,
+   type InstanceMultiBinding
+} from '@eclipse-glsp/server';
 import { injectable, type interfaces } from 'inversify';
 import type { LanguageMetaData } from '@hydranium/langium';
 import { type ServerLanguageServices, type ServerSharedServices, typedMetadata } from '@hydranium/core';
 import { HydraniumTypes } from '../state/hydranium-shared-core-services.js';
+import { HydraniumGlspRequestSaveModelActionHandler } from '../storage/hydranium-glsp-request-save-model-action-handler.js';
+import { HydraniumGlspCommandStack } from '../command/hydranium-glsp-command-stack.js';
 
 /**
  * Bind {@link HydraniumTypes}.DiagramLanguage on a GLSP **session** container
@@ -20,8 +28,10 @@ import { HydraniumTypes } from '../state/hydranium-shared-core-services.js';
  * Exported separately from {@link AbstractHydraniumGlspDiagramModule} for adopters
  * whose diagram module already extends an intermediate base of their own and
  * cannot take the framework base class; call it from `configure` after
- * `super.configure(...)`. The base class is the preferred entry point because
- * it makes the declaration non-optional.
+ * `super.configure(...)`, add {@link HydraniumGlspRequestSaveModelActionHandler}
+ * in `configureActionHandlers`, and return {@link HydraniumGlspCommandStack} from
+ * `bindCommandStack`, all of which the base also does. The base class is the
+ * preferred entry point because it makes the declaration non-optional.
  *
  * **Why the session tier.** GLSP builds its app container once per process,
  * before any document exists, so a per-language service bound there can only
@@ -114,4 +124,18 @@ export abstract class AbstractHydraniumGlspDiagramModule extends DiagramModule {
       super.configure(bind, unbind, isBound, rebind);
       bindDiagramLanguage(bind, this.declareLanguage());
    }
+
+   /** {@link HydraniumGlspCommandStack}, so the diagram is dirty exactly while a document it has open is. */
+   protected override bindCommandStack(): BindingTarget<CommandStack> {
+      return HydraniumGlspCommandStack;
+   }
+
+   /**
+    * Adds {@link HydraniumGlspRequestSaveModelActionHandler}, the save the
+    * Theia client sends, beside GLSP's own save handler.
+    */
+   protected override configureActionHandlers(binding: InstanceMultiBinding<ActionHandlerConstructor>): void {
+      super.configureActionHandlers(binding);
+      binding.add(HydraniumGlspRequestSaveModelActionHandler);
+   }
 }

package/src/launcher/hydranium-glsp-server.ts

@@ -15,6 +15,7 @@ import {
    type RequestAction,
    type ResponseAction
 } from '@eclipse-glsp/server';
+import { RequestSaveModelAction } from '@hydranium/protocol';
 import { injectable } from 'inversify';
 
 /**
@@ -64,9 +65,12 @@ export class HydraniumGlspServer extends DefaultGLSPServer {
    /**
     * Lifted verbatim from `@eclipse-glsp/server` 2.7.0's
     * {@link DefaultGLSPServer.handleClientRequest}, with the detail computation
-    * delegated to {@link requestFailureDetail}. Nothing else here — the
-    * timeout branch, the response dispatch, the nested send-failure handling —
-    * relates to that fallback.
+    * delegated to {@link requestFailureDetail}, and one addition: a failed
+    * {@link RequestSaveModelAction} also raises the error notification a failed
+    * `SaveModelAction` raises. A rejection reaches only the client's log, and a
+    * Theia host only logs a rejected save, so without it a save that failed
+    * would tell the user nothing. Nothing else here — the timeout branch, the
+    * response dispatch, the nested send-failure handling — relates to either.
     *
     * **This body does not track upstream.** A release that changes request
     * handling would silently not apply, on the path every request takes. There
@@ -97,6 +101,11 @@ export class HydraniumGlspServer extends DefaultGLSPServer {
                detail
             });
             this.sendResponseToClient(clientId, reject);
+            // Inside the guard: `process` does not await this method, so a
+            // closed connection throwing here would be an unhandled rejection.
+            if (action.kind === RequestSaveModelAction.KIND) {
+               this.handleProcessError({ clientId, action }, error);
+            }
          } catch (sendError: unknown) {
             this.logger.error(`Failed to send rejection for request '${action.requestId}':`, sendError);
          }

package/src/node/start-glsp-server.ts

@@ -16,8 +16,7 @@ import {
    defaultSocketLaunchOptions
 } from '@eclipse-glsp/server/node.js';
 import { Container, type ContainerModule } from 'inversify';
-import type { Logger } from '@hydranium/protocol';
-import { Deferred } from '@hydranium/langium';
+import { Deferred, type Logger } from '@hydranium/protocol';
 import type * as net from 'node:net';
 import type { IntegratedServer } from '@hydranium/core';
 import { createGlspFrameworkOverrides } from '../launcher/glsp-framework-overrides.js';

package/src/state/abstract-hydranium-glsp-state.ts

@@ -24,11 +24,11 @@ import {
    type BasedOn,
    type SnapshotVersion,
    type ConflictResolver,
-   type Disposable,
    type Logger,
    type Tracer,
    asSnapshotVersion,
-   NO_MATCHING_VERSION
+   NO_MATCHING_VERSION,
+   TIMED_OUT
 } from '@hydranium/protocol';
 import { type HydraniumGlspIndex } from './hydranium-glsp-index.js';
 import { HydraniumTypes } from './hydranium-shared-core-services.js';
@@ -514,31 +514,21 @@ export abstract class AbstractHydraniumGlspState<TRoot extends AstNode, TSourceM
    protected async readyWithTimeout(state: DocumentState): Promise<void> {
       const uri = this._sourceUri;
       const stopwatch = this.sharedServices.Clock.stopwatch();
-      let timer: Disposable | undefined;
-
-      const timeout = new Promise<void>((resolve, reject) => {
-         timer = this.sharedServices.Clock.setTimer(() => {
-            const elapsed = Math.round(stopwatch.elapsedMs);
-            // Through the model service's canonicalizing gateway, so a symlinked
-            // `_sourceUri` is not reported as a hard timeout.
-            const doc = this.sharedServices.model.ModelService.getDocument(uri);
-            if (doc && doc.state >= state) {
-               this.logger.warn(
-                  `Missed '${DocumentState[state]}' notification after ${elapsed}ms; document is already at state ` +
-                     `'${DocumentState[doc.state]}'. Likely a Langium build-phase event race.`
-               );
-               resolve();
-            } else {
-               reject(this.buildReadyTimeoutError(state, elapsed));
-            }
-         }, this.readyTimeoutMs);
-      });
-
-      try {
-         await Promise.race([this.sharedServices.model.ModelService.waitForDocumentState(uri, state), timeout]);
-      } finally {
-         timer?.dispose();
+      const reached = this.sharedServices.model.ModelService.waitForDocumentState(uri, state);
+      if ((await this.sharedServices.Clock.raceTimer(reached, this.readyTimeoutMs)) !== TIMED_OUT) {
+         return;
+      }
+      const elapsed = Math.round(stopwatch.elapsedMs);
+      // Through the model service's canonicalizing gateway, so a symlinked
+      // `_sourceUri` is not reported as a hard timeout.
+      const doc = this.sharedServices.model.ModelService.getDocument(uri);
+      if (!doc || doc.state < state) {
+         throw this.buildReadyTimeoutError(state, elapsed);
       }
+      this.logger.warn(
+         `Missed '${DocumentState[state]}' notification after ${elapsed}ms; document is already at state ` +
+            `'${DocumentState[doc.state]}'. Likely a Langium build-phase event race.`
+      );
    }
 
    /**

package/src/storage/hydranium-glsp-request-save-model-action-handler.ts

@@ -0,0 +1,40 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import { type Action, SaveModelAction, SaveModelActionHandler } from '@eclipse-glsp/server';
+import { ModelSavedAction, RequestSaveModelAction } from '@hydranium/protocol';
+import { injectable } from 'inversify';
+
+/**
+ * Answers a {@link RequestSaveModelAction}: saves exactly as GLSP's
+ * {@link SaveModelActionHandler} saves a `SaveModelAction` carrying the same
+ * `fileUri`, dirty-state change included, then replies with a
+ * {@link ModelSavedAction}.
+ *
+ * A failed save throws, and the server turns the throw into a `RejectAction`
+ * for the request. The save handler's own `SaveModelAction` stays registered,
+ * so a client that sends it is unaffected.
+ *
+ * `AbstractHydraniumGlspDiagramModule` registers it. A diagram module that does
+ * not extend that base adds it in `configureActionHandlers`. Without it no
+ * handler is advertised for the request, and the Theia client saves as GLSP's
+ * saveable does: a save nothing answers, so a failed one surfaces only as a
+ * timeout, and a window can close over a save still under way.
+ */
+@injectable()
+export class HydraniumGlspRequestSaveModelActionHandler extends SaveModelActionHandler {
+   override actionKinds = [RequestSaveModelAction.KIND];
+
+   // Typed `Action`, the one parameter type both this kind and the base's accept.
+   override async execute(action: Action): Promise<Action[]> {
+      const fileUri = 'fileUri' in action && typeof action.fileUri === 'string' ? action.fileUri : undefined;
+      const actions = await super.execute(SaveModelAction.create({ fileUri }));
+      return [...actions, ModelSavedAction.create()];
+   }
+}

package/src/storage/hydranium-glsp-storage.ts

@@ -27,6 +27,7 @@ import {
    type RequestModelAction,
    SOURCE_URI_ARG,
    type SaveModelAction,
+   SetDirtyStateAction,
    SetEditModeAction,
    type SourceModelStorage,
    TEMPORARY_CLIENT_ID
@@ -47,6 +48,7 @@ import {
    type AstDocumentSavedEvent,
    type AstDocumentUpdatedEvent,
    type ClientSession as ModelClientSession,
+   type DocumentDirtyChangedEvent,
    type ServerSharedServices
 } from '@hydranium/core';
 import { DiagnosticSeverity } from 'vscode-languageserver-types';
@@ -262,6 +264,8 @@ export class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string>
 
    /** Set by {@link dispose}; a disposed storage registers no session again. */
    protected disposed = false;
+   /** Saves of the diagram's own that GLSP's save handler awaits; see {@link handleDirtyChanged}. */
+   protected ownSavesPending = 0;
 
    /**
     * Whether an external resubmit has ever been dispatched. Gates the
@@ -329,10 +333,7 @@ export class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string>
     */
    protected requireModelSession(): ModelClientSession<AstNode> {
       if (this.disposed) {
-         throw new SessionClosedError(
-            this.state.clientId,
-            `The diagram of ${this.state.clientId} has closed; its client session has ended`
-         );
+         throw new SessionClosedError(this.state.clientId, 'The diagram has closed; its client session has ended.');
       }
       if (!this.state.modelSession) {
          this.state.modelSession = this.registerModelSession();
@@ -427,9 +428,12 @@ export class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string>
       // React to external rebuilds: settle-gated capture + debounced/deduped resubmit.
       this.toDispose.push(modelService.onModelUpdated(rootUri, event => this.handleModelUpdated(rootUri, event)));
 
-      // Coordinate the command stack's dirty state when another client saves.
+      // GLSP's own command stack counts commands; tell it of another client's save.
       this.toDispose.push(modelService.onModelSaved(rootUri, event => this.handleModelSaved(event)));
 
+      // Tell the client of each dirty flip, one the diagram did not cause included.
+      this.toDispose.push(this.sharedServices.workspace.TextDocuments.onDidChangeDirty(event => this.handleDirtyChanged(event)));
+
       // Capture the initial settled root.
       const document = await modelService.settled(rootUri);
       await this.captureSettledRoot(rootUri, document);
@@ -650,9 +654,10 @@ export class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string>
    }
 
    /**
-    * 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 {
       if (this.state.clientId !== event.sourceClientId) {
@@ -660,6 +665,35 @@ export class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string>
       }
    }
 
+   /**
+    * 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 handleDirtyChanged(event: DocumentDirtyChangedEvent): void {
+      if (this.ownSavesPending > 0 || !this.sharedServices.workspace.TextDocuments.isOpenInClient(event.uri, this.state.clientId)) {
+         return;
+      }
+      this.sendDirtyState();
+   }
+
+   /** Send the command stack's dirty state, reason `external`. */
+   protected sendDirtyState(): void {
+      this.actionDispatcher
+         .dispatch(SetDirtyStateAction.create(this.commandStack.isDirty, { reason: 'external' }))
+         .catch((error: unknown) => this.logger.warn(`Could not send the dirty state of ${this.state.sourceUri}: ${String(error)}`));
+   }
+
    /**
     * Re-settle to a guaranteed fully-linked + reprojected root, capture it, and
     * (unless suppressed) resubmit a deduped external GModel. Diagnostics for the
@@ -831,17 +865,29 @@ export class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string>
       // the call site rather than inside `getFileUri` so that method's contract —
       // return what the action said — is unchanged for adopters overriding it.
       const uri = this.toSourceModelUri(this.getFileUri(action));
-      const policy = this.saveDeliveryPolicy;
-      const persisted = this.flushWriteSet(uri);
-
-      if (policy.kind === 'fire-and-forget') {
+      if (this.saveDeliveryPolicy.kind === 'fire-and-forget') {
          // Log rather than leave an unhandled rejection: the promise is not
          // returned, so nothing else will observe a failure.
-         persisted.catch(error => this.logger.error(`Save failed for ${uri}: ${error instanceof Error ? error.message : String(error)}`));
+         this.flushWriteSet(uri).catch(error =>
+            this.logger.error(`Save failed for ${uri}: ${error instanceof Error ? error.message : String(error)}`)
+         );
          return undefined;
       }
-      // Awaited: any failure propagates to GLSP's save-action handler.
-      return persisted;
+      // Awaited: any failure propagates to GLSP's save-action handler, which
+      // then sends no dirty state, so the one the save held back goes here.
+      // An override that throws before it returns a promise throws inside the
+      // async function too, so the hold always ends.
+      this.ownSavesPending++;
+      return (async () => {
+         try {
+            await this.flushWriteSet(uri);
+         } catch (error: unknown) {
+            this.sendDirtyState();
+            throw error;
+         } finally {
+            this.ownSavesPending--;
+         }
+      })();
    }
 
    /**

package/src/storage/index.ts

@@ -7,5 +7,6 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
+export * from './hydranium-glsp-request-save-model-action-handler.js';
 export * from './hydranium-glsp-storage.js';
 export * from './save-delivery-policy.js';