@hydranium/glsp-client-theia 1.0.0-next.10

package/lib/browser/glsp-theia-frontend-module.d.ts

@@ -0,0 +1,110 @@
+/********************************************************************************
+ * 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 ContainerContext, DiagramConfiguration, GLSPClientContribution, type GLSPDiagramManager, GLSPTheiaFrontendModule } from '@eclipse-glsp/theia-integration';
+import { type GLSPDiagramLanguage } from '@eclipse-glsp/theia-integration/lib/common';
+import type { interfaces } from '@theia/core/shared/inversify';
+/**
+ * Sentinel returned from {@link AbstractHydraniumGlspTheiaFrontendModule.bindClientContribution}
+ * to mean "this module deliberately does not bind a GLSPClientContribution"
+ * — used for secondary diagram types that share a GLSP server with a
+ * primary diagram type whose module already bound the contribution. The
+ * override becomes a no-op rather than the framework default.
+ */
+export declare const SkipClientContribution: unique symbol;
+export type SkipClientContribution = typeof SkipClientContribution;
+/**
+ * `GLSPTheiaFrontendModule` subclass that factors out the method overrides
+ * every adopter writes verbatim (`bindDiagramConfiguration` /
+ * `bindGLSPClientContribution` / `configureDiagramManager`) into hook methods
+ * reading from abstract fields.
+ *
+ * Adopters subclass and provide:
+ *  - {@link diagramLanguage} (declared `abstract` on the base class but
+ *    `readonly` on the base type — `GLSPTheiaFrontendModule` requires it)
+ *  - {@link diagramConfiguration} — the adopter's `DiagramConfiguration`
+ *  - {@link diagramManager} — the adopter's `GLSPDiagramManager` subclass
+ *
+ * Optional override hook:
+ *  - {@link bindClientContribution} — return a `Newable<GLSPClientContribution>`
+ *    to bind it (the common case), {@link SkipClientContribution} to
+ *    bypass binding entirely (secondary diagrams), or `undefined` to
+ *    defer to `super.bindGLSPClientContribution(context)`. Default
+ *    returns `undefined` (framework default).
+ *
+ * Adopter-specific customisation that stays as `override` on the subclass:
+ *  - `bindDiagramWidgetFactory` — custom `GLSPDiagramWidget` rebinds
+ *  - `configure` — LibAvoid initialiser, color contribution, startup hooks
+ *  - `enableLayoutCommands` / `enableMarkerNavigationCommands` — flags
+ *
+ * Abstract base class + adopter subclass with concrete fields, following the
+ * GLSP module convention. No `Default*` concrete sibling because the abstract
+ * fields have no sane defaults — every adopter must provide them.
+ */
+export declare abstract class AbstractHydraniumGlspTheiaFrontendModule extends GLSPTheiaFrontendModule {
+    /** Wire-format identifiers + file routing — required by the base. */
+    abstract readonly diagramLanguage: GLSPDiagramLanguage;
+    /** Adopter's `DiagramConfiguration` class. Bound via `bindDiagramConfiguration`. */
+    protected abstract readonly diagramConfiguration: interfaces.Newable<DiagramConfiguration>;
+    /** Adopter's `GLSPDiagramManager` class. Bound + registered via `configureDiagramManager`. */
+    protected abstract readonly diagramManager: interfaces.Newable<GLSPDiagramManager>;
+    /**
+     * Theia preference id driving the framework log threshold, e.g.
+     * `'my-language.log.level'`. When set, {@link initialize} binds
+     * `LogLevelPreferenceContribution` so the level is applied at
+     * application start and kept in sync on change.
+     *
+     * It belongs here rather than beside the channel name in
+     * `createGlspClientTheiaModule`'s options because the two have different
+     * scopes: the channel is per diagram container, while the threshold is a
+     * process-global and must be applied once, from the frontend container.
+     */
+    protected readonly logLevelPreference?: string;
+    /**
+     * Hook returning the {@link GLSPClientContribution} class the framework
+     * should bind for this diagram module:
+     *  - `undefined` (default) — invoke `super.bindGLSPClientContribution(context)`
+     *  - a `Newable<GLSPClientContribution>` — bind it to-self singleton + bind
+     *    `GLSPClientContribution` to the service
+     *  - {@link SkipClientContribution} — no-op (secondary diagrams sharing
+     *    a GLSP server with a primary diagram whose module already bound
+     *    the contribution)
+     */
+    protected bindClientContribution(): interfaces.Newable<GLSPClientContribution> | SkipClientContribution | undefined;
+    /**
+     * Adds the framework's frontend-scoped bindings on top of the base wiring.
+     *
+     * Overrides `initialize` — the base's own orchestrator — rather than
+     * `configure`, which is documented as the *adopter's* hook: a subclass that
+     * overrides `configure` and forgets `super.configure(context)` would otherwise
+     * silently lose these bindings.
+     */
+    initialize(context: ContainerContext): void;
+    bindDiagramConfiguration(context: ContainerContext): void;
+    bindGLSPClientContribution(context: ContainerContext): void;
+    configureDiagramManager(context: ContainerContext): void;
+    /**
+     * Binds the framework diagram widget on top of the base factory wiring, so
+     * every hydranium head gets the loading overlay.
+     *
+     * `super` binds `GLSPDiagramWidget` to itself (via `lazyBind`, a no-op when
+     * already bound) plus the `DiagramWidgetFactory`; the rebind then points the
+     * same token at the subclass, leaving the factory untouched.
+     *
+     * Unconditional on purpose. {@link HydraniumGlspDiagramWidget} differs from
+     * GLSP's widget only by the overlay, so there is no flag here: an adopter that
+     * wants different behaviour overrides the widget (opt out of the overlay by
+     * no-op'ing `showLoadingOverlay`), and one that wants its own subclass rebinds
+     * this token again after calling `super`. A module-level flag gating the
+     * rebind would be worse than useless: it decides which CLASS to bind, so an
+     * adopter subclassing the framework widget and setting the flag to `false`
+     * still gets the overlay, and the flag's name lies.
+     */
+    bindDiagramWidgetFactory(context: ContainerContext): void;
+}
+//# sourceMappingURL=glsp-theia-frontend-module.d.ts.map

