@hydranium/glsp-server 1.0.0-next.10

package/lib/launcher/abstract-hydranium-glsp-diagram-module.d.ts

@@ -0,0 +1,75 @@
+/********************************************************************************
+ * 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 { DiagramModule } from '@eclipse-glsp/server';
+import { type interfaces } from 'inversify';
+import type { LanguageMetaData } from '@hydranium/langium';
+/**
+ * Bind {@link HydraniumTypes}.DiagramLanguage on a GLSP **session** container
+ * to the services of `metadata`'s grammar.
+ *
+ * Exported separately from {@link AbstractHydraniumGlspDiagramModule} for adopters
+ * whose diagram module already extends an intermediate base of their own and
+ * cannot take the framework base class; call it from `configure` after
+ * `super.configure(...)`. The base class is the preferred entry point because
+ * it makes the declaration non-optional.
+ *
+ * **Why the session tier.** GLSP builds its app container once per process,
+ * before any document exists, so a per-language service bound there can only
+ * ever be one grammar's. The session container is created per open diagram
+ * with its `diagramType` known, and a diagram type has exactly one grammar —
+ * so the language is a static fact about the module, resolvable with no URI
+ * and no ordering hazard. That last part is load-bearing: GLSP's
+ * `OperationHandlerRegistryInitializer` constructs every operation handler at
+ * `InitializeClientSession`, i.e. BEFORE `RequestModelAction` supplies the
+ * source URI, so anything derived from `ModelState.sourceUri` at injection
+ * time would throw on every diagram open.
+ *
+ * **The whole language, not pre-resolved providers.** There is deliberately no
+ * token for an individual per-language provider; see {@link HydraniumTypes} for
+ * why. Callers reach `modelState.diagramLanguage` or
+ * `modelState.languageServicesFor(node)` instead, which name the choice.
+ *
+ * Resolution is `toDynamicValue` + `inSingletonScope` — deferred so the parent
+ * container's `SharedCoreServices` is available, then resolved once per
+ * session rather than per injection.
+ */
+export declare function bindDiagramLanguage(bind: interfaces.Bind, metadata: LanguageMetaData): void;
+/**
+ * GLSP {@link DiagramModule} base that declares which grammar its diagram type
+ * edits, and binds that language's per-language services on the session
+ * container.
+ *
+ * Subclass instead of `DiagramModule` and implement {@link declareLanguage}
+ * alongside `diagramType`; the two are the same kind of fact about a diagram
+ * type, and pairing them is what lets one GLSP head serve N grammars.
+ *
+ * Adopter GLSP components then read the language they mean:
+ * `modelState.diagramLanguage.references.CandidateProvider` for a reference
+ * written on the canvas, `modelState.languageServicesFor(node).references.X`
+ * for anything reached through a reference. No per-language service is bound
+ * to a token of its own — see {@link bindDiagramLanguage} for why.
+ */
+export declare abstract class AbstractHydraniumGlspDiagramModule extends DiagramModule {
+    /**
+     * The `LanguageMetaData` of the grammar this diagram type edits — pass the
+     * generated `<Grammar>LanguageMetaData` constant directly.
+     *
+     * Abstract rather than optional so a new diagram module cannot silently
+     * omit it: a missing declaration is a compile error here, where the fix is
+     * obvious, instead of an unbound-token failure at the first diagram open.
+     *
+     * NOT named `bindLanguage`: every `bindX()` on GLSP's `DiagramModule`
+     * returns a `BindingTarget<T>` that GLSP's own `configure` consumes, and a
+     * method in that family returning a `LanguageMetaData` invites
+     * `{ service: … }`. This one states a fact; the framework does the binding.
+     */
+    protected abstract declareLanguage(): LanguageMetaData;
+    protected configure(bind: interfaces.Bind, unbind: interfaces.Unbind, isBound: interfaces.IsBound, rebind: interfaces.Rebind): void;
+}
+//# sourceMappingURL=abstract-hydranium-glsp-diagram-module.d.ts.map

