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

package/lib/hidden-bounds-updater.d.ts

@@ -0,0 +1,119 @@
+/********************************************************************************
+ * 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 Action, type ElementAndRoutingPoints, type GModelElement, type GRoutableElement, GLSPHiddenBoundsUpdater, RequestBoundsAction } from '@eclipse-glsp/client';
+import { type Clock, type Logger } from '@hydranium/protocol';
+import { type VNode } from 'snabbdom';
+/**
+ * Instruments sprotty's hidden-bounds pass and repairs degenerate routes before
+ * they go on the wire.
+ *
+ * **Why the framework owns this.** Every GLSP head runs the hidden-bounds pass on
+ * every model update, and it is the one client-side phase that scales with the
+ * *rendered element count* rather than the model size — labels, compartments and
+ * edge decorations expand a modest node count into orders of magnitude more DOM
+ * elements. Without a timing line there is no way to tell a slow measurement pass
+ * apart from slow edge routing or a slow server round trip; with one,
+ * `bounds-request` either exonerates the client in a sentence or names the
+ * dominant cost.
+ *
+ * Emits exactly one `trace` line per bounds request — `trace` because the
+ * frequency matches the per-action traffic `HydraniumGlspActionDispatcher` logs
+ * there (a bounds request is driven by those actions), so it belongs with them
+ * rather than above them. The line carries:
+ *
+ *  - `server` / `local` — whether the request came from the server or from a
+ *    client-local {@link LocalRequestBoundsAction}
+ *  - `scope=<ids>` — the elements a scoped request named; absent when the request
+ *    covers the whole diagram
+ *  - `measured=N` — DOM elements whose bounds were read. Exceeds the scoped id
+ *    count because the base class expands each requested element to its
+ *    descendants
+ *  - `getBBox=Nms` — {@link getBoundsFromDOM} **only**: the layout pass and the
+ *    `ComputedBoundsAction` assembly stay outside it, so the number isolates raw
+ *    measurement cost
+ *
+ * Composed from {@link Clock.measure} rather than `Tracer.time`, matching
+ * `HydraniumDocumentBuilder`'s phase instrumentation. `Tracer.time` is for "tell
+ * me when this is slow" and is deliberately silent on a fast success, which would
+ * drop the element count on every normal pass — and forcing it to emit costs a
+ * paired `[#N start]` line per request. This is a per-occurrence record, so it
+ * measures and composes its own line.
+ *
+ * Bound by `createGlspClientModule` via `rebind(GLSPHiddenBoundsUpdater)`.
+ */
+export declare class HydraniumHiddenBoundsUpdater extends GLSPHiddenBoundsUpdater {
+    protected readonly hydraniumLogger: Logger;
+    /** The diagram container's {@link Clock}, or a `SystemClock`; it only measures. */
+    protected readonly clock: Clock;
+    /**
+     * Scope description for the in-flight request, read from the `cause` in
+     * {@link postUpdate} and consumed by {@link getBoundsFromDOM} — which the base
+     * class calls with no arguments, so the cause cannot be threaded through.
+     */
+    protected currentScope?: string;
+    decorate(vnode: VNode, element: GModelElement): VNode;
+    /**
+     * Replace the routing entry the base class just pushed when it carries fewer
+     * than two points, which is not a valid route for any edge.
+     *
+     * `calcElementAndRoute` already guards the case where the registered router
+     * returns *nothing* — it falls back to source + own routing points + target.
+     * The hole is one step further in: `calcRoute` filters duplicate points at
+     * `Number.EPSILON`, so while obstacles still carry sprotty's unmeasured-bounds
+     * sentinel `(100, 100, -1, -1)` the source and target coincide and a valid
+     * two-point route collapses to a single point. That result is defined, so the
+     * upstream truthiness guard never fires and the single point ships.
+     *
+     * The substitute is deliberately upstream's own fallback shape rather than a
+     * new invention, so a repaired route is indistinguishable from a route the
+     * base class would have produced had it noticed. Only already-invalid payloads
+     * are touched, so a head with a working router is unaffected.
+     */
+    protected repairLastRoute(element: GRoutableElement): void;
+    /** A route needs at least a start and an end point to describe an edge. */
+    protected hasValidRoute(route: ElementAndRoutingPoints): boolean;
+    /** Upstream's `calcElementAndRoute` no-router fallback: the element's own
+     *  bendpoints framed by its source and target anchor positions. */
+    protected toSourceTargetRoute(element: GRoutableElement): ElementAndRoutingPoints;
+    protected getBoundsFromDOM(): void;
+    /** Format the per-request line. Override to change the wording. */
+    protected formatBoundsRequest(scope: string, measured: number, elapsedMs: number): string;
+    postUpdate(cause?: Action): void;
+    /**
+     * Scope facts for the log line: where the request came from, and which
+     * elements it asked for.
+     *
+     * Origin is read from {@link ServerAction}, the `__receivedFromServer` marker
+     * `GLSPModelSource` stamps on inbound actions, rather than from
+     * `LocalRequestBoundsAction.is`. The latter would answer the same today, but
+     * only incidentally: its `elementIDs` check is declared optional, so it is
+     * really just "a bounds request that did not come from the server". Keying on
+     * the marker states that directly, and keeps an *unscoped* local request from
+     * being mislabelled `server` if GLSP ever tightens that guard.
+     */
+    protected formatCause(cause: Action): string;
+    /**
+     * Name the elements a scoped request asked for, or `undefined` when it covers
+     * the whole diagram.
+     *
+     * Deliberately the ids and not their count. A scoped request in practice names
+     * a single element, so a count is always `1` and says nothing, while the id
+     * says *which* element was re-measured — and it is the only part of the line
+     * that distinguishes one such request from the next. It also stops the line
+     * reading as a contradiction: `scope=node0, measured=6` is coherent (the base
+     * class expands a requested element to its descendants, so one id measures six
+     * DOM elements), where `scoped=1, measured=6` invites the reader to wonder
+     * which number is wrong.
+     *
+     * A request naming only the root is treated as unscoped: it measures
+     * everything, so the id adds nothing over the absence of a `scope` tag.
+     */
+    protected formatScope(cause: RequestBoundsAction): string | undefined;
+}
+//# sourceMappingURL=hidden-bounds-updater.d.ts.map