package/lib/browser/glsp-theia-frontend-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glsp-theia-frontend-module.d.ts","sourceRoot":"","sources":["../../src/browser/glsp-theia-frontend-module.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EACJ,KAAK,gBAAgB,EACrB,oBAAoB,EACpB,sBAAsB,EACtB,KAAK,kBAAkB,EAEvB,uBAAuB,EAEzB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AAEtF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAG/D;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,eAAoE,CAAC;AACxG,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,8BAAsB,wCAAyC,SAAQ,uBAAuB;IAC3F,qEAAqE;IACrE,kBAA2B,eAAe,EAAE,mBAAmB,CAAC;IAEhE,oFAAoF;IACpF,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,oBAAoB,EAAE,UAAU,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAE3F,8FAA8F;IAC9F,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,cAAc,EAAE,UAAU,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAEnF;;;;;;;;;;OAUG;IACH,SAAS,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE/C;;;;;;;;;OASG;IACH,SAAS,CAAC,sBAAsB,IAAI,UAAU,CAAC,OAAO,CAAC,sBAAsB,CAAC,GAAG,sBAAsB,GAAG,SAAS;IAInH;;;;;;;OAOG;IACM,UAAU,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAO3C,wBAAwB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAIzD,0BAA0B,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAa3D,uBAAuB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAKjE;;;;;;;;;;;;;;;;OAgBG;IACM,wBAAwB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;CAIpE"}

package/lib/browser/glsp-theia-frontend-module.js

