@hydranium/glsp-client 0.0.0-stage → 1.0.0-next

package/lib/diagram-loader.d.ts

@@ -0,0 +1,124 @@
+/********************************************************************************
+ * 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 { DiagramLoader, type DiagramLoadingOptions } from '@eclipse-glsp/client';
+import { Deferred, type Logger } from '@hydranium/protocol';
+/**
+ * How a diagram load ended. A discriminated union rather than a boolean or a
+ * string: a consumer showing a pending indicator has to distinguish "not settled
+ * yet" (`undefined`) from either terminal state, and the failed arm has to carry
+ * enough for that consumer to decide whether *it* is now the only thing that can
+ * report the failure — see {@link DiagramLoadFailure.surfaced}.
+ */
+export type DiagramLoadOutcome = DiagramLoadSuccess | DiagramLoadFailure;
+export interface DiagramLoadSuccess {
+    readonly status: 'loaded';
+}
+export interface DiagramLoadFailure {
+    readonly status: 'failed';
+    /** The thrown value, verbatim. `unknown` because a rejection can be anything. */
+    readonly error: unknown;
+    /**
+     * Whether the `severity: 'ERROR'` {@link StatusAction} reached the action
+     * dispatcher. It says nothing about whether a status overlay shows it.
+     *
+     * `false` means the report itself failed, which happens when the action
+     * dispatcher is the thing that could not initialize. A consumer that covers
+     * the canvas must then render the failure itself: it is the only surface
+     * left, and removing its overlay would leave a blank diagram whose only
+     * explanation is a line in the log — the exact failure mode this loader
+     * exists to prevent.
+     */
+    readonly surfaced: boolean;
+}
+/**
+ * Diagram loader that never lets a load failure vanish.
+ *
+ * `DiagramLoader.load()` orchestrates the full diagram-init path — action
+ * dispatcher init, GLSP-client connect + server `initialize`, the first
+ * `RequestModelAction`, and the model-initialization constraint. Of these only
+ * the `IDiagramStartup` hooks are wrapped by the base loader (it logs them to
+ * `console.error`); the dispatcher-init / connection / request-model steps are
+ * not. The Theia widget that drives loading
+ * (`@eclipse-glsp/theia-integration`'s `GLSPDiagramWidget.onAfterAttach`)
+ * calls `load()` *without awaiting or catching it*, so any rejection becomes an
+ * uncaught promise rejection visible only in the browser devtools console —
+ * nothing reaches the e2e output, the server log, or a Theia log sink, and the
+ * diagram just stays blank.
+ *
+ * This subclass closes that gap: it catches every load failure, routes it to
+ * the host's logger (in Theia the Output channel the server log and action
+ * traffic share, so it is discoverable where a developer already looks), and
+ * surfaces a persistent error to the user via a `severity: 'ERROR'`
+ * {@link StatusAction} on the diagram's status overlay. It deliberately does
+ * **not** rethrow — the caller drops the promise, so rethrowing would only
+ * reproduce the uncaught rejection this exists to prevent.
+ *
+ * It also publishes the load's terminal state ({@link loadOutcome} /
+ * {@link onceLoadSettled}) so a pending indicator has one authority to key on.
+ * The Theia diagram widget uses it to cover the canvas while loading; see
+ * {@link settle} for why the signal cannot be derived from the error
+ * `StatusAction` instead.
+ *
+ * Bound by `createGlspClientModule` via `rebind(DiagramLoader)`.
+ */
+export declare class HydraniumDiagramLoader extends DiagramLoader {
+    protected readonly hydraniumLogger: Logger;
+    protected readonly settled: Deferred<DiagramLoadOutcome>;
+    protected outcome?: DiagramLoadOutcome;
+    /** Terminal state of the load, or `undefined` while it is still in flight.
+     *  The synchronous companion of {@link onceLoadSettled}, for a consumer that
+     *  must decide something in the same tick (e.g. whether to show an indicator
+     *  at all when re-attaching an already-loaded diagram). */
+    get loadOutcome(): DiagramLoadOutcome | undefined;
+    /** Resolves once the load reaches a terminal state — on success **and** on
+     *  failure, so a caller awaiting it cannot hang. Never rejects. */
+    onceLoadSettled(): Promise<DiagramLoadOutcome>;
+    load(options?: DiagramLoadingOptions): Promise<void>;
+    /**
+     * Record the terminal state and release {@link onceLoadSettled}. Idempotent —
+     * the first outcome wins, so a reload cannot flip a settled indicator.
+     *
+     * This runs unconditionally after {@link reportLoadFailure}, *including* when
+     * the status dispatch inside it threw. That is the load-bearing property: when
+     * the action dispatcher is itself the thing that failed to initialize — the
+     * exact failure this class exists for — no `StatusAction` ever lands, so a
+     * consumer observing actions would wait forever. Settling here means a pending
+     * indicator always comes down, and `surfaced: false` tells that consumer it is
+     * now the only thing that can report the failure.
+     */
+    protected settle(outcome: DiagramLoadOutcome): void;
+    /**
+     * Route a diagram-load failure to the host's logger and the status overlay.
+     * The status dispatch is itself guarded: when the action dispatcher is the
+     * thing that failed to initialize, dispatching may throw too, and a failure
+     * to *report* the failure must not re-escape as an uncaught rejection.
+     *
+     * @returns whether the `StatusAction` reached the dispatcher — i.e. whether the
+     * user can see this failure on the diagram. The log line always happens, so
+     * the return value is specifically about the *user-visible* report; a `false`
+     * makes {@link DiagramLoadFailure.surfaced} false and hands the job to whoever
+     * is covering the canvas.
+     */
+    protected reportLoadFailure(err: unknown): Promise<boolean>;
+    /**
+     * The sentence a failed load is reported with, on every surface that reports
+     * it. Public because the canvas overlay is one of those surfaces and lives in
+     * another class, where a second copy of the sentence would drift.
+     *
+     * English, formatted from {@link DIAGRAM_LOAD_FAILED}: this tier knows no
+     * locale. A host that does renders the code through its own mechanism by
+     * overriding this method, so every surface, the log line included, carries
+     * the one sentence the user reads.
+     */
+    loadFailureLabel(err: unknown): string;
+    /** Render a thrown value as a message. Shared so the log line, the status
+     *  overlay and any consumer rendering {@link DiagramLoadFailure.error} agree. */
+    protected formatError(err: unknown): string;
+}
+//# sourceMappingURL=diagram-loader.d.ts.map