package/lib/launcher/abstract-hydranium-glsp-diagram-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-hydranium-glsp-diagram-module.d.ts","sourceRoot":"","sources":["../../src/launcher/abstract-hydranium-glsp-diagram-module.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,WAAW,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAI3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAI3F;AA0BD;;;;;;;;;;;;;;GAcG;AACH,8BACsB,kCAAmC,SAAQ,aAAa;IAC3E;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,QAAQ,CAAC,eAAe,IAAI,gBAAgB;cAEnC,SAAS,CACzB,IAAI,EAAE,UAAU,CAAC,IAAI,EACrB,MAAM,EAAE,UAAU,CAAC,MAAM,EACzB,OAAO,EAAE,UAAU,CAAC,OAAO,EAC3B,MAAM,EAAE,UAAU,CAAC,MAAM,GACzB,IAAI;CAIT"}

package/lib/launcher/abstract-hydranium-glsp-diagram-module.js

@@ -0,0 +1,100 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { DiagramModule } from '@eclipse-glsp/server';
+import { injectable } from 'inversify';
+import { typedMetadata } from '@hydranium/core';
+import { HydraniumTypes } from '../state/hydranium-shared-core-services.js';
+/**
+ * Bind {@link HydraniumTypes}.DiagramLanguage on a GLSP **session** container
+ * to the services of `metadata`'s grammar.
+ *
+ * Exported separately from {@link AbstractHydraniumGlspDiagramModule} for adopters
+ * whose diagram module already extends an intermediate base of their own and
+ * cannot take the framework base class; call it from `configure` after
+ * `super.configure(...)`. The base class is the preferred entry point because
+ * it makes the declaration non-optional.
+ *
+ * **Why the session tier.** GLSP builds its app container once per process,
+ * before any document exists, so a per-language service bound there can only
+ * ever be one grammar's. The session container is created per open diagram
+ * with its `diagramType` known, and a diagram type has exactly one grammar —
+ * so the language is a static fact about the module, resolvable with no URI
+ * and no ordering hazard. That last part is load-bearing: GLSP's
+ * `OperationHandlerRegistryInitializer` constructs every operation handler at
+ * `InitializeClientSession`, i.e. BEFORE `RequestModelAction` supplies the
+ * source URI, so anything derived from `ModelState.sourceUri` at injection
+ * time would throw on every diagram open.
+ *
+ * **The whole language, not pre-resolved providers.** There is deliberately no
+ * token for an individual per-language provider; see {@link HydraniumTypes} for
+ * why. Callers reach `modelState.diagramLanguage` or
+ * `modelState.languageServicesFor(node)` instead, which name the choice.
+ *
+ * Resolution is `toDynamicValue` + `inSingletonScope` — deferred so the parent
+ * container's `SharedCoreServices` is available, then resolved once per
+ * session rather than per injection.
+ */
+export function bindDiagramLanguage(bind, metadata) {
+    bind(HydraniumTypes.DiagramLanguage)
+        .toDynamicValue(context => resolveDiagramLanguage(context.container, metadata))
+        .inSingletonScope();
+}
+/**
+ * The registered services for `metadata`'s language, or a throw naming both
+ * the declared id and the registered ones.
+ *
+ * Failing loudly is the point: the declared language is the one fact this
+ * module states that the grammar does not, so it can drift. An unregistered id
+ * means the adopter declared a language they never registered — a wiring
+ * mistake whose silent form (falling back to some other grammar's providers)
+ * would surface much later as references that resolve against the wrong scope.
+ */
+function resolveDiagramLanguage(container, metadata) {
+    const registry = container.get(HydraniumTypes.SharedCoreServices).ServiceRegistry;
+    const language = registry.getServices(typedMetadata(metadata));
+    if (!language) {
+        const registered = registry.all.map(candidate => candidate.LanguageMetaData.languageId);
+        throw new Error(`Diagram module declares language '${metadata.languageId}', which is not registered on the ServiceRegistry. ` +
+            `Registered languages: ${registered.length > 0 ? registered.join(', ') : '(none)'}. ` +
+            'Declare the languageId of a grammar passed to bootstrapLangiumLanguages.');
+    }
+    return language;
+}
+/**
+ * GLSP {@link DiagramModule} base that declares which grammar its diagram type
+ * edits, and binds that language's per-language services on the session
+ * container.
+ *
+ * Subclass instead of `DiagramModule` and implement {@link declareLanguage}
+ * alongside `diagramType`; the two are the same kind of fact about a diagram
+ * type, and pairing them is what lets one GLSP head serve N grammars.
+ *
+ * Adopter GLSP components then read the language they mean:
+ * `modelState.diagramLanguage.references.CandidateProvider` for a reference
+ * written on the canvas, `modelState.languageServicesFor(node).references.X`
+ * for anything reached through a reference. No per-language service is bound
+ * to a token of its own — see {@link bindDiagramLanguage} for why.
+ */
+let AbstractHydraniumGlspDiagramModule = class AbstractHydraniumGlspDiagramModule extends DiagramModule {
+    configure(bind, unbind, isBound, rebind) {
+        super.configure(bind, unbind, isBound, rebind);
+        bindDiagramLanguage(bind, this.declareLanguage());
+    }
+};
+AbstractHydraniumGlspDiagramModule = __decorate([
+    injectable()
+], AbstractHydraniumGlspDiagramModule);
+export { AbstractHydraniumGlspDiagramModule };
+//# sourceMappingURL=abstract-hydranium-glsp-diagram-module.js.map

