@hydranium/glsp-client-theia 1.0.0-next.32 → 1.0.0-next.321

package/src/browser/diagram-widget.ts

@@ -7,13 +7,17 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { DiagramLoader } from '@eclipse-glsp/client';
-import { GLSPDiagramWidget } from '@eclipse-glsp/theia-integration';
+import { type Args, DiagramLoader, EditorContextService, GLSPActionDispatcher, SetViewportAction } from '@eclipse-glsp/client';
+import { RESUME_TOKEN_ARG } from '@hydranium/protocol';
+import { GLSPDiagramWidget, type GLSPDiagramWidgetOptions } from '@eclipse-glsp/theia-integration';
+import { type DiagramLoadOutcome, HydraniumDiagramLoader } from '@hydranium/glsp-client';
 // 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';
+import { Emitter, type Event, nls } from '@theia/core';
+import { type Container, inject, injectable } from '@theia/core/shared/inversify';
+import { HydraniumGlspSaveable } from './glsp-saveable';
+import { WindowSessionService } from './window-session';
 // 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.
@@ -35,31 +39,55 @@ export const DIAGRAM_LOADING_FAILED_CLASS = `${DIAGRAM_LOADING_CLASS}-failed`;
  * 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.
+ * from `actionDispatcher.onceModelInitialized()`: the loader settles on failure
+ * as well as on success, even when its own error report throws, while
+ * `onceModelInitialized()` never settles on a failed load and would leave the
+ * spinner turning for good.
  *
- * **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.
+ * A failed load keeps the overlay up with the error and a Retry, which asks for
+ * a fresh widget through {@link onDidRequestReopen}.
  *
  * 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}.