package/lib/diagram-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagram-loader.d.ts","sourceRoot":"","sources":["../src/diagram-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,aAAa,EAAE,KAAK,qBAAqB,EAAgB,MAAM,sBAAsB,CAAC;AAC/F,OAAO,EAAE,QAAQ,EAAiB,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAK3E;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG,kBAAkB,GAAG,kBAAkB,CAAC;AAEzE,MAAM,WAAW,kBAAkB;IAChC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;CAC5B;AAED,MAAM,WAAW,kBAAkB;IAChC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,iFAAiF;IACjF,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBACa,sBAAuB,SAAQ,aAAa;IACjB,SAAS,CAAC,QAAQ,CAAC,eAAe,EAAG,MAAM,CAAC;IAEjF,SAAS,CAAC,QAAQ,CAAC,OAAO,+BAAsC;IAChE,SAAS,CAAC,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAEvC;;;+DAG2D;IAC3D,IAAI,WAAW,IAAI,kBAAkB,GAAG,SAAS,CAEhD;IAED;uEACmE;IACnE,eAAe,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAE7C;IAEc,IAAI,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CASlE;IAED;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,MAAM,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAMlD;IAED;;;;;;;;;;;OAWG;IACH,UAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAUhE;IAED;;;;;;;;;OASG;IACH,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAErC;IAED;qFACiF;IACjF,SAAS,CAAC,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAE1C;CACH"}

package/lib/diagram-loader.js