package/lib/launcher/abstract-hydranium-glsp-diagram-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-hydranium-glsp-diagram-module.js","sourceRoot":"","sources":["../../src/launcher/abstract-hydranium-glsp-diagram-module.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;;;;;;;AAElF,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAmB,MAAM,WAAW,CAAC;AAExD,OAAO,EAA0D,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACxG,OAAO,EAAE,cAAc,EAAE,MAAM,4CAA4C,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAqB,EAAE,QAA0B;IAClF,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC;SAChC,cAAc,CAAC,OAAO,CAAC,EAAE,CAAC,sBAAsB,CAAC,OAAO,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;SAC9E,gBAAgB,EAAE,CAAC;AAC1B,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,sBAAsB,CAAC,SAA+B,EAAE,QAA0B;IACxF,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAuB,cAAc,CAAC,kBAAkB,CAAC,CAAC,eAAe,CAAC;IACxG,MAAM,QAAQ,GAAG,QAAQ,CAAC,WAAW,CAAC,aAAa,CAAyB,QAAQ,CAAC,CAAC,CAAC;IACvF,IAAI,CAAC,QAAQ,EAAE,CAAC;QACb,MAAM,UAAU,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;QACxF,MAAM,IAAI,KAAK,CACZ,qCAAqC,QAAQ,CAAC,UAAU,qDAAqD;YAC1G,yBAAyB,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,IAAI;YACrF,0EAA0E,CAC/E,CAAC;IACL,CAAC;IACD,OAAO,QAAQ,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;;;GAcG;AAEI,IAAe,kCAAkC,GAAjD,MAAe,kCAAmC,SAAQ,aAAa;IAgBxD,SAAS,CACzB,IAAqB,EACrB,MAAyB,EACzB,OAA2B,EAC3B,MAAyB;QAEzB,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAC/C,mBAAmB,CAAC,IAAI,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;IACrD,CAAC;CACH,CAAA;AAzBqB,kCAAkC;IADvD,UAAU,EAAE;GACS,kCAAkC,CAyBvD"}

package/lib/launcher/glsp-app-module.d.ts

