@hydranium/data-client-theia 1.0.0-next.19 → 1.0.0-next.192

package/src/browser/data-session-stop-contribution.ts

@@ -0,0 +1,117 @@
+/********************************************************************************
+ * 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 { DataConnection, DataServerProtocol, DataSession, DiagnosticOf, TransferElement } from '@hydranium/protocol';
+// Type-only: the `@theia/core/lib/browser` barrel touches DOM globals at module
+// load, which the node-environment unit tests cannot provide.
+import type { FrontendApplicationContribution, OnWillStopAction } from '@theia/core/lib/browser';
+import { injectable } from '@theia/core/shared/inversify';
+
+/**
+ * Ends a Theia frontend's data sessions with its page, and holds the page
+ * while one of them is still saving. Bind it as a
+ * `FrontendApplicationContribution` in singleton scope and {@link track} each
+ * data connection the frontend binds, once.
+ *
+ * **Stop.** {@link onStop} disposes every tracked session, which sends its
+ * `closeSession`, so the server ends it as closed: each document it was the
+ * last to hold reverts at once. Otherwise the server learns of the page only
+ * when its connection goes, which Theia may hold open for its reconnect
+ * timeout, and then ends the sessions as lost, so their documents wait out the
+ * revert grace. The close is best effort: under load the page's last frames
+ * can be lost on the way, and the server then ends the sessions as lost. A
+ * session with calls still in flight at the stop closes after them, which is
+ * too late for a page going away, and is left to the server's connection-close
+ * cleanup. A call a session makes in the same tick as the stop is refused and
+ * never sent.
+ *
+ * **Veto.** While a tracked session has a save in flight, {@link onWillStop}
+ * vetoes, including a session disposed meanwhile. In Electron, Theia awaits
+ * the veto's action, which waits for the saves to answer, a save started during
+ * the wait included, up to {@link maxSettlePasses} times. The browser runs no
+ * action before unload, so there the veto shows the leave-page prompt and
+ * nothing more. Theia ignores every veto under
+ * `application.confirmExit: 'never'`, so there a save in flight at the stop
+ * may be cut off.
+ */
+@injectable()
+export class DataSessionStopContribution implements FrontendApplicationContribution {
+   /** The sessions to end at the stop, and to wait for while they save. */
+   protected readonly sessions = new Set<DataSession<TransferElement>>();
+   /**
+    * How many times the veto's action waits for the saves in flight before it
+    * lets the stop go. Each wait ends by the session's own bound, so a save
+    * that never answers holds the stop for a few bounds, not for good.
+    */
+   protected readonly maxSettlePasses: number = 3;
+
+   /**
+    * Take every session of `connection` into the stop: the ones it has
+    * started already, and each one it starts from now on. Generic, so a
+    * connection of any transfer root, server and client fits.
+    */
+   track<TTransfer extends TransferElement, TServer extends DataServerProtocol<TTransfer, DiagnosticOf<TServer>>, TClient extends object>(
+      connection: DataConnection<TTransfer, TServer, TClient>
+   ): void {
+      connection.liveSessions.forEach(session => this.trackSession(session));
+      connection.onDidCreateSession(session => this.trackSession(session));
+   }
+
+   /**
+    * Take `session` into the stop. It leaves once it has ended and its saves
+    * have answered, so a session disposed with a save in flight still holds
+    * the page.
+    */
+   protected trackSession(session: DataSession<TransferElement>): void {
+      this.sessions.add(session);
+      // A save can outlast the wait's bound, so the session stays until none
+      // is left in flight.
+      const release = (): void =>
+         void session.whenSavesSettled().then(() => (session.hasSavesInFlight ? release() : this.sessions.delete(session)));
+      // An ended session has fired its event already, and never fires it again.
+      if (session.isDisposed) {
+         release();
+      } else {
+         session.onDidDispose(release);
+      }
+   }
+
+   onWillStop(): OnWillStopAction | undefined {
+      if (this.savingSessions().length === 0) {
+         return undefined;
+      }
+      return {
+         // Theia logs the reason and shows it nowhere, so it is not translated.
+         reason: 'Data sessions are saving',
+         action: async () => {
+            // The page stays usable while Theia awaits this, so a save can
+            // start during a wait; each pass waits for the saves then in flight.
+            for (let pass = 0; pass < this.maxSettlePasses; pass++) {
+               const saving = this.savingSessions();
+               if (saving.length === 0) {
+                  break;
+               }
+               await Promise.all(saving.map(session => session.whenSavesSettled()));
+            }
+            return true;
+         }
+      };
+   }
+
+   /** The tracked sessions with a save in flight. */
+   protected savingSessions(): DataSession<TransferElement>[] {
+      return [...this.sessions].filter(session => session.hasSavesInFlight);
+   }
+
+   onStop(): void {
+      for (const session of this.sessions) {
+         session.dispose();
+      }
+   }
+}