@@ -0,0 +1,154 @@
+"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
+ ********************************************************************************/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HydraniumDiagramLoader = void 0;
+const client_1 = require("@eclipse-glsp/client");
+const protocol_1 = require("@hydranium/protocol");
+const inversify_1 = require("inversify");
+const diagram_load_failed_1 = require("./diagram-load-failed");
+const types_1 = require("./types");
+/**
+ * Diagram loader that never lets a load failure vanish.
+ *
+ * `DiagramLoader.load()` orchestrates the full diagram-init path — action
+ * dispatcher init, GLSP-client connect + server `initialize`, the first
+ * `RequestModelAction`, and the model-initialization constraint. Of these only
+ * the `IDiagramStartup` hooks are wrapped by the base loader (it logs them to
+ * `console.error`); the dispatcher-init / connection / request-model steps are
+ * not. The Theia widget that drives loading
+ * (`@eclipse-glsp/theia-integration`'s `GLSPDiagramWidget.onAfterAttach`)
+ * calls `load()` *without awaiting or catching it*, so any rejection becomes an
+ * uncaught promise rejection visible only in the browser devtools console —
+ * nothing reaches the e2e output, the server log, or a Theia log sink, and the
+ * diagram just stays blank.
+ *
+ * This subclass closes that gap: it catches every load failure, routes it to
+ * the host's logger (in Theia the Output channel the server log and action
+ * traffic share, so it is discoverable where a developer already looks), and
+ * surfaces a persistent error to the user via a `severity: 'ERROR'`
+ * {@link StatusAction} on the diagram's status overlay. It deliberately does
+ * **not** rethrow — the caller drops the promise, so rethrowing would only
+ * reproduce the uncaught rejection this exists to prevent.
+ *
+ * It also publishes the load's terminal state ({@link loadOutcome} /
+ * {@link onceLoadSettled}) so a pending indicator has one authority to key on.
+ * The Theia diagram widget uses it to cover the canvas while loading; see
+ * {@link settle} for why the signal cannot be derived from the error
+ * `StatusAction` instead.
+ *
+ * Bound by `createGlspClientModule` via `rebind(DiagramLoader)`.
+ */
+let HydraniumDiagramLoader = class HydraniumDiagramLoader extends client_1.DiagramLoader {
+    hydraniumLogger;
+    settled = new protocol_1.Deferred();
+    outcome;
+    /** Terminal state of the load, or `undefined` while it is still in flight.
+     *  The synchronous companion of {@link onceLoadSettled}, for a consumer that
+     *  must decide something in the same tick (e.g. whether to show an indicator
+     *  at all when re-attaching an already-loaded diagram). */
+    get loadOutcome() {
+        return this.outcome;
+    }
+    /** Resolves once the load reaches a terminal state — on success **and** on
+     *  failure, so a caller awaiting it cannot hang. Never rejects. */
+    onceLoadSettled() {
+        return this.settled.promise;
+    }
+    async load(options) {
+        try {
+            await super.load(options);
+            this.settle({ status: 'loaded' });
+        }
+        catch (err) {
+            // Report first, settle second, and carry whether the report landed.
+            const surfaced = await this.reportLoadFailure(err);
+            this.settle({ status: 'failed', error: err, surfaced });
+        }
+    }
+    /**
+     * Record the terminal state and release {@link onceLoadSettled}. Idempotent —
+     * the first outcome wins, so a reload cannot flip a settled indicator.
+     *
+     * This runs unconditionally after {@link reportLoadFailure}, *including* when
+     * the status dispatch inside it threw. That is the load-bearing property: when
+     * the action dispatcher is itself the thing that failed to initialize — the
+     * exact failure this class exists for — no `StatusAction` ever lands, so a
+     * consumer observing actions would wait forever. Settling here means a pending
+     * indicator always comes down, and `surfaced: false` tells that consumer it is
+     * now the only thing that can report the failure.
+     */
+    settle(outcome) {
+        if (this.outcome !== undefined) {
+            return;
+        }
+        this.outcome = outcome;
+        this.settled.resolve(outcome);
+    }
+    /**
+     * Route a diagram-load failure to the host's logger and the status overlay.
+     * The status dispatch is itself guarded: when the action dispatcher is the
+     * thing that failed to initialize, dispatching may throw too, and a failure
+     * to *report* the failure must not re-escape as an uncaught rejection.
+     *
+     * @returns whether the `StatusAction` reached the dispatcher — i.e. whether the
+     * user can see this failure on the diagram. The log line always happens, so
+     * the return value is specifically about the *user-visible* report; a `false`
+     * makes {@link DiagramLoadFailure.surfaced} false and hands the job to whoever
+     * is covering the canvas.
+     */
+    async reportLoadFailure(err) {
+        const label = this.loadFailureLabel(err);
+        this.hydraniumLogger.error(label, err);
+        try {
+            await this.actionDispatcher.dispatch(client_1.StatusAction.create(label, { severity: 'ERROR' }));
+            return true;
+        }
+        catch (statusErr) {
+            this.hydraniumLogger.error('Failed to surface the diagram-load failure on the status overlay', statusErr);
+            return false;
+        }
+    }
+    /**
+     * The sentence a failed load is reported with, on every surface that reports
+     * it. Public because the canvas overlay is one of those surfaces and lives in
+     * another class, where a second copy of the sentence would drift.
+     *
+     * English, formatted from {@link DIAGRAM_LOAD_FAILED}: this tier knows no
+     * locale. A host that does renders the code through its own mechanism by
+     * overriding this method, so every surface, the log line included, carries
+     * the one sentence the user reads.
+     */
+    loadFailureLabel(err) {
+        return diagram_load_failed_1.DIAGRAM_LOAD_FAILED.format({ reason: this.formatError(err) });
+    }
+    /** Render a thrown value as a message. Shared so the log line, the status
+     *  overlay and any consumer rendering {@link DiagramLoadFailure.error} agree. */
+    formatError(err) {
+        return (0, protocol_1.describeError)(err);
+    }
+};
+exports.HydraniumDiagramLoader = HydraniumDiagramLoader;
+__decorate([
+    (0, inversify_1.inject)(types_1.HydraniumClientTypes.Logger),
+    __metadata("design:type", Object)
+], HydraniumDiagramLoader.prototype, "hydraniumLogger", void 0);
+exports.HydraniumDiagramLoader = HydraniumDiagramLoader = __decorate([
+    (0, inversify_1.injectable)()
+], HydraniumDiagramLoader);
+//# sourceMappingURL=diagram-loader.js.map