@@ -0,0 +1,87 @@
+/********************************************************************************
+ * 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 { GLSPModule } from '@eclipse-glsp/server';
+import type { BindingContext } from '@eclipse-glsp/protocol/lib/di/inversify-util.js';
+import type { ServerSharedServices } from '@hydranium/core';
+import { type ConflictResolver } from '@hydranium/protocol';
+import { type interfaces } from 'inversify';
+/**
+ * Configuration accepted by {@link HydraniumGlspAppModule}. Bundles the
+ * framework-defined Inversify bindings every adopter wires verbatim in their
+ * GLSP server app-module (the `appModules` argument to `startGlspServer`).
+ *
+ * **App tier only, so nothing per-language belongs here.** This module is
+ * loaded into the one-per-process app container, built before any document
+ * exists — it cannot know which grammar a request concerns. Per-language
+ * services are declared per diagram type instead; see
+ * `AbstractHydraniumGlspDiagramModule`.
+ */
+export interface HydraniumGlspAppModuleOptions<TShared extends ServerSharedServices = ServerSharedServices> {
+    /**
+     * The framework's Langium-style shared services tree. Bound to the
+     * `HydraniumTypes.SharedCoreServices` symbol that framework state /
+     * index classes (`AbstractHydraniumGlspState`, `HydraniumGlspIndex`) `@inject`.
+     *
+     * Generic over `TShared` so adopters with their own narrower
+     * shared-services type (an adopter-specific type extending
+     * `ServerSharedServices` with extra slots) preserve that
+     * type at `this.options.shared` inside subclass methods without an
+     * explicit cast. The Inversify symbol binding still types `@inject`
+     * sites as the wider `ServerSharedServices`; specialise the binding
+     * with an adopter-specific symbol where injected components want the
+     * narrower view.
+     */
+    readonly shared: TShared;
+    /**
+     * Optional {@link ConflictResolver} policy bound to the
+     * `HydraniumTypes.ConflictResolver` symbol that `AbstractHydraniumGlspState`
+     * injects. Omit to get the framework default
+     * ({@link ReconcilingConflictResolver} — field-level three-way merge);
+     * pass a `ForceConflictResolver` for
+     * last-writer-wins, or a custom resolver. Applies uniformly to every
+     * conflict site (forward-write, undo, redo, save).
+     */
+    readonly conflictResolver?: ConflictResolver;
+}
+/**
+ * DI module that provides the framework-level Inversify bindings every
+ * `@hydranium/glsp-server` adopter needs. Pass instances (or instances of
+ * subclasses with additional bindings) into `startGlspServer`'s
+ * `appModules` array.
+ *
+ * Bindings provided:
+ *  - `HydraniumTypes.SharedCoreServices` (constant value)
+ *  - `HydraniumTypes.ConflictResolver` (constant value — `options.conflictResolver` or a default {@link ReconcilingConflictResolver})
+ *
+ * Both are language-independent, which is what makes them app-tier. The
+ * per-language providers (`ScopeProvider`, `CandidateProvider`) are bound one
+ * tier down by `AbstractHydraniumGlspDiagramModule`, from the grammar each
+ * diagram type declares.
+ *
+ * Concrete and usable as-is: adopters that need no extra bindings
+ * instantiate {@link HydraniumGlspAppModule} directly. Adopters that do
+ * subclass it and override {@link configureAdditionalBindings} to add their
+ * own service-identifier carriers.
+ *
+ * A conventional GLSP module (cf. `@eclipse-glsp/server`'s `GLSPModule`
+ * subclasses); the empty `configureAdditionalBindings` hook is the single
+ * extension point, so no separate abstract base is needed.
+ */
+export declare class HydraniumGlspAppModule<TShared extends ServerSharedServices = ServerSharedServices> extends GLSPModule {
+    protected readonly options: HydraniumGlspAppModuleOptions<TShared>;
+    constructor(options: HydraniumGlspAppModuleOptions<TShared>);
+    protected configure(bind: interfaces.Bind, unbind: interfaces.Unbind, isBound: interfaces.IsBound, rebind: interfaces.Rebind): void;
+    /**
+     * Extension point for adopter-specific bindings (service-identifier
+     * carriers for the adopter's own language services).
+     * Default implementation is empty.
+     */
+    protected configureAdditionalBindings(_context: BindingContext): void;
+}
+//# sourceMappingURL=glsp-app-module.d.ts.map

package/lib/launcher/glsp-app-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glsp-app-module.d.ts","sourceRoot":"","sources":["../../src/launcher/glsp-app-module.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iDAAiD,CAAC;AACtF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,KAAK,gBAAgB,EAA+B,MAAM,qBAAqB,CAAC;AACzF,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,WAAW,CAAC;AAGxD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,6BAA6B,CAAC,OAAO,SAAS,oBAAoB,GAAG,oBAAoB;IACvG;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAEzB;;;;;;;;OAQG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CAC/C;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBACa,sBAAsB,CAAC,OAAO,SAAS,oBAAoB,GAAG,oBAAoB,CAAE,SAAQ,UAAU;IACpG,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,6BAA6B,CAAC,OAAO,CAAC;gBAA/C,OAAO,EAAE,6BAA6B,CAAC,OAAO,CAAC;cAI3D,SAAS,CACzB,IAAI,EAAE,UAAU,CAAC,IAAI,EACrB,MAAM,EAAE,UAAU,CAAC,MAAM,EACzB,OAAO,EAAE,UAAU,CAAC,OAAO,EAC3B,MAAM,EAAE,UAAU,CAAC,MAAM,GACzB,IAAI;IAMP;;;;OAIG;IACH,SAAS,CAAC,2BAA2B,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;CAGvE"}

package/lib/launcher/glsp-app-module.js