+ *
+ * Its saveable is a {@link HydraniumGlspSaveable}, which keeps a pending save
+ * dirty, so Theia's exit check still counts it; see {@link createSaveable}.
  */
 @injectable()
 export class HydraniumGlspDiagramWidget extends GLSPDiagramWidget {
+   @inject(WindowSessionService) protected readonly windowSessions!: WindowSessionService;
    protected loadingOverlay?: HTMLElement;
+   protected readonly reopenRequestEmitter = new Emitter<void>();
+
+   /** Fires when this diagram asks to be replaced by a fresh widget, as its
+    *  Retry does; `AbstractHydraniumGlspDiagramManager` reopens it. A load is
+    *  not repeated in place, since GLSP's model source registers its handlers
+    *  once per load. */
+   readonly onDidRequestReopen: Event<void> = this.reopenRequestEmitter.event;
+
+   /**
+    * Replaces the saveable GLSP's `configure` builds inline, with no factory
+    * seam. The widget factory calls `configure` before the widget reaches the
+    * shell, so Theia only ever tracks this one.
+    */
+   override configure(options: GLSPDiagramWidgetOptions, diContainer: Container): void {
+      super.configure(options, diContainer);
+      this.saveable.dispose();
+      this.saveable = this.createSaveable();
+      this.toDispose.push(this.saveable);
+      this.toDispose.push(this.reopenRequestEmitter);
+   }
+
+   /** The widget's saveable. Override to change how saves and dirty state behave. */
+   protected createSaveable(): GLSPDiagramWidget['saveable'] {
+      return new HydraniumGlspSaveable(this.actionDispatcher, this.diContainer.get(EditorContextService));
+   }
+
+   /** Adds the window's resume token, so a reload or reconnect takes this diagram's session over. */
+   protected override getRequestModelOptions(): Args {
+      return { ...super.getRequestModelOptions(), [RESUME_TOKEN_ARG]: this.windowSessions.current().resumeToken };
+   }
 
    protected override onAfterAttach(msg: Message): void {
       // Before `super`, which is what starts the load on first attach — so the
@@ -73,6 +101,19 @@ export class HydraniumGlspDiagramWidget extends GLSPDiagramWidget {
       super.dispose();
    }
 
+   /**
+    * GLSP's restore with `animate: false`; compare the two on a GLSP upgrade.
+    * An animated restore holds back every later command, so a Delete right
+    * after a select-all typed as the diagram opens finds nothing selected.
+    */
+   protected override async setViewportData(viewportData: Parameters<GLSPDiagramWidget['setViewportData']>[0]): Promise<void> {
+      if (this.actionDispatcher instanceof GLSPActionDispatcher) {
+         this.actionDispatcher.dispatchOnceModelInitialized(
+            SetViewportAction.create(viewportData.elementId, viewportData.viewportData, { animate: false })
+         );
+      }
+   }
+
    /**
     * Cover the canvas until the load settles.
     *
@@ -100,15 +141,9 @@ export class HydraniumGlspDiagramWidget extends GLSPDiagramWidget {
       );
    }
 
-   /**
-    * 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.
-    */
+   /** Take the overlay down, or keep it as the failure's report. */
    protected onLoadSettled(outcome: DiagramLoadOutcome): void {
-      if (outcome.status === 'failed' && !outcome.surfaced) {
+      if (outcome.status === 'failed') {
          this.showLoadFailure(outcome.error);
          return;
       }
@@ -136,6 +171,23 @@ export class HydraniumGlspDiagramWidget extends GLSPDiagramWidget {
       if (label) {
          label.textContent = loader.loadFailureLabel(error);
       }
+      overlay.appendChild(this.createRetryButton());
+   }
+
+   /** Ask for a fresh widget, after a failed load. */
+   protected retryLoad(): void {
+      if (this.hydraniumDiagramLoader?.loadOutcome?.status === 'failed') {
+         this.reopenRequestEmitter.fire();
+      }
+   }
+
+   /** Build the failure overlay's Retry button, which calls {@link retryLoad}. */
+   protected createRetryButton(): HTMLElement {
+      const button = document.createElement('button');
+      button.className = `theia-button ${DIAGRAM_LOADING_CLASS}-retry`;
+      button.textContent = nls.localize('hydranium/glsp-client-theia/diagram-load-retry', 'Retry');
+      button.addEventListener('click', () => this.retryLoad());
+      return button;
    }
 
    protected hideLoadingOverlay(): void {

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

@@ -7,12 +7,19 @@
  * 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 { type BindingContext, DiagramLoader } from '@eclipse-glsp/client';
+import {
+   bindChannelLogger,
+   ChannelLogger,
+   type ChannelLoggerOptions,
+   ChannelTracer,
+   getRequestParentName
+} from '@hydranium/client-theia/browser';
+import { Clock } from '@hydranium/client-theia/common';
+import { createGlspClientModule, HydraniumClientTypes } from '@hydranium/glsp-client';
+import { SystemClock } from '@hydranium/protocol';
 import { bindHydraniumGlspMessageService } from './glsp-message-service';
-import { HydraniumHiddenBoundsUpdater } from './hidden-bounds-updater';
+import { HydraniumGlspTheiaDiagramLoader } from './theia-diagram-loader';
 
 /** Options for `createGlspClientTheiaModule`. The adopter supplies the channel
  *  logger configuration ({@link ChannelLoggerOptions} — a `channelName`, and
@@ -25,10 +32,17 @@ export interface GlspClientTheiaModuleOptions {
 }
 
 /**
- * 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.
+ * Composes the standard framework client bindings for a Theia frontend: the
+ * cross-head Output-channel logger, the host-neutral classes
+ * `createGlspClientModule` binds, fed from that channel, the loader that renders
+ * its failure through Theia's catalogue, and the message service that drops
+ * the duplicate model-loading notification.
+ *
+ * The neutral tokens are bound BEFORE the neutral binder runs, so it binds no
+ * console defaults. The logger binding tags each line with the requesting
+ * class, as `bindChannelLogger`'s own does; a plain `toService` alias would
+ * start a fresh request and lose the tag. The clock is resolved lazily, so a
+ * clock an adopter module binds after this one is still the one used.
  *
  * Takes the whole {@link BindingContext} rather than `(bind, rebind)`: the
  * message-service rebind has to know whether GLSP's `theiaNotificationModule`
@@ -46,9 +60,16 @@ export interface GlspClientTheiaModuleOptions {
 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();
+   bind(HydraniumClientTypes.Logger).toDynamicValue(ctx => {
+      const base = ctx.container.get(ChannelLogger);
+      const parentName = getRequestParentName(ctx);
+      return parentName ? base.for(parentName) : base;
+   });
+   bind(HydraniumClientTypes.Tracer).toService(ChannelTracer);
+   bind(HydraniumClientTypes.Clock)
+      .toDynamicValue(ctx => (ctx.container.isBound(Clock) ? ctx.container.get<Clock>(Clock) : new SystemClock()))
+      .inSingletonScope();
+   createGlspClientModule(context);
+   rebind(DiagramLoader).to(HydraniumGlspTheiaDiagramLoader).inSingletonScope();
    bindHydraniumGlspMessageService(bind, isBound, rebind);
 }

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

@@ -7,12 +7,22 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { codiconCSSString } from '@eclipse-glsp/client';
+import { codiconCSSString, DiagramLoader, type IDiagramOptions } from '@eclipse-glsp/client';
 import { GLSPDiagramManager } from '@eclipse-glsp/theia-integration';
 import { type GLSPDiagramLanguage } from '@eclipse-glsp/theia-integration/lib/common';
-import { type GLSPDiagramWidget } from '@eclipse-glsp/theia-integration/lib/browser';
+import {
+   type GLSPDiagramWidget,
+   type GLSPDiagramWidgetOptions,
+   type GLSPWidgetOpenerOptions
+} from '@eclipse-glsp/theia-integration/lib/browser';
 import { type WidgetOpenerOptions } from '@theia/core/lib/browser';
-import { injectable } from '@theia/core/shared/inversify';
+import { type Disposable, DisposableCollection } from '@theia/core';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { textHash } from '@hydranium/protocol';
+import { HydraniumDiagramLoader } from '@hydranium/glsp-client';
+import { HydraniumGlspClientContribution } from './client-contribution';
+import { HydraniumGlspDiagramWidget } from './diagram-widget';
+import { WindowSessionService } from './window-session';
 
 /**
  * `GLSPDiagramManager` subclass that derives the language-correlated getters
@@ -47,6 +57,12 @@ export abstract class AbstractHydraniumGlspDiagramManager extends GLSPDiagramMan
    /** Optional icon-class override; takes precedence over the language's `iconClass`. */
    protected readonly customIconClass?: string;
 
+   @inject(WindowSessionService) protected readonly windowSessions!: WindowSessionService;
+
+   protected clientListeners?: Disposable;
+   /** The reopens asked for so far, which run one at a time. */
+   protected reopening: Promise<void> = Promise.resolve();
+
    override get fileExtensions(): string[] {
       return [...this.diagramLanguage.fileExtensions];
    }
@@ -67,6 +83,99 @@ export abstract class AbstractHydraniumGlspDiagramManager extends GLSPDiagramMan
       return this.managerLabel;
    }
 
+   override async createWidget(options?: unknown): Promise<GLSPDiagramWidget> {
+      this.listenToClient();
+      const widget = await super.createWidget(options);
+      if (widget instanceof HydraniumGlspDiagramWidget) {
+         widget.onDidRequestReopen(() => void this.reopen(widget));
+      }
+      return widget;
+   }
+
+   /**
+    * The same client id for the same diagram in this window, across a reload
+    * and a reopen after a lost client, so its load takes over the session the
+    * old connection left and keeps its unsaved text. A diagram closed by the
+    * user ends its session, and opening it again starts afresh.
+    *
+    * The widget options enter as a hash: GLSP makes the id an element id and
+    * finds it with an `#id` selector, which a URI's `:` and `/` break. The
+    * options identify the widget, so two widgets of one document, in two edit
+    * modes or set apart by an option an adopter adds, do not take each other's
+    * session over.
+    */
+   protected override createDiagramOptions(options: GLSPDiagramWidgetOptions): IDiagramOptions {
+      const clientId = `${this.diagramType}_${this.windowSessions.current().id}_${textHash(JSON.stringify(options))}`;
+      return { ...super.createDiagramOptions(options), clientId };
+   }
+
+   /**
+    * Reopen every diagram once its client is lost, since none of them has a
+    * server behind it any more, and a failed one once a client starts.
+    */
+   protected listenToClient(): void {
+      if (this.clientListeners) {
+         return;
+      }
+      const contribution = this.diagramServiceProvider.getGLSPClientContribution(this.contributionId);
+      this.clientListeners =
+         contribution instanceof HydraniumGlspClientContribution
+            ? new DisposableCollection(
+                 contribution.onDidLoseClient(() => this.reopenAll(() => true)),
+                 contribution.onDidStartClient(() => this.reopenAll(widget => this.loadFailed(widget)))
+              )
+            : new DisposableCollection();
+   }
+
+   protected reopenAll(which: (widget: GLSPDiagramWidget) => boolean): void {
+      for (const widget of this.all.filter(which)) {
+         void this.reopen(widget);
+      }
+   }
+
+   protected loadFailed(widget: GLSPDiagramWidget): boolean {
+      const loader = widget.diContainer.get<DiagramLoader>(DiagramLoader);
+      return loader instanceof HydraniumDiagramLoader && loader.loadOutcome?.status === 'failed';
+   }
+
+   /**
+    * Replace `widget` with a fresh one for the same diagram, in the same tab
+    * position and with its viewport: a new container and load under the same
+    * client id, which takes over the session the old connection left.
+    * Reopens run one at a time, since each places its replacement next to a
+    * neighbour that a reopen running alongside could take out of the layout.
+    */
+   reopen(widget: GLSPDiagramWidget): Promise<void> {
+      const reopened = this.reopening.then(() => this.replaceWidget(widget));
+      this.reopening = reopened.catch(() => undefined);
+      return reopened;
+   }
+
+   /** Taken down as a close does, but without its save prompt, since a dirty
+    *  diagram whose server is gone has nothing to save to. */
+   protected async replaceWidget(widget: GLSPDiagramWidget): Promise<void> {
+      if (widget.isDisposed) {
+         return;
+      }
+      const tabBar = this.shell.getTabBarFor(widget);
+      const titles = tabBar?.titles ?? [];
+      const index = titles.indexOf(widget.title);
+      // ponytail: a diagram alone in its tab bar reopens where a new one opens,
+      // since its split closes with it; restore the dock layout if that matters.
+      const neighbour = index > 0 ? titles[index - 1].owner : titles[index + 1]?.owner;
+      const mode = this.shell.activeWidget === widget ? 'activate' : tabBar?.currentTitle === widget.title ? 'reveal' : 'open';
+      // Detached before the dispose, as a close does: the widget stores its
+      // viewport on detach, and its dispose empties the container it reads.
+      widget.parent = null;
+      widget.dispose();
+      const options: GLSPWidgetOpenerOptions = {
+         mode,
+         editMode: widget.options.editMode,
+         widgetOptions: neighbour ? { ref: neighbour, mode: index > 0 ? 'tab-after' : 'tab-before' } : undefined
+      };
+      await this.open(widget.uri, options);
+   }
+
    /**
     * Drops a `selection` key that is present but `undefined` before the base
     * class reads it.

package/src/browser/glsp-saveable.ts

@@ -0,0 +1,111 @@
+/********************************************************************************
+ * 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 { RequestSaveModelAction } from '@hydranium/protocol';
+// The module path, not the package root: the root also loads GLSP's diagram
+// widget, which touches DOM globals at module load, and this module's unit tests
+// load it in Node.
+import { GLSPSaveable } from '@eclipse-glsp/theia-integration/lib/browser/diagram/glsp-saveable';
+
+/**
+ * A `GLSPSaveable` whose every save is a request the server answers, and which
+ * stays dirty until that answer arrives.
+ *
+ * GLSP's sends a `SaveModelAction`, which the server does not answer. It takes
+ * the next dirty-state change to clean as the answer, but the editor context
+ * reports a change only when the dirty flag changes: the second of two saves
+ * gets no answer, and a failed save gets none either. Here each save sends a
+ * `RequestSaveModelAction` and settles on the response to that request only:
+ * it resolves when the server has saved, rejects when the server rejects it,
+ * and rejects when {@link saveTimeout} runs out. A save sent while another is
+ * pending is a request of its own, so an edit made between the two is saved.
+ *
+ * GLSP's also reports not dirty from the moment it sends a save. Theia's exit
+ * check asks only whether anything is dirty, so the window closes over a save
+ * the server has not finished, and a page reloaded right after Ctrl+S gives no
+ * warning. Here the saveable is dirty while any save is pending. GLSP's also
+ * gives up after 2 s, and Theia's Save All then counts the save as failed and
+ * closes the window anyway, so a slow save of a large model is cut off.
+ *
+ * The dirty flag still comes from the server. An edit whose dirty-state change
+ * has not arrived when Save All runs does not make the saveable dirty, so that
+ * edit is not saved.
+ *
+ * The server answers only where the diagram module registers the request's
+ * handler; `AbstractHydraniumGlspDiagramModule` does. A server without it does
+ * not advertise the request, and against such a server the saveable is GLSP's:
+ * it sends a `SaveModelAction` and reports dirty as GLSP's does. It does not
+ * keep only the dirty-while-pending half there, because GLSP's tracks one
+ * pending save and a second save overwrites it, so the first would never
+ * report clean.
+ *
+ * The answer means the server has done what its save does, which is not always
+ * the disk write: under the `fire-and-forget` `SaveDeliveryPolicy` the server
+ * answers before the write finishes and answers a failed write as saved, so a
+ * window closed on that answer can still lose the write.
+ */
+export class HydraniumGlspSaveable extends GLSPSaveable {
+   /**
+    * How long a save waits for the server's response before it rejects. The
+    * server answers up to its language-client settle bound after the write, so
+    * this exceeds that bound with room for the write itself; a save that
+    * rejects in Theia's Save All lets the window close over it.
+    */
+   protected override saveTimeout = 20_000;
+   /** The saves sent and not yet settled. */
+   protected readonly pendingSaves = new Set<Promise<void>>();
+
+   override get dirty(): boolean {
+      if (!this.serverAnswersSaves()) {
+         return super.dirty;
+      }
+      return this.editorContextService.isDirty || this.pendingSaves.size > 0;
+   }
+
+   override save(): Promise<void> {
+      if (!this.serverAnswersSaves()) {
+         return super.save();
+      }
+      if (this.editorContextService.isDirty) {
+         return this.sendSave();
+      }
+      // Nothing new to save, but a save still pending has not finished.
+      return Promise.all(this.pendingSaves).then(() => undefined);
+   }
+
+   /**
+    * Whether the server answers a {@link RequestSaveModelAction}. GLSP's model
+    * source registers a handler for each kind the server advertises before it
+    * requests the model, so the dispatcher knows it from the first save on.
+    */
+   protected serverAnswersSaves(): boolean {
+      return this.actionDispatcher.hasHandler(RequestSaveModelAction.create());
+   }
+
+   protected sendSave(): Promise<void> {
+      // `request` with a bound of our own rather than GLSP's `requestUntil`:
+      // that one forgets a request when it times out, so a late response is
+      // dispatched as an action no client handler takes, which rejects.
+      // Here a late response settles the forgotten request and nothing else.
+      const response = this.actionDispatcher.request(RequestSaveModelAction.create());
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      const timedOut = new Promise<never>((_resolve, reject) => {
+         timer = setTimeout(() => reject(new Error('Save operation timed out')), this.saveTimeout);
+      });
+      const saving: Promise<void> = Promise.race([response, timedOut])
+         .then(() => undefined)
+         .finally(() => {
+            clearTimeout(timer);
+            this.pendingSaves.delete(saving);
+            this.onDirtyChangedEmitter.fire(undefined);
+         });
+      this.pendingSaves.add(saving);
+      return saving;
+   }
+}

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

@@ -17,9 +17,10 @@ import {
    registerDiagramManager
 } from '@eclipse-glsp/theia-integration';
 import { type GLSPDiagramLanguage } from '@eclipse-glsp/theia-integration/lib/common';
-import { bindLogLevelPreference } from '@hydranium/client-theia/lib/browser';
+import { bindConnectionReporter, bindLogLevelPreference } from '@hydranium/client-theia/browser';
 import type { interfaces } from '@theia/core/shared/inversify';
 import { HydraniumGlspDiagramWidget } from './diagram-widget';
+import { bindWindowSessionService } from './window-session';
 
 /**
  * Sentinel returned from {@link AbstractHydraniumGlspTheiaFrontendModule.bindClientContribution}
@@ -106,6 +107,8 @@ export abstract class AbstractHydraniumGlspTheiaFrontendModule extends GLSPTheia
     */
    override initialize(context: ContainerContext): void {
       super.initialize(context);
+      bindConnectionReporter(context.bind, context.isBound);
+      bindWindowSessionService(context.bind, context.isBound);
       if (this.logLevelPreference) {
          bindLogLevelPreference(context.bind, this.logLevelPreference);
       }

package/src/browser/hydranium-glsp-diagram-configuration.ts

@@ -22,7 +22,9 @@ import { NoOpExternalMarkerManager } from './diagram-only-marker-manager.js';
  * **When to suppress.** A head with a co-resident LSP that publishes its
  * diagnostics over standard LSP `publishDiagnostics` would otherwise list each
  * error twice: GLSP's `TheiaMarkerManager` pushes the *same* errors again under
- * a different marker owner, and Theia shows the union across owners. The GLSP
+ * a different marker owner, and Theia shows the union across owners. One shared
+ * owner would not merge them either: each write replaces that owner's markers
+ * for the file, so the two heads would overwrite each other's. The GLSP
  * path is also open-diagram-scoped (markers clear when the diagram closes), so
  * for such a head it cannot reproduce the LSP head's persistent, cross-file
  * Problems entries — it is only ever a flickering duplicate. A graphical-only

package/src/browser/index.ts

@@ -7,16 +7,23 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-// Browser-side framework primitives for GLSP-on-Theia adopters.
-// The cross-head Output-channel logger lives in `@hydranium/client-theia/browser`.
-export * from './action-dispatcher';
+// Browser-side framework primitives for GLSP-on-Theia adopters. The
+// host-neutral classes (the dispatcher, loader, updater, overlay and client)
+// are `@hydranium/glsp-client`'s; the cross-head Output-channel logger lives
+// in `@hydranium/client-theia/browser`.
 export * from './client-contribution';
-export * from './diagram-loader';
 export * from './diagram-only-marker-manager';
 export * from './diagram-widget';
 export * from './glsp-client-theia-module';
 export * from './glsp-diagram-manager';
 export * from './glsp-message-service';
+export * from './glsp-saveable';
 export * from './glsp-theia-frontend-module';
-export * from './hidden-bounds-updater';
 export * from './hydranium-glsp-diagram-configuration';
+export * from './theia-diagram-loader';
+export * from './window-session';
+
+// Upstream's root entry is its browser tier and re-exports no `lib/common`, so the
+// type our abstract `diagramLanguage` members are declared with has no bare-specifier
+// path — without this line every adopter implementing one deep-imports it.
+export type { GLSPDiagramLanguage } from '@eclipse-glsp/theia-integration/lib/common';

package/src/browser/theia-diagram-loader.ts

@@ -0,0 +1,31 @@
+/********************************************************************************
+ * 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 { HydraniumDiagramLoader } from '@hydranium/glsp-client';
+import { nls } from '@theia/core';
+import { injectable } from '@theia/core/shared/inversify';
+
+/**
+ * The framework loader rendering its failure through Theia's catalogue, which
+ * knows the reading user's locale where the neutral loader does not.
+ *
+ * The key and the English are inline literals, because `theia nls-extract`
+ * drops a key it cannot resolve. The English must match
+ * `DIAGRAM_LOAD_FAILED`'s text in `@hydranium/glsp-client`; a test holds them
+ * equal.
+ *
+ * Bound by `createGlspClientTheiaModule` via `rebind(DiagramLoader)`, after
+ * `createGlspClientModule` bound the neutral loader.
+ */
+@injectable()
+export class HydraniumGlspTheiaDiagramLoader extends HydraniumDiagramLoader {
+   override loadFailureLabel(err: unknown): string {
+      return nls.localize('hydranium/glsp-client-theia/diagram-load-failed', 'Diagram failed to load: {0}', this.formatError(err));
+   }
+}