@hydranium/data-client-theia 1.0.0-next.60 → 1.0.0-next.62

package/lib/browser/channel-data-port.d.ts

@@ -0,0 +1,65 @@
+/********************************************************************************
+ * 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 DataPort, type ResolvedMessage } from '@hydranium/protocol';
+import { Emitter, MessageService, type Event } from '@theia/core';
+import { type ServiceConnectionProvider } from '@theia/core/lib/browser';
+import { WorkspaceService } from '@theia/workspace/lib/browser';
+import type { MessageConnection } from 'vscode-jsonrpc';
+import { type ChannelConnectionHandle } from './channel-connection';
+/**
+ * A {@link DataPort} over a Theia frontend channel.
+ *
+ * Subclasses supply {@link servicePath}; everything above the port —
+ * `DataConnection`, its sessions, and whatever model a widget drives — is
+ * host-neutral and shared with the VS Code and browser shells.
+ *
+ * Bind one per service path and in singleton scope. Theia keys a frontend
+ * channel by its path and refuses a second on a path already open, and the
+ * throw escapes the `openChannelConnection` the loser is awaiting, leaving that
+ * promise unsettled rather than rejected.
+ */
+export declare abstract class ChannelDataPort implements DataPort {
+    protected readonly connectionProvider: ServiceConnectionProvider;
+    protected readonly workspaceService: WorkspaceService;
+    protected readonly messageService: MessageService;
+    /** Frontend service path the backend forwarder for this head is registered under. */
+    protected abstract readonly servicePath: string;
+    /**
+     * Re-open the channel when the current connection is lost. Default `true` —
+     * re-opening is the only thing that recovers a restarted language server,
+     * which binds new ephemeral ports. Turn it off for a frontend that tears
+     * itself down on transport loss instead.
+     */
+    protected readonly reconnectOnConnectionLoss: boolean;
+    protected readonly disposeEmitter: Emitter<void>;
+    readonly onDispose: Event<void>;
+    protected handle?: ChannelConnectionHandle;
+    /**
+     * Open the workspace-gated channel and hand back its listening connection.
+     *
+     * Gated because the backend forwarder discovers the head's port by executing
+     * a command the language server answers, and the language server only
+     * launches once there is a workspace to launch it for. Asking earlier polls
+     * a command nobody has registered.
+     */
+    connect(): Promise<MessageConnection>;
+    /**
+     * Surface a transport or write failure as a Theia notification.
+     *
+     * Swallowing it is the failure this exists to prevent: a dead connection and
+     * an empty document are indistinguishable in a widget.
+     *
+     * `reported` is already a complete sentence with the detail interpolated, so
+     * wrapping it in a sentence of the host's own would nest one owner's clause
+     * inside another's and leave no translator in control of the whole.
+     */
+    reportError(_error: unknown, reported: ResolvedMessage): void;
+    dispose(): void;
+}
+//# sourceMappingURL=channel-data-port.d.ts.map

package/lib/browser/channel-data-port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-data-port.d.ts","sourceRoot":"","sources":["../../src/browser/channel-data-port.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAA0B,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAClG,OAAO,EAAE,OAAO,EAAE,cAAc,EAAO,KAAK,KAAK,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAGzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,KAAK,uBAAuB,EAAyB,MAAM,sBAAsB,CAAC;AAG3F;;;;;;;;;;;GAWG;AACH,8BACsB,eAAgB,YAAW,QAAQ;IACpB,SAAS,CAAC,QAAQ,CAAC,kBAAkB,EAAG,yBAAyB,CAAC;IAC1E,SAAS,CAAC,QAAQ,CAAC,gBAAgB,EAAG,gBAAgB,CAAC;IACzD,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAG,cAAc,CAAC;IAE3E,qFAAqF;IACrF,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAEhD;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,yBAAyB,EAAE,OAAO,CAAQ;IAE7D,SAAS,CAAC,QAAQ,CAAC,cAAc,gBAAuB;IACxD,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,CAA6B;IAE5D,SAAS,CAAC,MAAM,CAAC,EAAE,uBAAuB,CAAC;IAE3C;;;;;;;OAOG;IACH,OAAO,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAkBrC;;;;;;;;;OASG;IACH,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,eAAe,GAAG,IAAI;IAI7D,OAAO,IAAI,IAAI;CAMjB"}

package/lib/browser/channel-data-port.js

@@ -0,0 +1,115 @@
+"use strict";
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelDataPort = void 0;
+const protocol_1 = require("@hydranium/protocol");
+const core_1 = require("@theia/core");
+const service_connection_provider_1 = require("@theia/core/lib/browser/messaging/service-connection-provider");
+const inversify_1 = require("@theia/core/shared/inversify");
+const browser_1 = require("@theia/workspace/lib/browser");
+const channel_connection_1 = require("./channel-connection");
+const workspace_gate_1 = require("./workspace-gate");
+/**
+ * A {@link DataPort} over a Theia frontend channel.
+ *
+ * Subclasses supply {@link servicePath}; everything above the port —
+ * `DataConnection`, its sessions, and whatever model a widget drives — is
+ * host-neutral and shared with the VS Code and browser shells.
+ *
+ * Bind one per service path and in singleton scope. Theia keys a frontend
+ * channel by its path and refuses a second on a path already open, and the
+ * throw escapes the `openChannelConnection` the loser is awaiting, leaving that
+ * promise unsettled rather than rejected.
+ */
+let ChannelDataPort = class ChannelDataPort {
+    connectionProvider;
+    workspaceService;
+    messageService;
+    /**
+     * Re-open the channel when the current connection is lost. Default `true` —
+     * re-opening is the only thing that recovers a restarted language server,
+     * which binds new ephemeral ports. Turn it off for a frontend that tears
+     * itself down on transport loss instead.
+     */
+    reconnectOnConnectionLoss = true;
+    disposeEmitter = new core_1.Emitter();
+    onDispose = this.disposeEmitter.event;
+    handle;
+    /**
+     * Open the workspace-gated channel and hand back its listening connection.
+     *
+     * Gated because the backend forwarder discovers the head's port by executing
+     * a command the language server answers, and the language server only
+     * launches once there is a workspace to launch it for. Asking earlier polls
+     * a command nobody has registered.
+     */
+    connect() {
+        // Read per call rather than cached: `current` is repointed at a fresh
+        // promise every time the channel is re-opened, so reading through the
+        // handle is what makes a later generation reach the live server.
+        if (!this.handle) {
+            this.handle = (0, channel_connection_1.openChannelConnection)(this.connectionProvider, this.servicePath, {
+                whenReady: (0, workspace_gate_1.whenWorkspaceOpen)(this.workspaceService),
+                reconnect: this.reconnectOnConnectionLoss
+            });
+            // A relaunched server binds new ephemeral ports; the handle re-opens
+            // and the forwarder rediscovers, but `DataConnection` caches its
+            // generation and would go on addressing the dead one. Its signal to
+            // drop that generation is this event.
+            this.handle.onDidLoseConnection(() => this.disposeEmitter.fire(undefined));
+        }
+        return this.handle.current;
+    }
+    /**
+     * Surface a transport or write failure as a Theia notification.
+     *
+     * Swallowing it is the failure this exists to prevent: a dead connection and
+     * an empty document are indistinguishable in a widget.
+     *
+     * `reported` is already a complete sentence with the detail interpolated, so
+     * wrapping it in a sentence of the host's own would nest one owner's clause
+     * inside another's and leave no translator in control of the whole.
+     */
+    reportError(_error, reported) {
+        this.messageService.error((0, protocol_1.renderFrameworkMessage)(reported, core_1.nls.localization?.translations));
+    }
+    dispose() {
+        this.handle?.dispose();
+        this.handle = undefined;
+        this.disposeEmitter.fire(undefined);
+        this.disposeEmitter.dispose();
+    }
+};
+exports.ChannelDataPort = ChannelDataPort;
+__decorate([
+    (0, inversify_1.inject)(service_connection_provider_1.RemoteConnectionProvider),
+    __metadata("design:type", Function)
+], ChannelDataPort.prototype, "connectionProvider", void 0);
+__decorate([
+    (0, inversify_1.inject)(browser_1.WorkspaceService),
+    __metadata("design:type", browser_1.WorkspaceService)
+], ChannelDataPort.prototype, "workspaceService", void 0);
+__decorate([
+    (0, inversify_1.inject)(core_1.MessageService),
+    __metadata("design:type", core_1.MessageService)
+], ChannelDataPort.prototype, "messageService", void 0);
+exports.ChannelDataPort = ChannelDataPort = __decorate([
+    (0, inversify_1.injectable)()
+], ChannelDataPort);
+//# sourceMappingURL=channel-data-port.js.map

