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

package/README.md

@@ -6,10 +6,12 @@ Theia client primitives for the hydranium **data head** — the companion of
 
 The data head's frontend speaks the data server's own `vscode-jsonrpc` protocol
 over a channel that the Theia backend relays byte-for-byte onto the server's
-socket. This package is both halves of that arrangement: the browser-side
-connection and typed-frontend bases, and the backend-side connection handler and
-forwarder. Install it if a Theia application needs form editors, trees, or
-code-gen driven from the live AST rather than from LSP text edits.
+socket. This package is the Theia-specific half of that arrangement: the browser-side
+transport and the backend-side connection handler and forwarder. Everything above
+the transport — the connection, its sessions, the event fan-out — is host-neutral
+and lives in `@hydranium/protocol/client`. Install it if a Theia application needs
+form editors, trees, or code-gen driven from the live AST rather than from LSP
+text edits.
 
 ## What it gives you
 
@@ -22,19 +24,13 @@ code-gen driven from the live AST rather than from LSP text edits.
   channel ever arrives on its own. Retries follow `DEFAULT_RECONNECT_DELAYS`,
   escalating per consecutive loss and resetting after
   `RECONNECT_ESCALATION_RESET_MS`.
-- **`AbstractDataServiceFrontend`** — base for a frontend that owns the
-  data-server connection: the workspace-gated connect, the typed server proxy,
-  the inbound client binding, and a lazy idempotent init gate (`ensureConnected`).
-  You supply the connection seams (`connectionProvider`, `servicePath`,
-  `methodNamespace`, `client`, `clientMethods`); progress UI and domain caching
-  layer on top.
-- **`AbstractDiagnosticsDataServiceFrontend`** and
-  **`AbstractReferencesDataServiceFrontend`** — the same base specialised for the
-  two protocol fragments an adopter most often keeps: each diagnostics
-  (`dumpServerState`, `writeHeapSnapshot`, `dumpPodMemory`, the profiling and
-  latency calls) and each reference method is implemented as a readiness-gated
-  pass-through, so you do not hand-write identical one-line bodies. They are
-  deliberately independent bases rather than chained.
+- **`ChannelDataPort`** — the `DataPort` implementation over a Theia frontend
+  channel, and the only class a Theia adopter has to write against. Subclass it
+  with a `servicePath`; it supplies the channel, the workspace gate, the
+  reconnect signal and the `MessageService` error sink. Bind one per service path
+  in singleton scope. Hand it to `DataConnectionWithEvents` (from
+  `@hydranium/protocol`) and the connection, its sessions and its event fan-out
+  are the host-neutral ones every other shell uses.
 - **`EmitterDataClient`** (on `./common`, not `./browser`) — the default
   client-side implementation of the data protocol's inbound notifications,
   fanning each one out to a Theia `Event`: `onDidUpdateDocument`,
@@ -81,17 +77,20 @@ This package declares no `theiaExtensions` — it is a library your own Theia
 extension builds on. That extension's `package.json` declares the entries, and
 each entry names one frontend/backend module pair:
 
-- the **frontend** module binds your `AbstractDataServiceFrontend` subclass (and,
-  for the diagnostics commands, calls `bindHostDiagnostics`);
+- the **frontend** module binds your `ChannelDataPort` subclass and the
+  connection over it, both in singleton scope (and, for the diagnostics commands,
+  calls `bindHostDiagnostics`);
 - the **backend** module is typically a one-liner:
   `export default createDataServerConnectionContainerModule(MyHandler)`, where
   `MyHandler` extends `DataServerConnectionHandler`.
 
 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
-`servicePath` — while the shared `portCommand` still names the one server process
-behind them all.
+already open, so every frontend abstraction reaching the data head on its own
+channel needs its own `servicePath` — while the shared `portCommand` still names
+the one server process behind them all. Several participants over ONE channel
+need no second handler: that is what `DataConnection`'s sessions are for, and it
+is the cheaper arrangement.
 
 The refusal is silent, which is what makes it expensive: the loser's promise is
 left unsettled rather than rejected, so a frontend that shared a path hangs on

package/lib/browser/channel-connection.d.ts