@@ -0,0 +1,133 @@
+"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.AbstractHydraniumGlspTheiaFrontendModule = exports.SkipClientContribution = void 0;
+const theia_integration_1 = require("@eclipse-glsp/theia-integration");
+const browser_1 = require("@hydranium/client-theia/lib/browser");
+const diagram_widget_1 = require("./diagram-widget");
+/**
+ * Sentinel returned from {@link AbstractHydraniumGlspTheiaFrontendModule.bindClientContribution}
+ * to mean "this module deliberately does not bind a GLSPClientContribution"
+ * — used for secondary diagram types that share a GLSP server with a
+ * primary diagram type whose module already bound the contribution. The
+ * override becomes a no-op rather than the framework default.
+ */
+exports.SkipClientContribution = Symbol.for('@hydranium/glsp-client-theia#SkipClientContribution');
+/**
+ * `GLSPTheiaFrontendModule` subclass that factors out the method overrides
+ * every adopter writes verbatim (`bindDiagramConfiguration` /
+ * `bindGLSPClientContribution` / `configureDiagramManager`) into hook methods
+ * reading from abstract fields.
+ *
+ * Adopters subclass and provide:
+ *  - {@link diagramLanguage} (declared `abstract` on the base class but
+ *    `readonly` on the base type — `GLSPTheiaFrontendModule` requires it)
+ *  - {@link diagramConfiguration} — the adopter's `DiagramConfiguration`
+ *  - {@link diagramManager} — the adopter's `GLSPDiagramManager` subclass
+ *
+ * Optional override hook:
+ *  - {@link bindClientContribution} — return a `Newable<GLSPClientContribution>`
+ *    to bind it (the common case), {@link SkipClientContribution} to
+ *    bypass binding entirely (secondary diagrams), or `undefined` to
+ *    defer to `super.bindGLSPClientContribution(context)`. Default
+ *    returns `undefined` (framework default).
+ *
+ * Adopter-specific customisation that stays as `override` on the subclass:
+ *  - `bindDiagramWidgetFactory` — custom `GLSPDiagramWidget` rebinds
+ *  - `configure` — LibAvoid initialiser, color contribution, startup hooks
+ *  - `enableLayoutCommands` / `enableMarkerNavigationCommands` — flags
+ *
+ * Abstract base class + adopter subclass with concrete fields, following the
+ * GLSP module convention. No `Default*` concrete sibling because the abstract
+ * fields have no sane defaults — every adopter must provide them.
+ */
+class AbstractHydraniumGlspTheiaFrontendModule extends theia_integration_1.GLSPTheiaFrontendModule {
+    /**
+     * Theia preference id driving the framework log threshold, e.g.
+     * `'my-language.log.level'`. When set, {@link initialize} binds
+     * `LogLevelPreferenceContribution` so the level is applied at
+     * application start and kept in sync on change.
+     *
+     * It belongs here rather than beside the channel name in
+     * `createGlspClientTheiaModule`'s options because the two have different
+     * scopes: the channel is per diagram container, while the threshold is a
+     * process-global and must be applied once, from the frontend container.
+     */
+    logLevelPreference;
+    /**
+     * Hook returning the {@link GLSPClientContribution} class the framework
+     * should bind for this diagram module:
+     *  - `undefined` (default) — invoke `super.bindGLSPClientContribution(context)`
+     *  - a `Newable<GLSPClientContribution>` — bind it to-self singleton + bind
+     *    `GLSPClientContribution` to the service
+     *  - {@link SkipClientContribution} — no-op (secondary diagrams sharing
+     *    a GLSP server with a primary diagram whose module already bound
+     *    the contribution)
+     */
+    bindClientContribution() {
+        return undefined;
+    }
+    /**
+     * Adds the framework's frontend-scoped bindings on top of the base wiring.
+     *
+     * Overrides `initialize` — the base's own orchestrator — rather than
+     * `configure`, which is documented as the *adopter's* hook: a subclass that
+     * overrides `configure` and forgets `super.configure(context)` would otherwise
+     * silently lose these bindings.
+     */
+    initialize(context) {
+        super.initialize(context);
+        if (this.logLevelPreference) {
+            (0, browser_1.bindLogLevelPreference)(context.bind, this.logLevelPreference);
+        }
+    }
+    bindDiagramConfiguration(context) {
+        context.bind(theia_integration_1.DiagramConfiguration).to(this.diagramConfiguration);
+    }
+    bindGLSPClientContribution(context) {
+        const contribution = this.bindClientContribution();
+        if (contribution === exports.SkipClientContribution) {
+            return;
+        }
+        if (contribution === undefined) {
+            super.bindGLSPClientContribution(context);
+            return;
+        }
+        context.bind(contribution).toSelf().inSingletonScope();
+        context.bind(theia_integration_1.GLSPClientContribution).toService(contribution);
+    }
+    configureDiagramManager(context) {
+        context.bind(this.diagramManager).toSelf().inSingletonScope();
+        (0, theia_integration_1.registerDiagramManager)(context.bind, this.diagramManager, false);
+    }
+    /**
+     * Binds the framework diagram widget on top of the base factory wiring, so
+     * every hydranium head gets the loading overlay.
+     *
+     * `super` binds `GLSPDiagramWidget` to itself (via `lazyBind`, a no-op when
+     * already bound) plus the `DiagramWidgetFactory`; the rebind then points the
+     * same token at the subclass, leaving the factory untouched.
+     *
+     * Unconditional on purpose. {@link HydraniumGlspDiagramWidget} differs from
+     * GLSP's widget only by the overlay, so there is no flag here: an adopter that
+     * wants different behaviour overrides the widget (opt out of the overlay by
+     * no-op'ing `showLoadingOverlay`), and one that wants its own subclass rebinds
+     * this token again after calling `super`. A module-level flag gating the
+     * rebind would be worse than useless: it decides which CLASS to bind, so an
+     * adopter subclassing the framework widget and setting the flag to `false`
+     * still gets the overlay, and the flag's name lies.
+     */
+    bindDiagramWidgetFactory(context) {
+        super.bindDiagramWidgetFactory(context);
+        context.rebind(theia_integration_1.GLSPDiagramWidget).to(diagram_widget_1.HydraniumGlspDiagramWidget);
+    }
+}
+exports.AbstractHydraniumGlspTheiaFrontendModule = AbstractHydraniumGlspTheiaFrontendModule;
+//# sourceMappingURL=glsp-theia-frontend-module.js.map

