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

package/lib/node/glsp-server-connection-handler.js

@@ -22,38 +22,35 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GlspServerConnectionHandler = void 0;
 const common_1 = require("@eclipse-glsp/theia-integration/lib/common");
-const node_1 = require("@eclipse-glsp/theia-integration/lib/node");
-const node_2 = require("@hydranium/client-theia/lib/node");
+const node_1 = require("@hydranium/client-theia/node");
 const inversify_1 = require("@theia/core/shared/inversify");
 /**
  * Bridges a Theia browser-frontend channel to a GLSP server's TCP socket.
  *
- * The port-discovery + buffer-and-replay race fix + connect orchestration live
- * on the cross-head {@link AbstractSocketForwardingConnectionHandler} base; this
- * subclass supplies only the GLSP specifics — the per-language servicePath
+ * The port discovery, the buffer-and-replay race fix, the connect orchestration
+ * and the byte forwarder live on the cross-head
+ * {@link AbstractSocketForwardingConnectionHandler} base; this subclass supplies
+ * only the GLSP specifics — the per-language servicePath
  * (`GLSPContribution.servicePath + '/' + languageContributionId`), the port
- * command, the log labels — and plugs in `@eclipse-glsp/theia-integration`'s
- * `SocketConnectionForwarder` as the byte relay. Adopters with different
- * language ids or command names subclass with a one-line `super({...})` call.
- * Sibling of `@hydranium/data-client-theia`'s `DataServerConnectionHandler`,
- * which subclasses the same base with its own GLSP-free forwarder.
+ * command, the log labels. Adopters with different language ids or command
+ * names subclass with a one-line `super({...})` call.
  */
