@hydranium/data-client-theia 1.0.0-next.8 → 1.0.0-next.85

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/index.ts

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

package/src/common/emitter-data-client.ts

@@ -12,7 +12,9 @@ import type {
    Project,
    ProjectsChangedEvent,
    TransferDiagnostic,
+   TransferDocumentDeletedEvent,
    TransferDocumentSavedEvent,
+   TransferDocumentsBuiltEvent,
    TransferDocumentUpdatedEvent,
    TransferElement
 } from '@hydranium/protocol';
@@ -46,6 +48,14 @@ export class EmitterDataClient<
    /** Fires for each inbound {@link onDocumentSaved} notification. */
    readonly onDidSaveDocument: Event<TransferDocumentSavedEvent<TTransfer, TDiagnostic>> = this.onDocumentSavedEmitter.event;
 
+   protected readonly onDocumentDeletedEmitter = new Emitter<TransferDocumentDeletedEvent>();
+   /** Fires for each inbound {@link onDocumentDeleted} notification. */
+   readonly onDidDeleteDocument: Event<TransferDocumentDeletedEvent> = this.onDocumentDeletedEmitter.event;
+
+   protected readonly onDocumentsBuiltEmitter = new Emitter<TransferDocumentsBuiltEvent>();
+   /** Fires for each inbound {@link onDocumentsBuilt} notification. */
+   readonly onDidBuildDocuments: Event<TransferDocumentsBuiltEvent> = this.onDocumentsBuiltEmitter.event;
+
    protected readonly onProjectsChangedEmitter = new Emitter<ProjectsChangedEvent<TProject>>();
    /** Fires for each inbound {@link onProjectsChanged} notification. */
    readonly onDidChangeProjects: Event<ProjectsChangedEvent<TProject>> = this.onProjectsChangedEmitter.event;
@@ -58,6 +68,14 @@ export class EmitterDataClient<
       this.onDocumentSavedEmitter.fire(event);
    }
 
+   onDocumentDeleted(event: TransferDocumentDeletedEvent): void {
+      this.onDocumentDeletedEmitter.fire(event);
+   }
+
+   onDocumentsBuilt(event: TransferDocumentsBuiltEvent): void {
+      this.onDocumentsBuiltEmitter.fire(event);
+   }
+
    onProjectsChanged(event: ProjectsChangedEvent<TProject>): void {
       this.onProjectsChangedEmitter.fire(event);
    }

package/src/node/connection-container-module.ts

@@ -27,11 +27,12 @@ import { ContainerModule, type interfaces } from '@theia/core/shared/inversify';
  *
  * **More than one handler is the normal case, not an exotic one.** Theia keys a
  * frontend channel by its service path and refuses a second channel on a path
- * already open, so every frontend abstraction reaching the data head needs its
- * own path and therefore its own handler — a host-neutral `DataPort` beside a
- * Theia `AbstractDataServiceFrontend` is exactly that shape. They still forward
+ * already open, so every frontend abstraction reaching the data head on its own
+ * channel needs its own path and therefore its own handler. They still forward
  * to the SAME data server: the path distinguishes the channel, the shared