package/lib/browser/glsp-theia-frontend-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glsp-theia-frontend-module.js","sourceRoot":"","sources":["../../src/browser/glsp-theia-frontend-module.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;AAElF,uEAQyC;AAEzC,iEAA6E;AAE7E,qDAA8D;AAE9D;;;;;;GAMG;AACU,QAAA,sBAAsB,GAAG,MAAM,CAAC,GAAG,CAAC,qDAAqD,CAAC,CAAC;AAGxG;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAsB,wCAAyC,SAAQ,2CAAuB;IAU3F;;;;;;;;;;OAUG;IACgB,kBAAkB,CAAU;IAE/C;;;;;;;;;OASG;IACO,sBAAsB;QAC7B,OAAO,SAAS,CAAC;IACpB,CAAC;IAED;;;;;;;OAOG;IACM,UAAU,CAAC,OAAyB;QAC1C,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAC1B,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC3B,IAAA,gCAAsB,EAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;QACjE,CAAC;IACJ,CAAC;IAEQ,wBAAwB,CAAC,OAAyB;QACxD,OAAO,CAAC,IAAI,CAAC,wCAAoB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IACpE,CAAC;IAEQ,0BAA0B,CAAC,OAAyB;QAC1D,MAAM,YAAY,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;QACnD,IAAI,YAAY,KAAK,8BAAsB,EAAE,CAAC;YAC3C,OAAO;QACV,CAAC;QACD,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;YAC9B,KAAK,CAAC,0BAA0B,CAAC,OAAO,CAAC,CAAC;YAC1C,OAAO;QACV,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,MAAM,EAAE,CAAC,gBAAgB,EAAE,CAAC;QACvD,OAAO,CAAC,IAAI,CAAC,0CAAsB,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;IAChE,CAAC;IAEQ,uBAAuB,CAAC,OAAyB;QACvD,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,MAAM,EAAE,CAAC,gBAAgB,EAAE,CAAC;QAC9D,IAAA,0CAAsB,EAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;IACpE,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACM,wBAAwB,CAAC,OAAyB;QACxD,KAAK,CAAC,wBAAwB,CAAC,OAAO,CAAC,CAAC;QACxC,OAAO,CAAC,MAAM,CAAC,qCAAiB,CAAC,CAAC,EAAE,CAAC,2CAA0B,CAAC,CAAC;IACpE,CAAC;CACH;AA/FD,4FA+FC"}

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