package/lib/diagram-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagram-loader.js","sourceRoot":"","sources":["../src/diagram-loader.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;;;;;;;;;;AAElF,iDAA+F;AAC/F,kDAA2E;AAC3E,yCAA+C;AAC/C,+DAA4D;AAC5D,mCAA+C;AAiC/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEI,IAAM,sBAAsB,GAA5B,MAAM,sBAAuB,SAAQ,sBAAa;IACE,eAAe,CAAU;IAE9D,OAAO,GAAG,IAAI,mBAAQ,EAAsB,CAAC;IACtD,OAAO,CAAsB;IAEvC;;;+DAG2D;IAC3D,IAAI,WAAW;QACZ,OAAO,IAAI,CAAC,OAAO,CAAC;IACvB,CAAC;IAED;uEACmE;IACnE,eAAe;QACZ,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;IAC/B,CAAC;IAEQ,KAAK,CAAC,IAAI,CAAC,OAA+B;QAChD,IAAI,CAAC;YACF,MAAM,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC1B,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;QACrC,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACZ,oEAAoE;YACpE,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;YACnD,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC3D,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;OAWG;IACO,MAAM,CAAC,OAA2B;QACzC,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAC9B,OAAO;QACV,CAAC;QACD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACjC,CAAC;IAED;;;;;;;;;;;OAWG;IACO,KAAK,CAAC,iBAAiB,CAAC,GAAY;QAC3C,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QACzC,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QACvC,IAAI,CAAC;YACF,MAAM,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,qBAAY,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;YACxF,OAAO,IAAI,CAAC;QACf,CAAC;QAAC,OAAO,SAAS,EAAE,CAAC;YAClB,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,kEAAkE,EAAE,SAAS,CAAC,CAAC;YAC1G,OAAO,KAAK,CAAC;QAChB,CAAC;IACJ,CAAC;IAED;;;;;;;;;OASG;IACH,gBAAgB,CAAC,GAAY;QAC1B,OAAO,yCAAmB,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACxE,CAAC;IAED;qFACiF;IACvE,WAAW,CAAC,GAAY;QAC/B,OAAO,IAAA,wBAAa,EAAC,GAAG,CAAC,CAAC;IAC7B,CAAC;CACH,CAAA;;AA7F0D;IAAvD,IAAA,kBAAM,EAAC,4BAAoB,CAAC,MAAM,CAAC;;+DAA6C;iCADvE,sBAAsB;IADlC,IAAA,sBAAU,GAAE;GACA,sBAAsB,CA8FlC"}