package/lib/hidden-bounds-updater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hidden-bounds-updater.d.ts","sourceRoot":"","sources":["../src/hidden-bounds-updater.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EACJ,KAAK,MAAM,EACX,KAAK,uBAAuB,EAC5B,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,uBAAuB,EAGvB,mBAAmB,EAGrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,KAAK,KAAK,EAAE,KAAK,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAE3E,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,UAAU,CAAC;AAQtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBACa,4BAA6B,SAAQ,uBAAuB;IACjC,SAAS,CAAC,QAAQ,CAAC,eAAe,EAAG,MAAM,CAAC;IAEjF,mFAAmF;IACnC,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAqB;IAEpG;;;;OAIG;IACH,SAAS,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAEvB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,aAAa,GAAG,KAAK,CAM7D;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAMzD;IAED,2EAA2E;IAC3E,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAE/D;IAED;uEACmE;IACnE,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,gBAAgB,GAAG,uBAAuB,CAKhF;IAED,UAAmB,gBAAgB,IAAI,IAAI,CAW1C;IAED,mEAAmE;IACnE,SAAS,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAExF;IAEQ,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAWxC;IAED;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAI3C;IAED;;;;;;;;;;;;;;;OAeG;IACH,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,mBAAmB,GAAG,MAAM,GAAG,SAAS,CAapE;CACH"}

package/lib/hidden-bounds-updater.js