@@ -0,0 +1,122 @@
+/********************************************************************************
+ * 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 { ChannelLogger } from '@hydranium/client-theia/lib/browser';
+import { type Clock } 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 `createGlspClientTheiaModule` via `rebind(GLSPHiddenBoundsUpdater)`.
+ */
+export declare class HydraniumHiddenBoundsUpdater extends GLSPHiddenBoundsUpdater {
+    protected readonly channel: ChannelLogger;
+    /** Not injected: the browser container binds no {@link Clock}, and this only
+     *  measures — no logic is gated on time, so there is nothing to fake in
+     *  production. Overridden in tests for a deterministic elapsed value. */
+    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/browser/hidden-bounds-updater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hidden-bounds-updater.d.ts","sourceRoot":"","sources":["../../src/browser/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,aAAa,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,EAAE,KAAK,KAAK,EAAe,MAAM,qBAAqB,CAAC;AAE9D,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,UAAU,CAAC;AAOtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBACa,4BAA6B,SAAQ,uBAAuB;IAC/C,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAG,aAAa,CAAC;IAElE;;6EAEyE;IACzE,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAqB;IAEpD;;;;OAIG;IACH,SAAS,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAEvB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,aAAa,GAAG,KAAK;IAQ9D;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAQ1D,2EAA2E;IAC3E,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO;IAIhE;uEACmE;IACnE,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,gBAAgB,GAAG,uBAAuB;cAO9D,gBAAgB,IAAI,IAAI;IAa3C,mEAAmE;IACnE,SAAS,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM;IAIhF,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAazC;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAM5C;;;;;;;;;;;;;;;OAeG;IACH,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,mBAAmB,GAAG,MAAM,GAAG,SAAS;CAcvE"}

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

@@ -0,0 +1,207 @@
+"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 browser_1 = require("@hydranium/client-theia/lib/browser");
+const protocol_1 = require("@hydranium/protocol");
+const inversify_1 = require("@theia/core/shared/inversify");
+/** 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 channel. */
+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 `createGlspClientTheiaModule` via `rebind(GLSPHiddenBoundsUpdater)`.
+ */
+let HydraniumHiddenBoundsUpdater = class HydraniumHiddenBoundsUpdater extends client_1.GLSPHiddenBoundsUpdater {
+    channel;
+    /** Not injected: the browser container binds no {@link Clock}, and this only
+     *  measures — no logic is gated on time, so there is nothing to fake in
+     *  production. Overridden in tests for a deterministic elapsed value. */
+    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.channel.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)(browser_1.ChannelLogger),
+    __metadata("design:type", browser_1.ChannelLogger)
+], HydraniumHiddenBoundsUpdater.prototype, "channel", void 0);
+exports.HydraniumHiddenBoundsUpdater = HydraniumHiddenBoundsUpdater = __decorate([
+    (0, inversify_1.injectable)()
+], HydraniumHiddenBoundsUpdater);
+//# sourceMappingURL=hidden-bounds-updater.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hidden-bounds-updater.js","sourceRoot":"","sources":["../../src/browser/hidden-bounds-updater.ts"],"names":[],"mappings":"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"}