package/lib/edge.d.ts

@@ -0,0 +1,40 @@
+/********************************************************************************
+ * 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 BindingContext, type Bounds, GEdge, type Point } from '@eclipse-glsp/client';
+/**
+ * GLSP's edge, with an empty route transforming its children through the
+ * origin.
+ *
+ * `GEdge` offsets a child by the bounds of its routing points, and sprotty's
+ * `getRouteBounds` answers `NaN` for an empty route, which an edge without
+ * bendpoints always has. An edge label's bounds then come out `NaN`, and a
+ * fit-to-screen over every element lands the viewport at `translate(NaN,NaN)`,
+ * where every shape fails its visibility check and the canvas goes blank.
+ *
+ * Register your own edge types with this class in place of `GEdge`; sprotty
+ * fixes a type's class when it is registered, so an edge type registered with
+ * `GEdge` keeps the defect. Patching `GEdge`'s prototype would reach those
+ * types too, and is not done: it is no extension point of GLSP's.
+ */
+export declare class HydraniumGEdge extends GEdge {
+    localToParent(point: Point | Bounds): Bounds;
+    parentToLocal(point: Point | Bounds): Bounds;
+}
+/**
+ * GLSP's default model elements, with `DefaultTypes.EDGE` built as a
+ * {@link HydraniumGEdge}.
+ *
+ * Call it from your diagram module in place of GLSP's
+ * `configureDefaultModelElements`. The replacement cannot come from the
+ * binder: a diagram module is loaded after the host's, and GLSP's model
+ * registry gives a type to whichever registration came last, so a replacement
+ * bound before the defaults is the one overwritten.
+ */
+export declare function configureHydraniumModelElements(context: Pick<BindingContext, 'bind' | 'isBound'>): void;
+//# sourceMappingURL=edge.d.ts.map

package/lib/edge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge.d.ts","sourceRoot":"","sources":["../src/edge.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EACJ,KAAK,cAAc,EACnB,KAAK,MAAM,EAGX,KAAK,EAIL,KAAK,KAAK,EACZ,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;GAcG;AACH,qBAAa,cAAe,SAAQ,KAAK;IAC7B,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAEpD;IAEQ,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAEpD;CACH;AAOD;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG,IAAI,CAGvG"}

package/lib/edge.js

@@ -0,0 +1,56 @@
+"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.HydraniumGEdge = void 0;
+exports.configureHydraniumModelElements = configureHydraniumModelElements;
+const client_1 = require("@eclipse-glsp/client");
+/**
+ * GLSP's edge, with an empty route transforming its children through the
+ * origin.
+ *
+ * `GEdge` offsets a child by the bounds of its routing points, and sprotty's
+ * `getRouteBounds` answers `NaN` for an empty route, which an edge without
+ * bendpoints always has. An edge label's bounds then come out `NaN`, and a
+ * fit-to-screen over every element lands the viewport at `translate(NaN,NaN)`,
+ * where every shape fails its visibility check and the canvas goes blank.
+ *
+ * Register your own edge types with this class in place of `GEdge`; sprotty
+ * fixes a type's class when it is registered, so an edge type registered with
+ * `GEdge` keeps the defect. Patching `GEdge`'s prototype would reach those
+ * types too, and is not done: it is no extension point of GLSP's.
+ */
+class HydraniumGEdge extends client_1.GEdge {
+    localToParent(point) {
+        return this.routingPoints.length === 0 ? asBounds(point) : super.localToParent(point);
+    }
+    parentToLocal(point) {
+        return this.routingPoints.length === 0 ? asBounds(point) : super.parentToLocal(point);
+    }
+}
+exports.HydraniumGEdge = HydraniumGEdge;
+/** The shape `GEdge` returns: a point gains the size `-1`, bounds keep theirs. */
+function asBounds(point) {
+    return { x: point.x, y: point.y, width: (0, client_1.isBounds)(point) ? point.width : -1, height: (0, client_1.isBounds)(point) ? point.height : -1 };
+}
+/**
+ * GLSP's default model elements, with `DefaultTypes.EDGE` built as a
+ * {@link HydraniumGEdge}.
+ *
+ * Call it from your diagram module in place of GLSP's
+ * `configureDefaultModelElements`. The replacement cannot come from the
+ * binder: a diagram module is loaded after the host's, and GLSP's model
+ * registry gives a type to whichever registration came last, so a replacement
+ * bound before the defaults is the one overwritten.
+ */
+function configureHydraniumModelElements(context) {
+    (0, client_1.configureDefaultModelElements)(context);
+    (0, client_1.overrideModelElement)(context, client_1.DefaultTypes.EDGE, HydraniumGEdge, client_1.GEdgeView);
+}
+//# sourceMappingURL=edge.js.map

