@eclipse-glsp/client 2.7.0-next.9 → 2.7.0

package/src/features/export/default-svg-diagram-exporter.ts

@@ -0,0 +1,39 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { Action, ExportFormat, ExportMimeType, GModelRoot, SvgExportOptions } from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { DiagramExporter } from './diagram-exporter';
+import { GLSPSvgExporter } from './glsp-svg-exporter';
+
+/**
+ * Default SVG strategy for the unified export registry. Wraps {@link GLSPSvgExporter} —
+ * the same exporter that powers the legacy `RequestExportSvgAction` path — so adopter
+ * overrides on the SVG renderer (extending {@link GLSPSvgExporter}) participate in unified
+ * exports for free.
+ */
+@injectable()
+export class DefaultSvgDiagramExporter implements DiagramExporter<SvgExportOptions> {
+    readonly format: ExportFormat = 'svg';
+    readonly mimeType: ExportMimeType = 'image/svg+xml';
+    readonly encoding = 'text' as const;
+
+    @inject(GLSPSvgExporter) protected svgExporter: GLSPSvgExporter;
+
+    async export(root: GModelRoot, options: SvgExportOptions = {}, cause?: Action): Promise<string> {
+        return this.svgExporter.exportToString(root, options, cause);
+    }
+}

package/src/features/export/diagram-export-postprocessor.ts

@@ -0,0 +1,82 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import {
+    Action,
+    ExportResultAction,
+    GModelElement,
+    GModelRoot,
+    IActionDispatcher,
+    IVNodePostprocessor,
+    RejectAction,
+    RequestExportAction,
+    TYPES
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable, multiInject } from 'inversify';
+import { VNode } from 'snabbdom';
+import { DiagramExporter } from './diagram-exporter';
+
+/**
+ * Postprocessor for the unified {@link RequestExportAction} flow. Captures the rendered model
+ * root from the `decorate` pass, then on `postUpdate` looks up the matching
+ * {@link DiagramExporter} by `format` and dispatches an {@link ExportResultAction} with the
+ * produced bytes.
+ */
+@injectable()
+export class DiagramExportPostprocessor implements IVNodePostprocessor {
+    @multiInject(TYPES.IDiagramExporter) protected exporters: DiagramExporter[];
+    @inject(TYPES.IActionDispatcher) protected actionDispatcher: IActionDispatcher;
+
+    protected root: GModelRoot;
+
+    decorate(vnode: VNode, element: GModelElement): VNode {
+        if (element instanceof GModelRoot) {
+            this.root = element;
+        }
+        return vnode;
+    }
+
+    postUpdate(cause?: Action): void {
+        if (!this.root || !RequestExportAction.is(cause)) {
+            return;
+        }
+        const request = cause;
+        this.runExport(request).catch(err => {
+            const message = err instanceof Error ? err.message : String(err);
+            this.actionDispatcher.dispatch(RejectAction.create(message, { responseId: request.requestId }));
+        });
+    }
+
+    protected async runExport(request: RequestExportAction): Promise<void> {
+        // First-bound-wins on duplicate formats: an adopter who registers a custom
+        // PNG exporter without `unbind`-ing the default will pick up the default. To
+        // override, rebind via `binding.rebind(DefaultPngDiagramExporter, MyPngExporter)`
+        // in your `DiagramExportModule` extension.
+        const exporter = this.exporters.find(candidate => candidate.format === request.format);
+        if (!exporter) {
+            throw new Error(`No DiagramExporter registered for format '${request.format}'`);
+        }
+        const data = await exporter.export(this.root, request.formatOptions ?? {}, request);
+        this.actionDispatcher.dispatch(
+            ExportResultAction.create(exporter.format, data, {
+                mimeType: exporter.mimeType,
+                encoding: exporter.encoding,
+                responseId: request.requestId,
+                formatOptions: request.formatOptions
+            })
+        );
+    }
+}

package/src/features/export/diagram-exporter.ts

