@hydranium/glsp-client-theia 1.0.0-next.10

package/src/browser/diagram-loader.ts

@@ -0,0 +1,173 @@
+/********************************************************************************
+ * 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 { DiagramLoader, type DiagramLoadingOptions, StatusAction } from '@eclipse-glsp/client';
+import { ChannelLogger } from '@hydranium/client-theia/lib/browser';
+import { Deferred } from '@hydranium/protocol';
+import { inject, injectable } from '@theia/core/shared/inversify';
+
+/**
+ * How a diagram load ended. A discriminated union rather than a boolean or a
+ * string: a consumer showing a pending indicator has to distinguish "not settled
+ * yet" (`undefined`) from either terminal state, and the failed arm has to carry
+ * enough for that consumer to decide whether *it* is now the only thing that can
+ * report the failure — see {@link DiagramLoadFailure.surfaced}.
+ */
+export type DiagramLoadOutcome = DiagramLoadSuccess | DiagramLoadFailure;
+
+export interface DiagramLoadSuccess {
+   readonly status: 'loaded';
+}
+
+export interface DiagramLoadFailure {
+   readonly status: 'failed';
+   /** The thrown value, verbatim. `unknown` because a rejection can be anything. */
+   readonly error: unknown;
+   /**
+    * Whether the `severity: 'ERROR'` {@link StatusAction} reached the action
+    * dispatcher — i.e. whether GLSP's `StatusOverlay` is now displaying this
+    * failure.
+    *
+    * `false` means the report itself failed, which happens when the action
+    * dispatcher is the thing that could not initialize. A consumer that covers
+    * the canvas must then render the failure itself: it is the only surface
+    * left, and removing its overlay would leave a blank diagram whose only
+    * explanation is a line in the Output channel — the exact failure mode this
+    * loader exists to prevent.
+    */
+   readonly surfaced: boolean;
+}
+
+/**
+ * Diagram loader that never lets a load failure vanish.
+ *
+ * `DiagramLoader.load()` orchestrates the full diagram-init path — action
+ * dispatcher init, GLSP-client connect + server `initialize`, the first
+ * `RequestModelAction`, and the model-initialization constraint. Of these only
+ * the `IDiagramStartup` hooks are wrapped by the base loader (it logs them to
+ * `console.error`); the dispatcher-init / connection / request-model steps are
+ * not. The widget that drives loading
+ * (`@eclipse-glsp/theia-integration`'s `GLSPDiagramWidget.onAfterAttach`)
+ * calls `load()` *without awaiting or catching it*, so any rejection becomes an
+ * uncaught promise rejection visible only in the browser devtools console —
+ * nothing reaches the e2e output, the server log, or a Theia log sink, and the
+ * diagram just stays blank.
+ *
+ * This subclass closes that gap: it catches every load failure, routes it to
+ * the framework Output channel (the same {@link ChannelLogger} sink the server
+ * log and action traffic share, so it is discoverable where a developer already
+ * looks), and surfaces a persistent error to the user via a `severity: 'ERROR'`
+ * {@link StatusAction} on the diagram's status overlay. It deliberately does
+ * **not** rethrow — the caller drops the promise, so rethrowing would only
+ * reproduce the uncaught rejection this exists to prevent.
+ *
+ * It also publishes the load's terminal state ({@link loadOutcome} /
+ * {@link onceLoadSettled}) so a pending indicator has one authority to key on.
+ * `HydraniumGlspDiagramWidget` uses it to cover the canvas while loading; see
+ * {@link settle} for why the signal cannot be derived from the error
+ * `StatusAction` instead.
+ *
+ * Bound by `createGlspClientTheiaModule` via `rebind(DiagramLoader)`.
+ */
+@injectable()
+export class HydraniumDiagramLoader extends DiagramLoader {
+   @inject(ChannelLogger) protected readonly channel!: ChannelLogger;
+
+   protected readonly settled = new Deferred<DiagramLoadOutcome>();
+   protected outcome?: DiagramLoadOutcome;
+
+   /** Terminal state of the load, or `undefined` while it is still in flight.
+    *  The synchronous companion of {@link onceLoadSettled}, for a consumer that
+    *  must decide something in the same tick (e.g. whether to show an indicator
+    *  at all when re-attaching an already-loaded diagram). */
+   get loadOutcome(): DiagramLoadOutcome | undefined {
+      return this.outcome;
+   }
+
+   /** Resolves once the load reaches a terminal state — on success **and** on
+    *  failure, so a caller awaiting it cannot hang. Never rejects. */
+   onceLoadSettled(): Promise<DiagramLoadOutcome> {
+      return this.settled.promise;
+   }
+
+   override async load(options?: DiagramLoadingOptions): Promise<void> {
+      try {
+         await super.load(options);
+         this.settle({ status: 'loaded' });
+      } catch (err) {
+         // Report first, settle second, and carry whether the report landed: a
+         // consumer that uncovers the canvas on settle then finds the error
+         // already on the status overlay — or learns that it has to render the
+         // failure itself because nothing else can.
+         const surfaced = await this.reportLoadFailure(err);
+         this.settle({ status: 'failed', error: err, surfaced });
+      }
+   }
+
+   /**
+    * Record the terminal state and release {@link onceLoadSettled}. Idempotent —
+    * the first outcome wins, so a reload cannot flip a settled indicator.
+    *
+    * This runs unconditionally after {@link reportLoadFailure}, *including* when
+    * the status dispatch inside it threw. That is the load-bearing property: when
+    * the action dispatcher is itself the thing that failed to initialize — the
+    * exact failure this class exists for — no `StatusAction` ever lands, so a
+    * consumer observing actions would wait forever. Settling here means a pending
+    * indicator always comes down, and `surfaced: false` tells that consumer it is
+    * now the only thing that can report the failure.
+    */
+   protected settle(outcome: DiagramLoadOutcome): void {
+      if (this.outcome !== undefined) {
+         return;
+      }
+      this.outcome = outcome;
+      this.settled.resolve(outcome);
+   }
+
+   /**
+    * Route a diagram-load failure to the Output channel and the status overlay.
+    * The status dispatch is itself guarded: when the action dispatcher is the
+    * thing that failed to initialize, dispatching may throw too, and a failure
+    * to *report* the failure must not re-escape as an uncaught rejection.
+    *
+    * @returns whether the `StatusAction` reached the dispatcher — i.e. whether the
+    * user can see this failure on the diagram. The channel line always happens, so
+    * the return value is specifically about the *user-visible* report; a `false`
+    * makes {@link DiagramLoadFailure.surfaced} false and hands the job to whoever
+    * is covering the canvas.
+    */
+   protected async reportLoadFailure(err: unknown): Promise<boolean> {
+      const label = this.loadFailureLabel(err);
+      this.channel.error(label, err);
+      try {
+         await this.actionDispatcher.dispatch(StatusAction.create(label, { severity: 'ERROR' }));
+         return true;
+      } catch (statusErr) {
+         this.channel.error('Failed to surface the diagram-load failure on the status overlay', statusErr);
+         return false;
+      }
+   }
+
+   /**
+    * The sentence a failed load is reported with, on every surface that reports
+    * it, and the only seam an adopter rewords or localizes it at. Public
+    * because the canvas overlay is one of those surfaces and lives in another
+    * class: it renders this failure exactly when the `StatusAction` did not
+    * land, so a second copy of the sentence there could only ever drift unseen.
+    */
+   loadFailureLabel(err: unknown): string {
+      return `Diagram failed to load: ${this.formatError(err)}`;
+   }
+
+   /** Render a thrown value as a message. Shared so the channel line, the status
+    *  overlay and any consumer rendering {@link DiagramLoadFailure.error} agree. */
+   protected formatError(err: unknown): string {
+      return err instanceof Error ? err.message : String(err);
+   }
+}