@@ -0,0 +1,71 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { GLSPModule } from '@eclipse-glsp/server';
+import { ReconcilingConflictResolver } from '@hydranium/protocol';
+import { injectable } from 'inversify';
+import { HydraniumTypes } from '../state/hydranium-shared-core-services.js';
+/**
+ * DI module that provides the framework-level Inversify bindings every
+ * `@hydranium/glsp-server` adopter needs. Pass instances (or instances of
+ * subclasses with additional bindings) into `startGlspServer`'s
+ * `appModules` array.
+ *
+ * Bindings provided:
+ *  - `HydraniumTypes.SharedCoreServices` (constant value)
+ *  - `HydraniumTypes.ConflictResolver` (constant value — `options.conflictResolver` or a default {@link ReconcilingConflictResolver})
+ *
+ * Both are language-independent, which is what makes them app-tier. The
+ * per-language providers (`ScopeProvider`, `CandidateProvider`) are bound one
+ * tier down by `AbstractHydraniumGlspDiagramModule`, from the grammar each
+ * diagram type declares.
+ *
+ * Concrete and usable as-is: adopters that need no extra bindings
+ * instantiate {@link HydraniumGlspAppModule} directly. Adopters that do
+ * subclass it and override {@link configureAdditionalBindings} to add their
+ * own service-identifier carriers.
+ *
+ * A conventional GLSP module (cf. `@eclipse-glsp/server`'s `GLSPModule`
+ * subclasses); the empty `configureAdditionalBindings` hook is the single
+ * extension point, so no separate abstract base is needed.
+ */
+let HydraniumGlspAppModule = class HydraniumGlspAppModule extends GLSPModule {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    configure(bind, unbind, isBound, rebind) {
+        bind(HydraniumTypes.SharedCoreServices).toConstantValue(this.options.shared);
+        bind(HydraniumTypes.ConflictResolver).toConstantValue(this.options.conflictResolver ?? new ReconcilingConflictResolver());
+        this.configureAdditionalBindings({ bind, unbind, isBound, rebind });
+    }
+    /**
+     * Extension point for adopter-specific bindings (service-identifier
+     * carriers for the adopter's own language services).
+     * Default implementation is empty.
+     */
+    configureAdditionalBindings(_context) {
+        // empty by default
+    }
+};
+HydraniumGlspAppModule = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Object])
+], HydraniumGlspAppModule);
+export { HydraniumGlspAppModule };
+//# sourceMappingURL=glsp-app-module.js.map

package/lib/launcher/glsp-app-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glsp-app-module.js","sourceRoot":"","sources":["../../src/launcher/glsp-app-module.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;;;;;;;;;;AAElF,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAGlD,OAAO,EAAyB,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AACzF,OAAO,EAAE,UAAU,EAAmB,MAAM,WAAW,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,4CAA4C,CAAC;AA0C5E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEI,IAAM,sBAAsB,GAA5B,MAAM,sBAAoF,SAAQ,UAAU;IACjF;IAA/B,YAA+B,OAA+C;QAC3E,KAAK,EAAE,CAAC;QADoB,YAAO,GAAP,OAAO,CAAwC;IAE9E,CAAC;IAEkB,SAAS,CACzB,IAAqB,EACrB,MAAyB,EACzB,OAA2B,EAC3B,MAAyB;QAEzB,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAC7E,IAAI,CAAC,cAAc,CAAC,gBAAgB,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,gBAAgB,IAAI,IAAI,2BAA2B,EAAE,CAAC,CAAC;QAC1H,IAAI,CAAC,2BAA2B,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;IACvE,CAAC;IAED;;;;OAIG;IACO,2BAA2B,CAAC,QAAwB;QAC3D,mBAAmB;IACtB,CAAC;CACH,CAAA;AAxBY,sBAAsB;IADlC,UAAU,EAAE;;GACA,sBAAsB,CAwBlC"}

package/lib/launcher/glsp-framework-overrides.d.ts