package/lib/browser/channel-data-port.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-data-port.js","sourceRoot":"","sources":["../../src/browser/channel-data-port.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;;;;;;;;;;AAElF,kDAAkG;AAClG,sCAAuE;AAEvE,+GAAyG;AACzG,4DAAkE;AAClE,0DAAgE;AAEhE,6DAA2F;AAC3F,qDAAqD;AAErD;;;;;;;;;;;GAWG;AAEI,IAAe,eAAe,GAA9B,MAAe,eAAe;IACmB,kBAAkB,CAA6B;IACvD,gBAAgB,CAAoB;IACtC,cAAc,CAAkB;IAK3E;;;;;OAKG;IACgB,yBAAyB,GAAY,IAAI,CAAC;IAE1C,cAAc,GAAG,IAAI,cAAO,EAAQ,CAAC;IAC/C,SAAS,GAAgB,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC;IAElD,MAAM,CAA2B;IAE3C;;;;;;;OAOG;IACH,OAAO;QACJ,sEAAsE;QACtE,sEAAsE;QACtE,iEAAiE;QACjE,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,IAAI,CAAC,MAAM,GAAG,IAAA,0CAAqB,EAAC,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,WAAW,EAAE;gBAC5E,SAAS,EAAE,IAAA,kCAAiB,EAAC,IAAI,CAAC,gBAAgB,CAAC;gBACnD,SAAS,EAAE,IAAI,CAAC,yBAAyB;aAC3C,CAAC,CAAC;YACH,qEAAqE;YACrE,iEAAiE;YACjE,oEAAoE;YACpE,sCAAsC;YACtC,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;QAC9E,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;IAC9B,CAAC;IAED;;;;;;;;;OASG;IACH,WAAW,CAAC,MAAe,EAAE,QAAyB;QACnD,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,IAAA,iCAAsB,EAAC,QAAQ,EAAE,UAAG,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC;IAC/F,CAAC;IAED,OAAO;QACJ,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC;QACvB,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;QACxB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACpC,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;IACjC,CAAC;CACH,CAAA;AAnEqB,0CAAe;AACmB;IAApD,IAAA,kBAAM,EAAC,sDAAwB,CAAC;;2DAAmE;AACvD;IAA5C,IAAA,kBAAM,EAAC,0BAAgB,CAAC;8BAAuC,0BAAgB;yDAAC;AACtC;IAA1C,IAAA,kBAAM,EAAC,qBAAc,CAAC;8BAAqC,qBAAc;uDAAC;0BAHxD,eAAe;IADpC,IAAA,sBAAU,GAAE;GACS,eAAe,CAmEpC"}

package/lib/browser/data-service-frontend.d.ts

@@ -6,10 +6,10 @@
  *
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
+import { type DataPort, type ReadyServer, type ResolvedMessage, RpcConnection, type RpcProxy } from '@hydranium/protocol';
+import { Emitter, type MessageService } from '@theia/core';
 import type { ServiceConnectionProvider } from '@theia/core/lib/browser';
-import { Deferred } from '@theia/core/lib/common/promise-util';
 import type { WorkspaceService } from '@theia/workspace/lib/browser';
-import type { MessageConnection } from 'vscode-jsonrpc';
 import { type ChannelConnectionHandle } from './channel-connection';
 /**
  * Base for a Theia frontend that owns the data-server vscode-jsonrpc
@@ -24,109 +24,64 @@ import { type ChannelConnectionHandle } from './channel-connection';
  * the local notification target `TClient`. A subclass supplies the abstract
  * members below, calls {@link start} from its `@postConstruct`, and awaits
  * {@link ensureConnected} before its first `this.server.*` call.
+ *
+ * The lifecycle is `RpcConnection`'s — the same proxy, readiness gate and
+ * reconnect generation the host-neutral tier uses. What stays here is the Theia
+ * half: the channel, the workspace gate and the notification sink.
  */