package/src/browser/diagram-only-marker-manager.ts

@@ -0,0 +1,33 @@
+/********************************************************************************
+ * 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 { ExternalMarkerManager, type Marker } from '@eclipse-glsp/client';
+import { injectable } from '@theia/core/shared/inversify';
+
+/**
+ * {@link ExternalMarkerManager} that drops all marker propagation into Theia's
+ * Problems view. GLSP's `SetMarkersActionHandler` still applies the in-diagram
+ * decoration through the separate `ValidationFeedbackEmitter` path; only the
+ * forward into the `ProblemManager` is suppressed, so the LSP head stays the
+ * single source of Problems-view diagnostics.
+ *
+ * Bound per diagram by `AbstractHydraniumGlspDiagramConfiguration` when its
+ * `propagateMarkersToProblemsView` flag is `false`; see that flag for when a
+ * head should choose it.
+ *
+ * Kept in its own module — importing only `@eclipse-glsp/client`, not
+ * `@eclipse-glsp/theia-integration` — so it stays unit-testable without pulling
+ * the Theia integration into the test graph.
+ */
+@injectable()
+export class NoOpExternalMarkerManager extends ExternalMarkerManager {
+   setMarkers(_markers: Marker[], _reason?: string, _sourceUri?: string): void {
+      // Intentionally empty — the LSP head owns the Problems view.
+   }
+}