@@ -0,0 +1,32 @@
+/********************************************************************************
+ * 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 { Logger as GlspLogger } from '@eclipse-glsp/server';
+import { ContainerModule } from 'inversify';
+/**
+ * The framework bindings layered on top of GLSP's own app module, shared by
+ * every bringup regardless of transport.
+ *
+ * Two things happen here. GLSP's `Logger` / `LoggerFactory` are replaced with
+ * the adopter's — unbind-then-bind, the same pattern `createAppModule` uses
+ * internally — so GLSP server logs leave through the adopter's sink rather than
+ * a console the host may not own. And `HydraniumTypes.Tracer` is added,
+ * caller-tagged the same way the logger is, so an injected tracer's timing lines
+ * carry the requesting class's component without every call site naming itself.
+ *
+ * **Shared rather than written once per launcher, because the two would drift
+ * silently.** A transport-specific copy that fell behind would still bind
+ * something for each symbol, so nothing would fail — the head would merely log
+ * or trace differently depending on how it was started, which no test asks
+ * about.
+ *
+ * `createLogger` is called once per Inversify resolution, with `caller` set to
+ * the requesting parent's class name, and once per `LoggerFactory` invocation.
+ */
+export declare function createGlspFrameworkOverrides(createLogger: (caller?: string) => GlspLogger): ContainerModule;
+//# sourceMappingURL=glsp-framework-overrides.d.ts.map

package/lib/launcher/glsp-framework-overrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glsp-framework-overrides.d.ts","sourceRoot":"","sources":["../../src/launcher/glsp-framework-overrides.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,MAAM,IAAI,UAAU,EAAuC,MAAM,sBAAsB,CAAC;AACjG,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAI5C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,4BAA4B,CAAC,YAAY,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,UAAU,GAAG,eAAe,CAgB3G"}

package/lib/launcher/glsp-framework-overrides.js

@@ -0,0 +1,49 @@
+/********************************************************************************
+ * 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 { Logger as GlspLogger, LoggerFactory, getRequestParentName } from '@eclipse-glsp/server';
+import { ContainerModule } from 'inversify';
+import { HydraniumTypes } from '../state/hydranium-shared-core-services.js';
+/**
+ * The framework bindings layered on top of GLSP's own app module, shared by
+ * every bringup regardless of transport.
+ *
+ * Two things happen here. GLSP's `Logger` / `LoggerFactory` are replaced with
+ * the adopter's — unbind-then-bind, the same pattern `createAppModule` uses
+ * internally — so GLSP server logs leave through the adopter's sink rather than
+ * a console the host may not own. And `HydraniumTypes.Tracer` is added,
+ * caller-tagged the same way the logger is, so an injected tracer's timing lines
+ * carry the requesting class's component without every call site naming itself.
+ *
+ * **Shared rather than written once per launcher, because the two would drift
+ * silently.** A transport-specific copy that fell behind would still bind
+ * something for each symbol, so nothing would fail — the head would merely log
+ * or trace differently depending on how it was started, which no test asks
+ * about.
+ *
+ * `createLogger` is called once per Inversify resolution, with `caller` set to
+ * the requesting parent's class name, and once per `LoggerFactory` invocation.
+ */
+export function createGlspFrameworkOverrides(createLogger) {
+    return new ContainerModule((bind, unbind, isBound) => {
+        if (isBound(GlspLogger)) {
+            unbind(GlspLogger);
+        }
+        if (isBound(LoggerFactory)) {
+            unbind(LoggerFactory);
+        }
+        bind(GlspLogger).toDynamicValue(ctx => createLogger(getRequestParentName(ctx)));
+        bind(LoggerFactory).toFactory(() => (caller) => createLogger(caller));
+        bind(HydraniumTypes.Tracer).toDynamicValue(ctx => {
+            const tracer = ctx.container.get(HydraniumTypes.SharedCoreServices).Tracer;
+            const caller = getRequestParentName(ctx);
+            return caller ? tracer.for(caller) : tracer;
+        });
+    });
+}
+//# sourceMappingURL=glsp-framework-overrides.js.map

package/lib/launcher/glsp-framework-overrides.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glsp-framework-overrides.js","sourceRoot":"","sources":["../../src/launcher/glsp-framework-overrides.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,MAAM,IAAI,UAAU,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjG,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C,OAAO,EAAE,cAAc,EAAE,MAAM,4CAA4C,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,4BAA4B,CAAC,YAA6C;IACvF,OAAO,IAAI,eAAe,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE;QAClD,IAAI,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;YACvB,MAAM,CAAC,UAAU,CAAC,CAAC;QACtB,CAAC;QACD,IAAI,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC;YAC1B,MAAM,CAAC,aAAa,CAAC,CAAC;QACzB,CAAC;QACD,IAAI,CAAC,UAAU,CAAC,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC,YAAY,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAChF,IAAI,CAAC,aAAa,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,CAAC,MAAc,EAAE,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;QAC9E,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE;YAC9C,MAAM,MAAM,GAAG,GAAG,CAAC,SAAS,CAAC,GAAG,CAAuB,cAAc,CAAC,kBAAkB,CAAC,CAAC,MAAM,CAAC;YACjG,MAAM,MAAM,GAAG,oBAAoB,CAAC,GAAG,CAAC,CAAC;YACzC,OAAO,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QAC/C,CAAC,CAAC,CAAC;IACN,CAAC,CAAC,CAAC;AACN,CAAC"}