@@ -0,0 +1,45 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { Action, ExportEncoding, ExportFormat, ExportMimeType, GModelRoot } from '@eclipse-glsp/sprotty';
+
+/**
+ * A pluggable strategy that turns the rendered diagram into the bytes of a specific export
+ * format. GLSP ships strategies for `'svg'` and `'png'` (both rendered client-side via the
+ * existing SVG export pipeline + `OffscreenCanvas` for PNG). Adopters add formats — PPTX,
+ * PDF, server-rendered PNG, … — by registering additional contributions.
+ *
+ * Implementations choose how the bytes are produced (DOM serialisation, canvas
+ * rasterisation, delegation to a backend service via Theia/Electron RPC, …) — the registry
+ * is runtime-agnostic. The generic `O` is the strategy-specific options shape (e.g.
+ * `PngExportOptions`) carried inside `RequestExportAction.formatOptions`; the postprocessor
+ * forwards the bag to the strategy, so each implementation reads its typed options directly
+ * without an in-method cast.
+ */
+export interface DiagramExporter<O = unknown> {
+    /** Format identifier matched against `RequestExportAction.format` (lower-case). */
+    readonly format: ExportFormat;
+    /** MIME type written into the resulting `ExportResultAction.mimeType`. */
+    readonly mimeType: ExportMimeType;
+    /** Encoding of the produced `data` field — `'text'` for SVG markup, `'base64'` for binary formats, or any adopter-defined tag. */
+    readonly encoding: ExportEncoding;
+    /**
+     * Produce the export payload. `formatOptions` is the strategy-typed slice of
+     * `RequestExportAction.formatOptions`; `cause` carries the originating action so
+     * adopters can inspect request metadata beyond the per-format options.
+     */
+    export(root: GModelRoot, formatOptions: O, cause?: Action): Promise<string>;
+}

package/src/features/export/export-modules.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2024 EclipseSource and others.
+ * Copyright (c) 2019-2026 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,26 +13,42 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+/* eslint-disable @typescript-eslint/no-deprecated */
 import {
     bindAsService,
     configureActionHandler,
     configureCommand,
+    ExportResultAction,
     ExportSvgAction,
     ExportSvgCommand,
-    ExportSvgKeyListener,
     ExportSvgPostprocessor,
     FeatureModule,
     TYPES
 } from '@eclipse-glsp/sprotty';
+import { DefaultPngDiagramExporter } from './default-png-diagram-exporter';
+import { DefaultSvgDiagramExporter } from './default-svg-diagram-exporter';
+import { DiagramExportPostprocessor } from './diagram-export-postprocessor';
+import { ExportResultActionHandler } from './export-result-action-handler';
 import { ExportSvgActionHandler } from './export-svg-action-handler';
 import { GLSPSvgExporter } from './glsp-svg-exporter';
+import { RequestExportCommand } from './request-export-command';
+import { RequestExportKeyListener } from './request-export-key-listener';
 
 export const exportModule = new FeatureModule(
     (bind, _unbind, isBound) => {
         const context = { bind, isBound };
+        bindAsService(context, TYPES.SvgExporter, GLSPSvgExporter);
+
+        // Unified export pipeline.
+        bindAsService(context, TYPES.HiddenVNodePostprocessor, DiagramExportPostprocessor);
+        configureCommand(context, RequestExportCommand);
+        bindAsService(context, TYPES.IDiagramExporter, DefaultSvgDiagramExporter);
+        bindAsService(context, TYPES.IDiagramExporter, DefaultPngDiagramExporter);
+
+        // Legacy SVG-only pipeline kept functional for adopters still dispatching the
+        // deprecated `RequestExportSvgAction` / `ExportSvgAction`.
         bindAsService(context, TYPES.HiddenVNodePostprocessor, ExportSvgPostprocessor);
         configureCommand(context, ExportSvgCommand);
-        bind(TYPES.SvgExporter).to(GLSPSvgExporter).inSingletonScope();
     },
     { featureId: Symbol('export') }
 );