package/src/browser/diagram-widget.ts

@@ -0,0 +1,178 @@
+/********************************************************************************
+ * 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 { DiagramLoader } from '@eclipse-glsp/client';
+import { GLSPDiagramWidget } from '@eclipse-glsp/theia-integration';
+// Type-only: the `@theia/core/lib/browser` barrel touches DOM globals at module
+// load, which the node-environment unit tests cannot provide.
+import { type Message } from '@theia/core/lib/browser';
+import { injectable } from '@theia/core/shared/inversify';
+import { type DiagramLoadOutcome, HydraniumDiagramLoader } from './diagram-loader';
+// Shipped by this package rather than left to adopters: an overlay whose
+// stylesheet was forgotten is an unstyled div in normal flow, which is a silent
+// failure. Adopters override individual rules from their own stylesheet.
+import '../../style/diagram-loading.css';
+
+/** Class on the overlay root. Adopters style / override via this contract. */
+export const DIAGRAM_LOADING_CLASS = 'hydranium-diagram-loading';
+
+/** Added to the overlay root when it switches from pending to reporting a
+ *  failure, so the spinner can be hidden and the text restyled from CSS alone. */
+export const DIAGRAM_LOADING_FAILED_CLASS = `${DIAGRAM_LOADING_CLASS}-failed`;
+
+/**
+ * `GLSPDiagramWidget` that covers the canvas with a spinner until the diagram
+ * load reaches a terminal state.
+ *
+ * **Why.** GLSP renders nothing until the first model arrives, so opening a
+ * diagram shows a blank tab for the whole round trip — long enough on a large
+ * model to read as a broken editor rather than a slow one.
+ *
+ * **How the pending state is sourced.** From {@link HydraniumDiagramLoader}, not
+ * from `actionDispatcher.onceModelInitialized()`. The loader settles on failure
+ * as well as on success, and it does so even when its own error-reporting
+ * dispatch throws; `onceModelInitialized()` simply never settles on a failed
+ * load. That distinction is not academic here: this overlay is opaque and covers
+ * the widget node, while GLSP's `StatusOverlay` — where the loader reports the
+ * failure — mounts *inside* the diagram's base div. Keyed on model
+ * initialization, a failed load would leave a spinner turning on top of the
+ * error message explaining it. Keyed on the loader, exactly one component decides
+ * whether the canvas is pending and the two mechanisms compose instead of
+ * competing.
+ *
+ * **The one case where this overlay reports the failure itself.** When
+ * `DiagramLoadFailure.surfaced` is `false` the loader could not dispatch its
+ * `StatusAction` — the action dispatcher was what failed — so the status overlay
+ * shows nothing. Uncovering the canvas would then leave a blank diagram whose only
+ * explanation is a line in the Output channel. In that case, and only that case,
+ * the overlay stays up and swaps the spinner for the error text.
+ *
+ * Bound unconditionally by `AbstractHydraniumGlspTheiaFrontendModule`. To opt out,
+ * override {@link showLoadingOverlay} to a no-op; to change what is rendered,
+ * override {@link createLoadingOverlay} or {@link loadingLabel}.
+ */
+@injectable()
+export class HydraniumGlspDiagramWidget extends GLSPDiagramWidget {
+   protected loadingOverlay?: HTMLElement;
+
+   protected override onAfterAttach(msg: Message): void {
+      // Before `super`, which is what starts the load on first attach — so the
+      // overlay is already up when the round trip begins.
+      this.showLoadingOverlay();
+      super.onAfterAttach(msg);
+   }
+
+   override dispose(): void {
+      this.hideLoadingOverlay();
+      super.dispose();
+   }
+
+   /**
+    * Cover the canvas until the load settles.
+    *
+    * Nothing is created unless there is a signal to take it down again: no
+    * overlay without a framework loader, and none when the load has already
+    * settled — re-attaching a loaded diagram (a tab switch) skips it entirely
+    * rather than creating and immediately removing one, so there is no flash.
+    */
+   protected showLoadingOverlay(): void {
+      if (this.loadingOverlay) {
+         return;
+      }
+      const loader = this.hydraniumDiagramLoader;
+      if (!loader || loader.loadOutcome !== undefined) {
+         return;
+      }
+      this.loadingOverlay = this.createLoadingOverlay();
+      this.node.appendChild(this.loadingOverlay);
+      // Both arms: `onceLoadSettled` never rejects, but a widget must not be able
+      // to strand an overlay if that ever changes — a rejection is treated as an
+      // outcome it cannot report, which is the safe reading.
+      loader.onceLoadSettled().then(
+         outcome => this.onLoadSettled(outcome),
+         () => this.hideLoadingOverlay()
+      );
+   }
+
+   /**
+    * Take the overlay down, or keep it as the failure's only reporter.
+    *
+    * The overlay is retained ONLY for a failure the loader could not surface;
+    * anything else uncovers the canvas, so a load that failed *and was reported*
+    * reveals GLSP's status overlay rather than double-reporting on top of it.
+    */
+   protected onLoadSettled(outcome: DiagramLoadOutcome): void {
+      if (outcome.status === 'failed' && !outcome.surfaced) {
+         this.showLoadFailure(outcome.error);
+         return;
+      }
+      this.hideLoadingOverlay();
+   }
+
+   /**
+    * Repurpose the pending overlay in place as a failure report: same node, so
+    * there is no removal-then-insertion flicker, plus a marker class so the
+    * spinner can be hidden from CSS.
+    *
+    * The wording is {@link HydraniumDiagramLoader.loadFailureLabel}'s, so an
+    * adopter rewording a load failure reaches every surface that reports it.
+    * Without the framework loader there is no failure to render, so its absence
+    * is a no-op rather than a fallback wording.
+    */
+   protected showLoadFailure(error: unknown): void {
+      const overlay = this.loadingOverlay;
+      const loader = this.hydraniumDiagramLoader;
+      if (!overlay || !loader) {
+         return;
+      }
+      overlay.classList.add(DIAGRAM_LOADING_FAILED_CLASS);
+      const label = overlay.querySelector(`.${DIAGRAM_LOADING_CLASS}-label`);
+      if (label) {
+         label.textContent = loader.loadFailureLabel(error);
+      }
+   }
+
+   protected hideLoadingOverlay(): void {
+      this.loadingOverlay?.remove();
+      this.loadingOverlay = undefined;
+   }
+
+   /** Build the overlay DOM. Override to change the wording or add content; the
+    *  root must carry {@link DIAGRAM_LOADING_CLASS} for the shipped styling, and
+    *  the label element its `-label` class so {@link showLoadFailure} finds it. */
+   protected createLoadingOverlay(): HTMLElement {
+      const overlay = document.createElement('div');
+      overlay.className = DIAGRAM_LOADING_CLASS;
+      const spinner = document.createElement('div');
+      spinner.className = `${DIAGRAM_LOADING_CLASS}-spinner`;
+      const label = document.createElement('div');
+      label.className = `${DIAGRAM_LOADING_CLASS}-label`;
+      label.textContent = this.loadingLabel;
+      overlay.appendChild(spinner);
+      overlay.appendChild(label);
+      return overlay;
+   }
+
+   /** Text shown under the spinner. Override for a domain-specific wording; the
+    *  failure text that replaces it is {@link showLoadFailure}'s. */
+   protected get loadingLabel(): string {
+      return 'Loading diagram...';
+   }
+
+   /**
+    * The framework loader for this diagram, or `undefined` when the container
+    * binds a plain `DiagramLoader`. Absence degrades to "no overlay" rather than
+    * an error: a head that opted out of the framework loader has no settle signal
+    * to key on, and an overlay that never comes down is worse than none.
+    */
+   protected get hydraniumDiagramLoader(): HydraniumDiagramLoader | undefined {
+      const loader = this.diContainer.get<DiagramLoader>(DiagramLoader);
+      return loader instanceof HydraniumDiagramLoader ? loader : undefined;
+   }
+}