package/lib/launcher/glsp-server-overrides.d.ts

@@ -0,0 +1,39 @@
+/********************************************************************************
+ * 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 { ContainerModule } from 'inversify';
+/**
+ * The framework bindings layered on top of the adopter's `ServerModule`, in the
+ * SERVER container — one per connected application, a child of the app
+ * container every bringup composes.
+ *
+ * **The tier matters, and the app container cannot stand in for it.** GLSP's
+ * launcher creates the server container as a child and loads the adopter's
+ * `ServerModule` into it, so a `GLSPServer` binding made further up is shadowed
+ * rather than consulted, and inversify refuses to rebind a parent's binding
+ * from a child at all. The framework's app-tier overrides therefore cannot
+ * reach this symbol.
+ *
+ * **Load this AFTER the adopter's `ServerModule`, never beside it.** Both bind
+ * `GLSPServer`, so a plain second binding resolves to an ambiguous-match error
+ * rather than to either one; `rebind` needs the first binding to already be
+ * present.
+ *
+ * Keeping this out of the adopter's hands is the point: an adopter passes their
+ * own `ServerModule` in, so anything they must add themselves is a fix the
+ * adopters who most need it will not have.
+ *
+ * **It also decides what GLSP's own log lines are tagged with.** GLSP resolves
+ * a logger per injecting class and labels it with the bound implementation's
+ * name, so every line upstream's server logs carries
+ * {@link HydraniumGlspServer} rather than `DefaultGLSPServer`. Anything keyed
+ * on that label — a log filter, an assertion — reads the class bound here, and
+ * a further adopter subclass moves it again.
+ */
+export declare function createGlspServerOverrides(): ContainerModule;
+//# sourceMappingURL=glsp-server-overrides.d.ts.map

package/lib/launcher/glsp-server-overrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glsp-server-overrides.d.ts","sourceRoot":"","sources":["../../src/launcher/glsp-server-overrides.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAGlF,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAG5C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,yBAAyB,IAAI,eAAe,CAI3D"}

package/lib/launcher/glsp-server-overrides.js

@@ -0,0 +1,45 @@
+/********************************************************************************
+ * 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 { GLSPServer } from '@eclipse-glsp/server';
+import { ContainerModule } from 'inversify';
+import { HydraniumGlspServer } from './hydranium-glsp-server.js';
+/**
+ * The framework bindings layered on top of the adopter's `ServerModule`, in the
+ * SERVER container — one per connected application, a child of the app
+ * container every bringup composes.
+ *
+ * **The tier matters, and the app container cannot stand in for it.** GLSP's
+ * launcher creates the server container as a child and loads the adopter's
+ * `ServerModule` into it, so a `GLSPServer` binding made further up is shadowed
+ * rather than consulted, and inversify refuses to rebind a parent's binding
+ * from a child at all. The framework's app-tier overrides therefore cannot
+ * reach this symbol.
+ *
+ * **Load this AFTER the adopter's `ServerModule`, never beside it.** Both bind
+ * `GLSPServer`, so a plain second binding resolves to an ambiguous-match error
+ * rather than to either one; `rebind` needs the first binding to already be
+ * present.
+ *
+ * Keeping this out of the adopter's hands is the point: an adopter passes their
+ * own `ServerModule` in, so anything they must add themselves is a fix the
+ * adopters who most need it will not have.
+ *
+ * **It also decides what GLSP's own log lines are tagged with.** GLSP resolves
+ * a logger per injecting class and labels it with the bound implementation's
+ * name, so every line upstream's server logs carries
+ * {@link HydraniumGlspServer} rather than `DefaultGLSPServer`. Anything keyed
+ * on that label — a log filter, an assertion — reads the class bound here, and
+ * a further adopter subclass moves it again.
+ */
+export function createGlspServerOverrides() {
+    return new ContainerModule((_bind, _unbind, _isBound, rebind) => {
+        rebind(GLSPServer).to(HydraniumGlspServer).inSingletonScope();
+    });
+}
+//# sourceMappingURL=glsp-server-overrides.js.map