package/lib/edge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge.js","sourceRoot":"","sources":["../src/edge.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;;AAElF,iDAU8B;AAE9B;;;;;;;;;;;;;;GAcG;AACH,oBAA4B,SAAQ,cAAK;IAC7B,aAAa,CAAC,KAAqB;QACzC,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;IACzF,CAAC;IAEQ,aAAa,CAAC,KAAqB;QACzC,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;IACzF,CAAC;CACH;;AAED,kFAAkF;AAClF,SAAS,QAAQ,CAAC,KAAqB;IACpC,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,IAAA,iBAAQ,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,IAAA,iBAAQ,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AAC7H,CAAC;AAED;;;;;;;;;GASG;AACH,yCAAgD,OAAiD;IAC9F,IAAA,sCAA6B,EAAC,OAAO,CAAC,CAAC;IACvC,IAAA,6BAAoB,EAAC,OAAO,EAAE,qBAAY,CAAC,IAAI,EAAE,cAAc,EAAE,kBAAS,CAAC,CAAC;AAC/E,CAAC"}

package/lib/glsp-client-module.d.ts

@@ -0,0 +1,36 @@
+/********************************************************************************
+ * 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 BindingContext } from '@eclipse-glsp/client';
+import { type Logger } from '@hydranium/protocol';
+/** Options for {@link createGlspClientModule}. */
+export interface GlspClientModuleOptions {
+    /** The host's logger, bound on `HydraniumClientTypes.Logger` in place of any
+     *  binding the host made. Absent, the token keeps the host's own binding, or
+     *  gets a `ConsoleLogger` when it has none. */
+    readonly logger?: Logger;
+}
+/**
+ * Binds the framework's client classes into a GLSP diagram container, whatever
+ * hosts it: the instrumented action dispatcher, the failure-reporting diagram
+ * loader, the route-repairing hidden-bounds updater, the status overlay that
+ * stays on the page, and a sprotty logger that reports through the host's.
+ *
+ * Call it from the module a host adds AFTER GLSP's defaults, since every class
+ * here replaces a token those defaults bind; `rebind` on an unbound token
+ * throws. A host that wants one GLSP default back rebinds that token after
+ * this call, the same one-line move this function makes.
+ *
+ * The logger and tracer tokens are bound only when the host has not bound
+ * them, so a host with a richer logger binds `HydraniumClientTypes.Logger`
+ * first and passes no option. The tracer composes the bound logger and clock.
+ * Bind the tokens in the container this runs in: `isBound` sees a parent
+ * container's binding, which `rebind` cannot replace.
+ */
+export declare function createGlspClientModule(context: BindingContext, options?: GlspClientModuleOptions): void;
+//# sourceMappingURL=glsp-client-module.d.ts.map

package/lib/glsp-client-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glsp-client-module.d.ts","sourceRoot":"","sources":["../src/glsp-client-module.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EACJ,KAAK,cAAc,EAMrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAA4C,KAAK,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAQzG,kDAAkD;AAClD,MAAM,WAAW,uBAAuB;IACrC;;mDAE+C;IAC/C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,GAAE,uBAA4B,GAAG,IAAI,CAwB3G"}

package/lib/glsp-client-module.js