package/src/browser/glsp-client-theia-module.ts

@@ -0,0 +1,54 @@
+/********************************************************************************
+ * 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 { bindChannelLogger, type ChannelLoggerOptions } from '@hydranium/client-theia/lib/browser';
+import { type BindingContext, DiagramLoader, GLSPActionDispatcher, GLSPHiddenBoundsUpdater } from '@eclipse-glsp/client';
+import { HydraniumGlspActionDispatcher } from './action-dispatcher';
+import { HydraniumDiagramLoader } from './diagram-loader';
+import { bindHydraniumGlspMessageService } from './glsp-message-service';
+import { HydraniumHiddenBoundsUpdater } from './hidden-bounds-updater';
+
+/** Options for `createGlspClientTheiaModule`. The adopter supplies the channel
+ *  logger configuration ({@link ChannelLoggerOptions} — a `channelName`, and
+ *  optionally a `component` label); the framework owns the dispatcher type and
+ *  the `ChannelLogger` binding. The log threshold is not configured here — it
+ *  is process-global, driven by `bindLogLevelPreference` or by
+ *  `AbstractHydraniumGlspTheiaFrontendModule.logLevelPreference`. */
+export interface GlspClientTheiaModuleOptions {
+   readonly channelLogger: ChannelLoggerOptions;
+}
+
+/**
+ * Composes the standard framework client bindings: the cross-head Output-channel
+ * logger, the instrumented action dispatcher, the failure-reporting diagram
+ * loader, the instrumented hidden-bounds updater, and the message service that
+ * drops the duplicate model-loading notification.
+ *
+ * Takes the whole {@link BindingContext} rather than `(bind, rebind)`: the
+ * message-service rebind has to know whether GLSP's `theiaNotificationModule`
+ * already bound its token, and a container-module body has the full context to
+ * hand anyway.
+ *
+ * Every binding is unconditional, with no per-feature flags. Each replaces a
+ * GLSP default with a strict superset of its behaviour, so a head that wants
+ * the original rebinds that one token back — the same one-line move this
+ * function makes.
+ *
+ * Adopter composition roots call this first; adopter-specific bindings
+ * (diagram-module rebinds, custom tools, etc.) layer on top.
+ */
+export function createGlspClientTheiaModule(context: BindingContext, options: GlspClientTheiaModuleOptions): void {
+   const { bind, isBound, rebind } = context;
+   bindChannelLogger(bind, options.channelLogger);
+   bind(HydraniumGlspActionDispatcher).toSelf().inSingletonScope();
+   rebind(GLSPActionDispatcher).toService(HydraniumGlspActionDispatcher);
+   rebind(DiagramLoader).to(HydraniumDiagramLoader).inSingletonScope();
+   rebind(GLSPHiddenBoundsUpdater).to(HydraniumHiddenBoundsUpdater).inSingletonScope();
+   bindHydraniumGlspMessageService(bind, isBound, rebind);
+}