package/lib/launcher/glsp-server-overrides.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glsp-server-overrides.js","sourceRoot":"","sources":["../../src/launcher/glsp-server-overrides.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,yBAAyB;IACtC,OAAO,IAAI,eAAe,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE;QAC7D,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,mBAAmB,CAAC,CAAC,gBAAgB,EAAE,CAAC;IACjE,CAAC,CAAC,CAAC;AACN,CAAC"}

package/lib/launcher/hydranium-glsp-server.d.ts

@@ -0,0 +1,62 @@
+/********************************************************************************
+ * 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 ClientSession, DefaultGLSPServer, type RequestAction, type ResponseAction } from '@eclipse-glsp/server';
+/**
+ * The GLSP server the framework binds in place of upstream's
+ * {@link DefaultGLSPServer}, so a failed REQUEST reaches its reader with the
+ * text the thrower wrote.
+ *
+ * **What breaks without it.** Upstream projects a failing request's detail as
+ * `error.cause?.toString()` whenever the error is a {@link GLSPServerError},
+ * and that one value feeds both the server log and the client's
+ * {@link RejectAction}. A {@link GLSPServerError} carrying no `cause` therefore
+ * reaches no reader at all — not the toast, not the details pane, not the log —
+ * while a plain `Error` survives, because the other branch reads the error
+ * itself. The typed error is the trap, and it is the one upstream's own
+ * `getOrThrow` helper raises: that helper's signature cannot pass a `cause`, so
+ * an adopter using the sanctioned helper has no fix available on their side.
+ * Restating the cause at each throw site is the alternative, and it costs
+ * every adopter a rule they must know and cannot apply to `getOrThrow`.
+ *
+ * Only the REQUEST path needs this. Non-request actions fail through
+ * upstream's `handleProcessError`, which reads `message` directly.
+ *
+ * Adopters who bind their own GLSP server should extend this class rather than
+ * {@link DefaultGLSPServer}; the framework's server-container override replaces
+ * whatever the adopter's `ServerModule` bound, so a subclass of upstream's
+ * server would be discarded.
+ */
+export declare class HydraniumGlspServer extends DefaultGLSPServer {
+    /**
+     * The detail projected into the client's {@link RejectAction} and the server
+     * log when a request fails.
+     *
+     * A {@link GLSPServerError} with no `cause` falls back to its `message`; a
+     * nullish `cause` counts as absent, matching the optional chaining upstream
+     * applies. Anything else stringifies as upstream does, so a plain `Error`
+     * keeps its `"Error: …"` prefix and callers that match on it still match.
+     */
+    protected requestFailureDetail(error: unknown): string | undefined;
+    /**
+     * Lifted verbatim from `@eclipse-glsp/server` 2.7.0's
+     * {@link DefaultGLSPServer.handleClientRequest}, with the detail computation
+     * delegated to {@link requestFailureDetail}. Nothing else here — the
+     * timeout branch, the response dispatch, the nested send-failure handling —
+     * relates to that fallback.
+     *
+     * **This body does not track upstream.** A release that changes request
+     * handling would silently not apply, on the path every request takes. There
+     * is no narrower seam to override: upstream computes the detail inline. The
+     * accompanying test pins upstream's own source for this method, so a bump
+     * that changes it fails rather than diverging quietly; re-lift the body when
+     * it does.
+     */
+    protected handleClientRequest(clientSession: ClientSession, action: RequestAction<ResponseAction>, clientId: string): Promise<void>;
+}
+//# sourceMappingURL=hydranium-glsp-server.d.ts.map

package/lib/launcher/hydranium-glsp-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydranium-glsp-server.d.ts","sourceRoot":"","sources":["../../src/launcher/hydranium-glsp-server.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EACJ,KAAK,aAAa,EAClB,iBAAiB,EAGjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACrB,MAAM,sBAAsB,CAAC;AAG9B;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBACa,mBAAoB,SAAQ,iBAAiB;IACvD;;;;;;;;OAQG;IACH,SAAS,CAAC,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS;IAOlE;;;;;;;;;;;;;OAaG;cACsB,mBAAmB,CACzC,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,aAAa,CAAC,cAAc,CAAC,EACrC,QAAQ,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC;CAuBlB"}