-export declare abstract class AbstractDataServiceFrontend<TServer extends {
-    waitForReady(): Promise<void>;
-}, TClient extends object> {
-    /**
-     * The workspace-gated connection to the backend forwarder. Set by
-     * {@link start}, and REPLACED whenever the connection is lost and
-     * {@link reconnectOnConnectionLoss} is on — so read it per use and never
-     * cache the resolved connection.
-     */
-    protected connectionPromise: Promise<MessageConnection>;
-    /**
-     * Typed proxy over {@link connectionPromise}, addressing the server under
-     * {@link methodNamespace}. Set by {@link start}, and replaced alongside
-     * {@link connectionPromise} on reconnect.
-     *
-     * `createRpcProxy` resolves the connection promise once and binds to it for
-     * good, so a reconnect necessarily means a new proxy. Reading
-     * `this.server.foo()` per call — rather than hoisting `this.server` into a
-     * local or a constructor-time field — is what keeps a subclass correct
-     * across one.
-     */
-    protected server: TServer;
-    /** The channel handle {@link start} opened; owns reconnect and disposal. */
-    protected channel?: ChannelConnectionHandle;
-    /** Shared init Deferred so concurrent {@link ensureConnected} callers await one initialization. */
-    protected initialized?: Deferred<void>;
-    /** Theia connection provider the channel is opened through. */
+export declare abstract class AbstractDataServiceFrontend<TServer extends ReadyServer, TClient extends object> {
     protected abstract readonly connectionProvider: ServiceConnectionProvider;
-    /**
-     * Optional workspace service. When provided, the default
-     * {@link connectionReadyGate} waits for a workspace before opening the
-     * channel; a head that is not workspace-scoped omits it (and may override
-     * {@link connectionReadyGate} for a different gate).
-     */
     protected abstract readonly workspaceService?: WorkspaceService;
-    /** Local inbound-notification target bound on the connection (the `localTarget`). */
     protected abstract readonly client: TClient;
-    /**
-     * Theia service path the backend forwarder is registered under.
-     *
-     * **Unique per frontend, not per server.** Theia keys a frontend channel by
-     * this path and throws `Another channel with the id '<path>' is already open`
-     * on a second opener — so a subclass sharing the framework default with any
-     * other consumer of the same head (a host-neutral `DataPort`, a sibling
-     * service frontend) breaks whichever opens second. The failure is remote from
-     * its cause: the throw escapes an `openChannelConnection` the other consumer
-     * awaited, leaving its request permanently unsettled rather than rejected,
-     * which presents as a view stuck on its loading state with a clean server
-     * log. Give each frontend its own path and register a forwarder per path;
-     * they still reach one server, since the shared `portCommand` is what names
-     * the process.
-     */
+    /** Frontend service path the backend forwarder for this head is registered under. */
     protected abstract readonly servicePath: string;
-    /** Wire namespace the server + client methods are addressed under. */
     protected abstract readonly methodNamespace: string;
     /** Allowlist of {@link client} methods to bind as inbound handlers. */
     protected abstract readonly clientMethods: readonly (keyof TClient & string)[];
+    /** Surfaces a transport failure. Optional: a frontend with no UI of its own omits it. */
+    protected readonly messageService?: MessageService;
     /**
-     * Rebuild the connection and the proxy when the current connection is lost,
-     * and re-run initialization against the replacement. Defaults to `true` —
-     * see `OpenChannelConnectionOptions.reconnect` for why re-opening the
-     * channel is the only thing that recovers a restarted language server, and
-     * why a dead connection leaves no alternative worth preserving.
-     *
-     * The subclass-facing cost is that {@link doInitialize} runs again per
-     * connection, so any progress UI it drives reappears. Turn this off for a
-     * frontend that would rather show nothing than show its warm-up twice, or
-     * that tears itself down on transport loss.
+     * Rebuild the connection when the current one is lost. Defaults to `true` —
+     * re-opening the channel is the only thing that recovers a restarted
+     * language server, which binds new ephemeral ports. Turn it off for a
+     * frontend that would rather tear itself down than show its warm-up twice.
      */
     protected readonly reconnectOnConnectionLoss: boolean;
+    protected channel?: ChannelConnectionHandle;
+    protected connection?: RpcConnection<TServer, TClient>;
+    protected readonly lossEmitter: Emitter<void>;
     /**
      * Readiness gate for the connection — the channel opens only once the
      * returned promise settles. Default: waits for a workspace when
-     * {@link workspaceService} is provided, otherwise opens immediately
-     * (`undefined`). Override for a different gate (e.g. a fixed model store
-     * that is always ready, or a custom warm-up).
+     * {@link workspaceService} is provided, otherwise opens immediately.
      */
     protected connectionReadyGate(): Promise<void> | undefined;
+    /** A connection generation is opening, including on each reconnect. */
+    protected onConnecting(): void;
+    /** The server's readiness gate has settled for a generation. */
+    protected onReady(): void;
+    /** A generation failed; the awaiting caller still rejects. */
+    protected onFailed(_error: unknown): void;
     /**
-     * Open the connection (workspace-gated by default via
-     * {@link connectionReadyGate}) and build the combined server proxy +
-     * inbound client binding. Call once (typically from the adopter's
-     * `@postConstruct`). Outbound calls + inbound notifications queue over the
-     * connection promise until the channel is live.
+     * Open the channel and build the connection over it. Call once, typically
+     * from the adopter's `@postConstruct`. Outbound calls and inbound
+     * notifications queue until the channel is live.
      */
     protected start(): void;
+    /** The channel as a {@link DataPort} — the whole Theia-specific half. */
+    protected channelPort(): DataPort;
+    /** Surface a transport failure the way this host does. */
+    protected reportError(reported: ResolvedMessage): void;
     /**
-     * Point {@link connectionPromise} and {@link server} at the channel's
-     * current connection. Called by {@link start} and again per reconnect.
+     * The server proxy. Calls queue against the connection, so await
+     * {@link ensureConnected} first wherever the server's readiness matters.
      */
-    protected bindConnection(): void;
+    protected get server(): RpcProxy<TServer>;
     /**
-     * Rebind onto the replacement connection and arm initialization to run again.
-     *
-     * Clearing {@link initialized} is the load-bearing half. A restarted server
-     * has an unwarmed workspace, so its `waitForReady` gate has to be awaited
-     * afresh; leaving the old resolved Deferred in place would let the first
-     * request after a restart through against a server still walking the
-     * workspace, and be answered correctly from an empty registry — which reads
-     * as data loss rather than as a race.
+     * Await the connection and the server's readiness gate, shared across
+     * concurrent callers and re-run once per connection generation.
      */
-    protected handleConnectionLost(): void;
+    protected ensureConnected(): Promise<void>;
     /**
      * Release the connection and stop tracking the channel. Idempotent.
      *
@@ -135,20 +90,7 @@ export declare abstract class AbstractDataServiceFrontend<TServer extends {
      * lifecycle of its own.
      */
     dispose(): void;
-    /**
-     * Lazily drive initialization, shared across concurrent callers via one
-     * {@link Deferred}. Request methods `await this.ensureConnected()` before
-     * their first `this.server.*` call.
-     */
-    protected ensureConnected(): Promise<void>;
-    /**
-     * Default initialization: await the connection, await the server's readiness
-     * gate, then resolve the passed Deferred. Initialization completion is
-     * observable by awaiting {@link ensureConnected} (which returns this same
-     * Deferred's promise) — there is no separate post-init hook. Override
-     * wholesale to interleave progress UI / extra warm-up; an override owns
-     * resolving/rejecting `initialized` (there is no `super` step to call).
-     */
-    protected doInitialize(initialized: Deferred<void>): Promise<void>;
+    protected requireConnection(): RpcConnection<TServer, TClient>;
+    protected requireChannel(): ChannelConnectionHandle;
 }
 //# sourceMappingURL=data-service-frontend.d.ts.map

package/lib/browser/data-service-frontend.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data-service-frontend.d.ts","sourceRoot":"","sources":["../../src/browser/data-service-frontend.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAGlF,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AAC/D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,KAAK,uBAAuB,EAAyB,MAAM,sBAAsB,CAAC;AAG3F;;;;;;;;;;;;;GAaG;AACH,8BAAsB,2BAA2B,CAAC,OAAO,SAAS;IAAE,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,EAAE,OAAO,SAAS,MAAM;IACxH;;;;;OAKG;IACH,SAAS,CAAC,iBAAiB,EAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACzD;;;;;;;;;;OAUG;IACH,SAAS,CAAC,MAAM,EAAG,OAAO,CAAC;IAC3B,4EAA4E;IAC5E,SAAS,CAAC,OAAO,CAAC,EAAE,uBAAuB,CAAC;IAC5C,mGAAmG;IACnG,SAAS,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;IAEvC,+DAA+D;IAC/D,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,kBAAkB,EAAE,yBAAyB,CAAC;IAC1E;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IAChE,qFAAqF;IACrF,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAC5C;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAChD,sEAAsE;IACtE,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACpD,uEAAuE;IACvE,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,aAAa,EAAE,SAAS,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC,EAAE,CAAC;IAE/E;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,QAAQ,CAAC,yBAAyB,EAAE,OAAO,CAAQ;IAE7D;;;;;;OAMG;IACH,SAAS,CAAC,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS;IAI1D;;;;;;OAMG;IACH,SAAS,CAAC,KAAK,IAAI,IAAI;IAavB;;;OAGG;IACH,SAAS,CAAC,cAAc,IAAI,IAAI;IAYhC;;;;;;;;;OASG;IACH,SAAS,CAAC,oBAAoB,IAAI,IAAI;IAKtC;;;;;;OAMG;IACH,OAAO,IAAI,IAAI;IAMf;;;;OAIG;IACH,SAAS,CAAC,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ1C;;;;;;;OAOG;cACa,YAAY,CAAC,WAAW,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAS1E"}
+{"version":3,"file":"data-service-frontend.d.ts","sourceRoot":"","sources":["../../src/browser/data-service-frontend.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EACJ,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,aAAa,EACb,KAAK,QAAQ,EAEf,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,OAAO,EAAO,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,KAAK,uBAAuB,EAAyB,MAAM,sBAAsB,CAAC;AAG3F;;;;;;;;;;;;;;;;;GAiBG;AACH,8BAAsB,2BAA2B,CAAC,OAAO,SAAS,WAAW,EAAE,OAAO,SAAS,MAAM;IAClG,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,kBAAkB,EAAE,yBAAyB,CAAC;IAC1E,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IAChE,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAC5C,qFAAqF;IACrF,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAChD,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACpD,uEAAuE;IACvE,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,aAAa,EAAE,SAAS,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC,EAAE,CAAC;IAE/E,yFAAyF;IACzF,SAAS,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;IAEnD;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,yBAAyB,EAAE,OAAO,CAAQ;IAE7D,SAAS,CAAC,OAAO,CAAC,EAAE,uBAAuB,CAAC;IAC5C,SAAS,CAAC,UAAU,CAAC,EAAE,aAAa,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACvD,SAAS,CAAC,QAAQ,CAAC,WAAW,gBAAuB;IAErD;;;;OAIG;IACH,SAAS,CAAC,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS;IAI1D,uEAAuE;IACvE,SAAS,CAAC,YAAY,IAAI,IAAI;IAI9B,gEAAgE;IAChE,SAAS,CAAC,OAAO,IAAI,IAAI;IAIzB,8DAA8D;IAC9D,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;IAIzC;;;;OAIG;IACH,SAAS,CAAC,KAAK,IAAI,IAAI;IAoBvB,yEAAyE;IACzE,SAAS,CAAC,WAAW,IAAI,QAAQ;IAWjC,0DAA0D;IAC1D,SAAS,CAAC,WAAW,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAItD;;;OAGG;IACH,SAAS,KAAK,MAAM,IAAI,QAAQ,CAAC,OAAO,CAAC,CAExC;IAED;;;OAGG;cACa,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAIhD;;;;;;OAMG;IACH,OAAO,IAAI,IAAI;IAQf,SAAS,CAAC,iBAAiB,IAAI,aAAa,CAAC,OAAO,EAAE,OAAO,CAAC;IAO9D,SAAS,CAAC,cAAc,IAAI,uBAAuB;CAMrD"}

package/lib/browser/data-service-frontend.js

@@ -10,7 +10,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractDataServiceFrontend = void 0;
 const protocol_1 = require("@hydranium/protocol");
-const promise_util_1 = require("@theia/core/lib/common/promise-util");
+const core_1 = require("@theia/core");
 const channel_connection_1 = require("./channel-connection");
 const workspace_gate_1 = require("./workspace-gate");
 /**
@@ -26,101 +26,96 @@ const workspace_gate_1 = require("./workspace-gate");
  * the local notification target `TClient`. A subclass supplies the abstract
  * members below, calls {@link start} from its `@postConstruct`, and awaits
  * {@link ensureConnected} before its first `this.server.*` call.
+ *
+ * The lifecycle is `RpcConnection`'s — the same proxy, readiness gate and
+ * reconnect generation the host-neutral tier uses. What stays here is the Theia
+ * half: the channel, the workspace gate and the notification sink.
  */
 class AbstractDataServiceFrontend {
+    /** Surfaces a transport failure. Optional: a frontend with no UI of its own omits it. */
+    messageService;
     /**
-     * The workspace-gated connection to the backend forwarder. Set by
-     * {@link start}, and REPLACED whenever the connection is lost and
-     * {@link reconnectOnConnectionLoss} is on — so read it per use and never
-     * cache the resolved connection.
-     */
-    connectionPromise;
-    /**
-     * Typed proxy over {@link connectionPromise}, addressing the server under
-     * {@link methodNamespace}. Set by {@link start}, and replaced alongside
-     * {@link connectionPromise} on reconnect.
-     *
-     * `createRpcProxy` resolves the connection promise once and binds to it for
-     * good, so a reconnect necessarily means a new proxy. Reading
-     * `this.server.foo()` per call — rather than hoisting `this.server` into a
-     * local or a constructor-time field — is what keeps a subclass correct
-     * across one.
-     */
-    server;
-    /** The channel handle {@link start} opened; owns reconnect and disposal. */
-    channel;
-    /** Shared init Deferred so concurrent {@link ensureConnected} callers await one initialization. */
-    initialized;
-    /**
-     * Rebuild the connection and the proxy when the current connection is lost,
-     * and re-run initialization against the replacement. Defaults to `true` —
-     * see `OpenChannelConnectionOptions.reconnect` for why re-opening the
-     * channel is the only thing that recovers a restarted language server, and
-     * why a dead connection leaves no alternative worth preserving.
-     *
-     * The subclass-facing cost is that {@link doInitialize} runs again per
-     * connection, so any progress UI it drives reappears. Turn this off for a
-     * frontend that would rather show nothing than show its warm-up twice, or
-     * that tears itself down on transport loss.
+     * Rebuild the connection when the current one is lost. Defaults to `true` —
+     * re-opening the channel is the only thing that recovers a restarted
+     * language server, which binds new ephemeral ports. Turn it off for a
+     * frontend that would rather tear itself down than show its warm-up twice.
      */
     reconnectOnConnectionLoss = true;
+    channel;
+    connection;
+    lossEmitter = new core_1.Emitter();
     /**
      * Readiness gate for the connection — the channel opens only once the
      * returned promise settles. Default: waits for a workspace when
-     * {@link workspaceService} is provided, otherwise opens immediately
-     * (`undefined`). Override for a different gate (e.g. a fixed model store
-     * that is always ready, or a custom warm-up).
+     * {@link workspaceService} is provided, otherwise opens immediately.
      */
     connectionReadyGate() {
         return this.workspaceService ? (0, workspace_gate_1.whenWorkspaceOpen)(this.workspaceService) : undefined;
     }
+    /** A connection generation is opening, including on each reconnect. */
+    onConnecting() {
+        // nothing by default
+    }
+    /** The server's readiness gate has settled for a generation. */
+    onReady() {
+        // nothing by default
+    }
+    /** A generation failed; the awaiting caller still rejects. */
+    onFailed(_error) {
+        // nothing by default
+    }
     /**
-     * Open the connection (workspace-gated by default via
-     * {@link connectionReadyGate}) and build the combined server proxy +
-     * inbound client binding. Call once (typically from the adopter's
-     * `@postConstruct`). Outbound calls + inbound notifications queue over the
-     * connection promise until the channel is live.
+     * Open the channel and build the connection over it. Call once, typically
+     * from the adopter's `@postConstruct`. Outbound calls and inbound
+     * notifications queue until the channel is live.
      */
     start() {
         this.channel = (0, channel_connection_1.openChannelConnection)(this.connectionProvider, this.servicePath, {
             whenReady: this.connectionReadyGate(),
             reconnect: this.reconnectOnConnectionLoss
         });
-        this.bindConnection();
-        // The LOSS, not the replacement's arrival: rebinding when the channel
-        // closes points `server` at the queueing replacement promise, so a request
-        // made during the gap waits for the new server instead of being addressed
-        // at the dead one and never settling.
-        this.channel.onDidLoseConnection(() => this.handleConnectionLost());
+        // The LOSS, not the replacement's arrival: the connection drops its
+        // generation here, so a request made during the gap waits for the fresh
+        // one instead of addressing the dead one and never settling.
+        this.channel.onDidLoseConnection(() => this.lossEmitter.fire(undefined));
+        this.connection = new protocol_1.RpcConnection(this.channelPort(), this.client, {
+            methodNamespace: this.methodNamespace,
+            clientMethods: this.clientMethods,
+            lifecycle: {
+                onConnecting: () => this.onConnecting(),
+                onReady: () => this.onReady(),
+                onFailed: error => this.onFailed(error)
+            }
+        });
+    }
+    /** The channel as a {@link DataPort} — the whole Theia-specific half. */
+    channelPort() {
+        return {
+            // Read per call: `current` is repointed on every re-open, so reaching
+            // through the handle is what makes a later generation find the live
+            // server.
+            connect: () => this.requireChannel().current,
+            reportError: (_error, reported) => this.reportError(reported),
+            onDispose: this.lossEmitter.event
+        };
+    }
+    /** Surface a transport failure the way this host does. */
+    reportError(reported) {
+        this.messageService?.error((0, protocol_1.renderFrameworkMessage)(reported, core_1.nls.localization?.translations));
     }
     /**
-     * Point {@link connectionPromise} and {@link server} at the channel's
-     * current connection. Called by {@link start} and again per reconnect.
+     * The server proxy. Calls queue against the connection, so await
+     * {@link ensureConnected} first wherever the server's readiness matters.
      */
-    bindConnection() {
-        if (!this.channel) {
-            throw new Error('bindConnection called before start');
-        }
-        this.connectionPromise = this.channel.current;
-        this.server = (0, protocol_1.createRpcProxy)(this.connectionPromise, {
-            methodNamespace: this.methodNamespace,
-            localTarget: this.client,
-            localMethods: this.clientMethods
-        });
+    get server() {
+        return this.requireConnection().server;
     }
     /**
-     * Rebind onto the replacement connection and arm initialization to run again.
-     *
-     * Clearing {@link initialized} is the load-bearing half. A restarted server
-     * has an unwarmed workspace, so its `waitForReady` gate has to be awaited
-     * afresh; leaving the old resolved Deferred in place would let the first
-     * request after a restart through against a server still walking the
-     * workspace, and be answered correctly from an empty registry — which reads
-     * as data loss rather than as a race.
+     * Await the connection and the server's readiness gate, shared across
+     * concurrent callers and re-run once per connection generation.
      */
-    handleConnectionLost() {
-        this.initialized = undefined;
-        this.bindConnection();
+    async ensureConnected() {
+        await this.requireConnection().connected();
     }
     /**
      * Release the connection and stop tracking the channel. Idempotent.
@@ -130,39 +125,23 @@ class AbstractDataServiceFrontend {
      * lifecycle of its own.
      */
     dispose() {
+        this.connection?.dispose();
+        this.connection = undefined;
         this.channel?.dispose();
         this.channel = undefined;
-        this.initialized = undefined;
+        this.lossEmitter.dispose();
     }
-    /**
-     * Lazily drive initialization, shared across concurrent callers via one
-     * {@link Deferred}. Request methods `await this.ensureConnected()` before
-     * their first `this.server.*` call.
-     */
-    ensureConnected() {
-        if (!this.initialized) {
-            this.initialized = new promise_util_1.Deferred();
-            void this.doInitialize(this.initialized);
+    requireConnection() {
+        if (!this.connection) {
+            throw new Error('the connection is not open: call start() first');
         }
-        return this.initialized.promise;
+        return this.connection;
     }
-    /**
-     * Default initialization: await the connection, await the server's readiness
-     * gate, then resolve the passed Deferred. Initialization completion is
-     * observable by awaiting {@link ensureConnected} (which returns this same
-     * Deferred's promise) — there is no separate post-init hook. Override
-     * wholesale to interleave progress UI / extra warm-up; an override owns
-     * resolving/rejecting `initialized` (there is no `super` step to call).
-     */
-    async doInitialize(initialized) {
-        try {
-            await this.connectionPromise;
-            await this.server.waitForReady();
-            initialized.resolve();
-        }
-        catch (error) {
-            initialized.reject(error instanceof Error ? error : new Error(String(error)));
+    requireChannel() {
+        if (!this.channel) {
+            throw new Error('the channel is not open: call start() first');
         }
+        return this.channel;
     }
 }
 exports.AbstractDataServiceFrontend = AbstractDataServiceFrontend;

package/lib/browser/data-service-frontend.js.map

@@ -1 +1 @@
-{"version":3,"file":"data-service-frontend.js","sourceRoot":"","sources":["../../src/browser/data-service-frontend.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"data-service-frontend.js","sourceRoot":"","sources":["../../src/browser/data-service-frontend.ts"],"names":[],"mappings":"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"}

package/lib/browser/index.d.ts

@@ -7,6 +7,7 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 export * from './channel-connection';
+export * from './channel-data-port';
 export * from './data-service-frontend';
 export * from './diagnostics-data-service-frontend';
 export * from './host-diagnostics-frontend';

package/lib/browser/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/browser/index.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qCAAqC,CAAC;AACpD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/browser/index.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qCAAqC,CAAC;AACpD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,kBAAkB,CAAC"}

package/lib/browser/index.js

@@ -23,6 +23,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./channel-connection"), exports);
+__exportStar(require("./channel-data-port"), exports);
 __exportStar(require("./data-service-frontend"), exports);
 __exportStar(require("./diagnostics-data-service-frontend"), exports);
 __exportStar(require("./host-diagnostics-frontend"), exports);

package/lib/browser/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/browser/index.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;;;;;;;;;;;;;;AAElF,uDAAqC;AACrC,0DAAwC;AACxC,sEAAoD;AACpD,8DAA4C;AAC5C,qEAAmD;AACnD,mDAAiC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/browser/index.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;;;;;;;;;;;;;;AAElF,uDAAqC;AACrC,sDAAoC;AACpC,0DAAwC;AACxC,sEAAoD;AACpD,8DAA4C;AAC5C,qEAAmD;AACnD,mDAAiC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hydranium/data-client-theia",
-  "version": "1.0.0-next.60",
+  "version": "1.0.0-next.62",
   "description": "Theia-coupled client primitives for the hydranium data-server protocol head; companion of @hydranium/data-server. Bridges framework typed errors (e.g. ConflictError) across Theia's RPC boundary so their code + data survive the wire.",
   "keywords": [
     "hydranium",
@@ -70,9 +70,9 @@
     "watch": "tsc -b -w --preserveWatchOutput"
   },
   "devDependencies": {
-    "@hydranium/client-theia": "1.0.0-next.60",
-    "@hydranium/core": "1.0.0-next.60",
-    "@hydranium/protocol": "1.0.0-next.60",
+    "@hydranium/client-theia": "1.0.0-next.62",
+    "@hydranium/core": "1.0.0-next.62",
+    "@hydranium/protocol": "1.0.0-next.62",
     "@theia/core": "^1.70.0",
     "@theia/workspace": "^1.70.0",
     "@types/node": "^22.0.0",
@@ -83,9 +83,9 @@
     "vscode-jsonrpc": "9.0.1"
   },
   "peerDependencies": {
-    "@hydranium/client-theia": "1.0.0-next.60",
-    "@hydranium/core": "1.0.0-next.60",
-    "@hydranium/protocol": "1.0.0-next.60",
+    "@hydranium/client-theia": "1.0.0-next.62",
+    "@hydranium/core": "1.0.0-next.62",
+    "@hydranium/protocol": "1.0.0-next.62",
     "@theia/core": "^1.70.0",
     "@theia/workspace": "^1.70.0",
     "inversify": "^6.0.0",

package/src/browser/channel-data-port.ts

@@ -0,0 +1,100 @@
+/********************************************************************************
+ * 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 { renderFrameworkMessage, type DataPort, type ResolvedMessage } from '@hydranium/protocol';
+import { Emitter, MessageService, nls, type Event } from '@theia/core';
+import { type ServiceConnectionProvider } from '@theia/core/lib/browser';
+import { RemoteConnectionProvider } from '@theia/core/lib/browser/messaging/service-connection-provider';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { WorkspaceService } from '@theia/workspace/lib/browser';
+import type { MessageConnection } from 'vscode-jsonrpc';
+import { type ChannelConnectionHandle, openChannelConnection } from './channel-connection';
+import { whenWorkspaceOpen } from './workspace-gate';
+
+/**
+ * A {@link DataPort} over a Theia frontend channel.
+ *
+ * Subclasses supply {@link servicePath}; everything above the port —
+ * `DataConnection`, its sessions, and whatever model a widget drives — is
+ * host-neutral and shared with the VS Code and browser shells.
+ *
+ * Bind one per service path and in singleton scope. Theia keys a frontend
+ * channel by its path and refuses a second on a path already open, and the
+ * throw escapes the `openChannelConnection` the loser is awaiting, leaving that
+ * promise unsettled rather than rejected.
+ */
+@injectable()
+export abstract class ChannelDataPort implements DataPort {
+   @inject(RemoteConnectionProvider) protected readonly connectionProvider!: ServiceConnectionProvider;
+   @inject(WorkspaceService) protected readonly workspaceService!: WorkspaceService;
+   @inject(MessageService) protected readonly messageService!: MessageService;
+
+   /** Frontend service path the backend forwarder for this head is registered under. */
+   protected abstract readonly servicePath: string;
+
+   /**
+    * Re-open the channel when the current connection is lost. Default `true` —
+    * re-opening is the only thing that recovers a restarted language server,
+    * which binds new ephemeral ports. Turn it off for a frontend that tears
+    * itself down on transport loss instead.
+    */
+   protected readonly reconnectOnConnectionLoss: boolean = true;
+
+   protected readonly disposeEmitter = new Emitter<void>();
+   readonly onDispose: Event<void> = this.disposeEmitter.event;
+
+   protected handle?: ChannelConnectionHandle;
+
+   /**
+    * Open the workspace-gated channel and hand back its listening connection.
+    *
+    * Gated because the backend forwarder discovers the head's port by executing
+    * a command the language server answers, and the language server only
+    * launches once there is a workspace to launch it for. Asking earlier polls
+    * a command nobody has registered.
+    */
+   connect(): Promise<MessageConnection> {
+      // Read per call rather than cached: `current` is repointed at a fresh
+      // promise every time the channel is re-opened, so reading through the
+      // handle is what makes a later generation reach the live server.
+      if (!this.handle) {
+         this.handle = openChannelConnection(this.connectionProvider, this.servicePath, {
+            whenReady: whenWorkspaceOpen(this.workspaceService),
+            reconnect: this.reconnectOnConnectionLoss
+         });
+         // A relaunched server binds new ephemeral ports; the handle re-opens
+         // and the forwarder rediscovers, but `DataConnection` caches its
+         // generation and would go on addressing the dead one. Its signal to
+         // drop that generation is this event.
+         this.handle.onDidLoseConnection(() => this.disposeEmitter.fire(undefined));
+      }
+      return this.handle.current;
+   }
+
+   /**
+    * Surface a transport or write failure as a Theia notification.
+    *
+    * Swallowing it is the failure this exists to prevent: a dead connection and
+    * an empty document are indistinguishable in a widget.
+    *
+    * `reported` is already a complete sentence with the detail interpolated, so
+    * wrapping it in a sentence of the host's own would nest one owner's clause
+    * inside another's and leave no translator in control of the whole.
+    */
+   reportError(_error: unknown, reported: ResolvedMessage): void {
+      this.messageService.error(renderFrameworkMessage(reported, nls.localization?.translations));
+   }
+
+   dispose(): void {
+      this.handle?.dispose();
+      this.handle = undefined;
+      this.disposeEmitter.fire(undefined);
+      this.disposeEmitter.dispose();
+   }
+}

package/src/browser/data-service-frontend.ts

@@ -7,11 +7,17 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { createRpcProxy } from '@hydranium/protocol';
+import {
+   type DataPort,
+   type ReadyServer,
+   type ResolvedMessage,
+   RpcConnection,
+   type RpcProxy,
+   renderFrameworkMessage
+} from '@hydranium/protocol';
+import { Emitter, nls, type MessageService } from '@theia/core';
 import type { ServiceConnectionProvider } from '@theia/core/lib/browser';
-import { Deferred } from '@theia/core/lib/common/promise-util';
 import type { WorkspaceService } from '@theia/workspace/lib/browser';
-import type { MessageConnection } from 'vscode-jsonrpc';
 import { type ChannelConnectionHandle, openChannelConnection } from './channel-connection';
 import { whenWorkspaceOpen } from './workspace-gate';
 
@@ -28,138 +34,116 @@ import { whenWorkspaceOpen } from './workspace-gate';
  * the local notification target `TClient`. A subclass supplies the abstract
  * members below, calls {@link start} from its `@postConstruct`, and awaits
  * {@link ensureConnected} before its first `this.server.*` call.
+ *
+ * The lifecycle is `RpcConnection`'s — the same proxy, readiness gate and
+ * reconnect generation the host-neutral tier uses. What stays here is the Theia
+ * half: the channel, the workspace gate and the notification sink.
  */
-export abstract class AbstractDataServiceFrontend<TServer extends { waitForReady(): Promise<void> }, TClient extends object> {
-   /**
-    * The workspace-gated connection to the backend forwarder. Set by
-    * {@link start}, and REPLACED whenever the connection is lost and
-    * {@link reconnectOnConnectionLoss} is on — so read it per use and never
-    * cache the resolved connection.
-    */
-   protected connectionPromise!: Promise<MessageConnection>;
-   /**
-    * Typed proxy over {@link connectionPromise}, addressing the server under
-    * {@link methodNamespace}. Set by {@link start}, and replaced alongside
-    * {@link connectionPromise} on reconnect.
-    *
-    * `createRpcProxy` resolves the connection promise once and binds to it for
-    * good, so a reconnect necessarily means a new proxy. Reading
-    * `this.server.foo()` per call — rather than hoisting `this.server` into a
-    * local or a constructor-time field — is what keeps a subclass correct
-    * across one.
-    */
-   protected server!: TServer;
-   /** The channel handle {@link start} opened; owns reconnect and disposal. */
-   protected channel?: ChannelConnectionHandle;
-   /** Shared init Deferred so concurrent {@link ensureConnected} callers await one initialization. */
-   protected initialized?: Deferred<void>;
-
-   /** Theia connection provider the channel is opened through. */
+export abstract class AbstractDataServiceFrontend<TServer extends ReadyServer, TClient extends object> {
    protected abstract readonly connectionProvider: ServiceConnectionProvider;
-   /**
-    * Optional workspace service. When provided, the default
-    * {@link connectionReadyGate} waits for a workspace before opening the
-    * channel; a head that is not workspace-scoped omits it (and may override
-    * {@link connectionReadyGate} for a different gate).
-    */
    protected abstract readonly workspaceService?: WorkspaceService;
-   /** Local inbound-notification target bound on the connection (the `localTarget`). */
    protected abstract readonly client: TClient;
-   /**
-    * Theia service path the backend forwarder is registered under.
-    *
-    * **Unique per frontend, not per server.** Theia keys a frontend channel by
-    * this path and throws `Another channel with the id '<path>' is already open`
-    * on a second opener — so a subclass sharing the framework default with any
-    * other consumer of the same head (a host-neutral `DataPort`, a sibling
-    * service frontend) breaks whichever opens second. The failure is remote from
-    * its cause: the throw escapes an `openChannelConnection` the other consumer
-    * awaited, leaving its request permanently unsettled rather than rejected,
-    * which presents as a view stuck on its loading state with a clean server
-    * log. Give each frontend its own path and register a forwarder per path;
-    * they still reach one server, since the shared `portCommand` is what names
-    * the process.
-    */
+   /** Frontend service path the backend forwarder for this head is registered under. */
    protected abstract readonly servicePath: string;
-   /** Wire namespace the server + client methods are addressed under. */
    protected abstract readonly methodNamespace: string;
    /** Allowlist of {@link client} methods to bind as inbound handlers. */
    protected abstract readonly clientMethods: readonly (keyof TClient & string)[];
 
+   /** Surfaces a transport failure. Optional: a frontend with no UI of its own omits it. */
+   protected readonly messageService?: MessageService;
+
    /**
-    * Rebuild the connection and the proxy when the current connection is lost,
-    * and re-run initialization against the replacement. Defaults to `true` —
-    * see `OpenChannelConnectionOptions.reconnect` for why re-opening the
-    * channel is the only thing that recovers a restarted language server, and
-    * why a dead connection leaves no alternative worth preserving.
-    *
-    * The subclass-facing cost is that {@link doInitialize} runs again per
-    * connection, so any progress UI it drives reappears. Turn this off for a
-    * frontend that would rather show nothing than show its warm-up twice, or
-    * that tears itself down on transport loss.
+    * Rebuild the connection when the current one is lost. Defaults to `true` —
+    * re-opening the channel is the only thing that recovers a restarted
+    * language server, which binds new ephemeral ports. Turn it off for a
+    * frontend that would rather tear itself down than show its warm-up twice.
     */
    protected readonly reconnectOnConnectionLoss: boolean = true;
 
+   protected channel?: ChannelConnectionHandle;
+   protected connection?: RpcConnection<TServer, TClient>;
+   protected readonly lossEmitter = new Emitter<void>();
+
    /**
     * Readiness gate for the connection — the channel opens only once the
     * returned promise settles. Default: waits for a workspace when
-    * {@link workspaceService} is provided, otherwise opens immediately
-    * (`undefined`). Override for a different gate (e.g. a fixed model store
-    * that is always ready, or a custom warm-up).
+    * {@link workspaceService} is provided, otherwise opens immediately.
     */
    protected connectionReadyGate(): Promise<void> | undefined {
       return this.workspaceService ? whenWorkspaceOpen(this.workspaceService) : undefined;
    }
 
+   /** A connection generation is opening, including on each reconnect. */
+   protected onConnecting(): void {
+      // nothing by default
+   }
+
+   /** The server's readiness gate has settled for a generation. */
+   protected onReady(): void {
+      // nothing by default
+   }
+
+   /** A generation failed; the awaiting caller still rejects. */
+   protected onFailed(_error: unknown): void {
+      // nothing by default
+   }
+
    /**
-    * Open the connection (workspace-gated by default via
-    * {@link connectionReadyGate}) and build the combined server proxy +
-    * inbound client binding. Call once (typically from the adopter's
-    * `@postConstruct`). Outbound calls + inbound notifications queue over the
-    * connection promise until the channel is live.
+    * Open the channel and build the connection over it. Call once, typically
+    * from the adopter's `@postConstruct`. Outbound calls and inbound
+    * notifications queue until the channel is live.
     */
    protected start(): void {
       this.channel = openChannelConnection(this.connectionProvider, this.servicePath, {
          whenReady: this.connectionReadyGate(),
          reconnect: this.reconnectOnConnectionLoss
       });
-      this.bindConnection();
-      // The LOSS, not the replacement's arrival: rebinding when the channel
-      // closes points `server` at the queueing replacement promise, so a request
-      // made during the gap waits for the new server instead of being addressed
-      // at the dead one and never settling.
-      this.channel.onDidLoseConnection(() => this.handleConnectionLost());
+      // The LOSS, not the replacement's arrival: the connection drops its
+      // generation here, so a request made during the gap waits for the fresh
+      // one instead of addressing the dead one and never settling.
+      this.channel.onDidLoseConnection(() => this.lossEmitter.fire(undefined));
+      this.connection = new RpcConnection<TServer, TClient>(this.channelPort(), this.client, {
+         methodNamespace: this.methodNamespace,
+         clientMethods: this.clientMethods,
+         lifecycle: {
+            onConnecting: () => this.onConnecting(),
+            onReady: () => this.onReady(),
+            onFailed: error => this.onFailed(error)
+         }
+      });
+   }
+
+   /** The channel as a {@link DataPort} — the whole Theia-specific half. */
+   protected channelPort(): DataPort {
+      return {
+         // Read per call: `current` is repointed on every re-open, so reaching
+         // through the handle is what makes a later generation find the live
+         // server.
+         connect: () => this.requireChannel().current,
+         reportError: (_error, reported) => this.reportError(reported),
+         onDispose: this.lossEmitter.event
+      };
+   }
+
+   /** Surface a transport failure the way this host does. */
+   protected reportError(reported: ResolvedMessage): void {
+      this.messageService?.error(renderFrameworkMessage(reported, nls.localization?.translations));
    }
 
    /**
-    * Point {@link connectionPromise} and {@link server} at the channel's
-    * current connection. Called by {@link start} and again per reconnect.
+    * The server proxy. Calls queue against the connection, so await
+    * {@link ensureConnected} first wherever the server's readiness matters.
     */
-   protected bindConnection(): void {
-      if (!this.channel) {
-         throw new Error('bindConnection called before start');
-      }
-      this.connectionPromise = this.channel.current;
-      this.server = createRpcProxy<TServer, TClient>(this.connectionPromise, {
-         methodNamespace: this.methodNamespace,
-         localTarget: this.client,
-         localMethods: this.clientMethods
-      });
+   protected get server(): RpcProxy<TServer> {
+      return this.requireConnection().server;
    }
 
    /**
-    * Rebind onto the replacement connection and arm initialization to run again.
-    *
-    * Clearing {@link initialized} is the load-bearing half. A restarted server
-    * has an unwarmed workspace, so its `waitForReady` gate has to be awaited
-    * afresh; leaving the old resolved Deferred in place would let the first
-    * request after a restart through against a server still walking the
-    * workspace, and be answered correctly from an empty registry — which reads
-    * as data loss rather than as a race.
+    * Await the connection and the server's readiness gate, shared across
+    * concurrent callers and re-run once per connection generation.
     */
-   protected handleConnectionLost(): void {
-      this.initialized = undefined;
-      this.bindConnection();
+   protected async ensureConnected(): Promise<void> {
+      await this.requireConnection().connected();
    }
 
    /**
@@ -170,39 +154,24 @@ export abstract class AbstractDataServiceFrontend<TServer extends { waitForReady
     * lifecycle of its own.
     */
    dispose(): void {
+      this.connection?.dispose();
+      this.connection = undefined;
       this.channel?.dispose();
       this.channel = undefined;
-      this.initialized = undefined;
+      this.lossEmitter.dispose();
    }
 
-   /**
-    * Lazily drive initialization, shared across concurrent callers via one
-    * {@link Deferred}. Request methods `await this.ensureConnected()` before
-    * their first `this.server.*` call.
-    */
-   protected ensureConnected(): Promise<void> {
-      if (!this.initialized) {
-         this.initialized = new Deferred<void>();
-         void this.doInitialize(this.initialized);
+   protected requireConnection(): RpcConnection<TServer, TClient> {
+      if (!this.connection) {
+         throw new Error('the connection is not open: call start() first');
       }
-      return this.initialized.promise;
+      return this.connection;
    }
 
-   /**
-    * Default initialization: await the connection, await the server's readiness
-    * gate, then resolve the passed Deferred. Initialization completion is
-    * observable by awaiting {@link ensureConnected} (which returns this same
-    * Deferred's promise) — there is no separate post-init hook. Override
-    * wholesale to interleave progress UI / extra warm-up; an override owns
-    * resolving/rejecting `initialized` (there is no `super` step to call).
-    */
-   protected async doInitialize(initialized: Deferred<void>): Promise<void> {
-      try {
-         await this.connectionPromise;
-         await this.server.waitForReady();
-         initialized.resolve();
-      } catch (error) {
-         initialized.reject(error instanceof Error ? error : new Error(String(error)));
+   protected requireChannel(): ChannelConnectionHandle {
+      if (!this.channel) {
+         throw new Error('the channel is not open: call start() first');
       }
+      return this.channel;
    }
 }

package/src/browser/index.ts

@@ -8,6 +8,7 @@
  ********************************************************************************/
 
 export * from './channel-connection';
+export * from './channel-data-port';
 export * from './data-service-frontend';
 export * from './diagnostics-data-service-frontend';
 export * from './host-diagnostics-frontend';