@@ -0,0 +1,63 @@
+"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.createGlspClientModule = createGlspClientModule;
+const client_1 = require("@eclipse-glsp/client");
+const protocol_1 = require("@hydranium/protocol");
+const action_dispatcher_1 = require("./action-dispatcher");
+const diagram_loader_1 = require("./diagram-loader");
+const hidden_bounds_updater_1 = require("./hidden-bounds-updater");
+const sprotty_logger_adapter_1 = require("./sprotty-logger-adapter");
+const status_overlay_1 = require("./status-overlay");
+const types_1 = require("./types");
+/**
+ * Binds the framework's client classes into a GLSP diagram container, whatever
+ * hosts it: the instrumented action dispatcher, the failure-reporting diagram
+ * loader, the route-repairing hidden-bounds updater, the status overlay that
+ * stays on the page, and a sprotty logger that reports through the host's.
+ *
+ * Call it from the module a host adds AFTER GLSP's defaults, since every class
+ * here replaces a token those defaults bind; `rebind` on an unbound token
+ * throws. A host that wants one GLSP default back rebinds that token after
+ * this call, the same one-line move this function makes.
+ *
+ * The logger and tracer tokens are bound only when the host has not bound
+ * them, so a host with a richer logger binds `HydraniumClientTypes.Logger`
+ * first and passes no option. The tracer composes the bound logger and clock.
+ * Bind the tokens in the container this runs in: `isBound` sees a parent
+ * container's binding, which `rebind` cannot replace.
+ */
+function createGlspClientModule(context, options = {}) {
+    const { bind, isBound, rebind } = context;
+    if (options.logger) {
+        (isBound(types_1.HydraniumClientTypes.Logger) ? rebind : bind)(types_1.HydraniumClientTypes.Logger).toConstantValue(options.logger);
+    }
+    else if (!isBound(types_1.HydraniumClientTypes.Logger)) {
+        bind(types_1.HydraniumClientTypes.Logger).toConstantValue(new protocol_1.ConsoleLogger());
+    }
+    if (!isBound(types_1.HydraniumClientTypes.Tracer)) {
+        bind(types_1.HydraniumClientTypes.Tracer)
+            .toDynamicValue(ctx => {
+            const logger = ctx.container.get(types_1.HydraniumClientTypes.Logger);
+            const clock = ctx.container.isBound(types_1.HydraniumClientTypes.Clock)
+                ? ctx.container.get(types_1.HydraniumClientTypes.Clock)
+                : new protocol_1.SystemClock();
+            return new protocol_1.DefaultTracer(logger, clock);
+        })
+            .inSingletonScope();
+    }
+    bind(action_dispatcher_1.HydraniumGlspActionDispatcher).toSelf().inSingletonScope();
+    rebind(client_1.GLSPActionDispatcher).toService(action_dispatcher_1.HydraniumGlspActionDispatcher);
+    rebind(client_1.DiagramLoader).to(diagram_loader_1.HydraniumDiagramLoader).inSingletonScope();
+    rebind(client_1.GLSPHiddenBoundsUpdater).to(hidden_bounds_updater_1.HydraniumHiddenBoundsUpdater).inSingletonScope();
+    rebind(client_1.StatusOverlay).to(status_overlay_1.HydraniumStatusOverlay).inSingletonScope();
+    rebind(client_1.TYPES.ILogger).to(sprotty_logger_adapter_1.SprottyLoggerAdapter).inSingletonScope();
+}
+//# sourceMappingURL=glsp-client-module.js.map