package/src/browser/glsp-diagram-manager.ts

@@ -0,0 +1,67 @@
+/********************************************************************************
+ * 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 { codiconCSSString } from '@eclipse-glsp/client';
+import { GLSPDiagramManager } from '@eclipse-glsp/theia-integration';
+import { type GLSPDiagramLanguage } from '@eclipse-glsp/theia-integration/lib/common';
+import { injectable } from '@theia/core/shared/inversify';
+
+/**
+ * `GLSPDiagramManager` subclass that derives the language-correlated getters
+ * (`fileExtensions`, `diagramType`, `contributionId`, `iconClass`) from a
+ * {@link GLSPDiagramLanguage} descriptor and the human-readable `label` from a
+ * separate adopter field — so adopters override two abstract members per
+ * manager rather than a getter apiece.
+ *
+ * Adopters subclass and provide:
+ *  - {@link diagramLanguage} — wire-format identifiers + file routing
+ *  - {@link managerLabel} — human-readable label shown in the open-with menu
+ *
+ * Optional override:
+ *  - {@link customIconClass} — overrides the language's `iconClass`
+ *  - `get id()` — manager id; defaults to nothing because manager id is
+ *    typically `static readonly ID = '…'` referenced by external callers
+ *    (Theia `WidgetManager` lookups). Adopter subclasses set `static ID`
+ *    and override `get id()` to return it.
+ *
+ * Abstract base class with hook fields, adopter subclasses with concrete
+ * values, following the GLSP module convention. The container always
+ * constructs the adopter subclass, never the abstract base directly.
+ */
+@injectable()
+export abstract class AbstractHydraniumGlspDiagramManager extends GLSPDiagramManager {
+   /** Wire-format identifiers + file routing for this manager's diagram type. */
+   protected abstract readonly diagramLanguage: GLSPDiagramLanguage;
+
+   /** Human-readable label shown in the open-with menu and editor tabs. */
+   protected abstract readonly managerLabel: string;
+
+   /** Optional icon-class override; takes precedence over the language's `iconClass`. */
+   protected readonly customIconClass?: string;
+
+   override get fileExtensions(): string[] {
+      return [...this.diagramLanguage.fileExtensions];
+   }
+
+   override get diagramType(): string {
+      return this.diagramLanguage.diagramType;
+   }
+
+   override get contributionId(): string {
+      return this.diagramLanguage.contributionId;
+   }
+
+   override get iconClass(): string {
+      return this.customIconClass ?? this.diagramLanguage.iconClass ?? codiconCSSString('type-hierarchy-sub');
+   }
+
+   get label(): string {
+      return this.managerLabel;
+   }
+}