@@ -0,0 +1,210 @@
+"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.HydraniumHiddenBoundsUpdater = void 0;
+const client_1 = require("@eclipse-glsp/client");
+const protocol_1 = require("@hydranium/protocol");
+const inversify_1 = require("inversify");
+const types_1 = require("./types");
+/** How many scoped element ids the log line names before summarising the rest.
+ *  A scoped request names one element in practice; the cap only stops a
+ *  pathological caller from writing a thousand ids into the log. */
+const SCOPE_ID_CAP = 3;
+/**
+ * Instruments sprotty's hidden-bounds pass and repairs degenerate routes before
+ * they go on the wire.
+ *
+ * **Why the framework owns this.** Every GLSP head runs the hidden-bounds pass on
+ * every model update, and it is the one client-side phase that scales with the
+ * *rendered element count* rather than the model size — labels, compartments and
+ * edge decorations expand a modest node count into orders of magnitude more DOM
+ * elements. Without a timing line there is no way to tell a slow measurement pass
+ * apart from slow edge routing or a slow server round trip; with one,
+ * `bounds-request` either exonerates the client in a sentence or names the
+ * dominant cost.
+ *
+ * Emits exactly one `trace` line per bounds request — `trace` because the
+ * frequency matches the per-action traffic `HydraniumGlspActionDispatcher` logs
+ * there (a bounds request is driven by those actions), so it belongs with them
+ * rather than above them. The line carries:
+ *
+ *  - `server` / `local` — whether the request came from the server or from a
+ *    client-local {@link LocalRequestBoundsAction}
+ *  - `scope=<ids>` — the elements a scoped request named; absent when the request
+ *    covers the whole diagram
+ *  - `measured=N` — DOM elements whose bounds were read. Exceeds the scoped id
+ *    count because the base class expands each requested element to its
+ *    descendants
+ *  - `getBBox=Nms` — {@link getBoundsFromDOM} **only**: the layout pass and the
+ *    `ComputedBoundsAction` assembly stay outside it, so the number isolates raw
+ *    measurement cost
+ *
+ * Composed from {@link Clock.measure} rather than `Tracer.time`, matching
+ * `HydraniumDocumentBuilder`'s phase instrumentation. `Tracer.time` is for "tell
+ * me when this is slow" and is deliberately silent on a fast success, which would
+ * drop the element count on every normal pass — and forcing it to emit costs a
+ * paired `[#N start]` line per request. This is a per-occurrence record, so it
+ * measures and composes its own line.
+ *
+ * Bound by `createGlspClientModule` via `rebind(GLSPHiddenBoundsUpdater)`.
+ */
+let HydraniumHiddenBoundsUpdater = class HydraniumHiddenBoundsUpdater extends client_1.GLSPHiddenBoundsUpdater {
+    hydraniumLogger;
+    /** The diagram container's {@link Clock}, or a `SystemClock`; it only measures. */
+    clock = new protocol_1.SystemClock();
+    /**
+     * Scope description for the in-flight request, read from the `cause` in
+     * {@link postUpdate} and consumed by {@link getBoundsFromDOM} — which the base
+     * class calls with no arguments, so the cause cannot be threaded through.
+     */
+    currentScope;
+    decorate(vnode, element) {
+        super.decorate(vnode, element);
+        if ((0, client_1.isRoutable)(element)) {
+            this.repairLastRoute(element);
+        }
+        return vnode;
+    }
+    /**
+     * Replace the routing entry the base class just pushed when it carries fewer
+     * than two points, which is not a valid route for any edge.
+     *
+     * `calcElementAndRoute` already guards the case where the registered router
+     * returns *nothing* — it falls back to source + own routing points + target.
+     * The hole is one step further in: `calcRoute` filters duplicate points at
+     * `Number.EPSILON`, so while obstacles still carry sprotty's unmeasured-bounds
+     * sentinel `(100, 100, -1, -1)` the source and target coincide and a valid
+     * two-point route collapses to a single point. That result is defined, so the
+     * upstream truthiness guard never fires and the single point ships.
+     *
+     * The substitute is deliberately upstream's own fallback shape rather than a
+     * new invention, so a repaired route is indistinguishable from a route the
+     * base class would have produced had it noticed. Only already-invalid payloads
+     * are touched, so a head with a working router is unaffected.
+     */
+    repairLastRoute(element) {
+        const addedRoute = this.element2route.pop();
+        if (addedRoute === undefined) {
+            return;
+        }
+        this.element2route.push(this.hasValidRoute(addedRoute) ? addedRoute : this.toSourceTargetRoute(element));
+    }
+    /** A route needs at least a start and an end point to describe an edge. */
+    hasValidRoute(route) {
+        return route.newRoutingPoints !== undefined && route.newRoutingPoints.length >= 2;
+    }
+    /** Upstream's `calcElementAndRoute` no-router fallback: the element's own
+     *  bendpoints framed by its source and target anchor positions. */
+    toSourceTargetRoute(element) {
+        return {
+            elementId: element.id,
+            newRoutingPoints: [element.source?.position ?? client_1.Point.ORIGIN, ...element.routingPoints, element.target?.position ?? client_1.Point.ORIGIN]
+        };
+    }
+    getBoundsFromDOM() {
+        if (this.currentScope === undefined) {
+            // Not inside an instrumented `postUpdate` (a subclass calling directly);
+            // with no cause there is nothing to attribute a measurement to.
+            super.getBoundsFromDOM();
+            return;
+        }
+        // Read before the pass: the base class clears the map on its way out.
+        const measured = this.getElement2BoundsData().size;
+        const { elapsedMs } = this.clock.measure(() => super.getBoundsFromDOM());
+        this.hydraniumLogger.trace(this.formatBoundsRequest(this.currentScope, measured, elapsedMs));
+    }
+    /** Format the per-request line. Override to change the wording. */
+    formatBoundsRequest(scope, measured, elapsedMs) {
+        return `bounds-request[${scope}] measured=${measured} getBBox=${elapsedMs.toFixed(0)}ms`;
+    }
+    postUpdate(cause) {
+        if (cause?.kind !== client_1.RequestBoundsAction.KIND) {
+            super.postUpdate(cause);
+            return;
+        }
+        this.currentScope = this.formatCause(cause);
+        try {
+            super.postUpdate(cause);
+        }
+        finally {
+            this.currentScope = undefined;
+        }
+    }
+    /**
+     * Scope facts for the log line: where the request came from, and which
+     * elements it asked for.
+     *
+     * Origin is read from {@link ServerAction}, the `__receivedFromServer` marker
+     * `GLSPModelSource` stamps on inbound actions, rather than from
+     * `LocalRequestBoundsAction.is`. The latter would answer the same today, but
+     * only incidentally: its `elementIDs` check is declared optional, so it is
+     * really just "a bounds request that did not come from the server". Keying on
+     * the marker states that directly, and keeps an *unscoped* local request from
+     * being mislabelled `server` if GLSP ever tightens that guard.
+     */
+    formatCause(cause) {
+        const origin = client_1.ServerAction.is(cause) ? 'server' : 'local';
+        const scope = this.formatScope(cause);
+        return scope ? `${origin} scope=${scope}` : origin;
+    }
+    /**
+     * Name the elements a scoped request asked for, or `undefined` when it covers
+     * the whole diagram.
+     *
+     * Deliberately the ids and not their count. A scoped request in practice names
+     * a single element, so a count is always `1` and says nothing, while the id
+     * says *which* element was re-measured — and it is the only part of the line
+     * that distinguishes one such request from the next. It also stops the line
+     * reading as a contradiction: `scope=node0, measured=6` is coherent (the base
+     * class expands a requested element to its descendants, so one id measures six
+     * DOM elements), where `scoped=1, measured=6` invites the reader to wonder
+     * which number is wrong.
+     *
+     * A request naming only the root is treated as unscoped: it measures
+     * everything, so the id adds nothing over the absence of a `scope` tag.
+     */
+    formatScope(cause) {
+        const scopedIds = cause.elementIDs;
+        if (!scopedIds || scopedIds.length === 0) {
+            return undefined;
+        }
+        const named = scopedIds.filter(id => id !== cause.newRoot?.id);
+        if (named.length === 0) {
+            return undefined;
+        }
+        if (named.length > SCOPE_ID_CAP) {
+            return `${named.slice(0, SCOPE_ID_CAP).join(',')},+${named.length - SCOPE_ID_CAP} more`;
+        }
+        return named.join(',');
+    }
+};
+exports.HydraniumHiddenBoundsUpdater = HydraniumHiddenBoundsUpdater;
+__decorate([
+    (0, inversify_1.inject)(types_1.HydraniumClientTypes.Logger),
+    __metadata("design:type", Object)
+], HydraniumHiddenBoundsUpdater.prototype, "hydraniumLogger", void 0);
+__decorate([
+    (0, inversify_1.inject)(types_1.HydraniumClientTypes.Clock),
+    (0, inversify_1.optional)(),
+    __metadata("design:type", Object)
+], HydraniumHiddenBoundsUpdater.prototype, "clock", void 0);
+exports.HydraniumHiddenBoundsUpdater = HydraniumHiddenBoundsUpdater = __decorate([
+    (0, inversify_1.injectable)()
+], HydraniumHiddenBoundsUpdater);
+//# sourceMappingURL=hidden-bounds-updater.js.map