package/src/browser/index.ts

@@ -8,8 +8,7 @@
  ********************************************************************************/
 
 export * from './channel-connection';
-export * from './data-service-frontend';
-export * from './diagnostics-data-service-frontend';
+export * from './channel-data-port';
+export * from './data-session-stop-contribution';
 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,10 @@ import type {
    Project,
    ProjectsChangedEvent,
    TransferDiagnostic,
+   TransferDocumentDeletedEvent,
+   TransferDocumentDirtyChangedEvent,
    TransferDocumentSavedEvent,
+   TransferDocumentsBuiltEvent,
    TransferDocumentUpdatedEvent,
    TransferElement
 } from '@hydranium/protocol';
@@ -46,6 +49,18 @@ export class EmitterDataClient<
    /** Fires for each inbound {@link onDocumentSaved} notification. */
    readonly onDidSaveDocument: Event<TransferDocumentSavedEvent<TTransfer, TDiagnostic>> = this.onDocumentSavedEmitter.event;
 
+   protected readonly onDocumentDirtyChangedEmitter = new Emitter<TransferDocumentDirtyChangedEvent>();
+   /** Fires for each inbound {@link onDocumentDirtyChanged} notification. */
+   readonly onDidChangeDocumentDirty: Event<TransferDocumentDirtyChangedEvent> = this.onDocumentDirtyChangedEmitter.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 +73,18 @@ export class EmitterDataClient<
       this.onDocumentSavedEmitter.fire(event);
    }
 
+   onDocumentDirtyChanged(event: TransferDocumentDirtyChangedEvent): void {
+      this.onDocumentDirtyChangedEmitter.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

@@ -9,10 +9,8 @@
 
 import { AbstractSocketForwardingConnectionHandler } from '@hydranium/client-theia/lib/node';
 import { DATA_SERVER_PATH, DATA_SERVER_PORT_COMMAND } from '@hydranium/protocol';
-import { type Channel, type Disposable } from '@theia/core';
 import { injectable, unmanaged } from '@theia/core/shared/inversify';
 import type * as net from 'node:net';
-import { SocketChannelForwarder } from './socket-channel-forwarder';
 
 /** Options for {@link DataServerConnectionHandler}. `servicePath` is the Theia
  *  service path the browser frontend opens a channel to; `portCommand` is the
@@ -30,6 +28,8 @@ export interface DataServerConnectionHandlerOptions {
     *  Defaults to the framework `DATA_SERVER_PORT_COMMAND`; override to match
     *  an adopter's established id. */
    readonly portCommand?: string;
+   /** Name of the server in this handler's log lines. */
+   readonly serverName?: string;
    readonly findPortTimeout?: number;
    readonly findPortAttempts?: number;
    readonly connectTimeoutMs?: number;
@@ -47,13 +47,10 @@ export interface DataServerConnectionHandlerOptions {
  * Bridges a Theia browser-frontend channel to a data-server's TCP socket — the
  * backend half of the data-server head's transport.
  *
- * The port-discovery + buffer-and-replay race fix + connect orchestration live
- * on the cross-head {@link AbstractSocketForwardingConnectionHandler} base; this
- * subclass supplies only the data-server defaults (service path / port command /
- * log labels) and plugs in {@link SocketChannelForwarder} as the byte relay —
- * its own forwarder, so the data head carries no GLSP dependency. Sibling of
- * `@hydranium/glsp-client-theia`'s `GlspServerConnectionHandler`, which
- * subclasses the same base with `@eclipse-glsp`'s `SocketConnectionForwarder`.
+ * The port discovery, the buffer-and-replay race fix, the connect orchestration
+ * and the byte forwarder live on the cross-head
+ * {@link AbstractSocketForwardingConnectionHandler} base; this subclass supplies
+ * only the data-server defaults (service path / port command / log labels).
  */
 @injectable()
 export class DataServerConnectionHandler extends AbstractSocketForwardingConnectionHandler {
@@ -62,7 +59,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 ?? 'Data Server',
          findPortTimeout: options.findPortTimeout,
          findPortAttempts: options.findPortAttempts,
          connectTimeoutMs: options.connectTimeoutMs,
@@ -70,7 +67,7 @@ export class DataServerConnectionHandler extends AbstractSocketForwardingConnect
       });
    }
 
-   protected forwardToSocketConnection(clientChannel: Channel, socket: net.Socket): Disposable {
-      return new SocketChannelForwarder(clientChannel, socket);
-   }
+   /** Logged only: the frontend port reports the connection, and a second
+    *  notification would duplicate it. */
+   protected override reportConnectFailure(): void {}
 }

package/src/node/index.ts

@@ -10,4 +10,3 @@
 export * from './connection-container-module';
 export * from './data-server-connection-handler';
 export * from './host-diagnostics-server';
-export * from './socket-channel-forwarder';

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"}