@@ -107,8 +107,8 @@ export interface ChannelConnectionHandle {
     /**
      * The current connection. Read it per use rather than caching it: after a
      * reconnect this returns a NEW promise, and a cached one resolves to the
-     * dead connection forever. The same reasoning makes
-     * `AbstractDataServiceFrontend` rebuild its proxy rather than hold one.
+     * dead connection forever. The same reasoning makes `RpcConnection` rebuild
+     * its proxy per generation rather than hold one.
      */
     readonly current: Promise<MessageConnection>;
     /**

package/lib/browser/index.d.ts

@@ -8,9 +8,6 @@
  ********************************************************************************/
 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';
-export * from './references-data-service-frontend';
 export * from './workspace-gate';
 //# sourceMappingURL=index.d.ts.map

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,qBAAqB,CAAC;AACpC,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,6BAA6B,CAAC;AAC5C,cAAc,kBAAkB,CAAC"}

package/lib/browser/index.js

@@ -24,9 +24,6 @@ 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);
-__exportStar(require("./references-data-service-frontend"), exports);
 __exportStar(require("./workspace-gate"), exports);
 //# sourceMappingURL=index.js.map

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,sDAAoC;AACpC,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,8DAA4C;AAC5C,mDAAiC"}

package/lib/node/connection-container-module.d.ts

@@ -24,11 +24,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 declare function createDataServerConnectionContainerModule(...handlerClasses: interfaces.Newable<ConnectionHandler>[]): ContainerModule;
 //# sourceMappingURL=connection-container-module.d.ts.map