package/lib/glsp-client-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glsp-client-module.js","sourceRoot":"","sources":["../src/glsp-client-module.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;AAElF,iDAO8B;AAC9B,kDAAyG;AACzG,2DAAoE;AACpE,qDAA0D;AAC1D,mEAAuE;AACvE,qEAAgE;AAChE,qDAA0D;AAC1D,mCAA+C;AAU/C;;;;;;;;;;;;;;;;GAgBG;AACH,gCAAuC,OAAuB,EAAE,OAAO,GAA4B,EAAE;IAClG,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IAC1C,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;QAClB,CAAC,OAAO,CAAC,4BAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,4BAAoB,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACvH,CAAC;SAAM,IAAI,CAAC,OAAO,CAAC,4BAAoB,CAAC,MAAM,CAAC,EAAE,CAAC;QAChD,IAAI,CAAC,4BAAoB,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC,IAAI,wBAAa,EAAE,CAAC,CAAC;IAC1E,CAAC;IACD,IAAI,CAAC,OAAO,CAAC,4BAAoB,CAAC,MAAM,CAAC,EAAE,CAAC;QACzC,IAAI,CAAC,4BAAoB,CAAC,MAAM,CAAC;aAC7B,cAAc,CAAC,GAAG,CAAC,EAAE;YACnB,MAAM,MAAM,GAAG,GAAG,CAAC,SAAS,CAAC,GAAG,CAAS,4BAAoB,CAAC,MAAM,CAAC,CAAC;YACtE,MAAM,KAAK,GAAG,GAAG,CAAC,SAAS,CAAC,OAAO,CAAC,4BAAoB,CAAC,KAAK,CAAC;gBAC5D,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAQ,4BAAoB,CAAC,KAAK,CAAC;gBACtD,CAAC,CAAC,IAAI,sBAAW,EAAE,CAAC;YACvB,OAAO,IAAI,wBAAa,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAC3C,CAAC,CAAC;aACD,gBAAgB,EAAE,CAAC;IAC1B,CAAC;IACD,IAAI,CAAC,iDAA6B,CAAC,CAAC,MAAM,EAAE,CAAC,gBAAgB,EAAE,CAAC;IAChE,MAAM,CAAC,6BAAoB,CAAC,CAAC,SAAS,CAAC,iDAA6B,CAAC,CAAC;IACtE,MAAM,CAAC,sBAAa,CAAC,CAAC,EAAE,CAAC,uCAAsB,CAAC,CAAC,gBAAgB,EAAE,CAAC;IACpE,MAAM,CAAC,gCAAuB,CAAC,CAAC,EAAE,CAAC,oDAA4B,CAAC,CAAC,gBAAgB,EAAE,CAAC;IACpF,MAAM,CAAC,sBAAa,CAAC,CAAC,EAAE,CAAC,uCAAsB,CAAC,CAAC,gBAAgB,EAAE,CAAC;IACpE,MAAM,CAAC,cAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,6CAAoB,CAAC,CAAC,gBAAgB,EAAE,CAAC;AACrE,CAAC"}

package/lib/glsp-client.d.ts

@@ -0,0 +1,17 @@
+/********************************************************************************
+ * 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 { BaseJsonrpcGLSPClient, type DisposeClientSessionParameters } from '@eclipse-glsp/client';
+/** The GLSP client a host builds over its connection to the GLSP head. */
+export declare class HydraniumGlspClient extends BaseJsonrpcGLSPClient {
+    /** Resolves at once when the connection is gone: the session went with its
+     *  server, and upstream would throw, which a diagram disposed after its
+     *  client was lost logs as an error. */
+    disposeClientSession(params: DisposeClientSessionParameters): Promise<void>;
+}
+//# sourceMappingURL=glsp-client.d.ts.map

package/lib/glsp-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glsp-client.d.ts","sourceRoot":"","sources":["../src/glsp-client.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,qBAAqB,EAAE,KAAK,8BAA8B,EAAE,MAAM,sBAAsB,CAAC;AAElG,0EAA0E;AAC1E,qBAAa,mBAAoB,SAAQ,qBAAqB;IAC3D;;4CAEwC;IAC/B,oBAAoB,CAAC,MAAM,EAAE,8BAA8B,GAAG,OAAO,CAAC,IAAI,CAAC,CAEnF;CACH"}

package/lib/glsp-client.js

@@ -0,0 +1,23 @@
+"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.HydraniumGlspClient = void 0;
+const client_1 = require("@eclipse-glsp/client");
+/** The GLSP client a host builds over its connection to the GLSP head. */
+class HydraniumGlspClient extends client_1.BaseJsonrpcGLSPClient {
+    /** Resolves at once when the connection is gone: the session went with its
+     *  server, and upstream would throw, which a diagram disposed after its
+     *  client was lost logs as an error. */
+    disposeClientSession(params) {
+        return this.isConnectionActive() ? super.disposeClientSession(params) : Promise.resolve();
+    }
+}
+exports.HydraniumGlspClient = HydraniumGlspClient;
+//# sourceMappingURL=glsp-client.js.map

package/lib/glsp-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glsp-client.js","sourceRoot":"","sources":["../src/glsp-client.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;AAElF,iDAAkG;AAElG,0EAA0E;AAC1E,yBAAiC,SAAQ,8BAAqB;IAC3D;;4CAEwC;IAC/B,oBAAoB,CAAC,MAAsC;QACjE,OAAO,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IAC7F,CAAC;CACH"}