package/lib/hidden-bounds-updater.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hidden-bounds-updater.js","sourceRoot":"","sources":["../src/hidden-bounds-updater.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;;;;;;;;;;AAElF,iDAW8B;AAC9B,kDAA2E;AAC3E,yCAAyD;AAEzD,mCAA+C;AAE/C;;oEAEoE;AACpE,MAAM,YAAY,GAAG,CAAC,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEI,IAAM,4BAA4B,GAAlC,MAAM,4BAA6B,SAAQ,gCAAuB;IACd,eAAe,CAAU;IAEjF,mFAAmF;IAChB,KAAK,GAAU,IAAI,sBAAW,EAAE,CAAC;IAEpG;;;;OAIG;IACO,YAAY,CAAU;IAEvB,QAAQ,CAAC,KAAY,EAAE,OAAsB;QACnD,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAC/B,IAAI,IAAA,mBAAU,EAAC,OAAO,CAAC,EAAE,CAAC;YACvB,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;QACjC,CAAC;QACD,OAAO,KAAK,CAAC;IAChB,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACO,eAAe,CAAC,OAAyB;QAChD,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC;QAC5C,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC5B,OAAO;QACV,CAAC;QACD,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC5G,CAAC;IAED,2EAA2E;IACjE,aAAa,CAAC,KAA8B;QACnD,OAAO,KAAK,CAAC,gBAAgB,KAAK,SAAS,IAAI,KAAK,CAAC,gBAAgB,CAAC,MAAM,IAAI,CAAC,CAAC;IACrF,CAAC;IAED;uEACmE;IACzD,mBAAmB,CAAC,OAAyB;QACpD,OAAO;YACJ,SAAS,EAAE,OAAO,CAAC,EAAE;YACrB,gBAAgB,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,QAAQ,IAAI,cAAK,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,aAAa,EAAE,OAAO,CAAC,MAAM,EAAE,QAAQ,IAAI,cAAK,CAAC,MAAM,CAAC;SAClI,CAAC;IACL,CAAC;IAEkB,gBAAgB;QAChC,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE,CAAC;YACnC,yEAAyE;YACzE,gEAAgE;YAChE,KAAK,CAAC,gBAAgB,EAAE,CAAC;YACzB,OAAO;QACV,CAAC;QACD,sEAAsE;QACtE,MAAM,QAAQ,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC,IAAI,CAAC;QACnD,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,gBAAgB,EAAE,CAAC,CAAC;QACzE,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,YAAY,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;IAChG,CAAC;IAED,mEAAmE;IACzD,mBAAmB,CAAC,KAAa,EAAE,QAAgB,EAAE,SAAiB;QAC7E,OAAO,kBAAkB,KAAK,cAAc,QAAQ,YAAY,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;IAC5F,CAAC;IAEQ,UAAU,CAAC,KAAc;QAC/B,IAAI,KAAK,EAAE,IAAI,KAAK,4BAAmB,CAAC,IAAI,EAAE,CAAC;YAC5C,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YACxB,OAAO;QACV,CAAC;QACD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAC5C,IAAI,CAAC;YACF,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAC3B,CAAC;gBAAS,CAAC;YACR,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;QACjC,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;OAWG;IACO,WAAW,CAAC,KAAa;QAChC,MAAM,MAAM,GAAG,qBAAY,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC;QAC3D,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,KAA4B,CAAC,CAAC;QAC7D,OAAO,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,UAAU,KAAK,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;IACtD,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACO,WAAW,CAAC,KAA0B;QAC7C,MAAM,SAAS,GAAI,KAAkC,CAAC,UAAU,CAAC;QACjE,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxC,OAAO,SAAS,CAAC;QACpB,CAAC;QACD,MAAM,KAAK,GAAG,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QAC/D,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtB,OAAO,SAAS,CAAC;QACpB,CAAC;QACD,IAAI,KAAK,CAAC,MAAM,GAAG,YAAY,EAAE,CAAC;YAC/B,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,KAAK,CAAC,MAAM,GAAG,YAAY,OAAO,CAAC;QAC3F,CAAC;QACD,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC1B,CAAC;CACH,CAAA;;AA1I0D;IAAvD,IAAA,kBAAM,EAAC,4BAAoB,CAAC,MAAM,CAAC;;qEAA6C;AAGd;IAAlE,IAAA,kBAAM,EAAC,4BAAoB,CAAC,KAAK,CAAC;IAAE,IAAA,oBAAQ,GAAE;;2DAAqD;uCAJ1F,4BAA4B;IADxC,IAAA,sBAAU,GAAE;GACA,4BAA4B,CA2IxC"}