-let GlspServerConnectionHandler = class GlspServerConnectionHandler extends node_2.AbstractSocketForwardingConnectionHandler {
+let GlspServerConnectionHandler = class GlspServerConnectionHandler extends node_1.AbstractSocketForwardingConnectionHandler {
     constructor(options) {
         super({
             path: common_1.GLSPContribution.servicePath + '/' + options.languageContributionId,
             portCommand: options.portCommand,
             logComponent: 'GLSP',
-            serverName: options.serverName ?? 'Graphical Server',
+            serverName: options.serverName ?? 'Diagram Server',
             findPortTimeout: options.findPortTimeout,
             findPortAttempts: options.findPortAttempts,
             connectTimeoutMs: options.connectTimeoutMs,
             onSocketCreated: options.onSocketCreated
         });
     }
-    forwardToSocketConnection(clientChannel, socket) {
-        return new node_1.SocketConnectionForwarder(clientChannel, socket);
-    }
+    /** Logged only: the frontend contribution reports the failed start, and a
+     *  second notification would duplicate it. */
+    reportConnectFailure() { }
 };
 exports.GlspServerConnectionHandler = GlspServerConnectionHandler;
 exports.GlspServerConnectionHandler = GlspServerConnectionHandler = __decorate([

package/lib/node/glsp-server-connection-handler.js.map

@@ -1 +1 @@
-{"version":3,"file":"glsp-server-connection-handler.js","sourceRoot":"","sources":["../../src/node/glsp-server-connection-handler.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;;;;;;;;;;;;;AAElF,uEAA8E;AAC9E,mEAAqF;AACrF,2DAA6F;AAE7F,4DAAqE;AAkCrE;;;;;;;;;;;;GAYG;AAEI,IAAM,2BAA2B,GAAjC,MAAM,2BAA4B,SAAQ,gDAAyC;IACvF,YAAyB,OAA2C;QACjE,KAAK,CAAC;YACH,IAAI,EAAE,yBAAgB,CAAC,WAAW,GAAG,GAAG,GAAG,OAAO,CAAC,sBAAsB;YACzE,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,YAAY,EAAE,MAAM;YACpB,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,kBAAkB;YACpD,eAAe,EAAE,OAAO,CAAC,eAAe;YACxC,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;YAC1C,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;YAC1C,eAAe,EAAE,OAAO,CAAC,eAAe;SAC1C,CAAC,CAAC;IACN,CAAC;IAES,yBAAyB,CAAC,aAAsB,EAAE,MAAkB;QAC3E,OAAO,IAAI,gCAAyB,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;IAC/D,CAAC;CACH,CAAA;AAjBY,kEAA2B;sCAA3B,2BAA2B;IADvC,IAAA,sBAAU,GAAE;IAEG,WAAA,IAAA,qBAAS,GAAE,CAAA;;GADd,2BAA2B,CAiBvC"}
+{"version":3,"file":"glsp-server-connection-handler.js","sourceRoot":"","sources":["../../src/node/glsp-server-connection-handler.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;;;;;;;;;;;;;AAElF,uEAA8E;AAC9E,uDAAyF;AACzF,4DAAqE;AA0BrE;;;;;;;;;;GAUG;AAEI,IAAM,2BAA2B,GAAjC,MAAM,2BAA4B,SAAQ,gDAAyC;IACvF,YAAyB,OAA2C;QACjE,KAAK,CAAC;YACH,IAAI,EAAE,yBAAgB,CAAC,WAAW,GAAG,GAAG,GAAG,OAAO,CAAC,sBAAsB;YACzE,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,YAAY,EAAE,MAAM;YACpB,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,gBAAgB;YAClD,eAAe,EAAE,OAAO,CAAC,eAAe;YACxC,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;YAC1C,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;YAC1C,eAAe,EAAE,OAAO,CAAC,eAAe;SAC1C,CAAC,CAAC;IACN,CAAC;IAED;kDAC8C;IAC3B,oBAAoB,KAAU,CAAC;CACpD,CAAA;;sCAjBY,2BAA2B;IADvC,IAAA,sBAAU,GAAE;IAEG,WAAA,IAAA,qBAAS,GAAE,CAAA;;GADd,2BAA2B,CAiBvC"}

package/package.json

@@ -1,32 +1,40 @@
 {
   "name": "@hydranium/glsp-client-theia",
-  "version": "1.0.0-next.32",
-  "description": "Theia-coupled client primitives for GLSP heads built on @hydranium/glsp-server. Provides the action dispatcher, channel logger, and connection-handler bases that Theia-based adopters extend; companion of @hydranium/glsp-server.",
+  "version": "1.0.0-next.321",
+  "description": "Theia-coupled client primitives for GLSP heads built on @hydranium/glsp-server. Provides the diagram widget, manager, client contribution and connection-handler bases that Theia-based adopters extend, and binds @hydranium/glsp-client's host-neutral classes through the Output channel; companion of @hydranium/glsp-server.",
   "keywords": [
+    "diagram",
+    "glsp",
     "hydranium",
     "langium",
     "language-server",
     "lsp",
-    "glsp",
-    "diagram",
     "theia"
   ],
   "homepage": "https://github.com/eclipse-emfcloud/hydranium/tree/main/packages/glsp-client-theia",
   "bugs": {
     "url": "https://github.com/eclipse-emfcloud/hydranium/issues"
   },
+  "license": "MIT",
+  "author": {
+    "name": "Hydranium Team"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/eclipse-emfcloud/hydranium.git",
     "directory": "packages/glsp-client-theia"
   },
-  "license": "MIT",
-  "author": {
-    "name": "Hydranium Team"
-  },
+  "files": [
+    "lib",
+    "src",
+    "style",
+    "!lib/**/*.tsbuildinfo"
+  ],
   "sideEffects": [
     "**/*.css"
   ],
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "exports": {
     ".": {
       "types": "./lib/index.d.ts",
@@ -40,36 +48,15 @@
       "types": "./lib/node/index.d.ts",
       "default": "./lib/node/index.js"
     },
-    "./testing": {
-      "types": "./lib/testing/index.d.ts",
-      "default": "./lib/testing/index.js"
-    },
-    "./lib/browser": {
-      "types": "./lib/browser/index.d.ts",
-      "default": "./lib/browser/index.js"
-    },
-    "./lib/node": {
-      "types": "./lib/node/index.d.ts",
-      "default": "./lib/node/index.js"
-    },
-    "./lib/testing": {
-      "types": "./lib/testing/index.d.ts",
-      "default": "./lib/testing/index.js"
-    },
     "./style/diagram-loading.css": "./style/diagram-loading.css"
   },
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "files": [
-    "lib",
-    "src",
-    "style",
-    "!lib/**/*.tsbuildinfo"
-  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "tsc -b",
     "clean": "rimraf lib tsconfig.tsbuildinfo",
-    "lint": "eslint src test --max-warnings 0",
+    "lint": "oxlint --format stylish --config ../../oxlint.config.cjs src test --max-warnings 0",
     "prepack": "node -e \"const m=require('./package.json'),fs=require('node:fs');const missing=[m.main,...Object.values(m.bin||{})].filter(entry=>entry&&!fs.existsSync(entry));if(missing.length){console.error('prepack '+m.name+': not built ('+missing.join(', ')+' missing). Run the build before packing: a files entry that matches nothing is skipped silently, so the tarball would ship src only.');process.exit(1);}\"",
     "test": "npm run typecheck:test && vitest run",
     "typecheck:test": "tsc --noEmit -p tsconfig.test.json",
@@ -77,38 +64,42 @@
   },
   "devDependencies": {
     "@eclipse-glsp/client": "2.7.0",
+    "@eclipse-glsp/server": "2.7.0",
     "@eclipse-glsp/theia-integration": "2.7.0",
-    "@hydranium/client-theia": "1.0.0-next.32",
-    "@hydranium/protocol": "1.0.0-next.32",
+    "@hydranium/client-theia": "1.0.0-next.321",
+    "@hydranium/core": "1.0.0-next.321",
+    "@hydranium/glsp-client": "1.0.0-next.321",
+    "@hydranium/glsp-server": "1.0.0-next.321",
+    "@hydranium/protocol": "1.0.0-next.321",
     "@theia/core": "^1.70.0",
-    "@theia/output": "^1.70.0",
     "@theia/process": "^1.70.0",
     "@theia/workspace": "^1.70.0",
     "@types/node": "^22.0.0",
     "inversify": "6.2.2",
+    "reflect-metadata": "0.2.2",
     "rimraf": "^5.0.0",
     "snabbdom": "3.5.1",
-    "typescript": "^5.8.0"
+    "typescript": "^7.0.2",
+    "vscode-jsonrpc": "9.0.0"
   },
   "peerDependencies": {
     "@eclipse-glsp/client": "^2.6.0",
     "@eclipse-glsp/theia-integration": "^2.6.0",
-    "@hydranium/client-theia": "1.0.0-next.32",
-    "@hydranium/protocol": "1.0.0-next.32",
+    "@hydranium/client-theia": "1.0.0-next.321",
+    "@hydranium/glsp-client": "1.0.0-next.321",
+    "@hydranium/protocol": "1.0.0-next.321",
     "@theia/core": "^1.70.0",
-    "@theia/output": "^1.70.0",
     "@theia/process": "^1.70.0",
     "@theia/workspace": "^1.70.0",
     "inversify": "^6.0.0",
-    "snabbdom": "^3.5.1"
+    "snabbdom": "^3.5.1",
+    "vscode-jsonrpc": "^9.0.0"
   },
   "engines": {
     "node": ">=22.13"
   },
-  "publishConfig": {
-    "access": "public"
-  },
-  "//exports": "The stylesheet key is an ASSET entry, not a module subpath, and it is spelled as the exact filename rather than `./style/*` so nothing becomes reachable automatically — the same no-wildcard property every other key here has. It exists because the widget's own import is package-RELATIVE, which `exports` does not gate, so the map's silence broke nobody inside the package while blocking every adopter who wants to `@import` the sheet, re-bundle it or override it by specifier; that failure reads as \"not exported under the conditions\" rather than as a missing entry. It has NO `./lib/style/...` twin, and must not grow one: the twin rule exists so a bare subpath is reachable from a node10 MODULE resolver, `tsc` emits no assets so there is no `lib/style/` to point at, and a bundler — which is what resolves a stylesheet — reads the map. `check:exports` carves out exactly this shape and asserts instead that the target file exists and is covered by `files`, which is the pair of mistakes an asset key can actually make.",
-  "//prepack": "The publish guard, and it deliberately is NOT a `prepare`: npm runs a workspace `prepare` BEFORE the root `postinstall` that applies patches/vscode-jsonrpc+9.0.1.patch, so building there fails on a cold clone and npm rolls the entire install back. `prepack` runs only when a tarball is made (`npm pack`, `npm publish`) and never on install, so it cannot break the install it has no business touching. It FAILS rather than rebuilds, because the rebuild is exactly the part that ordering defeats. What it defends against: `files` lists `lib`, `lib` is gitignored, and a `files` entry matching nothing is skipped SILENTLY — so `npm publish` from an unbuilt tree emits a tarball of `src` and nothing else, with no error.",
+  "//exports": "The stylesheet key is an ASSET entry, not a module subpath, and it is spelled as the exact filename rather than `./style/*` so nothing becomes reachable automatically — the same no-wildcard property every other key here has. It exists because the widget's own import is package-RELATIVE, which `exports` does not gate, so the map's silence broke nobody inside the package while blocking every adopter who wants to `@import` the sheet, re-bundle it or override it by specifier; that failure reads as \"not exported under the conditions\" rather than as a missing entry. `tsc` emits no assets, so no build step produces the target; `check:exports` asserts that the file exists and is covered by `files`, which is the pair of mistakes an asset key can actually make.",
+  "//peerDependencies": "`vscode-jsonrpc` is a peer because the client loads its `browser` entry for one effect: GLSP's Theia channel connection requires the top-level copy's root entry, which installs no runtime layer, so without that entry the frontend receives no message. A peer resolves to that same top-level copy. The caret matches the other framework packages.",
+  "//prepack": "The publish guard, a `prepack` rather than a `prepare`: `prepack` runs only when a tarball is made (`npm pack`, `npm publish`) and never on install, so it cannot break the install it has no business touching. What it defends against: `files` lists `lib`, `lib` is gitignored, and a `files` entry matching nothing is skipped SILENTLY — so `npm publish` from an unbuilt tree emits a tarball of `src` and nothing else, with no error.",
   "//sideEffects": "A stylesheet IS the side effect: `style/diagram-loading.css` is pulled in by a bare import in `browser/diagram-widget.js`, and a CSS module exports nothing, so under a blanket `false` a bundler drops the import as unused and the diagram loading overlay renders unstyled. Nothing fails at build time. The glob rather than the importing module, so a second stylesheet is covered without another edit; the widget itself is reached through its exported class and needs no flag."
 }

package/src/browser/client-contribution.ts

@@ -7,94 +7,293 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { type GLSPClient } from '@eclipse-glsp/client';
+import { ClientState, type GLSPClient, type InitializeResult } from '@eclipse-glsp/client';
 import { BaseGLSPClientContribution } from '@eclipse-glsp/theia-integration';
+import { createChannelConnection, GLSPContribution } from '@eclipse-glsp/theia-integration/lib/common';
+import { ChannelLogger, ConnectionReporter, type ConnectionTarget } from '@hydranium/client-theia/browser';
+import { Clock } from '@hydranium/client-theia/common';
+import { HydraniumGlspClient } from '@hydranium/glsp-client';
+import { sendByMethodName, describeError, type Stopwatch, SystemClock } from '@hydranium/protocol';
+import { type Channel, Disposable, Emitter, Event, nls } from '@theia/core';
 import { Deferred } from '@theia/core/lib/common/promise-util';
-import { inject, injectable, unmanaged } from '@theia/core/shared/inversify';
-import { OutputChannelManager } from '@theia/output/lib/browser/output-channel';
+import { inject, injectable, optional, unmanaged } from '@theia/core/shared/inversify';
 import { WorkspaceService } from '@theia/workspace/lib/browser';
+// GLSP's channel connection uses the top-level `vscode-jsonrpc`'s root entry, which
+// installs no runtime layer; without the browser entry, no message is received.
+import 'vscode-jsonrpc/browser';
 
-/** Options for `HydraniumGlspClientContribution`. The channel name is the
- *  Theia Output channel both the LSP and GLSP sides write to (so log lines
- *  interleave); the ready marker is a server-printed substring that signals
- *  "the GLSP server is accepting client connections". */
+export const DEFAULT_GLSP_CLIENT_STARTUP_TIMEOUT_MS = 30_000;
+
+/** Options for `HydraniumGlspClientContribution`. */
 export interface ClientContributionOptions {
    readonly languageContributionId: string;
-   readonly channelName: string;
-   readonly readyMarker: string;
+   /** How long a start may take, from the workspace opening to the server
+    *  answering `initializeServer`, before it fails; `0` or less waits for good. */
+   readonly startupTimeoutMs?: number;
 }
 
 /**
  * Theia GLSP client contribution for adopters whose GLSP server runs in a
  * sideloaded VS Code extension process (or any other deferred-start setup).
- * The behaviours adopters reliably need are lifted:
  *
- *   1. `waitForBackendConnected`: tail the OutputChannel for a server-printed
- *      ready marker. While a socket connection might open earlier, the GLSP
- *      server typically does internal initialisation before it can accept
- *      client connections — we wait for it to say so.
- *   2. `start`: defer until a workspace is opened. If Theia starts without a
- *      workspace, this prevents the frontend-backend connection (and its
- *      "connecting" progress spinner) from firing prematurely.
+ * The client starts once a workspace is open and sends its first request at
+ * once; the backend handler holds it until its socket to the server is up. A
+ * start that fails, and a connection lost after one succeeded, start a fresh
+ * client after a backoff, for as long as the contribution lives. Each start is
+ * reported through the {@link ConnectionReporter}, and announced through
+ * {@link onDidStartClient} and {@link onDidLoseClient}.
  *
  * A `GLSPClient` override filtering inbound messages by clientId is
  * deliberately NOT provided: upstream's `BaseJsonrpcGLSPClient.onActionMessage`
- * already filters by clientId, so the `TheiaJsonrpcGLSPClient` returned by
- * `BaseGLSPClientContribution.createGLSPClient` is correct as-is.
+ * already filters by clientId.
  */
 @injectable()
 export class HydraniumGlspClientContribution extends BaseGLSPClientContribution {
-   @inject(OutputChannelManager) protected outputChannelManager!: OutputChannelManager;
    @inject(WorkspaceService) protected readonly workspaceService!: WorkspaceService;
+   @inject(ConnectionReporter) protected readonly connectionReporter!: ConnectionReporter;
+   @inject(ChannelLogger) protected readonly logger!: ChannelLogger;
+   /** Times the restart escalation reset: the container's {@link Clock}, or a `SystemClock`. */
+   @inject(Clock) @optional() protected readonly clock: Clock = new SystemClock();
 
    readonly id: string;
-   protected readonly channelName: string;
-   protected readonly readyMarker: string;
+
+   /** Delay before the restart following each consecutive failed start or lost
+    *  client; the last repeats. */
+   protected readonly restartDelaysMs: readonly number[] = [1_000, 2_000, 4_000, 8_000];
+   /** How long a client must stay up before the restart delays start over, so
+    *  a server that fails right after starting is not restarted at once. */
+   protected readonly restartEscalationResetMs: number = 30_000;
+   protected consecutiveFailures = 0;
+   protected restartTimer?: ReturnType<typeof setTimeout>;
+   /** Running since the current client started; cleared once a restart has taken it into account. */
+   protected sinceStart?: Stopwatch;
+   /** Clients started so far, which numbers them in the log: they share {@link id}. */
+   protected startedClients = 0;
+   /** The attempt waiting for a channel, if any. */
+   protected channelRequest?: Deferred<Channel>;
+   protected disposed = false;
+   protected readonly clientStartedEmitter = new Emitter<GLSPClient>();
+   protected readonly clientLostEmitter = new Emitter<void>();
+
+   /** Fires with each client once it has started and its server has answered. */
+   readonly onDidStartClient: Event<GLSPClient> = this.clientStartedEmitter.event;
+   /** Fires when the started client stops; {@link glspClient} already waits
+    *  for its replacement then. */
+   readonly onDidLoseClient: Event<void> = this.clientLostEmitter.event;
 
    constructor(@unmanaged() options: ClientContributionOptions) {
       super();
       this.id = options.languageContributionId;
-      this.channelName = options.channelName;
-      this.readyMarker = options.readyMarker;
-   }
-
-   /** Wait for the server to print its ready marker into the OutputChannel.
-    *  Resolves immediately if the marker is already present (server started
-    *  before the client contribution mounted). */
-   protected async waitForBackendConnected(): Promise<void> {
-      const channel = this.outputChannelManager.getChannel(this.channelName);
-      const channelText =
-         (channel as unknown as { resource?: { textModel?: { getValue(): string } } }).resource?.textModel?.getValue() ?? '';
-      if (channelText.includes(this.readyMarker)) {
+      this.glspClientStartupTimeout = options.startupTimeoutMs ?? DEFAULT_GLSP_CLIENT_STARTUP_TIMEOUT_MS;
+   }
+
+   /** The client every diagram load awaits; after a failed start, a fresh one. */
+   override get glspClient(): Promise<GLSPClient> {
+      return this.glspClientDeferred.state === 'rejected' ? this.restart() : this.glspClientDeferred.promise;
+   }
+
+   /** Start a fresh client over a fresh channel at once, if the last start failed. */
+   restart(): Promise<GLSPClient> {
+      if (!this.disposed && this.glspClientDeferred.state === 'rejected') {
+         this.replaceClient();
+         void this.activateClient();
+      }
+      return this.glspClientDeferred.promise;
+   }
+
+   /** Point {@link glspClient} at a fresh client still to start, and tear down
+    *  the old one's channel. */
+   protected replaceClient(): void {
+      clearTimeout(this.restartTimer);
+      // Replaced before the old channel goes, so the old client stopping is
+      // not taken for a loss of the new one.
+      this.glspClientDeferred = new Deferred<GLSPClient>();
+      this.toDispose.dispose();
+      // Upstream refuses to open a channel while the collection is disposed.
+      this.toDispose.push(Disposable.NULL);
+   }
+
+   /** Settles the promise current when it began, so a start a restart overtook
+    *  cannot settle its successor. */
+   protected override async activateClient(): Promise<void> {
+      const pending = this.glspClientDeferred;
+      await this.workspaceOpened();
+      if (this.disposed) {
          return;
       }
-      const deferred = new Deferred<void>();
-      const channelListener = channel.onContentChange(() => {
-         const text = (channel as unknown as { resource?: { textModel?: { getValue(): string } } }).resource?.textModel?.getValue() ?? '';
-         if (text.includes(this.readyMarker)) {
-            channelListener.dispose();
-            deferred.resolve();
+      const attempt = this.connectionReporter.connecting(this.connectionTarget);
+      const timeout =
+         this.glspClientStartupTimeout > 0
+            ? setTimeout(() => pending.reject(new Error(this.startupTimeoutMessage())), this.glspClientStartupTimeout)
+            : undefined;
+      pending.promise.then(
+         client => {
+            clearTimeout(timeout);
+            attempt.connected();
+            this.sinceStart = this.clock.stopwatch();
+            this.logger.info(`[${this.id}] Diagram client ${++this.startedClients} started.`);
+            this.clientStartedEmitter.fire(client);
+            this.restartOnLoss(client);
+         },
+         (error: unknown) => {
+            clearTimeout(timeout);
+            if (this.disposed) {
+               attempt.cancelled();
+               return;
+            }
+            attempt.failed(describeError(error), () => void this.restart());
+            this.scheduleRestart(() => {
+               if (this.glspClientDeferred === pending) {
+                  void this.restart();
+               }
+            });
+         }
+      );
+      try {
+         const connection = await this.createConnection();
+         // Ahead of the client's own listener, whose teardown rejects with a
+         // transport message instead.
+         connection.onClose(() => pending.reject(new Error(this.unreachableMessage())));
+         // Upstream builds the connection from the `vscode-jsonrpc` hoisted
+         // beside it and the client's typed messages from its protocol's copy;
+         // a type sent over another copy's connection throws.
+         const client = await this.createGLSPClient(sendByMethodName(connection));
+         connection.onDispose(() => client.stop());
+         await this.start(client);
+         pending.resolve(client);
+      } catch (error: unknown) {
+         pending.reject(error);
+      }
+   }
+
+   /** Run `restart` after the delay for the failures so far, and return that delay. */
+   protected scheduleRestart(restart: () => void): number {
+      if (this.sinceStart !== undefined && this.sinceStart.elapsedMs >= this.restartEscalationResetMs) {
+         this.consecutiveFailures = 0;
+      }
+      this.sinceStart = undefined;
+      const delay = this.restartDelaysMs[Math.min(this.consecutiveFailures, this.restartDelaysMs.length - 1)];
+      this.consecutiveFailures++;
+      clearTimeout(this.restartTimer);
+      this.restartTimer = setTimeout(restart, delay);
+      return delay;
+   }
+
+   /** Once `client` stops, replace it and start its replacement after the
+    *  restart delay, unless a dispose stopped it. */
+   protected restartOnLoss(client: GLSPClient): void {
+      const listener = client.onCurrentStateChanged(state => {
+         if (state !== ClientState.ServerError && state !== ClientState.Stopped) {
+            return;
+         }
+         listener.dispose();
+         if (!this.disposed) {
+            this.replaceClient();
+            this.clientLostEmitter.fire();
+            const delay = this.scheduleRestart(() => void this.activateClient());
+            // Upstream's client has just logged that it will not be restarted, which holds for it alone.
+            this.logger.info(`[${this.id}] Diagram client ${this.startedClients} lost; starting a fresh one in ${delay} ms.`);
          }
       });
-      return deferred.promise;
    }
 
+   /** Start the client and initialize its server, rejecting on failure; the
+    *  caller settles {@link glspClient}. */
    protected override async start(glspClient: GLSPClient): Promise<void> {
-      // Defer starting the GLSP client until a workspace is opened. If Theia
-      // starts without a workspace, this prevents creating the frontend-
-      // backend connection (and showing the "connecting" progress) prematurely.
+      await glspClient.start();
+      await this.initialize(glspClient);
+   }
+
+   /** Without upstream's own error notification, which would duplicate the reporter's. */
+   protected override async initialize(glspClient: GLSPClient): Promise<InitializeResult> {
+      return glspClient.initializeServer(await this.createInitializeParameters());
+   }
+
+   /** Upstream's base client, without the notifications of its Theia subclass,
+    *  which would duplicate the reporter's. */
+   protected override async createGLSPClient(
+      connectionProvider: Parameters<BaseGLSPClientContribution['createGLSPClient']>[0]
+   ): Promise<GLSPClient> {
+      return new HydraniumGlspClient({ id: this.id, connectionProvider });
+   }
+
+   /**
+    * Whichever channel arrives goes to the attempt waiting now, and one that
+    * arrives with none waiting is closed. Theia holds each open until its
+    * websocket is back, and after an outage every held open past the first
+    * throws "already open" without reaching its handler, so the first to arrive
+    * has to serve the latest attempt. Without Theia's replay, which would be a
+    * second opener of the same path.
+    */
+   protected override async createChannelConnection(): ReturnType<BaseGLSPClientContribution['createChannelConnection']> {
+      this.channelRequest?.reject(new Error('A newer start took over the channel request.'));
+      const request = new Deferred<Channel>();
+      this.channelRequest = request;
+      this.connectionProvider.listen(
+         GLSPContribution.getPath(this),
+         (_path, channel) => {
+            const waiting = this.channelRequest;
+            this.channelRequest = undefined;
+            if (waiting && !this.disposed) {
+               waiting.resolve(channel);
+            } else {
+               channel.close();
+            }
+         },
+         false
+      );
+      const channel = await request.promise;
+      const connection = createChannelConnection(channel, this.logger);
+      this.toDispose.push(Disposable.create(() => this.disposeChannel(connection, channel)));
+      return connection;
+   }
+
+   /** Also closes the channel: upstream leaves a Theia channel open, and the
+    *  next one on the same path then cannot open. */
+   protected override async disposeChannel(
+      connection: Parameters<BaseGLSPClientContribution['disposeChannel']>[0],
+      channel: Channel
+   ): Promise<void> {
+      await super.disposeChannel(connection, channel);
+      channel.close();
+   }
+
+   /** Also fails a start in flight, so nothing reports it after this. */
+   override dispose(): void {
+      this.disposed = true;
+      clearTimeout(this.restartTimer);
+      this.glspClientDeferred.promise.catch(() => undefined);
+      this.glspClientDeferred.reject(new Error('The diagram client was disposed.'));
+      this.clientStartedEmitter.dispose();
+      this.clientLostEmitter.dispose();
+      super.dispose();
+   }
+
+   protected async workspaceOpened(): Promise<void> {
       const roots = this.workspaceService.tryGetRoots();
-      if (!roots || roots.length === 0) {
-         await new Promise<void>(resolve => {
-            const disposable = this.workspaceService.onWorkspaceChanged(changedRoots => {
-               if (changedRoots && changedRoots.length > 0) {
-                  disposable.dispose();
-                  resolve();
-               }
-            });
-         });
+      if (roots.length === 0) {
+         await Event.toPromise(Event.filter(this.workspaceService.onWorkspaceChanged, changedRoots => changedRoots.length > 0));
       }
-      await this.waitForBackendConnected();
-      return super.start(glspClient);
+   }
+
+   protected get connectionTarget(): ConnectionTarget {
+      return (this.cachedConnectionTarget ??= {
+         connectingMessage: nls.localize('hydranium/glsp-client-theia/diagram-server-connecting', 'Connecting to the diagram server…'),
+         connectedMessage: nls.localize('hydranium/glsp-client-theia/diagram-server-connected', 'Connected to the diagram server.')
+      });
+   }
+   /** One object per contribution: the reporter keys what it has shown on it. */
+   protected cachedConnectionTarget?: ConnectionTarget;
+
+   protected unreachableMessage(): string {
+      return nls.localize('hydranium/glsp-client-theia/diagram-server-unreachable', 'Could not connect to the diagram server.');
+   }
+
+   protected startupTimeoutMessage(): string {
+      return nls.localize(
+         'hydranium/glsp-client-theia/diagram-server-timeout',
+         'The diagram server did not answer within {0} seconds.',
+         String(Math.round(this.glspClientStartupTimeout / 1000))
+      );
    }
 }