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

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

@@ -10,6 +10,7 @@
 import { type AnyObject, type JsonModelState, JsonRecordingCommand, type MaybePromise } from '@eclipse-glsp/server';
 import { type AstNode } from '@hydranium/langium';
 import { type AbstractHydraniumGlspState } from '../state/abstract-hydranium-glsp-state.js';
+import { HydraniumGlspOperationCommand, openOperationOf, runOperation } from './hydranium-glsp-operation-command.js';
 
 /**
  * Source-model state shape consumed by {@link HydraniumGlspRecordingCommand}.
@@ -25,159 +26,77 @@ export type HydraniumGlspRecordingState<TSourceModel extends AnyObject> = Abstra
    JsonModelState<TSourceModel>;
 
 /**
- * GLSP {@link JsonRecordingCommand} base shared by all hydranium adopters.
- * Adds two things on top of GLSP's class:
- *
- *  1. A **time-labelled execute wrapper** so log lines record how long a
- *     user-facing operation takes end-to-end — including the `postChange`
- *     source-model update that re-parses the document. Otherwise the diff +
- *     patch + persist work happens silently and is hard to attribute when
- *     something is slow.
- *  2. A typed `state` field that exposes `updateSourceModel` for the
- *     `postChange` bridge AND the framework `logger` for time-labelled
- *     logging. GLSP's base class only types `modelState: JsonModelState`,
- *     which lacks the framework's logger surface.
+ * GLSP {@link JsonRecordingCommand} base shared by all hydranium adopters: a
+ * handler mutates `sourceRoot` in the command's runnable, and the operation
+ * the command executes in writes the result once when it ends.
  *
  * **Optional undo/redo bridge hooks.** An adopter command can supply
- * `undoAction` / `redoAction` callbacks invoked alongside the patch apply, to
- * re-emit a side-effect the patch itself does not carry. Provided as optional
- * constructor args so adopters get that composition surface without
- * subclassing. Operation handlers that don't need bridge callbacks omit them.
+ * `undoAction` / `redoAction` callbacks, run when the operation is undone or
+ * redone and when a failed operation rolls back, to re-emit a side effect the
+ * model does not carry. During an undo or redo they run against throwaway
+ * copies, and a recording command executed there throws.
  *
- * **postChange semantics.** GLSP's `JsonRecordingCommand.postChange` calls
- * `modelState.updateSourceModel(newModel)` with the model only. The
- * framework lift overrides `postChange` so it also threads the based-on
- * version captured at command start — letting the downstream
- * `ModelService.update` opt into the `ConflictError` gate. Undo / redo
- * postChange calls run with version `undefined` (no gating): the user
- * authored against the recorded patch, not against a specific server
- * version, so re-applying it should succeed regardless of intervening
- * edits. The recorded patch itself encodes the semantic intent.
+ * A command executed outside an operation opens one of its own through
+ * `runExclusive`, so executing it from inside the boundary with no operation
+ * open deadlocks. Its undo and redo then undo and redo that operation without
+ * taking the boundary, which the caller holds, as the framework's undo handler
+ * does; taking it there would deadlock under that handler.
  */
 export class HydraniumGlspRecordingCommand<TSourceModel extends AnyObject> extends JsonRecordingCommand<TSourceModel> {
    declare protected modelState: HydraniumGlspRecordingState<TSourceModel>;
 
-   /**
-    * Based-on version captured at {@link execute} start; threaded into
-    * {@link postChange} so {@link AbstractHydraniumGlspState.updateSourceModel}
-    * sees the version the user authored against. Cleared after `execute`
-    * returns so undo / redo paths fall through to `updateSourceModel`
-    * without a version (no gating).
-    */
-   protected activeVersion?: number;
-
-   /**
-    * Source-model snapshots captured at {@link execute} — the state the
-    * command left ({@link afterSnapshot}) and the state it started from
-    * ({@link beforeSnapshot}). {@link undo} / {@link redo} reconcile the
-    * recorded transition against the *current* source model via the state's
-    * {@link AbstractHydraniumGlspState.conflictResolver}, so under the default
-    * reconciling policy a concurrent edit to another field survives and a
-    * same-field collision is dropped rather than clobbered.
-    */
-   protected beforeSnapshot?: TSourceModel;
-   protected afterSnapshot?: TSourceModel;
+   /** The operation this command opened, when it executed outside one. */
+   protected ownOperation?: HydraniumGlspOperationCommand<TSourceModel>;
 
    constructor(
       modelState: HydraniumGlspRecordingState<TSourceModel>,
       /** Human-readable label for the operation; appears in the timing-pair log line. */
       protected readonly label: string,
       doExecute: () => MaybePromise<void>,
-      /** Optional bridge invoked alongside undo patch application; for adopters
-       *  that need to re-emit a side-effect the patch does not carry. */
+      /** Optional bridge invoked when the command is undone; for adopters
+       *  that need to re-emit a side-effect the model does not carry. */
       protected readonly undoAction?: () => MaybePromise<void>,
-      /** Optional bridge invoked alongside redo patch application. */
+      /** Optional bridge invoked when the command is redone. */
       protected readonly redoAction?: () => MaybePromise<void>
    ) {
       super(modelState, doExecute);
    }
 
-   /**
-    * Time-label the full execute path: pre-state snapshot + `doExecute` +
-    * post-state snapshot + patch-derive + `postChange` (which writes back
-    * via {@link AbstractHydraniumGlspState.updateSourceModel}). The label combines
-    * the operation name with the source-uri-stamped logger.
-    *
-    * Captures {@link AbstractHydraniumGlspState.version} at start so {@link postChange}
-    * can thread the based-on version into `updateSourceModel`. The capture
-    * is `try`/`finally`-scoped so undo / redo paths invoked later do not
-    * see a stale captured version.
-    */
    override async execute(): Promise<void> {
-      const logger = this.modelState.logger.for('HydraniumGlspRecordingCommand');
-      this.activeVersion = this.modelState.version;
-      logger.debug(`Executing '${this.label}' (based-on doc.version=v${this.activeVersion})`);
-      this.beforeSnapshot = this.deepClone(await this.getJsonObject());
-      try {
-         await this.modelState.tracer.for('HydraniumGlspRecordingCommand').time(`Execute command '${this.label}'`, () => super.execute());
-      } finally {
-         this.activeVersion = undefined;
+      const open = openOperationOf(this.modelState);
+      if (!open) {
+         const operation = new HydraniumGlspOperationCommand<TSourceModel>(this.modelState);
+         if ((await this.modelState.runExclusive(() => runOperation(operation, () => this))) === 'executed') {
+            this.ownOperation = operation;
+         }
+         return;
       }
-      this.afterSnapshot = this.deepClone(await this.getJsonObject());
+      open.assertNotDuringUndoRedo(this.label);
+      const tracer = this.modelState.tracer.for('HydraniumGlspRecordingCommand');
+      tracer.debug(`Executing '${this.label}' (base version v${this.modelState.version})`);
+      await tracer.time(`Execute command '${this.label}'`, () => super.execute());
+      open.recordExecuted({ undo: () => this.undoAction?.(), redo: () => this.redoAction?.() });
    }
 
-   /**
-    * Override of GLSP's {@link JsonRecordingCommand.postChange} so the
-    * call to {@link AbstractHydraniumGlspState.updateSourceModel} threads the
-    * captured based-on version alongside the new model.
-    *
-    * During {@link execute} the version is the snapshot captured at
-    * command start; during {@link undo} / {@link redo} it is `undefined`
-    * — replaying a recorded patch does not author against a specific
-    * server version, so no gate applies.
-    */
-   protected override postChange(newModel: TSourceModel): MaybePromise<void> {
-      return this.modelState.updateSourceModel(newModel, this.activeVersion);
+   /** Writes nothing: the operation the command executes in writes once when it ends. */
+   protected override postChange(_newModel: TSourceModel): void {
+      // Written by the operation.
    }
 
    /**
-    * Reconcile the recorded `after → before` transition against the
-    * *current* source model via the state's
-    * {@link AbstractHydraniumGlspState.conflictResolver}, invoke the optional adopter
-    * `undoAction`, and persist via `postChange`. Under the default reconciling
-    * policy the revert is replayed guarded by `test` ops, so a concurrent edit
-    * to another field is preserved (merged) and a same-field collision is
-    * dropped rather than clobbered; a force policy clobbers (last-writer-wins).
-    * On anything but a clean merge the undo is a logged no-op — the side-effect
-    * bridge and `postChange` only run on a merged result, preserving a
-    * "bridge before commit" order.
+    * Inside an open operation does nothing: the operation runs the bridge, once
+    * for every recording command that executed.
     */
    override async undo(): Promise<void> {
-      if (!this.undoPatch || this.beforeSnapshot === undefined || this.afterSnapshot === undefined) {
-         return;
+      if (!openOperationOf(this.modelState)) {
+         await this.ownOperation?.undo();
       }
-      const logger = this.modelState.logger.for('HydraniumGlspRecordingCommand');
-      logger.debug(`Undoing '${this.label}' at doc.version=v${this.modelState.version}`);
-      const outcome = await this.modelState.conflictResolver.resolve(this.afterSnapshot, this.beforeSnapshot, async () =>
-         this.getJsonObject()
-      );
-      if (outcome.status !== 'merged') {
-         logger.warn(`Undo '${this.label}' skipped (${outcome.status}); a foreign edit changed a shared field since the command ran`);
-         return;
-      }
-      await this.undoAction?.();
-      await this.postChange?.(outcome.merged);
    }
 
-   /**
-    * Reconcile the recorded `before → after` transition against the current
-    * source model, invoke the optional adopter `redoAction`, and persist via
-    * `postChange`. Same guarded merge / drop semantics as {@link undo}.
-    */
+   /** Inside an open operation does nothing, as {@link undo}. */
    override async redo(): Promise<void> {
-      if (!this.redoPatch || this.beforeSnapshot === undefined || this.afterSnapshot === undefined) {
-         return;
-      }
-      const logger = this.modelState.logger.for('HydraniumGlspRecordingCommand');
-      logger.debug(`Redoing '${this.label}' at doc.version=v${this.modelState.version}`);
-      const outcome = await this.modelState.conflictResolver.resolve(this.beforeSnapshot, this.afterSnapshot, async () =>
-         this.getJsonObject()
-      );
-      if (outcome.status !== 'merged') {
-         logger.warn(`Redo '${this.label}' skipped (${outcome.status}); a foreign edit changed a shared field since the undo`);
-         return;
+      if (!openOperationOf(this.modelState)) {
+         await this.ownOperation?.redo();
       }
-      await this.redoAction?.();
-      await this.postChange?.(outcome.merged);
    }
 }

package/src/command/hydranium-glsp-undo-redo-action-handler.ts

@@ -0,0 +1,29 @@
+/********************************************************************************
+ * 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 { type Action, ModelState, UndoRedoActionHandler } from '@eclipse-glsp/server';
+import { type AstNode } from '@hydranium/langium';
+import { inject, injectable } from 'inversify';
+import { type AbstractHydraniumGlspState } from '../state/abstract-hydranium-glsp-state.js';
+
+/**
+ * GLSP's undo and redo handler inside the state's `runExclusive`. GLSP's
+ * command stack moves its position before it undoes or redoes the entry, so
+ * the boundary covers the whole action: taken around the undo or redo alone,
+ * an undo arriving while an operation runs would move the position past an
+ * entry it then cannot undo.
+ */
+@injectable()
+export class HydraniumGlspUndoRedoActionHandler extends UndoRedoActionHandler {
+   @inject(ModelState) protected readonly modelState!: AbstractHydraniumGlspState<AstNode, unknown>;
+
+   override execute(action: Action): Promise<Action[]> {
+      return this.modelState.runExclusive(() => super.execute(action));
+   }
+}

package/src/command/index.ts

@@ -8,3 +8,13 @@
  ********************************************************************************/
 
 export * from './hydranium-glsp-recording-command.js';
+export * from './hydranium-glsp-command-stack.js';
+export * from './hydranium-glsp-operation-action-handler.js';
+export {
+   HydraniumGlspOperationCommand,
+   type OperationSideEffect,
+   type OperationTransition,
+   type UndoRedoDirection
+} from './hydranium-glsp-operation-command.js';
+export * from './hydranium-glsp-undo-redo-action-handler.js';
+export * from './diagram-edit-dropped-error.js';

package/src/computed-bounds/hydranium-glsp-computed-bounds-action-handler.ts

@@ -32,7 +32,7 @@ import { type HydraniumGlspSubmissionHandler } from '../submission/hydranium-gls
  * very first `computedBounds` arrives with a revision the server has already
  * bumped, the subsequent `SetModelAction` response never fires and the diagram
  * stays stuck at "model loading…". Adopters need this initial-handshake case
- * surfaced as a warning so the failure mode is visible in logs.
+ * logged as an error: the diagram stays empty, so the requested load failed.
  *
  * **Handshake detection** uses
  * {@link HydraniumGlspSubmissionHandler.hasPendingInitialRequest} — true
@@ -55,7 +55,7 @@ export class HydraniumGlspComputedBoundsActionHandler extends ComputedBoundsActi
       const model = this.modelState.root;
       if (action.revision !== model.revision) {
          if (this.submissionHandler.hasPendingInitialRequest()) {
-            this.modelState.logger.warn(
+            this.modelState.logger.error(
                `ComputedBounds rejected (initial handshake): action.revision=${action.revision} model.revision=${model.revision} — ` +
                   'initial SetModelAction will not fire (empty diagram)'
             );

package/src/dispatcher/server-action-dispatcher.ts

@@ -7,66 +7,74 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { type Action, DefaultActionDispatcher } from '@eclipse-glsp/server';
+import { type Action, CheckEdgeResultAction, DefaultActionDispatcher } from '@eclipse-glsp/server';
 import { inject, injectable } from 'inversify';
-import { type Tracer } from '@hydranium/protocol';
-import { type GlspClientLogger } from '../logging/glsp-client-logger.js';
+import { Logger, type Tracer } from '@hydranium/protocol';
 import { HydraniumTypes } from '../state/hydranium-shared-core-services.js';
 
 /**
- * Server-side action dispatcher with built-in traffic observability:
- * every {@link DefaultActionDispatcher.dispatch} call is wrapped in a
- * {@link Tracer.time} pair that records the dispatch direction
- * (`→ client` vs `→ server`) and timing.
+ * Server-side action dispatcher with built-in traffic observability: while
+ * debug is enabled, each {@link DefaultActionDispatcher.dispatch} call runs
+ * inside {@link Tracer.time}, which logs it with its direction (`→ client` vs
+ * `→ server`) and timing only when it is slow or fails, and an action that
+ * {@link summarize} details gets its own debug line whatever its duration.
  *
  * **Why this lives in the framework (vs left as an adopter override).**
  * Debugging GLSP state, storage, and submission flows depends heavily on
- * seeing each action with timing and direction — especially when bringing
- * up a new adopter against an empty/partial diagram before its submission
- * flow is complete. Providing this dispatcher in the framework gives every
- * adopter the same observability primitive from the very first GLSP-head
- * launch.
+ * seeing slow or failing actions with timing and direction — especially when
+ * bringing up a new adopter against an empty/partial diagram before its
+ * submission flow is complete. Providing this dispatcher in the framework
+ * gives every adopter the same observability primitive from the very first
+ * GLSP-head launch.
  *
  * **Extension points.**
  * - {@link loggedKinds} — if set, filter the log lines (the dispatch
- *   still happens; only the bracketed timing line is suppressed). Default
- *   `undefined` means **every** action's dispatch is timed and logged.
- * - {@link summarize} — return a non-empty string to append `[summary]`
- *   to the log line; default returns `''` (no extra bracket).
- *
- * Adopters bind it in a per-diagram module, as the `ActionDispatcher` service.
+ *   still happens; only its timing and summary lines are suppressed).
+ *   Default `undefined` times every action's dispatch while debug is enabled.
+ * - {@link summarize} — return a non-empty string to log it as a debug line
+ *   for the dispatch; `''` logs none.
  */
 @injectable()
 export class HydraniumGlspServerActionDispatcher extends DefaultActionDispatcher {
-   /** Narrowed from `Logger`; DI binds {@link GlspClientLogger}. */
-   declare protected readonly logger: GlspClientLogger;
-
    /** Caller-tagged tracer (auto-componented with this class name, like the logger). */
    @inject(HydraniumTypes.Tracer) protected readonly tracer!: Tracer;
 
    /**
-    * If set, the timing log line is emitted only when `action.kind` is in
-    * this set. Subclasses override via field reassignment.
+    * If set, the timing and summary lines are emitted only when `action.kind`
+    * is in this set. Subclasses override via field reassignment.
     */
    protected readonly loggedKinds: ReadonlySet<string> | undefined = undefined;
 
    /**
-    * Override to enrich the log line with payload-specific detail. Return an
-    * empty string to suppress the bracket. Default returns `''`.
+    * Payload detail logged at debug before the dispatch, as
+    * `Dispatch action '<kind>' <direction> [<summary>]`, on every dispatch,
+    * fast or slow; `''` logs no line. The default details only an action whose
+    * outcome the log otherwise loses, each through a `format*` method. Called
+    * only when debug is enabled, so it may serialise the payload.
     */
-   protected summarize(_action: Action): string {
+   protected summarize(action: Action): string {
+      if (CheckEdgeResultAction.is(action)) {
+         return this.formatEdgeCheck(action);
+      }
       return '';
    }
 
+   /** An edge check's verdict, so the log shows whether the server let an edge tool connect. */
+   protected formatEdgeCheck(action: CheckEdgeResultAction): string {
+      return `edgeType=${action.edgeType} source=${action.sourceElementId} target=${action.targetElementId ?? 'none'} isValid=${action.isValid}`;
+   }
+
    override dispatch(action: Action): Promise<void> {
-      if (this.loggedKinds && !this.loggedKinds.has(action.kind)) {
+      if (!Logger.isLevelEnabled('debug') || (this.loggedKinds && !this.loggedKinds.has(action.kind))) {
          return super.dispatch(action);
       }
       const direction = this.clientActionForwarder.shouldForwardToClient(action) ? '→ client' : '→ server';
+      const label = `Dispatch action '${action.kind}' ${direction}`;
       const summary = this.summarize(action);
-      const label = summary
-         ? `Dispatch action '${action.kind}' ${direction} [${summary}]`
-         : `Dispatch action '${action.kind}' ${direction}`;
-      return this.tracer.time(label, () => super.dispatch(action));
+      if (summary) {
+         // Its own line: `time` is silent on a fast success.
+         this.tracer.debug(`${label} [${summary}]`);
+      }
+      return this.tracer.time(label, () => super.dispatch(action), 'debug');
    }
 }

package/src/index.ts

@@ -14,6 +14,7 @@ export * from './dispatcher/index.js';
 export * from './launcher/index.js';
 export * from './logging/index.js';
 export * from './state/index.js';
+export * from './status/index.js';
 export * from './storage/index.js';
 export * from './submission/index.js';
 export * from './util/index.js';

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

@@ -7,111 +7,99 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { DiagramModule } from '@eclipse-glsp/server';
+import {
+   type ActionDispatcher,
+   type ActionHandlerConstructor,
+   applyBindingTarget,
+   type BindingTarget,
+   type ClientSessionInitializer,
+   type CommandStack,
+   DiagramModule,
+   type InstanceMultiBinding,
+   type MultiBinding,
+   OperationActionHandler,
+   RequestModelActionHandler,
+   SetEditModeActionHandler,
+   UndoRedoActionHandler
+} 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 { HydraniumGlspServerActionDispatcher } from '../dispatcher/server-action-dispatcher.js';
+import { HydraniumGlspRequestSaveModelActionHandler } from '../storage/hydranium-glsp-request-save-model-action-handler.js';
+import { HydraniumGlspCommandStack } from '../command/hydranium-glsp-command-stack.js';
+import { HydraniumGlspOperationActionHandler } from '../command/hydranium-glsp-operation-action-handler.js';
+import { HydraniumGlspUndoRedoActionHandler } from '../command/hydranium-glsp-undo-redo-action-handler.js';
+import { DefaultDiagramStatusReporter, DiagramStatusReporter } from '../status/diagram-status-reporter.js';
+import { HydraniumGlspRequestModelActionHandler } from '../status/hydranium-glsp-request-model-action-handler.js';
+import { HydraniumGlspSetEditModeActionHandler } from '../status/hydranium-glsp-set-edit-mode-action-handler.js';
 
 /**
- * Bind {@link HydraniumTypes}.DiagramLanguage on a GLSP **session** container
- * to the services of `metadata`'s grammar.
+ * GLSP {@link DiagramModule} base that wires the framework's diagram status,
+ * dispatch timing, command stack, save, and transactional operation, undo and
+ * redo handlers.
  *
- * 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.
+ * A diagram module declares no grammar: a session's language is the one its
+ * loaded document routes to, so one diagram type can serve several grammars.
+ * Adopter GLSP components read `modelState.diagramLanguage` for a reference
+ * written on the canvas and `modelState.languageServicesFor(node)` for
+ * anything reached through a reference; see `HydraniumTypes` for why no
+ * per-language service has a token of its own.
  *
- * **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
- * ever be one grammar's. The session container is created per open diagram
- * with its `diagramType` known, and a diagram type has exactly one grammar —
- * so the language is a static fact about the module, resolvable with no URI
- * and no ordering hazard. That last part is load-bearing: GLSP's
- * `OperationHandlerRegistryInitializer` constructs every operation handler at
- * `InitializeClientSession`, i.e. BEFORE `RequestModelAction` supplies the
- * source URI, so anything derived from `ModelState.sourceUri` at injection
- * time would throw on every diagram open.
- *
- * **The whole language, not pre-resolved providers.** There is deliberately no
- * token for an individual per-language provider; see {@link HydraniumTypes} for
- * why. Callers reach `modelState.diagramLanguage` or
- * `modelState.languageServicesFor(node)` instead, which name the choice.
- *
- * Resolution is `toDynamicValue` + `inSingletonScope` — deferred so the parent
- * container's `SharedCoreServices` is available, then resolved once per
- * session rather than per injection.
- */
-export function bindDiagramLanguage(bind: interfaces.Bind, metadata: LanguageMetaData): void {
-   bind(HydraniumTypes.DiagramLanguage)
-      .toDynamicValue(context => resolveDiagramLanguage(context.container, metadata))
-      .inSingletonScope();
-}
-
-/**
- * The registered services for `metadata`'s language, or a throw naming both
- * the declared id and the registered ones.
- *
- * Failing loudly is the point: the declared language is the one fact this
- * module states that the grammar does not, so it can drift. An unregistered id
- * means the adopter declared a language they never registered — a wiring
- * mistake whose silent form (falling back to some other grammar's providers)
- * would surface much later as references that resolve against the wrong scope.
- */
-function resolveDiagramLanguage(container: interfaces.Container, metadata: LanguageMetaData): ServerLanguageServices {
-   const registry = container.get<ServerSharedServices>(HydraniumTypes.SharedCoreServices).ServiceRegistry;
-   const language = registry.getServices(typedMetadata<ServerLanguageServices>(metadata));
-   if (!language) {
-      const registered = registry.all.map(candidate => candidate.LanguageMetaData.languageId);
-      throw new Error(
-         `Diagram module declares language '${metadata.languageId}', which is not registered on the ServiceRegistry. ` +
-            `Registered languages: ${registered.length > 0 ? registered.join(', ') : '(none)'}. ` +
-            'Declare the languageId of a grammar passed to bootstrapLangiumLanguages.'
-      );
-   }
-   return language;
-}
-
-/**
- * GLSP {@link DiagramModule} base that declares which grammar its diagram type
- * edits, and binds that language's per-language services on the session
- * container.
- *
- * Subclass instead of `DiagramModule` and implement {@link declareLanguage}
- * alongside `diagramType`; the two are the same kind of fact about a diagram
- * type, and pairing them is what lets one GLSP head serve N grammars.
- *
- * Adopter GLSP components then read the language they mean:
- * `modelState.diagramLanguage.references.CandidateProvider` for a reference
- * written on the canvas, `modelState.languageServicesFor(node).references.X`
- * for anything reached through a reference. No per-language service is bound
- * to a token of its own — see {@link bindDiagramLanguage} for why.
+ * An adopter whose diagram module already extends a base of its own repeats
+ * what this class's overrides do. Without the status bindings among them,
+ * nothing tells the client why its diagram is read-only; without the operation
+ * and undo handlers, operation handlers edit the built root every reader
+ * shares.
  */
 @injectable()
 export abstract class AbstractHydraniumGlspDiagramModule extends DiagramModule {
-   /**
-    * The `LanguageMetaData` of the grammar this diagram type edits — pass the
-    * generated `<Grammar>LanguageMetaData` constant directly.
-    *
-    * Abstract rather than optional so a new diagram module cannot silently
-    * omit it: a missing declaration is a compile error here, where the fix is
-    * obvious, instead of an unbound-token failure at the first diagram open.
-    *
-    * NOT named `bindLanguage`: every `bindX()` on GLSP's `DiagramModule`
-    * returns a `BindingTarget<T>` that GLSP's own `configure` consumes, and a
-    * method in that family returning a `LanguageMetaData` invites
-    * `{ service: … }`. This one states a fact; the framework does the binding.
-    */
-   protected abstract declareLanguage(): LanguageMetaData;
-
    protected override configure(
       bind: interfaces.Bind,
       unbind: interfaces.Unbind,
       isBound: interfaces.IsBound,
       rebind: interfaces.Rebind
    ): void {
+      // Bound first: `super.configure` applies the session initializers, and the
+      // reporter's initializer entry refers to this binding.
+      applyBindingTarget({ bind, isBound }, DiagramStatusReporter, this.bindDiagramStatusReporter()).inSingletonScope();
       super.configure(bind, unbind, isBound, rebind);
-      bindDiagramLanguage(bind, this.declareLanguage());
+   }
+
+   /** The {@link DiagramStatusReporter} of the session; {@link DefaultDiagramStatusReporter} by default. */
+   protected bindDiagramStatusReporter(): BindingTarget<DiagramStatusReporter> {
+      return DefaultDiagramStatusReporter;
+   }
+
+   /** Starts the {@link DiagramStatusReporter} with the session, since nothing else injects it. */
+   override configureClientSessionInitializers(binding: MultiBinding<ClientSessionInitializer>): void {
+      super.configureClientSessionInitializers(binding);
+      binding.add({ service: DiagramStatusReporter });
+   }
+
+   /** {@link HydraniumGlspServerActionDispatcher}, so every dispatch is timed once logging is at debug. */
+   protected override bindActionDispatcher(): BindingTarget<ActionDispatcher> {
+      return HydraniumGlspServerActionDispatcher;
+   }
+
+   /** {@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; replaces the GLSP
+    * handlers that write the client's status or edit mode with ones that set a
+    * diagram status instead; and runs operations, undo and redo through
+    * {@link HydraniumGlspOperationActionHandler} and
+    * {@link HydraniumGlspUndoRedoActionHandler}, without which handlers edit
+    * the built root every reader shares.
+    */
+   protected override configureActionHandlers(binding: InstanceMultiBinding<ActionHandlerConstructor>): void {
+      super.configureActionHandlers(binding);
+      binding.add(HydraniumGlspRequestSaveModelActionHandler);
+      binding.rebind(RequestModelActionHandler, HydraniumGlspRequestModelActionHandler);
+      binding.rebind(SetEditModeActionHandler, HydraniumGlspSetEditModeActionHandler);
+      binding.rebind(OperationActionHandler, HydraniumGlspOperationActionHandler);
+      binding.rebind(UndoRedoActionHandler, HydraniumGlspUndoRedoActionHandler);
    }
 }

package/src/launcher/drop-notifications-to-gone-client.ts

@@ -0,0 +1,47 @@
+/********************************************************************************
+ * 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 type { Logger as GlspLogger } from '@eclipse-glsp/server';
+import { isClientGoneError } from '@hydranium/core';
+
+/**
+ * `connection` with a notification to a client that has gone dropped, logged
+ * at debug, rather than left to throw or reject. GLSP sends every action as a
+ * notification and drops the promise, so a client that disconnects mid-write
+ * (an `EPIPE`) or a send after GLSP disposed the connection is otherwise an
+ * unhandled rejection on every ordinary close. Any other failure still throws
+ * or rejects: {@link isClientGoneError} tells the two apart, as on the
+ * LSP head. A launcher that overrides `createConnection` applies it, as the
+ * framework's own do.
+ */
+export function dropNotificationsToGoneClient<T extends { sendNotification(method: string, ...params: unknown[]): Promise<void> }>(
+   connection: T,
+   logger: GlspLogger
+): T {
+   const dropIfGone = (error: unknown): void => {
+      if (!isClientGoneError(error)) {
+         throw error;
+      }
+      logger.debug(`Dropped a notification to a client that has gone: ${String(error)}`);
+   };
+   const sendNotification = (method: string, ...params: unknown[]): Promise<void> => {
+      try {
+         return connection.sendNotification(method, ...params).catch(dropIfGone);
+      } catch (error: unknown) {
+         // A disposed connection throws rather than rejecting.
+         dropIfGone(error);
+         return Promise.resolve();
+      }
+   };
+   return new Proxy(connection, {
+      get(target, property, receiver) {
+         return property === 'sendNotification' ? sendNotification : Reflect.get(target, property, receiver);
+      }
+   });
+}

package/src/launcher/glsp-app-module.ts

@@ -7,8 +7,7 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { GLSPModule } from '@eclipse-glsp/server';
-import type { BindingContext } from '@eclipse-glsp/protocol/lib/di/inversify-util.js';
+import { type BindingContext, GLSPModule } from '@eclipse-glsp/server';
 import type { ServerSharedServices } from '@hydranium/core';
 import { type ConflictResolver, ReconcilingConflictResolver } from '@hydranium/protocol';
 import { injectable, type interfaces } from 'inversify';