package/lib/index.d.ts

@@ -0,0 +1,19 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+export * from './action-dispatcher';
+export * from './diagram-load-failed';
+export * from './diagram-loader';
+export * from './edge';
+export * from './glsp-client';
+export * from './glsp-client-module';
+export * from './hidden-bounds-updater';
+export * from './sprotty-logger-adapter';
+export * from './status-overlay';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAOlF,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,QAAQ,CAAC;AACvB,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC"}

package/lib/index.js

@@ -0,0 +1,40 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// The host-neutral GLSP client classes and the binder that mounts them. This
+// root is browser-bound, not neutral: it loads `@eclipse-glsp/client`, whose
+// graph imports stylesheets, so it needs a bundler with a CSS loader. It is
+// free of Node and of any host platform, which is the claim `check:neutral`
+// gates.
+__exportStar(require("./action-dispatcher"), exports);
+__exportStar(require("./diagram-load-failed"), exports);
+__exportStar(require("./diagram-loader"), exports);
+__exportStar(require("./edge"), exports);
+__exportStar(require("./glsp-client"), exports);
+__exportStar(require("./glsp-client-module"), exports);
+__exportStar(require("./hidden-bounds-updater"), exports);
+__exportStar(require("./sprotty-logger-adapter"), exports);
+__exportStar(require("./status-overlay"), exports);
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;;;;;;;;;;;;;;AAElF,6EAA6E;AAC7E,6EAA6E;AAC7E,4EAA4E;AAC5E,4EAA4E;AAC5E,SAAS;AACT,sDAAoC;AACpC,wDAAsC;AACtC,mDAAiC;AACjC,yCAAuB;AACvB,gDAA8B;AAC9B,uDAAqC;AACrC,0DAAwC;AACxC,2DAAyC;AACzC,mDAAiC;AACjC,0CAAwB"}

