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

package/src/base/action-dispatcher.ts

@@ -21,7 +21,9 @@ import {
     Deferred,
     EMPTY_ROOT,
     GModelRoot,
+    HandleActionResult,
     IActionDispatcher,
+    MaybePromise,
     RejectAction,
     RequestAction,
     ResponseAction,
@@ -132,17 +134,15 @@ export class GLSPActionDispatcher extends ActionDispatcher implements IGModelRoo
     }
 
     protected async handleResponseAction(action: ResponseAction): Promise<void> {
-        // clear any pending timeout
         const timeout = this.timeouts.get(action.responseId);
         if (timeout !== undefined) {
             clearTimeout(timeout);
             this.timeouts.delete(action.responseId);
         }
 
-        // check for matching request
         const request = this.requests.get(action.responseId);
         if (!request) {
-            // treat no matching request by dispatching action normally
+            // No pending request: re-dispatch as a normal action.
             this.logger.log(this, 'No matching request for response, dispatch normally', action);
             action.responseId = '';
             return this.handleAction(action);
@@ -150,7 +150,6 @@ export class GLSPActionDispatcher extends ActionDispatcher implements IGModelRoo
 
         this.requests.delete(action.responseId);
         if (RejectAction.is(action)) {
-            // translation reject action to request rejection
             request.reject(new Error(action.message));
             this.logger.warn(this, `Request with id ${action.responseId} failed.`, action.message, action.detail);
         } else {
@@ -169,34 +168,47 @@ export class GLSPActionDispatcher extends ActionDispatcher implements IGModelRoo
         }
         this.logger.warn(this, 'Missing handler for action', action);
         const error = new Error(`Missing handler for action '${action.kind}'`);
-        if (!RequestAction.is(action)) {
-            throw error;
-        }
-        const request = this.requests.get(action.requestId);
-        if (request !== undefined) {
-            this.requests.delete(action.requestId);
-            request.reject(error);
+        if (RequestAction.is(action)) {
+            const request = this.requests.get(action.requestId);
+            if (request !== undefined) {
+                this.requests.delete(action.requestId);
+                request.reject(error);
+            }
         }
+        throw error;
     }
 
     protected async handleActionWithHandler(action: Action, handlers: ActionHandler[]): Promise<void> {
         this.logger.log(this, 'Handle', action);
-        const handlerResults: Promise<any>[] = [];
+        // No `await` inside the loop: invoke handlers in one burst and await their results collectively.
+        const handlerResults: PromiseLike<unknown>[] = [];
         for (const handler of handlers) {
-            const result = await handler.handle(action);
-            if (Action.is(result)) {
-                handlerResults.push(this.dispatch(result));
-            } else if (result !== undefined) {
-                this.blockUntil = result.blockUntil;
-                handlerResults.push(this.commandStack.execute(result));
+            const maybeResult = handler.handle(action);
+            if (MaybePromise.isPromise(maybeResult)) {
+                handlerResults.push(maybeResult.then(result => this.processHandlerResult(result)));
+            } else {
+                const resultPromise = this.processHandlerResult(maybeResult);
+                if (resultPromise) {
+                    handlerResults.push(resultPromise);
+                }
             }
         }
         await Promise.all(handlerResults);
     }
 
+    protected processHandlerResult(result: HandleActionResult): Promise<unknown> | undefined {
+        if (Action.is(result)) {
+            return this.dispatch(result);
+        }
+        if (result !== undefined) {
+            this.blockUntil = result.blockUntil;
+            return this.commandStack.execute(result);
+        }
+        return undefined;
+    }
+
     override request<Res extends ResponseAction>(action: RequestAction<Res>): Promise<Res> {
-        if (!action.requestId && action.requestId === '') {
-            // No request id has been specified. So we use a generated one.
+        if (!action.requestId || action.requestId === '') {
             action.requestId = RequestAction.generateRequestId();
         }
         return super.request(action);
@@ -214,19 +226,20 @@ export class GLSPActionDispatcher extends ActionDispatcher implements IGModelRoo
      */
     requestUntil<Res extends ResponseAction>(
         action: RequestAction<Res>,
-        timeoutMs = 2000,
+        timeoutMs: number = action.timeout ?? 2000,
         rejectOnTimeout = false
     ): Promise<Res | undefined> {
-        if (!action.requestId && action.requestId === '') {
-            // No request id has been specified. So we use a generated one.
+        if (!action.requestId || action.requestId === '') {
             action.requestId = RequestAction.generateRequestId();
         }
+        // Stamp the effective timeout onto the action so the receiving side
+        // (handleServerRequest/handleClientRequest) can respect it.
+        action.timeout = timeoutMs;
 
         const requestId = action.requestId;
         const timeout = setTimeout(() => {
             const deferred = this.requests.get(requestId);
             if (deferred !== undefined) {
-                // cleanup
                 clearTimeout(timeout);
                 this.requests.delete(requestId);
 
@@ -240,6 +253,18 @@ export class GLSPActionDispatcher extends ActionDispatcher implements IGModelRoo
             }
         }, timeoutMs);
         this.timeouts.set(requestId, timeout);
-        return super.request<Res>(action);
+
+        const result = super.request<Res>(action);
+        // handleResponseAction only clears the timeout on the response path; clear it here on every
+        // other settle path (timeout, rejection, missing handler) so the timer and map entry can't leak.
+        const clearRequestTimeout = (): void => {
+            const pending = this.timeouts.get(requestId);
+            if (pending !== undefined) {
+                clearTimeout(pending);
+                this.timeouts.delete(requestId);
+            }
+        };
+        result.then(clearRequestTimeout, clearRequestTimeout);
+        return result;
     }
 }

package/src/base/default.module.ts

@@ -16,6 +16,8 @@
 import {
     ActionHandlerRegistry,
     FeatureModule,
+    GetEditorContextAction,
+    GetSelectionAction,
     KeyTool,
     LocationPostprocessor,
     MousePositionTracker,
@@ -83,6 +85,7 @@ export const defaultModule = new FeatureModule(
 
         configureActionHandler(context, SetEditModeAction.KIND, EditorContextService);
         configureActionHandler(context, SetDirtyStateAction.KIND, EditorContextService);
+        configureActionHandler(context, GetEditorContextAction.KIND, EditorContextService);
 
         bind(FocusTracker).toSelf().inSingletonScope();
         bind(TYPES.IDiagramStartup).toService(FocusTracker);
@@ -121,6 +124,7 @@ export const defaultModule = new FeatureModule(
         bind(SelectionService).toSelf().inSingletonScope();
         bind(TYPES.IGModelRootListener).toService(SelectionService);
         bind(TYPES.IDiagramStartup).toService(SelectionService);
+        configureActionHandler(context, GetSelectionAction.KIND, SelectionService);
 
         // Feedback Support ------------------------------------
         // Generic re-usable feedback modifying css classes

package/src/base/editor-context-service.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2025 EclipseSource and others.
+ * Copyright (c) 2020-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
@@ -21,14 +21,14 @@ import {
     DisposableCollection,
     EditMode,
     EditorContext,
+    EditorContextResult,
     Emitter,
     Event,
-    findParentByFeature,
     GModelElement,
     GModelRoot,
+    GetEditorContextAction,
     IActionDispatcher,
     IActionHandler,
-    isViewport,
     LazyInjector,
     MaybePromise,
     MousePositionTracker,
@@ -37,7 +37,9 @@ import {
     SetEditModeAction,
     TYPES,
     ValueChange,
-    Viewport
+    Viewport,
+    findParentByFeature,
+    isViewport
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable, postConstruct, preDestroy } from 'inversify';
 import { FocusChange, FocusTracker } from './focus/focus-tracker';
@@ -177,6 +179,8 @@ export class EditorContextService implements IActionHandler, Disposable, IDiagra
         return {
             selectedElementIds: Array.from(this.selectionService.getSelectedElementIDs()),
             lastMousePosition: this.mousePositionTracker.lastPositionOnDiagram,
+            viewport: this.viewportData,
+            canvasBounds: this.canvasBounds,
             args
         };
     }
@@ -185,18 +189,26 @@ export class EditorContextService implements IActionHandler, Disposable, IDiagra
         return {
             selectedElementIds,
             lastMousePosition: this.mousePositionTracker.lastPositionOnDiagram,
+            viewport: this.viewportData,
+            canvasBounds: this.canvasBounds,
             args
         };
     }
 
-    handle(action: Action): void {
+    handle(action: Action): Action | void {
         if (SetEditModeAction.is(action)) {
             this.handleSetEditModeAction(action);
         } else if (SetDirtyStateAction.is(action)) {
             this.handleSetDirtyStateAction(action);
+        } else if (GetEditorContextAction.is(action)) {
+            return this.handleGetEditorContext(action);
         }
     }
 
+    protected handleGetEditorContext(action: GetEditorContextAction): EditorContextResult {
+        return EditorContextResult.create(this.get(), { responseId: action.requestId });
+    }
+
     protected handleSetEditModeAction(action: SetEditModeAction): void {
         const oldValue = this._editMode;
         this._editMode = action.editMode;

package/src/base/model/diagram-loader.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023-2024 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
@@ -117,7 +117,7 @@ export namespace IDiagramStartup {
     }
 }
 
-export interface DiagramLoadingOptions {
+export interface DiagramLoadingOptions<P extends InitializeParameters = InitializeParameters> {
     /**
      * Optional custom options that should be used the initial {@link RequestModelAction}.
      * These options will be merged with the default options (`diagramType` and `sourceUri`).
@@ -126,10 +126,12 @@ export interface DiagramLoadingOptions {
     requestModelOptions?: Args;
 
     /**
-     * Optional partial {@link InitializeParameters} that should be used for {@link GLSPClient.initializeServer} request if the underlying
-     * {@link GLSPClient} has not been initialized yet.
+     * Optional partial {@link InitializeParameters} that should be used for {@link GLSPClient.initializeServer}
+     * request if the underlying {@link GLSPClient} has not been initialized yet. The generic type parameter
+     * `P` lets callers narrow this to a more specific extension type (e.g., `McpInitializeParameters`)
+     * without leaking that extension into the base loader API.
      */
-    initializeParameters?: Partial<InitializeParameters>;
+    initializeParameters?: Partial<P>;
 
     /**
      * Flag to enable/disable client side notifications during the loading process.
@@ -171,7 +173,7 @@ export class DiagramLoader {
         return this.lazyInjector.getAll<IDiagramStartup>(TYPES.IDiagramStartup);
     }
 
-    async load(options: DiagramLoadingOptions = {}): Promise<void> {
+    async load<P extends InitializeParameters = InitializeParameters>(options: DiagramLoadingOptions<P> = {}): Promise<void> {
         this.diagramStartups.sort(Ranked.sort);
         await this.invokeStartupHook('preLoadDiagram');
         const resolvedOptions: ResolvedDiagramLoadingOptions = {

package/src/base/model/glsp-model-source.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023-2024 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
@@ -22,10 +22,14 @@ import {
     DisposeClientSessionParameters,
     GLSPClient,
     GModelRootSchema,
+    IActionDispatcher,
     ILogger,
     InitializeClientSessionParameters,
     InitializeResult,
     ModelSource,
+    RejectAction,
+    RequestAction,
+    ResponseAction,
     TYPES
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable, preDestroy } from 'inversify';
@@ -94,6 +98,8 @@ export class GLSPModelSource extends ModelSource implements Disposable {
     @inject(TYPES.IDiagramOptions)
     protected options: IDiagramOptions;
 
+    declare readonly actionDispatcher: IActionDispatcher;
+
     protected toDispose = new DisposableCollection();
     clientId: string;
 
@@ -164,9 +170,37 @@ export class GLSPModelSource extends ModelSource implements Disposable {
         const action = message.action;
         ServerAction.mark(action);
         this.logger.log(this, 'receiving', action);
+        if (RequestAction.is(action)) {
+            this.handleServerRequest(action);
+            return;
+        }
         this.actionDispatcher.dispatch(action);
     }
 
+    // Fire-and-forget: intentionally not awaited by messageReceived()
+    protected async handleServerRequest(action: RequestAction<ResponseAction>): Promise<void> {
+        try {
+            const response =
+                action.timeout !== undefined
+                    ? await this.actionDispatcher.requestUntil(action, action.timeout, true)
+                    : await this.actionDispatcher.request(action);
+            if (response) {
+                this.sendResponseToServer(response);
+            }
+        } catch (error) {
+            this.logger.error(this, `Failed to handle server request '${action.kind}' (${action.requestId})`, error);
+            const reject = RejectAction.create(`Failed to handle request '${action.kind}' (${action.requestId})`, {
+                responseId: action.requestId,
+                detail: error?.toString?.()
+            });
+            this.sendResponseToServer(reject);
+        }
+    }
+
+    protected sendResponseToServer(response: ResponseAction): void {
+        this.forwardToServer(response);
+    }
+
     override initialize(registry: GLSPActionHandlerRegistry): void {
         // Registering actions here is discouraged and it's recommended
         // to implemented dedicated action handlers.

package/src/base/selection-service.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
@@ -23,12 +23,15 @@ import {
     Emitter,
     Event,
     GChildElement,
+    GetSelectionAction,
     GModelElement,
     GModelRoot,
+    IActionHandler,
     ILogger,
     LazyInjector,
     SelectAction,
     SelectAllAction,
+    SelectionResult,
     SprottySelectAllCommand,
     SprottySelectCommand,
     TYPES,
@@ -60,7 +63,7 @@ export interface SelectionChange {
 }
 
 @injectable()
-export class SelectionService implements IGModelRootListener, Disposable, IDiagramStartup {
+export class SelectionService implements IGModelRootListener, IActionHandler, Disposable, IDiagramStartup {
     @inject(TYPES.IFeedbackActionDispatcher)
     protected feedbackDispatcher: IFeedbackActionDispatcher;
 
@@ -84,6 +87,12 @@ export class SelectionService implements IGModelRootListener, Disposable, IDiagr
         this.lazyInjector.getAll<ISelectionListener>(TYPES.ISelectionListener).forEach(listener => this.addListener(listener));
     }
 
+    handle(action: Action): Action | void {
+        if (GetSelectionAction.is(action)) {
+            return SelectionResult.create(this.getSelectedElementIDs(), action.requestId);
+        }
+    }
+
     @preDestroy()
     dispose(): void {
         this.toDispose.dispose();

package/src/base/shortcuts/available-shortcuts-extension.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023-2025 Business Informatics Group (TU Wien) and others.
+ * Copyright (c) 2023-2026 Business Informatics Group (TU Wien) 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
@@ -14,9 +14,8 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { GModelRoot, matchesKeystroke, TYPES } from '@eclipse-glsp/sprotty';
+import { GModelRoot, groupBy, matchesKeystroke, TYPES } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
-import { groupBy } from 'lodash';
 import { GLSPAbstractUIExtension } from '../../base/ui-extension/ui-extension';
 import { messages } from '../messages';
 import type { IShortcutManager, ShortcutRegistration } from './shortcuts-manager';
@@ -79,7 +78,7 @@ export class AvailableShortcutsUIExtension extends GLSPAbstractUIExtension {
         headerRow.appendChild(keybindingCell);
         tableHead.appendChild(headerRow);
 
-        for (const [group, shortcuts] of Object.entries(grouped)) {
+        for (const [group, shortcuts] of grouped.entries()) {
             tableBody.appendChild(this.createGroupHeader(group));
             shortcuts.forEach(s => {
                 tableBody.appendChild(this.createEntry(s));

package/src/base/view/mouse-tool.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
@@ -18,6 +18,7 @@ import {
     Disposable,
     GModelElement,
     GModelRoot,
+    groupBy,
     LazyInjector,
     MaybePromise,
     MouseListener,
@@ -51,7 +52,7 @@ export class GLSPMouseTool extends MouseTool implements IDiagramStartup {
 
     override register(mouseListener: MouseListener): void {
         super.register(mouseListener);
-        this.rankedMouseListeners = groupBy(this.mouseListeners, listener => Ranked.getRank(listener));
+        this.rankedMouseListeners = groupBy(this.mouseListeners, listener => Ranked.getRank(listener), true);
     }
 
     registerListener(mouseListener: MouseListener): Disposable {
@@ -61,7 +62,7 @@ export class GLSPMouseTool extends MouseTool implements IDiagramStartup {
 
     override deregister(mouseListener: MouseListener): void {
         super.deregister(mouseListener);
-        this.rankedMouseListeners = groupBy(this.mouseListeners, listener => Ranked.getRank(listener));
+        this.rankedMouseListeners = groupBy(this.mouseListeners, listener => Ranked.getRank(listener), true);
     }
 
     protected override handleEvent<K extends MouseListenerMethods>(methodName: K, model: GModelRoot, event: MouseEvent): void {
@@ -104,19 +105,3 @@ export class GLSPMouseTool extends MouseTool implements IDiagramStartup {
         }
     }
 }
-
-function groupBy<K, T>(array: Array<T>, keyFunction: (x: T) => K): Map<K, T[]> {
-    const unsortedMap = array.reduce((result: Map<K, T[]>, item: T) => {
-        const key = keyFunction(item);
-        if (!result.has(key)) {
-            result.set(key, [item]);
-        } else {
-            const entries = result.get(key);
-            if (entries) {
-                entries.push(item);
-            }
-        }
-        return result;
-    }, new Map<K, T[]>());
-    return new Map<K, T[]>([...unsortedMap.entries()].sort());
-}

package/src/features/change-bounds/move-element-handler.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023-2025 Business Informatics Group (TU Wien) and others.
+ * Copyright (c) 2023-2026 Business Informatics Group (TU Wien) 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
@@ -17,6 +17,7 @@
 import {
     Action,
     ChangeBoundsOperation,
+    DebouncedFunc,
     ElementAndBounds,
     ElementMove,
     IActionDispatcher,
@@ -27,10 +28,10 @@ import {
     MoveViewportAction,
     Point,
     TYPES,
+    debounce,
     isBoundsAware
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional, postConstruct } from 'inversify';
-import { DebouncedFunc, debounce } from 'lodash';
 import { EditorContextService } from '../../base/editor-context-service';
 import { IFeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
 import { FeedbackEmitter } from '../../base/feedback/feedback-emitter';

package/src/features/change-bounds/resize/resize-handler.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023-2025 Business Informatics Group (TU Wien) and others.
+ * Copyright (c) 2023-2026 Business Informatics Group (TU Wien) 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
@@ -17,6 +17,7 @@
 import {
     Action,
     ChangeBoundsOperation,
+    DebouncedFunc,
     Dimension,
     ElementAndBounds,
     GModelElement,
@@ -27,10 +28,10 @@ import {
     ISnapper,
     Point,
     SetBoundsAction,
-    TYPES
+    TYPES,
+    debounce
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional, postConstruct } from 'inversify';
-import { DebouncedFunc, debounce } from 'lodash';
 import { EditorContextService } from '../../../base/editor-context-service';
 import { IFeedbackActionDispatcher } from '../../../base/feedback/feedback-action-dispatcher';
 import { FeedbackEmitter } from '../../../base/feedback/feedback-emitter';

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

@@ -0,0 +1,145 @@
+/********************************************************************************
+ * 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, PngExportOptions } from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { DiagramExporter } from './diagram-exporter';
+import { GLSPSvgExporter } from './glsp-svg-exporter';
+
+/** Default raster width (in CSS px) when neither `width` nor `height` is specified. */
+const DEFAULT_PNG_WIDTH = 1024;
+const DEFAULT_PNG_BACKGROUND = 'white';
+
+/**
+ * Default PNG strategy for the unified export registry. Reuses {@link GLSPSvgExporter}'s
+ * SVG-rendering pipeline and rasterises the result client-side via `OffscreenCanvas`.
+ * Adopters that need server-side rendering replace this binding with their own strategy.
+ */
+@injectable()
+export class DefaultPngDiagramExporter implements DiagramExporter<PngExportOptions> {
+    readonly format: ExportFormat = 'png';
+    readonly mimeType: ExportMimeType = 'image/png';
+    readonly encoding = 'base64' as const;
+
+    @inject(GLSPSvgExporter) protected svgExporter: GLSPSvgExporter;
+
+    async export(root: GModelRoot, options: PngExportOptions = {}, cause?: Action): Promise<string> {
+        if (typeof document === 'undefined' || typeof OffscreenCanvas === 'undefined') {
+            throw new Error('PNG export failed: requires a DOM environment with OffscreenCanvas support');
+        }
+        const svgString = this.svgExporter.exportToString(root, options, cause);
+        const { width, height } = this.computeDimensions(svgString, options);
+        // Pin the SVG root to the target raster size BEFORE loading into `<img>` so the browser
+        // rasterises the vector content at full resolution.
+        const sizedSvg = this.applyRasterSize(svgString, width, height);
+        const blob = await this.rasterise(sizedSvg, width, height, options.background ?? DEFAULT_PNG_BACKGROUND);
+        return this.blobToBase64(blob);
+    }
+
+    /**
+     * Rewrite the root `<svg>` tag so its rendered size matches the target raster dimensions.
+     * Replaces `width`/`height` attributes and strips conflicting `style` declarations
+     * (the SVG exporter emits `width: …px !important` on the inline style for viewer-friendly
+     * display, which would otherwise win over the attributes). The existing `viewBox`
+     * preserves the vector coordinate system so the content scales without distortion.
+     */
+    protected applyRasterSize(svgString: string, width: number, height: number): string {
+        return svgString.replace(/<svg\b([^>]*)>/, (_, attrs: string) => {
+            const cleaned = attrs
+                .replace(/\swidth="[^"]*"/, '')
+                .replace(/\sheight="[^"]*"/, '')
+                .replace(/style="([^"]*)"/, (_match, styleBody: string) => {
+                    const stripped = styleBody
+                        .replace(/(?:^|;)\s*width\s*:[^;]*/gi, '')
+                        .replace(/(?:^|;)\s*height\s*:[^;]*/gi, '')
+                        .replace(/^\s*;+/, '')
+                        .trim();
+                    return stripped ? `style="${stripped}"` : '';
+                });
+            return `<svg${cleaned} width="${width}" height="${height}">`;
+        });
+    }
+
+    protected computeDimensions(svgString: string, options: PngExportOptions): { width: number; height: number } {
+        const requestedWidth = options.width ?? DEFAULT_PNG_WIDTH;
+        const requestedHeight = options.height;
+        if (requestedHeight !== undefined) {
+            return { width: requestedWidth, height: requestedHeight };
+        }
+        // Read the aspect from the SVG attributes directly to avoid a redundant bitmap decode.
+        const aspect = this.parseAspectRatio(svgString);
+        return { width: requestedWidth, height: requestedWidth / aspect };
+    }
+
+    /**
+     * Read the aspect ratio from the root `<svg>` tag's `viewBox`, falling back to the
+     * `width`/`height` attributes. GLSP-emitted SVGs always carry a `viewBox` (set by the
+     * underlying sprotty exporter), so the fallback is a defensive safeguard.
+     */
+    protected parseAspectRatio(svgString: string): number {
+        const root = svgString.match(/<svg\b([^>]*)>/);
+        const attrs = root?.[1] ?? '';
+        const viewBox = attrs.match(/viewBox\s*=\s*"\s*[\d.eE+-]+\s+[\d.eE+-]+\s+([\d.eE+-]+)\s+([\d.eE+-]+)\s*"/);
+        if (viewBox) {
+            return parseFloat(viewBox[1]) / parseFloat(viewBox[2]);
+        }
+        const widthAttr = attrs.match(/\swidth\s*=\s*"([\d.eE+-]+)/);
+        const heightAttr = attrs.match(/\sheight\s*=\s*"([\d.eE+-]+)/);
+        if (widthAttr && heightAttr) {
+            return parseFloat(widthAttr[1]) / parseFloat(heightAttr[1]);
+        }
+        throw new Error('PNG export failed: SVG missing viewBox/width/height — cannot determine aspect ratio');
+    }
+
+    protected async rasterise(svgString: string, width: number, height: number, background: string): Promise<Blob> {
+        const url = URL.createObjectURL(new Blob([svgString], { type: 'image/svg+xml;charset=utf-8' }));
+        try {
+            const bitmap = await this.bitmapFromSvgUrl(url);
+            const offscreen = new OffscreenCanvas(width, height);
+            const ctx = offscreen.getContext('2d');
+            if (!ctx) {
+                throw new Error('PNG export failed: 2D context unavailable on OffscreenCanvas');
+            }
+            ctx.fillStyle = background;
+            ctx.fillRect(0, 0, width, height);
+            ctx.drawImage(bitmap, 0, 0, width, height);
+            return offscreen.convertToBlob({ type: 'image/png' });
+        } finally {
+            URL.revokeObjectURL(url);
+        }
+    }
+
+    protected bitmapFromSvgUrl(url: string): Promise<ImageBitmap> {
+        return new Promise((resolve, reject) => {
+            const img = new Image();
+            img.onload = () => createImageBitmap(img).then(resolve, reject);
+            img.onerror = () => reject(new Error('PNG export failed: SVG could not be loaded into Image'));
+            img.src = url;
+        });
+    }
+
+    protected blobToBase64(blob: Blob): Promise<string> {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onloadend = () => {
+                const result = reader.result as string;
+                resolve(result.replace(/^data:[^;]+;base64,/, ''));
+            };
+            reader.onerror = () => reject(reader.error ?? new Error('PNG export failed: FileReader error'));
+            reader.readAsDataURL(blob);
+        });
+    }
+}