package/lib/browser/hydranium-glsp-diagram-configuration.d.ts

@@ -0,0 +1,52 @@
+/********************************************************************************
+ * 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 { GLSPDiagramConfiguration } from '@eclipse-glsp/theia-integration';
+import { type Container } from '@theia/core/shared/inversify';
+/**
+ * `GLSPDiagramConfiguration` base for hydranium adopters. By default GLSP
+ * validation markers propagate into Theia's Problems view (the stock
+ * `@eclipse-glsp/theia-integration` behaviour); a head that already publishes
+ * the same diagnostics over LSP suppresses that propagation by setting
+ * {@link propagateMarkersToProblemsView} to `false`.
+ *
+ * **When to suppress.** A head with a co-resident LSP that publishes its
+ * diagnostics over standard LSP `publishDiagnostics` would otherwise list each
+ * error twice: GLSP's `TheiaMarkerManager` pushes the *same* errors again under
+ * a different marker owner, and Theia shows the union across owners. The GLSP
+ * path is also open-diagram-scoped (markers clear when the diagram closes), so
+ * for such a head it cannot reproduce the LSP head's persistent, cross-file
+ * Problems entries — it is only ever a flickering duplicate. A graphical-only
+ * head (no LSP diagnostics, or markers the LSP never produces) keeps the
+ * default so its markers reach the Problems view. The on-diagram decoration is
+ * a separate client feedback path (`ApplyMarkersCommand`), unaffected either
+ * way.
+ *
+ * **How.** {@link initializeContainer} hands {@link connectTheiaMarkerManager}
+ * the Theia marker-manager factory by default; when suppression is enabled it
+ * hands a no-op {@link ExternalMarkerManager} factory instead, so the
+ * per-diagram container binds a manager that renders-but-does-not-forward and
+ * the real `TheiaMarkerManager` (with its `@postConstruct`
+ * `ProblemManager`/shell subscriptions) is never constructed.
+ *
+ * NB: this overrides `GLSPDiagramConfiguration.initializeContainer` rather than
+ * calling `super`. It mirrors the base body (context-menu + marker-manager
+ * wiring); revisit if a future `@eclipse-glsp/theia-integration` adds further
+ * setup there.
+ */
+export declare abstract class AbstractHydraniumGlspDiagramConfiguration extends GLSPDiagramConfiguration {
+    /**
+     * Whether GLSP markers propagate into Theia's Problems view. `true` (the
+     * framework default) keeps the stock Theia propagation; set `false` for a
+     * head with a co-resident LSP that already publishes the same diagnostics,
+     * to render markers on the diagram only and avoid double-listing.
+     */
+    protected propagateMarkersToProblemsView: boolean;
+    protected initializeContainer(container: Container): void;
+}
+//# sourceMappingURL=hydranium-glsp-diagram-configuration.d.ts.map

package/lib/browser/hydranium-glsp-diagram-configuration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydranium-glsp-diagram-configuration.d.ts","sourceRoot":"","sources":["../../src/browser/hydranium-glsp-diagram-configuration.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAGlF,OAAO,EAAE,wBAAwB,EAA6D,MAAM,iCAAiC,CAAC;AACtI,OAAO,EAAE,KAAK,SAAS,EAAc,MAAM,8BAA8B,CAAC;AAG1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,8BACsB,yCAA0C,SAAQ,wBAAwB;IAC7F;;;;;OAKG;IACH,SAAS,CAAC,8BAA8B,UAAQ;cAE7B,mBAAmB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;CAOpE"}