package/lib/messages/index.d.ts

@@ -0,0 +1,10 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+export { DIAGRAM_LOAD_FAILED } from '../diagram-load-failed';
+//# sourceMappingURL=index.d.ts.map

package/lib/messages/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/messages/index.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AASlF,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC"}

package/lib/messages/index.js

@@ -0,0 +1,20 @@
+"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.DIAGRAM_LOAD_FAILED = void 0;
+// Every user-facing message `@hydranium/glsp-client` raises. The client tier
+// renders only its own messages, which fire when no server could have worded
+// them: the loader formats the English, and a host that knows the reading
+// user's locale renders the code through its own mechanism instead, as the
+// Theia loader does through `nls`. The barrel is how an adopter rendering their
+// own diagram chrome discovers the codes exist.
+var diagram_load_failed_1 = require("../diagram-load-failed");
+Object.defineProperty(exports, "DIAGRAM_LOAD_FAILED", { enumerable: true, get: function () { return diagram_load_failed_1.DIAGRAM_LOAD_FAILED; } });
+//# sourceMappingURL=index.js.map

package/lib/messages/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/messages/index.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;AAElF,6EAA6E;AAC7E,6EAA6E;AAC7E,0EAA0E;AAC1E,2EAA2E;AAC3E,gFAAgF;AAChF,gDAAgD;AAEhD,8DAA6D;AAApD,0HAAA,mBAAmB,OAAA"}

package/lib/sprotty-logger-adapter.d.ts