@@ -45,7 +61,11 @@ export const exportModule = new FeatureModule(
 export const standaloneExportModule = new FeatureModule(
     (bind, _unbind, isBound) => {
         const context = { bind, isBound };
-        bindAsService(context, TYPES.KeyListener, ExportSvgKeyListener);
+        bindAsService(context, TYPES.KeyListener, RequestExportKeyListener);
+        bind(ExportResultActionHandler).toSelf().inSingletonScope();
+        configureActionHandler(context, ExportResultAction.KIND, ExportResultActionHandler);
+
+        // Legacy download path: bound so adopters dispatching `ExportSvgAction` still get a download.
         bind(ExportSvgActionHandler).toSelf().inSingletonScope();
         configureActionHandler(context, ExportSvgAction.KIND, ExportSvgActionHandler);
     },

package/src/features/export/export-result-action-handler.ts

@@ -0,0 +1,66 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { ExportResultAction, IActionHandler } from '@eclipse-glsp/sprotty';
+import { saveAs } from 'file-saver';
+import { injectable } from 'inversify';
+
+/**
+ * Default handler for the unified {@link ExportResultAction} — triggers a browser file
+ * download for UI-driven flows. Bound by `standaloneExportModule`; integrations that
+ * provide their own download UX omit it.
+ */
+@injectable()
+export class ExportResultActionHandler implements IActionHandler {
+    handle(action: ExportResultAction): void {
+        if (!ExportResultAction.is(action)) {
+            return;
+        }
+        const blob = this.toBlob(action);
+        saveAs(blob, `diagram.${this.extensionFor(action.format)}`);
+    }
+
+    protected toBlob(action: ExportResultAction): Blob {
+        // `encoding` is `ProposalString<'text' | 'base64'>` — an open union. Reject unknown
+        // tags explicitly: silently treating an arbitrary value as text would mojibake binary
+        // payloads, while treating it as base64 would corrupt text payloads.
+        switch (action.encoding) {
+            case 'text':
+                return new Blob([action.data], { type: `${action.mimeType};charset=utf-8` });
+            case 'base64':
+                return new Blob([this.decodeBase64(action.data)], { type: action.mimeType });
+            default:
+                throw new Error(
+                    `ExportResultActionHandler: unsupported encoding '${action.encoding}' for format '${action.format}'. ` +
+                        'Adopters that ship a custom encoding must also subclass this handler to decode it.'
+                );
+        }
+    }
+
+    protected extensionFor(format: string): string {
+        return format.toLowerCase();
+    }
+
+    protected decodeBase64(data: string): ArrayBuffer {
+        const binary = atob(data);
+        const buffer = new ArrayBuffer(binary.length);
+        const view = new Uint8Array(buffer);
+        for (let i = 0; i < binary.length; ++i) {
+            view[i] = binary.charCodeAt(i);
+        }
+        return buffer;
+    }
+}

package/src/features/export/export-svg-action-handler.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 EclipseSource and others.
+ * Copyright (c) 2023-2026 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,15 +13,20 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+/* eslint-disable @typescript-eslint/no-deprecated */
+import { ExportSvgAction, IActionHandler } from '@eclipse-glsp/sprotty';
 import { saveAs } from 'file-saver';
 import { injectable } from 'inversify';
-import { ExportSvgAction, IActionHandler } from '@eclipse-glsp/sprotty';
 
 /**
  * The default handler for {@link ExportSvgAction}s. This generic handler can be used in
  * any GLSP project independent of the target platform. However, platform integration modules typically
  *  * this handler is rebound to an application specific handler in platform integration modules
  * (e.g. the Theia integration)
+ *
+ * @deprecated Use the unified export pipeline ({@link RequestExportAction} +
+ * {@link DiagramExporter}) and bind your own {@link IActionHandler} for
+ * {@link ExportResultAction} instead.
  */
 @injectable()
 export class ExportSvgActionHandler implements IActionHandler {

package/src/features/export/glsp-svg-exporter.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2024 EclipseSource and others.
+ * Copyright (c) 2022-2026 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,11 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+/* eslint-disable @typescript-eslint/no-deprecated */
 import {
     Action,
     ExportSvgAction,
     ExportSvgOptions,
     GModelRoot,
+    RejectAction,
     RequestAction,
     RequestExportSvgAction,
     SvgExporter
@@ -27,18 +29,52 @@ import { v4 as uuid } from 'uuid';
 
 @injectable()
 export class GLSPSvgExporter extends SvgExporter {
+    /**
+     * Legacy entry point for the SVG-only export flow. New code should use the unified
+     * `RequestExportAction` flow (registered via the `DiagramExporter` registry);
+     * adopters that previously bound {@link RequestExportSvgAction} should migrate to
+     * `RequestExportAction` with `format: 'svg'`.
+     *
+     * @deprecated Use the unified export pipeline. Retained for backward compatibility
+     * with the legacy {@link RequestExportSvgAction} / {@link ExportSvgAction} flow.
+     */
     override export(root: GModelRoot, request?: RequestExportSvgAction): void {
-        if (typeof document !== 'undefined') {
-            let svgElement = this.findSvgElement();
-            if (svgElement) {
-                svgElement = this.prepareSvgElement(svgElement, root, request);
-                const serializedSvg = this.createSvg(svgElement, root, request?.options ?? {}, request);
-                const svgExport = this.getSvgExport(serializedSvg, svgElement, root, request);
-                // do not give request/response id here as otherwise the action is treated as an unrequested response
-                this.actionDispatcher.dispatch(
-                    ExportSvgAction.create(svgExport, { responseId: request?.requestId, options: request?.options })
-                );
-            }
+        try {
+            const svgExport = this.exportToString(root, request?.options, request);
+            this.actionDispatcher.dispatch(
+                ExportSvgAction.create(svgExport, { responseId: request?.requestId, options: request?.options })
+            );
+        } catch (err: unknown) {
+            this.dispatchRejectionIfRequested(request, err instanceof Error ? err.message : String(err));
+        }
+    }
+
+    /**
+     * Produce the serialised SVG string without dispatching any action. Throws on
+     * failure (no document, no SVG element). Used by the legacy `export()` path and
+     * by unified-export strategies (`DefaultSvgDiagramExporter`, `DefaultPngDiagramExporter`)
+     * that need the SVG bytes without the action-dispatch side effect.
+     */
+    exportToString(root: GModelRoot, options?: ExportSvgOptions, cause?: Action): string {
+        if (typeof document === 'undefined') {
+            throw new Error('SVG export failed: document is not available');
+        }
+        let svgElement = this.findSvgElement();
+        if (!svgElement) {
+            throw new Error('SVG export failed: SVG element not found');
+        }
+        // Only the legacy SVG-only flow carries a `RequestExportSvgAction`; under the unified
+        // export flow `cause` is a `RequestExportAction` and the legacy override hooks are
+        // intentionally invoked with `undefined`.
+        const request = RequestExportSvgAction.is(cause) ? cause : undefined;
+        svgElement = this.prepareSvgElement(svgElement, root, request);
+        const serializedSvg = this.createSvg(svgElement, root, options ?? {}, cause);
+        return this.getSvgExport(serializedSvg, svgElement, root, request);
+    }
+
+    protected dispatchRejectionIfRequested(request: RequestExportSvgAction | undefined, message: string): void {
+        if (request?.requestId) {
+            this.actionDispatcher.dispatch(RejectAction.create(message, { responseId: request.requestId }));
         }
     }
 

package/src/features/export/request-export-command.ts

@@ -0,0 +1,65 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import {
+    CommandExecutionContext,
+    CommandResult,
+    HiddenCommand,
+    isExportable,
+    isHoverable,
+    isSelectable,
+    isViewport,
+    RequestExportAction,
+    TYPES
+} from '@eclipse-glsp/sprotty';
+import { inject } from 'inversify';
+
+/**
+ * {@link HiddenCommand} for the unified {@link RequestExportAction} kind. Performs the same
+ * pre-render preparation as sprotty's `ExportSvgCommand` (clone the root, reset
+ * viewport, drop selection/hover) so the rendered SVG used by every
+ * `DiagramExporter` strategy is independent of UI state.
+ */
+export class RequestExportCommand extends HiddenCommand {
+    static readonly KIND = RequestExportAction.KIND;
+
+    constructor(@inject(TYPES.Action) protected action: RequestExportAction) {
+        super();
+    }
+
+    execute(context: CommandExecutionContext): CommandResult {
+        if (!isExportable(context.root)) {
+            return { model: context.root, modelChanged: false };
+        }
+        const root = context.modelFactory.createRoot(context.root);
+        if (!isExportable(root)) {
+            return { model: context.root, modelChanged: false };
+        }
+        if (isViewport(root)) {
+            root.zoom = 1;
+            root.scroll = { x: 0, y: 0 };
+        }
+        root.index.all().forEach(element => {
+            if (isSelectable(element) && element.selected) {
+                element.selected = false;
+            }
+            if (isHoverable(element) && element.hoverFeedback) {
+                element.hoverFeedback = false;
+            }
+        });
+        return { model: root, modelChanged: true, cause: this.action };
+    }
+}

package/src/features/export/request-export-key-listener.ts

@@ -0,0 +1,29 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { Action, GModelElement, KeyListener, RequestExportAction, matchesKeystroke } from '@eclipse-glsp/sprotty';
+import { injectable } from 'inversify';
+
+/** Dispatches a {@link RequestExportAction} (format `'svg'`) on `Ctrl+Shift+E`. */
+@injectable()
+export class RequestExportKeyListener extends KeyListener {
+    override keyDown(_element: GModelElement, event: KeyboardEvent): Action[] {
+        if (matchesKeystroke(event, 'KeyE', 'ctrlCmd', 'shift')) {
+            return [RequestExportAction.create('svg')];
+        }
+        return [];
+    }
+}

package/src/features/helper-lines/helper-line-feedback.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023-2025 EclipseSource and others.
+ * Copyright (c) 2023-2026 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -30,10 +30,10 @@ import {
     equalUpTo,
     isBoundsAware,
     isDecoration,
-    isViewport
+    isViewport,
+    partition
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
-import { partition } from 'lodash';
 import '../../../css/helper-lines.css';
 import { EditorContextService } from '../../base/editor-context-service';
 import { FeedbackCommand } from '../../base/feedback/feedback-command';
@@ -125,7 +125,9 @@ export class DrawHelperLinesFeedbackCommand extends FeedbackCommand {
         removeSelectionBounds(context.root);
         const alignableElements = getMatchingElements(context.root.index, this.isAlignableElementPredicate);
         this.log('All alignable elements: ', alignableElements);
-        const [referenceElements, elements] = partition(alignableElements, element => this.elementIds.includes(element.id));
+        const { match: referenceElements, rest: elements } = partition(alignableElements, (element): element is BoundsAwareModelElement =>
+            this.elementIds.includes(element.id)
+        );
         this.log('Split alignable elements into reference elements and other elements: ', referenceElements, elements);
         if (referenceElements.length === 0) {
             this.log('--> No helper lines as we do not have any reference elements.');

package/src/features/routing/edge-router.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2024 EclipseSource and others.
+ * Copyright (c) 2024-2026 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -114,7 +114,7 @@ export class GLSPBezierEdgeRouter extends BezierEdgeRouter {
     }
 }
 
-function ensureBounds(element?: GConnectableElement): boolean {
+export function ensureBounds(element?: GConnectableElement): boolean {
     if (!element) {
         return false;
     }

package/src/features/routing/routing-module.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2024 EclipseSource and others.
+ * Copyright (c) 2019-2026 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -32,6 +32,8 @@ import {
     configureCommand
 } from '@eclipse-glsp/sprotty';
 import { GLSPBezierEdgeRouter, GLSPManhattanEdgeRouter, GLSPPolylineEdgeRouter } from './edge-router';
+import { StickyManhattanDiamondAnchor, StickyManhattanEllipticAnchor, StickyManhattanRectangularAnchor } from './sticky-manhattan-anchors';
+import { GLSPStickyManhattanEdgeRouter } from './sticky-manhattan-edge-router';
 
 export const routingModule = new FeatureModule(
     (bind, unbind, isBound, rebind) => {
@@ -54,6 +56,11 @@ export const routingModule = new FeatureModule(
         bindAsService(context, TYPES.IAnchorComputer, BezierRectangleAnchor);
         bindAsService(context, TYPES.IAnchorComputer, BezierDiamondAnchor);
 
+        bindAsService(context, TYPES.IEdgeRouter, GLSPStickyManhattanEdgeRouter);
+        bindAsService(context, TYPES.IAnchorComputer, StickyManhattanEllipticAnchor);
+        bindAsService(context, TYPES.IAnchorComputer, StickyManhattanRectangularAnchor);
+        bindAsService(context, TYPES.IAnchorComputer, StickyManhattanDiamondAnchor);
+
         configureCommand({ bind, isBound }, AddRemoveBezierSegmentCommand);
     },
     { featureId: Symbol('routing') }

package/src/features/routing/sticky-manhattan-anchors.ts

@@ -0,0 +1,53 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import {
+    DIAMOND_ANCHOR_KIND,
+    ELLIPTIC_ANCHOR_KIND,
+    ManhattanDiamondAnchor,
+    ManhattanEllipticAnchor,
+    ManhattanRectangularAnchor,
+    RECTANGULAR_ANCHOR_KIND
+} from '@eclipse-glsp/sprotty';
+import { injectable } from 'inversify';
+import { GLSPStickyManhattanEdgeRouter } from './sticky-manhattan-edge-router';
+
+// Anchor computers are keyed by `<routerKind>:<anchorKind>` in the AnchorComputerRegistry.
+// The sticky router has its own routerKind, so dedicated subclasses must be registered even
+// though their geometry behavior is identical to the standard Manhattan anchors.
+
+@injectable()
+export class StickyManhattanRectangularAnchor extends ManhattanRectangularAnchor {
+    static override readonly KIND = GLSPStickyManhattanEdgeRouter.KIND + ':' + RECTANGULAR_ANCHOR_KIND;
+    override get kind(): string {
+        return StickyManhattanRectangularAnchor.KIND;
+    }
+}
+
+@injectable()
+export class StickyManhattanDiamondAnchor extends ManhattanDiamondAnchor {
+    static override readonly KIND = GLSPStickyManhattanEdgeRouter.KIND + ':' + DIAMOND_ANCHOR_KIND;
+    override get kind(): string {
+        return StickyManhattanDiamondAnchor.KIND;
+    }
+}
+
+@injectable()
+export class StickyManhattanEllipticAnchor extends ManhattanEllipticAnchor {
+    static override readonly KIND = GLSPStickyManhattanEdgeRouter.KIND + ':' + ELLIPTIC_ANCHOR_KIND;
+    override get kind(): string {
+        return StickyManhattanEllipticAnchor.KIND;
+    }
+}