package/src/browser/glsp-message-service.ts

@@ -0,0 +1,90 @@
+/********************************************************************************
+ * 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 EndProgressAction, type StartProgressAction, type UpdateProgressAction } from '@eclipse-glsp/client';
+import { TheiaGLSPMessageService } from '@eclipse-glsp/theia-integration';
+import { type interfaces, injectable } from '@theia/core/shared/inversify';
+
+/**
+ * Title of the model-loading progress report. Emitted by
+ * `@eclipse-glsp/server`'s `RequestModelActionHandler`, so it is a GLSP-protocol
+ * constant every server shares, not an adopter string — which is what makes
+ * matching on it a framework-level concern.
+ *
+ * Matched by title because `StartProgressAction` carries no kind or category to
+ * key on; the `progressId` is generated per report, so it can only be correlated
+ * after the fact (see {@link HydraniumGlspMessageService.suppressedProgressIds}).
+ *
+ * Matching an English literal fails silently — no error, no log line, just the
+ * duplicate progress popup back — so this needs keeping in step with
+ * `RequestModelActionHandler` on every GLSP bump.
+ */
+export const MODEL_LOADING_PROGRESS_TITLE = 'Model loading in progress';
+
+/**
+ * Drops the Theia progress notification for diagram model loading, and only that
+ * one.
+ *
+ * `HydraniumGlspDiagramWidget`'s loading overlay already reports model loading,
+ * on the canvas the user is looking at; the notification says the same thing in a
+ * corner popup. Every other progress report is forwarded untouched, so a
+ * long-running server operation still surfaces normally.
+ *
+ * Bound unconditionally by `createGlspClientTheiaModule`, because the overlay it
+ * defers to is likewise unconditional. A head that no-ops the overlay and wants
+ * the notification back rebinds `TheiaGLSPMessageService` to GLSP's own.
+ */
+@injectable()
+export class HydraniumGlspMessageService extends TheiaGLSPMessageService {
+   /** Ids of reports that were swallowed, so their updates and completion are
+    *  dropped as well — otherwise Theia sees an update for a progress it never
+    *  started. */
+   protected suppressedProgressIds = new Set<string>();
+
+   protected override startProgress(action: StartProgressAction): void {
+      if (action.title === MODEL_LOADING_PROGRESS_TITLE) {
+         this.suppressedProgressIds.add(action.progressId);
+         return;
+      }
+      super.startProgress(action);
+   }
+
+   protected override updateProgress(action: UpdateProgressAction): void {
+      if (this.suppressedProgressIds.has(action.progressId)) {
+         return;
+      }
+      super.updateProgress(action);
+   }
+
+   protected override endProgress(action: EndProgressAction): void {
+      // `delete` reports whether the id was suppressed and cleans the entry up in
+      // one step, so the set cannot grow across reloads.
+      if (this.suppressedProgressIds.delete(action.progressId)) {
+         return;
+      }
+      super.endProgress(action);
+   }
+}
+
+/**
+ * Replace the message service bound by GLSP's `theiaNotificationModule`.
+ *
+ * Called by `createGlspClientTheiaModule`, whose module the adopter registers
+ * after the Theia default modules — so the token is normally already bound and
+ * this rebinds. The `isBound` branch keeps it correct regardless of module order
+ * and if GLSP's default composition changes: it degrades to "we bind it
+ * ourselves" instead of an inversify error at diagram-open time.
+ */
+export function bindHydraniumGlspMessageService(bind: interfaces.Bind, isBound: interfaces.IsBound, rebind: interfaces.Rebind): void {
+   if (isBound(TheiaGLSPMessageService)) {
+      rebind(TheiaGLSPMessageService).to(HydraniumGlspMessageService).inSingletonScope();
+   } else {
+      bind(TheiaGLSPMessageService).to(HydraniumGlspMessageService).inSingletonScope();
+   }
+}