@@ -0,0 +1,61 @@
+/********************************************************************************
+ * 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 ILogger, LogLevel } from '@eclipse-glsp/client';
+import { Logger } from '@hydranium/protocol';
+/**
+ * sprotty's `ILogger` over the host's {@link Logger}, so sprotty's own lines
+ * reach the same sink as the framework's: a view-registration failure lands in
+ * the Theia Output channel beside the action traffic, or on a page's console.
+ * sprotty binds a `NullLogger` by default, which drops those failures.
+ *
+ * sprotty's `error` and `warn` keep their levels and their parameters, where
+ * the parameter is the useful part, such as the element type that has no view.
+ *
+ * Its `info` is diagnosis, chatty on every hover's feedback, so it goes to
+ * `debug`; the one anomaly reported there, a request GLSP resolved silently
+ * after its timeout, goes to `warn`, where a default threshold shows it.
+ *
+ * Its `log` fires per action, per command and per render with the whole action
+ * or model as a parameter, so it goes to `trace`, where the framework
+ * dispatcher logs that traffic. **At `info` and `log` a parameter is reduced to
+ * its name**, an action's `kind` or an object's class, never forwarded whole:
+ * the Theia channel logger stringifies every parameter as JSON, so forwarding
+ * them would write the model into the Output channel on every action.
+ *
+ * Each line goes through a logger nested under the host's for the calling
+ * class, cached per class, so the origin is a tag the host renders inside its
+ * own, `[GLSP client :: Viewer]`, not a prefix inside the message. Where
+ * sprotty passes a sentence instead of the caller, as its layout registries
+ * do, the sentence prefixes the message. The adapter's own `logLevel` is
+ * sprotty's most verbose, so only the framework threshold filters; `info` and
+ * `log` check it first, since they run on every action and render and would
+ * otherwise format a line the threshold drops.
+ *
+ * Bound by `createGlspClientModule` via `rebind(TYPES.ILogger)`.
+ */
+export declare class SprottyLoggerAdapter implements ILogger {
+    protected readonly logger: Logger;
+    logLevel: LogLevel;
+    /** Loggers derived per calling class; sprotty logs from a few dozen classes. */
+    protected readonly loggers: Map<string, Logger>;
+    error(thisArg: unknown, message: string, ...params: unknown[]): void;
+    warn(thisArg: unknown, message: string, ...params: unknown[]): void;
+    info(thisArg: unknown, message: string, ...params: unknown[]): void;
+    log(thisArg: unknown, message: string, ...params: unknown[]): void;
+    /** The host's logger with the calling class nested under its tag, or the
+     *  host's own when the caller is not an object. */
+    protected loggerFor(thisArg: unknown): Logger;
+    /** The message, behind the sentence sprotty sometimes passes as the caller,
+     *  followed by the parameters' names. */
+    protected formatMessage(thisArg: unknown, message: string, params?: readonly unknown[]): string;
+    /** An action's `kind`, also inside the message GLSP sends an action in, a
+     *  string as it is, any other object's class, else nothing. */
+    protected nameOf(value: unknown): string | undefined;
+}
+//# sourceMappingURL=sprotty-logger-adapter.d.ts.map

package/lib/sprotty-logger-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sprotty-logger-adapter.d.ts","sourceRoot":"","sources":["../src/sprotty-logger-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,KAAK,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAQ7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBACa,oBAAqB,YAAW,OAAO;IACZ,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAG,MAAM,CAAC;IAExE,QAAQ,EAAE,QAAQ,CAAgB;IAElC,gFAAgF;IAChF,SAAS,CAAC,QAAQ,CAAC,OAAO,sBAA6B;IAEvD,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAEnE;IAED,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAElE;IAED,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAMlE;IAED,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAIjE;IAED;uDACmD;IACnD,SAAS,CAAC,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAW5C;IAED;6CACyC;IACzC,SAAS,CAAC,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAE,SAAS,OAAO,EAAO,GAAG,MAAM,CAGlG;IAED;mEAC+D;IAC/D,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAenD;CACH"}

package/lib/sprotty-logger-adapter.js