package/lib/node/connection-container-module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connection-container-module.d.ts","sourceRoot":"","sources":["../../src/node/connection-container-module.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,EAAE,eAAe,EAAE,KAAK,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,yCAAyC,CAAC,GAAG,cAAc,EAAE,UAAU,CAAC,OAAO,CAAC,iBAAiB,CAAC,EAAE,GAAG,eAAe,CAerI"}
+{"version":3,"file":"connection-container-module.d.ts","sourceRoot":"","sources":["../../src/node/connection-container-module.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,EAAE,eAAe,EAAE,KAAK,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,yCAAyC,CAAC,GAAG,cAAc,EAAE,UAAU,CAAC,OAAO,CAAC,iBAAiB,CAAC,EAAE,GAAG,eAAe,CAerI"}

package/lib/node/connection-container-module.js

@@ -28,11 +28,12 @@ const inversify_1 = require("@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.
  */
 function createDataServerConnectionContainerModule(...handlerClasses) {
     const frontendScopedConnectionModule = connection_container_module_1.ConnectionContainerModule.create(({ bind }) => {

package/lib/node/connection-container-module.js.map

@@ -1 +1 @@
-{"version":3,"file":"connection-container-module.js","sourceRoot":"","sources":["../../src/node/connection-container-module.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;AA4BlF,8FAeC;AAzCD,sCAAgD;AAChD,4GAAuG;AACvG,4DAAgF;AAEhF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,yCAAyC,CAAC,GAAG,cAAuD;IACjH,MAAM,8BAA8B,GAAG,uDAAyB,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE;QAClF,KAAK,MAAM,YAAY,IAAI,cAAc,EAAE,CAAC;YACzC,IAAI,CAAC,YAAY,CAAC,CAAC,MAAM,EAAE,CAAC,gBAAgB,EAAE,CAAC;YAC/C,mEAAmE;YACnE,mEAAmE;YACnE,oEAAoE;YACpE,IAAI,CAAC,wBAAiB,CAAC;iBACnB,cAAc,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;iBAC9D,gBAAgB,EAAE,CAAC;QAC1B,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,OAAO,IAAI,2BAAe,CAAC,IAAI,CAAC,EAAE;QAC/B,IAAI,CAAC,uDAAyB,CAAC,CAAC,eAAe,CAAC,8BAA8B,CAAC,CAAC;IACnF,CAAC,CAAC,CAAC;AACN,CAAC"}
+{"version":3,"file":"connection-container-module.js","sourceRoot":"","sources":["../../src/node/connection-container-module.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;AA6BlF,8FAeC;AA1CD,sCAAgD;AAChD,4GAAuG;AACvG,4DAAgF;AAEhF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,SAAgB,yCAAyC,CAAC,GAAG,cAAuD;IACjH,MAAM,8BAA8B,GAAG,uDAAyB,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE;QAClF,KAAK,MAAM,YAAY,IAAI,cAAc,EAAE,CAAC;YACzC,IAAI,CAAC,YAAY,CAAC,CAAC,MAAM,EAAE,CAAC,gBAAgB,EAAE,CAAC;YAC/C,mEAAmE;YACnE,mEAAmE;YACnE,oEAAoE;YACpE,IAAI,CAAC,wBAAiB,CAAC;iBACnB,cAAc,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;iBAC9D,gBAAgB,EAAE,CAAC;QAC1B,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,OAAO,IAAI,2BAAe,CAAC,IAAI,CAAC,EAAE;QAC/B,IAAI,CAAC,uDAAyB,CAAC,CAAC,eAAe,CAAC,8BAA8B,CAAC,CAAC;IACnF,CAAC,CAAC,CAAC;AACN,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hydranium/data-client-theia",
-  "version": "1.0.0-next.62",
+  "version": "1.0.0-next.66",
   "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.62",
-    "@hydranium/core": "1.0.0-next.62",
-    "@hydranium/protocol": "1.0.0-next.62",
+    "@hydranium/client-theia": "1.0.0-next.66",
+    "@hydranium/core": "1.0.0-next.66",
+    "@hydranium/protocol": "1.0.0-next.66",
     "@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.62",
-    "@hydranium/core": "1.0.0-next.62",
-    "@hydranium/protocol": "1.0.0-next.62",
+    "@hydranium/client-theia": "1.0.0-next.66",
+    "@hydranium/core": "1.0.0-next.66",
+    "@hydranium/protocol": "1.0.0-next.66",
     "@theia/core": "^1.70.0",
     "@theia/workspace": "^1.70.0",
     "inversify": "^6.0.0",

package/src/browser/channel-connection.ts

@@ -199,8 +199,8 @@ export interface ChannelConnectionHandle {
    /**
     * The current connection. Read it per use rather than caching it: after a
     * reconnect this returns a NEW promise, and a cached one resolves to the
-    * dead connection forever. The same reasoning makes
-    * `AbstractDataServiceFrontend` rebuild its proxy rather than hold one.
+    * dead connection forever. The same reasoning makes `RpcConnection` rebuild
+    * its proxy per generation rather than hold one.
     */
    readonly current: Promise<MessageConnection>;
 

package/src/browser/index.ts

@@ -9,8 +9,5 @@
 
 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';
-export * from './references-data-service-frontend';
 export * from './workspace-gate';

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/lib/browser/data-service-frontend.d.ts

@@ -1,96 +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 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 type { WorkspaceService } from '@theia/workspace/lib/browser';
-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.
- *
- * 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 ReadyServer, TClient extends object> {
-    protected abstract readonly connectionProvider: ServiceConnectionProvider;
-    protected abstract readonly workspaceService?: WorkspaceService;
-    protected abstract readonly client: TClient;
-    /** Frontend service path the backend forwarder for this head is registered under. */
-    protected abstract readonly servicePath: string;
-    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 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.
-     */
-    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 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;
-    /**
-     * The server proxy. Calls queue against the connection, so await
-     * {@link ensureConnected} first wherever the server's readiness matters.
-     */
-    protected get server(): RpcProxy<TServer>;
-    /**
-     * Await the connection and the server's readiness gate, shared across
-     * concurrent callers and re-run once per connection generation.
-     */
-    protected ensureConnected(): Promise<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;
-    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 +0,0 @@
-{"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

@@ -1,148 +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 core_1 = require("@theia/core");
-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.
- *
- * 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;
-    /**
-     * 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.
-     */
-    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 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
-        });
-        // 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));
-    }
-    /**
-     * The server proxy. Calls queue against the connection, so await
-     * {@link ensureConnected} first wherever the server's readiness matters.
-     */
-    get server() {
-        return this.requireConnection().server;
-    }
-    /**
-     * Await the connection and the server's readiness gate, shared across
-     * concurrent callers and re-run once per connection generation.
-     */
-    async ensureConnected() {
-        await this.requireConnection().connected();
-    }
-    /**
-     * 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.connection?.dispose();
-        this.connection = undefined;
-        this.channel?.dispose();
-        this.channel = undefined;
-        this.lossEmitter.dispose();
-    }
-    requireConnection() {
-        if (!this.connection) {
-            throw new Error('the connection is not open: call start() first');
-        }
-        return this.connection;
-    }
-    requireChannel() {
-        if (!this.channel) {
-            throw new Error('the channel is not open: call start() first');
-        }
-        return this.channel;
-    }
-}
-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":";AAAA;;;;;;;kFAOkF;;;AAElF,kDAO6B;AAC7B,sCAAgE;AAGhE,6DAA2F;AAC3F,qDAAqD;AAErD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAsB,2BAA2B;IAU9C,yFAAyF;IACtE,cAAc,CAAkB;IAEnD;;;;;OAKG;IACgB,yBAAyB,GAAY,IAAI,CAAC;IAEnD,OAAO,CAA2B;IAClC,UAAU,CAAmC;IACpC,WAAW,GAAG,IAAI,cAAO,EAAQ,CAAC;IAErD;;;;OAIG;IACO,mBAAmB;QAC1B,OAAO,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAA,kCAAiB,EAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACvF,CAAC;IAED,uEAAuE;IAC7D,YAAY;QACnB,qBAAqB;IACxB,CAAC;IAED,gEAAgE;IACtD,OAAO;QACd,qBAAqB;IACxB,CAAC;IAED,8DAA8D;IACpD,QAAQ,CAAC,MAAe;QAC/B,qBAAqB;IACxB,CAAC;IAED;;;;OAIG;IACO,KAAK;QACZ,IAAI,CAAC,OAAO,GAAG,IAAA,0CAAqB,EAAC,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,WAAW,EAAE;YAC7E,SAAS,EAAE,IAAI,CAAC,mBAAmB,EAAE;YACrC,SAAS,EAAE,IAAI,CAAC,yBAAyB;SAC3C,CAAC,CAAC;QACH,oEAAoE;QACpE,wEAAwE;QACxE,6DAA6D;QAC7D,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;QACzE,IAAI,CAAC,UAAU,GAAG,IAAI,wBAAa,CAAmB,IAAI,CAAC,WAAW,EAAE,EAAE,IAAI,CAAC,MAAM,EAAE;YACpF,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,SAAS,EAAE;gBACR,YAAY,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,EAAE;gBACvC,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE;gBAC7B,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;aACzC;SACH,CAAC,CAAC;IACN,CAAC;IAED,yEAAyE;IAC/D,WAAW;QAClB,OAAO;YACJ,sEAAsE;YACtE,oEAAoE;YACpE,UAAU;YACV,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,OAAO;YAC5C,WAAW,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC;YAC7D,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,KAAK;SACnC,CAAC;IACL,CAAC;IAED,0DAA0D;IAChD,WAAW,CAAC,QAAyB;QAC5C,IAAI,CAAC,cAAc,EAAE,KAAK,CAAC,IAAA,iCAAsB,EAAC,QAAQ,EAAE,UAAG,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC;IAChG,CAAC;IAED;;;OAGG;IACH,IAAc,MAAM;QACjB,OAAO,IAAI,CAAC,iBAAiB,EAAE,CAAC,MAAM,CAAC;IAC1C,CAAC;IAED;;;OAGG;IACO,KAAK,CAAC,eAAe;QAC5B,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC,SAAS,EAAE,CAAC;IAC9C,CAAC;IAED;;;;;;OAMG;IACH,OAAO;QACJ,IAAI,CAAC,UAAU,EAAE,OAAO,EAAE,CAAC;QAC3B,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC5B,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,CAAC;QACxB,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;QACzB,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;IAC9B,CAAC;IAES,iBAAiB;QACxB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;QACrE,CAAC;QACD,OAAO,IAAI,CAAC,UAAU,CAAC;IAC1B,CAAC;IAES,cAAc;QACrB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;QAClE,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,CAAC;IACvB,CAAC;CACH;AAvID,kEAuIC"}

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

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

@@ -1,45 +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 { FindNextNameArgs, ReferenceCandidate, ReferenceContext, ReferenceRequest, ReferenceServerProtocol, ReferenceTarget, TransferElement } from '@hydranium/protocol';
-import { AbstractDataServiceFrontend } from './data-service-frontend';
-/**
- * {@link AbstractDataServiceFrontend} specialised for a server that also
- * composes the framework {@link ReferenceServerProtocol} fragment. It
- * implements each reference method as a readiness-gated pass-through —
- * `await this.ensureConnected()`, then delegate to `this.server` — so an
- * adopter frontend gets the candidate / resolve / next-name surface without
- * hand-writing identical one-liner bodies.
- *
- * The sibling of `AbstractDiagnosticsDataServiceFrontend`, and the same
- * shape for the same reason: `this.server` is already a forwarding proxy, but
- * it queues only on the channel being live, not on the server's `waitForReady`
- * gate — so the gate has to be interposed per method.
- *
- * Extend this instead of {@link AbstractDataServiceFrontend} whenever the
- * head's `DataServer` registers the reference fragment (typically via a
- * subclass's `additionalMethods`, since
- * `REFERENCE_SERVER_PROTOCOL_METHODS` is deliberately NOT part of
- * `DATA_SERVER_PROTOCOL_METHODS`). The `TServer` bound carries
- * `ReferenceServerProtocol`, so the delegates are type-checked without casts.
- *
- * A frontend needing both fragments extends the diagnostics base and mixes
- * these three in, or vice versa — TypeScript allows only one base class, so
- * the two bases are deliberately independent rather than chained. Chaining
- * them would force every reference-fragment adopter to also carry the
- * diagnostics surface, which a head that dropped those methods via
- * `DataServerOptions.excludedMethods` cannot satisfy.
- */
-export declare abstract class AbstractReferencesDataServiceFrontend<TTransfer extends TransferElement, TServer extends {
-    waitForReady(): Promise<void>;
-} & ReferenceServerProtocol<TTransfer>, TClient extends object> extends AbstractDataServiceFrontend<TServer, TClient> implements ReferenceServerProtocol<TTransfer> {
-    findReferenceCandidates(ctx: ReferenceContext): Promise<ReferenceCandidate[]>;
-    resolveReference(ref: ReferenceRequest): Promise<ReferenceTarget<TTransfer> | undefined>;
-    findNextName(args: FindNextNameArgs): Promise<string>;
-}
-//# sourceMappingURL=references-data-service-frontend.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"references-data-service-frontend.d.ts","sourceRoot":"","sources":["../../src/browser/references-data-service-frontend.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,KAAK,EACT,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,EAChB,uBAAuB,EACvB,eAAe,EACf,eAAe,EACjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,8BAAsB,qCAAqC,CACxD,SAAS,SAAS,eAAe,EACjC,OAAO,SAAS;IAAE,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,GAAG,uBAAuB,CAAC,SAAS,CAAC,EACtF,OAAO,SAAS,MAAM,CAEtB,SAAQ,2BAA2B,CAAC,OAAO,EAAE,OAAO,CACpD,YAAW,uBAAuB,CAAC,SAAS,CAAC;IAEvC,uBAAuB,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAK7E,gBAAgB,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;IAKxF,YAAY,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC;CAI7D"}

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

@@ -1,55 +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.AbstractReferencesDataServiceFrontend = void 0;
-const data_service_frontend_1 = require("./data-service-frontend");
-/**
- * {@link AbstractDataServiceFrontend} specialised for a server that also
- * composes the framework {@link ReferenceServerProtocol} fragment. It
- * implements each reference method as a readiness-gated pass-through —
- * `await this.ensureConnected()`, then delegate to `this.server` — so an
- * adopter frontend gets the candidate / resolve / next-name surface without
- * hand-writing identical one-liner bodies.
- *
- * The sibling of `AbstractDiagnosticsDataServiceFrontend`, and the same
- * shape for the same reason: `this.server` is already a forwarding proxy, but
- * it queues only on the channel being live, not on the server's `waitForReady`
- * gate — so the gate has to be interposed per method.
- *
- * Extend this instead of {@link AbstractDataServiceFrontend} whenever the
- * head's `DataServer` registers the reference fragment (typically via a
- * subclass's `additionalMethods`, since
- * `REFERENCE_SERVER_PROTOCOL_METHODS` is deliberately NOT part of
- * `DATA_SERVER_PROTOCOL_METHODS`). The `TServer` bound carries
- * `ReferenceServerProtocol`, so the delegates are type-checked without casts.
- *
- * A frontend needing both fragments extends the diagnostics base and mixes
- * these three in, or vice versa — TypeScript allows only one base class, so
- * the two bases are deliberately independent rather than chained. Chaining
- * them would force every reference-fragment adopter to also carry the
- * diagnostics surface, which a head that dropped those methods via
- * `DataServerOptions.excludedMethods` cannot satisfy.
- */
-class AbstractReferencesDataServiceFrontend extends data_service_frontend_1.AbstractDataServiceFrontend {
-    async findReferenceCandidates(ctx) {
-        await this.ensureConnected();
-        return this.server.findReferenceCandidates(ctx);
-    }
-    async resolveReference(ref) {
-        await this.ensureConnected();
-        return this.server.resolveReference(ref);
-    }
-    async findNextName(args) {
-        await this.ensureConnected();
-        return this.server.findNextName(args);
-    }
-}
-exports.AbstractReferencesDataServiceFrontend = AbstractReferencesDataServiceFrontend;
-//# sourceMappingURL=references-data-service-frontend.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"references-data-service-frontend.js","sourceRoot":"","sources":["../../src/browser/references-data-service-frontend.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;AAWlF,mEAAsE;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAsB,qCAKnB,SAAQ,mDAA6C;IAGrD,KAAK,CAAC,uBAAuB,CAAC,GAAqB;QAChD,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,MAAM,CAAC,uBAAuB,CAAC,GAAG,CAAC,CAAC;IACnD,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAC,GAAqB;QACzC,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;IAC5C,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,IAAsB;QACtC,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;CACH;AAtBD,sFAsBC"}

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

@@ -1,177 +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 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 type { WorkspaceService } from '@theia/workspace/lib/browser';
-import { type ChannelConnectionHandle, openChannelConnection } from './channel-connection';
-import { whenWorkspaceOpen } from './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.
- *
- * 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 ReadyServer, TClient extends object> {
-   protected abstract readonly connectionProvider: ServiceConnectionProvider;
-   protected abstract readonly workspaceService?: WorkspaceService;
-   protected abstract readonly client: TClient;
-   /** Frontend service path the backend forwarder for this head is registered under. */
-   protected abstract readonly servicePath: string;
-   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 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.
-    */
-   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 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
-      });
-      // 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));
-   }
-
-   /**
-    * The server proxy. Calls queue against the connection, so await
-    * {@link ensureConnected} first wherever the server's readiness matters.
-    */
-   protected get server(): RpcProxy<TServer> {
-      return this.requireConnection().server;
-   }
-
-   /**
-    * Await the connection and the server's readiness gate, shared across
-    * concurrent callers and re-run once per connection generation.
-    */
-   protected async ensureConnected(): Promise<void> {
-      await this.requireConnection().connected();
-   }
-
-   /**
-    * 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 {
-      this.connection?.dispose();
-      this.connection = undefined;
-      this.channel?.dispose();
-      this.channel = undefined;
-      this.lossEmitter.dispose();
-   }
-
-   protected requireConnection(): RpcConnection<TServer, TClient> {
-      if (!this.connection) {
-         throw new Error('the connection is not open: call start() first');
-      }
-      return this.connection;
-   }
-
-   protected requireChannel(): ChannelConnectionHandle {
-      if (!this.channel) {
-         throw new Error('the channel is not open: call start() first');
-      }
-      return this.channel;
-   }
-}

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

@@ -1,70 +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 abstract class AbstractDiagnosticsDataServiceFrontend<
-   TServer extends { waitForReady(): Promise<void> } & DataServerDiagnosticsProtocol,
-   TClient extends object
->
-   extends AbstractDataServiceFrontend<TServer, TClient>
-   implements DataServerDiagnosticsProtocol
-{
-   async dumpServerState(args: DumpServerStateArgs): Promise<string> {
-      await this.ensureConnected();
-      return this.server.dumpServerState(args);
-   }
-
-   async writeHeapSnapshot(args: WriteServerHeapSnapshotArgs): Promise<string> {
-      await this.ensureConnected();
-      return this.server.writeHeapSnapshot(args);
-   }
-
-   async dumpPodMemory(): Promise<string> {
-      await this.ensureConnected();
-      return this.server.dumpPodMemory();
-   }
-
-   async startProfiling(args: StartProfilingArgs): Promise<void> {
-      await this.ensureConnected();
-      return this.server.startProfiling(args);
-   }
-
-   async stopProfiling(args: StopProfilingArgs): Promise<string> {
-      await this.ensureConnected();
-      return this.server.stopProfiling(args);
-   }
-
-   async getLatency(): Promise<LatencyReport> {
-      await this.ensureConnected();
-      return this.server.getLatency();
-   }
-}

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

@@ -1,70 +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 {
-   FindNextNameArgs,
-   ReferenceCandidate,
-   ReferenceContext,
-   ReferenceRequest,
-   ReferenceServerProtocol,
-   ReferenceTarget,
-   TransferElement
-} from '@hydranium/protocol';
-import { AbstractDataServiceFrontend } from './data-service-frontend';
-
-/**
- * {@link AbstractDataServiceFrontend} specialised for a server that also
- * composes the framework {@link ReferenceServerProtocol} fragment. It
- * implements each reference method as a readiness-gated pass-through —
- * `await this.ensureConnected()`, then delegate to `this.server` — so an
- * adopter frontend gets the candidate / resolve / next-name surface without
- * hand-writing identical one-liner bodies.
- *
- * The sibling of `AbstractDiagnosticsDataServiceFrontend`, and the same
- * shape for the same reason: `this.server` is already a forwarding proxy, but
- * it queues only on the channel being live, not on the server's `waitForReady`
- * gate — so the gate has to be interposed per method.
- *
- * Extend this instead of {@link AbstractDataServiceFrontend} whenever the
- * head's `DataServer` registers the reference fragment (typically via a
- * subclass's `additionalMethods`, since
- * `REFERENCE_SERVER_PROTOCOL_METHODS` is deliberately NOT part of
- * `DATA_SERVER_PROTOCOL_METHODS`). The `TServer` bound carries
- * `ReferenceServerProtocol`, so the delegates are type-checked without casts.
- *
- * A frontend needing both fragments extends the diagnostics base and mixes
- * these three in, or vice versa — TypeScript allows only one base class, so
- * the two bases are deliberately independent rather than chained. Chaining
- * them would force every reference-fragment adopter to also carry the
- * diagnostics surface, which a head that dropped those methods via
- * `DataServerOptions.excludedMethods` cannot satisfy.
- */
-export abstract class AbstractReferencesDataServiceFrontend<
-   TTransfer extends TransferElement,
-   TServer extends { waitForReady(): Promise<void> } & ReferenceServerProtocol<TTransfer>,
-   TClient extends object
->
-   extends AbstractDataServiceFrontend<TServer, TClient>
-   implements ReferenceServerProtocol<TTransfer>
-{
-   async findReferenceCandidates(ctx: ReferenceContext): Promise<ReferenceCandidate[]> {
-      await this.ensureConnected();
-      return this.server.findReferenceCandidates(ctx);
-   }
-
-   async resolveReference(ref: ReferenceRequest): Promise<ReferenceTarget<TTransfer> | undefined> {
-      await this.ensureConnected();
-      return this.server.resolveReference(ref);
-   }
-
-   async findNextName(args: FindNextNameArgs): Promise<string> {
-      await this.ensureConnected();
-      return this.server.findNextName(args);
-   }
-}