- * `portCommand` names the one process behind it.
+ * `portCommand` names the one process behind it. Several participants over ONE
+ * channel need no second handler — that is what `DataConnection`'s sessions are
+ * for, and it is the cheaper arrangement.
  */
 export function createDataServerConnectionContainerModule(...handlerClasses: interfaces.Newable<ConnectionHandler>[]): ContainerModule {
    const frontendScopedConnectionModule = ConnectionContainerModule.create(({ bind }) => {

package/src/node/data-server-connection-handler.ts

@@ -30,6 +30,16 @@ export interface DataServerConnectionHandlerOptions {
     *  Defaults to the framework `DATA_SERVER_PORT_COMMAND`; override to match
     *  an adopter's established id. */
    readonly portCommand?: string;
+   /**
+    * Product name for the connect-failure dialog this handler raises.
+    *
+    * It reaches the adopter's UI verbatim, so the framework default leaks a
+    * framework noun into a product that is not ours. Not a translation concern —
+    * routing it through a catalogue would ask an adopter to "translate" English
+    * into their own product name, and would make their branding
+    * locale-dependent.
+    */
+   readonly serverName?: string;
    readonly findPortTimeout?: number;
    readonly findPortAttempts?: number;
    readonly connectTimeoutMs?: number;
@@ -62,7 +72,7 @@ export class DataServerConnectionHandler extends AbstractSocketForwardingConnect
          path: options.servicePath ?? DATA_SERVER_PATH,
          portCommand: options.portCommand ?? DATA_SERVER_PORT_COMMAND,
          logComponent: 'DataServer',
-         serverName: 'Model Server',
+         serverName: options.serverName ?? 'Model Server',
          findPortTimeout: options.findPortTimeout,
          findPortAttempts: options.findPortAttempts,
          connectTimeoutMs: options.connectTimeoutMs,

package/src/node/socket-channel-forwarder.ts

@@ -34,8 +34,13 @@ export class SocketChannelForwarder implements Disposable {
       const reader = new SocketMessageReader(socket);
       const writer = new SocketMessageWriter(socket);
       const connection = createMessageConnection(reader, writer);
+      // Nothing here destroys the socket, and adding it back would be dead
+      // code in both directions. `SocketMessageWriter.dispose()` destroys it
+      // itself, which covers the dispose path; and `connection.onClose` fires
+      // only from the reader's or writer's own close, which for a socket means
+      // the socket has already gone — so a destroy handler there is downstream
+      // of the effect it would be trying to cause.
       this.toDispose.pushAll([
-         connection.onClose(() => socket.destroy()),
          reader.listen(message => this.writeToChannel(message)),
          channel.onMessage(provider => void writer.write(this.decodeChannelMessage(provider))),
          channel.onClose(() => connection.dispose()),

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

@@ -1,154 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the MIT License which is available in the project root.
- *
- * SPDX-License-Identifier: MIT
- ********************************************************************************/
-import type { 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
- * connection directly (the data head's "frontend speaks the model-server's
- * protocol over a relayed channel" pattern). Lifts the mechanical wiring —
- * the workspace-gated connection, the combined server proxy + inbound client
- * binding, and the lazy idempotent init gate — leaving the adopter to supply
- * the connection seams and any progress UI / domain caching / request-method
- * delegation on top.
- *
- * Generic over the server protocol `TServer` (must expose `waitForReady`) and
- * 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.
- */
-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. */
-    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.
-     */
-    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)[];
-    /**
-     * 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.
-     */
-    protected readonly reconnectOnConnectionLoss: boolean;
-    /**
-     * 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).
-     */
-    protected connectionReadyGate(): Promise<void> | undefined;
-    /**
-     * 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.
-     */
-    protected start(): void;
-    /**
-     * Point {@link connectionPromise} and {@link server} at the channel's
-     * current connection. Called by {@link start} and again per reconnect.
-     */
-    protected bindConnection(): void;
-    /**
-     * 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.
-     */
-    protected handleConnectionLost(): void;
-    /**
-     * Release the connection and stop tracking the channel. Idempotent.
-     *
-     * Subclasses that are Theia `Disposable`s should route their own disposal
-     * here; nothing calls it automatically, because the base is not bound to a
-     * 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>;
-}
-//# sourceMappingURL=data-service-frontend.d.ts.map

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

@@ -1 +0,0 @@
-{"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"}

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

@@ -1,169 +0,0 @@
-"use strict";
-/********************************************************************************
- * 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
- ********************************************************************************/
-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 channel_connection_1 = require("./channel-connection");
-const workspace_gate_1 = require("./workspace-gate");
-/**
- * Base for a Theia frontend that owns the data-server vscode-jsonrpc
- * connection directly (the data head's "frontend speaks the model-server's
- * protocol over a relayed channel" pattern). Lifts the mechanical wiring —
- * the workspace-gated connection, the combined server proxy + inbound client
- * binding, and the lazy idempotent init gate — leaving the adopter to supply
- * the connection seams and any progress UI / domain caching / request-method
- * delegation on top.
- *
- * Generic over the server protocol `TServer` (must expose `waitForReady`) and
- * 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.
- */
-class AbstractDataServiceFrontend {
-    /**
-     * 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.
-     */
-    reconnectOnConnectionLoss = true;
-    /**
-     * 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).
-     */
-    connectionReadyGate() {
-        return this.workspaceService ? (0, workspace_gate_1.whenWorkspaceOpen)(this.workspaceService) : undefined;
-    }
-    /**
-     * 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.
-     */
-    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());
-    }
-    /**
-     * Point {@link connectionPromise} and {@link server} at the channel's
-     * current connection. Called by {@link start} and again per reconnect.
-     */
-    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
-        });
-    }
-    /**
-     * 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.
-     */
-    handleConnectionLost() {
-        this.initialized = undefined;
-        this.bindConnection();
-    }
-    /**
-     * Release the connection and stop tracking the channel. Idempotent.
-     *
-     * Subclasses that are Theia `Disposable`s should route their own disposal
-     * here; nothing calls it automatically, because the base is not bound to a
-     * lifecycle of its own.
-     */
-    dispose() {
-        this.channel?.dispose();
-        this.channel = undefined;
-        this.initialized = undefined;
-    }
-    /**
-     * 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);
-        }
-        return this.initialized.promise;
-    }
-    /**
-     * 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)));
-        }
-    }
-}
-exports.AbstractDataServiceFrontend = AbstractDataServiceFrontend;
-//# sourceMappingURL=data-service-frontend.js.map

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

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

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

@@ -1,35 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the MIT License which is available in the project root.
- *
- * SPDX-License-Identifier: MIT
- ********************************************************************************/
-import type { DataServerDiagnosticsProtocol, DumpServerStateArgs, LatencyReport, StartProfilingArgs, StopProfilingArgs, WriteServerHeapSnapshotArgs } from '@hydranium/protocol';
-import { AbstractDataServiceFrontend } from './data-service-frontend';
-/**
- * {@link AbstractDataServiceFrontend} specialised for a server that also exposes
- * the framework {@link DataServerDiagnosticsProtocol} (which the framework
- * `DataServer` implements by default). It implements each diagnostics method as
- * a readiness-gated pass-through — `await this.ensureConnected()`, then delegate
- * to `this.server` — so every adopter frontend gets the memory / state /
- * profiling / latency surface without hand-writing identical one-liner bodies.
- *
- * Extend this instead of {@link AbstractDataServiceFrontend} whenever the head's
- * `DataServer` keeps the default diagnostics registration; the `TServer` bound
- * carries `DataServerDiagnosticsProtocol`, so the delegates are type-checked
- * (no casts). A head that dropped the diagnostics methods via
- * `DataServerOptions.excludedMethods` should extend the plain base instead.
- */
-export declare abstract class AbstractDiagnosticsDataServiceFrontend<TServer extends {
-    waitForReady(): Promise<void>;
-} & DataServerDiagnosticsProtocol, TClient extends object> extends AbstractDataServiceFrontend<TServer, TClient> implements DataServerDiagnosticsProtocol {
-    dumpServerState(args: DumpServerStateArgs): Promise<string>;
-    writeHeapSnapshot(args: WriteServerHeapSnapshotArgs): Promise<string>;
-    dumpPodMemory(): Promise<string>;
-    startProfiling(args: StartProfilingArgs): Promise<void>;
-    stopProfiling(args: StopProfilingArgs): Promise<string>;
-    getLatency(): Promise<LatencyReport>;
-}
-//# sourceMappingURL=diagnostics-data-service-frontend.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"diagnostics-data-service-frontend.d.ts","sourceRoot":"","sources":["../../src/browser/diagnostics-data-service-frontend.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,KAAK,EACT,6BAA6B,EAC7B,mBAAmB,EACnB,aAAa,EACb,kBAAkB,EAClB,iBAAiB,EACjB,2BAA2B,EAC7B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAEtE;;;;;;;;;;;;;GAaG;AACH,8BAAsB,sCAAsC,CACzD,OAAO,SAAS;IAAE,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,GAAG,6BAA6B,EACjF,OAAO,SAAS,MAAM,CAEtB,SAAQ,2BAA2B,CAAC,OAAO,EAAE,OAAO,CACpD,YAAW,6BAA6B;IAElC,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC;IAK3D,iBAAiB,CAAC,IAAI,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,CAAC;IAKrE,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC;IAKhC,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAKvD,aAAa,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IAKvD,UAAU,IAAI,OAAO,CAAC,aAAa,CAAC;CAI5C"}

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

@@ -1,54 +0,0 @@
-"use strict";
-/********************************************************************************
- * 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
- ********************************************************************************/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractDiagnosticsDataServiceFrontend = void 0;
-const data_service_frontend_1 = require("./data-service-frontend");
-/**
- * {@link AbstractDataServiceFrontend} specialised for a server that also exposes
- * the framework {@link DataServerDiagnosticsProtocol} (which the framework
- * `DataServer` implements by default). It implements each diagnostics method as
- * a readiness-gated pass-through — `await this.ensureConnected()`, then delegate
- * to `this.server` — so every adopter frontend gets the memory / state /
- * profiling / latency surface without hand-writing identical one-liner bodies.
- *
- * Extend this instead of {@link AbstractDataServiceFrontend} whenever the head's
- * `DataServer` keeps the default diagnostics registration; the `TServer` bound
- * carries `DataServerDiagnosticsProtocol`, so the delegates are type-checked
- * (no casts). A head that dropped the diagnostics methods via
- * `DataServerOptions.excludedMethods` should extend the plain base instead.
- */
-class AbstractDiagnosticsDataServiceFrontend extends data_service_frontend_1.AbstractDataServiceFrontend {
-    async dumpServerState(args) {
-        await this.ensureConnected();
-        return this.server.dumpServerState(args);
-    }
-    async writeHeapSnapshot(args) {
-        await this.ensureConnected();
-        return this.server.writeHeapSnapshot(args);
-    }
-    async dumpPodMemory() {
-        await this.ensureConnected();
-        return this.server.dumpPodMemory();
-    }
-    async startProfiling(args) {
-        await this.ensureConnected();
-        return this.server.startProfiling(args);
-    }
-    async stopProfiling(args) {
-        await this.ensureConnected();
-        return this.server.stopProfiling(args);
-    }
-    async getLatency() {
-        await this.ensureConnected();
-        return this.server.getLatency();
-    }
-}
-exports.AbstractDiagnosticsDataServiceFrontend = AbstractDiagnosticsDataServiceFrontend;
-//# sourceMappingURL=diagnostics-data-service-frontend.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"diagnostics-data-service-frontend.js","sourceRoot":"","sources":["../../src/browser/diagnostics-data-service-frontend.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;AAUlF,mEAAsE;AAEtE;;;;;;;;;;;;;GAaG;AACH,MAAsB,sCAInB,SAAQ,mDAA6C;IAGrD,KAAK,CAAC,eAAe,CAAC,IAAyB;QAC5C,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IAED,KAAK,CAAC,iBAAiB,CAAC,IAAiC;QACtD,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;IAED,KAAK,CAAC,aAAa;QAChB,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,IAAwB;QAC1C,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,IAAuB;QACxC,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IAC1C,CAAC;IAED,KAAK,CAAC,UAAU;QACb,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;IACnC,CAAC;CACH;AApCD,wFAoCC"}