@@ -0,0 +1,130 @@
+"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.SprottyLoggerAdapter = void 0;
+const client_1 = require("@eclipse-glsp/client");
+const protocol_1 = require("@hydranium/protocol");
+const inversify_1 = require("inversify");
+const types_1 = require("./types");
+/** GLSP's wording for a request it resolved silently after its timeout. If
+ *  upstream rewords it, the notice degrades to `debug` with the rest of `info`. */
+const REQUEST_TIMED_OUT = /\btime out after \d+ms\b/;
+/**
+ * sprotty's `ILogger` over the host's {@link Logger}, so sprotty's own lines
+ * reach the same sink as the framework's: a view-registration failure lands in
+ * the Theia Output channel beside the action traffic, or on a page's console.
+ * sprotty binds a `NullLogger` by default, which drops those failures.
+ *
+ * sprotty's `error` and `warn` keep their levels and their parameters, where
+ * the parameter is the useful part, such as the element type that has no view.
+ *
+ * Its `info` is diagnosis, chatty on every hover's feedback, so it goes to
+ * `debug`; the one anomaly reported there, a request GLSP resolved silently
+ * after its timeout, goes to `warn`, where a default threshold shows it.
+ *
+ * Its `log` fires per action, per command and per render with the whole action
+ * or model as a parameter, so it goes to `trace`, where the framework
+ * dispatcher logs that traffic. **At `info` and `log` a parameter is reduced to
+ * its name**, an action's `kind` or an object's class, never forwarded whole:
+ * the Theia channel logger stringifies every parameter as JSON, so forwarding
+ * them would write the model into the Output channel on every action.
+ *
+ * Each line goes through a logger nested under the host's for the calling
+ * class, cached per class, so the origin is a tag the host renders inside its
+ * own, `[GLSP client :: Viewer]`, not a prefix inside the message. Where
+ * sprotty passes a sentence instead of the caller, as its layout registries
+ * do, the sentence prefixes the message. The adapter's own `logLevel` is
+ * sprotty's most verbose, so only the framework threshold filters; `info` and
+ * `log` check it first, since they run on every action and render and would
+ * otherwise format a line the threshold drops.
+ *
+ * Bound by `createGlspClientModule` via `rebind(TYPES.ILogger)`.
+ */
+let SprottyLoggerAdapter = class SprottyLoggerAdapter {
+    logger;
+    logLevel = client_1.LogLevel.log;
+    /** Loggers derived per calling class; sprotty logs from a few dozen classes. */
+    loggers = new Map();
+    error(thisArg, message, ...params) {
+        this.loggerFor(thisArg).error(this.formatMessage(thisArg, message), ...params);
+    }
+    warn(thisArg, message, ...params) {
+        this.loggerFor(thisArg).warn(this.formatMessage(thisArg, message), ...params);
+    }
+    info(thisArg, message, ...params) {
+        if (REQUEST_TIMED_OUT.test(message)) {
+            this.loggerFor(thisArg).warn(this.formatMessage(thisArg, message, params));
+        }
+        else if (protocol_1.Logger.isLevelEnabled('debug')) {
+            this.loggerFor(thisArg).debug(this.formatMessage(thisArg, message, params));
+        }
+    }
+    log(thisArg, message, ...params) {
+        if (protocol_1.Logger.isLevelEnabled('trace')) {
+            this.loggerFor(thisArg).trace(this.formatMessage(thisArg, message, params));
+        }
+    }
+    /** The host's logger with the calling class nested under its tag, or the
+     *  host's own when the caller is not an object. */
+    loggerFor(thisArg) {
+        const caller = typeof thisArg === 'object' && thisArg !== null ? this.nameOf(thisArg) : undefined;
+        if (caller === undefined) {
+            return this.logger;
+        }
+        let derived = this.loggers.get(caller);
+        if (derived === undefined) {
+            derived = this.logger.sub(caller);
+            this.loggers.set(caller, derived);
+        }
+        return derived;
+    }
+    /** The message, behind the sentence sprotty sometimes passes as the caller,
+     *  followed by the parameters' names. */
+    formatMessage(thisArg, message, params = []) {
+        const text = typeof thisArg === 'string' ? `${thisArg}${message}` : message;
+        return [text, ...params.map(param => this.nameOf(param)).filter(name => name !== undefined)].join(' ');
+    }
+    /** An action's `kind`, also inside the message GLSP sends an action in, a
+     *  string as it is, any other object's class, else nothing. */
+    nameOf(value) {
+        if (typeof value === 'string') {
+            return value;
+        }
+        if (typeof value !== 'object' || value === null) {
+            return undefined;
+        }
+        const { kind, action } = value;
+        if (typeof kind === 'string') {
+            return kind;
+        }
+        if (typeof action?.kind === 'string') {
+            return action.kind;
+        }
+        return value.constructor?.name;
+    }
+};
+exports.SprottyLoggerAdapter = SprottyLoggerAdapter;
+__decorate([
+    (0, inversify_1.inject)(types_1.HydraniumClientTypes.Logger),
+    __metadata("design:type", Object)
+], SprottyLoggerAdapter.prototype, "logger", void 0);
+exports.SprottyLoggerAdapter = SprottyLoggerAdapter = __decorate([
+    (0, inversify_1.injectable)()
+], SprottyLoggerAdapter);
+//# sourceMappingURL=sprotty-logger-adapter.js.map