From 3a357075aa1f987b7d33d58c4d2d2fab684b1ae6 Mon Sep 17 00:00:00 2001
From: e-filchenko-bosh <FVI2FE@bosch.com>
Date: Wed, 26 Aug 2026 15:28:04 +0300
Subject: [PATCH 1/7] Add graphical view functionality and enhance language
 client integration

---
 .vscode-test.mjs                             |   3 +
 package.json                                 |  13 +-
 src/aspectValidation.ts                      |   2 +-
 src/extension.ts                             |  41 ++
 src/graphicalView.ts                         | 611 +++++++++++++++++++
 src/graphicalViewPanel.ts                    | 101 +++
 src/graphicalViewProtocol.ts                 | 147 +++++
 src/languageClient.ts                        |  63 +-
 src/test/graphicalViewController.test.ts     | 346 +++++++++++
 src/test/graphicalViewTestHarness.ts         | 286 +++++++++
 src/test/languageClientGraphicalView.test.ts | 141 +++++
 11 files changed, 1744 insertions(+), 10 deletions(-)
 create mode 100644 src/graphicalView.ts
 create mode 100644 src/graphicalViewPanel.ts
 create mode 100644 src/graphicalViewProtocol.ts
 create mode 100644 src/test/graphicalViewController.test.ts
 create mode 100644 src/test/graphicalViewTestHarness.ts
 create mode 100644 src/test/languageClientGraphicalView.test.ts

diff --git a/.vscode-test.mjs b/.vscode-test.mjs
index d320b89..b36d3f4 100644
--- a/.vscode-test.mjs
+++ b/.vscode-test.mjs
@@ -1,7 +1,10 @@
 import { defineConfig } from '@vscode/test-cli';
 
+const vscodeExecutablePath = process.env.VSCODE_EXECUTABLE_PATH;
+
 export default defineConfig({
 	files: 'out/test/**/*.test.js',
+	...(vscodeExecutablePath ? { useInstallation: { fromPath: vscodeExecutablePath } } : {}),
 	launchArgs: [
 		'--user-data-dir=/tmp/extension-vscode-test-user-data',
 		'--extensions-dir=/tmp/extension-vscode-test-extensions'
diff --git a/package.json b/package.json
index 5c65ebf..87ade76 100644
--- a/package.json
+++ b/package.json
@@ -39,6 +39,12 @@
         "command": "turtle.selectSammCliExecutable",
         "title": "Select SAMM CLI Executable",
         "category": "Turtle"
+      },
+      {
+        "command": "turtle.openGraphicalView",
+        "title": "Open Graphical View",
+        "category": "Turtle",
+        "enablement": "editorLangId == turtle"
       }
     ],
     "languages": [
@@ -113,6 +119,11 @@
           "command": "turtle.validateDocumentNow",
           "when": "resourceLangId == turtle",
           "group": "1_modification"
+        },
+        {
+          "command": "turtle.openGraphicalView",
+          "when": "resourceLangId == turtle",
+          "group": "1_modification@2"
         }
       ]
     },
@@ -172,4 +183,4 @@
     "tar": "^7.5.15",
     "vscode-languageclient": "^9.0.1"
   }
-}
\ No newline at end of file
+}
diff --git a/src/aspectValidation.ts b/src/aspectValidation.ts
index 9dbf802..125d94b 100644
--- a/src/aspectValidation.ts
+++ b/src/aspectValidation.ts
@@ -30,7 +30,7 @@ export interface DiagnosticReport {
 }
 
 export interface RequestClient {
-    sendRequest<R>(method: string, params?: unknown): Thenable<R>;
+    sendRequest<R>(method: string, params?: unknown, token?: vscode.CancellationToken): Thenable<R>;
 }
 
 export interface ValidationWindow {
diff --git a/src/extension.ts b/src/extension.ts
index 8bc4388..f396302 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -18,6 +18,8 @@ import { SammCliDownloader } from './sammCliDownloader';
 import { TurtleExtensionSettings } from './settings';
 import { TurtleLanguageClient } from './languageClient';
 import type { ExtensionLogger } from './outputChannel';
+import { GraphicalViewController } from './graphicalView';
+import { VscodeGraphicalViewPanelFactory } from './graphicalViewPanel';
 
 const SELECT_EXECUTABLE_COMMAND = 'turtle.selectSammCliExecutable';
 const SELECT_EXECUTABLE_TITLE = 'Select SAMM CLI Executable';
@@ -27,6 +29,7 @@ let settings: TurtleExtensionSettings;
 let languageServer: TurtleLanguageServer | undefined;
 let languageClient: TurtleLanguageClient;
 let aspectValidationController: AspectValidationController;
+let graphicalViewController: GraphicalViewController;
 let sammCliDownloader: SammCliDownloader;
 
 let outputChannel: ExtensionLogger;
@@ -43,6 +46,40 @@ export async function activate(ctx: vscode.ExtensionContext): Promise<void> {
     languageClient = new TurtleLanguageClient(outputChannel, settings.getSammCliLspServerPort(), settings.getLanguageClientTraceLevel());
     aspectValidationController = new AspectValidationController(createUnavailableClient(), vscode.window, vscode.workspace, outputChannel);
     aspectValidationController.register(context);
+    graphicalViewController = new GraphicalViewController(
+        undefined,
+        new VscodeGraphicalViewPanelFactory(),
+        vscode.commands,
+        vscode.window,
+        {
+            onDidSaveTextDocument: listener => vscode.workspace.onDidSaveTextDocument(listener),
+            onDidChangeDocumentAvailability: listener =>
+                vscode.Disposable.from(
+                    vscode.workspace.onDidOpenTextDocument(document => listener(document.uri.toString(), true)),
+                    vscode.workspace.onDidCloseTextDocument(document => listener(document.uri.toString(), false)),
+                    vscode.window.tabGroups.onDidChangeTabs(event => {
+                        for (const tab of event.closed) {
+                            if (tab.input instanceof vscode.TabInputText) {
+                                const sourceUri = tab.input.uri.toString();
+                                const remainsOpen = vscode.window.tabGroups.all.some(group =>
+                                    group.tabs.some(
+                                        candidate =>
+                                            candidate.input instanceof vscode.TabInputText &&
+                                            candidate.input.uri.toString() === sourceUri,
+                                    ),
+                                );
+                                if (!remainsOpen) {
+                                    listener(sourceUri, false);
+                                }
+                            }
+                        }
+                    }),
+                ),
+            isDocumentAvailable: uri => vscode.workspace.textDocuments.some(document => document.uri.toString() === uri),
+        },
+        outputChannel,
+    );
+    graphicalViewController.register(context);
 
     context.subscriptions.push(
         vscode.commands.registerCommand(SELECT_EXECUTABLE_COMMAND, async () => {
@@ -112,6 +149,7 @@ async function restartLanguageServices(reason: string): Promise<void> {
     outputChannel.info(`Restarting language services (${reason}).`);
 
     aspectValidationController.setClient(createUnavailableClient());
+    graphicalViewController.setClient(undefined);
     await languageClient.disconnect();
     await stopLanguageServer();
 
@@ -124,6 +162,7 @@ async function restartLanguageServices(reason: string): Promise<void> {
     } catch (error) {
         await stopLanguageServer().catch(() => undefined);
         aspectValidationController.setClient(createUnavailableClient());
+        graphicalViewController.setClient(undefined);
 
         throw error;
     }
@@ -132,6 +171,7 @@ async function restartLanguageServices(reason: string): Promise<void> {
     await nextClient.connect();
     languageClient = nextClient;
     aspectValidationController.setClient(nextClient);
+    graphicalViewController.setClient(nextClient);
 }
 
 type SammCliQuickPickItem = vscode.QuickPickItem & {
@@ -257,6 +297,7 @@ function createUnavailableClient(): RequestClient {
 }
 
 export async function deactivate(): Promise<void> {
+    graphicalViewController?.dispose();
     await restartChain;
     await languageClient.disconnect();
     await stopLanguageServer();
diff --git a/src/graphicalView.ts b/src/graphicalView.ts
new file mode 100644
index 0000000..f412aa1
--- /dev/null
+++ b/src/graphicalView.ts
@@ -0,0 +1,611 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ *
+ * See the AUTHORS file(s) distributed with this work for additional
+ * information regarding authorship.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import * as vscode from 'vscode';
+import type {ExtensionLogger} from './outputChannel';
+import {
+    GraphicalViewRenderResult,
+    GraphicalViewRenderWarning,
+    GraphicalViewRequestClient,
+    GraphicalViewTarget,
+    isGraphicalViewRenderResult,
+} from './graphicalViewProtocol';
+
+export const OPEN_GRAPHICAL_VIEW_COMMAND = 'turtle.openGraphicalView';
+
+export type GraphicalViewStatus =
+    | Readonly<{kind: 'loading'; message: string}>
+    | Readonly<{kind: 'ready'; message: string}>
+    | Readonly<{kind: 'stale'; reason: string; message: string}>
+    | Readonly<{kind: 'unsupported'; message: string}>
+    | Readonly<{kind: 'disconnected'; message: string}>;
+
+export interface GraphicalViewAcceptedResult {
+    readonly uri: string;
+    readonly svg: string;
+    readonly targets: readonly Readonly<GraphicalViewTarget>[];
+    readonly warnings: readonly GraphicalViewRenderWarning[];
+    readonly targetById: ReadonlyMap<string, Readonly<GraphicalViewTarget>>;
+}
+
+export type GraphicalViewDelivery =
+    | Readonly<{type: 'status'; uri: string; status: GraphicalViewStatus}>
+    | Readonly<{type: 'render'; uri: string; svg: string; warnings: readonly GraphicalViewRenderWarning[]}>;
+
+export type GraphicalViewPanelMessage = Readonly<{type: 'ready'}> | Readonly<{type: 'refresh'}> | Readonly<{type: 'navigate'; targetId: string}>;
+
+export interface GraphicalViewPanelAdapter extends vscode.Disposable {
+    readonly visible: boolean;
+    reveal(): void;
+    deliver(delivery: GraphicalViewDelivery): void;
+    onDidDispose(listener: () => void): vscode.Disposable;
+    onDidChangeVisibility(listener: (visible: boolean) => void): vscode.Disposable;
+    onDidReceiveMessage(listener: (message: unknown) => void): vscode.Disposable;
+}
+
+export interface GraphicalViewPanelFactory {
+    create(sourceUri: string): GraphicalViewPanelAdapter;
+}
+
+export interface GraphicalViewDocument {
+    readonly languageId: string;
+    readonly uri: vscode.Uri;
+}
+
+export interface GraphicalViewWindow {
+    readonly activeTextEditor: {readonly document: GraphicalViewDocument} | undefined;
+    showWarningMessage(message: string): Thenable<unknown>;
+}
+
+export interface GraphicalViewWorkspace {
+    onDidSaveTextDocument(listener: (document: GraphicalViewDocument) => void): vscode.Disposable;
+    onDidChangeDocumentAvailability(listener: (sourceUri: string, available: boolean) => void): vscode.Disposable;
+    isDocumentAvailable(uri: string): boolean;
+}
+
+export interface GraphicalViewCommands {
+    registerCommand(command: string, callback: () => unknown): vscode.Disposable;
+}
+
+export interface GraphicalViewControllerContext {
+    subscriptions: vscode.Disposable[];
+}
+
+export interface GraphicalViewPanelSnapshot {
+    readonly sourceUri: string;
+    readonly sequence: number;
+    readonly visible: boolean;
+    readonly disposed: boolean;
+    readonly status: GraphicalViewStatus;
+    readonly lastSuccess: GraphicalViewAcceptedResult | undefined;
+}
+
+interface PanelState {
+    readonly sourceUri: string;
+    readonly panel: GraphicalViewPanelAdapter;
+    readonly subscriptions: vscode.Disposable[];
+    sequence: number;
+    sourceAvailable: boolean;
+    visible: boolean;
+    disposed: boolean;
+    cancellation: vscode.CancellationTokenSource | undefined;
+    status: GraphicalViewStatus;
+    lastSuccess: GraphicalViewAcceptedResult | undefined;
+}
+
+const DISCONNECTED_STATUS: GraphicalViewStatus = Object.freeze({
+    kind: 'disconnected',
+    message: 'The Turtle language server is disconnected. Reconnect and use Refresh to try again.',
+});
+
+export class GraphicalViewController implements vscode.Disposable {
+    private readonly panels = new Map<string, PanelState>();
+    private readonly subscriptions: vscode.Disposable[] = [];
+    private clientSubscription: vscode.Disposable | undefined;
+    private registered = false;
+    private disposed = false;
+
+    constructor(
+        private client: GraphicalViewRequestClient | undefined,
+        private readonly panelFactory: GraphicalViewPanelFactory,
+        private readonly commands: GraphicalViewCommands,
+        private readonly window: GraphicalViewWindow,
+        private readonly workspace: GraphicalViewWorkspace,
+        private readonly outputChannel: ExtensionLogger,
+        private readonly createCancellationSource: () => vscode.CancellationTokenSource = () => new vscode.CancellationTokenSource(),
+    ) {
+        this.subscribeToClient();
+    }
+
+    register(context: GraphicalViewControllerContext): void {
+        if (this.registered || this.disposed) {
+            return;
+        }
+        this.registered = true;
+
+        this.subscriptions.push(
+            this.commands.registerCommand(OPEN_GRAPHICAL_VIEW_COMMAND, () => this.openGraphicalView(this.window.activeTextEditor?.document)),
+            this.workspace.onDidSaveTextDocument(document => this.handleSave(document)),
+            this.workspace.onDidChangeDocumentAvailability((sourceUri, available) =>
+                this.handleDocumentAvailability(sourceUri, available),
+            ),
+        );
+        context.subscriptions.push(this);
+    }
+
+    async openGraphicalView(document: GraphicalViewDocument | undefined): Promise<GraphicalViewPanelSnapshot | undefined> {
+        if (!document || document.languageId !== 'turtle') {
+            await this.window.showWarningMessage('Open a Turtle file before opening the graphical view.');
+            return undefined;
+        }
+
+        const sourceUri = document.uri.toString();
+        const existing = this.panels.get(sourceUri);
+        if (existing && !existing.disposed) {
+            existing.panel.reveal();
+            return this.snapshot(existing);
+        }
+
+        const panel = this.panelFactory.create(sourceUri);
+        const state: PanelState = {
+            sourceUri,
+            panel,
+            subscriptions: [],
+            sequence: 0,
+            sourceAvailable: this.workspace.isDocumentAvailable(sourceUri),
+            visible: panel.visible,
+            disposed: false,
+            cancellation: undefined,
+            status: Object.freeze({kind: 'loading', message: 'Preparing graphical view...'}),
+            lastSuccess: undefined,
+        };
+        this.panels.set(sourceUri, state);
+        state.subscriptions.push(
+            panel.onDidDispose(() => this.disposePanelState(state, false)),
+            panel.onDidChangeVisibility(visible => this.handleVisibilityChange(state, visible)),
+            panel.onDidReceiveMessage(message => this.handlePanelMessage(state, message)),
+        );
+        void this.requestRender(state, 'initial');
+        return this.snapshot(state);
+    }
+
+    setClient(client: GraphicalViewRequestClient | undefined): void {
+        if (this.disposed) {
+            return;
+        }
+
+        this.clientSubscription?.dispose();
+        this.clientSubscription = undefined;
+        this.client = client;
+        for (const state of this.panels.values()) {
+            this.invalidate(state);
+            this.setStatus(state, client?.isGraphicalViewAvailable() ? availableAgainStatus(state) : DISCONNECTED_STATUS);
+        }
+        this.subscribeToClient();
+    }
+
+    getPanelCount(): number {
+        return this.panels.size;
+    }
+
+    getPanelState(sourceUri: string): GraphicalViewPanelSnapshot | undefined {
+        const state = this.panels.get(sourceUri);
+        return state ? this.snapshot(state) : undefined;
+    }
+
+    dispose(): void {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        this.clientSubscription?.dispose();
+        this.clientSubscription = undefined;
+        for (const subscription of this.subscriptions.splice(0)) {
+            subscription.dispose();
+        }
+        for (const state of [...this.panels.values()]) {
+            this.disposePanelState(state, true);
+        }
+    }
+
+    private subscribeToClient(): void {
+        if (!this.client || this.disposed) {
+            return;
+        }
+        this.clientSubscription = this.client.onDidChangeGraphicalViewAvailability(available => this.handleClientAvailability(available));
+    }
+
+    private handleClientAvailability(available: boolean): void {
+        for (const state of this.panels.values()) {
+            if (!available) {
+                this.invalidate(state);
+                this.setStatus(state, DISCONNECTED_STATUS);
+            } else {
+                this.setStatus(state, availableAgainStatus(state));
+            }
+        }
+    }
+
+    private handleSave(document: GraphicalViewDocument): void {
+        const state = this.panels.get(document.uri.toString());
+        if (!state || state.disposed) {
+            return;
+        }
+
+        if (!state.visible) {
+            this.invalidate(state);
+            this.setStatus(state, retainedAfterHiddenSaveStatus(state));
+            return;
+        }
+
+        void this.requestRender(state, 'save');
+    }
+
+    private handleDocumentAvailability(sourceUri: string, available: boolean): void {
+        const state = this.panels.get(sourceUri);
+        if (!state || state.disposed || state.sourceAvailable === available) {
+            return;
+        }
+
+        state.sourceAvailable = available;
+        if (available) {
+            return;
+        }
+
+        this.invalidate(state);
+        this.setStatus(state, retainedAfterSourceLossStatus(state));
+    }
+
+    private handleVisibilityChange(state: PanelState, visible: boolean): void {
+        if (!this.isCurrent(state)) {
+            return;
+        }
+        state.visible = visible;
+        if (visible) {
+            this.deliverCurrentState(state);
+        }
+    }
+
+    private handlePanelMessage(state: PanelState, message: unknown): void {
+        if (!this.isCurrent(state) || !isPanelMessage(message)) {
+            return;
+        }
+
+        switch (message.type) {
+            case 'ready':
+                this.deliverCurrentState(state);
+                return;
+            case 'refresh':
+                if (state.visible) {
+                    void this.requestRender(state, 'manual');
+                }
+                return;
+            case 'navigate':
+                // Task 4 validates current-sidecar membership and resolves navigation.
+                return;
+        }
+    }
+
+    private async requestRender(state: PanelState, trigger: 'initial' | 'manual' | 'save'): Promise<void> {
+        if (!this.isCurrent(state)) {
+            return;
+        }
+
+        this.cancelCurrent(state);
+        const sequence = ++state.sequence;
+        const sourceUri = state.sourceUri;
+
+        state.sourceAvailable = this.workspace.isDocumentAvailable(sourceUri);
+        if (!state.sourceAvailable) {
+            this.setStatus(
+                state,
+                Object.freeze({
+                    kind: 'stale',
+                    reason: 'sourceUnavailable',
+                    message: 'The source document is not available to the language server. Reopen it and use Refresh.',
+                }),
+            );
+            return;
+        }
+
+        const client = this.client;
+        if (!client?.isGraphicalViewAvailable()) {
+            this.setStatus(state, DISCONNECTED_STATUS);
+            return;
+        }
+
+        const cancellation = this.createCancellationSource();
+        state.cancellation = cancellation;
+        this.setStatus(state, Object.freeze({kind: 'loading', message: `Rendering graphical view (${trigger})...`}));
+
+        try {
+            const result = await client.renderGraphicalView({uri: sourceUri}, cancellation.token);
+            if (!this.isCurrentRequest(state, sourceUri, sequence, cancellation)) {
+                return;
+            }
+            state.cancellation = undefined;
+            cancellation.dispose();
+            this.handleRenderResult(state, result);
+        } catch (error) {
+            if (!this.isCurrentRequest(state, sourceUri, sequence, cancellation)) {
+                return;
+            }
+            state.cancellation = undefined;
+            cancellation.dispose();
+            this.handleRenderFailure(state, error);
+        }
+    }
+
+    private handleRenderResult(state: PanelState, result: unknown): void {
+        if (!isGraphicalViewRenderResult(result)) {
+            this.setStale(state, 'invalidResponse', 'The language server returned an invalid graphical-view response.');
+            return;
+        }
+
+        if (result.uri !== state.sourceUri) {
+            this.setStale(state, 'uriMismatch', 'The language server returned a graphical view for a different source document.');
+            return;
+        }
+
+        if (result.svg === undefined || result.svg === null) {
+            this.handleWarningResult(state, result.warnings);
+            return;
+        }
+
+        const accepted = createAcceptedResult(result, result.svg);
+        state.lastSuccess = accepted;
+        state.status = Object.freeze({kind: 'ready', message: 'Graphical view is up to date.'});
+        state.panel.deliver(Object.freeze({type: 'render', uri: accepted.uri, svg: accepted.svg, warnings: accepted.warnings}));
+        this.deliverStatus(state);
+    }
+
+    private handleWarningResult(state: PanelState, warnings: readonly GraphicalViewRenderWarning[]): void {
+        const warning = warnings[0];
+        switch (warning) {
+            case 'timeout':
+                this.setStale(state, warning, 'Graphical rendering timed out. The last successful diagram is retained.');
+                return;
+            case 'modelTooLarge':
+                this.setStale(state, warning, 'The model is too large for graphical rendering. The last successful diagram is retained.');
+                return;
+            case 'missingDocument':
+                this.setStale(state, warning, 'The source document is unavailable. The last successful diagram is retained.');
+                return;
+            case 'unsupportedUri':
+                this.setStale(state, warning, 'The source URI is not supported for graphical rendering.');
+                return;
+            case 'temporarilyUnresolvable':
+            default:
+                this.setStale(state, warning ?? 'renderFailure', 'The model could not be loaded or parsed. The last successful diagram is retained.');
+        }
+    }
+
+    private handleRenderFailure(state: PanelState, error: unknown): void {
+        if (isMethodNotFound(error)) {
+            this.setStatus(
+                state,
+                Object.freeze({
+                    kind: 'unsupported',
+                    message: 'Graphical view is not supported by the current server build. The last successful diagram is retained.',
+                }),
+            );
+            return;
+        }
+
+        const detail = error instanceof Error ? error.message : String(error);
+        this.setStale(state, classifyFailure(detail), `Graphical rendering failed: ${detail}. The last successful diagram is retained.`);
+    }
+
+    private setStale(state: PanelState, reason: string, message: string): void {
+        this.setStatus(state, Object.freeze({kind: 'stale', reason, message}));
+    }
+
+    private setStatus(state: PanelState, status: GraphicalViewStatus): void {
+        if (!this.isCurrent(state)) {
+            return;
+        }
+        state.status = status;
+        this.deliverStatus(state);
+    }
+
+    private deliverCurrentState(state: PanelState): void {
+        this.deliverStatus(state);
+        const accepted = state.lastSuccess;
+        if (accepted) {
+            state.panel.deliver(Object.freeze({type: 'render', uri: accepted.uri, svg: accepted.svg, warnings: accepted.warnings}));
+        }
+    }
+
+    private deliverStatus(state: PanelState): void {
+        state.panel.deliver(Object.freeze({type: 'status', uri: state.sourceUri, status: state.status}));
+    }
+
+    private invalidate(state: PanelState): void {
+        if (!this.isCurrent(state)) {
+            return;
+        }
+        this.cancelCurrent(state);
+        state.sequence += 1;
+    }
+
+    private cancelCurrent(state: PanelState): void {
+        const cancellation = state.cancellation;
+        state.cancellation = undefined;
+        if (cancellation) {
+            cancellation.cancel();
+            cancellation.dispose();
+        }
+    }
+
+    private isCurrentRequest(
+        state: PanelState,
+        sourceUri: string,
+        sequence: number,
+        cancellation: vscode.CancellationTokenSource,
+    ): boolean {
+        return this.isCurrent(state) && state.sourceUri === sourceUri && state.sequence === sequence && state.cancellation === cancellation;
+    }
+
+    private isCurrent(state: PanelState): boolean {
+        return !this.disposed && !state.disposed && this.panels.get(state.sourceUri) === state;
+    }
+
+    private disposePanelState(state: PanelState, disposePanel: boolean): void {
+        if (state.disposed) {
+            return;
+        }
+        this.cancelCurrent(state);
+        state.sequence += 1;
+        state.disposed = true;
+        this.panels.delete(state.sourceUri);
+        for (const subscription of state.subscriptions.splice(0)) {
+            subscription.dispose();
+        }
+        if (disposePanel) {
+            state.panel.dispose();
+        }
+    }
+
+    private snapshot(state: PanelState): GraphicalViewPanelSnapshot {
+        return Object.freeze({
+            sourceUri: state.sourceUri,
+            sequence: state.sequence,
+            visible: state.visible,
+            disposed: state.disposed,
+            status: state.status,
+            lastSuccess: state.lastSuccess,
+        });
+    }
+}
+
+function createAcceptedResult(result: GraphicalViewRenderResult, svg: string): GraphicalViewAcceptedResult {
+    const targets = Object.freeze(result.targets.map(target => Object.freeze({...target})));
+    const warnings = Object.freeze([...result.warnings]);
+    const targetById = new ImmutableTargetMap(targets.map(target => [target.id, target]));
+    return Object.freeze({uri: result.uri, svg, targets, warnings, targetById});
+}
+
+class ImmutableTargetMap<K, V> implements ReadonlyMap<K, V> {
+    private readonly map: Map<K, V>;
+
+    constructor(entries: readonly (readonly [K, V])[]) {
+        this.map = new Map(entries);
+        Object.freeze(this);
+    }
+
+    get size(): number {
+        return this.map.size;
+    }
+
+    get(key: K): V | undefined {
+        return this.map.get(key);
+    }
+
+    has(key: K): boolean {
+        return this.map.has(key);
+    }
+
+    forEach(callbackfn: (value: V, key: K, map: ReadonlyMap<K, V>) => void, thisArg?: unknown): void {
+        this.map.forEach((value, key) => callbackfn.call(thisArg, value, key, this));
+    }
+
+    entries(): MapIterator<[K, V]> {
+        return this.map.entries();
+    }
+
+    keys(): MapIterator<K> {
+        return this.map.keys();
+    }
+
+    values(): MapIterator<V> {
+        return this.map.values();
+    }
+
+    [Symbol.iterator](): MapIterator<[K, V]> {
+        return this.entries();
+    }
+
+    get [Symbol.toStringTag](): string {
+        return 'ImmutableTargetMap';
+    }
+}
+
+function availableAgainStatus(state: PanelState): GraphicalViewStatus {
+    return Object.freeze({
+        kind: 'stale',
+        reason: 'clientAvailable',
+        message: state.lastSuccess
+            ? 'The language server is available again. The retained diagram remains visible; use Refresh to update it.'
+            : 'The language server is available. Use Refresh to render the graphical view.',
+    });
+}
+
+function retainedAfterHiddenSaveStatus(state: PanelState): GraphicalViewStatus {
+    if (state.lastSuccess) {
+        return Object.freeze({kind: 'ready', message: 'Showing the retained graphical-view snapshot.'});
+    }
+    return Object.freeze({
+        kind: 'stale',
+        reason: 'noSnapshot',
+        message: 'No graphical-view snapshot is available. Reveal the panel and use Refresh to render one.',
+    });
+}
+
+function retainedAfterSourceLossStatus(state: PanelState): GraphicalViewStatus {
+    if (state.lastSuccess) {
+        return Object.freeze({kind: 'ready', message: 'Showing the retained graphical-view snapshot.'});
+    }
+    return Object.freeze({
+        kind: 'stale',
+        reason: 'sourceUnavailable',
+        message: 'The source document is no longer open. Reopen it and use Refresh to render the graphical view.',
+    });
+}
+
+function isPanelMessage(value: unknown): value is GraphicalViewPanelMessage {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const keys = Object.keys(value);
+    if ((value.type === 'ready' || value.type === 'refresh') && keys.length === 1) {
+        return true;
+    }
+    return value.type === 'navigate' && keys.length === 2 && typeof value.targetId === 'string';
+}
+
+function isMethodNotFound(error: unknown): boolean {
+    if (isRecord(error) && error.code === -32601) {
+        return true;
+    }
+    return error instanceof Error && /method\s+not\s+found/i.test(error.message);
+}
+
+function classifyFailure(message: string): string {
+    if (/timeout|timed out/i.test(message)) {
+        return 'timeout';
+    }
+    if (/parse|syntax/i.test(message)) {
+        return 'parse';
+    }
+    if (/load/i.test(message)) {
+        return 'loading';
+    }
+    if (/transport|connection|socket/i.test(message)) {
+        return 'transport';
+    }
+    return 'error';
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null;
+}
diff --git a/src/graphicalViewPanel.ts b/src/graphicalViewPanel.ts
new file mode 100644
index 0000000..0bbda48
--- /dev/null
+++ b/src/graphicalViewPanel.ts
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ *
+ * See the AUTHORS file(s) distributed with this work for additional
+ * information regarding authorship.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import {randomBytes} from 'node:crypto';
+import * as vscode from 'vscode';
+import {GraphicalViewDelivery, GraphicalViewPanelAdapter, GraphicalViewPanelFactory} from './graphicalView';
+
+const VIEW_TYPE = 'turtle.graphicalView';
+
+export class VscodeGraphicalViewPanelFactory implements GraphicalViewPanelFactory {
+    create(sourceUri: string): GraphicalViewPanelAdapter {
+        const uri = vscode.Uri.parse(sourceUri, true);
+        const name = uri.path.split('/').filter(Boolean).at(-1) ?? 'Aspect Model';
+        const panel = vscode.window.createWebviewPanel(VIEW_TYPE, `Graphical View: ${name}`, vscode.ViewColumn.Beside, {
+            enableScripts: true,
+            enableForms: false,
+            enableCommandUris: false,
+            localResourceRoots: [],
+        });
+        return new VscodeGraphicalViewPanel(panel);
+    }
+}
+
+class VscodeGraphicalViewPanel implements GraphicalViewPanelAdapter {
+    constructor(private readonly panel: vscode.WebviewPanel) {
+        panel.webview.html = createShellHtml(panel.webview);
+    }
+
+    get visible(): boolean {
+        return this.panel.visible;
+    }
+
+    reveal(): void {
+        this.panel.reveal(undefined, false);
+    }
+
+    deliver(delivery: GraphicalViewDelivery): void {
+        void this.panel.webview.postMessage(delivery);
+    }
+
+    onDidDispose(listener: () => void): vscode.Disposable {
+        return this.panel.onDidDispose(listener);
+    }
+
+    onDidChangeVisibility(listener: (visible: boolean) => void): vscode.Disposable {
+        return this.panel.onDidChangeViewState(event => listener(event.webviewPanel.visible));
+    }
+
+    onDidReceiveMessage(listener: (message: unknown) => void): vscode.Disposable {
+        return this.panel.webview.onDidReceiveMessage(listener);
+    }
+
+    dispose(): void {
+        this.panel.dispose();
+    }
+}
+
+function createShellHtml(webview: vscode.Webview): string {
+    const nonce = randomBytes(16).toString('hex');
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'nonce-${nonce}'; style-src 'none'; img-src 'none'; connect-src 'none'; object-src 'none'; base-uri 'none'; form-action 'none'">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Graphical View</title>
+</head>
+<body>
+    <button id="refresh" type="button">Refresh</button>
+    <p id="status" role="status">Preparing graphical view...</p>
+    <p id="task4-boundary">Diagram rendering is prepared. Secure SVG display is completed in Task 4.</p>
+    <script nonce="${nonce}">
+        (() => {
+            const vscode = acquireVsCodeApi();
+            const status = document.getElementById('status');
+            document.getElementById('refresh').addEventListener('click', () => vscode.postMessage({type: 'refresh'}));
+            window.addEventListener('message', event => {
+                const message = event.data;
+                if (message && message.type === 'status' && message.status && typeof message.status.message === 'string') {
+                    status.textContent = message.status.message;
+                }
+                if (message && message.type === 'render') {
+                    document.body.dataset.snapshotAvailable = 'true';
+                }
+            });
+            vscode.postMessage({type: 'ready'});
+        })();
+    </script>
+</body>
+</html>`;
+}
diff --git a/src/graphicalViewProtocol.ts b/src/graphicalViewProtocol.ts
new file mode 100644
index 0000000..a86a838
--- /dev/null
+++ b/src/graphicalViewProtocol.ts
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ *
+ * See the AUTHORS file(s) distributed with this work for additional
+ * information regarding authorship.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import type * as vscode from 'vscode';
+
+export const GRAPHICAL_VIEW_RENDER_REQUEST = 'turtle/graphicalView/render';
+export const GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST = 'turtle/graphicalView/resolveTarget';
+export const GRAPHICAL_VIEW_MARKER_PATTERN = /^gv-header-[a-z0-9]{16,32}$/;
+
+export type GraphicalViewRenderWarning =
+    | 'unsupportedUri'
+    | 'missingDocument'
+    | 'modelTooLarge'
+    | 'timeout'
+    | 'temporarilyUnresolvable';
+
+export type GraphicalViewResolveTargetWarning = 'notFound' | 'ambiguous' | 'unsupportedUri' | 'temporarilyUnresolvable';
+
+export interface GraphicalViewRenderParams {
+    uri: string;
+}
+
+export interface GraphicalViewTarget {
+    id: string;
+    kind: 'elementHeader';
+    elementUrn: string;
+}
+
+export interface GraphicalViewRenderResult {
+    uri: string;
+    svg?: string | null;
+    targets: GraphicalViewTarget[];
+    warnings: GraphicalViewRenderWarning[];
+}
+
+export interface GraphicalViewResolveTargetParams {
+    sourceUri: string;
+    elementUrn: string;
+}
+
+export interface GraphicalViewPosition {
+    line: number;
+    character: number;
+}
+
+export interface GraphicalViewLocation {
+    uri: string;
+    range: {
+        start: GraphicalViewPosition;
+        end: GraphicalViewPosition;
+    };
+}
+
+export interface GraphicalViewResolveTargetResult {
+    location?: GraphicalViewLocation | null;
+    warning?: GraphicalViewResolveTargetWarning | null;
+}
+
+export interface GraphicalViewRequestClient {
+    isGraphicalViewAvailable(): boolean;
+    onDidChangeGraphicalViewAvailability(listener: (available: boolean) => void): vscode.Disposable;
+    renderGraphicalView(params: GraphicalViewRenderParams, token: vscode.CancellationToken): Thenable<GraphicalViewRenderResult>;
+    resolveGraphicalViewTarget(
+        params: GraphicalViewResolveTargetParams,
+        token?: vscode.CancellationToken,
+    ): Thenable<GraphicalViewResolveTargetResult>;
+}
+
+const RENDER_WARNINGS: ReadonlySet<string> = new Set([
+    'unsupportedUri',
+    'missingDocument',
+    'modelTooLarge',
+    'timeout',
+    'temporarilyUnresolvable',
+]);
+const ASPECT_MODEL_URN_PATTERN = /^urn:samm:[^\s#]+#[^\s#]+$/;
+const SVG_MARKER_PATTERN = /\bid\s*=\s*(["'])(gv-header-[a-z0-9]{16,32})\1/g;
+
+export function isGraphicalViewRenderResult(value: unknown): value is GraphicalViewRenderResult {
+    if (!isRecord(value) || typeof value.uri !== 'string' || !Array.isArray(value.targets) || !Array.isArray(value.warnings)) {
+        return false;
+    }
+
+    if (value.svg !== undefined && value.svg !== null && typeof value.svg !== 'string') {
+        return false;
+    }
+
+    if (!value.warnings.every(warning => typeof warning === 'string' && RENDER_WARNINGS.has(warning))) {
+        return false;
+    }
+
+    if (!value.targets.every(isGraphicalViewTarget)) {
+        return false;
+    }
+
+    if (value.svg === undefined || value.svg === null) {
+        return value.targets.length === 0 && value.warnings.length > 0;
+    }
+
+    return value.svg.trim().length > 0 && hasConsistentSidecar(value.svg, value.targets);
+}
+
+function isGraphicalViewTarget(value: unknown): value is GraphicalViewTarget {
+    return (
+        isRecord(value) &&
+        typeof value.id === 'string' &&
+        GRAPHICAL_VIEW_MARKER_PATTERN.test(value.id) &&
+        value.kind === 'elementHeader' &&
+        typeof value.elementUrn === 'string' &&
+        ASPECT_MODEL_URN_PATTERN.test(value.elementUrn)
+    );
+}
+
+function hasConsistentSidecar(svg: string, targets: GraphicalViewTarget[]): boolean {
+    const targetIds = new Set<string>();
+    for (const target of targets) {
+        if (targetIds.has(target.id)) {
+            return false;
+        }
+        targetIds.add(target.id);
+    }
+
+    const svgIds = new Set<string>();
+    for (const match of svg.matchAll(SVG_MARKER_PATTERN)) {
+        const id = match[2];
+        if (svgIds.has(id)) {
+            return false;
+        }
+        svgIds.add(id);
+    }
+
+    return targetIds.size === svgIds.size && [...targetIds].every(id => svgIds.has(id));
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null;
+}
diff --git a/src/languageClient.ts b/src/languageClient.ts
index 2e12733..2858351 100644
--- a/src/languageClient.ts
+++ b/src/languageClient.ts
@@ -14,21 +14,49 @@
 import { Trace } from 'vscode-jsonrpc';
 import * as net from 'node:net';
 import * as vscode from 'vscode';
-import { LanguageClient, LanguageClientOptions, State, StreamInfo } from 'vscode-languageclient/node';
+import {LanguageClient, LanguageClientOptions, State, StateChangeEvent, StreamInfo} from 'vscode-languageclient/node';
 import type { RequestClient } from './aspectValidation';
+import {
+    GRAPHICAL_VIEW_RENDER_REQUEST,
+    GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST,
+    GraphicalViewRenderParams,
+    GraphicalViewRenderResult,
+    GraphicalViewRequestClient,
+    GraphicalViewResolveTargetParams,
+    GraphicalViewResolveTargetResult,
+} from './graphicalViewProtocol';
 import type { ExtensionLogger } from './outputChannel';
 
 const CLIENT_START_TIMEOUT_MS = 5000;
 
-export class TurtleLanguageClient implements RequestClient {
-    private client: LanguageClient;
+export interface LanguageClientAdapter {
+    readonly state: State;
+    setTrace(value: Trace): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    onDidChangeState(listener: (event: StateChangeEvent) => void): vscode.Disposable;
+    sendRequest<R>(method: string, params?: unknown, token?: vscode.CancellationToken): Promise<R>;
+}
+
+export class TurtleLanguageClient implements RequestClient, GraphicalViewRequestClient {
+    private client: LanguageClientAdapter;
+    private readonly graphicalViewAvailability = new vscode.EventEmitter<boolean>();
+    private lastGraphicalViewAvailability = false;
 
     constructor(
         private outputChannel: ExtensionLogger,
         private readonly serverPort: number,
-        private readonly traceLevel: 'off' | 'messages' | 'verbose' = 'off'
+        private readonly traceLevel: 'off' | 'messages' | 'verbose' = 'off',
+        clientFactory?: () => LanguageClientAdapter,
     ) {
-        this.client = this.initLanguageClient(this.serverPort);
+        this.client = clientFactory ? clientFactory() : this.initLanguageClient(this.serverPort);
+        this.client.onDidChangeState(event => {
+            const available = event.newState === State.Running;
+            if (available !== this.lastGraphicalViewAvailability) {
+                this.lastGraphicalViewAvailability = available;
+                this.graphicalViewAvailability.fire(available);
+            }
+        });
     }
 
     private toTrace(level: 'off' | 'messages' | 'verbose'): Trace {
@@ -39,7 +67,7 @@ export class TurtleLanguageClient implements RequestClient {
         }
     }
 
-    private initLanguageClient(serverPort: number): LanguageClient {
+    private initLanguageClient(serverPort: number): LanguageClientAdapter {
         const serverOptions = async (): Promise<StreamInfo> => new Promise((resolve, reject) => {
             const socket = net.connect({ host: '127.0.0.1', port: serverPort }, () => {
                 resolve({ reader: socket, writer: socket });
@@ -100,12 +128,31 @@ export class TurtleLanguageClient implements RequestClient {
         await this.client.stop();
     }
 
-    sendRequest<R>(method: string, params?: unknown): Promise<R> {
+    sendRequest<R>(method: string, params?: unknown, token?: vscode.CancellationToken): Promise<R> {
         if (this.client.state === State.Stopped) {
             return Promise.reject(new Error('The Turtle language client is not connected.'));
         }
 
-        return this.client.sendRequest<R>(method, params) as Promise<R>;
+        return this.client.sendRequest<R>(method, params, token) as Promise<R>;
+    }
+
+    isGraphicalViewAvailable(): boolean {
+        return this.client.state === State.Running;
+    }
+
+    onDidChangeGraphicalViewAvailability(listener: (available: boolean) => void): vscode.Disposable {
+        return this.graphicalViewAvailability.event(listener);
+    }
+
+    renderGraphicalView(params: GraphicalViewRenderParams, token: vscode.CancellationToken): Promise<GraphicalViewRenderResult> {
+        return this.sendRequest<GraphicalViewRenderResult>(GRAPHICAL_VIEW_RENDER_REQUEST, params, token);
+    }
+
+    resolveGraphicalViewTarget(
+        params: GraphicalViewResolveTargetParams,
+        token?: vscode.CancellationToken,
+    ): Promise<GraphicalViewResolveTargetResult> {
+        return this.sendRequest<GraphicalViewResolveTargetResult>(GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST, params, token);
     }
 
 }
diff --git a/src/test/graphicalViewController.test.ts b/src/test/graphicalViewController.test.ts
new file mode 100644
index 0000000..7604c56
--- /dev/null
+++ b/src/test/graphicalViewController.test.ts
@@ -0,0 +1,346 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ *
+ * See the AUTHORS file(s) distributed with this work for additional
+ * information regarding authorship.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import * as assert from 'node:assert/strict';
+import {readFileSync} from 'node:fs';
+import {join} from 'node:path';
+import {OPEN_GRAPHICAL_VIEW_COMMAND} from '../graphicalView';
+import {GraphicalViewRenderResult} from '../graphicalViewProtocol';
+import {
+    FakeGraphicalViewClient,
+    createGraphicalViewDocument,
+    createGraphicalViewHarness,
+    flushPromises,
+    successfulResult,
+} from './graphicalViewTestHarness';
+
+suite('GraphicalViewController', () => {
+    test('contributes the guarded Turtle editor command', () => {
+        const manifest = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf8')) as {
+            contributes: {commands: Array<Record<string, string>>; menus: {'editor/context': Array<Record<string, string>>}};
+        };
+        const command = manifest.contributes.commands.find(candidate => candidate.command === OPEN_GRAPHICAL_VIEW_COMMAND);
+        const menu = manifest.contributes.menus['editor/context'].find(candidate => candidate.command === OPEN_GRAPHICAL_VIEW_COMMAND);
+        assert.equal(command?.enablement, 'editorLangId == turtle');
+        assert.equal(menu?.when, 'resourceLangId == turtle');
+    });
+
+    test('guards absent and non-Turtle active editors without a panel or request', async () => {
+        const harness = createGraphicalViewHarness();
+        await harness.commands.execute(OPEN_GRAPHICAL_VIEW_COMMAND);
+        harness.window.activeTextEditor = {document: createGraphicalViewDocument('/tmp/not-turtle.txt', 'plaintext')};
+        await harness.commands.execute(OPEN_GRAPHICAL_VIEW_COMMAND);
+        assert.equal(harness.window.warnings.length, 2);
+        assert.equal(harness.panels.panels.length, 0);
+        assert.equal(harness.client.requests.length, 0);
+        harness.controller.dispose();
+    });
+
+    test('creates one panel and performs the initial typed render', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/initial.ttl');
+        harness.window.activeTextEditor = {document};
+        await harness.commands.execute(OPEN_GRAPHICAL_VIEW_COMMAND);
+        assert.equal(harness.panels.panels.length, 1);
+        assert.deepEqual(harness.client.requests[0].params, {uri: document.uri.toString()});
+        assert.equal(harness.controller.getPanelState(document.uri.toString())?.sequence, 1);
+
+        harness.client.requests[0].deferred.resolve(successfulResult(document));
+        await flushPromises();
+        const state = harness.controller.getPanelState(document.uri.toString());
+        assert.equal(state?.status.kind, 'ready');
+        assert.equal(state?.lastSuccess?.svg, successfulResult(document).svg);
+        assert.equal(state?.lastSuccess?.targetById.size, 1);
+        harness.controller.dispose();
+    });
+
+    test('reveals one panel per URI and keeps different URI panels independent', async () => {
+        const harness = createGraphicalViewHarness();
+        const first = track(harness, '/tmp/first.ttl');
+        const second = track(harness, '/tmp/second.ttl');
+        await harness.controller.openGraphicalView(first);
+        await harness.controller.openGraphicalView(first);
+        assert.equal(harness.panels.panels.length, 1);
+        assert.equal(harness.panels.panels[0].revealCount, 1);
+        assert.equal(harness.client.requests.length, 1);
+
+        await harness.controller.openGraphicalView(second);
+        assert.equal(harness.controller.getPanelCount(), 2);
+        assert.equal(harness.client.requests.length, 2);
+        assert.equal(harness.client.requests[1].params.uri, second.uri.toString());
+        harness.controller.dispose();
+    });
+
+    test('renders on manual Refresh and visible bound-main Save only', async () => {
+        const harness = createGraphicalViewHarness();
+        const main = track(harness, '/tmp/main.ttl');
+        const imported = track(harness, '/tmp/import.ttl');
+        await harness.controller.openGraphicalView(main);
+        harness.panels.panels[0].emitMessage({type: 'refresh'});
+        assert.equal(harness.client.requests.length, 2);
+        assert.equal(harness.client.requests[0].token.isCancellationRequested, true);
+
+        harness.workspace.fireSave(imported);
+        assert.equal(harness.client.requests.length, 2);
+        harness.workspace.fireSave(main);
+        assert.equal(harness.client.requests.length, 3);
+        assert.equal(harness.client.requests[1].token.isCancellationRequested, true);
+        harness.controller.dispose();
+    });
+
+    test('hidden Save invalidates pending work; typing and reveal do not render', async () => {
+        const harness = createGraphicalViewHarness();
+        const main = track(harness, '/tmp/hidden.ttl');
+        await harness.controller.openGraphicalView(main);
+        harness.client.requests[0].deferred.resolve(successfulResult(main));
+        await flushPromises();
+        const panel = harness.panels.panels[0];
+        panel.emitMessage({type: 'refresh'});
+        const pending = harness.client.requests[1];
+        panel.setVisible(false);
+        panel.emitMessage({type: 'refresh'});
+        assert.equal(harness.client.requests.length, 2);
+        const before = harness.controller.getPanelState(main.uri.toString())?.sequence;
+        harness.workspace.fireSave(main);
+        assert.equal(harness.client.requests.length, 2);
+        assert.equal(pending.token.isCancellationRequested, true);
+        assert.equal(harness.controller.getPanelState(main.uri.toString())?.sequence, (before ?? 0) + 1);
+        assert.equal(harness.controller.getPanelState(main.uri.toString())?.status.kind, 'ready');
+        assert.ok(harness.controller.getPanelState(main.uri.toString())?.lastSuccess);
+
+        panel.setVisible(true);
+        panel.emitMessage({type: 'ready'});
+        panel.emitMessage({type: 'navigate', targetId: 'gv-header-0123456789abcdef'});
+        assert.equal(harness.client.requests.length, 2);
+        harness.controller.dispose();
+    });
+
+    test('source editor closure invalidates pending work and ignores its late failure', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/closed.ttl');
+        await harness.controller.openGraphicalView(document);
+        harness.client.requests[0].deferred.resolve(successfulResult(document));
+        await flushPromises();
+        const retained = harness.controller.getPanelState(document.uri.toString())?.lastSuccess;
+        harness.panels.panels[0].emitMessage({type: 'refresh'});
+        const pending = harness.client.requests[1];
+        const sequence = harness.controller.getPanelState(document.uri.toString())?.sequence ?? 0;
+
+        harness.workspace.closeSourceEditor(document);
+        assert.equal(harness.controller.getPanelCount(), 1);
+        assert.equal(harness.client.requests.length, 2);
+        assert.equal(pending.token.isCancellationRequested, true);
+        assert.equal(harness.controller.getPanelState(document.uri.toString())?.sequence, sequence + 1);
+        assert.equal(harness.controller.getPanelState(document.uri.toString())?.lastSuccess, retained);
+
+        pending.deferred.reject(new Error('late transport failure'));
+        await flushPromises();
+        const state = harness.controller.getPanelState(document.uri.toString());
+        assert.equal(state?.status.kind, 'ready');
+        assert.equal(state?.lastSuccess, retained);
+        harness.controller.dispose();
+    });
+
+    test('bound-source loss invalidates pending work and ignores its late success', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/lost.ttl');
+        await harness.controller.openGraphicalView(document);
+        const retainedResult = successfulResult(document, 'aaaaaaaaaaaaaaaa');
+        harness.client.requests[0].deferred.resolve(retainedResult);
+        await flushPromises();
+        const retained = harness.controller.getPanelState(document.uri.toString())?.lastSuccess;
+
+        harness.panels.panels[0].emitMessage({type: 'refresh'});
+        const pending = harness.client.requests[1];
+        const sequence = harness.controller.getPanelState(document.uri.toString())?.sequence ?? 0;
+        harness.workspace.loseDocument(document);
+        assert.equal(harness.client.requests.length, 2);
+        assert.equal(pending.token.isCancellationRequested, true);
+        assert.equal(harness.controller.getPanelState(document.uri.toString())?.sequence, sequence + 1);
+
+        pending.deferred.resolve(successfulResult(document, 'bbbbbbbbbbbbbbbb'));
+        await flushPromises();
+        const state = harness.controller.getPanelState(document.uri.toString());
+        assert.equal(state?.status.kind, 'ready');
+        assert.equal(state?.lastSuccess, retained);
+        assert.equal(state?.lastSuccess?.svg, retainedResult.svg);
+        harness.controller.dispose();
+    });
+
+    test('cancels superseded work and rejects obsolete success and failure completions', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/sequence.ttl');
+        await harness.controller.openGraphicalView(document);
+        const first = harness.client.requests[0];
+        harness.panels.panels[0].emitMessage({type: 'refresh'});
+        const second = harness.client.requests[1];
+        assert.equal(first.token.isCancellationRequested, true);
+
+        second.deferred.resolve(successfulResult(document, '1111111111111111'));
+        await flushPromises();
+        first.deferred.resolve(successfulResult(document, '2222222222222222'));
+        await flushPromises();
+        assert.match(harness.controller.getPanelState(document.uri.toString())?.lastSuccess?.svg ?? '', /1111111111111111/);
+
+        harness.panels.panels[0].emitMessage({type: 'refresh'});
+        const obsoleteFailure = harness.client.requests[2];
+        harness.panels.panels[0].emitMessage({type: 'refresh'});
+        const newest = harness.client.requests[3];
+        obsoleteFailure.deferred.reject(new Error('obsolete transport failure'));
+        await flushPromises();
+        assert.equal(harness.controller.getPanelState(document.uri.toString())?.status.kind, 'loading');
+        newest.deferred.resolve(successfulResult(document, '3333333333333333'));
+        await flushPromises();
+        assert.match(harness.controller.getPanelState(document.uri.toString())?.lastSuccess?.svg ?? '', /3333333333333333/);
+        harness.controller.dispose();
+    });
+
+    test('rejects URI mismatches and malformed, duplicate, invalid-marker, and inconsistent sidecars', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/validation.ttl');
+        await harness.controller.openGraphicalView(document);
+        const good = successfulResult(document);
+        harness.client.requests[0].deferred.resolve(good);
+        await flushPromises();
+
+        const invalidResults: GraphicalViewRenderResult[] = [
+            {...good, uri: 'file:///tmp/other.ttl'},
+            {...good, targets: [...good.targets, good.targets[0]]},
+            {...good, targets: [{...good.targets[0], id: 'bad-marker'}]},
+            {...good, targets: [{...good.targets[0], kind: 'notHeader' as 'elementHeader'}]},
+            {...good, targets: [{...good.targets[0], elementUrn: 'not-a-urn'}]},
+            {...good, svg: '<svg></svg>'},
+        ];
+
+        for (const invalid of invalidResults) {
+            harness.panels.panels[0].emitMessage({type: 'refresh'});
+            harness.client.requests.at(-1)?.deferred.resolve(invalid);
+            await flushPromises();
+            const state = harness.controller.getPanelState(document.uri.toString());
+            assert.equal(state?.status.kind, 'stale');
+            assert.equal(state?.lastSuccess?.svg, good.svg);
+            assert.equal(state?.lastSuccess?.targetById.get(good.targets[0].id)?.elementUrn, good.targets[0].elementUrn);
+        }
+        harness.controller.dispose();
+    });
+
+    test('installs SVG and sidecar atomically and retains them for all failure classes', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/retention.ttl');
+        await harness.controller.openGraphicalView(document);
+        const accepted = successfulResult(document, 'aaaaaaaaaaaaaaaa');
+        harness.client.requests[0].deferred.resolve(accepted);
+        await flushPromises();
+        assert.equal(harness.controller.getPanelState(document.uri.toString())?.lastSuccess?.targetById.has(accepted.targets[0].id), true);
+
+        const failures: Array<GraphicalViewRenderResult | Error> = [
+            {uri: document.uri.toString(), svg: null, targets: [], warnings: ['temporarilyUnresolvable']},
+            {uri: document.uri.toString(), targets: [], warnings: ['timeout']},
+            {uri: document.uri.toString(), svg: null, targets: [], warnings: ['modelTooLarge']},
+            new Error('transport socket closed'),
+            new Error('generic failure'),
+        ];
+        for (const failure of failures) {
+            harness.panels.panels[0].emitMessage({type: 'refresh'});
+            const request = harness.client.requests.at(-1);
+            if (failure instanceof Error) {
+                request?.deferred.reject(failure);
+            } else {
+                request?.deferred.resolve(failure);
+            }
+            await flushPromises();
+            const state = harness.controller.getPanelState(document.uri.toString());
+            assert.equal(state?.status.kind, 'stale');
+            assert.equal(state?.lastSuccess?.svg, accepted.svg);
+            assert.equal(state?.lastSuccess?.targetById.has(accepted.targets[0].id), true);
+        }
+        harness.controller.dispose();
+    });
+
+    test('detects MethodNotFound by code and recovers compatibility state after client replacement', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/unsupported.ttl');
+        await harness.controller.openGraphicalView(document);
+        harness.client.requests[0].deferred.reject(Object.assign(new Error('localized message'), {code: -32601}));
+        await flushPromises();
+        assert.equal(harness.controller.getPanelState(document.uri.toString())?.status.kind, 'unsupported');
+
+        const replacement = new FakeGraphicalViewClient();
+        harness.controller.setClient(replacement);
+        assert.equal(harness.controller.getPanelState(document.uri.toString())?.status.kind, 'stale');
+        assert.equal(replacement.requests.length, 0);
+        harness.panels.panels[0].emitMessage({type: 'refresh'});
+        assert.equal(replacement.requests.length, 1);
+        harness.controller.dispose();
+    });
+
+    test('handles explicit replacement and unexpected disconnect/reconnect without automatic render', async () => {
+        const client = new FakeGraphicalViewClient();
+        const harness = createGraphicalViewHarness(client);
+        const document = track(harness, '/tmp/lifecycle.ttl');
+        await harness.controller.openGraphicalView(document);
+        const pending = client.requests[0];
+        harness.controller.setClient(undefined);
+        assert.equal(pending.token.isCancellationRequested, true);
+        assert.equal(harness.controller.getPanelState(document.uri.toString())?.status.kind, 'disconnected');
+
+        const replacement = new FakeGraphicalViewClient();
+        harness.controller.setClient(replacement);
+        assert.equal(replacement.requests.length, 0);
+        replacement.setAvailable(false);
+        assert.equal(harness.controller.getPanelState(document.uri.toString())?.status.kind, 'disconnected');
+        replacement.setAvailable(true);
+        assert.equal(harness.controller.getPanelState(document.uri.toString())?.status.kind, 'stale');
+        assert.equal(replacement.requests.length, 0);
+        harness.controller.dispose();
+    });
+
+    test('disposal removes ownership, cancels work, disposes listeners, and rejects late results', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/dispose.ttl');
+        await harness.controller.openGraphicalView(document);
+        const request = harness.client.requests[0];
+        const panel = harness.panels.panels[0];
+        panel.dispose();
+        assert.equal(harness.controller.getPanelCount(), 0);
+        assert.equal(request.token.isCancellationRequested, true);
+        assert.equal(panel.disposedListenerCount, 3);
+        request.deferred.resolve(successfulResult(document));
+        await flushPromises();
+        assert.equal(harness.controller.getPanelCount(), 0);
+        harness.controller.dispose();
+    });
+
+    test('multiple panels neither leak nor cross-deliver results or status', async () => {
+        const harness = createGraphicalViewHarness();
+        const first = track(harness, '/tmp/multi-one.ttl');
+        const second = track(harness, '/tmp/multi-two.ttl');
+        await harness.controller.openGraphicalView(first);
+        await harness.controller.openGraphicalView(second);
+        const firstDeliveryCount = harness.panels.panels[0].deliveries.length;
+        harness.client.requests[1].deferred.resolve(successfulResult(second, 'bbbbbbbbbbbbbbbb'));
+        await flushPromises();
+        assert.equal(harness.panels.panels[0].deliveries.length, firstDeliveryCount);
+        assert.match(harness.controller.getPanelState(second.uri.toString())?.lastSuccess?.svg ?? '', /bbbbbbbbbbbbbbbb/);
+        assert.equal(harness.controller.getPanelState(first.uri.toString())?.lastSuccess, undefined);
+        harness.controller.dispose();
+        assert.equal(harness.panels.panels[0].disposeCount, 1);
+        assert.equal(harness.panels.panels[1].disposeCount, 1);
+    });
+});
+
+function track(harness: ReturnType<typeof createGraphicalViewHarness>, filePath: string) {
+    const document = createGraphicalViewDocument(filePath);
+    harness.workspace.available.add(document.uri.toString());
+    return document;
+}
diff --git a/src/test/graphicalViewTestHarness.ts b/src/test/graphicalViewTestHarness.ts
new file mode 100644
index 0000000..6ea0459
--- /dev/null
+++ b/src/test/graphicalViewTestHarness.ts
@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ *
+ * See the AUTHORS file(s) distributed with this work for additional
+ * information regarding authorship.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import * as vscode from 'vscode';
+import {
+    GraphicalViewCommands,
+    GraphicalViewController,
+    GraphicalViewDelivery,
+    GraphicalViewDocument,
+    GraphicalViewPanelAdapter,
+    GraphicalViewPanelFactory,
+    GraphicalViewWindow,
+    GraphicalViewWorkspace,
+} from '../graphicalView';
+import {
+    GraphicalViewRenderParams,
+    GraphicalViewRenderResult,
+    GraphicalViewRequestClient,
+    GraphicalViewResolveTargetParams,
+    GraphicalViewResolveTargetResult,
+} from '../graphicalViewProtocol';
+import type {ExtensionLogger} from '../outputChannel';
+
+export interface RecordedRenderRequest {
+    readonly params: GraphicalViewRenderParams;
+    readonly token: vscode.CancellationToken;
+    readonly deferred: Deferred<GraphicalViewRenderResult>;
+}
+
+export class FakeGraphicalViewClient implements GraphicalViewRequestClient {
+    readonly requests: RecordedRenderRequest[] = [];
+    private readonly listeners = new Set<(available: boolean) => void>();
+
+    constructor(private available = true) {}
+
+    isGraphicalViewAvailable(): boolean {
+        return this.available;
+    }
+
+    onDidChangeGraphicalViewAvailability(listener: (available: boolean) => void): vscode.Disposable {
+        this.listeners.add(listener);
+        return new vscode.Disposable(() => this.listeners.delete(listener));
+    }
+
+    renderGraphicalView(params: GraphicalViewRenderParams, token: vscode.CancellationToken): Promise<GraphicalViewRenderResult> {
+        const deferred = new Deferred<GraphicalViewRenderResult>();
+        this.requests.push({params, token, deferred});
+        return deferred.promise;
+    }
+
+    resolveGraphicalViewTarget(
+        _params: GraphicalViewResolveTargetParams,
+        _token?: vscode.CancellationToken,
+    ): Promise<GraphicalViewResolveTargetResult> {
+        return Promise.resolve({location: null, warning: 'temporarilyUnresolvable'});
+    }
+
+    setAvailable(available: boolean): void {
+        this.available = available;
+        for (const listener of [...this.listeners]) {
+            listener(available);
+        }
+    }
+}
+
+export class FakeGraphicalViewPanel implements GraphicalViewPanelAdapter {
+    readonly deliveries: GraphicalViewDelivery[] = [];
+    revealCount = 0;
+    disposeCount = 0;
+    disposedListenerCount = 0;
+    private readonly disposeListeners = new Set<() => void>();
+    private readonly visibilityListeners = new Set<(visible: boolean) => void>();
+    private readonly messageListeners = new Set<(message: unknown) => void>();
+
+    constructor(public visible = true) {}
+
+    reveal(): void {
+        this.revealCount += 1;
+        this.setVisible(true);
+    }
+
+    deliver(delivery: GraphicalViewDelivery): void {
+        this.deliveries.push(delivery);
+    }
+
+    onDidDispose(listener: () => void): vscode.Disposable {
+        this.disposeListeners.add(listener);
+        return this.listenerDisposable(this.disposeListeners, listener);
+    }
+
+    onDidChangeVisibility(listener: (visible: boolean) => void): vscode.Disposable {
+        this.visibilityListeners.add(listener);
+        return this.listenerDisposable(this.visibilityListeners, listener);
+    }
+
+    onDidReceiveMessage(listener: (message: unknown) => void): vscode.Disposable {
+        this.messageListeners.add(listener);
+        return this.listenerDisposable(this.messageListeners, listener);
+    }
+
+    setVisible(visible: boolean): void {
+        if (this.visible === visible) {
+            return;
+        }
+        this.visible = visible;
+        for (const listener of [...this.visibilityListeners]) {
+            listener(visible);
+        }
+    }
+
+    emitMessage(message: unknown): void {
+        for (const listener of [...this.messageListeners]) {
+            listener(message);
+        }
+    }
+
+    dispose(): void {
+        if (this.disposeCount > 0) {
+            return;
+        }
+        this.disposeCount += 1;
+        for (const listener of [...this.disposeListeners]) {
+            listener();
+        }
+    }
+
+    private listenerDisposable<T>(listeners: Set<T>, listener: T): vscode.Disposable {
+        return new vscode.Disposable(() => {
+            if (listeners.delete(listener)) {
+                this.disposedListenerCount += 1;
+            }
+        });
+    }
+}
+
+export class FakeGraphicalViewPanelFactory implements GraphicalViewPanelFactory {
+    readonly panels: FakeGraphicalViewPanel[] = [];
+
+    create(_sourceUri: string): FakeGraphicalViewPanel {
+        const panel = new FakeGraphicalViewPanel();
+        this.panels.push(panel);
+        return panel;
+    }
+}
+
+export function createGraphicalViewHarness(client = new FakeGraphicalViewClient()) {
+    const panels = new FakeGraphicalViewPanelFactory();
+    const commands = new FakeCommands();
+    const window = new FakeWindow();
+    const workspace = new FakeWorkspace();
+    const outputChannel = new FakeOutputChannel();
+    const controller = new GraphicalViewController(client, panels, commands, window, workspace, outputChannel);
+    const context = {subscriptions: [] as vscode.Disposable[]};
+    controller.register(context);
+    return {client, commands, context, controller, outputChannel, panels, window, workspace};
+}
+
+export function createGraphicalViewDocument(filePath: string, languageId = 'turtle'): GraphicalViewDocument {
+    return {languageId, uri: vscode.Uri.file(filePath)};
+}
+
+export function successfulResult(document: GraphicalViewDocument, suffix = '0123456789abcdef'): GraphicalViewRenderResult {
+    const id = `gv-header-${suffix}`;
+    return {
+        uri: document.uri.toString(),
+        svg: `<svg><g id="${id}"><text>Aspect</text></g></svg>`,
+        targets: [{id, kind: 'elementHeader', elementUrn: 'urn:samm:example.graphical:1.0.0#Aspect'}],
+        warnings: [],
+    };
+}
+
+export async function flushPromises(): Promise<void> {
+    await new Promise<void>(resolve => setImmediate(resolve));
+}
+
+class FakeCommands implements GraphicalViewCommands {
+    private readonly callbacks = new Map<string, () => unknown>();
+
+    registerCommand(command: string, callback: () => unknown): vscode.Disposable {
+        this.callbacks.set(command, callback);
+        return new vscode.Disposable(() => this.callbacks.delete(command));
+    }
+
+    async execute(command: string): Promise<unknown> {
+        return this.callbacks.get(command)?.();
+    }
+}
+
+class FakeWindow implements GraphicalViewWindow {
+    activeTextEditor: {document: GraphicalViewDocument} | undefined;
+    readonly warnings: string[] = [];
+
+    showWarningMessage(message: string): Promise<unknown> {
+        this.warnings.push(message);
+        return Promise.resolve(undefined);
+    }
+}
+
+class FakeWorkspace implements GraphicalViewWorkspace {
+    readonly available = new Set<string>();
+    private saveListener: ((document: GraphicalViewDocument) => void) | undefined;
+    private availabilityListener: ((sourceUri: string, available: boolean) => void) | undefined;
+
+    onDidSaveTextDocument(listener: (document: GraphicalViewDocument) => void): vscode.Disposable {
+        this.saveListener = listener;
+        return new vscode.Disposable(() => {
+            if (this.saveListener === listener) {
+                this.saveListener = undefined;
+            }
+        });
+    }
+
+    onDidChangeDocumentAvailability(listener: (sourceUri: string, available: boolean) => void): vscode.Disposable {
+        this.availabilityListener = listener;
+        return new vscode.Disposable(() => {
+            if (this.availabilityListener === listener) {
+                this.availabilityListener = undefined;
+            }
+        });
+    }
+
+    isDocumentAvailable(uri: string): boolean {
+        return this.available.has(uri);
+    }
+
+    fireSave(document: GraphicalViewDocument): void {
+        this.saveListener?.(document);
+    }
+
+    loseDocument(document: GraphicalViewDocument): void {
+        this.available.delete(document.uri.toString());
+        this.availabilityListener?.(document.uri.toString(), false);
+    }
+
+    closeSourceEditor(document: GraphicalViewDocument): void {
+        this.available.delete(document.uri.toString());
+        this.availabilityListener?.(document.uri.toString(), false);
+    }
+}
+
+class FakeOutputChannel implements ExtensionLogger {
+    readonly lines: string[] = [];
+    trace(message: string): void {
+        this.lines.push(`[trace] ${message}`);
+    }
+    info(message: string): void {
+        this.lines.push(`[info] ${message}`);
+    }
+    warn(message: string): void {
+        this.lines.push(`[warn] ${message}`);
+    }
+    error(message: string | Error): void {
+        this.lines.push(`[error] ${message instanceof Error ? message.message : message}`);
+    }
+}
+
+class Deferred<T> {
+    readonly promise: Promise<T>;
+    private resolvePromise!: (value: T) => void;
+    private rejectPromise!: (reason: unknown) => void;
+
+    constructor() {
+        this.promise = new Promise<T>((resolve, reject) => {
+            this.resolvePromise = resolve;
+            this.rejectPromise = reject;
+        });
+    }
+
+    resolve(value: T): void {
+        this.resolvePromise(value);
+    }
+
+    reject(reason: unknown): void {
+        this.rejectPromise(reason);
+    }
+}
diff --git a/src/test/languageClientGraphicalView.test.ts b/src/test/languageClientGraphicalView.test.ts
new file mode 100644
index 0000000..e3691ac
--- /dev/null
+++ b/src/test/languageClientGraphicalView.test.ts
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ *
+ * See the AUTHORS file(s) distributed with this work for additional
+ * information regarding authorship.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import * as assert from 'node:assert/strict';
+import * as vscode from 'vscode';
+import {Trace} from 'vscode-jsonrpc';
+import {State, StateChangeEvent} from 'vscode-languageclient/node';
+import {
+    GRAPHICAL_VIEW_RENDER_REQUEST,
+    GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST,
+    GraphicalViewRenderResult,
+    GraphicalViewResolveTargetResult,
+    isGraphicalViewRenderResult,
+} from '../graphicalViewProtocol';
+import {LanguageClientAdapter, TurtleLanguageClient} from '../languageClient';
+import type {ExtensionLogger} from '../outputChannel';
+
+suite('TurtleLanguageClient graphical-view integration', () => {
+    test('forwards exact typed methods and render cancellation token', async () => {
+        const adapter = new FakeLanguageClientAdapter();
+        const client = new TurtleLanguageClient(new FakeLogger(), 1846, 'off', () => adapter);
+        await client.connect();
+        const cancellation = new vscode.CancellationTokenSource();
+
+        const render = await client.renderGraphicalView({uri: 'file:///model.ttl'}, cancellation.token);
+        const resolve = await client.resolveGraphicalViewTarget({
+            sourceUri: 'file:///model.ttl',
+            elementUrn: 'urn:samm:example:1.0.0#Aspect',
+        });
+
+        assert.equal(render.uri, 'file:///model.ttl');
+        assert.equal(resolve.warning, 'notFound');
+        assert.equal(adapter.requests[0].method, GRAPHICAL_VIEW_RENDER_REQUEST);
+        assert.equal(adapter.requests[0].token, cancellation.token);
+        assert.equal(adapter.requests[1].method, GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST);
+        cancellation.dispose();
+    });
+
+    test('exposes disconnect and reconnect transitions once per availability change', async () => {
+        const adapter = new FakeLanguageClientAdapter();
+        const client = new TurtleLanguageClient(new FakeLogger(), 1846, 'off', () => adapter);
+        const events: boolean[] = [];
+        const subscription = client.onDidChangeGraphicalViewAvailability(available => events.push(available));
+
+        await client.connect();
+        adapter.transition(State.Starting);
+        adapter.transition(State.Stopped);
+        adapter.transition(State.Running);
+        assert.deepEqual(events, [true, false, true]);
+        subscription.dispose();
+    });
+
+    test('accepts Task 2 render warning JSON with omitted or explicit-null svg', () => {
+        const omittedSvg = JSON.parse(
+            '{"uri":"file:///model.ttl","targets":[],"warnings":["timeout"]}',
+        ) as unknown;
+        const nullSvg = JSON.parse(
+            '{"uri":"file:///model.ttl","svg":null,"targets":[],"warnings":["modelTooLarge"]}',
+        ) as unknown;
+        const missingSuccessfulSvg = JSON.parse(
+            '{"uri":"file:///model.ttl","targets":[],"warnings":[]}',
+        ) as unknown;
+
+        assert.equal(isGraphicalViewRenderResult(omittedSvg), true);
+        assert.equal(isGraphicalViewRenderResult(nullSvg), true);
+        assert.equal(isGraphicalViewRenderResult(missingSuccessfulSvg), false);
+    });
+
+    test('models omitted and explicit-null resolve result fields from Task 2 JSON', () => {
+        const omittedLocation = JSON.parse('{"warning":"notFound"}') as GraphicalViewResolveTargetResult;
+        const omittedWarning = JSON.parse(
+            '{"location":{"uri":"file:///model.ttl","range":{"start":{"line":1,"character":2},"end":{"line":1,"character":3}}}}',
+        ) as GraphicalViewResolveTargetResult;
+        const explicitNulls = JSON.parse('{"location":null,"warning":null}') as GraphicalViewResolveTargetResult;
+
+        assert.equal(omittedLocation.location, undefined);
+        assert.equal(omittedLocation.warning, 'notFound');
+        assert.equal(omittedWarning.warning, undefined);
+        assert.equal(omittedWarning.location?.uri, 'file:///model.ttl');
+        assert.equal(explicitNulls.location, null);
+        assert.equal(explicitNulls.warning, null);
+    });
+});
+
+class FakeLanguageClientAdapter implements LanguageClientAdapter {
+    state = State.Stopped;
+    readonly requests: Array<{method: string; params: unknown; token: vscode.CancellationToken | undefined}> = [];
+    private readonly listeners = new Set<(event: StateChangeEvent) => void>();
+
+    setTrace(_value: Trace): void {}
+
+    start(): Promise<void> {
+        this.transition(State.Running);
+        return Promise.resolve();
+    }
+
+    stop(): Promise<void> {
+        this.transition(State.Stopped);
+        return Promise.resolve();
+    }
+
+    onDidChangeState(listener: (event: StateChangeEvent) => void): vscode.Disposable {
+        this.listeners.add(listener);
+        return new vscode.Disposable(() => this.listeners.delete(listener));
+    }
+
+    sendRequest<R>(method: string, params?: unknown, token?: vscode.CancellationToken): Promise<R> {
+        this.requests.push({method, params, token});
+        if (method === GRAPHICAL_VIEW_RENDER_REQUEST) {
+            const result: GraphicalViewRenderResult = {uri: 'file:///model.ttl', svg: '<svg/>', targets: [], warnings: []};
+            return Promise.resolve(result as R);
+        }
+        const result: GraphicalViewResolveTargetResult = {location: null, warning: 'notFound'};
+        return Promise.resolve(result as R);
+    }
+
+    transition(newState: State): void {
+        const oldState = this.state;
+        this.state = newState;
+        for (const listener of [...this.listeners]) {
+            listener({oldState, newState});
+        }
+    }
+}
+
+class FakeLogger implements ExtensionLogger {
+    trace(_message: string): void {}
+    info(_message: string): void {}
+    warn(_message: string): void {}
+    error(_message: string | Error): void {}
+}

From 4438a2f2f9121d6e6eb7186b2c7f7dbffe572c60 Mon Sep 17 00:00:00 2001
From: e-filchenko-bosh <FVI2FE@bosch.com>
Date: Thu, 27 Aug 2026 15:21:49 +0300
Subject: [PATCH 2/7] Enhance graphical view functionality and add webview
 assets

---
 package-lock.json                             |  17 +
 package.json                                  |   6 +-
 src/extension.ts                              |   2 +-
 src/graphicalView.ts                          | 313 ++++++++++++++++--
 src/graphicalViewPanel.ts                     | 101 ++++--
 src/test/graphicalViewController.test.ts      | 210 ++++++++++++
 src/test/graphicalViewPanel.test.ts           | 100 ++++++
 src/test/graphicalViewTestHarness.ts          |  43 ++-
 .../graphicalViewWebviewLifecycle.test.ts     | 197 +++++++++++
 src/webview/RobotoCondensed-NOTICE.txt        |  19 ++
 src/webview/RobotoCondensed-Regular.ttf       | Bin 0 -> 140396 bytes
 src/webview/sanitizer-contract.js             | 155 +++++++++
 src/webview/webview.css                       |  95 ++++++
 src/webview/webview.js                        | 229 +++++++++++++
 14 files changed, 1428 insertions(+), 59 deletions(-)
 create mode 100644 src/test/graphicalViewPanel.test.ts
 create mode 100644 src/test/graphicalViewWebviewLifecycle.test.ts
 create mode 100644 src/webview/RobotoCondensed-NOTICE.txt
 create mode 100644 src/webview/RobotoCondensed-Regular.ttf
 create mode 100644 src/webview/sanitizer-contract.js
 create mode 100644 src/webview/webview.css
 create mode 100644 src/webview/webview.js

diff --git a/package-lock.json b/package-lock.json
index 6a2d563..591143d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,6 +9,7 @@
       "version": "0.0.1",
       "license": "MPL-2.0",
       "dependencies": {
+        "dompurify": "3.4.13",
         "extract-zip": "^2.0.1",
         "tar": "^7.5.15",
         "vscode-languageclient": "^9.0.1"
@@ -561,6 +562,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/trusted-types": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz",
+      "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==",
+      "license": "MIT",
+      "optional": true
+    },
     "node_modules/@types/vscode": {
       "version": "1.120.0",
       "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.120.0.tgz",
@@ -1422,6 +1430,15 @@
         "node": ">=0.3.1"
       }
     },
+    "node_modules/dompurify": {
+      "version": "3.4.13",
+      "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.4.13.tgz",
+      "integrity": "sha512-2vmYIoqjze2d+kakP8S/nS5shfsl587kzwEjcGlTdiksUVgFHnFCsLYDVj/JNqJVOQZGSYBTmuycv0PodwmnMQ==",
+      "license": "(MPL-2.0 OR Apache-2.0)",
+      "optionalDependencies": {
+        "@types/trusted-types": "^2.0.7"
+      }
+    },
     "node_modules/eastasianwidth": {
       "version": "0.2.0",
       "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
diff --git a/package.json b/package.json
index 87ade76..749b751 100644
--- a/package.json
+++ b/package.json
@@ -159,14 +159,15 @@
     "vscode:prepublish": "npm run build",
     "watch": "tsc -watch -p ./",
     "pretest": "npm run build && npm run lint",
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && node scripts/copy-webview-assets.mjs",
     "build-watch": "tsc -p tsconfig.json --watch",
     "prettier": "prettier --config .prettierrc --write './src/**/*{.ts,.js,.json}'",
     "test": "vscode-test --config .vscode-test.mjs",
     "test:prettier": "prettier --config .prettierrc --list-different './src/**/*{.ts,.js,.json}'",
     "test:coverage": "vscode-test --config .vscode-test.mjs --coverage --coverage-reporter text --coverage-reporter lcov",
     "lint": "eslint src --ext .ts",
-    "lint:fix": "eslint src --ext .ts --fix"
+    "lint:fix": "eslint src --ext .ts --fix",
+    "test:webview-assets": "node scripts/verify-webview-assets.mjs"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",
@@ -179,6 +180,7 @@
     "typescript-eslint": "^8.56.1"
   },
   "dependencies": {
+    "dompurify": "3.4.13",
     "extract-zip": "^2.0.1",
     "tar": "^7.5.15",
     "vscode-languageclient": "^9.0.1"
diff --git a/src/extension.ts b/src/extension.ts
index f396302..f573ad9 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -48,7 +48,7 @@ export async function activate(ctx: vscode.ExtensionContext): Promise<void> {
     aspectValidationController.register(context);
     graphicalViewController = new GraphicalViewController(
         undefined,
-        new VscodeGraphicalViewPanelFactory(),
+        new VscodeGraphicalViewPanelFactory(context.extensionUri),
         vscode.commands,
         vscode.window,
         {
diff --git a/src/graphicalView.ts b/src/graphicalView.ts
index f412aa1..5c4c09e 100644
--- a/src/graphicalView.ts
+++ b/src/graphicalView.ts
@@ -14,6 +14,7 @@
 import * as vscode from 'vscode';
 import type {ExtensionLogger} from './outputChannel';
 import {
+    GRAPHICAL_VIEW_MARKER_PATTERN,
     GraphicalViewRenderResult,
     GraphicalViewRenderWarning,
     GraphicalViewRequestClient,
@@ -31,6 +32,7 @@ export type GraphicalViewStatus =
     | Readonly<{kind: 'disconnected'; message: string}>;
 
 export interface GraphicalViewAcceptedResult {
+    readonly version: number;
     readonly uri: string;
     readonly svg: string;
     readonly targets: readonly Readonly<GraphicalViewTarget>[];
@@ -39,10 +41,15 @@ export interface GraphicalViewAcceptedResult {
 }
 
 export type GraphicalViewDelivery =
-    | Readonly<{type: 'status'; uri: string; status: GraphicalViewStatus}>
-    | Readonly<{type: 'render'; uri: string; svg: string; warnings: readonly GraphicalViewRenderWarning[]}>;
+    | Readonly<{type: 'status'; status: GraphicalViewStatus}>
+    | Readonly<{type: 'render'; version: number; svg: string}>;
 
-export type GraphicalViewPanelMessage = Readonly<{type: 'ready'}> | Readonly<{type: 'refresh'}> | Readonly<{type: 'navigate'; targetId: string}>;
+export type GraphicalViewPanelMessage =
+    | Readonly<{type: 'ready'}>
+    | Readonly<{type: 'refresh'}>
+    | Readonly<{type: 'rendered'; version: number}>
+    | Readonly<{type: 'renderError'; version: number; reason: 'sanitizationFailed'}>
+    | Readonly<{type: 'navigate'; version: number; targetId: string}>;
 
 export interface GraphicalViewPanelAdapter extends vscode.Disposable {
     readonly visible: boolean;
@@ -65,6 +72,7 @@ export interface GraphicalViewDocument {
 export interface GraphicalViewWindow {
     readonly activeTextEditor: {readonly document: GraphicalViewDocument} | undefined;
     showWarningMessage(message: string): Thenable<unknown>;
+    showTextDocument(uri: vscode.Uri, options?: vscode.TextDocumentShowOptions): Thenable<vscode.TextEditor>;
 }
 
 export interface GraphicalViewWorkspace {
@@ -99,8 +107,16 @@ interface PanelState {
     visible: boolean;
     disposed: boolean;
     cancellation: vscode.CancellationTokenSource | undefined;
+    navigationCancellation: vscode.CancellationTokenSource | undefined;
+    nextDisplayVersion: number;
     status: GraphicalViewStatus;
     lastSuccess: GraphicalViewAcceptedResult | undefined;
+    pendingDelivery: PendingDelivery | undefined;
+}
+
+interface PendingDelivery {
+    readonly accepted: GraphicalViewAcceptedResult;
+    readonly requestSequence: number;
 }
 
 const DISCONNECTED_STATUS: GraphicalViewStatus = Object.freeze({
@@ -166,8 +182,11 @@ export class GraphicalViewController implements vscode.Disposable {
             visible: panel.visible,
             disposed: false,
             cancellation: undefined,
+            navigationCancellation: undefined,
+            nextDisplayVersion: 0,
             status: Object.freeze({kind: 'loading', message: 'Preparing graphical view...'}),
             lastSuccess: undefined,
+            pendingDelivery: undefined,
         };
         this.panels.set(sourceUri, state);
         state.subscriptions.push(
@@ -272,7 +291,7 @@ export class GraphicalViewController implements vscode.Disposable {
         }
         state.visible = visible;
         if (visible) {
-            this.deliverCurrentState(state);
+            this.deliverStatus(state);
         }
     }
 
@@ -290,8 +309,14 @@ export class GraphicalViewController implements vscode.Disposable {
                     void this.requestRender(state, 'manual');
                 }
                 return;
+            case 'rendered':
+                this.handleRendered(state, message.version);
+                return;
+            case 'renderError':
+                this.handleRenderError(state, message.version);
+                return;
             case 'navigate':
-                // Task 4 validates current-sidecar membership and resolves navigation.
+                void this.navigateToTarget(state, message);
                 return;
         }
     }
@@ -335,7 +360,7 @@ export class GraphicalViewController implements vscode.Disposable {
             }
             state.cancellation = undefined;
             cancellation.dispose();
-            this.handleRenderResult(state, result);
+            this.handleRenderResult(state, result, sequence);
         } catch (error) {
             if (!this.isCurrentRequest(state, sourceUri, sequence, cancellation)) {
                 return;
@@ -346,7 +371,7 @@ export class GraphicalViewController implements vscode.Disposable {
         }
     }
 
-    private handleRenderResult(state: PanelState, result: unknown): void {
+    private handleRenderResult(state: PanelState, result: unknown, requestSequence: number): void {
         if (!isGraphicalViewRenderResult(result)) {
             this.setStale(state, 'invalidResponse', 'The language server returned an invalid graphical-view response.');
             return;
@@ -362,11 +387,127 @@ export class GraphicalViewController implements vscode.Disposable {
             return;
         }
 
-        const accepted = createAcceptedResult(result, result.svg);
-        state.lastSuccess = accepted;
-        state.status = Object.freeze({kind: 'ready', message: 'Graphical view is up to date.'});
-        state.panel.deliver(Object.freeze({type: 'render', uri: accepted.uri, svg: accepted.svg, warnings: accepted.warnings}));
-        this.deliverStatus(state);
+        const accepted = createAcceptedResult(result, result.svg, ++state.nextDisplayVersion);
+        state.pendingDelivery = Object.freeze({accepted, requestSequence});
+        state.panel.deliver(Object.freeze({type: 'render', version: accepted.version, svg: accepted.svg}));
+    }
+
+    private handleRendered(state: PanelState, version: number): void {
+        const pending = state.pendingDelivery;
+        if (pending?.accepted.version === version) {
+            this.cancelNavigation(state);
+            state.lastSuccess = pending.accepted;
+            state.pendingDelivery = undefined;
+            if (state.sequence === pending.requestSequence) {
+                this.setStatus(state, Object.freeze({kind: 'ready', message: 'Graphical view is up to date.'}));
+            }
+            return;
+        }
+
+        // An acknowledgement for a rehydrated last-successful snapshot must not
+        // clear a newer stale/error status.
+    }
+
+    private handleRenderError(state: PanelState, version: number): void {
+        if (state.pendingDelivery?.accepted.version === version) {
+            state.pendingDelivery = undefined;
+        } else if (state.lastSuccess?.version !== version) {
+            return;
+        }
+        this.outputChannel.warn('Graphical view rejected an SVG payload at the secure rendering boundary.');
+        this.setStale(
+            state,
+            'sanitizationFailed',
+            'The new diagram could not be displayed safely. The last successful diagram is retained.',
+        );
+    }
+
+    private async navigateToTarget(
+        state: PanelState,
+        message: Readonly<{type: 'navigate'; version: number; targetId: string}>,
+    ): Promise<void> {
+        const accepted = state.lastSuccess;
+        const target = accepted?.version === message.version ? accepted.targetById.get(message.targetId) : undefined;
+        if (!accepted || !target || target.kind !== 'elementHeader' || !GRAPHICAL_VIEW_MARKER_PATTERN.test(message.targetId)) {
+            return;
+        }
+
+        const client = this.client;
+        if (!client?.isGraphicalViewAvailable()) {
+            await this.warnNavigation('The graphical target is temporarily unavailable because the language server is disconnected.');
+            return;
+        }
+
+        this.cancelNavigation(state);
+        const cancellation = this.createCancellationSource();
+        state.navigationCancellation = cancellation;
+        try {
+            const response = await client.resolveGraphicalViewTarget(
+                {sourceUri: state.sourceUri, elementUrn: target.elementUrn},
+                cancellation.token,
+            );
+            if (!this.isCurrentNavigation(state, accepted, target, cancellation)) {
+                return;
+            }
+            state.navigationCancellation = undefined;
+            cancellation.dispose();
+
+            const resolved = validateResolveTargetResult(response);
+            if (resolved.kind === 'warning') {
+                await this.warnNavigation(resolveWarningMessage(resolved.warning));
+                return;
+            }
+            if (resolved.kind === 'invalid') {
+                await this.warnNavigation('The language server returned an invalid graphical target location.');
+                return;
+            }
+
+            try {
+                const editor = await this.window.showTextDocument(resolved.uri, {preview: false});
+                if (!this.isCurrentNavigationResult(state, accepted, target)) {
+                    return;
+                }
+                const range = new vscode.Range(
+                    resolved.start.line,
+                    resolved.start.character,
+                    resolved.end.line,
+                    resolved.end.character,
+                );
+                editor.selection = new vscode.Selection(range.start, range.end);
+                editor.revealRange(range, vscode.TextEditorRevealType.InCenterIfOutsideViewport);
+            } catch (_error) {
+                await this.warnNavigation('The graphical target could not be opened in an editor.');
+            }
+        } catch (_error) {
+            if (this.isCurrentNavigation(state, accepted, target, cancellation)) {
+                state.navigationCancellation = undefined;
+                cancellation.dispose();
+                await this.warnNavigation('The graphical target is temporarily unavailable.');
+            }
+        }
+    }
+
+    private isCurrentNavigation(
+        state: PanelState,
+        accepted: GraphicalViewAcceptedResult,
+        target: Readonly<GraphicalViewTarget>,
+        cancellation: vscode.CancellationTokenSource,
+    ): boolean {
+        return state.navigationCancellation === cancellation && this.isCurrentNavigationResult(state, accepted, target);
+    }
+
+    private isCurrentNavigationResult(
+        state: PanelState,
+        accepted: GraphicalViewAcceptedResult,
+        target: Readonly<GraphicalViewTarget>,
+    ): boolean {
+        return this.isCurrent(state)
+            && state.lastSuccess === accepted
+            && accepted.targetById.get(target.id) === target;
+    }
+
+    private async warnNavigation(message: string): Promise<void> {
+        await this.window.showWarningMessage(message);
     }
 
     private handleWarningResult(state: PanelState, warnings: readonly GraphicalViewRenderWarning[]): void {
@@ -403,7 +544,9 @@ export class GraphicalViewController implements vscode.Disposable {
         }
 
         const detail = error instanceof Error ? error.message : String(error);
-        this.setStale(state, classifyFailure(detail), `Graphical rendering failed: ${detail}. The last successful diagram is retained.`);
+        const reason = classifyFailure(detail);
+        this.outputChannel.warn(`Graphical view render request failed (${reason}).`);
+        this.setStale(state, reason, 'Graphical rendering failed. The last successful diagram is retained.');
     }
 
     private setStale(state: PanelState, reason: string, message: string): void {
@@ -420,14 +563,14 @@ export class GraphicalViewController implements vscode.Disposable {
 
     private deliverCurrentState(state: PanelState): void {
         this.deliverStatus(state);
-        const accepted = state.lastSuccess;
+        const accepted = state.pendingDelivery?.accepted ?? state.lastSuccess;
         if (accepted) {
-            state.panel.deliver(Object.freeze({type: 'render', uri: accepted.uri, svg: accepted.svg, warnings: accepted.warnings}));
+            state.panel.deliver(Object.freeze({type: 'render', version: accepted.version, svg: accepted.svg}));
         }
     }
 
     private deliverStatus(state: PanelState): void {
-        state.panel.deliver(Object.freeze({type: 'status', uri: state.sourceUri, status: state.status}));
+        state.panel.deliver(Object.freeze({type: 'status', status: state.status}));
     }
 
     private invalidate(state: PanelState): void {
@@ -435,6 +578,8 @@ export class GraphicalViewController implements vscode.Disposable {
             return;
         }
         this.cancelCurrent(state);
+        this.cancelNavigation(state);
+        state.pendingDelivery = undefined;
         state.sequence += 1;
     }
 
@@ -447,6 +592,15 @@ export class GraphicalViewController implements vscode.Disposable {
         }
     }
 
+    private cancelNavigation(state: PanelState): void {
+        const cancellation = state.navigationCancellation;
+        state.navigationCancellation = undefined;
+        if (cancellation) {
+            cancellation.cancel();
+            cancellation.dispose();
+        }
+    }
+
     private isCurrentRequest(
         state: PanelState,
         sourceUri: string,
@@ -465,6 +619,7 @@ export class GraphicalViewController implements vscode.Disposable {
             return;
         }
         this.cancelCurrent(state);
+        this.cancelNavigation(state);
         state.sequence += 1;
         state.disposed = true;
         this.panels.delete(state.sourceUri);
@@ -488,11 +643,11 @@ export class GraphicalViewController implements vscode.Disposable {
     }
 }
 
-function createAcceptedResult(result: GraphicalViewRenderResult, svg: string): GraphicalViewAcceptedResult {
+function createAcceptedResult(result: GraphicalViewRenderResult, svg: string, version: number): GraphicalViewAcceptedResult {
     const targets = Object.freeze(result.targets.map(target => Object.freeze({...target})));
     const warnings = Object.freeze([...result.warnings]);
     const targetById = new ImmutableTargetMap(targets.map(target => [target.id, target]));
-    return Object.freeze({uri: result.uri, svg, targets, warnings, targetById});
+    return Object.freeze({version, uri: result.uri, svg, targets, warnings, targetById});
 }
 
 class ImmutableTargetMap<K, V> implements ReadonlyMap<K, V> {
@@ -576,11 +731,129 @@ function isPanelMessage(value: unknown): value is GraphicalViewPanelMessage {
     if (!isRecord(value)) {
         return false;
     }
-    const keys = Object.keys(value);
+    const keys = Object.keys(value).sort();
     if ((value.type === 'ready' || value.type === 'refresh') && keys.length === 1) {
         return true;
     }
-    return value.type === 'navigate' && keys.length === 2 && typeof value.targetId === 'string';
+    if (value.type === 'rendered') {
+        return keys.length === 2 && keys[0] === 'type' && keys[1] === 'version' && isDisplayedVersion(value.version);
+    }
+    if (value.type === 'renderError') {
+        return keys.length === 3
+            && keys[0] === 'reason'
+            && keys[1] === 'type'
+            && keys[2] === 'version'
+            && value.reason === 'sanitizationFailed'
+            && isDisplayedVersion(value.version);
+    }
+    return value.type === 'navigate'
+        && keys.length === 3
+        && keys[0] === 'targetId'
+        && keys[1] === 'type'
+        && keys[2] === 'version'
+        && isDisplayedVersion(value.version)
+        && typeof value.targetId === 'string'
+        && GRAPHICAL_VIEW_MARKER_PATTERN.test(value.targetId);
+}
+
+function isDisplayedVersion(value: unknown): value is number {
+    return Number.isSafeInteger(value) && (value as number) > 0;
+}
+
+type ValidatedResolveTarget =
+    | Readonly<{kind: 'location'; uri: vscode.Uri; start: vscode.Position; end: vscode.Position}>
+    | Readonly<{kind: 'warning'; warning: GraphicalViewResolveWarning}>
+    | Readonly<{kind: 'invalid'}>;
+
+type GraphicalViewResolveWarning = 'notFound' | 'ambiguous' | 'unsupportedUri' | 'temporarilyUnresolvable';
+
+const RESOLVE_WARNINGS: ReadonlySet<string> = new Set([
+    'notFound',
+    'ambiguous',
+    'unsupportedUri',
+    'temporarilyUnresolvable',
+]);
+
+function validateResolveTargetResult(value: unknown): ValidatedResolveTarget {
+    if (!isRecord(value) || !hasOnlyKeys(value, ['location', 'warning'])) {
+        return {kind: 'invalid'};
+    }
+
+    const warning = value.warning;
+    if (warning !== undefined && warning !== null && (typeof warning !== 'string' || !RESOLVE_WARNINGS.has(warning))) {
+        return {kind: 'invalid'};
+    }
+    const location = value.location;
+    if (location === undefined || location === null) {
+        return typeof warning === 'string'
+            ? {kind: 'warning', warning: warning as GraphicalViewResolveWarning}
+            : {kind: 'invalid'};
+    }
+    if (warning !== undefined && warning !== null) {
+        return {kind: 'invalid'};
+    }
+    if (!isRecord(location) || !hasExactKeys(location, ['range', 'uri']) || typeof location.uri !== 'string') {
+        return {kind: 'invalid'};
+    }
+    const range = location.range;
+    if (!isRecord(range) || !hasExactKeys(range, ['end', 'start'])) {
+        return {kind: 'invalid'};
+    }
+    const start = validatePosition(range.start);
+    const end = validatePosition(range.end);
+    if (!start || !end || start.isAfter(end)) {
+        return {kind: 'invalid'};
+    }
+
+    try {
+        const uri = vscode.Uri.parse(location.uri, true);
+        if (uri.scheme !== 'file'
+            || uri.authority !== ''
+            || !uri.path.startsWith('/')
+            || uri.query !== ''
+            || uri.fragment !== ''
+            || uri.fsPath.includes('\0')) {
+            return {kind: 'warning', warning: 'unsupportedUri'};
+        }
+        return {kind: 'location', uri, start, end};
+    } catch (_error) {
+        return {kind: 'invalid'};
+    }
+}
+
+function validatePosition(value: unknown): vscode.Position | undefined {
+    if (!isRecord(value)
+        || !hasExactKeys(value, ['character', 'line'])
+        || !Number.isSafeInteger(value.line)
+        || !Number.isSafeInteger(value.character)
+        || (value.line as number) < 0
+        || (value.character as number) < 0) {
+        return undefined;
+    }
+    return new vscode.Position(value.line as number, value.character as number);
+}
+
+function hasOnlyKeys(value: Record<string, unknown>, allowedKeys: readonly string[]): boolean {
+    const allowed = new Set(allowedKeys);
+    return Object.keys(value).every(key => allowed.has(key));
+}
+
+function hasExactKeys(value: Record<string, unknown>, expectedKeys: readonly string[]): boolean {
+    const actualKeys = Object.keys(value).sort();
+    return actualKeys.length === expectedKeys.length && actualKeys.every((key, index) => key === expectedKeys[index]);
+}
+
+function resolveWarningMessage(warning: GraphicalViewResolveWarning): string {
+    switch (warning) {
+        case 'notFound':
+            return 'The graphical target no longer exists in the current model.';
+        case 'ambiguous':
+            return 'The graphical target is ambiguous in the current model.';
+        case 'unsupportedUri':
+            return 'The graphical target is not a local file and cannot be opened.';
+        case 'temporarilyUnresolvable':
+            return 'The graphical target is temporarily unavailable. Fix any model syntax errors and try again.';
+    }
 }
 
 function isMethodNotFound(error: unknown): boolean {
diff --git a/src/graphicalViewPanel.ts b/src/graphicalViewPanel.ts
index 0bbda48..e04b411 100644
--- a/src/graphicalViewPanel.ts
+++ b/src/graphicalViewPanel.ts
@@ -16,24 +16,31 @@ import * as vscode from 'vscode';
 import {GraphicalViewDelivery, GraphicalViewPanelAdapter, GraphicalViewPanelFactory} from './graphicalView';
 
 const VIEW_TYPE = 'turtle.graphicalView';
+export const WEBVIEW_ASSET_DIRECTORY = Object.freeze(['out', 'webview'] as const);
+export const WEBVIEW_SCRIPT_ORDER = Object.freeze(['purify.min.js', 'sanitizer-contract.js', 'webview.js'] as const);
 
 export class VscodeGraphicalViewPanelFactory implements GraphicalViewPanelFactory {
+    constructor(private readonly extensionUri: vscode.Uri) {}
+
     create(sourceUri: string): GraphicalViewPanelAdapter {
         const uri = vscode.Uri.parse(sourceUri, true);
         const name = uri.path.split('/').filter(Boolean).at(-1) ?? 'Aspect Model';
-        const panel = vscode.window.createWebviewPanel(VIEW_TYPE, `Graphical View: ${name}`, vscode.ViewColumn.Beside, {
-            enableScripts: true,
-            enableForms: false,
-            enableCommandUris: false,
-            localResourceRoots: [],
-        });
-        return new VscodeGraphicalViewPanel(panel);
+        const panel = vscode.window.createWebviewPanel(
+            VIEW_TYPE,
+            `Graphical View: ${name}`,
+            vscode.ViewColumn.Beside,
+            createGraphicalViewPanelOptions(this.extensionUri),
+        );
+        return new VscodeGraphicalViewPanel(panel, this.extensionUri);
     }
 }
 
 class VscodeGraphicalViewPanel implements GraphicalViewPanelAdapter {
-    constructor(private readonly panel: vscode.WebviewPanel) {
-        panel.webview.html = createShellHtml(panel.webview);
+    constructor(
+        private readonly panel: vscode.WebviewPanel,
+        extensionUri: vscode.Uri,
+    ) {
+        panel.webview.html = createShellHtml(panel.webview, extensionUri);
     }
 
     get visible(): boolean {
@@ -65,37 +72,65 @@ class VscodeGraphicalViewPanel implements GraphicalViewPanelAdapter {
     }
 }
 
-function createShellHtml(webview: vscode.Webview): string {
-    const nonce = randomBytes(16).toString('hex');
+export function webviewAssetDirectory(extensionUri: vscode.Uri): vscode.Uri {
+    return vscode.Uri.joinPath(extensionUri, ...WEBVIEW_ASSET_DIRECTORY);
+}
+
+export function createGraphicalViewPanelOptions(extensionUri: vscode.Uri): vscode.WebviewPanelOptions & vscode.WebviewOptions {
+    return {
+        enableScripts: true,
+        enableForms: false,
+        enableCommandUris: false,
+        localResourceRoots: [webviewAssetDirectory(extensionUri)],
+    };
+}
+
+export function createShellHtml(
+    webview: Pick<vscode.Webview, 'asWebviewUri' | 'cspSource'>,
+    extensionUri: vscode.Uri,
+    nonce = randomBytes(18).toString('base64'),
+    testMode = false,
+): string {
+    const assetDirectory = webviewAssetDirectory(extensionUri);
+    const stylesheetUri = webview.asWebviewUri(vscode.Uri.joinPath(assetDirectory, 'webview.css'));
+    const scriptUris = WEBVIEW_SCRIPT_ORDER.map(asset => webview.asWebviewUri(vscode.Uri.joinPath(assetDirectory, asset)));
+    const csp = [
+        "default-src 'none'",
+        `script-src 'nonce-${nonce}'`,
+        `style-src ${webview.cspSource}`,
+        `font-src ${webview.cspSource}`,
+        "img-src 'none'",
+        "connect-src 'none'",
+        "object-src 'none'",
+        "base-uri 'none'",
+        "form-action 'none'",
+    ].join('; ');
+
     return `<!DOCTYPE html>
-<html lang="en">
+<html lang="en"${testMode ? ' data-test-mode="true"' : ''}>
 <head>
     <meta charset="UTF-8">
-    <meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'nonce-${nonce}'; style-src 'none'; img-src 'none'; connect-src 'none'; object-src 'none'; base-uri 'none'; form-action 'none'">
+    <meta http-equiv="Content-Security-Policy" content="${csp}">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <link rel="stylesheet" href="${stylesheetUri}">
     <title>Graphical View</title>
 </head>
 <body>
-    <button id="refresh" type="button">Refresh</button>
-    <p id="status" role="status">Preparing graphical view...</p>
-    <p id="task4-boundary">Diagram rendering is prepared. Secure SVG display is completed in Task 4.</p>
-    <script nonce="${nonce}">
-        (() => {
-            const vscode = acquireVsCodeApi();
-            const status = document.getElementById('status');
-            document.getElementById('refresh').addEventListener('click', () => vscode.postMessage({type: 'refresh'}));
-            window.addEventListener('message', event => {
-                const message = event.data;
-                if (message && message.type === 'status' && message.status && typeof message.status.message === 'string') {
-                    status.textContent = message.status.message;
-                }
-                if (message && message.type === 'render') {
-                    document.body.dataset.snapshotAvailable = 'true';
-                }
-            });
-            vscode.postMessage({type: 'ready'});
-        })();
-    </script>
+    <div id="toolbar" role="toolbar" aria-label="Graphical view controls">
+        <button id="refresh" type="button" aria-label="Refresh graphical view" title="Refresh">Refresh</button>
+        <button id="zoom-out" type="button" aria-label="Zoom out" title="Zoom out">−</button>
+        <output id="zoom-value" aria-live="polite">100%</output>
+        <button id="zoom-in" type="button" aria-label="Zoom in" title="Zoom in">+</button>
+        <button id="zoom-reset" type="button" aria-label="Reset zoom to 100 percent" title="Reset zoom">100%</button>
+        <button id="zoom-fit" type="button" aria-label="Fit diagram to view" title="Fit to view">Fit</button>
+        <p id="status" role="status">Preparing graphical view...</p>
+    </div>
+    <main id="viewport" tabindex="0" aria-label="Scrollable graphical view">
+        <div id="diagram" aria-live="off"></div>
+    </main>
+    <script nonce="${nonce}" src="${scriptUris[0]}"></script>
+    <script nonce="${nonce}" src="${scriptUris[1]}"></script>
+    <script nonce="${nonce}" src="${scriptUris[2]}"></script>
 </body>
 </html>`;
 }
diff --git a/src/test/graphicalViewController.test.ts b/src/test/graphicalViewController.test.ts
index 7604c56..9e72414 100644
--- a/src/test/graphicalViewController.test.ts
+++ b/src/test/graphicalViewController.test.ts
@@ -14,6 +14,7 @@
 import * as assert from 'node:assert/strict';
 import {readFileSync} from 'node:fs';
 import {join} from 'node:path';
+import * as vscode from 'vscode';
 import {OPEN_GRAPHICAL_VIEW_COMMAND} from '../graphicalView';
 import {GraphicalViewRenderResult} from '../graphicalViewProtocol';
 import {
@@ -267,6 +268,215 @@ suite('GraphicalViewController', () => {
         harness.controller.dispose();
     });
 
+    test('commits a sidecar only after secure render confirmation and retains last-good state on render rejection', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/secure-render.ttl');
+        await harness.controller.openGraphicalView(document);
+        const first = successfulResult(document, 'aaaaaaaaaaaaaaaa');
+        harness.client.requests[0].deferred.resolve(first);
+        await flushPromises();
+        const retained = harness.controller.getPanelState(document.uri.toString())?.lastSuccess;
+        assert.equal(retained?.version, 1);
+
+        const panel = harness.panels.panels[0];
+        panel.renderOutcome = 'failure';
+        panel.emitMessage({type: 'refresh'});
+        const rejected = successfulResult(document, 'bbbbbbbbbbbbbbbb');
+        harness.client.requests[1].deferred.resolve(rejected);
+        await flushPromises();
+
+        const state = harness.controller.getPanelState(document.uri.toString());
+        assert.equal(state?.status.kind, 'stale');
+        assert.equal(state?.lastSuccess, retained);
+        assert.equal(state?.lastSuccess?.targetById.has(first.targets[0].id), true);
+        assert.equal(state?.lastSuccess?.targetById.has(rejected.targets[0].id), false);
+        harness.controller.dispose();
+    });
+
+    test('late acknowledgement for delivered A establishes its sidecar without overwriting loading state for B', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/delayed-render-ack-loading.ttl');
+        await harness.controller.openGraphicalView(document);
+        const panel = harness.panels.panels[0];
+        panel.renderOutcome = 'none';
+
+        harness.client.requests[0].deferred.resolve(successfulResult(document, 'aaaaaaaaaaaaaaaa'));
+        await flushPromises();
+        panel.emitMessage({type: 'refresh'});
+        const loadingB = harness.controller.getPanelState(document.uri.toString())?.status;
+
+        panel.emitMessage({type: 'rendered', version: 1});
+        const state = harness.controller.getPanelState(document.uri.toString());
+        assert.equal(state?.lastSuccess?.version, 1);
+        assert.equal(state?.status, loadingB);
+        assert.equal(state?.status.kind, 'loading');
+        harness.controller.dispose();
+    });
+
+    test('late acknowledgement for delivered A establishes its sidecar without overwriting failed state for B', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/delayed-render-ack-stale.ttl');
+        await harness.controller.openGraphicalView(document);
+        const panel = harness.panels.panels[0];
+        panel.renderOutcome = 'none';
+
+        harness.client.requests[0].deferred.resolve(successfulResult(document, 'aaaaaaaaaaaaaaaa'));
+        await flushPromises();
+        panel.emitMessage({type: 'refresh'});
+        harness.client.requests[1].deferred.reject(new Error('render B failed'));
+        await flushPromises();
+        const failedB = harness.controller.getPanelState(document.uri.toString())?.status;
+
+        panel.emitMessage({type: 'rendered', version: 1});
+        const state = harness.controller.getPanelState(document.uri.toString());
+        assert.equal(state?.lastSuccess?.version, 1);
+        assert.equal(state?.status, failedB);
+        assert.equal(state?.status.kind, 'stale');
+        harness.controller.dispose();
+    });
+
+    test('rehydrates the current version through ready without an LSP render or shell reset', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/rehydrate.ttl');
+        await harness.controller.openGraphicalView(document);
+        harness.client.requests[0].deferred.resolve(successfulResult(document));
+        await flushPromises();
+        const panel = harness.panels.panels[0];
+        const renderCount = panel.deliveries.filter(delivery => delivery.type === 'render').length;
+
+        panel.emitMessage({type: 'ready'});
+        assert.equal(harness.client.requests.length, 1);
+        assert.equal(panel.deliveries.filter(delivery => delivery.type === 'render').length, renderCount + 1);
+        assert.equal(harness.controller.getPanelState(document.uri.toString())?.lastSuccess?.version, 1);
+
+        panel.renderOutcome = 'failure';
+        panel.emitMessage({type: 'refresh'});
+        harness.client.requests[1].deferred.resolve(successfulResult(document, 'bbbbbbbbbbbbbbbb'));
+        await flushPromises();
+        assert.equal(harness.controller.getPanelState(document.uri.toString())?.status.kind, 'stale');
+
+        panel.renderOutcome = 'success';
+        panel.emitMessage({type: 'ready'});
+        assert.equal(harness.client.requests.length, 2);
+        assert.equal(harness.controller.getPanelState(document.uri.toString())?.lastSuccess?.version, 1);
+        assert.equal(harness.controller.getPanelState(document.uri.toString())?.status.kind, 'stale');
+        harness.controller.dispose();
+    });
+
+    test('resolves a current sidecar-backed marker and opens, selects, and reveals only its local file location', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/navigation-source.ttl');
+        await harness.controller.openGraphicalView(document);
+        const result = successfulResult(document);
+        harness.client.requests[0].deferred.resolve(result);
+        await flushPromises();
+        const targetUri = vscode.Uri.file('/tmp/navigation-target.ttl');
+        harness.client.resolveResult = {
+            location: {
+                uri: targetUri.toString(),
+                range: {start: {line: 3, character: 4}, end: {line: 5, character: 6}},
+            },
+        };
+
+        harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: result.targets[0].id});
+        await flushPromises();
+        await flushPromises();
+
+        assert.deepEqual(harness.client.resolveRequests[0].params, {
+            sourceUri: document.uri.toString(),
+            elementUrn: result.targets[0].elementUrn,
+        });
+        assert.equal(harness.client.resolveRequests[0].token?.isCancellationRequested, false);
+        assert.equal(harness.window.openedEditors[0].uri.toString(), targetUri.toString());
+        assert.equal(harness.window.openedEditors[0].options?.preview, false);
+        assert.deepEqual(harness.window.openedEditors[0].editor.selection.start, new vscode.Position(3, 4));
+        assert.deepEqual(harness.window.openedEditors[0].editor.selection.end, new vscode.Position(5, 6));
+        assert.deepEqual(harness.window.openedEditors[0].revealedRanges[0], new vscode.Range(3, 4, 5, 6));
+        harness.controller.dispose();
+    });
+
+    test('rejects malformed, stale, fake, extra-field, and non-sidecar navigation before LSP resolution', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/rejected-navigation.ttl');
+        await harness.controller.openGraphicalView(document);
+        const first = successfulResult(document, 'aaaaaaaaaaaaaaaa');
+        harness.client.requests[0].deferred.resolve(first);
+        await flushPromises();
+
+        const rejectedMessages: unknown[] = [
+            {type: 'navigate', targetId: first.targets[0].id},
+            {type: 'navigate', version: 1, targetId: first.targets[0].id, uri: 'file:///tmp/evil.ttl'},
+            {type: 'navigate', version: 1, targetId: 'gv-header-bbbbbbbbbbbbbbbb'},
+            {type: 'navigate', version: 1, targetId: 'bad-marker'},
+            {type: 'navigate', version: 1.5, targetId: first.targets[0].id},
+            {type: 'navigate', version: '1', targetId: first.targets[0].id},
+            {type: 'navigate', version: 1, targetId: first.targets[0].id, elementUrn: first.targets[0].elementUrn},
+        ];
+        for (const message of rejectedMessages) {
+            harness.panels.panels[0].emitMessage(message);
+        }
+
+        harness.panels.panels[0].emitMessage({type: 'refresh'});
+        const second = successfulResult(document, 'cccccccccccccccc');
+        harness.client.requests[1].deferred.resolve(second);
+        await flushPromises();
+        harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: first.targets[0].id});
+        assert.equal(harness.client.resolveRequests.length, 0);
+        assert.equal(harness.window.openedEditors.length, 0);
+        harness.controller.dispose();
+    });
+
+    test('blocks warning, malformed, invalid-range, non-file, resolver-failure, and editor-open navigation paths', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/navigation-failures.ttl');
+        await harness.controller.openGraphicalView(document);
+        const result = successfulResult(document);
+        harness.client.requests[0].deferred.resolve(result);
+        await flushPromises();
+        const navigate = async () => {
+            harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: result.targets[0].id});
+            await flushPromises();
+            await flushPromises();
+        };
+
+        for (const warning of ['notFound', 'ambiguous', 'unsupportedUri', 'temporarilyUnresolvable'] as const) {
+            harness.client.resolveResult = {location: null, warning};
+            await navigate();
+        }
+        harness.client.resolveResult = {
+            location: {
+                uri: 'https://example.invalid/model.ttl',
+                range: {start: {line: 0, character: 0}, end: {line: 0, character: 1}},
+            },
+        };
+        await navigate();
+        harness.client.resolveResult = {
+            location: {
+                uri: vscode.Uri.file('/tmp/invalid-range.ttl').toString(),
+                range: {start: {line: 2, character: 0}, end: {line: 1, character: 0}},
+            },
+        };
+        await navigate();
+        harness.client.resolveResult = {location: null, warning: null};
+        await navigate();
+        harness.client.resolveFailure = new Error('hostile resolver detail');
+        await navigate();
+        harness.client.resolveFailure = undefined;
+        harness.client.resolveResult = {
+            location: {
+                uri: vscode.Uri.file('/tmp/open-failure.ttl').toString(),
+                range: {start: {line: 0, character: 0}, end: {line: 0, character: 1}},
+            },
+        };
+        harness.window.showTextDocumentFailure = new Error('hostile editor detail');
+        await navigate();
+
+        assert.equal(harness.window.openedEditors.length, 0);
+        assert.equal(harness.window.warnings.length, 9);
+        assert.ok(harness.window.warnings.every(message => !message.includes('hostile')));
+        harness.controller.dispose();
+    });
+
     test('detects MethodNotFound by code and recovers compatibility state after client replacement', async () => {
         const harness = createGraphicalViewHarness();
         const document = track(harness, '/tmp/unsupported.ttl');
diff --git a/src/test/graphicalViewPanel.test.ts b/src/test/graphicalViewPanel.test.ts
new file mode 100644
index 0000000..f2c8f98
--- /dev/null
+++ b/src/test/graphicalViewPanel.test.ts
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ *
+ * See the AUTHORS file(s) distributed with this work for additional
+ * information regarding authorship.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import * as assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {readdirSync, readFileSync} from 'node:fs';
+import {join} from 'node:path';
+import * as vscode from 'vscode';
+import {WEBVIEW_SCRIPT_ORDER, createGraphicalViewPanelOptions, createShellHtml, webviewAssetDirectory} from '../graphicalViewPanel';
+
+suite('GraphicalView secure panel contract', () => {
+    test('uses exact script/forms/command options and one out/webview resource root without retention', () => {
+        const extensionUri = vscode.Uri.file('/tmp/graphical-view-extension');
+        const options = createGraphicalViewPanelOptions(extensionUri);
+
+        assert.equal(options.enableScripts, true);
+        assert.equal(options.enableForms, false);
+        assert.equal(options.enableCommandUris, false);
+        assert.equal(options.localResourceRoots?.length, 1);
+        assert.equal(options.localResourceRoots?.[0].toString(), webviewAssetDirectory(extensionUri).toString());
+        assert.equal('retainContextWhenHidden' in options, false);
+    });
+
+    test('creates the exact CSP, fresh nonce, local resource URIs, and fixed external script order', () => {
+        const extensionUri = vscode.Uri.file('/tmp/graphical-view-extension');
+        const webview = {
+            cspSource: 'vscode-webview-resource:',
+            asWebviewUri: (uri: vscode.Uri) => uri.with({scheme: 'vscode-webview-resource'}),
+        };
+        const first = createShellHtml(webview, extensionUri, 'first-nonce');
+        const second = createShellHtml(webview, extensionUri, 'second-nonce');
+
+        const expectedCsp =
+            "default-src 'none'; script-src 'nonce-first-nonce'; style-src vscode-webview-resource:; " +
+            "font-src vscode-webview-resource:; img-src 'none'; connect-src 'none'; object-src 'none'; " +
+            "base-uri 'none'; form-action 'none'";
+        assert.ok(first.includes(`content="${expectedCsp}"`));
+        assert.equal(first.includes('second-nonce'), false);
+        assert.equal(second.includes('second-nonce'), true);
+        assert.equal((first.match(/<script /g) ?? []).length, 3);
+        assert.equal((first.match(/nonce="first-nonce"/g) ?? []).length, 3);
+        assert.equal(first.includes('<script nonce="first-nonce">'), false);
+        assert.equal(first.includes('http://'), false);
+        assert.equal(first.includes('https://'), false);
+
+        const scriptPositions = WEBVIEW_SCRIPT_ORDER.map(asset => first.indexOf(`/out/webview/${asset}`));
+        assert.ok(scriptPositions.every(position => position >= 0));
+        assert.deepEqual(
+            [...scriptPositions].sort((left, right) => left - right),
+            scriptPositions,
+        );
+        assert.ok(first.includes('/out/webview/webview.css'));
+    });
+
+    test('build output contains only the deterministic webview inventory and reference hashes', () => {
+        const outputDirectory = join(__dirname, '..', 'webview');
+        const expectedFiles = [
+            'DOMPurify-LICENSE-Apache-2.0.txt',
+            'DOMPurify-LICENSE-MPL-2.0.txt',
+            'RobotoCondensed-NOTICE.txt',
+            'RobotoCondensed-Regular.ttf',
+            'purify.min.js',
+            'sanitizer-contract.js',
+            'webview.css',
+            'webview.js',
+        ];
+        assert.deepEqual(readdirSync(outputDirectory).sort(), expectedFiles);
+        assert.equal(sha256(join(outputDirectory, 'purify.min.js')), '9ab3d44d73c3e3947f9ab72e0f0bc15c7f1931d60b365ba261fc85fe59013c56');
+        assert.equal(
+            sha256(join(outputDirectory, 'RobotoCondensed-Regular.ttf')),
+            '4a7c36df4318fee50a8159c3a0ebde4572abab65447ae4a651c2fe87212302b5',
+        );
+    });
+
+    test('webview controller retains a stable DOM sink and persists passive viewport state only', () => {
+        const controllerSource = readFileSync(join(__dirname, '..', '..', 'src', 'webview', 'webview.js'), 'utf8');
+        assert.ok(controllerSource.includes('diagram.replaceChildren(sanitized.fragment)'));
+        assert.equal(/innerHTML|outerHTML|insertAdjacentHTML/.test(controllerSource), false);
+        assert.ok(controllerSource.includes('vscode.getState()'));
+        assert.ok(controllerSource.includes('vscode.setState(state)'));
+        assert.ok(controllerSource.includes('schemaVersion: 1'));
+        assert.ok(controllerSource.includes('scrollLeft'));
+        assert.ok(controllerSource.includes('scrollTop'));
+        assert.equal(/setState\([^)]*(?:svg|uri|target|command)/i.test(controllerSource), false);
+    });
+});
+
+function sha256(file: string): string {
+    return createHash('sha256').update(readFileSync(file)).digest('hex');
+}
diff --git a/src/test/graphicalViewTestHarness.ts b/src/test/graphicalViewTestHarness.ts
index 6ea0459..e495994 100644
--- a/src/test/graphicalViewTestHarness.ts
+++ b/src/test/graphicalViewTestHarness.ts
@@ -37,8 +37,16 @@ export interface RecordedRenderRequest {
     readonly deferred: Deferred<GraphicalViewRenderResult>;
 }
 
+export interface RecordedResolveRequest {
+    readonly params: GraphicalViewResolveTargetParams;
+    readonly token: vscode.CancellationToken | undefined;
+}
+
 export class FakeGraphicalViewClient implements GraphicalViewRequestClient {
     readonly requests: RecordedRenderRequest[] = [];
+    readonly resolveRequests: RecordedResolveRequest[] = [];
+    resolveResult: GraphicalViewResolveTargetResult = {location: null, warning: 'temporarilyUnresolvable'};
+    resolveFailure: unknown | undefined;
     private readonly listeners = new Set<(available: boolean) => void>();
 
     constructor(private available = true) {}
@@ -59,10 +67,11 @@ export class FakeGraphicalViewClient implements GraphicalViewRequestClient {
     }
 
     resolveGraphicalViewTarget(
-        _params: GraphicalViewResolveTargetParams,
-        _token?: vscode.CancellationToken,
+        params: GraphicalViewResolveTargetParams,
+        token?: vscode.CancellationToken,
     ): Promise<GraphicalViewResolveTargetResult> {
-        return Promise.resolve({location: null, warning: 'temporarilyUnresolvable'});
+        this.resolveRequests.push({params, token});
+        return this.resolveFailure === undefined ? Promise.resolve(this.resolveResult) : Promise.reject(this.resolveFailure);
     }
 
     setAvailable(available: boolean): void {
@@ -78,6 +87,7 @@ export class FakeGraphicalViewPanel implements GraphicalViewPanelAdapter {
     revealCount = 0;
     disposeCount = 0;
     disposedListenerCount = 0;
+    renderOutcome: 'success' | 'failure' | 'none' = 'success';
     private readonly disposeListeners = new Set<() => void>();
     private readonly visibilityListeners = new Set<(visible: boolean) => void>();
     private readonly messageListeners = new Set<(message: unknown) => void>();
@@ -91,6 +101,13 @@ export class FakeGraphicalViewPanel implements GraphicalViewPanelAdapter {
 
     deliver(delivery: GraphicalViewDelivery): void {
         this.deliveries.push(delivery);
+        if (delivery.type === 'render' && this.renderOutcome !== 'none') {
+            this.emitMessage(
+                this.renderOutcome === 'success'
+                    ? {type: 'rendered', version: delivery.version}
+                    : {type: 'renderError', version: delivery.version, reason: 'sanitizationFailed'},
+            );
+        }
     }
 
     onDidDispose(listener: () => void): vscode.Disposable {
@@ -199,11 +216,31 @@ class FakeCommands implements GraphicalViewCommands {
 class FakeWindow implements GraphicalViewWindow {
     activeTextEditor: {document: GraphicalViewDocument} | undefined;
     readonly warnings: string[] = [];
+    readonly openedEditors: Array<{
+        uri: vscode.Uri;
+        options: vscode.TextDocumentShowOptions | undefined;
+        editor: vscode.TextEditor;
+        revealedRanges: vscode.Range[];
+    }> = [];
+    showTextDocumentFailure: unknown | undefined;
 
     showWarningMessage(message: string): Promise<unknown> {
         this.warnings.push(message);
         return Promise.resolve(undefined);
     }
+
+    showTextDocument(uri: vscode.Uri, options?: vscode.TextDocumentShowOptions): Promise<vscode.TextEditor> {
+        if (this.showTextDocumentFailure !== undefined) {
+            return Promise.reject(this.showTextDocumentFailure);
+        }
+        const revealedRanges: vscode.Range[] = [];
+        const editor = {
+            selection: new vscode.Selection(0, 0, 0, 0),
+            revealRange: (range: vscode.Range) => revealedRanges.push(range),
+        } as unknown as vscode.TextEditor;
+        this.openedEditors.push({uri, options, editor, revealedRanges});
+        return Promise.resolve(editor);
+    }
 }
 
 class FakeWorkspace implements GraphicalViewWorkspace {
diff --git a/src/test/graphicalViewWebviewLifecycle.test.ts b/src/test/graphicalViewWebviewLifecycle.test.ts
new file mode 100644
index 0000000..f7185a9
--- /dev/null
+++ b/src/test/graphicalViewWebviewLifecycle.test.ts
@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ *
+ * See the AUTHORS file(s) distributed with this work for additional
+ * information regarding authorship.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import * as assert from 'node:assert/strict';
+import {join} from 'node:path';
+import * as vscode from 'vscode';
+import {createGraphicalViewPanelOptions, createShellHtml} from '../graphicalViewPanel';
+
+const FIRST_MARKER = 'gv-header-aaaaaaaaaaaaaaaa';
+const SECOND_MARKER = 'gv-header-bbbbbbbbbbbbbbbb';
+
+suite('GraphicalView real webview lifecycle', function () {
+    this.timeout(30_000);
+
+    test('rehydrates viewport state and keeps current/stale clicks bounded across context recreation', async function (this: Mocha.Context) {
+        this.timeout(30_000);
+        const extensionUri = vscode.Uri.file(join(__dirname, '..', '..'));
+        const panel = vscode.window.createWebviewPanel(
+            'turtle.graphicalViewLifecycleTest',
+            'Graphical View Lifecycle Test',
+            vscode.ViewColumn.One,
+            createGraphicalViewPanelOptions(extensionUri),
+        );
+        const messages: unknown[] = [];
+        const subscription = panel.webview.onDidReceiveMessage(message => messages.push(message));
+        const shell = createShellHtml(panel.webview, extensionUri, 'lifecycle-test-nonce', true);
+
+        try {
+            panel.webview.html = shell;
+            await waitFor(() => countMessages(messages, 'ready') >= 1, 'initial ready');
+            panel.reveal(vscode.ViewColumn.One, false);
+            await waitFor(() => panel.visible, 'initial webview visibility');
+            await new Promise(resolve => setTimeout(resolve, 100));
+
+            assert.equal(
+                await panel.webview.postMessage({type: 'render', version: 1, svg: graphperSvg(FIRST_MARKER)}),
+                true,
+                `initial render delivery failed; messages=${JSON.stringify(messages)}`,
+            );
+            await waitFor(
+                () => hasMessage(messages, 'rendered', 1) || hasMessage(messages, 'renderError', 1),
+                'initial secure render',
+                3_000,
+            ).catch(error => {
+                throw new Error(`${error instanceof Error ? error.message : String(error)}; messages=${JSON.stringify(messages)}`);
+            });
+            assert.equal(
+                hasMessage(messages, 'renderError', 1),
+                false,
+                `secure render failed: ${JSON.stringify(messages.filter(message => isRecord(message) && message.type === 'testRenderDiagnostic'))}`,
+            );
+
+            await panel.webview.postMessage({type: 'testSetViewport', zoom: 1.5, scrollLeft: 280, scrollTop: 190});
+            const firstState = await waitForMessage(messages, message => isViewportState(message, 1.5, 280, 190), 'viewport persistence');
+            assert.deepEqual(firstState.state, {schemaVersion: 1, zoom: 1.5, scrollLeft: 280, scrollTop: 190});
+
+            const hiddenDocument = await vscode.workspace.openTextDocument({
+                content: 'Hide graphical view lifecycle test',
+                language: 'plaintext',
+            });
+            await vscode.window.showTextDocument(hiddenDocument, {viewColumn: vscode.ViewColumn.One, preview: false});
+            await waitFor(() => !panel.visible, 'webview becoming hidden');
+            const renderedBeforeReveal = countMessages(messages, 'rendered');
+
+            panel.reveal(vscode.ViewColumn.One, false);
+            await waitFor(() => countMessages(messages, 'ready') >= 2, 'recreated webview ready');
+            assert.equal(countMessages(messages, 'rendered'), renderedBeforeReveal, 'reveal must not render by itself');
+            assert.equal(panel.webview.html, shell, 'stable shell must not be reassigned per result');
+
+            await panel.webview.postMessage({type: 'render', version: 1, svg: graphperSvg(FIRST_MARKER)});
+            await waitFor(() => countMessages(messages, 'rendered') >= 2, 'retained result rehydration');
+            const restoredState = await waitForMessage(
+                messages,
+                message => isViewportState(message, 1.5, 280, 190),
+                'restored viewport state',
+                1,
+            ).catch(error => {
+                throw new Error(`${error instanceof Error ? error.message : String(error)}; messages=${JSON.stringify(messages)}`);
+            });
+            assert.equal(restoredState.state.schemaVersion, 1);
+
+            await panel.webview.postMessage({type: 'testClickMarker', targetId: FIRST_MARKER});
+            await waitFor(() => navigationMessages(messages).length === 1, 'current marker click');
+            assert.deepEqual(navigationMessages(messages)[0], {type: 'navigate', version: 1, targetId: FIRST_MARKER});
+
+            await panel.webview.postMessage({type: 'render', version: 2, svg: graphperSvg(SECOND_MARKER)});
+            await waitFor(() => hasMessage(messages, 'rendered', 2), 'replacement render');
+            await panel.webview.postMessage({type: 'testClickMarker', targetId: FIRST_MARKER});
+            await new Promise(resolve => setTimeout(resolve, 200));
+            assert.equal(navigationMessages(messages).length, 1, 'stale marker must be inert after replacement');
+
+            await panel.webview.postMessage({type: 'testClickMarker', targetId: SECOND_MARKER});
+            await waitFor(() => navigationMessages(messages).length === 2, 'replacement marker click');
+            assert.deepEqual(navigationMessages(messages)[1], {type: 'navigate', version: 2, targetId: SECOND_MARKER});
+            assert.equal(
+                messages.some(message => isRecord(message) && message.type === 'renderError'),
+                false,
+            );
+        } finally {
+            subscription.dispose();
+            panel.dispose();
+        }
+    });
+});
+
+function graphperSvg(marker: string): string {
+    return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" height="1600pt" width="2200pt" viewBox="0 0 2200 1600">
+<style>@font-face { font-family: Roboto Condensed; }</style>
+<g id="graph_root" class="graph" transform="scale(1 1) rotate(0)">
+<g id="${marker}" class="node">
+<polygon id="${marker}_polygon" points="10,10 2190,10 2190,1590 10,1590" fill="#ffffff" stroke="#000000" stroke-width="1" cx="0" cy="0" rx="0" ry="0"></polygon>
+<text id="${marker}_text_0" x="1100" y="800" fill="#000000" font-family="Arial" font-size="12" text-anchor="middle">Aspect</text>
+<title>Aspect</title>
+</g>
+</g>
+</svg>`;
+}
+
+async function waitFor(probe: () => boolean, description: string, timeoutMs = 20_000): Promise<void> {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (probe()) {
+            return;
+        }
+        await new Promise(resolve => setTimeout(resolve, 50));
+    }
+    throw new Error(`Timed out waiting for ${description}`);
+}
+
+async function waitForMessage<T>(
+    messages: readonly unknown[],
+    predicate: (message: unknown) => message is T,
+    description: string,
+    skip = 0,
+): Promise<T> {
+    let result: T | undefined;
+    await waitFor(() => {
+        const matches = messages.filter(predicate);
+        result = matches.at(skip);
+        return result !== undefined;
+    }, description);
+    return result as T;
+}
+
+function countMessages(messages: readonly unknown[], type: string): number {
+    return messages.filter(message => isRecord(message) && message.type === type).length;
+}
+
+function hasMessage(messages: readonly unknown[], type: string, version: number): boolean {
+    return messages.some(message => isRecord(message) && message.type === type && message.version === version);
+}
+
+function navigationMessages(messages: readonly unknown[]): unknown[] {
+    return messages.filter(message => isRecord(message) && message.type === 'navigate');
+}
+
+function isTestState(
+    message: unknown,
+): message is {type: 'testState'; state: {schemaVersion: number; zoom: number; scrollLeft: number; scrollTop: number}} {
+    return (
+        isRecord(message) &&
+        message.type === 'testState' &&
+        isRecord(message.state) &&
+        typeof message.state.schemaVersion === 'number' &&
+        typeof message.state.zoom === 'number' &&
+        typeof message.state.scrollLeft === 'number' &&
+        typeof message.state.scrollTop === 'number'
+    );
+}
+
+function isViewportState(
+    message: unknown,
+    zoom: number,
+    scrollLeft: number,
+    scrollTop: number,
+): message is {type: 'testState'; state: {schemaVersion: number; zoom: number; scrollLeft: number; scrollTop: number}} {
+    return (
+        isTestState(message) &&
+        message.state.zoom === zoom &&
+        message.state.scrollLeft === scrollLeft &&
+        message.state.scrollTop === scrollTop
+    );
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null;
+}
diff --git a/src/webview/RobotoCondensed-NOTICE.txt b/src/webview/RobotoCondensed-NOTICE.txt
new file mode 100644
index 0000000..fb40b42
--- /dev/null
+++ b/src/webview/RobotoCondensed-NOTICE.txt
@@ -0,0 +1,19 @@
+RobotoCondensed-Regular
+=======================
+
+Copyright (C) Christian Robertson
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+The complete Apache License 2.0 text is included in this extension as
+DOMPurify-LICENSE-Apache-2.0.txt and is also available at the URL above.
diff --git a/src/webview/RobotoCondensed-Regular.ttf b/src/webview/RobotoCondensed-Regular.ttf
new file mode 100644
index 0000000000000000000000000000000000000000..65bf32a19f9fe3d42d7f48f3f35c56b62b83513a
GIT binary patch
literal 140396
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
Iq-}TpA2k&yXaE2J

literal 0
HcmV?d00001

diff --git a/src/webview/sanitizer-contract.js b/src/webview/sanitizer-contract.js
new file mode 100644
index 0000000..83fe29c
--- /dev/null
+++ b/src/webview/sanitizer-contract.js
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ *
+ * See the AUTHORS file(s) distributed with this work for additional
+ * information regarding authorship.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+(function () {
+    'use strict';
+
+    const ALLOWED_TAGS = Object.freeze(['svg', 'g', 'path', 'polygon', 'text', 'title']);
+    const TAG_ATTRIBUTES = Object.freeze({
+        svg: new Set(['xmlns', 'height', 'width', 'viewBox']),
+        g: new Set(['id', 'transform']),
+        path: new Set(['d', 'fill', 'stroke']),
+        polygon: new Set(['points', 'fill', 'stroke', 'stroke-width', 'cx', 'cy', 'rx', 'ry']),
+        text: new Set(['x', 'y', 'fill', 'font-family', 'font-size', 'text-anchor']),
+        title: new Set(),
+    });
+    const ALLOWED_ATTRIBUTES = Object.freeze(
+        Array.from(new Set(Object.values(TAG_ATTRIBUTES).flatMap(attributes => Array.from(attributes)))),
+    );
+    const MARKER_PATTERN = /^gv-header-[a-z0-9]{16,32}$/;
+    const COLOR_PATTERN = /^(?:none|#[0-9a-f]{6})$/i;
+    const FONT_FAMILIES = new Set(['Arial', 'Roboto Condensed']);
+    const NUMBER = '[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?';
+    const NUMBER_PATTERN = new RegExp(`^${NUMBER}$`);
+    const LENGTH_PATTERN = new RegExp(`^${NUMBER}(?:pt)?$`);
+    const VIEW_BOX_PATTERN = new RegExp(`^${NUMBER}\\s+${NUMBER}\\s+${NUMBER}\\s+${NUMBER}$`);
+    const TRANSFORM_PATTERN = new RegExp(`^scale\\(${NUMBER}\\s+${NUMBER}\\)\\s+rotate\\(${NUMBER}\\)$`);
+    const PATH_PATTERN = /^[MmLlHhVvCcSsQqTtAaZzEe0-9.,+\-\s]+$/;
+    const POINTS_PATTERN = /^[0-9eE.,+\-\s]+$/;
+    const FORBIDDEN_SCHEME_PATTERN = /^(?:https?|file|command|javascript|data):/i;
+
+    const DOMPURIFY_CONFIG = Object.freeze({
+        ALLOWED_TAGS,
+        ALLOWED_ATTR: ALLOWED_ATTRIBUTES,
+        ALLOW_ARIA_ATTR: false,
+        ALLOW_DATA_ATTR: false,
+        ALLOW_UNKNOWN_PROTOCOLS: false,
+        FORBID_TAGS: ['a', 'style', 'script', 'foreignObject', 'defs', 'clipPath', 'tspan', 'image', 'use'],
+        FORBID_ATTR: ['href', 'xlink:href', 'style'],
+        RETURN_DOM_FRAGMENT: true,
+        SANITIZE_DOM: true,
+        SANITIZE_NAMED_PROPS: false,
+    });
+
+    function sanitizeSvg(svgText) {
+        if (typeof svgText !== 'string') {
+            throw new TypeError('SVG payload must be a string');
+        }
+
+        const fragment = DOMPurify.sanitize(svgText, DOMPURIFY_CONFIG);
+        validatePurifierRemovals(DOMPurify.removed);
+        const roots = Array.from(fragment.children);
+        if (roots.length !== 1 || roots[0].localName !== 'svg') {
+            throw new Error('Sanitized payload must contain exactly one SVG root');
+        }
+
+        const svg = roots[0];
+        const markerIds = new Set();
+        for (const element of [svg, ...svg.querySelectorAll('*')]) {
+            const permittedAttributes = TAG_ATTRIBUTES[element.localName];
+            if (!permittedAttributes) {
+                throw new Error('Sanitized payload contains an unsupported SVG element');
+            }
+
+            if (element.hasAttribute('id')) {
+                const id = element.getAttribute('id');
+                if (element.localName !== 'g' || !MARKER_PATTERN.test(id)) {
+                    element.removeAttribute('id');
+                } else if (markerIds.has(id)) {
+                    throw new Error('Sanitized payload contains a duplicate navigation marker');
+                } else {
+                    markerIds.add(id);
+                }
+            }
+
+            for (const attribute of Array.from(element.attributes)) {
+                if (!permittedAttributes.has(attribute.name)) {
+                    throw new Error('Sanitized payload contains an attribute on an unsupported element');
+                }
+            }
+
+            for (const attribute of Array.from(element.attributes)) {
+                const value = attribute.value.trim();
+                if (attribute.name !== 'xmlns' && (/url\s*\(/i.test(value) || FORBIDDEN_SCHEME_PATTERN.test(value))) {
+                    throw new Error('Sanitized payload contains a forbidden resource value');
+                }
+            }
+
+            validateOptionalValue(element, 'fill', COLOR_PATTERN);
+            validateOptionalValue(element, 'stroke', COLOR_PATTERN);
+            validateOptionalSetValue(element, 'font-family', FONT_FAMILIES);
+            validateOptionalExactValue(element, 'xmlns', 'http://www.w3.org/2000/svg');
+            validateOptionalExactValue(element, 'text-anchor', 'middle');
+            validateOptionalValue(element, 'height', LENGTH_PATTERN);
+            validateOptionalValue(element, 'width', LENGTH_PATTERN);
+            validateOptionalValue(element, 'viewBox', VIEW_BOX_PATTERN);
+            validateOptionalValue(element, 'transform', TRANSFORM_PATTERN);
+            validateOptionalValue(element, 'd', PATH_PATTERN);
+            validateOptionalValue(element, 'points', POINTS_PATTERN);
+            for (const name of ['cx', 'cy', 'rx', 'ry', 'stroke-width', 'font-size', 'x', 'y']) {
+                validateOptionalValue(element, name, NUMBER_PATTERN);
+            }
+        }
+
+        return {fragment, svg, markerIds: Object.freeze(Array.from(markerIds))};
+    }
+
+    function validatePurifierRemovals(removals) {
+        for (const removal of removals) {
+            if (removal.element?.localName === 'style' || removal.element?.localName === 'body') {
+                continue;
+            }
+            const attributeName = removal.attribute?.name;
+            if (attributeName === 'class' || attributeName === 'xmlns:xlink') {
+                continue;
+            }
+            const constructKind = removal.element ? 'element' : 'attribute';
+            const constructName = boundedConstructName(removal.element?.localName ?? attributeName);
+            throw new Error(`DOMPurify removed an unsupported SVG ${constructKind}: ${constructName}`);
+        }
+    }
+
+    function boundedConstructName(value) {
+        return typeof value === 'string' && /^[a-z0-9:_-]{1,40}$/i.test(value) ? value : 'unknown';
+    }
+
+    function validateOptionalValue(element, attributeName, pattern) {
+        if (element.hasAttribute(attributeName) && !pattern.test(element.getAttribute(attributeName).trim())) {
+            throw new Error('Sanitized payload contains an invalid SVG attribute value');
+        }
+    }
+
+    function validateOptionalSetValue(element, attributeName, values) {
+        if (element.hasAttribute(attributeName) && !values.has(element.getAttribute(attributeName))) {
+            throw new Error('Sanitized payload contains an unsupported SVG attribute value');
+        }
+    }
+
+    function validateOptionalExactValue(element, attributeName, expected) {
+        if (element.hasAttribute(attributeName) && element.getAttribute(attributeName) !== expected) {
+            throw new Error('Sanitized payload contains an unsupported SVG attribute value');
+        }
+    }
+
+    globalThis.SanitizerContract = Object.freeze({MARKER_PATTERN, sanitizeSvg});
+})();
diff --git a/src/webview/webview.css b/src/webview/webview.css
new file mode 100644
index 0000000..8eb9f69
--- /dev/null
+++ b/src/webview/webview.css
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ *
+ * See the AUTHORS file(s) distributed with this work for additional
+ * information regarding authorship.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+@font-face {
+    font-family: "Roboto Condensed";
+    src: url("./RobotoCondensed-Regular.ttf") format("truetype");
+    font-style: normal;
+    font-weight: 400;
+}
+
+html,
+body {
+    width: 100%;
+    height: 100%;
+    margin: 0;
+    padding: 0;
+    overflow: hidden;
+}
+
+body {
+    display: flex;
+    flex-direction: column;
+    color: var(--vscode-foreground);
+    background: var(--vscode-editor-background);
+    font-family: var(--vscode-font-family);
+}
+
+#toolbar {
+    display: flex;
+    flex: 0 0 auto;
+    align-items: center;
+    gap: 0.35rem;
+    padding: 0.45rem;
+    border-bottom: 1px solid var(--vscode-panel-border);
+}
+
+#toolbar button {
+    min-width: 2rem;
+    min-height: 1.75rem;
+    color: var(--vscode-button-foreground);
+    background: var(--vscode-button-background);
+    border: 1px solid transparent;
+    border-radius: 2px;
+}
+
+#toolbar button:hover {
+    background: var(--vscode-button-hoverBackground);
+}
+
+#toolbar button:focus-visible,
+#viewport:focus-visible {
+    outline: 1px solid var(--vscode-focusBorder);
+    outline-offset: 1px;
+}
+
+#status {
+    min-width: 12rem;
+    margin: 0 0 0 0.5rem;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+#zoom-value {
+    min-width: 3.5rem;
+    text-align: center;
+}
+
+#viewport {
+    box-sizing: border-box;
+    flex: 1 1 auto;
+    width: 100%;
+    min-height: 0;
+    overflow: auto;
+    padding: 0.75rem;
+}
+
+#diagram svg {
+    display: block;
+}
+
+#diagram svg g[id^="gv-header-"] {
+    cursor: pointer;
+    pointer-events: all;
+}
diff --git a/src/webview/webview.js b/src/webview/webview.js
new file mode 100644
index 0000000..89da37c
--- /dev/null
+++ b/src/webview/webview.js
@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ *
+ * See the AUTHORS file(s) distributed with this work for additional
+ * information regarding authorship.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+(function () {
+    'use strict';
+
+    const MIN_ZOOM = 0.25;
+    const MAX_ZOOM = 4;
+    const ZOOM_FACTOR = 1.2;
+    const vscode = acquireVsCodeApi();
+    const viewport = document.querySelector('#viewport');
+    const diagram = document.querySelector('#diagram');
+    const status = document.querySelector('#status');
+    const zoomValue = document.querySelector('#zoom-value');
+    const testMode = document.documentElement.dataset.testMode === 'true';
+    let currentVersion = null;
+    let currentSvg = null;
+    let baseWidth = 0;
+    let baseHeight = 0;
+    let restoreGeneration = 0;
+    let state = normalizeState(vscode.getState());
+
+    function normalizeState(candidate) {
+        if (!candidate || candidate.schemaVersion !== 1) {
+            return {schemaVersion: 1, zoom: 1, scrollLeft: 0, scrollTop: 0};
+        }
+        return {
+            schemaVersion: 1,
+            zoom: Number.isFinite(candidate.zoom) ? clamp(candidate.zoom, MIN_ZOOM, MAX_ZOOM) : 1,
+            scrollLeft: Number.isFinite(candidate.scrollLeft) ? Math.max(0, candidate.scrollLeft) : 0,
+            scrollTop: Number.isFinite(candidate.scrollTop) ? Math.max(0, candidate.scrollTop) : 0,
+        };
+    }
+
+    function clamp(value, minimum, maximum) {
+        return Math.min(maximum, Math.max(minimum, value));
+    }
+
+    function persistState() {
+        state = {
+            schemaVersion: 1,
+            zoom: state.zoom,
+            scrollLeft: Math.max(0, viewport.scrollLeft),
+            scrollTop: Math.max(0, viewport.scrollTop),
+        };
+        vscode.setState(state);
+        updateZoomLabel();
+    }
+
+    function updateZoomLabel() {
+        zoomValue.textContent = `${Math.round(state.zoom * 100)}%`;
+    }
+
+    function captureViewport() {
+        state = {...state, scrollLeft: Math.max(0, viewport.scrollLeft), scrollTop: Math.max(0, viewport.scrollTop)};
+    }
+
+    function dimensions(svg) {
+        const width = Number.parseFloat(svg.getAttribute('width'));
+        const height = Number.parseFloat(svg.getAttribute('height'));
+        const viewBox = svg.viewBox?.baseVal;
+        const resolvedWidth = Number.isFinite(width) && width > 0 ? width : viewBox?.width;
+        const resolvedHeight = Number.isFinite(height) && height > 0 ? height : viewBox?.height;
+        if (!Number.isFinite(resolvedWidth) || resolvedWidth <= 0 || !Number.isFinite(resolvedHeight) || resolvedHeight <= 0) {
+            throw new Error('SVG dimensions are unavailable');
+        }
+        return {width: resolvedWidth, height: resolvedHeight};
+    }
+
+    function applyZoom() {
+        if (!currentSvg) {
+            updateZoomLabel();
+            return;
+        }
+        currentSvg.setAttribute('width', String(baseWidth * state.zoom));
+        currentSvg.setAttribute('height', String(baseHeight * state.zoom));
+        updateZoomLabel();
+    }
+
+    function restoreViewport(version, notifyRendered) {
+        const generation = ++restoreGeneration;
+        afterLayout(() => {
+            if (generation !== restoreGeneration || version !== currentVersion) {
+                return;
+            }
+            const maximumLeft = Math.max(0, viewport.scrollWidth - viewport.clientWidth);
+            const maximumTop = Math.max(0, viewport.scrollHeight - viewport.clientHeight);
+            viewport.scrollLeft = Math.min(state.scrollLeft, maximumLeft);
+            viewport.scrollTop = Math.min(state.scrollTop, maximumTop);
+            persistState();
+            if (notifyRendered) {
+                vscode.postMessage({type: 'rendered', version});
+            }
+            if (testMode) {
+                vscode.postMessage({type: 'testState', state});
+            }
+        });
+    }
+
+    function afterLayout(callback) {
+        let completed = false;
+        const complete = () => {
+            if (!completed) {
+                completed = true;
+                callback();
+            }
+        };
+        requestAnimationFrame(() => requestAnimationFrame(complete));
+        setTimeout(complete, 100);
+    }
+
+    function setZoom(zoom) {
+        captureViewport();
+        state = {...state, zoom: clamp(zoom, MIN_ZOOM, MAX_ZOOM)};
+        applyZoom();
+        restoreViewport(currentVersion, false);
+    }
+
+    function fitDiagram() {
+        if (!currentSvg || baseWidth <= 0 || baseHeight <= 0) {
+            return;
+        }
+        const availableWidth = Math.max(1, viewport.clientWidth - 24);
+        const availableHeight = Math.max(1, viewport.clientHeight - 24);
+        setZoom(Math.min(availableWidth / baseWidth, availableHeight / baseHeight));
+        state = {...state, scrollLeft: 0, scrollTop: 0};
+        restoreViewport(currentVersion, false);
+    }
+
+    function isExactMessage(message, keys) {
+        if (!message || typeof message !== 'object' || Array.isArray(message)) {
+            return false;
+        }
+        const actualKeys = Object.keys(message).sort();
+        return actualKeys.length === keys.length && actualKeys.every((key, index) => key === keys[index]);
+    }
+
+    function render(message) {
+        if (
+            !isExactMessage(message, ['svg', 'type', 'version']) ||
+            message.type !== 'render' ||
+            !Number.isInteger(message.version) ||
+            message.version < 1 ||
+            typeof message.svg !== 'string'
+        ) {
+            return;
+        }
+
+        try {
+            if (currentSvg) {
+                captureViewport();
+            }
+            const sanitized = SanitizerContract.sanitizeSvg(message.svg);
+            const size = dimensions(sanitized.svg);
+            diagram.replaceChildren(sanitized.fragment);
+            currentSvg = sanitized.svg;
+            currentVersion = message.version;
+            baseWidth = size.width;
+            baseHeight = size.height;
+            applyZoom();
+            restoreViewport(currentVersion, true);
+        } catch (error) {
+            status.textContent = 'The new diagram could not be displayed safely. The last valid diagram is retained.';
+            vscode.postMessage({type: 'renderError', version: message.version, reason: 'sanitizationFailed'});
+            if (testMode) {
+                vscode.postMessage({
+                    type: 'testRenderDiagnostic',
+                    message: error instanceof Error ? error.message : 'Unknown render failure',
+                });
+            }
+        }
+    }
+
+    viewport.addEventListener('scroll', persistState, {passive: true});
+    diagram.addEventListener('click', event => {
+        const group = event.target instanceof Element ? event.target.closest('g[id^="gv-header-"]') : null;
+        if (!group || !diagram.contains(group) || !SanitizerContract.MARKER_PATTERN.test(group.id) || !Number.isInteger(currentVersion)) {
+            return;
+        }
+        vscode.postMessage({type: 'navigate', version: currentVersion, targetId: group.id});
+    });
+
+    document.querySelector('#refresh').addEventListener('click', () => vscode.postMessage({type: 'refresh'}));
+    document.querySelector('#zoom-in').addEventListener('click', () => setZoom(state.zoom * ZOOM_FACTOR));
+    document.querySelector('#zoom-out').addEventListener('click', () => setZoom(state.zoom / ZOOM_FACTOR));
+    document.querySelector('#zoom-reset').addEventListener('click', () => setZoom(1));
+    document.querySelector('#zoom-fit').addEventListener('click', fitDiagram);
+
+    window.addEventListener('message', event => {
+        const message = event.data;
+        if (message?.type === 'render') {
+            render(message);
+            return;
+        }
+        if (
+            isExactMessage(message, ['status', 'type']) &&
+            message.type === 'status' &&
+            message.status &&
+            typeof message.status.message === 'string'
+        ) {
+            status.textContent = message.status.message;
+            return;
+        }
+        if (testMode && isExactMessage(message, ['scrollLeft', 'scrollTop', 'type', 'zoom']) && message.type === 'testSetViewport') {
+            state = normalizeState({schemaVersion: 1, zoom: message.zoom, scrollLeft: message.scrollLeft, scrollTop: message.scrollTop});
+            applyZoom();
+            restoreViewport(currentVersion, false);
+            return;
+        }
+        if (testMode && isExactMessage(message, ['targetId', 'type']) && message.type === 'testClickMarker') {
+            const marker = diagram.querySelector(`g[id="${CSS.escape(message.targetId)}"]`);
+            marker?.dispatchEvent(new MouseEvent('click', {bubbles: true}));
+        }
+    });
+
+    updateZoomLabel();
+    vscode.setState(state);
+    vscode.postMessage({type: 'ready'});
+})();

From b406d54de65ca963f7b9eff992392b14ab156729 Mon Sep 17 00:00:00 2001
From: e-filchenko-bosh <FVI2FE@bosch.com>
Date: Thu, 27 Aug 2026 19:29:55 +0300
Subject: [PATCH 3/7] Add support for attribute navigation in graphical view

---
 src/graphicalView.ts                          |  70 +++++--
 src/graphicalViewProtocol.ts                  |  93 +++++++--
 src/languageClient.ts                         |  14 ++
 src/test/graphicalViewController.test.ts      | 184 +++++++++++++++++-
 src/test/graphicalViewTestHarness.ts          |  22 ++-
 .../graphicalViewWebviewLifecycle.test.ts     |  36 +++-
 src/test/languageClientGraphicalView.test.ts  |  10 +
 src/webview/sanitizer-contract.js             |   2 +-
 src/webview/webview.css                       |  14 +-
 src/webview/webview.js                        |  40 +++-
 10 files changed, 451 insertions(+), 34 deletions(-)

diff --git a/src/graphicalView.ts b/src/graphicalView.ts
index 5c4c09e..e12d454 100644
--- a/src/graphicalView.ts
+++ b/src/graphicalView.ts
@@ -38,6 +38,7 @@ export interface GraphicalViewAcceptedResult {
     readonly targets: readonly Readonly<GraphicalViewTarget>[];
     readonly warnings: readonly GraphicalViewRenderWarning[];
     readonly targetById: ReadonlyMap<string, Readonly<GraphicalViewTarget>>;
+    readonly attributeRowsAvailable: boolean;
 }
 
 export type GraphicalViewDelivery =
@@ -354,13 +355,23 @@ export class GraphicalViewController implements vscode.Disposable {
         this.setStatus(state, Object.freeze({kind: 'loading', message: `Rendering graphical view (${trigger})...`}));
 
         try {
-            const result = await client.renderGraphicalView({uri: sourceUri}, cancellation.token);
+            let attributeRowsAvailable = true;
+            let result: GraphicalViewRenderResult;
+            try {
+                result = await client.renderGraphicalView({uri: sourceUri, includeAttributeRows: true}, cancellation.token);
+            } catch (error) {
+                if (!isInvalidParams(error) || !this.isCurrentRequest(state, sourceUri, sequence, cancellation)) {
+                    throw error;
+                }
+                attributeRowsAvailable = false;
+                result = await client.renderGraphicalView({uri: sourceUri}, cancellation.token);
+            }
             if (!this.isCurrentRequest(state, sourceUri, sequence, cancellation)) {
                 return;
             }
             state.cancellation = undefined;
             cancellation.dispose();
-            this.handleRenderResult(state, result, sequence);
+            this.handleRenderResult(state, result, sequence, attributeRowsAvailable);
         } catch (error) {
             if (!this.isCurrentRequest(state, sourceUri, sequence, cancellation)) {
                 return;
@@ -371,7 +382,12 @@ export class GraphicalViewController implements vscode.Disposable {
         }
     }
 
-    private handleRenderResult(state: PanelState, result: unknown, requestSequence: number): void {
+    private handleRenderResult(
+        state: PanelState,
+        result: unknown,
+        requestSequence: number,
+        attributeRowsAvailable: boolean,
+    ): void {
         if (!isGraphicalViewRenderResult(result)) {
             this.setStale(state, 'invalidResponse', 'The language server returned an invalid graphical-view response.');
             return;
@@ -382,12 +398,17 @@ export class GraphicalViewController implements vscode.Disposable {
             return;
         }
 
+        if (!attributeRowsAvailable && result.targets.some(target => target.kind !== 'elementHeader')) {
+            this.setStale(state, 'invalidResponse', 'The legacy language server returned an invalid graphical-view response.');
+            return;
+        }
+
         if (result.svg === undefined || result.svg === null) {
             this.handleWarningResult(state, result.warnings);
             return;
         }
 
-        const accepted = createAcceptedResult(result, result.svg, ++state.nextDisplayVersion);
+        const accepted = createAcceptedResult(result, result.svg, ++state.nextDisplayVersion, attributeRowsAvailable);
         state.pendingDelivery = Object.freeze({accepted, requestSequence});
         state.panel.deliver(Object.freeze({type: 'render', version: accepted.version, svg: accepted.svg}));
     }
@@ -399,7 +420,12 @@ export class GraphicalViewController implements vscode.Disposable {
             state.lastSuccess = pending.accepted;
             state.pendingDelivery = undefined;
             if (state.sequence === pending.requestSequence) {
-                this.setStatus(state, Object.freeze({kind: 'ready', message: 'Graphical view is up to date.'}));
+                this.setStatus(state, Object.freeze({
+                    kind: 'ready',
+                    message: pending.accepted.attributeRowsAvailable
+                        ? 'Graphical view is up to date.'
+                        : 'The server supports header navigation only; attribute-row navigation is unavailable.',
+                }));
             }
             return;
         }
@@ -428,7 +454,7 @@ export class GraphicalViewController implements vscode.Disposable {
     ): Promise<void> {
         const accepted = state.lastSuccess;
         const target = accepted?.version === message.version ? accepted.targetById.get(message.targetId) : undefined;
-        if (!accepted || !target || target.kind !== 'elementHeader' || !GRAPHICAL_VIEW_MARKER_PATTERN.test(message.targetId)) {
+        if (!accepted || !target || !GRAPHICAL_VIEW_MARKER_PATTERN.test(message.targetId)) {
             return;
         }
 
@@ -442,10 +468,21 @@ export class GraphicalViewController implements vscode.Disposable {
         const cancellation = this.createCancellationSource();
         state.navigationCancellation = cancellation;
         try {
-            const response = await client.resolveGraphicalViewTarget(
-                {sourceUri: state.sourceUri, elementUrn: target.elementUrn},
-                cancellation.token,
-            );
+            const response = target.kind === 'elementHeader'
+                ? await client.resolveGraphicalViewTarget(
+                    {sourceUri: state.sourceUri, elementUrn: target.elementUrn},
+                    cancellation.token,
+                )
+                : await client.resolveGraphicalViewAttributeTarget(
+                    {
+                        sourceUri: state.sourceUri,
+                        ownerUrn: target.ownerUrn,
+                        predicateUrn: target.predicateUrn,
+                        selection: target.selection,
+                        ...(target.language === undefined ? {} : {language: target.language}),
+                    },
+                    cancellation.token,
+                );
             if (!this.isCurrentNavigation(state, accepted, target, cancellation)) {
                 return;
             }
@@ -643,11 +680,16 @@ export class GraphicalViewController implements vscode.Disposable {
     }
 }
 
-function createAcceptedResult(result: GraphicalViewRenderResult, svg: string, version: number): GraphicalViewAcceptedResult {
+function createAcceptedResult(
+    result: GraphicalViewRenderResult,
+    svg: string,
+    version: number,
+    attributeRowsAvailable: boolean,
+): GraphicalViewAcceptedResult {
     const targets = Object.freeze(result.targets.map(target => Object.freeze({...target})));
     const warnings = Object.freeze([...result.warnings]);
     const targetById = new ImmutableTargetMap(targets.map(target => [target.id, target]));
-    return Object.freeze({version, uri: result.uri, svg, targets, warnings, targetById});
+    return Object.freeze({version, uri: result.uri, svg, targets, warnings, targetById, attributeRowsAvailable});
 }
 
 class ImmutableTargetMap<K, V> implements ReadonlyMap<K, V> {
@@ -863,6 +905,10 @@ function isMethodNotFound(error: unknown): boolean {
     return error instanceof Error && /method\s+not\s+found/i.test(error.message);
 }
 
+function isInvalidParams(error: unknown): boolean {
+    return isRecord(error) && error.code === -32602;
+}
+
 function classifyFailure(message: string): string {
     if (/timeout|timed out/i.test(message)) {
         return 'timeout';
diff --git a/src/graphicalViewProtocol.ts b/src/graphicalViewProtocol.ts
index a86a838..168f06c 100644
--- a/src/graphicalViewProtocol.ts
+++ b/src/graphicalViewProtocol.ts
@@ -15,7 +15,10 @@ import type * as vscode from 'vscode';
 
 export const GRAPHICAL_VIEW_RENDER_REQUEST = 'turtle/graphicalView/render';
 export const GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST = 'turtle/graphicalView/resolveTarget';
-export const GRAPHICAL_VIEW_MARKER_PATTERN = /^gv-header-[a-z0-9]{16,32}$/;
+export const GRAPHICAL_VIEW_RESOLVE_ATTRIBUTE_TARGET_REQUEST = 'turtle/graphicalView/resolveAttributeTarget';
+export const GRAPHICAL_VIEW_HEADER_MARKER_PATTERN = /^gv-header-[a-z0-9]{16,32}$/;
+export const GRAPHICAL_VIEW_ATTRIBUTE_MARKER_PATTERN = /^gv-attribute-[a-z0-9]{16,32}$/;
+export const GRAPHICAL_VIEW_MARKER_PATTERN = /^gv-(?:header|attribute)-[a-z0-9]{16,32}$/;
 
 export type GraphicalViewRenderWarning =
     | 'unsupportedUri'
@@ -28,14 +31,26 @@ export type GraphicalViewResolveTargetWarning = 'notFound' | 'ambiguous' | 'unsu
 
 export interface GraphicalViewRenderParams {
     uri: string;
+    includeAttributeRows?: boolean;
 }
 
-export interface GraphicalViewTarget {
+export interface GraphicalViewElementHeaderTarget {
     id: string;
     kind: 'elementHeader';
     elementUrn: string;
 }
 
+export interface GraphicalViewAttributeTarget {
+    id: string;
+    kind: 'attributeRow';
+    ownerUrn: string;
+    predicateUrn: string;
+    selection: 'singleOccurrence' | 'predicateStart';
+    language?: string;
+}
+
+export type GraphicalViewTarget = GraphicalViewElementHeaderTarget | GraphicalViewAttributeTarget;
+
 export interface GraphicalViewRenderResult {
     uri: string;
     svg?: string | null;
@@ -66,6 +81,16 @@ export interface GraphicalViewResolveTargetResult {
     warning?: GraphicalViewResolveTargetWarning | null;
 }
 
+export interface GraphicalViewResolveAttributeTargetParams {
+    sourceUri: string;
+    ownerUrn: string;
+    predicateUrn: string;
+    selection: 'singleOccurrence' | 'predicateStart';
+    language?: string;
+}
+
+export type GraphicalViewResolveAttributeTargetResult = GraphicalViewResolveTargetResult;
+
 export interface GraphicalViewRequestClient {
     isGraphicalViewAvailable(): boolean;
     onDidChangeGraphicalViewAvailability(listener: (available: boolean) => void): vscode.Disposable;
@@ -74,6 +99,10 @@ export interface GraphicalViewRequestClient {
         params: GraphicalViewResolveTargetParams,
         token?: vscode.CancellationToken,
     ): Thenable<GraphicalViewResolveTargetResult>;
+    resolveGraphicalViewAttributeTarget(
+        params: GraphicalViewResolveAttributeTargetParams,
+        token?: vscode.CancellationToken,
+    ): Thenable<GraphicalViewResolveAttributeTargetResult>;
 }
 
 const RENDER_WARNINGS: ReadonlySet<string> = new Set([
@@ -84,13 +113,20 @@ const RENDER_WARNINGS: ReadonlySet<string> = new Set([
     'temporarilyUnresolvable',
 ]);
 const ASPECT_MODEL_URN_PATTERN = /^urn:samm:[^\s#]+#[^\s#]+$/;
-const SVG_MARKER_PATTERN = /\bid\s*=\s*(["'])(gv-header-[a-z0-9]{16,32})\1/g;
+const LANGUAGE_PATTERN = /^[a-z]{2,8}(?:-[a-z0-9]{1,8})*$/;
+const SVG_ID_PATTERN = /\bid\s*=\s*(["'])([^"']+)\1/g;
+const GRAPHPER_DESCENDANT_PATTERN = /^gv-(?:header|attribute)-[a-z0-9]{16,32}_(?:polygon|text_0)$/;
 
 export function isGraphicalViewRenderResult(value: unknown): value is GraphicalViewRenderResult {
     if (!isRecord(value) || typeof value.uri !== 'string' || !Array.isArray(value.targets) || !Array.isArray(value.warnings)) {
         return false;
     }
 
+    const allowedResultKeys = value.svg === undefined ? ['targets', 'uri', 'warnings'] : ['svg', 'targets', 'uri', 'warnings'];
+    if (!hasExactKeys(value, allowedResultKeys)) {
+        return false;
+    }
+
     if (value.svg !== undefined && value.svg !== null && typeof value.svg !== 'string') {
         return false;
     }
@@ -111,14 +147,32 @@ export function isGraphicalViewRenderResult(value: unknown): value is GraphicalV
 }
 
 function isGraphicalViewTarget(value: unknown): value is GraphicalViewTarget {
-    return (
-        isRecord(value) &&
-        typeof value.id === 'string' &&
-        GRAPHICAL_VIEW_MARKER_PATTERN.test(value.id) &&
-        value.kind === 'elementHeader' &&
-        typeof value.elementUrn === 'string' &&
-        ASPECT_MODEL_URN_PATTERN.test(value.elementUrn)
-    );
+    if (!isRecord(value) || typeof value.id !== 'string') {
+        return false;
+    }
+    if (value.kind === 'elementHeader') {
+        return hasExactKeys(value, ['elementUrn', 'id', 'kind'])
+            && GRAPHICAL_VIEW_HEADER_MARKER_PATTERN.test(value.id)
+            && typeof value.elementUrn === 'string'
+            && ASPECT_MODEL_URN_PATTERN.test(value.elementUrn);
+    }
+    if (value.kind !== 'attributeRow') {
+        return false;
+    }
+    const expectedKeys = value.language === undefined
+        ? ['id', 'kind', 'ownerUrn', 'predicateUrn', 'selection']
+        : ['id', 'kind', 'language', 'ownerUrn', 'predicateUrn', 'selection'];
+    return hasExactKeys(value, expectedKeys)
+        && GRAPHICAL_VIEW_ATTRIBUTE_MARKER_PATTERN.test(value.id)
+        && typeof value.ownerUrn === 'string'
+        && ASPECT_MODEL_URN_PATTERN.test(value.ownerUrn)
+        && typeof value.predicateUrn === 'string'
+        && ASPECT_MODEL_URN_PATTERN.test(value.predicateUrn)
+        && (value.selection === 'singleOccurrence' || value.selection === 'predicateStart')
+        && (value.language === undefined
+            || (value.selection === 'singleOccurrence'
+                && typeof value.language === 'string'
+                && LANGUAGE_PATTERN.test(value.language)));
 }
 
 function hasConsistentSidecar(svg: string, targets: GraphicalViewTarget[]): boolean {
@@ -131,8 +185,17 @@ function hasConsistentSidecar(svg: string, targets: GraphicalViewTarget[]): bool
     }
 
     const svgIds = new Set<string>();
-    for (const match of svg.matchAll(SVG_MARKER_PATTERN)) {
+    for (const match of svg.matchAll(SVG_ID_PATTERN)) {
         const id = match[2];
+        if (GRAPHPER_DESCENDANT_PATTERN.test(id)) {
+            continue;
+        }
+        if (!id.startsWith('gv-header-') && !id.startsWith('gv-attribute-')) {
+            continue;
+        }
+        if (!GRAPHICAL_VIEW_MARKER_PATTERN.test(id)) {
+            return false;
+        }
         if (svgIds.has(id)) {
             return false;
         }
@@ -145,3 +208,9 @@ function hasConsistentSidecar(svg: string, targets: GraphicalViewTarget[]): bool
 function isRecord(value: unknown): value is Record<string, unknown> {
     return typeof value === 'object' && value !== null;
 }
+
+function hasExactKeys(value: Record<string, unknown>, expectedKeys: readonly string[]): boolean {
+    const actualKeys = Object.keys(value).sort();
+    const expected = [...expectedKeys].sort();
+    return actualKeys.length === expected.length && actualKeys.every((key, index) => key === expected[index]);
+}
diff --git a/src/languageClient.ts b/src/languageClient.ts
index 2858351..2f6c2a1 100644
--- a/src/languageClient.ts
+++ b/src/languageClient.ts
@@ -18,10 +18,13 @@ import {LanguageClient, LanguageClientOptions, State, StateChangeEvent, StreamIn
 import type { RequestClient } from './aspectValidation';
 import {
     GRAPHICAL_VIEW_RENDER_REQUEST,
+    GRAPHICAL_VIEW_RESOLVE_ATTRIBUTE_TARGET_REQUEST,
     GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST,
     GraphicalViewRenderParams,
     GraphicalViewRenderResult,
     GraphicalViewRequestClient,
+    GraphicalViewResolveAttributeTargetParams,
+    GraphicalViewResolveAttributeTargetResult,
     GraphicalViewResolveTargetParams,
     GraphicalViewResolveTargetResult,
 } from './graphicalViewProtocol';
@@ -155,4 +158,15 @@ export class TurtleLanguageClient implements RequestClient, GraphicalViewRequest
         return this.sendRequest<GraphicalViewResolveTargetResult>(GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST, params, token);
     }
 
+    resolveGraphicalViewAttributeTarget(
+        params: GraphicalViewResolveAttributeTargetParams,
+        token?: vscode.CancellationToken,
+    ): Promise<GraphicalViewResolveAttributeTargetResult> {
+        return this.sendRequest<GraphicalViewResolveAttributeTargetResult>(
+            GRAPHICAL_VIEW_RESOLVE_ATTRIBUTE_TARGET_REQUEST,
+            params,
+            token,
+        );
+    }
+
 }
diff --git a/src/test/graphicalViewController.test.ts b/src/test/graphicalViewController.test.ts
index 9e72414..670b15c 100644
--- a/src/test/graphicalViewController.test.ts
+++ b/src/test/graphicalViewController.test.ts
@@ -53,7 +53,7 @@ suite('GraphicalViewController', () => {
         harness.window.activeTextEditor = {document};
         await harness.commands.execute(OPEN_GRAPHICAL_VIEW_COMMAND);
         assert.equal(harness.panels.panels.length, 1);
-        assert.deepEqual(harness.client.requests[0].params, {uri: document.uri.toString()});
+        assert.deepEqual(harness.client.requests[0].params, {uri: document.uri.toString(), includeAttributeRows: true});
         assert.equal(harness.controller.getPanelState(document.uri.toString())?.sequence, 1);
 
         harness.client.requests[0].deferred.resolve(successfulResult(document));
@@ -221,6 +221,8 @@ suite('GraphicalViewController', () => {
             {...good, targets: [{...good.targets[0], kind: 'notHeader' as 'elementHeader'}]},
             {...good, targets: [{...good.targets[0], elementUrn: 'not-a-urn'}]},
             {...good, svg: '<svg></svg>'},
+            {...good, targets: [{...good.targets[0], extra: 'rejected'}] as never},
+            {...good, svg: `${good.svg}<g id="gv-attribute-BAD"></g>`},
         ];
 
         for (const invalid of invalidResults) {
@@ -230,7 +232,9 @@ suite('GraphicalViewController', () => {
             const state = harness.controller.getPanelState(document.uri.toString());
             assert.equal(state?.status.kind, 'stale');
             assert.equal(state?.lastSuccess?.svg, good.svg);
-            assert.equal(state?.lastSuccess?.targetById.get(good.targets[0].id)?.elementUrn, good.targets[0].elementUrn);
+            const retainedTarget = state?.lastSuccess?.targetById.get(good.targets[0].id);
+            assert.equal(retainedTarget?.kind, 'elementHeader');
+            assert.equal(retainedTarget?.kind === 'elementHeader' ? retainedTarget.elementUrn : undefined, good.targets[0].elementUrn);
         }
         harness.controller.dispose();
     });
@@ -395,6 +399,182 @@ suite('GraphicalViewController', () => {
         harness.controller.dispose();
     });
 
+    test('accepts an exact attribute sidecar and routes only its trusted semantic selector to the attribute resolver', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/attribute-navigation-source.ttl');
+        await harness.controller.openGraphicalView(document);
+        const id = 'gv-attribute-0123456789abcdef';
+        const result: GraphicalViewRenderResult = {
+            uri: document.uri.toString(),
+            svg: `<svg><g id="${id}"><polygon points="0,0 1,0 1,1"/><text x="0" y="0">description: row</text></g></svg>`,
+            targets: [{
+                id,
+                kind: 'attributeRow',
+                ownerUrn: 'urn:samm:example.graphical:1.0.0#Aspect',
+                predicateUrn: 'urn:samm:org.eclipse.esmf.samm:meta-model:2.2.0#description',
+                selection: 'singleOccurrence',
+                language: 'en',
+            }],
+            warnings: [],
+        };
+        harness.client.requests[0].deferred.resolve(result);
+        await flushPromises();
+        harness.client.resolveResult = {
+            location: {
+                uri: vscode.Uri.file('/tmp/attribute-navigation-target.ttl').toString(),
+                range: {start: {line: 7, character: 3}, end: {line: 7, character: 19}},
+            },
+        };
+
+        harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: id});
+        await flushPromises();
+        await flushPromises();
+
+        assert.equal(harness.client.resolveRequests.length, 0);
+        assert.deepEqual(harness.client.attributeResolveRequests[0].params, {
+            sourceUri: document.uri.toString(),
+            ownerUrn: 'urn:samm:example.graphical:1.0.0#Aspect',
+            predicateUrn: 'urn:samm:org.eclipse.esmf.samm:meta-model:2.2.0#description',
+            selection: 'singleOccurrence',
+            language: 'en',
+        });
+        assert.deepEqual(harness.window.openedEditors[0].editor.selection.start, new vscode.Position(7, 3));
+        harness.controller.dispose();
+    });
+
+    test('opens the same predicate statement from both physical rows of a wrapped aggregated see target', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/wrapped-see-source.ttl');
+        await harness.controller.openGraphicalView(document);
+        const ids = ['gv-attribute-1111111111111111', 'gv-attribute-2222222222222222'] as const;
+        const locator = {
+            kind: 'attributeRow' as const,
+            ownerUrn: 'urn:samm:example.graphical:1.0.0#Aspect',
+            predicateUrn: 'urn:samm:org.eclipse.esmf.samm:meta-model:2.2.0#see',
+            selection: 'predicateStart' as const,
+        };
+        const result: GraphicalViewRenderResult = {
+            uri: document.uri.toString(),
+            svg: `<svg><g id="${ids[0]}"><text>see: urn:irdi:0173:1:02:AAO677:002,</text></g>`
+                + `<g id="${ids[1]}"><text>urn:irdi:0173:1:02:AAO677:003</text></g></svg>`,
+            targets: ids.map(id => ({id, ...locator})),
+            warnings: [],
+        };
+        harness.client.requests[0].deferred.resolve(result);
+        await flushPromises();
+        const targetUri = vscode.Uri.file('/tmp/wrapped-see-source.ttl');
+        harness.client.resolveResult = {
+            location: {
+                uri: targetUri.toString(),
+                range: {start: {line: 8, character: 3}, end: {line: 8, character: 11}},
+            },
+        };
+
+        for (const id of ids) {
+            harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: id});
+            await flushPromises();
+            await flushPromises();
+        }
+
+        assert.equal(harness.client.attributeResolveRequests.length, 2);
+        const expectedParams = {
+            sourceUri: document.uri.toString(),
+            ownerUrn: locator.ownerUrn,
+            predicateUrn: locator.predicateUrn,
+            selection: locator.selection,
+        };
+        assert.deepEqual(harness.client.attributeResolveRequests.map(request => request.params), [expectedParams, expectedParams]);
+        assert.equal(harness.window.openedEditors.length, 2);
+        assert.ok(harness.window.openedEditors.every(opened => opened.uri.toString() === targetUri.toString()));
+        assert.ok(harness.window.openedEditors.every(
+            opened => opened.editor.selection.isEqual(new vscode.Selection(8, 3, 8, 11)),
+        ));
+        assert.equal(harness.window.warnings.length, 0);
+        harness.controller.dispose();
+    });
+
+    test('rejects attribute kind-prefix-shape-qualifier and sidecar inconsistencies atomically', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/attribute-validation.ttl');
+        await harness.controller.openGraphicalView(document);
+        const good = successfulResult(document);
+        harness.client.requests[0].deferred.resolve(good);
+        await flushPromises();
+        const base = {
+            id: 'gv-attribute-0123456789abcdef',
+            kind: 'attributeRow' as const,
+            ownerUrn: 'urn:samm:example.graphical:1.0.0#Aspect',
+            predicateUrn: 'urn:samm:org.eclipse.esmf.samm:meta-model:2.2.0#description',
+            selection: 'singleOccurrence' as const,
+            language: 'en',
+        };
+        const candidates: unknown[] = [
+            {...base, id: 'gv-header-0123456789abcdef'},
+            {...base, ownerUrn: 'Aspect'},
+            {...base, predicateUrn: 'description'},
+            {...base, selection: 'predicateStart', language: 'en'},
+            {...base, language: 'EN'},
+            {...base, sourceText: 'forbidden'},
+        ];
+        for (const target of candidates) {
+            harness.panels.panels[0].emitMessage({type: 'refresh'});
+            const id = (target as {id: string}).id;
+            harness.client.requests.at(-1)?.deferred.resolve({
+                uri: document.uri.toString(),
+                svg: `<svg><g id="${id}"><text>row</text></g></svg>`,
+                targets: [target] as never,
+                warnings: [],
+            });
+            await flushPromises();
+            assert.equal(harness.controller.getPanelState(document.uri.toString())?.lastSuccess?.svg, good.svg);
+        }
+        harness.controller.dispose();
+    });
+
+    test('falls back once to legacy header-only render on InvalidParams and exposes the compatibility limitation', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/legacy-server.ttl');
+        await harness.controller.openGraphicalView(document);
+        harness.client.requests[0].deferred.reject({code: -32602, message: 'Invalid params'});
+        await flushPromises();
+        assert.equal(harness.client.requests.length, 2);
+        assert.deepEqual(harness.client.requests[1].params, {uri: document.uri.toString()});
+        harness.client.requests[1].deferred.resolve(successfulResult(document));
+        await flushPromises();
+        const state = harness.controller.getPanelState(document.uri.toString());
+        assert.equal(state?.lastSuccess?.attributeRowsAvailable, false);
+        assert.match(state?.status.message ?? '', /header navigation only/i);
+        harness.controller.dispose();
+    });
+
+    test('rejects attribute targets returned by the legacy header-only fallback', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = track(harness, '/tmp/invalid-legacy-server.ttl');
+        await harness.controller.openGraphicalView(document);
+        harness.client.requests[0].deferred.reject({code: -32602, message: 'Invalid params'});
+        await flushPromises();
+        const attributeId = 'gv-attribute-0123456789abcdef';
+        harness.client.requests[1].deferred.resolve({
+            uri: document.uri.toString(),
+            svg: `<svg><g id="${attributeId}"><text>row</text></g></svg>`,
+            targets: [{
+                id: attributeId,
+                kind: 'attributeRow',
+                ownerUrn: 'urn:samm:example.graphical:1.0.0#Aspect',
+                predicateUrn: 'urn:samm:org.eclipse.esmf.samm:meta-model:2.2.0#description',
+                selection: 'singleOccurrence',
+                language: 'en',
+            }],
+            warnings: [],
+        });
+        await flushPromises();
+        const state = harness.controller.getPanelState(document.uri.toString());
+        assert.equal(state?.lastSuccess, undefined);
+        assert.equal(state?.status.kind, 'stale');
+        assert.equal(state?.status.reason, 'invalidResponse');
+        harness.controller.dispose();
+    });
+
     test('rejects malformed, stale, fake, extra-field, and non-sidecar navigation before LSP resolution', async () => {
         const harness = createGraphicalViewHarness();
         const document = track(harness, '/tmp/rejected-navigation.ttl');
diff --git a/src/test/graphicalViewTestHarness.ts b/src/test/graphicalViewTestHarness.ts
index e495994..29d5943 100644
--- a/src/test/graphicalViewTestHarness.ts
+++ b/src/test/graphicalViewTestHarness.ts
@@ -25,7 +25,10 @@ import {
 import {
     GraphicalViewRenderParams,
     GraphicalViewRenderResult,
+    GraphicalViewElementHeaderTarget,
     GraphicalViewRequestClient,
+    GraphicalViewResolveAttributeTargetParams,
+    GraphicalViewResolveAttributeTargetResult,
     GraphicalViewResolveTargetParams,
     GraphicalViewResolveTargetResult,
 } from '../graphicalViewProtocol';
@@ -42,9 +45,15 @@ export interface RecordedResolveRequest {
     readonly token: vscode.CancellationToken | undefined;
 }
 
+export interface RecordedAttributeResolveRequest {
+    readonly params: GraphicalViewResolveAttributeTargetParams;
+    readonly token: vscode.CancellationToken | undefined;
+}
+
 export class FakeGraphicalViewClient implements GraphicalViewRequestClient {
     readonly requests: RecordedRenderRequest[] = [];
     readonly resolveRequests: RecordedResolveRequest[] = [];
+    readonly attributeResolveRequests: RecordedAttributeResolveRequest[] = [];
     resolveResult: GraphicalViewResolveTargetResult = {location: null, warning: 'temporarilyUnresolvable'};
     resolveFailure: unknown | undefined;
     private readonly listeners = new Set<(available: boolean) => void>();
@@ -74,6 +83,14 @@ export class FakeGraphicalViewClient implements GraphicalViewRequestClient {
         return this.resolveFailure === undefined ? Promise.resolve(this.resolveResult) : Promise.reject(this.resolveFailure);
     }
 
+    resolveGraphicalViewAttributeTarget(
+        params: GraphicalViewResolveAttributeTargetParams,
+        token?: vscode.CancellationToken,
+    ): Promise<GraphicalViewResolveAttributeTargetResult> {
+        this.attributeResolveRequests.push({params, token});
+        return this.resolveFailure === undefined ? Promise.resolve(this.resolveResult) : Promise.reject(this.resolveFailure);
+    }
+
     setAvailable(available: boolean): void {
         this.available = available;
         for (const listener of [...this.listeners]) {
@@ -186,7 +203,10 @@ export function createGraphicalViewDocument(filePath: string, languageId = 'turt
     return {languageId, uri: vscode.Uri.file(filePath)};
 }
 
-export function successfulResult(document: GraphicalViewDocument, suffix = '0123456789abcdef'): GraphicalViewRenderResult {
+export function successfulResult(
+    document: GraphicalViewDocument,
+    suffix = '0123456789abcdef',
+): GraphicalViewRenderResult & {targets: [GraphicalViewElementHeaderTarget]} {
     const id = `gv-header-${suffix}`;
     return {
         uri: document.uri.toString(),
diff --git a/src/test/graphicalViewWebviewLifecycle.test.ts b/src/test/graphicalViewWebviewLifecycle.test.ts
index f7185a9..e46cd6b 100644
--- a/src/test/graphicalViewWebviewLifecycle.test.ts
+++ b/src/test/graphicalViewWebviewLifecycle.test.ts
@@ -17,7 +17,9 @@ import * as vscode from 'vscode';
 import {createGraphicalViewPanelOptions, createShellHtml} from '../graphicalViewPanel';
 
 const FIRST_MARKER = 'gv-header-aaaaaaaaaaaaaaaa';
-const SECOND_MARKER = 'gv-header-bbbbbbbbbbbbbbbb';
+const SECOND_MARKER = 'gv-attribute-bbbbbbbbbbbbbbbb';
+const WRAPPED_SEE_FIRST_MARKER = 'gv-attribute-cccccccccccccccc';
+const WRAPPED_SEE_CONTINUATION_MARKER = 'gv-attribute-dddddddddddddddd';
 
 suite('GraphicalView real webview lifecycle', function () {
     this.timeout(30_000);
@@ -102,6 +104,29 @@ suite('GraphicalView real webview lifecycle', function () {
             await panel.webview.postMessage({type: 'testClickMarker', targetId: SECOND_MARKER});
             await waitFor(() => navigationMessages(messages).length === 2, 'replacement marker click');
             assert.deepEqual(navigationMessages(messages)[1], {type: 'navigate', version: 2, targetId: SECOND_MARKER});
+            await panel.webview.postMessage({type: 'testKeyMarker', targetId: SECOND_MARKER, key: 'Enter'});
+            await waitFor(() => navigationMessages(messages).length === 3, 'attribute marker Enter activation');
+            await panel.webview.postMessage({type: 'testKeyMarker', targetId: SECOND_MARKER, key: ' '});
+            await waitFor(() => navigationMessages(messages).length === 4, 'attribute marker Space activation');
+            assert.deepEqual(navigationMessages(messages).slice(2), [
+                {type: 'navigate', version: 2, targetId: SECOND_MARKER},
+                {type: 'navigate', version: 2, targetId: SECOND_MARKER},
+            ]);
+
+            await panel.webview.postMessage({
+                type: 'render',
+                version: 3,
+                svg: wrappedSeeSvg(WRAPPED_SEE_FIRST_MARKER, WRAPPED_SEE_CONTINUATION_MARKER),
+            });
+            await waitFor(() => hasMessage(messages, 'rendered', 3), 'wrapped see render');
+            await panel.webview.postMessage({type: 'testClickMarker', targetId: WRAPPED_SEE_FIRST_MARKER});
+            await waitFor(() => navigationMessages(messages).length === 5, 'wrapped see first-row click');
+            await panel.webview.postMessage({type: 'testClickMarker', targetId: WRAPPED_SEE_CONTINUATION_MARKER});
+            await waitFor(() => navigationMessages(messages).length === 6, 'wrapped see continuation-row click');
+            assert.deepEqual(navigationMessages(messages).slice(4), [
+                {type: 'navigate', version: 3, targetId: WRAPPED_SEE_FIRST_MARKER},
+                {type: 'navigate', version: 3, targetId: WRAPPED_SEE_CONTINUATION_MARKER},
+            ]);
             assert.equal(
                 messages.some(message => isRecord(message) && message.type === 'renderError'),
                 false,
@@ -126,6 +151,15 @@ function graphperSvg(marker: string): string {
 </svg>`;
 }
 
+function wrappedSeeSvg(firstMarker: string, continuationMarker: string): string {
+    return `<svg xmlns="http://www.w3.org/2000/svg" height="1600pt" width="2200pt" viewBox="0 0 2200 1600">
+<g id="graph_root" class="graph" transform="scale(1 1) rotate(0)">
+<g id="${firstMarker}" class="node"><polygon points="10,10 2190,10 2190,700 10,700"></polygon><text x="20" y="300">see: urn:irdi:0173:1:02:AAO677:002,</text></g>
+<g id="${continuationMarker}" class="node"><polygon points="10,710 2190,710 2190,1590 10,1590"></polygon><text x="20" y="1000">urn:irdi:0173:1:02:AAO677:003</text></g>
+</g>
+</svg>`;
+}
+
 async function waitFor(probe: () => boolean, description: string, timeoutMs = 20_000): Promise<void> {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
diff --git a/src/test/languageClientGraphicalView.test.ts b/src/test/languageClientGraphicalView.test.ts
index e3691ac..d9b042c 100644
--- a/src/test/languageClientGraphicalView.test.ts
+++ b/src/test/languageClientGraphicalView.test.ts
@@ -17,6 +17,7 @@ import {Trace} from 'vscode-jsonrpc';
 import {State, StateChangeEvent} from 'vscode-languageclient/node';
 import {
     GRAPHICAL_VIEW_RENDER_REQUEST,
+    GRAPHICAL_VIEW_RESOLVE_ATTRIBUTE_TARGET_REQUEST,
     GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST,
     GraphicalViewRenderResult,
     GraphicalViewResolveTargetResult,
@@ -37,12 +38,21 @@ suite('TurtleLanguageClient graphical-view integration', () => {
             sourceUri: 'file:///model.ttl',
             elementUrn: 'urn:samm:example:1.0.0#Aspect',
         });
+        const resolveAttribute = await client.resolveGraphicalViewAttributeTarget({
+            sourceUri: 'file:///model.ttl',
+            ownerUrn: 'urn:samm:example:1.0.0#Aspect',
+            predicateUrn: 'urn:samm:org.eclipse.esmf.samm:meta-model:2.2.0#description',
+            selection: 'singleOccurrence',
+            language: 'en',
+        });
 
         assert.equal(render.uri, 'file:///model.ttl');
         assert.equal(resolve.warning, 'notFound');
+        assert.equal(resolveAttribute.warning, 'notFound');
         assert.equal(adapter.requests[0].method, GRAPHICAL_VIEW_RENDER_REQUEST);
         assert.equal(adapter.requests[0].token, cancellation.token);
         assert.equal(adapter.requests[1].method, GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST);
+        assert.equal(adapter.requests[2].method, GRAPHICAL_VIEW_RESOLVE_ATTRIBUTE_TARGET_REQUEST);
         cancellation.dispose();
     });
 
diff --git a/src/webview/sanitizer-contract.js b/src/webview/sanitizer-contract.js
index 83fe29c..0e4e621 100644
--- a/src/webview/sanitizer-contract.js
+++ b/src/webview/sanitizer-contract.js
@@ -26,7 +26,7 @@
     const ALLOWED_ATTRIBUTES = Object.freeze(
         Array.from(new Set(Object.values(TAG_ATTRIBUTES).flatMap(attributes => Array.from(attributes)))),
     );
-    const MARKER_PATTERN = /^gv-header-[a-z0-9]{16,32}$/;
+    const MARKER_PATTERN = /^gv-(?:header|attribute)-[a-z0-9]{16,32}$/;
     const COLOR_PATTERN = /^(?:none|#[0-9a-f]{6})$/i;
     const FONT_FAMILIES = new Set(['Arial', 'Roboto Condensed']);
     const NUMBER = '[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?';
diff --git a/src/webview/webview.css b/src/webview/webview.css
index 8eb9f69..92d72c8 100644
--- a/src/webview/webview.css
+++ b/src/webview/webview.css
@@ -89,7 +89,19 @@ body {
     display: block;
 }
 
-#diagram svg g[id^="gv-header-"] {
+#diagram svg g[id^="gv-header-"],
+#diagram svg g[id^="gv-attribute-"] {
     cursor: pointer;
     pointer-events: all;
 }
+
+#diagram svg g[id^="gv-header-"]:hover,
+#diagram svg g[id^="gv-attribute-"]:hover {
+    filter: brightness(0.94);
+}
+
+#diagram svg g[id^="gv-header-"]:focus-visible,
+#diagram svg g[id^="gv-attribute-"]:focus-visible {
+    outline: 2px solid var(--vscode-focusBorder);
+    outline-offset: 2px;
+}
diff --git a/src/webview/webview.js b/src/webview/webview.js
index 89da37c..cf7d599 100644
--- a/src/webview/webview.js
+++ b/src/webview/webview.js
@@ -162,6 +162,7 @@
             }
             const sanitized = SanitizerContract.sanitizeSvg(message.svg);
             const size = dimensions(sanitized.svg);
+            makeNavigationMarkersInteractive(sanitized.svg);
             diagram.replaceChildren(sanitized.fragment);
             currentSvg = sanitized.svg;
             currentVersion = message.version;
@@ -183,13 +184,38 @@
 
     viewport.addEventListener('scroll', persistState, {passive: true});
     diagram.addEventListener('click', event => {
-        const group = event.target instanceof Element ? event.target.closest('g[id^="gv-header-"]') : null;
-        if (!group || !diagram.contains(group) || !SanitizerContract.MARKER_PATTERN.test(group.id) || !Number.isInteger(currentVersion)) {
+        activateNavigationTarget(event.target);
+    });
+    diagram.addEventListener('keydown', event => {
+        if (event.key !== 'Enter' && event.key !== ' ') {
             return;
         }
-        vscode.postMessage({type: 'navigate', version: currentVersion, targetId: group.id});
+        if (activateNavigationTarget(event.target)) {
+            event.preventDefault();
+        }
     });
 
+    function makeNavigationMarkersInteractive(svg) {
+        for (const group of svg.querySelectorAll('g[id]')) {
+            if (SanitizerContract.MARKER_PATTERN.test(group.id)) {
+                group.setAttribute('tabindex', '0');
+                group.setAttribute('role', 'link');
+                group.setAttribute('aria-label', group.id.startsWith('gv-attribute-')
+                    ? 'Navigate to attribute source statement'
+                    : 'Navigate to element definition');
+            }
+        }
+    }
+
+    function activateNavigationTarget(target) {
+        const group = target instanceof Element ? target.closest('g[id]') : null;
+        if (!group || !diagram.contains(group) || !SanitizerContract.MARKER_PATTERN.test(group.id) || !Number.isInteger(currentVersion)) {
+            return false;
+        }
+        vscode.postMessage({type: 'navigate', version: currentVersion, targetId: group.id});
+        return true;
+    }
+
     document.querySelector('#refresh').addEventListener('click', () => vscode.postMessage({type: 'refresh'}));
     document.querySelector('#zoom-in').addEventListener('click', () => setZoom(state.zoom * ZOOM_FACTOR));
     document.querySelector('#zoom-out').addEventListener('click', () => setZoom(state.zoom / ZOOM_FACTOR));
@@ -219,7 +245,13 @@
         }
         if (testMode && isExactMessage(message, ['targetId', 'type']) && message.type === 'testClickMarker') {
             const marker = diagram.querySelector(`g[id="${CSS.escape(message.targetId)}"]`);
-            marker?.dispatchEvent(new MouseEvent('click', {bubbles: true}));
+            const hitTarget = marker?.querySelector('polygon') ?? marker;
+            hitTarget?.dispatchEvent(new MouseEvent('click', {bubbles: true}));
+            return;
+        }
+        if (testMode && isExactMessage(message, ['key', 'targetId', 'type']) && message.type === 'testKeyMarker') {
+            const marker = diagram.querySelector(`g[id="${CSS.escape(message.targetId)}"]`);
+            marker?.dispatchEvent(new KeyboardEvent('keydown', {key: message.key, bubbles: true}));
         }
     });
 

From 4a841f76756bf651494464cbdd788becfa941578 Mon Sep 17 00:00:00 2001
From: e-filchenko-bosh <FVI2FE@bosch.com>
Date: Thu, 27 Aug 2026 21:23:51 +0300
Subject: [PATCH 4/7] Update SVG references in graphical view tests to use full
 URLs

---
 src/test/graphicalViewController.test.ts       | 2 +-
 src/test/graphicalViewWebviewLifecycle.test.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/test/graphicalViewController.test.ts b/src/test/graphicalViewController.test.ts
index 670b15c..f814724 100644
--- a/src/test/graphicalViewController.test.ts
+++ b/src/test/graphicalViewController.test.ts
@@ -455,7 +455,7 @@ suite('GraphicalViewController', () => {
         };
         const result: GraphicalViewRenderResult = {
             uri: document.uri.toString(),
-            svg: `<svg><g id="${ids[0]}"><text>see: urn:irdi:0173:1:02:AAO677:002,</text></g>`
+            svg: `<svg><g id="${ids[0]}"><text>see: https://example.test/reference/with/a/long/path,</text></g>`
                 + `<g id="${ids[1]}"><text>urn:irdi:0173:1:02:AAO677:003</text></g></svg>`,
             targets: ids.map(id => ({id, ...locator})),
             warnings: [],
diff --git a/src/test/graphicalViewWebviewLifecycle.test.ts b/src/test/graphicalViewWebviewLifecycle.test.ts
index e46cd6b..d2385da 100644
--- a/src/test/graphicalViewWebviewLifecycle.test.ts
+++ b/src/test/graphicalViewWebviewLifecycle.test.ts
@@ -154,7 +154,7 @@ function graphperSvg(marker: string): string {
 function wrappedSeeSvg(firstMarker: string, continuationMarker: string): string {
     return `<svg xmlns="http://www.w3.org/2000/svg" height="1600pt" width="2200pt" viewBox="0 0 2200 1600">
 <g id="graph_root" class="graph" transform="scale(1 1) rotate(0)">
-<g id="${firstMarker}" class="node"><polygon points="10,10 2190,10 2190,700 10,700"></polygon><text x="20" y="300">see: urn:irdi:0173:1:02:AAO677:002,</text></g>
+<g id="${firstMarker}" class="node"><polygon points="10,10 2190,10 2190,700 10,700"></polygon><text x="20" y="300">see: https://example.test/reference/with/a/long/path,</text></g>
 <g id="${continuationMarker}" class="node"><polygon points="10,710 2190,710 2190,1590 10,1590"></polygon><text x="20" y="1000">urn:irdi:0173:1:02:AAO677:003</text></g>
 </g>
 </svg>`;

From 56bfeb17d982217a4daa440e0c34e7e263714183 Mon Sep 17 00:00:00 2001
From: e-filchenko-bosh <FVI2FE@bosch.com>
Date: Wed, 2 Sep 2026 11:21:03 +0300
Subject: [PATCH 5/7] refactoring

---
 .vscodeignore                                 |   1 +
 media/aspect-model-editor-targetsize-192.png  | Bin 0 -> 2168 bytes
 package.json                                  |  13 +-
 src/extension.ts                              |   3 +-
 src/graphicalView.ts                          | 558 ++++----------
 src/graphicalViewClient.ts                    |  83 +++
 src/graphicalViewNavigation.ts                | 138 ++++
 src/graphicalViewPanel.ts                     |  87 ++-
 src/graphicalViewProtocol.ts                  | 126 ----
 src/graphicalViewResult.ts                    | 200 +++++
 src/languageClient.ts                         |  71 +-
 src/test/graphicalViewController.test.ts      | 691 +++---------------
 src/test/graphicalViewManifest.test.ts        | 116 +++
 src/test/graphicalViewNavigation.test.ts      | 172 +++++
 src/test/graphicalViewPanel.test.ts           |  47 +-
 src/test/graphicalViewProtocol.test.ts        |  97 +++
 src/test/graphicalViewTestHarness.ts          |  47 +-
 .../graphicalViewWebviewController.test.ts    | 145 ++++
 .../graphicalViewWebviewLifecycle.test.ts     | 167 +----
 src/test/languageClientGraphicalView.test.ts  | 171 ++---
 src/webview/webview.js                        |  26 -
 21 files changed, 1462 insertions(+), 1497 deletions(-)
 create mode 100644 media/aspect-model-editor-targetsize-192.png
 create mode 100644 src/graphicalViewClient.ts
 create mode 100644 src/graphicalViewNavigation.ts
 create mode 100644 src/graphicalViewResult.ts
 create mode 100644 src/test/graphicalViewManifest.test.ts
 create mode 100644 src/test/graphicalViewNavigation.test.ts
 create mode 100644 src/test/graphicalViewProtocol.test.ts
 create mode 100644 src/test/graphicalViewWebviewController.test.ts

diff --git a/.vscodeignore b/.vscodeignore
index 7d3e5c7..3d26b57 100644
--- a/.vscodeignore
+++ b/.vscodeignore
@@ -1,6 +1,7 @@
 .vscode/**
 .vscode-test/**
 src/**
+out/test/**
 .gitignore
 .yarnrc
 vsc-extension-quickstart.md
diff --git a/media/aspect-model-editor-targetsize-192.png b/media/aspect-model-editor-targetsize-192.png
new file mode 100644
index 0000000000000000000000000000000000000000..a8f811b4e69e038237c3ed1606b3b7307c31c8c4
GIT binary patch
literal 2168
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
QuLR)X=H*&>_{_Ec07GuwlK=n!

literal 0
HcmV?d00001

diff --git a/package.json b/package.json
index 749b751..ba935a6 100644
--- a/package.json
+++ b/package.json
@@ -44,7 +44,11 @@
         "command": "turtle.openGraphicalView",
         "title": "Open Graphical View",
         "category": "Turtle",
-        "enablement": "editorLangId == turtle"
+        "enablement": "editorLangId == turtle",
+        "icon": {
+          "light": "media/aspect-model-editor-targetsize-192.png",
+          "dark": "media/aspect-model-editor-targetsize-192.png"
+        }
       }
     ],
     "languages": [
@@ -114,6 +118,13 @@
       }
     },
     "menus": {
+      "editor/title": [
+        {
+          "command": "turtle.openGraphicalView",
+          "when": "resourceLangId == turtle",
+          "group": "navigation@10"
+        }
+      ],
       "editor/context": [
         {
           "command": "turtle.validateDocumentNow",
diff --git a/src/extension.ts b/src/extension.ts
index f573ad9..49113ec 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -19,6 +19,7 @@ import { TurtleExtensionSettings } from './settings';
 import { TurtleLanguageClient } from './languageClient';
 import type { ExtensionLogger } from './outputChannel';
 import { GraphicalViewController } from './graphicalView';
+import {LspGraphicalViewClient} from './graphicalViewClient';
 import { VscodeGraphicalViewPanelFactory } from './graphicalViewPanel';
 
 const SELECT_EXECUTABLE_COMMAND = 'turtle.selectSammCliExecutable';
@@ -171,7 +172,7 @@ async function restartLanguageServices(reason: string): Promise<void> {
     await nextClient.connect();
     languageClient = nextClient;
     aspectValidationController.setClient(nextClient);
-    graphicalViewController.setClient(nextClient);
+    graphicalViewController.setClient(new LspGraphicalViewClient(nextClient));
 }
 
 type SammCliQuickPickItem = vscode.QuickPickItem & {
diff --git a/src/graphicalView.ts b/src/graphicalView.ts
index e12d454..744b70b 100644
--- a/src/graphicalView.ts
+++ b/src/graphicalView.ts
@@ -13,58 +13,19 @@
 
 import * as vscode from 'vscode';
 import type {ExtensionLogger} from './outputChannel';
+import type {GraphicalViewClient} from './graphicalViewClient';
+import {resolveGraphicalViewNavigation} from './graphicalViewNavigation';
 import {
-    GRAPHICAL_VIEW_MARKER_PATTERN,
-    GraphicalViewRenderResult,
-    GraphicalViewRenderWarning,
-    GraphicalViewRequestClient,
-    GraphicalViewTarget,
-    isGraphicalViewRenderResult,
-} from './graphicalViewProtocol';
+    GraphicalViewPanel,
+    GraphicalViewPanelFactory,
+    GraphicalViewStatus,
+    parseGraphicalViewPanelMessage,
+} from './graphicalViewPanel';
+import type {GraphicalViewRenderResult, GraphicalViewRenderWarning, GraphicalViewTarget} from './graphicalViewProtocol';
+import {AcceptedGraphicalViewResult, acceptGraphicalViewResult, isGraphicalViewRenderResult} from './graphicalViewResult';
 
 export const OPEN_GRAPHICAL_VIEW_COMMAND = 'turtle.openGraphicalView';
 
-export type GraphicalViewStatus =
-    | Readonly<{kind: 'loading'; message: string}>
-    | Readonly<{kind: 'ready'; message: string}>
-    | Readonly<{kind: 'stale'; reason: string; message: string}>
-    | Readonly<{kind: 'unsupported'; message: string}>
-    | Readonly<{kind: 'disconnected'; message: string}>;
-
-export interface GraphicalViewAcceptedResult {
-    readonly version: number;
-    readonly uri: string;
-    readonly svg: string;
-    readonly targets: readonly Readonly<GraphicalViewTarget>[];
-    readonly warnings: readonly GraphicalViewRenderWarning[];
-    readonly targetById: ReadonlyMap<string, Readonly<GraphicalViewTarget>>;
-    readonly attributeRowsAvailable: boolean;
-}
-
-export type GraphicalViewDelivery =
-    | Readonly<{type: 'status'; status: GraphicalViewStatus}>
-    | Readonly<{type: 'render'; version: number; svg: string}>;
-
-export type GraphicalViewPanelMessage =
-    | Readonly<{type: 'ready'}>
-    | Readonly<{type: 'refresh'}>
-    | Readonly<{type: 'rendered'; version: number}>
-    | Readonly<{type: 'renderError'; version: number; reason: 'sanitizationFailed'}>
-    | Readonly<{type: 'navigate'; version: number; targetId: string}>;
-
-export interface GraphicalViewPanelAdapter extends vscode.Disposable {
-    readonly visible: boolean;
-    reveal(): void;
-    deliver(delivery: GraphicalViewDelivery): void;
-    onDidDispose(listener: () => void): vscode.Disposable;
-    onDidChangeVisibility(listener: (visible: boolean) => void): vscode.Disposable;
-    onDidReceiveMessage(listener: (message: unknown) => void): vscode.Disposable;
-}
-
-export interface GraphicalViewPanelFactory {
-    create(sourceUri: string): GraphicalViewPanelAdapter;
-}
-
 export interface GraphicalViewDocument {
     readonly languageId: string;
     readonly uri: vscode.Uri;
@@ -86,22 +47,9 @@ export interface GraphicalViewCommands {
     registerCommand(command: string, callback: () => unknown): vscode.Disposable;
 }
 
-export interface GraphicalViewControllerContext {
-    subscriptions: vscode.Disposable[];
-}
-
-export interface GraphicalViewPanelSnapshot {
-    readonly sourceUri: string;
-    readonly sequence: number;
-    readonly visible: boolean;
-    readonly disposed: boolean;
-    readonly status: GraphicalViewStatus;
-    readonly lastSuccess: GraphicalViewAcceptedResult | undefined;
-}
-
 interface PanelState {
     readonly sourceUri: string;
-    readonly panel: GraphicalViewPanelAdapter;
+    readonly panel: GraphicalViewPanel;
     readonly subscriptions: vscode.Disposable[];
     sequence: number;
     sourceAvailable: boolean;
@@ -111,12 +59,12 @@ interface PanelState {
     navigationCancellation: vscode.CancellationTokenSource | undefined;
     nextDisplayVersion: number;
     status: GraphicalViewStatus;
-    lastSuccess: GraphicalViewAcceptedResult | undefined;
+    lastSuccess: AcceptedGraphicalViewResult | undefined;
     pendingDelivery: PendingDelivery | undefined;
 }
 
 interface PendingDelivery {
-    readonly accepted: GraphicalViewAcceptedResult;
+    readonly accepted: AcceptedGraphicalViewResult;
     readonly requestSequence: number;
 }
 
@@ -133,25 +81,23 @@ export class GraphicalViewController implements vscode.Disposable {
     private disposed = false;
 
     constructor(
-        private client: GraphicalViewRequestClient | undefined,
+        private client: GraphicalViewClient | undefined,
         private readonly panelFactory: GraphicalViewPanelFactory,
         private readonly commands: GraphicalViewCommands,
         private readonly window: GraphicalViewWindow,
         private readonly workspace: GraphicalViewWorkspace,
         private readonly outputChannel: ExtensionLogger,
-        private readonly createCancellationSource: () => vscode.CancellationTokenSource = () => new vscode.CancellationTokenSource(),
     ) {
         this.subscribeToClient();
     }
 
-    register(context: GraphicalViewControllerContext): void {
+    register(context: Pick<vscode.ExtensionContext, 'subscriptions'>): void {
         if (this.registered || this.disposed) {
             return;
         }
         this.registered = true;
-
         this.subscriptions.push(
-            this.commands.registerCommand(OPEN_GRAPHICAL_VIEW_COMMAND, () => this.openGraphicalView(this.window.activeTextEditor?.document)),
+            this.commands.registerCommand(OPEN_GRAPHICAL_VIEW_COMMAND, () => this.openActiveDocument()),
             this.workspace.onDidSaveTextDocument(document => this.handleSave(document)),
             this.workspace.onDidChangeDocumentAvailability((sourceUri, available) =>
                 this.handleDocumentAvailability(sourceUri, available),
@@ -160,17 +106,47 @@ export class GraphicalViewController implements vscode.Disposable {
         context.subscriptions.push(this);
     }
 
-    async openGraphicalView(document: GraphicalViewDocument | undefined): Promise<GraphicalViewPanelSnapshot | undefined> {
+    setClient(client: GraphicalViewClient | undefined): void {
+        if (this.disposed) {
+            return;
+        }
+        this.clientSubscription?.dispose();
+        this.clientSubscription = undefined;
+        this.client = client;
+        for (const state of this.panels.values()) {
+            this.invalidate(state);
+            this.setStatus(state, client?.isAvailable() ? availableAgainStatus(state) : DISCONNECTED_STATUS);
+        }
+        this.subscribeToClient();
+    }
+
+    dispose(): void {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        this.clientSubscription?.dispose();
+        this.clientSubscription = undefined;
+        for (const subscription of this.subscriptions.splice(0)) {
+            subscription.dispose();
+        }
+        for (const state of [...this.panels.values()]) {
+            this.disposePanelState(state, true);
+        }
+    }
+
+    private async openActiveDocument(): Promise<void> {
+        const document = this.window.activeTextEditor?.document;
         if (!document || document.languageId !== 'turtle') {
             await this.window.showWarningMessage('Open a Turtle file before opening the graphical view.');
-            return undefined;
+            return;
         }
 
         const sourceUri = document.uri.toString();
         const existing = this.panels.get(sourceUri);
         if (existing && !existing.disposed) {
             existing.panel.reveal();
-            return this.snapshot(existing);
+            return;
         }
 
         const panel = this.panelFactory.create(sourceUri);
@@ -196,53 +172,13 @@ export class GraphicalViewController implements vscode.Disposable {
             panel.onDidReceiveMessage(message => this.handlePanelMessage(state, message)),
         );
         void this.requestRender(state, 'initial');
-        return this.snapshot(state);
-    }
-
-    setClient(client: GraphicalViewRequestClient | undefined): void {
-        if (this.disposed) {
-            return;
-        }
-
-        this.clientSubscription?.dispose();
-        this.clientSubscription = undefined;
-        this.client = client;
-        for (const state of this.panels.values()) {
-            this.invalidate(state);
-            this.setStatus(state, client?.isGraphicalViewAvailable() ? availableAgainStatus(state) : DISCONNECTED_STATUS);
-        }
-        this.subscribeToClient();
-    }
-
-    getPanelCount(): number {
-        return this.panels.size;
-    }
-
-    getPanelState(sourceUri: string): GraphicalViewPanelSnapshot | undefined {
-        const state = this.panels.get(sourceUri);
-        return state ? this.snapshot(state) : undefined;
-    }
-
-    dispose(): void {
-        if (this.disposed) {
-            return;
-        }
-        this.disposed = true;
-        this.clientSubscription?.dispose();
-        this.clientSubscription = undefined;
-        for (const subscription of this.subscriptions.splice(0)) {
-            subscription.dispose();
-        }
-        for (const state of [...this.panels.values()]) {
-            this.disposePanelState(state, true);
-        }
     }
 
     private subscribeToClient(): void {
         if (!this.client || this.disposed) {
             return;
         }
-        this.clientSubscription = this.client.onDidChangeGraphicalViewAvailability(available => this.handleClientAvailability(available));
+        this.clientSubscription = this.client.onDidChangeAvailability(available => this.handleClientAvailability(available));
     }
 
     private handleClientAvailability(available: boolean): void {
@@ -261,13 +197,11 @@ export class GraphicalViewController implements vscode.Disposable {
         if (!state || state.disposed) {
             return;
         }
-
         if (!state.visible) {
             this.invalidate(state);
             this.setStatus(state, retainedAfterHiddenSaveStatus(state));
             return;
         }
-
         void this.requestRender(state, 'save');
     }
 
@@ -276,12 +210,10 @@ export class GraphicalViewController implements vscode.Disposable {
         if (!state || state.disposed || state.sourceAvailable === available) {
             return;
         }
-
         state.sourceAvailable = available;
         if (available) {
             return;
         }
-
         this.invalidate(state);
         this.setStatus(state, retainedAfterSourceLossStatus(state));
     }
@@ -296,11 +228,14 @@ export class GraphicalViewController implements vscode.Disposable {
         }
     }
 
-    private handlePanelMessage(state: PanelState, message: unknown): void {
-        if (!this.isCurrent(state) || !isPanelMessage(message)) {
+    private handlePanelMessage(state: PanelState, value: unknown): void {
+        if (!this.isCurrent(state)) {
+            return;
+        }
+        const message = parseGraphicalViewPanelMessage(value);
+        if (!message) {
             return;
         }
-
         switch (message.type) {
             case 'ready':
                 this.deliverCurrentState(state);
@@ -317,8 +252,7 @@ export class GraphicalViewController implements vscode.Disposable {
                 this.handleRenderError(state, message.version);
                 return;
             case 'navigate':
-                void this.navigateToTarget(state, message);
-                return;
+                void this.navigateToTarget(state, message.version, message.targetId);
         }
     }
 
@@ -326,45 +260,39 @@ export class GraphicalViewController implements vscode.Disposable {
         if (!this.isCurrent(state)) {
             return;
         }
-
-        this.cancelCurrent(state);
+        this.cancelRender(state);
         const sequence = ++state.sequence;
         const sourceUri = state.sourceUri;
-
         state.sourceAvailable = this.workspace.isDocumentAvailable(sourceUri);
         if (!state.sourceAvailable) {
-            this.setStatus(
+            this.setStale(
                 state,
-                Object.freeze({
-                    kind: 'stale',
-                    reason: 'sourceUnavailable',
-                    message: 'The source document is not available to the language server. Reopen it and use Refresh.',
-                }),
+                'sourceUnavailable',
+                'The source document is not available to the language server. Reopen it and use Refresh.',
             );
             return;
         }
 
         const client = this.client;
-        if (!client?.isGraphicalViewAvailable()) {
+        if (!client?.isAvailable()) {
             this.setStatus(state, DISCONNECTED_STATUS);
             return;
         }
 
-        const cancellation = this.createCancellationSource();
+        const cancellation = new vscode.CancellationTokenSource();
         state.cancellation = cancellation;
         this.setStatus(state, Object.freeze({kind: 'loading', message: `Rendering graphical view (${trigger})...`}));
-
         try {
             let attributeRowsAvailable = true;
             let result: GraphicalViewRenderResult;
             try {
-                result = await client.renderGraphicalView({uri: sourceUri, includeAttributeRows: true}, cancellation.token);
+                result = await client.render({uri: sourceUri, includeAttributeRows: true}, cancellation.token);
             } catch (error) {
                 if (!isInvalidParams(error) || !this.isCurrentRequest(state, sourceUri, sequence, cancellation)) {
                     throw error;
                 }
                 attributeRowsAvailable = false;
-                result = await client.renderGraphicalView({uri: sourceUri}, cancellation.token);
+                result = await client.render({uri: sourceUri}, cancellation.token);
             }
             if (!this.isCurrentRequest(state, sourceUri, sequence, cancellation)) {
                 return;
@@ -392,46 +320,40 @@ export class GraphicalViewController implements vscode.Disposable {
             this.setStale(state, 'invalidResponse', 'The language server returned an invalid graphical-view response.');
             return;
         }
-
         if (result.uri !== state.sourceUri) {
             this.setStale(state, 'uriMismatch', 'The language server returned a graphical view for a different source document.');
             return;
         }
-
         if (!attributeRowsAvailable && result.targets.some(target => target.kind !== 'elementHeader')) {
             this.setStale(state, 'invalidResponse', 'The legacy language server returned an invalid graphical-view response.');
             return;
         }
-
         if (result.svg === undefined || result.svg === null) {
             this.handleWarningResult(state, result.warnings);
             return;
         }
 
-        const accepted = createAcceptedResult(result, result.svg, ++state.nextDisplayVersion, attributeRowsAvailable);
+        const accepted = acceptGraphicalViewResult(result, ++state.nextDisplayVersion, attributeRowsAvailable);
         state.pendingDelivery = Object.freeze({accepted, requestSequence});
         state.panel.deliver(Object.freeze({type: 'render', version: accepted.version, svg: accepted.svg}));
     }
 
     private handleRendered(state: PanelState, version: number): void {
         const pending = state.pendingDelivery;
-        if (pending?.accepted.version === version) {
-            this.cancelNavigation(state);
-            state.lastSuccess = pending.accepted;
-            state.pendingDelivery = undefined;
-            if (state.sequence === pending.requestSequence) {
-                this.setStatus(state, Object.freeze({
-                    kind: 'ready',
-                    message: pending.accepted.attributeRowsAvailable
-                        ? 'Graphical view is up to date.'
-                        : 'The server supports header navigation only; attribute-row navigation is unavailable.',
-                }));
-            }
+        if (pending?.accepted.version !== version) {
             return;
         }
-
-        // An acknowledgement for a rehydrated last-successful snapshot must not
-        // clear a newer stale/error status.
+        this.cancelNavigation(state);
+        state.lastSuccess = pending.accepted;
+        state.pendingDelivery = undefined;
+        if (state.sequence === pending.requestSequence) {
+            this.setStatus(state, Object.freeze({
+                kind: 'ready',
+                message: pending.accepted.attributeRowsAvailable
+                    ? 'Graphical view is up to date.'
+                    : 'The server supports header navigation only; attribute-row navigation is unavailable.',
+            }));
+        }
     }
 
     private handleRenderError(state: PanelState, version: number): void {
@@ -448,85 +370,58 @@ export class GraphicalViewController implements vscode.Disposable {
         );
     }
 
-    private async navigateToTarget(
-        state: PanelState,
-        message: Readonly<{type: 'navigate'; version: number; targetId: string}>,
-    ): Promise<void> {
+    private async navigateToTarget(state: PanelState, version: number, targetId: string): Promise<void> {
         const accepted = state.lastSuccess;
-        const target = accepted?.version === message.version ? accepted.targetById.get(message.targetId) : undefined;
-        if (!accepted || !target || !GRAPHICAL_VIEW_MARKER_PATTERN.test(message.targetId)) {
+        const target = accepted?.version === version ? accepted.targetById.get(targetId) : undefined;
+        if (!accepted || !target) {
             return;
         }
 
         const client = this.client;
-        if (!client?.isGraphicalViewAvailable()) {
-            await this.warnNavigation('The graphical target is temporarily unavailable because the language server is disconnected.');
+        if (!client?.isAvailable()) {
+            await this.window.showWarningMessage(
+                'The graphical target is temporarily unavailable because the language server is disconnected.',
+            );
             return;
         }
 
         this.cancelNavigation(state);
-        const cancellation = this.createCancellationSource();
+        const cancellation = new vscode.CancellationTokenSource();
         state.navigationCancellation = cancellation;
         try {
-            const response = target.kind === 'elementHeader'
-                ? await client.resolveGraphicalViewTarget(
-                    {sourceUri: state.sourceUri, elementUrn: target.elementUrn},
-                    cancellation.token,
-                )
-                : await client.resolveGraphicalViewAttributeTarget(
-                    {
-                        sourceUri: state.sourceUri,
-                        ownerUrn: target.ownerUrn,
-                        predicateUrn: target.predicateUrn,
-                        selection: target.selection,
-                        ...(target.language === undefined ? {} : {language: target.language}),
-                    },
-                    cancellation.token,
-                );
+            const resolution = await resolveGraphicalViewNavigation(client, state.sourceUri, target, cancellation.token);
             if (!this.isCurrentNavigation(state, accepted, target, cancellation)) {
                 return;
             }
             state.navigationCancellation = undefined;
             cancellation.dispose();
-
-            const resolved = validateResolveTargetResult(response);
-            if (resolved.kind === 'warning') {
-                await this.warnNavigation(resolveWarningMessage(resolved.warning));
-                return;
-            }
-            if (resolved.kind === 'invalid') {
-                await this.warnNavigation('The language server returned an invalid graphical target location.');
+            if (resolution.kind === 'warning') {
+                await this.window.showWarningMessage(resolution.message);
                 return;
             }
 
             try {
-                const editor = await this.window.showTextDocument(resolved.uri, {preview: false});
+                const editor = await this.window.showTextDocument(resolution.uri, {preview: false});
                 if (!this.isCurrentNavigationResult(state, accepted, target)) {
                     return;
                 }
-                const range = new vscode.Range(
-                    resolved.start.line,
-                    resolved.start.character,
-                    resolved.end.line,
-                    resolved.end.character,
-                );
-                editor.selection = new vscode.Selection(range.start, range.end);
-                editor.revealRange(range, vscode.TextEditorRevealType.InCenterIfOutsideViewport);
+                editor.selection = new vscode.Selection(resolution.range.start, resolution.range.end);
+                editor.revealRange(resolution.range, vscode.TextEditorRevealType.InCenterIfOutsideViewport);
             } catch (_error) {
-                await this.warnNavigation('The graphical target could not be opened in an editor.');
+                await this.window.showWarningMessage('The graphical target could not be opened in an editor.');
             }
         } catch (_error) {
             if (this.isCurrentNavigation(state, accepted, target, cancellation)) {
                 state.navigationCancellation = undefined;
                 cancellation.dispose();
-                await this.warnNavigation('The graphical target is temporarily unavailable.');
+                await this.window.showWarningMessage('The graphical target is temporarily unavailable.');
             }
         }
     }
 
     private isCurrentNavigation(
         state: PanelState,
-        accepted: GraphicalViewAcceptedResult,
+        accepted: AcceptedGraphicalViewResult,
         target: Readonly<GraphicalViewTarget>,
         cancellation: vscode.CancellationTokenSource,
     ): boolean {
@@ -535,7 +430,7 @@ export class GraphicalViewController implements vscode.Disposable {
 
     private isCurrentNavigationResult(
         state: PanelState,
-        accepted: GraphicalViewAcceptedResult,
+        accepted: AcceptedGraphicalViewResult,
         target: Readonly<GraphicalViewTarget>,
     ): boolean {
         return this.isCurrent(state)
@@ -543,10 +438,6 @@ export class GraphicalViewController implements vscode.Disposable {
             && accepted.targetById.get(target.id) === target;
     }
 
-    private async warnNavigation(message: string): Promise<void> {
-        await this.window.showWarningMessage(message);
-    }
-
     private handleWarningResult(state: PanelState, warnings: readonly GraphicalViewRenderWarning[]): void {
         const warning = warnings[0];
         switch (warning) {
@@ -570,18 +461,13 @@ export class GraphicalViewController implements vscode.Disposable {
 
     private handleRenderFailure(state: PanelState, error: unknown): void {
         if (isMethodNotFound(error)) {
-            this.setStatus(
-                state,
-                Object.freeze({
-                    kind: 'unsupported',
-                    message: 'Graphical view is not supported by the current server build. The last successful diagram is retained.',
-                }),
-            );
+            this.setStatus(state, Object.freeze({
+                kind: 'unsupported',
+                message: 'Graphical view is not supported by the current server build. The last successful diagram is retained.',
+            }));
             return;
         }
-
-        const detail = error instanceof Error ? error.message : String(error);
-        const reason = classifyFailure(detail);
+        const reason = classifyFailure(error instanceof Error ? error.message : String(error));
         this.outputChannel.warn(`Graphical view render request failed (${reason}).`);
         this.setStale(state, reason, 'Graphical rendering failed. The last successful diagram is retained.');
     }
@@ -614,13 +500,13 @@ export class GraphicalViewController implements vscode.Disposable {
         if (!this.isCurrent(state)) {
             return;
         }
-        this.cancelCurrent(state);
+        this.cancelRender(state);
         this.cancelNavigation(state);
         state.pendingDelivery = undefined;
         state.sequence += 1;
     }
 
-    private cancelCurrent(state: PanelState): void {
+    private cancelRender(state: PanelState): void {
         const cancellation = state.cancellation;
         state.cancellation = undefined;
         if (cancellation) {
@@ -644,7 +530,10 @@ export class GraphicalViewController implements vscode.Disposable {
         sequence: number,
         cancellation: vscode.CancellationTokenSource,
     ): boolean {
-        return this.isCurrent(state) && state.sourceUri === sourceUri && state.sequence === sequence && state.cancellation === cancellation;
+        return this.isCurrent(state)
+            && state.sourceUri === sourceUri
+            && state.sequence === sequence
+            && state.cancellation === cancellation;
     }
 
     private isCurrent(state: PanelState): boolean {
@@ -655,7 +544,7 @@ export class GraphicalViewController implements vscode.Disposable {
         if (state.disposed) {
             return;
         }
-        this.cancelCurrent(state);
+        this.cancelRender(state);
         this.cancelNavigation(state);
         state.sequence += 1;
         state.disposed = true;
@@ -667,74 +556,6 @@ export class GraphicalViewController implements vscode.Disposable {
             state.panel.dispose();
         }
     }
-
-    private snapshot(state: PanelState): GraphicalViewPanelSnapshot {
-        return Object.freeze({
-            sourceUri: state.sourceUri,
-            sequence: state.sequence,
-            visible: state.visible,
-            disposed: state.disposed,
-            status: state.status,
-            lastSuccess: state.lastSuccess,
-        });
-    }
-}
-
-function createAcceptedResult(
-    result: GraphicalViewRenderResult,
-    svg: string,
-    version: number,
-    attributeRowsAvailable: boolean,
-): GraphicalViewAcceptedResult {
-    const targets = Object.freeze(result.targets.map(target => Object.freeze({...target})));
-    const warnings = Object.freeze([...result.warnings]);
-    const targetById = new ImmutableTargetMap(targets.map(target => [target.id, target]));
-    return Object.freeze({version, uri: result.uri, svg, targets, warnings, targetById, attributeRowsAvailable});
-}
-
-class ImmutableTargetMap<K, V> implements ReadonlyMap<K, V> {
-    private readonly map: Map<K, V>;
-
-    constructor(entries: readonly (readonly [K, V])[]) {
-        this.map = new Map(entries);
-        Object.freeze(this);
-    }
-
-    get size(): number {
-        return this.map.size;
-    }
-
-    get(key: K): V | undefined {
-        return this.map.get(key);
-    }
-
-    has(key: K): boolean {
-        return this.map.has(key);
-    }
-
-    forEach(callbackfn: (value: V, key: K, map: ReadonlyMap<K, V>) => void, thisArg?: unknown): void {
-        this.map.forEach((value, key) => callbackfn.call(thisArg, value, key, this));
-    }
-
-    entries(): MapIterator<[K, V]> {
-        return this.map.entries();
-    }
-
-    keys(): MapIterator<K> {
-        return this.map.keys();
-    }
-
-    values(): MapIterator<V> {
-        return this.map.values();
-    }
-
-    [Symbol.iterator](): MapIterator<[K, V]> {
-        return this.entries();
-    }
-
-    get [Symbol.toStringTag](): string {
-        return 'ImmutableTargetMap';
-    }
 }
 
 function availableAgainStatus(state: PanelState): GraphicalViewStatus {
@@ -748,161 +569,28 @@ function availableAgainStatus(state: PanelState): GraphicalViewStatus {
 }
 
 function retainedAfterHiddenSaveStatus(state: PanelState): GraphicalViewStatus {
-    if (state.lastSuccess) {
-        return Object.freeze({kind: 'ready', message: 'Showing the retained graphical-view snapshot.'});
-    }
-    return Object.freeze({
-        kind: 'stale',
-        reason: 'noSnapshot',
-        message: 'No graphical-view snapshot is available. Reveal the panel and use Refresh to render one.',
-    });
+    return state.lastSuccess
+        ? Object.freeze({kind: 'ready', message: 'Showing the retained graphical-view snapshot.'})
+        : Object.freeze({
+            kind: 'stale',
+            reason: 'noSnapshot',
+            message: 'No graphical-view snapshot is available. Reveal the panel and use Refresh to render one.',
+        });
 }
 
 function retainedAfterSourceLossStatus(state: PanelState): GraphicalViewStatus {
-    if (state.lastSuccess) {
-        return Object.freeze({kind: 'ready', message: 'Showing the retained graphical-view snapshot.'});
-    }
-    return Object.freeze({
-        kind: 'stale',
-        reason: 'sourceUnavailable',
-        message: 'The source document is no longer open. Reopen it and use Refresh to render the graphical view.',
-    });
-}
-
-function isPanelMessage(value: unknown): value is GraphicalViewPanelMessage {
-    if (!isRecord(value)) {
-        return false;
-    }
-    const keys = Object.keys(value).sort();
-    if ((value.type === 'ready' || value.type === 'refresh') && keys.length === 1) {
-        return true;
-    }
-    if (value.type === 'rendered') {
-        return keys.length === 2 && keys[0] === 'type' && keys[1] === 'version' && isDisplayedVersion(value.version);
-    }
-    if (value.type === 'renderError') {
-        return keys.length === 3
-            && keys[0] === 'reason'
-            && keys[1] === 'type'
-            && keys[2] === 'version'
-            && value.reason === 'sanitizationFailed'
-            && isDisplayedVersion(value.version);
-    }
-    return value.type === 'navigate'
-        && keys.length === 3
-        && keys[0] === 'targetId'
-        && keys[1] === 'type'
-        && keys[2] === 'version'
-        && isDisplayedVersion(value.version)
-        && typeof value.targetId === 'string'
-        && GRAPHICAL_VIEW_MARKER_PATTERN.test(value.targetId);
-}
-
-function isDisplayedVersion(value: unknown): value is number {
-    return Number.isSafeInteger(value) && (value as number) > 0;
-}
-
-type ValidatedResolveTarget =
-    | Readonly<{kind: 'location'; uri: vscode.Uri; start: vscode.Position; end: vscode.Position}>
-    | Readonly<{kind: 'warning'; warning: GraphicalViewResolveWarning}>
-    | Readonly<{kind: 'invalid'}>;
-
-type GraphicalViewResolveWarning = 'notFound' | 'ambiguous' | 'unsupportedUri' | 'temporarilyUnresolvable';
-
-const RESOLVE_WARNINGS: ReadonlySet<string> = new Set([
-    'notFound',
-    'ambiguous',
-    'unsupportedUri',
-    'temporarilyUnresolvable',
-]);
-
-function validateResolveTargetResult(value: unknown): ValidatedResolveTarget {
-    if (!isRecord(value) || !hasOnlyKeys(value, ['location', 'warning'])) {
-        return {kind: 'invalid'};
-    }
-
-    const warning = value.warning;
-    if (warning !== undefined && warning !== null && (typeof warning !== 'string' || !RESOLVE_WARNINGS.has(warning))) {
-        return {kind: 'invalid'};
-    }
-    const location = value.location;
-    if (location === undefined || location === null) {
-        return typeof warning === 'string'
-            ? {kind: 'warning', warning: warning as GraphicalViewResolveWarning}
-            : {kind: 'invalid'};
-    }
-    if (warning !== undefined && warning !== null) {
-        return {kind: 'invalid'};
-    }
-    if (!isRecord(location) || !hasExactKeys(location, ['range', 'uri']) || typeof location.uri !== 'string') {
-        return {kind: 'invalid'};
-    }
-    const range = location.range;
-    if (!isRecord(range) || !hasExactKeys(range, ['end', 'start'])) {
-        return {kind: 'invalid'};
-    }
-    const start = validatePosition(range.start);
-    const end = validatePosition(range.end);
-    if (!start || !end || start.isAfter(end)) {
-        return {kind: 'invalid'};
-    }
-
-    try {
-        const uri = vscode.Uri.parse(location.uri, true);
-        if (uri.scheme !== 'file'
-            || uri.authority !== ''
-            || !uri.path.startsWith('/')
-            || uri.query !== ''
-            || uri.fragment !== ''
-            || uri.fsPath.includes('\0')) {
-            return {kind: 'warning', warning: 'unsupportedUri'};
-        }
-        return {kind: 'location', uri, start, end};
-    } catch (_error) {
-        return {kind: 'invalid'};
-    }
-}
-
-function validatePosition(value: unknown): vscode.Position | undefined {
-    if (!isRecord(value)
-        || !hasExactKeys(value, ['character', 'line'])
-        || !Number.isSafeInteger(value.line)
-        || !Number.isSafeInteger(value.character)
-        || (value.line as number) < 0
-        || (value.character as number) < 0) {
-        return undefined;
-    }
-    return new vscode.Position(value.line as number, value.character as number);
-}
-
-function hasOnlyKeys(value: Record<string, unknown>, allowedKeys: readonly string[]): boolean {
-    const allowed = new Set(allowedKeys);
-    return Object.keys(value).every(key => allowed.has(key));
-}
-
-function hasExactKeys(value: Record<string, unknown>, expectedKeys: readonly string[]): boolean {
-    const actualKeys = Object.keys(value).sort();
-    return actualKeys.length === expectedKeys.length && actualKeys.every((key, index) => key === expectedKeys[index]);
-}
-
-function resolveWarningMessage(warning: GraphicalViewResolveWarning): string {
-    switch (warning) {
-        case 'notFound':
-            return 'The graphical target no longer exists in the current model.';
-        case 'ambiguous':
-            return 'The graphical target is ambiguous in the current model.';
-        case 'unsupportedUri':
-            return 'The graphical target is not a local file and cannot be opened.';
-        case 'temporarilyUnresolvable':
-            return 'The graphical target is temporarily unavailable. Fix any model syntax errors and try again.';
-    }
+    return state.lastSuccess
+        ? Object.freeze({kind: 'ready', message: 'Showing the retained graphical-view snapshot.'})
+        : Object.freeze({
+            kind: 'stale',
+            reason: 'sourceUnavailable',
+            message: 'The source document is no longer open. Reopen it and use Refresh to render the graphical view.',
+        });
 }
 
 function isMethodNotFound(error: unknown): boolean {
-    if (isRecord(error) && error.code === -32601) {
-        return true;
-    }
-    return error instanceof Error && /method\s+not\s+found/i.test(error.message);
+    return (isRecord(error) && error.code === -32601)
+        || (error instanceof Error && /method\s+not\s+found/i.test(error.message));
 }
 
 function isInvalidParams(error: unknown): boolean {
diff --git a/src/graphicalViewClient.ts b/src/graphicalViewClient.ts
new file mode 100644
index 0000000..fa76a94
--- /dev/null
+++ b/src/graphicalViewClient.ts
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ *
+ * See the AUTHORS file(s) distributed with this work for additional
+ * information regarding authorship.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import type * as vscode from 'vscode';
+import type {RequestClient} from './aspectValidation';
+import {
+    GRAPHICAL_VIEW_RENDER_REQUEST,
+    GRAPHICAL_VIEW_RESOLVE_ATTRIBUTE_TARGET_REQUEST,
+    GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST,
+    GraphicalViewRenderParams,
+    GraphicalViewRenderResult,
+    GraphicalViewResolveAttributeTargetParams,
+    GraphicalViewResolveAttributeTargetResult,
+    GraphicalViewResolveTargetParams,
+    GraphicalViewResolveTargetResult,
+} from './graphicalViewProtocol';
+
+export interface GraphicalViewClient {
+    isAvailable(): boolean;
+    onDidChangeAvailability(listener: (available: boolean) => void): vscode.Disposable;
+    render(params: GraphicalViewRenderParams, token: vscode.CancellationToken): Thenable<GraphicalViewRenderResult>;
+    resolveElement(
+        params: GraphicalViewResolveTargetParams,
+        token: vscode.CancellationToken,
+    ): Thenable<GraphicalViewResolveTargetResult>;
+    resolveAttribute(
+        params: GraphicalViewResolveAttributeTargetParams,
+        token: vscode.CancellationToken,
+    ): Thenable<GraphicalViewResolveAttributeTargetResult>;
+}
+
+export interface GraphicalViewRequestTransport extends RequestClient {
+    isAvailable(): boolean;
+    onDidChangeAvailability(listener: (available: boolean) => void): vscode.Disposable;
+}
+
+export class LspGraphicalViewClient implements GraphicalViewClient {
+    constructor(private readonly transport: GraphicalViewRequestTransport) {}
+
+    isAvailable(): boolean {
+        return this.transport.isAvailable();
+    }
+
+    onDidChangeAvailability(listener: (available: boolean) => void): vscode.Disposable {
+        return this.transport.onDidChangeAvailability(listener);
+    }
+
+    render(params: GraphicalViewRenderParams, token: vscode.CancellationToken): Thenable<GraphicalViewRenderResult> {
+        return this.transport.sendRequest<GraphicalViewRenderResult>(GRAPHICAL_VIEW_RENDER_REQUEST, params, token);
+    }
+
+    resolveElement(
+        params: GraphicalViewResolveTargetParams,
+        token: vscode.CancellationToken,
+    ): Thenable<GraphicalViewResolveTargetResult> {
+        return this.transport.sendRequest<GraphicalViewResolveTargetResult>(
+            GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST,
+            params,
+            token,
+        );
+    }
+
+    resolveAttribute(
+        params: GraphicalViewResolveAttributeTargetParams,
+        token: vscode.CancellationToken,
+    ): Thenable<GraphicalViewResolveAttributeTargetResult> {
+        return this.transport.sendRequest<GraphicalViewResolveAttributeTargetResult>(
+            GRAPHICAL_VIEW_RESOLVE_ATTRIBUTE_TARGET_REQUEST,
+            params,
+            token,
+        );
+    }
+}
diff --git a/src/graphicalViewNavigation.ts b/src/graphicalViewNavigation.ts
new file mode 100644
index 0000000..3ea9305
--- /dev/null
+++ b/src/graphicalViewNavigation.ts
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ *
+ * See the AUTHORS file(s) distributed with this work for additional
+ * information regarding authorship.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import * as vscode from 'vscode';
+import type {GraphicalViewClient} from './graphicalViewClient';
+import type {GraphicalViewResolveTargetWarning, GraphicalViewTarget} from './graphicalViewProtocol';
+
+export type GraphicalViewNavigationResolution =
+    | Readonly<{kind: 'location'; uri: vscode.Uri; range: vscode.Range}>
+    | Readonly<{kind: 'warning'; message: string}>;
+
+const RESOLVE_WARNINGS: ReadonlySet<string> = new Set([
+    'notFound',
+    'ambiguous',
+    'unsupportedUri',
+    'temporarilyUnresolvable',
+]);
+
+export async function resolveGraphicalViewNavigation(
+    client: GraphicalViewClient,
+    sourceUri: string,
+    target: Readonly<GraphicalViewTarget>,
+    token: vscode.CancellationToken,
+): Promise<GraphicalViewNavigationResolution> {
+    const response = target.kind === 'elementHeader'
+        ? await client.resolveElement({sourceUri, elementUrn: target.elementUrn}, token)
+        : await client.resolveAttribute(
+            {
+                sourceUri,
+                ownerUrn: target.ownerUrn,
+                predicateUrn: target.predicateUrn,
+                selection: target.selection,
+                ...(target.language === undefined ? {} : {language: target.language}),
+            },
+            token,
+        );
+    return validateGraphicalViewResolveResult(response);
+}
+
+export function validateGraphicalViewResolveResult(value: unknown): GraphicalViewNavigationResolution {
+    if (!isRecord(value) || !hasOnlyKeys(value, ['location', 'warning'])) {
+        return invalidLocation();
+    }
+
+    const warning = value.warning;
+    if (warning !== undefined && warning !== null && (typeof warning !== 'string' || !RESOLVE_WARNINGS.has(warning))) {
+        return invalidLocation();
+    }
+    const location = value.location;
+    if (location === undefined || location === null) {
+        return typeof warning === 'string'
+            ? {kind: 'warning', message: resolveWarningMessage(warning as GraphicalViewResolveTargetWarning)}
+            : invalidLocation();
+    }
+    if (warning !== undefined && warning !== null) {
+        return invalidLocation();
+    }
+    if (!isRecord(location) || !hasExactKeys(location, ['range', 'uri']) || typeof location.uri !== 'string') {
+        return invalidLocation();
+    }
+    const range = location.range;
+    if (!isRecord(range) || !hasExactKeys(range, ['end', 'start'])) {
+        return invalidLocation();
+    }
+    const start = validatePosition(range.start);
+    const end = validatePosition(range.end);
+    if (!start || !end || start.isAfter(end)) {
+        return invalidLocation();
+    }
+
+    try {
+        const uri = vscode.Uri.parse(location.uri, true);
+        if (uri.scheme !== 'file'
+            || uri.authority !== ''
+            || !uri.path.startsWith('/')
+            || uri.query !== ''
+            || uri.fragment !== ''
+            || uri.fsPath.includes('\0')) {
+            return {kind: 'warning', message: resolveWarningMessage('unsupportedUri')};
+        }
+        return {kind: 'location', uri, range: new vscode.Range(start, end)};
+    } catch (_error) {
+        return invalidLocation();
+    }
+}
+
+function validatePosition(value: unknown): vscode.Position | undefined {
+    if (!isRecord(value)
+        || !hasExactKeys(value, ['character', 'line'])
+        || !Number.isSafeInteger(value.line)
+        || !Number.isSafeInteger(value.character)
+        || (value.line as number) < 0
+        || (value.character as number) < 0) {
+        return undefined;
+    }
+    return new vscode.Position(value.line as number, value.character as number);
+}
+
+function invalidLocation(): GraphicalViewNavigationResolution {
+    return {kind: 'warning', message: 'The language server returned an invalid graphical target location.'};
+}
+
+function resolveWarningMessage(warning: GraphicalViewResolveTargetWarning): string {
+    switch (warning) {
+        case 'notFound':
+            return 'The graphical target no longer exists in the current model.';
+        case 'ambiguous':
+            return 'The graphical target is ambiguous in the current model.';
+        case 'unsupportedUri':
+            return 'The graphical target is not a local file and cannot be opened.';
+        case 'temporarilyUnresolvable':
+            return 'The graphical target is temporarily unavailable. Fix any model syntax errors and try again.';
+    }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null;
+}
+
+function hasOnlyKeys(value: Record<string, unknown>, allowedKeys: readonly string[]): boolean {
+    const allowed = new Set(allowedKeys);
+    return Object.keys(value).every(key => allowed.has(key));
+}
+
+function hasExactKeys(value: Record<string, unknown>, expectedKeys: readonly string[]): boolean {
+    const actualKeys = Object.keys(value).sort();
+    return actualKeys.length === expectedKeys.length && actualKeys.every((key, index) => key === expectedKeys[index]);
+}
diff --git a/src/graphicalViewPanel.ts b/src/graphicalViewPanel.ts
index e04b411..b2d4959 100644
--- a/src/graphicalViewPanel.ts
+++ b/src/graphicalViewPanel.ts
@@ -13,16 +13,47 @@
 
 import {randomBytes} from 'node:crypto';
 import * as vscode from 'vscode';
-import {GraphicalViewDelivery, GraphicalViewPanelAdapter, GraphicalViewPanelFactory} from './graphicalView';
+import {GRAPHICAL_VIEW_MARKER_PATTERN} from './graphicalViewProtocol';
 
 const VIEW_TYPE = 'turtle.graphicalView';
 export const WEBVIEW_ASSET_DIRECTORY = Object.freeze(['out', 'webview'] as const);
 export const WEBVIEW_SCRIPT_ORDER = Object.freeze(['purify.min.js', 'sanitizer-contract.js', 'webview.js'] as const);
 
+export type GraphicalViewStatus =
+    | Readonly<{kind: 'loading'; message: string}>
+    | Readonly<{kind: 'ready'; message: string}>
+    | Readonly<{kind: 'stale'; reason: string; message: string}>
+    | Readonly<{kind: 'unsupported'; message: string}>
+    | Readonly<{kind: 'disconnected'; message: string}>;
+
+export type GraphicalViewDelivery =
+    | Readonly<{type: 'status'; status: GraphicalViewStatus}>
+    | Readonly<{type: 'render'; version: number; svg: string}>;
+
+export type GraphicalViewPanelMessage =
+    | Readonly<{type: 'ready'}>
+    | Readonly<{type: 'refresh'}>
+    | Readonly<{type: 'rendered'; version: number}>
+    | Readonly<{type: 'renderError'; version: number; reason: 'sanitizationFailed'}>
+    | Readonly<{type: 'navigate'; version: number; targetId: string}>;
+
+export interface GraphicalViewPanel extends vscode.Disposable {
+    readonly visible: boolean;
+    reveal(): void;
+    deliver(delivery: GraphicalViewDelivery): void;
+    onDidDispose(listener: () => void): vscode.Disposable;
+    onDidChangeVisibility(listener: (visible: boolean) => void): vscode.Disposable;
+    onDidReceiveMessage(listener: (message: unknown) => void): vscode.Disposable;
+}
+
+export interface GraphicalViewPanelFactory {
+    create(sourceUri: string): GraphicalViewPanel;
+}
+
 export class VscodeGraphicalViewPanelFactory implements GraphicalViewPanelFactory {
     constructor(private readonly extensionUri: vscode.Uri) {}
 
-    create(sourceUri: string): GraphicalViewPanelAdapter {
+    create(sourceUri: string): GraphicalViewPanel {
         const uri = vscode.Uri.parse(sourceUri, true);
         const name = uri.path.split('/').filter(Boolean).at(-1) ?? 'Aspect Model';
         const panel = vscode.window.createWebviewPanel(
@@ -35,12 +66,12 @@ export class VscodeGraphicalViewPanelFactory implements GraphicalViewPanelFactor
     }
 }
 
-class VscodeGraphicalViewPanel implements GraphicalViewPanelAdapter {
+class VscodeGraphicalViewPanel implements GraphicalViewPanel {
     constructor(
         private readonly panel: vscode.WebviewPanel,
         extensionUri: vscode.Uri,
     ) {
-        panel.webview.html = createShellHtml(panel.webview, extensionUri);
+        panel.webview.html = createGraphicalViewShell(panel.webview, extensionUri);
     }
 
     get visible(): boolean {
@@ -85,12 +116,11 @@ export function createGraphicalViewPanelOptions(extensionUri: vscode.Uri): vscod
     };
 }
 
-export function createShellHtml(
+export function createGraphicalViewShell(
     webview: Pick<vscode.Webview, 'asWebviewUri' | 'cspSource'>,
     extensionUri: vscode.Uri,
-    nonce = randomBytes(18).toString('base64'),
-    testMode = false,
 ): string {
+    const nonce = randomBytes(18).toString('base64');
     const assetDirectory = webviewAssetDirectory(extensionUri);
     const stylesheetUri = webview.asWebviewUri(vscode.Uri.joinPath(assetDirectory, 'webview.css'));
     const scriptUris = WEBVIEW_SCRIPT_ORDER.map(asset => webview.asWebviewUri(vscode.Uri.joinPath(assetDirectory, asset)));
@@ -107,7 +137,7 @@ export function createShellHtml(
     ].join('; ');
 
     return `<!DOCTYPE html>
-<html lang="en"${testMode ? ' data-test-mode="true"' : ''}>
+<html lang="en">
 <head>
     <meta charset="UTF-8">
     <meta http-equiv="Content-Security-Policy" content="${csp}">
@@ -134,3 +164,44 @@ export function createShellHtml(
 </body>
 </html>`;
 }
+
+export function parseGraphicalViewPanelMessage(value: unknown): GraphicalViewPanelMessage | undefined {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const keys = Object.keys(value).sort();
+    if ((value.type === 'ready' || value.type === 'refresh') && keys.length === 1) {
+        return value as {type: 'ready'} | {type: 'refresh'};
+    }
+    if (value.type === 'rendered'
+        && hasExactKeys(keys, ['type', 'version'])
+        && isDisplayedVersion(value.version)) {
+        return value as {type: 'rendered'; version: number};
+    }
+    if (value.type === 'renderError'
+        && hasExactKeys(keys, ['reason', 'type', 'version'])
+        && value.reason === 'sanitizationFailed'
+        && isDisplayedVersion(value.version)) {
+        return value as {type: 'renderError'; version: number; reason: 'sanitizationFailed'};
+    }
+    if (value.type === 'navigate'
+        && hasExactKeys(keys, ['targetId', 'type', 'version'])
+        && isDisplayedVersion(value.version)
+        && typeof value.targetId === 'string'
+        && GRAPHICAL_VIEW_MARKER_PATTERN.test(value.targetId)) {
+        return value as {type: 'navigate'; version: number; targetId: string};
+    }
+    return undefined;
+}
+
+function isDisplayedVersion(value: unknown): value is number {
+    return Number.isSafeInteger(value) && (value as number) > 0;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null;
+}
+
+function hasExactKeys(actualKeys: readonly string[], expectedKeys: readonly string[]): boolean {
+    return actualKeys.length === expectedKeys.length && actualKeys.every((key, index) => key === expectedKeys[index]);
+}
diff --git a/src/graphicalViewProtocol.ts b/src/graphicalViewProtocol.ts
index 168f06c..cb547ec 100644
--- a/src/graphicalViewProtocol.ts
+++ b/src/graphicalViewProtocol.ts
@@ -11,8 +11,6 @@
  * SPDX-License-Identifier: MPL-2.0
  */
 
-import type * as vscode from 'vscode';
-
 export const GRAPHICAL_VIEW_RENDER_REQUEST = 'turtle/graphicalView/render';
 export const GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST = 'turtle/graphicalView/resolveTarget';
 export const GRAPHICAL_VIEW_RESOLVE_ATTRIBUTE_TARGET_REQUEST = 'turtle/graphicalView/resolveAttributeTarget';
@@ -90,127 +88,3 @@ export interface GraphicalViewResolveAttributeTargetParams {
 }
 
 export type GraphicalViewResolveAttributeTargetResult = GraphicalViewResolveTargetResult;
-
-export interface GraphicalViewRequestClient {
-    isGraphicalViewAvailable(): boolean;
-    onDidChangeGraphicalViewAvailability(listener: (available: boolean) => void): vscode.Disposable;
-    renderGraphicalView(params: GraphicalViewRenderParams, token: vscode.CancellationToken): Thenable<GraphicalViewRenderResult>;
-    resolveGraphicalViewTarget(
-        params: GraphicalViewResolveTargetParams,
-        token?: vscode.CancellationToken,
-    ): Thenable<GraphicalViewResolveTargetResult>;
-    resolveGraphicalViewAttributeTarget(
-        params: GraphicalViewResolveAttributeTargetParams,
-        token?: vscode.CancellationToken,
-    ): Thenable<GraphicalViewResolveAttributeTargetResult>;
-}
-
-const RENDER_WARNINGS: ReadonlySet<string> = new Set([
-    'unsupportedUri',
-    'missingDocument',
-    'modelTooLarge',
-    'timeout',
-    'temporarilyUnresolvable',
-]);
-const ASPECT_MODEL_URN_PATTERN = /^urn:samm:[^\s#]+#[^\s#]+$/;
-const LANGUAGE_PATTERN = /^[a-z]{2,8}(?:-[a-z0-9]{1,8})*$/;
-const SVG_ID_PATTERN = /\bid\s*=\s*(["'])([^"']+)\1/g;
-const GRAPHPER_DESCENDANT_PATTERN = /^gv-(?:header|attribute)-[a-z0-9]{16,32}_(?:polygon|text_0)$/;
-
-export function isGraphicalViewRenderResult(value: unknown): value is GraphicalViewRenderResult {
-    if (!isRecord(value) || typeof value.uri !== 'string' || !Array.isArray(value.targets) || !Array.isArray(value.warnings)) {
-        return false;
-    }
-
-    const allowedResultKeys = value.svg === undefined ? ['targets', 'uri', 'warnings'] : ['svg', 'targets', 'uri', 'warnings'];
-    if (!hasExactKeys(value, allowedResultKeys)) {
-        return false;
-    }
-
-    if (value.svg !== undefined && value.svg !== null && typeof value.svg !== 'string') {
-        return false;
-    }
-
-    if (!value.warnings.every(warning => typeof warning === 'string' && RENDER_WARNINGS.has(warning))) {
-        return false;
-    }
-
-    if (!value.targets.every(isGraphicalViewTarget)) {
-        return false;
-    }
-
-    if (value.svg === undefined || value.svg === null) {
-        return value.targets.length === 0 && value.warnings.length > 0;
-    }
-
-    return value.svg.trim().length > 0 && hasConsistentSidecar(value.svg, value.targets);
-}
-
-function isGraphicalViewTarget(value: unknown): value is GraphicalViewTarget {
-    if (!isRecord(value) || typeof value.id !== 'string') {
-        return false;
-    }
-    if (value.kind === 'elementHeader') {
-        return hasExactKeys(value, ['elementUrn', 'id', 'kind'])
-            && GRAPHICAL_VIEW_HEADER_MARKER_PATTERN.test(value.id)
-            && typeof value.elementUrn === 'string'
-            && ASPECT_MODEL_URN_PATTERN.test(value.elementUrn);
-    }
-    if (value.kind !== 'attributeRow') {
-        return false;
-    }
-    const expectedKeys = value.language === undefined
-        ? ['id', 'kind', 'ownerUrn', 'predicateUrn', 'selection']
-        : ['id', 'kind', 'language', 'ownerUrn', 'predicateUrn', 'selection'];
-    return hasExactKeys(value, expectedKeys)
-        && GRAPHICAL_VIEW_ATTRIBUTE_MARKER_PATTERN.test(value.id)
-        && typeof value.ownerUrn === 'string'
-        && ASPECT_MODEL_URN_PATTERN.test(value.ownerUrn)
-        && typeof value.predicateUrn === 'string'
-        && ASPECT_MODEL_URN_PATTERN.test(value.predicateUrn)
-        && (value.selection === 'singleOccurrence' || value.selection === 'predicateStart')
-        && (value.language === undefined
-            || (value.selection === 'singleOccurrence'
-                && typeof value.language === 'string'
-                && LANGUAGE_PATTERN.test(value.language)));
-}
-
-function hasConsistentSidecar(svg: string, targets: GraphicalViewTarget[]): boolean {
-    const targetIds = new Set<string>();
-    for (const target of targets) {
-        if (targetIds.has(target.id)) {
-            return false;
-        }
-        targetIds.add(target.id);
-    }
-
-    const svgIds = new Set<string>();
-    for (const match of svg.matchAll(SVG_ID_PATTERN)) {
-        const id = match[2];
-        if (GRAPHPER_DESCENDANT_PATTERN.test(id)) {
-            continue;
-        }
-        if (!id.startsWith('gv-header-') && !id.startsWith('gv-attribute-')) {
-            continue;
-        }
-        if (!GRAPHICAL_VIEW_MARKER_PATTERN.test(id)) {
-            return false;
-        }
-        if (svgIds.has(id)) {
-            return false;
-        }
-        svgIds.add(id);
-    }
-
-    return targetIds.size === svgIds.size && [...targetIds].every(id => svgIds.has(id));
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-    return typeof value === 'object' && value !== null;
-}
-
-function hasExactKeys(value: Record<string, unknown>, expectedKeys: readonly string[]): boolean {
-    const actualKeys = Object.keys(value).sort();
-    const expected = [...expectedKeys].sort();
-    return actualKeys.length === expected.length && actualKeys.every((key, index) => key === expected[index]);
-}
diff --git a/src/graphicalViewResult.ts b/src/graphicalViewResult.ts
new file mode 100644
index 0000000..4c25d86
--- /dev/null
+++ b/src/graphicalViewResult.ts
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ *
+ * See the AUTHORS file(s) distributed with this work for additional
+ * information regarding authorship.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import {
+    GRAPHICAL_VIEW_ATTRIBUTE_MARKER_PATTERN,
+    GRAPHICAL_VIEW_HEADER_MARKER_PATTERN,
+    GRAPHICAL_VIEW_MARKER_PATTERN,
+    GraphicalViewRenderResult,
+    GraphicalViewRenderWarning,
+    GraphicalViewTarget,
+} from './graphicalViewProtocol';
+
+export interface AcceptedGraphicalViewResult {
+    readonly version: number;
+    readonly uri: string;
+    readonly svg: string;
+    readonly targets: readonly Readonly<GraphicalViewTarget>[];
+    readonly warnings: readonly GraphicalViewRenderWarning[];
+    readonly targetById: ReadonlyMap<string, Readonly<GraphicalViewTarget>>;
+    readonly attributeRowsAvailable: boolean;
+}
+
+const RENDER_WARNINGS: ReadonlySet<string> = new Set([
+    'unsupportedUri',
+    'missingDocument',
+    'modelTooLarge',
+    'timeout',
+    'temporarilyUnresolvable',
+]);
+const ASPECT_MODEL_URN_PATTERN = /^urn:samm:[^\s#]+#[^\s#]+$/;
+const LANGUAGE_PATTERN = /^[a-z]{2,8}(?:-[a-z0-9]{1,8})*$/;
+const SVG_ID_PATTERN = /\bid\s*=\s*(["'])([^"']+)\1/g;
+const GRAPHPER_DESCENDANT_PATTERN = /^gv-(?:header|attribute)-[a-z0-9]{16,32}_(?:polygon|text_0)$/;
+
+export function isGraphicalViewRenderResult(value: unknown): value is GraphicalViewRenderResult {
+    if (!isRecord(value) || typeof value.uri !== 'string' || !Array.isArray(value.targets) || !Array.isArray(value.warnings)) {
+        return false;
+    }
+
+    const allowedResultKeys = value.svg === undefined ? ['targets', 'uri', 'warnings'] : ['svg', 'targets', 'uri', 'warnings'];
+    if (!hasExactKeys(value, allowedResultKeys)) {
+        return false;
+    }
+    if (value.svg !== undefined && value.svg !== null && typeof value.svg !== 'string') {
+        return false;
+    }
+    if (!value.warnings.every(warning => typeof warning === 'string' && RENDER_WARNINGS.has(warning))) {
+        return false;
+    }
+    if (!value.targets.every(isGraphicalViewTarget)) {
+        return false;
+    }
+    if (value.svg === undefined || value.svg === null) {
+        return value.targets.length === 0 && value.warnings.length > 0;
+    }
+    return value.svg.trim().length > 0 && hasConsistentSidecar(value.svg, value.targets);
+}
+
+export function acceptGraphicalViewResult(
+    result: GraphicalViewRenderResult,
+    version: number,
+    attributeRowsAvailable: boolean,
+): AcceptedGraphicalViewResult {
+    if (result.svg === undefined || result.svg === null) {
+        throw new Error('A successful graphical-view result requires SVG content.');
+    }
+    const targets = Object.freeze(result.targets.map(target => Object.freeze({...target})));
+    const warnings = Object.freeze([...result.warnings]);
+    const targetById = new ImmutableMap(targets.map(target => [target.id, target] as const));
+    return Object.freeze({
+        version,
+        uri: result.uri,
+        svg: result.svg,
+        targets,
+        warnings,
+        targetById,
+        attributeRowsAvailable,
+    });
+}
+
+class ImmutableMap<K, V> implements ReadonlyMap<K, V> {
+    private readonly valuesByKey: Map<K, V>;
+
+    constructor(entries: readonly (readonly [K, V])[]) {
+        this.valuesByKey = new Map(entries);
+        Object.freeze(this);
+    }
+
+    get size(): number {
+        return this.valuesByKey.size;
+    }
+
+    get(key: K): V | undefined {
+        return this.valuesByKey.get(key);
+    }
+
+    has(key: K): boolean {
+        return this.valuesByKey.has(key);
+    }
+
+    forEach(callback: (value: V, key: K, map: ReadonlyMap<K, V>) => void, thisArg?: unknown): void {
+        this.valuesByKey.forEach((value, key) => callback.call(thisArg, value, key, this));
+    }
+
+    entries(): MapIterator<[K, V]> {
+        return this.valuesByKey.entries();
+    }
+
+    keys(): MapIterator<K> {
+        return this.valuesByKey.keys();
+    }
+
+    values(): MapIterator<V> {
+        return this.valuesByKey.values();
+    }
+
+    [Symbol.iterator](): MapIterator<[K, V]> {
+        return this.entries();
+    }
+
+    get [Symbol.toStringTag](): string {
+        return 'ImmutableMap';
+    }
+}
+
+function isGraphicalViewTarget(value: unknown): value is GraphicalViewTarget {
+    if (!isRecord(value) || typeof value.id !== 'string') {
+        return false;
+    }
+    if (value.kind === 'elementHeader') {
+        return hasExactKeys(value, ['elementUrn', 'id', 'kind'])
+            && GRAPHICAL_VIEW_HEADER_MARKER_PATTERN.test(value.id)
+            && typeof value.elementUrn === 'string'
+            && ASPECT_MODEL_URN_PATTERN.test(value.elementUrn);
+    }
+    if (value.kind !== 'attributeRow') {
+        return false;
+    }
+    const expectedKeys = value.language === undefined
+        ? ['id', 'kind', 'ownerUrn', 'predicateUrn', 'selection']
+        : ['id', 'kind', 'language', 'ownerUrn', 'predicateUrn', 'selection'];
+    return hasExactKeys(value, expectedKeys)
+        && GRAPHICAL_VIEW_ATTRIBUTE_MARKER_PATTERN.test(value.id)
+        && typeof value.ownerUrn === 'string'
+        && ASPECT_MODEL_URN_PATTERN.test(value.ownerUrn)
+        && typeof value.predicateUrn === 'string'
+        && ASPECT_MODEL_URN_PATTERN.test(value.predicateUrn)
+        && (value.selection === 'singleOccurrence' || value.selection === 'predicateStart')
+        && (value.language === undefined
+            || (value.selection === 'singleOccurrence'
+                && typeof value.language === 'string'
+                && LANGUAGE_PATTERN.test(value.language)));
+}
+
+function hasConsistentSidecar(svg: string, targets: GraphicalViewTarget[]): boolean {
+    const targetIds = new Set<string>();
+    for (const target of targets) {
+        if (targetIds.has(target.id)) {
+            return false;
+        }
+        targetIds.add(target.id);
+    }
+
+    const svgIds = new Set<string>();
+    for (const match of svg.matchAll(SVG_ID_PATTERN)) {
+        const id = match[2];
+        if (GRAPHPER_DESCENDANT_PATTERN.test(id)) {
+            continue;
+        }
+        if (!id.startsWith('gv-header-') && !id.startsWith('gv-attribute-')) {
+            continue;
+        }
+        if (!GRAPHICAL_VIEW_MARKER_PATTERN.test(id) || svgIds.has(id)) {
+            return false;
+        }
+        svgIds.add(id);
+    }
+
+    return targetIds.size === svgIds.size && [...targetIds].every(id => svgIds.has(id));
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null;
+}
+
+function hasExactKeys(value: Record<string, unknown>, expectedKeys: readonly string[]): boolean {
+    const actualKeys = Object.keys(value).sort();
+    const expected = [...expectedKeys].sort();
+    return actualKeys.length === expected.length && actualKeys.every((key, index) => key === expected[index]);
+}
diff --git a/src/languageClient.ts b/src/languageClient.ts
index 2f6c2a1..be4c242 100644
--- a/src/languageClient.ts
+++ b/src/languageClient.ts
@@ -14,50 +14,29 @@
 import { Trace } from 'vscode-jsonrpc';
 import * as net from 'node:net';
 import * as vscode from 'vscode';
-import {LanguageClient, LanguageClientOptions, State, StateChangeEvent, StreamInfo} from 'vscode-languageclient/node';
+import {LanguageClient, LanguageClientOptions, State, StreamInfo} from 'vscode-languageclient/node';
 import type { RequestClient } from './aspectValidation';
-import {
-    GRAPHICAL_VIEW_RENDER_REQUEST,
-    GRAPHICAL_VIEW_RESOLVE_ATTRIBUTE_TARGET_REQUEST,
-    GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST,
-    GraphicalViewRenderParams,
-    GraphicalViewRenderResult,
-    GraphicalViewRequestClient,
-    GraphicalViewResolveAttributeTargetParams,
-    GraphicalViewResolveAttributeTargetResult,
-    GraphicalViewResolveTargetParams,
-    GraphicalViewResolveTargetResult,
-} from './graphicalViewProtocol';
+import type {GraphicalViewRequestTransport} from './graphicalViewClient';
 import type { ExtensionLogger } from './outputChannel';
 
 const CLIENT_START_TIMEOUT_MS = 5000;
 
-export interface LanguageClientAdapter {
-    readonly state: State;
-    setTrace(value: Trace): void;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    onDidChangeState(listener: (event: StateChangeEvent) => void): vscode.Disposable;
-    sendRequest<R>(method: string, params?: unknown, token?: vscode.CancellationToken): Promise<R>;
-}
-
-export class TurtleLanguageClient implements RequestClient, GraphicalViewRequestClient {
-    private client: LanguageClientAdapter;
-    private readonly graphicalViewAvailability = new vscode.EventEmitter<boolean>();
-    private lastGraphicalViewAvailability = false;
+export class TurtleLanguageClient implements RequestClient, GraphicalViewRequestTransport {
+    private readonly client: LanguageClient;
+    private readonly availability = new vscode.EventEmitter<boolean>();
+    private lastAvailability = false;
 
     constructor(
         private outputChannel: ExtensionLogger,
         private readonly serverPort: number,
         private readonly traceLevel: 'off' | 'messages' | 'verbose' = 'off',
-        clientFactory?: () => LanguageClientAdapter,
     ) {
-        this.client = clientFactory ? clientFactory() : this.initLanguageClient(this.serverPort);
+        this.client = this.initLanguageClient(this.serverPort);
         this.client.onDidChangeState(event => {
             const available = event.newState === State.Running;
-            if (available !== this.lastGraphicalViewAvailability) {
-                this.lastGraphicalViewAvailability = available;
-                this.graphicalViewAvailability.fire(available);
+            if (available !== this.lastAvailability) {
+                this.lastAvailability = available;
+                this.availability.fire(available);
             }
         });
     }
@@ -70,7 +49,7 @@ export class TurtleLanguageClient implements RequestClient, GraphicalViewRequest
         }
     }
 
-    private initLanguageClient(serverPort: number): LanguageClientAdapter {
+    private initLanguageClient(serverPort: number): LanguageClient {
         const serverOptions = async (): Promise<StreamInfo> => new Promise((resolve, reject) => {
             const socket = net.connect({ host: '127.0.0.1', port: serverPort }, () => {
                 resolve({ reader: socket, writer: socket });
@@ -139,34 +118,12 @@ export class TurtleLanguageClient implements RequestClient, GraphicalViewRequest
         return this.client.sendRequest<R>(method, params, token) as Promise<R>;
     }
 
-    isGraphicalViewAvailable(): boolean {
+    isAvailable(): boolean {
         return this.client.state === State.Running;
     }
 
-    onDidChangeGraphicalViewAvailability(listener: (available: boolean) => void): vscode.Disposable {
-        return this.graphicalViewAvailability.event(listener);
-    }
-
-    renderGraphicalView(params: GraphicalViewRenderParams, token: vscode.CancellationToken): Promise<GraphicalViewRenderResult> {
-        return this.sendRequest<GraphicalViewRenderResult>(GRAPHICAL_VIEW_RENDER_REQUEST, params, token);
-    }
-
-    resolveGraphicalViewTarget(
-        params: GraphicalViewResolveTargetParams,
-        token?: vscode.CancellationToken,
-    ): Promise<GraphicalViewResolveTargetResult> {
-        return this.sendRequest<GraphicalViewResolveTargetResult>(GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST, params, token);
-    }
-
-    resolveGraphicalViewAttributeTarget(
-        params: GraphicalViewResolveAttributeTargetParams,
-        token?: vscode.CancellationToken,
-    ): Promise<GraphicalViewResolveAttributeTargetResult> {
-        return this.sendRequest<GraphicalViewResolveAttributeTargetResult>(
-            GRAPHICAL_VIEW_RESOLVE_ATTRIBUTE_TARGET_REQUEST,
-            params,
-            token,
-        );
+    onDidChangeAvailability(listener: (available: boolean) => void): vscode.Disposable {
+        return this.availability.event(listener);
     }
 
 }
diff --git a/src/test/graphicalViewController.test.ts b/src/test/graphicalViewController.test.ts
index f814724..91b5c65 100644
--- a/src/test/graphicalViewController.test.ts
+++ b/src/test/graphicalViewController.test.ts
@@ -12,717 +12,266 @@
  */
 
 import * as assert from 'node:assert/strict';
-import {readFileSync} from 'node:fs';
-import {join} from 'node:path';
-import * as vscode from 'vscode';
 import {OPEN_GRAPHICAL_VIEW_COMMAND} from '../graphicalView';
-import {GraphicalViewRenderResult} from '../graphicalViewProtocol';
 import {
     FakeGraphicalViewClient,
     createGraphicalViewDocument,
     createGraphicalViewHarness,
     flushPromises,
+    lastStatus,
+    openGraphicalView,
+    renderDeliveries,
     successfulResult,
 } from './graphicalViewTestHarness';
 
-suite('GraphicalViewController', () => {
-    test('contributes the guarded Turtle editor command', () => {
-        const manifest = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf8')) as {
-            contributes: {commands: Array<Record<string, string>>; menus: {'editor/context': Array<Record<string, string>>}};
-        };
-        const command = manifest.contributes.commands.find(candidate => candidate.command === OPEN_GRAPHICAL_VIEW_COMMAND);
-        const menu = manifest.contributes.menus['editor/context'].find(candidate => candidate.command === OPEN_GRAPHICAL_VIEW_COMMAND);
-        assert.equal(command?.enablement, 'editorLangId == turtle');
-        assert.equal(menu?.when, 'resourceLangId == turtle');
-    });
-
-    test('guards absent and non-Turtle active editors without a panel or request', async () => {
+suite('GraphicalViewController lifecycle', () => {
+    test('guards absent and non-Turtle active editors without creating a panel or request', async () => {
         const harness = createGraphicalViewHarness();
         await harness.commands.execute(OPEN_GRAPHICAL_VIEW_COMMAND);
         harness.window.activeTextEditor = {document: createGraphicalViewDocument('/tmp/not-turtle.txt', 'plaintext')};
         await harness.commands.execute(OPEN_GRAPHICAL_VIEW_COMMAND);
+
         assert.equal(harness.window.warnings.length, 2);
         assert.equal(harness.panels.panels.length, 0);
         assert.equal(harness.client.requests.length, 0);
         harness.controller.dispose();
     });
 
-    test('creates one panel and performs the initial typed render', async () => {
-        const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/initial.ttl');
-        harness.window.activeTextEditor = {document};
-        await harness.commands.execute(OPEN_GRAPHICAL_VIEW_COMMAND);
-        assert.equal(harness.panels.panels.length, 1);
-        assert.deepEqual(harness.client.requests[0].params, {uri: document.uri.toString(), includeAttributeRows: true});
-        assert.equal(harness.controller.getPanelState(document.uri.toString())?.sequence, 1);
-
-        harness.client.requests[0].deferred.resolve(successfulResult(document));
-        await flushPromises();
-        const state = harness.controller.getPanelState(document.uri.toString());
-        assert.equal(state?.status.kind, 'ready');
-        assert.equal(state?.lastSuccess?.svg, successfulResult(document).svg);
-        assert.equal(state?.lastSuccess?.targetById.size, 1);
-        harness.controller.dispose();
-    });
-
-    test('reveals one panel per URI and keeps different URI panels independent', async () => {
+    test('creates one panel per canonical URI and renders only on first creation', async () => {
         const harness = createGraphicalViewHarness();
         const first = track(harness, '/tmp/first.ttl');
         const second = track(harness, '/tmp/second.ttl');
-        await harness.controller.openGraphicalView(first);
-        await harness.controller.openGraphicalView(first);
-        assert.equal(harness.panels.panels.length, 1);
-        assert.equal(harness.panels.panels[0].revealCount, 1);
-        assert.equal(harness.client.requests.length, 1);
 
-        await harness.controller.openGraphicalView(second);
-        assert.equal(harness.controller.getPanelCount(), 2);
+        await openGraphicalView(harness, first);
+        await openGraphicalView(harness, first);
+        await openGraphicalView(harness, second);
+
+        assert.equal(harness.panels.panels.length, 2);
+        assert.equal(harness.panels.panels[0].revealCount, 1);
         assert.equal(harness.client.requests.length, 2);
-        assert.equal(harness.client.requests[1].params.uri, second.uri.toString());
+        assert.deepEqual(harness.client.requests.map(request => request.params), [
+            {uri: first.uri.toString(), includeAttributeRows: true},
+            {uri: second.uri.toString(), includeAttributeRows: true},
+        ]);
         harness.controller.dispose();
     });
 
-    test('renders on manual Refresh and visible bound-main Save only', async () => {
+    test('renders on visible Refresh and bound-main Save but not imported Save or reveal', async () => {
         const harness = createGraphicalViewHarness();
         const main = track(harness, '/tmp/main.ttl');
         const imported = track(harness, '/tmp/import.ttl');
-        await harness.controller.openGraphicalView(main);
-        harness.panels.panels[0].emitMessage({type: 'refresh'});
-        assert.equal(harness.client.requests.length, 2);
-        assert.equal(harness.client.requests[0].token.isCancellationRequested, true);
+        await openGraphicalView(harness, main);
 
+        harness.panels.panels[0].emitMessage({type: 'refresh'});
         harness.workspace.fireSave(imported);
-        assert.equal(harness.client.requests.length, 2);
+        await openGraphicalView(harness, main);
         harness.workspace.fireSave(main);
+
         assert.equal(harness.client.requests.length, 3);
+        assert.equal(harness.client.requests[0].token.isCancellationRequested, true);
         assert.equal(harness.client.requests[1].token.isCancellationRequested, true);
         harness.controller.dispose();
     });
 
-    test('hidden Save invalidates pending work; typing and reveal do not render', async () => {
+    test('hidden main Save invalidates pending work and ready rehydrates without rendering', async () => {
         const harness = createGraphicalViewHarness();
-        const main = track(harness, '/tmp/hidden.ttl');
-        await harness.controller.openGraphicalView(main);
-        harness.client.requests[0].deferred.resolve(successfulResult(main));
+        const document = track(harness, '/tmp/hidden.ttl');
+        await openGraphicalView(harness, document);
+        harness.client.requests[0].deferred.resolve(successfulResult(document));
         await flushPromises();
+
         const panel = harness.panels.panels[0];
         panel.emitMessage({type: 'refresh'});
         const pending = harness.client.requests[1];
         panel.setVisible(false);
+        harness.workspace.fireSave(document);
         panel.emitMessage({type: 'refresh'});
-        assert.equal(harness.client.requests.length, 2);
-        const before = harness.controller.getPanelState(main.uri.toString())?.sequence;
-        harness.workspace.fireSave(main);
-        assert.equal(harness.client.requests.length, 2);
-        assert.equal(pending.token.isCancellationRequested, true);
-        assert.equal(harness.controller.getPanelState(main.uri.toString())?.sequence, (before ?? 0) + 1);
-        assert.equal(harness.controller.getPanelState(main.uri.toString())?.status.kind, 'ready');
-        assert.ok(harness.controller.getPanelState(main.uri.toString())?.lastSuccess);
-
         panel.setVisible(true);
+        const deliveriesBeforeReady = renderDeliveries(panel).length;
         panel.emitMessage({type: 'ready'});
-        panel.emitMessage({type: 'navigate', targetId: 'gv-header-0123456789abcdef'});
+
         assert.equal(harness.client.requests.length, 2);
+        assert.equal(pending.token.isCancellationRequested, true);
+        assert.equal(renderDeliveries(panel).length, deliveriesBeforeReady + 1);
+        assert.equal(renderDeliveries(panel).at(-1)?.svg, successfulResult(document).svg);
+        assert.equal(lastStatus(panel)?.kind, 'ready');
         harness.controller.dispose();
     });
 
-    test('source editor closure invalidates pending work and ignores its late failure', async () => {
+    test('source closure preserves the panel and last result while invalidating late work', async () => {
         const harness = createGraphicalViewHarness();
         const document = track(harness, '/tmp/closed.ttl');
-        await harness.controller.openGraphicalView(document);
+        await openGraphicalView(harness, document);
         harness.client.requests[0].deferred.resolve(successfulResult(document));
         await flushPromises();
-        const retained = harness.controller.getPanelState(document.uri.toString())?.lastSuccess;
-        harness.panels.panels[0].emitMessage({type: 'refresh'});
+        const panel = harness.panels.panels[0];
+        panel.emitMessage({type: 'refresh'});
         const pending = harness.client.requests[1];
-        const sequence = harness.controller.getPanelState(document.uri.toString())?.sequence ?? 0;
 
         harness.workspace.closeSourceEditor(document);
-        assert.equal(harness.controller.getPanelCount(), 1);
-        assert.equal(harness.client.requests.length, 2);
-        assert.equal(pending.token.isCancellationRequested, true);
-        assert.equal(harness.controller.getPanelState(document.uri.toString())?.sequence, sequence + 1);
-        assert.equal(harness.controller.getPanelState(document.uri.toString())?.lastSuccess, retained);
-
         pending.deferred.reject(new Error('late transport failure'));
         await flushPromises();
-        const state = harness.controller.getPanelState(document.uri.toString());
-        assert.equal(state?.status.kind, 'ready');
-        assert.equal(state?.lastSuccess, retained);
-        harness.controller.dispose();
-    });
-
-    test('bound-source loss invalidates pending work and ignores its late success', async () => {
-        const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/lost.ttl');
-        await harness.controller.openGraphicalView(document);
-        const retainedResult = successfulResult(document, 'aaaaaaaaaaaaaaaa');
-        harness.client.requests[0].deferred.resolve(retainedResult);
-        await flushPromises();
-        const retained = harness.controller.getPanelState(document.uri.toString())?.lastSuccess;
+        panel.emitMessage({type: 'ready'});
 
-        harness.panels.panels[0].emitMessage({type: 'refresh'});
-        const pending = harness.client.requests[1];
-        const sequence = harness.controller.getPanelState(document.uri.toString())?.sequence ?? 0;
-        harness.workspace.loseDocument(document);
-        assert.equal(harness.client.requests.length, 2);
+        assert.equal(harness.panels.panels.length, 1);
         assert.equal(pending.token.isCancellationRequested, true);
-        assert.equal(harness.controller.getPanelState(document.uri.toString())?.sequence, sequence + 1);
-
-        pending.deferred.resolve(successfulResult(document, 'bbbbbbbbbbbbbbbb'));
-        await flushPromises();
-        const state = harness.controller.getPanelState(document.uri.toString());
-        assert.equal(state?.status.kind, 'ready');
-        assert.equal(state?.lastSuccess, retained);
-        assert.equal(state?.lastSuccess?.svg, retainedResult.svg);
+        assert.equal(renderDeliveries(panel).at(-1)?.svg, successfulResult(document).svg);
+        assert.equal(lastStatus(panel)?.kind, 'ready');
         harness.controller.dispose();
     });
 
-    test('cancels superseded work and rejects obsolete success and failure completions', async () => {
+    test('accepts only the newest request and discards obsolete success and failure completions', async () => {
         const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/sequence.ttl');
-        await harness.controller.openGraphicalView(document);
+        const document = track(harness, '/tmp/latest.ttl');
+        await openGraphicalView(harness, document);
         const first = harness.client.requests[0];
         harness.panels.panels[0].emitMessage({type: 'refresh'});
         const second = harness.client.requests[1];
-        assert.equal(first.token.isCancellationRequested, true);
-
-        second.deferred.resolve(successfulResult(document, '1111111111111111'));
-        await flushPromises();
-        first.deferred.resolve(successfulResult(document, '2222222222222222'));
-        await flushPromises();
-        assert.match(harness.controller.getPanelState(document.uri.toString())?.lastSuccess?.svg ?? '', /1111111111111111/);
-
-        harness.panels.panels[0].emitMessage({type: 'refresh'});
-        const obsoleteFailure = harness.client.requests[2];
         harness.panels.panels[0].emitMessage({type: 'refresh'});
-        const newest = harness.client.requests[3];
-        obsoleteFailure.deferred.reject(new Error('obsolete transport failure'));
-        await flushPromises();
-        assert.equal(harness.controller.getPanelState(document.uri.toString())?.status.kind, 'loading');
-        newest.deferred.resolve(successfulResult(document, '3333333333333333'));
-        await flushPromises();
-        assert.match(harness.controller.getPanelState(document.uri.toString())?.lastSuccess?.svg ?? '', /3333333333333333/);
-        harness.controller.dispose();
-    });
+        const third = harness.client.requests[2];
 
-    test('rejects URI mismatches and malformed, duplicate, invalid-marker, and inconsistent sidecars', async () => {
-        const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/validation.ttl');
-        await harness.controller.openGraphicalView(document);
-        const good = successfulResult(document);
-        harness.client.requests[0].deferred.resolve(good);
+        second.deferred.reject(new Error('obsolete failure'));
+        first.deferred.resolve(successfulResult(document, '1111111111111111'));
+        third.deferred.resolve(successfulResult(document, '3333333333333333'));
         await flushPromises();
 
-        const invalidResults: GraphicalViewRenderResult[] = [
-            {...good, uri: 'file:///tmp/other.ttl'},
-            {...good, targets: [...good.targets, good.targets[0]]},
-            {...good, targets: [{...good.targets[0], id: 'bad-marker'}]},
-            {...good, targets: [{...good.targets[0], kind: 'notHeader' as 'elementHeader'}]},
-            {...good, targets: [{...good.targets[0], elementUrn: 'not-a-urn'}]},
-            {...good, svg: '<svg></svg>'},
-            {...good, targets: [{...good.targets[0], extra: 'rejected'}] as never},
-            {...good, svg: `${good.svg}<g id="gv-attribute-BAD"></g>`},
-        ];
-
-        for (const invalid of invalidResults) {
-            harness.panels.panels[0].emitMessage({type: 'refresh'});
-            harness.client.requests.at(-1)?.deferred.resolve(invalid);
-            await flushPromises();
-            const state = harness.controller.getPanelState(document.uri.toString());
-            assert.equal(state?.status.kind, 'stale');
-            assert.equal(state?.lastSuccess?.svg, good.svg);
-            const retainedTarget = state?.lastSuccess?.targetById.get(good.targets[0].id);
-            assert.equal(retainedTarget?.kind, 'elementHeader');
-            assert.equal(retainedTarget?.kind === 'elementHeader' ? retainedTarget.elementUrn : undefined, good.targets[0].elementUrn);
-        }
+        const renders = renderDeliveries(harness.panels.panels[0]);
+        assert.equal(renders.length, 1);
+        assert.match(renders[0].svg, /3333333333333333/);
+        assert.equal(lastStatus(harness.panels.panels[0])?.kind, 'ready');
         harness.controller.dispose();
     });
 
-    test('installs SVG and sidecar atomically and retains them for all failure classes', async () => {
+    test('rejects a URI mismatch without replacing the retained result', async () => {
         const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/retention.ttl');
-        await harness.controller.openGraphicalView(document);
-        const accepted = successfulResult(document, 'aaaaaaaaaaaaaaaa');
-        harness.client.requests[0].deferred.resolve(accepted);
-        await flushPromises();
-        assert.equal(harness.controller.getPanelState(document.uri.toString())?.lastSuccess?.targetById.has(accepted.targets[0].id), true);
-
-        const failures: Array<GraphicalViewRenderResult | Error> = [
-            {uri: document.uri.toString(), svg: null, targets: [], warnings: ['temporarilyUnresolvable']},
-            {uri: document.uri.toString(), targets: [], warnings: ['timeout']},
-            {uri: document.uri.toString(), svg: null, targets: [], warnings: ['modelTooLarge']},
-            new Error('transport socket closed'),
-            new Error('generic failure'),
-        ];
-        for (const failure of failures) {
-            harness.panels.panels[0].emitMessage({type: 'refresh'});
-            const request = harness.client.requests.at(-1);
-            if (failure instanceof Error) {
-                request?.deferred.reject(failure);
-            } else {
-                request?.deferred.resolve(failure);
-            }
-            await flushPromises();
-            const state = harness.controller.getPanelState(document.uri.toString());
-            assert.equal(state?.status.kind, 'stale');
-            assert.equal(state?.lastSuccess?.svg, accepted.svg);
-            assert.equal(state?.lastSuccess?.targetById.has(accepted.targets[0].id), true);
-        }
-        harness.controller.dispose();
-    });
-
-    test('commits a sidecar only after secure render confirmation and retains last-good state on render rejection', async () => {
-        const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/secure-render.ttl');
-        await harness.controller.openGraphicalView(document);
-        const first = successfulResult(document, 'aaaaaaaaaaaaaaaa');
-        harness.client.requests[0].deferred.resolve(first);
+        const document = track(harness, '/tmp/uri-mismatch.ttl');
+        await openGraphicalView(harness, document);
+        harness.client.requests[0].deferred.resolve(successfulResult(document));
         await flushPromises();
-        const retained = harness.controller.getPanelState(document.uri.toString())?.lastSuccess;
-        assert.equal(retained?.version, 1);
-
-        const panel = harness.panels.panels[0];
-        panel.renderOutcome = 'failure';
-        panel.emitMessage({type: 'refresh'});
-        const rejected = successfulResult(document, 'bbbbbbbbbbbbbbbb');
-        harness.client.requests[1].deferred.resolve(rejected);
+        harness.panels.panels[0].emitMessage({type: 'refresh'});
+        harness.client.requests[1].deferred.resolve({...successfulResult(document), uri: 'file:///tmp/other.ttl'});
         await flushPromises();
+        harness.panels.panels[0].emitMessage({type: 'ready'});
 
-        const state = harness.controller.getPanelState(document.uri.toString());
-        assert.equal(state?.status.kind, 'stale');
-        assert.equal(state?.lastSuccess, retained);
-        assert.equal(state?.lastSuccess?.targetById.has(first.targets[0].id), true);
-        assert.equal(state?.lastSuccess?.targetById.has(rejected.targets[0].id), false);
+        assert.equal(renderDeliveries(harness.panels.panels[0]).at(-1)?.svg, successfulResult(document).svg);
+        const status = lastStatus(harness.panels.panels[0]);
+        assert.equal(status?.kind, 'stale');
+        assert.equal(status?.kind === 'stale' && status.reason, 'uriMismatch');
         harness.controller.dispose();
     });
 
-    test('late acknowledgement for delivered A establishes its sidecar without overwriting loading state for B', async () => {
+    test('commits SVG and sidecar only after the secure webview acknowledges it', async () => {
         const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/delayed-render-ack-loading.ttl');
-        await harness.controller.openGraphicalView(document);
+        const document = track(harness, '/tmp/ack.ttl');
+        await openGraphicalView(harness, document);
         const panel = harness.panels.panels[0];
         panel.renderOutcome = 'none';
-
-        harness.client.requests[0].deferred.resolve(successfulResult(document, 'aaaaaaaaaaaaaaaa'));
+        harness.client.requests[0].deferred.resolve(successfulResult(document));
         await flushPromises();
-        panel.emitMessage({type: 'refresh'});
-        const loadingB = harness.controller.getPanelState(document.uri.toString())?.status;
 
+        panel.emitMessage({type: 'navigate', version: 1, targetId: successfulResult(document).targets[0].id});
+        assert.equal(harness.client.resolveRequests.length, 0);
         panel.emitMessage({type: 'rendered', version: 1});
-        const state = harness.controller.getPanelState(document.uri.toString());
-        assert.equal(state?.lastSuccess?.version, 1);
-        assert.equal(state?.status, loadingB);
-        assert.equal(state?.status.kind, 'loading');
+        panel.emitMessage({type: 'navigate', version: 1, targetId: successfulResult(document).targets[0].id});
+        await flushPromises();
+        assert.equal(harness.client.resolveRequests.length, 1);
         harness.controller.dispose();
     });
 
-    test('late acknowledgement for delivered A establishes its sidecar without overwriting failed state for B', async () => {
+    test('retains the last accepted diagram for warning, transport, and sanitizer failures', async () => {
         const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/delayed-render-ack-stale.ttl');
-        await harness.controller.openGraphicalView(document);
+        const document = track(harness, '/tmp/retention.ttl');
+        await openGraphicalView(harness, document);
+        const retained = successfulResult(document);
+        harness.client.requests[0].deferred.resolve(retained);
+        await flushPromises();
         const panel = harness.panels.panels[0];
-        panel.renderOutcome = 'none';
 
-        harness.client.requests[0].deferred.resolve(successfulResult(document, 'aaaaaaaaaaaaaaaa'));
-        await flushPromises();
         panel.emitMessage({type: 'refresh'});
-        harness.client.requests[1].deferred.reject(new Error('render B failed'));
+        harness.client.requests[1].deferred.resolve({uri: document.uri.toString(), svg: null, targets: [], warnings: ['timeout']});
         await flushPromises();
-        const failedB = harness.controller.getPanelState(document.uri.toString())?.status;
-
-        panel.emitMessage({type: 'rendered', version: 1});
-        const state = harness.controller.getPanelState(document.uri.toString());
-        assert.equal(state?.lastSuccess?.version, 1);
-        assert.equal(state?.status, failedB);
-        assert.equal(state?.status.kind, 'stale');
-        harness.controller.dispose();
-    });
-
-    test('rehydrates the current version through ready without an LSP render or shell reset', async () => {
-        const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/rehydrate.ttl');
-        await harness.controller.openGraphicalView(document);
-        harness.client.requests[0].deferred.resolve(successfulResult(document));
+        panel.emitMessage({type: 'refresh'});
+        harness.client.requests[2].deferred.reject(new Error('transport connection failed'));
         await flushPromises();
-        const panel = harness.panels.panels[0];
-        const renderCount = panel.deliveries.filter(delivery => delivery.type === 'render').length;
-
-        panel.emitMessage({type: 'ready'});
-        assert.equal(harness.client.requests.length, 1);
-        assert.equal(panel.deliveries.filter(delivery => delivery.type === 'render').length, renderCount + 1);
-        assert.equal(harness.controller.getPanelState(document.uri.toString())?.lastSuccess?.version, 1);
-
         panel.renderOutcome = 'failure';
         panel.emitMessage({type: 'refresh'});
-        harness.client.requests[1].deferred.resolve(successfulResult(document, 'bbbbbbbbbbbbbbbb'));
+        harness.client.requests[3].deferred.resolve(successfulResult(document, 'aaaaaaaaaaaaaaaa'));
         await flushPromises();
-        assert.equal(harness.controller.getPanelState(document.uri.toString())?.status.kind, 'stale');
-
         panel.renderOutcome = 'success';
         panel.emitMessage({type: 'ready'});
-        assert.equal(harness.client.requests.length, 2);
-        assert.equal(harness.controller.getPanelState(document.uri.toString())?.lastSuccess?.version, 1);
-        assert.equal(harness.controller.getPanelState(document.uri.toString())?.status.kind, 'stale');
-        harness.controller.dispose();
-    });
-
-    test('resolves a current sidecar-backed marker and opens, selects, and reveals only its local file location', async () => {
-        const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/navigation-source.ttl');
-        await harness.controller.openGraphicalView(document);
-        const result = successfulResult(document);
-        harness.client.requests[0].deferred.resolve(result);
-        await flushPromises();
-        const targetUri = vscode.Uri.file('/tmp/navigation-target.ttl');
-        harness.client.resolveResult = {
-            location: {
-                uri: targetUri.toString(),
-                range: {start: {line: 3, character: 4}, end: {line: 5, character: 6}},
-            },
-        };
-
-        harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: result.targets[0].id});
-        await flushPromises();
-        await flushPromises();
 
-        assert.deepEqual(harness.client.resolveRequests[0].params, {
-            sourceUri: document.uri.toString(),
-            elementUrn: result.targets[0].elementUrn,
-        });
-        assert.equal(harness.client.resolveRequests[0].token?.isCancellationRequested, false);
-        assert.equal(harness.window.openedEditors[0].uri.toString(), targetUri.toString());
-        assert.equal(harness.window.openedEditors[0].options?.preview, false);
-        assert.deepEqual(harness.window.openedEditors[0].editor.selection.start, new vscode.Position(3, 4));
-        assert.deepEqual(harness.window.openedEditors[0].editor.selection.end, new vscode.Position(5, 6));
-        assert.deepEqual(harness.window.openedEditors[0].revealedRanges[0], new vscode.Range(3, 4, 5, 6));
+        assert.equal(renderDeliveries(panel).at(-1)?.svg, retained.svg);
+        assert.equal(lastStatus(panel)?.kind, 'stale');
+        assert.ok(harness.outputChannel.lines.some(line => line.includes('secure rendering boundary')));
         harness.controller.dispose();
     });
 
-    test('accepts an exact attribute sidecar and routes only its trusted semantic selector to the attribute resolver', async () => {
+    test('falls back once on InvalidParams and exposes header-only compatibility', async () => {
         const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/attribute-navigation-source.ttl');
-        await harness.controller.openGraphicalView(document);
-        const id = 'gv-attribute-0123456789abcdef';
-        const result: GraphicalViewRenderResult = {
-            uri: document.uri.toString(),
-            svg: `<svg><g id="${id}"><polygon points="0,0 1,0 1,1"/><text x="0" y="0">description: row</text></g></svg>`,
-            targets: [{
-                id,
-                kind: 'attributeRow',
-                ownerUrn: 'urn:samm:example.graphical:1.0.0#Aspect',
-                predicateUrn: 'urn:samm:org.eclipse.esmf.samm:meta-model:2.2.0#description',
-                selection: 'singleOccurrence',
-                language: 'en',
-            }],
-            warnings: [],
-        };
-        harness.client.requests[0].deferred.resolve(result);
-        await flushPromises();
-        harness.client.resolveResult = {
-            location: {
-                uri: vscode.Uri.file('/tmp/attribute-navigation-target.ttl').toString(),
-                range: {start: {line: 7, character: 3}, end: {line: 7, character: 19}},
-            },
-        };
-
-        harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: id});
-        await flushPromises();
-        await flushPromises();
-
-        assert.equal(harness.client.resolveRequests.length, 0);
-        assert.deepEqual(harness.client.attributeResolveRequests[0].params, {
-            sourceUri: document.uri.toString(),
-            ownerUrn: 'urn:samm:example.graphical:1.0.0#Aspect',
-            predicateUrn: 'urn:samm:org.eclipse.esmf.samm:meta-model:2.2.0#description',
-            selection: 'singleOccurrence',
-            language: 'en',
-        });
-        assert.deepEqual(harness.window.openedEditors[0].editor.selection.start, new vscode.Position(7, 3));
-        harness.controller.dispose();
-    });
-
-    test('opens the same predicate statement from both physical rows of a wrapped aggregated see target', async () => {
-        const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/wrapped-see-source.ttl');
-        await harness.controller.openGraphicalView(document);
-        const ids = ['gv-attribute-1111111111111111', 'gv-attribute-2222222222222222'] as const;
-        const locator = {
-            kind: 'attributeRow' as const,
-            ownerUrn: 'urn:samm:example.graphical:1.0.0#Aspect',
-            predicateUrn: 'urn:samm:org.eclipse.esmf.samm:meta-model:2.2.0#see',
-            selection: 'predicateStart' as const,
-        };
-        const result: GraphicalViewRenderResult = {
-            uri: document.uri.toString(),
-            svg: `<svg><g id="${ids[0]}"><text>see: https://example.test/reference/with/a/long/path,</text></g>`
-                + `<g id="${ids[1]}"><text>urn:irdi:0173:1:02:AAO677:003</text></g></svg>`,
-            targets: ids.map(id => ({id, ...locator})),
-            warnings: [],
-        };
-        harness.client.requests[0].deferred.resolve(result);
-        await flushPromises();
-        const targetUri = vscode.Uri.file('/tmp/wrapped-see-source.ttl');
-        harness.client.resolveResult = {
-            location: {
-                uri: targetUri.toString(),
-                range: {start: {line: 8, character: 3}, end: {line: 8, character: 11}},
-            },
-        };
-
-        for (const id of ids) {
-            harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: id});
-            await flushPromises();
-            await flushPromises();
-        }
-
-        assert.equal(harness.client.attributeResolveRequests.length, 2);
-        const expectedParams = {
-            sourceUri: document.uri.toString(),
-            ownerUrn: locator.ownerUrn,
-            predicateUrn: locator.predicateUrn,
-            selection: locator.selection,
-        };
-        assert.deepEqual(harness.client.attributeResolveRequests.map(request => request.params), [expectedParams, expectedParams]);
-        assert.equal(harness.window.openedEditors.length, 2);
-        assert.ok(harness.window.openedEditors.every(opened => opened.uri.toString() === targetUri.toString()));
-        assert.ok(harness.window.openedEditors.every(
-            opened => opened.editor.selection.isEqual(new vscode.Selection(8, 3, 8, 11)),
-        ));
-        assert.equal(harness.window.warnings.length, 0);
-        harness.controller.dispose();
-    });
-
-    test('rejects attribute kind-prefix-shape-qualifier and sidecar inconsistencies atomically', async () => {
-        const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/attribute-validation.ttl');
-        await harness.controller.openGraphicalView(document);
-        const good = successfulResult(document);
-        harness.client.requests[0].deferred.resolve(good);
-        await flushPromises();
-        const base = {
-            id: 'gv-attribute-0123456789abcdef',
-            kind: 'attributeRow' as const,
-            ownerUrn: 'urn:samm:example.graphical:1.0.0#Aspect',
-            predicateUrn: 'urn:samm:org.eclipse.esmf.samm:meta-model:2.2.0#description',
-            selection: 'singleOccurrence' as const,
-            language: 'en',
-        };
-        const candidates: unknown[] = [
-            {...base, id: 'gv-header-0123456789abcdef'},
-            {...base, ownerUrn: 'Aspect'},
-            {...base, predicateUrn: 'description'},
-            {...base, selection: 'predicateStart', language: 'en'},
-            {...base, language: 'EN'},
-            {...base, sourceText: 'forbidden'},
-        ];
-        for (const target of candidates) {
-            harness.panels.panels[0].emitMessage({type: 'refresh'});
-            const id = (target as {id: string}).id;
-            harness.client.requests.at(-1)?.deferred.resolve({
-                uri: document.uri.toString(),
-                svg: `<svg><g id="${id}"><text>row</text></g></svg>`,
-                targets: [target] as never,
-                warnings: [],
-            });
-            await flushPromises();
-            assert.equal(harness.controller.getPanelState(document.uri.toString())?.lastSuccess?.svg, good.svg);
-        }
-        harness.controller.dispose();
-    });
-
-    test('falls back once to legacy header-only render on InvalidParams and exposes the compatibility limitation', async () => {
-        const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/legacy-server.ttl');
-        await harness.controller.openGraphicalView(document);
+        const document = track(harness, '/tmp/legacy.ttl');
+        await openGraphicalView(harness, document);
         harness.client.requests[0].deferred.reject({code: -32602, message: 'Invalid params'});
         await flushPromises();
-        assert.equal(harness.client.requests.length, 2);
-        assert.deepEqual(harness.client.requests[1].params, {uri: document.uri.toString()});
         harness.client.requests[1].deferred.resolve(successfulResult(document));
         await flushPromises();
-        const state = harness.controller.getPanelState(document.uri.toString());
-        assert.equal(state?.lastSuccess?.attributeRowsAvailable, false);
-        assert.match(state?.status.message ?? '', /header navigation only/i);
-        harness.controller.dispose();
-    });
-
-    test('rejects attribute targets returned by the legacy header-only fallback', async () => {
-        const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/invalid-legacy-server.ttl');
-        await harness.controller.openGraphicalView(document);
-        harness.client.requests[0].deferred.reject({code: -32602, message: 'Invalid params'});
-        await flushPromises();
-        const attributeId = 'gv-attribute-0123456789abcdef';
-        harness.client.requests[1].deferred.resolve({
-            uri: document.uri.toString(),
-            svg: `<svg><g id="${attributeId}"><text>row</text></g></svg>`,
-            targets: [{
-                id: attributeId,
-                kind: 'attributeRow',
-                ownerUrn: 'urn:samm:example.graphical:1.0.0#Aspect',
-                predicateUrn: 'urn:samm:org.eclipse.esmf.samm:meta-model:2.2.0#description',
-                selection: 'singleOccurrence',
-                language: 'en',
-            }],
-            warnings: [],
-        });
-        await flushPromises();
-        const state = harness.controller.getPanelState(document.uri.toString());
-        assert.equal(state?.lastSuccess, undefined);
-        assert.equal(state?.status.kind, 'stale');
-        assert.equal(state?.status.reason, 'invalidResponse');
-        harness.controller.dispose();
-    });
-
-    test('rejects malformed, stale, fake, extra-field, and non-sidecar navigation before LSP resolution', async () => {
-        const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/rejected-navigation.ttl');
-        await harness.controller.openGraphicalView(document);
-        const first = successfulResult(document, 'aaaaaaaaaaaaaaaa');
-        harness.client.requests[0].deferred.resolve(first);
-        await flushPromises();
 
-        const rejectedMessages: unknown[] = [
-            {type: 'navigate', targetId: first.targets[0].id},
-            {type: 'navigate', version: 1, targetId: first.targets[0].id, uri: 'file:///tmp/evil.ttl'},
-            {type: 'navigate', version: 1, targetId: 'gv-header-bbbbbbbbbbbbbbbb'},
-            {type: 'navigate', version: 1, targetId: 'bad-marker'},
-            {type: 'navigate', version: 1.5, targetId: first.targets[0].id},
-            {type: 'navigate', version: '1', targetId: first.targets[0].id},
-            {type: 'navigate', version: 1, targetId: first.targets[0].id, elementUrn: first.targets[0].elementUrn},
-        ];
-        for (const message of rejectedMessages) {
-            harness.panels.panels[0].emitMessage(message);
-        }
-
-        harness.panels.panels[0].emitMessage({type: 'refresh'});
-        const second = successfulResult(document, 'cccccccccccccccc');
-        harness.client.requests[1].deferred.resolve(second);
-        await flushPromises();
-        harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: first.targets[0].id});
-        assert.equal(harness.client.resolveRequests.length, 0);
-        assert.equal(harness.window.openedEditors.length, 0);
-        harness.controller.dispose();
-    });
-
-    test('blocks warning, malformed, invalid-range, non-file, resolver-failure, and editor-open navigation paths', async () => {
-        const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/navigation-failures.ttl');
-        await harness.controller.openGraphicalView(document);
-        const result = successfulResult(document);
-        harness.client.requests[0].deferred.resolve(result);
-        await flushPromises();
-        const navigate = async () => {
-            harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: result.targets[0].id});
-            await flushPromises();
-            await flushPromises();
-        };
-
-        for (const warning of ['notFound', 'ambiguous', 'unsupportedUri', 'temporarilyUnresolvable'] as const) {
-            harness.client.resolveResult = {location: null, warning};
-            await navigate();
-        }
-        harness.client.resolveResult = {
-            location: {
-                uri: 'https://example.invalid/model.ttl',
-                range: {start: {line: 0, character: 0}, end: {line: 0, character: 1}},
-            },
-        };
-        await navigate();
-        harness.client.resolveResult = {
-            location: {
-                uri: vscode.Uri.file('/tmp/invalid-range.ttl').toString(),
-                range: {start: {line: 2, character: 0}, end: {line: 1, character: 0}},
-            },
-        };
-        await navigate();
-        harness.client.resolveResult = {location: null, warning: null};
-        await navigate();
-        harness.client.resolveFailure = new Error('hostile resolver detail');
-        await navigate();
-        harness.client.resolveFailure = undefined;
-        harness.client.resolveResult = {
-            location: {
-                uri: vscode.Uri.file('/tmp/open-failure.ttl').toString(),
-                range: {start: {line: 0, character: 0}, end: {line: 0, character: 1}},
-            },
-        };
-        harness.window.showTextDocumentFailure = new Error('hostile editor detail');
-        await navigate();
-
-        assert.equal(harness.window.openedEditors.length, 0);
-        assert.equal(harness.window.warnings.length, 9);
-        assert.ok(harness.window.warnings.every(message => !message.includes('hostile')));
+        assert.deepEqual(harness.client.requests.map(request => request.params), [
+            {uri: document.uri.toString(), includeAttributeRows: true},
+            {uri: document.uri.toString()},
+        ]);
+        assert.match(lastStatus(harness.panels.panels[0])?.message ?? '', /header navigation only/i);
         harness.controller.dispose();
     });
 
-    test('detects MethodNotFound by code and recovers compatibility state after client replacement', async () => {
+    test('handles MethodNotFound, client replacement, disconnect, and reconnect without automatic rendering', async () => {
         const harness = createGraphicalViewHarness();
-        const document = track(harness, '/tmp/unsupported.ttl');
-        await harness.controller.openGraphicalView(document);
-        harness.client.requests[0].deferred.reject(Object.assign(new Error('localized message'), {code: -32601}));
-        await flushPromises();
-        assert.equal(harness.controller.getPanelState(document.uri.toString())?.status.kind, 'unsupported');
-
-        const replacement = new FakeGraphicalViewClient();
-        harness.controller.setClient(replacement);
-        assert.equal(harness.controller.getPanelState(document.uri.toString())?.status.kind, 'stale');
-        assert.equal(replacement.requests.length, 0);
-        harness.panels.panels[0].emitMessage({type: 'refresh'});
-        assert.equal(replacement.requests.length, 1);
-        harness.controller.dispose();
-    });
-
-    test('handles explicit replacement and unexpected disconnect/reconnect without automatic render', async () => {
-        const client = new FakeGraphicalViewClient();
-        const harness = createGraphicalViewHarness(client);
         const document = track(harness, '/tmp/lifecycle.ttl');
-        await harness.controller.openGraphicalView(document);
-        const pending = client.requests[0];
-        harness.controller.setClient(undefined);
-        assert.equal(pending.token.isCancellationRequested, true);
-        assert.equal(harness.controller.getPanelState(document.uri.toString())?.status.kind, 'disconnected');
+        await openGraphicalView(harness, document);
+        harness.client.requests[0].deferred.reject({code: -32601, message: 'localized'});
+        await flushPromises();
+        assert.equal(lastStatus(harness.panels.panels[0])?.kind, 'unsupported');
 
         const replacement = new FakeGraphicalViewClient();
         harness.controller.setClient(replacement);
-        assert.equal(replacement.requests.length, 0);
         replacement.setAvailable(false);
-        assert.equal(harness.controller.getPanelState(document.uri.toString())?.status.kind, 'disconnected');
         replacement.setAvailable(true);
-        assert.equal(harness.controller.getPanelState(document.uri.toString())?.status.kind, 'stale');
         assert.equal(replacement.requests.length, 0);
+        assert.equal(lastStatus(harness.panels.panels[0])?.kind, 'stale');
+
+        harness.panels.panels[0].emitMessage({type: 'refresh'});
+        assert.equal(replacement.requests.length, 1);
         harness.controller.dispose();
     });
 
-    test('disposal removes ownership, cancels work, disposes listeners, and rejects late results', async () => {
+    test('panel disposal cancels work, removes ownership, and rejects late results', async () => {
         const harness = createGraphicalViewHarness();
         const document = track(harness, '/tmp/dispose.ttl');
-        await harness.controller.openGraphicalView(document);
+        await openGraphicalView(harness, document);
+        const firstPanel = harness.panels.panels[0];
         const request = harness.client.requests[0];
-        const panel = harness.panels.panels[0];
-        panel.dispose();
-        assert.equal(harness.controller.getPanelCount(), 0);
-        assert.equal(request.token.isCancellationRequested, true);
-        assert.equal(panel.disposedListenerCount, 3);
+        firstPanel.dispose();
         request.deferred.resolve(successfulResult(document));
         await flushPromises();
-        assert.equal(harness.controller.getPanelCount(), 0);
+        await openGraphicalView(harness, document);
+
+        assert.equal(request.token.isCancellationRequested, true);
+        assert.equal(firstPanel.disposedListenerCount, 3);
+        assert.equal(renderDeliveries(firstPanel).length, 0);
+        assert.equal(harness.panels.panels.length, 2);
         harness.controller.dispose();
     });
 
-    test('multiple panels neither leak nor cross-deliver results or status', async () => {
+    test('independent panels do not cross-deliver results and controller disposal closes both', async () => {
         const harness = createGraphicalViewHarness();
         const first = track(harness, '/tmp/multi-one.ttl');
         const second = track(harness, '/tmp/multi-two.ttl');
-        await harness.controller.openGraphicalView(first);
-        await harness.controller.openGraphicalView(second);
-        const firstDeliveryCount = harness.panels.panels[0].deliveries.length;
+        await openGraphicalView(harness, first);
+        await openGraphicalView(harness, second);
         harness.client.requests[1].deferred.resolve(successfulResult(second, 'bbbbbbbbbbbbbbbb'));
         await flushPromises();
-        assert.equal(harness.panels.panels[0].deliveries.length, firstDeliveryCount);
-        assert.match(harness.controller.getPanelState(second.uri.toString())?.lastSuccess?.svg ?? '', /bbbbbbbbbbbbbbbb/);
-        assert.equal(harness.controller.getPanelState(first.uri.toString())?.lastSuccess, undefined);
+
+        assert.equal(renderDeliveries(harness.panels.panels[0]).length, 0);
+        assert.match(renderDeliveries(harness.panels.panels[1])[0].svg, /bbbbbbbbbbbbbbbb/);
         harness.controller.dispose();
         assert.equal(harness.panels.panels[0].disposeCount, 1);
         assert.equal(harness.panels.panels[1].disposeCount, 1);
diff --git a/src/test/graphicalViewManifest.test.ts b/src/test/graphicalViewManifest.test.ts
new file mode 100644
index 0000000..1245c58
--- /dev/null
+++ b/src/test/graphicalViewManifest.test.ts
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ *
+ * See the AUTHORS file(s) distributed with this work for additional
+ * information regarding authorship.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import * as assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {existsSync, readFileSync, statSync} from 'node:fs';
+import {isAbsolute, relative, resolve} from 'node:path';
+import {OPEN_GRAPHICAL_VIEW_COMMAND} from '../graphicalView';
+
+const ICON_PATH = 'media/aspect-model-editor-targetsize-192.png';
+const ICON_SHA_256 = 'd4e288af96113cd31e0f3fea5ea6f6629ab568230dff967ed4c12da12c4cbe5b';
+
+type ManifestCommand = {
+    command: string;
+    title?: string;
+    category?: string;
+    enablement?: string;
+    icon?: {light?: string; dark?: string};
+};
+
+type ManifestMenuItem = {
+    command?: string;
+    when?: string;
+    group?: string;
+    alt?: string;
+};
+
+type ExtensionManifest = {
+    contributes: {
+        commands: ManifestCommand[];
+        menus: Record<string, ManifestMenuItem[] | undefined>;
+    };
+};
+
+suite('Graphical View editor-title manifest contract', () => {
+    const extensionRoot = resolve(__dirname, '..', '..');
+    const manifest = JSON.parse(readFileSync(resolve(extensionRoot, 'package.json'), 'utf8')) as ExtensionManifest;
+
+    test('reuses the single existing command with its approved local light and dark icon', () => {
+        const commands = manifest.contributes.commands.filter(command => command.command === OPEN_GRAPHICAL_VIEW_COMMAND);
+        assert.equal(commands.length, 1);
+        assert.deepEqual(commands[0], {
+            command: OPEN_GRAPHICAL_VIEW_COMMAND,
+            title: 'Open Graphical View',
+            category: 'Turtle',
+            enablement: 'editorLangId == turtle',
+            icon: {light: ICON_PATH, dark: ICON_PATH},
+        });
+
+        for (const iconPath of Object.values(commands[0].icon ?? {})) {
+            assertLocalAsset(extensionRoot, iconPath);
+        }
+        assert.equal(sha256(resolve(extensionRoot, ICON_PATH)), ICON_SHA_256);
+    });
+
+    test('contributes exactly one Turtle-scoped primary editor-title action in stable order', () => {
+        const titleItems = (manifest.contributes.menus['editor/title'] ?? []).filter(item => item.command === OPEN_GRAPHICAL_VIEW_COMMAND);
+        assert.deepEqual(titleItems, [
+            {
+                command: OPEN_GRAPHICAL_VIEW_COMMAND,
+                when: 'resourceLangId == turtle',
+                group: 'navigation@10',
+            },
+        ]);
+        assert.equal('alt' in titleItems[0], false);
+    });
+
+    test('preserves editor context and unrestricted Command Palette behavior without duplicate surfaces', () => {
+        const contextItems = (manifest.contributes.menus['editor/context'] ?? []).filter(
+            item => item.command === OPEN_GRAPHICAL_VIEW_COMMAND,
+        );
+        assert.deepEqual(contextItems, [
+            {
+                command: OPEN_GRAPHICAL_VIEW_COMMAND,
+                when: 'resourceLangId == turtle',
+                group: '1_modification@2',
+            },
+        ]);
+
+        const paletteItems = (manifest.contributes.menus.commandPalette ?? []).filter(item => item.command === OPEN_GRAPHICAL_VIEW_COMMAND);
+        assert.deepEqual(paletteItems, []);
+
+        const graphicalCommands = manifest.contributes.commands.filter(command => command.command.toLowerCase().includes('graphicalview'));
+        assert.deepEqual(
+            graphicalCommands.map(command => command.command),
+            [OPEN_GRAPHICAL_VIEW_COMMAND],
+        );
+    });
+});
+
+function assertLocalAsset(extensionRoot: string, assetPath: string | undefined): asserts assetPath is string {
+    assert.ok(assetPath, 'The command icon path must be present');
+    assert.equal(isAbsolute(assetPath), false, 'The command icon path must be extension-relative');
+    assert.equal(/^(?:[a-z][a-z\d+.-]*:|\/\/)/i.test(assetPath), false, 'The command icon path must not be a URL');
+
+    const resolvedPath = resolve(extensionRoot, assetPath);
+    const relativePath = relative(extensionRoot, resolvedPath);
+    assert.equal(relativePath.startsWith('..') || isAbsolute(relativePath), false, 'The command icon must stay inside the extension');
+    assert.equal(existsSync(resolvedPath), true, `The command icon does not exist: ${assetPath}`);
+    assert.equal(statSync(resolvedPath).isFile(), true, `The command icon is not a file: ${assetPath}`);
+    assert.ok(statSync(resolvedPath).size > 0, `The command icon is empty: ${assetPath}`);
+}
+
+function sha256(file: string): string {
+    return createHash('sha256').update(readFileSync(file)).digest('hex');
+}
diff --git a/src/test/graphicalViewNavigation.test.ts b/src/test/graphicalViewNavigation.test.ts
new file mode 100644
index 0000000..c1227bb
--- /dev/null
+++ b/src/test/graphicalViewNavigation.test.ts
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import * as assert from 'node:assert/strict';
+import * as vscode from 'vscode';
+import {resolveGraphicalViewNavigation, validateGraphicalViewResolveResult} from '../graphicalViewNavigation';
+import type {GraphicalViewRenderResult} from '../graphicalViewProtocol';
+import {
+    createGraphicalViewDocument,
+    createGraphicalViewHarness,
+    flushPromises,
+    openGraphicalView,
+} from './graphicalViewTestHarness';
+
+const OWNER = 'urn:samm:example.graphical:1.0.0#Aspect';
+const PREDICATE = 'urn:samm:org.eclipse.esmf.samm:meta-model:2.2.0#description';
+
+suite('Graphical View source navigation', () => {
+    test('dispatches trusted element and language-qualified attribute locators to distinct LSP methods', async () => {
+        const harness = createGraphicalViewHarness();
+        const cancellation = new vscode.CancellationTokenSource();
+        harness.client.resolveResult = {location: null, warning: 'notFound'};
+
+        await resolveGraphicalViewNavigation(
+            harness.client,
+            'file:///tmp/source.ttl',
+            {id: 'gv-header-aaaaaaaaaaaaaaaa', kind: 'elementHeader', elementUrn: OWNER},
+            cancellation.token,
+        );
+        await resolveGraphicalViewNavigation(
+            harness.client,
+            'file:///tmp/source.ttl',
+            {
+                id: 'gv-attribute-bbbbbbbbbbbbbbbb',
+                kind: 'attributeRow',
+                ownerUrn: OWNER,
+                predicateUrn: PREDICATE,
+                selection: 'singleOccurrence',
+                language: 'de',
+            },
+            cancellation.token,
+        );
+
+        assert.deepEqual(harness.client.resolveRequests[0].params, {
+            sourceUri: 'file:///tmp/source.ttl',
+            elementUrn: OWNER,
+        });
+        assert.deepEqual(harness.client.attributeResolveRequests[0].params, {
+            sourceUri: 'file:///tmp/source.ttl',
+            ownerUrn: OWNER,
+            predicateUrn: PREDICATE,
+            selection: 'singleOccurrence',
+            language: 'de',
+        });
+        cancellation.dispose();
+        harness.controller.dispose();
+    });
+
+    test('validates local file locations and rejects invalid ranges, remote URIs, and ambiguous result shapes', () => {
+        const valid = validateGraphicalViewResolveResult({
+            location: {
+                uri: vscode.Uri.file('/tmp/target.ttl').toString(),
+                range: {start: {line: 3, character: 4}, end: {line: 5, character: 6}},
+            },
+        });
+        assert.equal(valid.kind, 'location');
+        assert.deepEqual(valid.kind === 'location' && valid.range, new vscode.Range(3, 4, 5, 6));
+
+        const invalid = [
+            {location: {uri: 'https://example.invalid/model.ttl', range: positions(0, 0, 0, 1)}},
+            {location: {uri: vscode.Uri.file('/tmp/model.ttl').toString(), range: positions(2, 0, 1, 0)}},
+            {location: null, warning: null},
+            {location: {uri: vscode.Uri.file('/tmp/model.ttl').toString(), range: positions(0, 0, 0, 1)}, warning: 'notFound'},
+            {location: null, warning: 'unknown'},
+        ];
+        assert.ok(invalid.every(candidate => validateGraphicalViewResolveResult(candidate).kind === 'warning'));
+    });
+
+    test('opens current multilingual and wrapped attribute targets using only the accepted sidecar', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = createGraphicalViewDocument('/tmp/navigation.ttl');
+        harness.workspace.available.add(document.uri.toString());
+        await openGraphicalView(harness, document);
+        const ids = [
+            'gv-attribute-aaaaaaaaaaaaaaaa',
+            'gv-attribute-bbbbbbbbbbbbbbbb',
+            'gv-attribute-cccccccccccccccc',
+        ];
+        const result: GraphicalViewRenderResult = {
+            uri: document.uri.toString(),
+            svg: `<svg>${ids.map(id => `<g id="${id}"><text>row</text></g>`).join('')}</svg>`,
+            targets: [
+                {id: ids[0], kind: 'attributeRow', ownerUrn: OWNER, predicateUrn: PREDICATE, selection: 'singleOccurrence', language: 'de'},
+                {id: ids[1], kind: 'attributeRow', ownerUrn: OWNER, predicateUrn: PREDICATE, selection: 'singleOccurrence', language: 'en'},
+                {id: ids[2], kind: 'attributeRow', ownerUrn: OWNER, predicateUrn: PREDICATE, selection: 'predicateStart'},
+            ],
+            warnings: [],
+        };
+        harness.client.requests[0].deferred.resolve(result);
+        await flushPromises();
+        harness.client.resolveResult = {
+            location: {uri: document.uri.toString(), range: positions(8, 3, 8, 11)},
+        };
+
+        for (const id of ids) {
+            harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: id});
+            await flushPromises();
+            await flushPromises();
+        }
+
+        assert.deepEqual(harness.client.attributeResolveRequests.map(request => request.params.language), ['de', 'en', undefined]);
+        assert.deepEqual(harness.client.attributeResolveRequests.map(request => request.params.selection), [
+            'singleOccurrence',
+            'singleOccurrence',
+            'predicateStart',
+        ]);
+        assert.equal(harness.window.openedEditors.length, 3);
+        assert.ok(harness.window.openedEditors.every(opened => opened.editor.selection.isEqual(new vscode.Selection(8, 3, 8, 11))));
+        harness.controller.dispose();
+    });
+
+    test('rejects stale, fake, malformed, extra-field, warning, non-file, and editor-open paths', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = createGraphicalViewDocument('/tmp/rejected.ttl');
+        harness.workspace.available.add(document.uri.toString());
+        await openGraphicalView(harness, document);
+        const id = 'gv-header-aaaaaaaaaaaaaaaa';
+        harness.client.requests[0].deferred.resolve({
+            uri: document.uri.toString(),
+            svg: `<svg><g id="${id}"/></svg>`,
+            targets: [{id, kind: 'elementHeader', elementUrn: OWNER}],
+            warnings: [],
+        });
+        await flushPromises();
+
+        for (const message of [
+            {type: 'navigate', targetId: id},
+            {type: 'navigate', version: 2, targetId: id},
+            {type: 'navigate', version: 1, targetId: 'gv-header-bbbbbbbbbbbbbbbb'},
+            {type: 'navigate', version: 1, targetId: id, elementUrn: OWNER},
+        ]) {
+            harness.panels.panels[0].emitMessage(message);
+        }
+        assert.equal(harness.client.resolveRequests.length, 0);
+
+        harness.client.resolveResult = {location: null, warning: 'ambiguous'};
+        harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: id});
+        await flushPromises();
+        harness.client.resolveResult = {location: {uri: 'https://example.invalid/model.ttl', range: positions(0, 0, 0, 1)}};
+        harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: id});
+        await flushPromises();
+        harness.client.resolveResult = {location: {uri: document.uri.toString(), range: positions(0, 0, 0, 1)}};
+        harness.window.showTextDocumentFailure = new Error('hostile detail');
+        harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: id});
+        await flushPromises();
+        await flushPromises();
+
+        assert.equal(harness.window.openedEditors.length, 0);
+        assert.equal(harness.window.warnings.length, 3);
+        assert.ok(harness.window.warnings.every(message => !message.includes('hostile')));
+        harness.controller.dispose();
+    });
+});
+
+function positions(startLine: number, startCharacter: number, endLine: number, endCharacter: number) {
+    return {
+        start: {line: startLine, character: startCharacter},
+        end: {line: endLine, character: endCharacter},
+    };
+}
diff --git a/src/test/graphicalViewPanel.test.ts b/src/test/graphicalViewPanel.test.ts
index f2c8f98..460198e 100644
--- a/src/test/graphicalViewPanel.test.ts
+++ b/src/test/graphicalViewPanel.test.ts
@@ -16,7 +16,13 @@ import {createHash} from 'node:crypto';
 import {readdirSync, readFileSync} from 'node:fs';
 import {join} from 'node:path';
 import * as vscode from 'vscode';
-import {WEBVIEW_SCRIPT_ORDER, createGraphicalViewPanelOptions, createShellHtml, webviewAssetDirectory} from '../graphicalViewPanel';
+import {
+    WEBVIEW_SCRIPT_ORDER,
+    createGraphicalViewPanelOptions,
+    createGraphicalViewShell,
+    parseGraphicalViewPanelMessage,
+    webviewAssetDirectory,
+} from '../graphicalViewPanel';
 
 suite('GraphicalView secure panel contract', () => {
     test('uses exact script/forms/command options and one out/webview resource root without retention', () => {
@@ -37,19 +43,22 @@ suite('GraphicalView secure panel contract', () => {
             cspSource: 'vscode-webview-resource:',
             asWebviewUri: (uri: vscode.Uri) => uri.with({scheme: 'vscode-webview-resource'}),
         };
-        const first = createShellHtml(webview, extensionUri, 'first-nonce');
-        const second = createShellHtml(webview, extensionUri, 'second-nonce');
+        const first = createGraphicalViewShell(webview, extensionUri);
+        const second = createGraphicalViewShell(webview, extensionUri);
+        const firstNonce = first.match(/script-src 'nonce-([^']+)'/)?.[1];
+        const secondNonce = second.match(/script-src 'nonce-([^']+)'/)?.[1];
+        assert.ok(firstNonce);
+        assert.ok(secondNonce);
+        assert.notEqual(firstNonce, secondNonce);
 
         const expectedCsp =
-            "default-src 'none'; script-src 'nonce-first-nonce'; style-src vscode-webview-resource:; " +
+            `default-src 'none'; script-src 'nonce-${firstNonce}'; style-src vscode-webview-resource:; ` +
             "font-src vscode-webview-resource:; img-src 'none'; connect-src 'none'; object-src 'none'; " +
             "base-uri 'none'; form-action 'none'";
         assert.ok(first.includes(`content="${expectedCsp}"`));
-        assert.equal(first.includes('second-nonce'), false);
-        assert.equal(second.includes('second-nonce'), true);
         assert.equal((first.match(/<script /g) ?? []).length, 3);
-        assert.equal((first.match(/nonce="first-nonce"/g) ?? []).length, 3);
-        assert.equal(first.includes('<script nonce="first-nonce">'), false);
+        assert.equal(first.split(`nonce="${firstNonce}"`).length - 1, 3);
+        assert.equal(first.includes(`<script nonce="${firstNonce}">`), false);
         assert.equal(first.includes('http://'), false);
         assert.equal(first.includes('https://'), false);
 
@@ -62,6 +71,25 @@ suite('GraphicalView secure panel contract', () => {
         assert.ok(first.includes('/out/webview/webview.css'));
     });
 
+    test('accepts only exact production webview messages', () => {
+        assert.deepEqual(parseGraphicalViewPanelMessage({type: 'ready'}), {type: 'ready'});
+        assert.deepEqual(parseGraphicalViewPanelMessage({type: 'refresh'}), {type: 'refresh'});
+        assert.deepEqual(parseGraphicalViewPanelMessage({type: 'rendered', version: 1}), {type: 'rendered', version: 1});
+        assert.deepEqual(
+            parseGraphicalViewPanelMessage({type: 'navigate', version: 2, targetId: 'gv-attribute-aaaaaaaaaaaaaaaa'}),
+            {type: 'navigate', version: 2, targetId: 'gv-attribute-aaaaaaaaaaaaaaaa'},
+        );
+        for (const message of [
+            {type: 'ready', extra: true},
+            {type: 'navigate', version: 2, targetId: 'bad'},
+            {type: 'navigate', version: 2, targetId: 'gv-header-aaaaaaaaaaaaaaaa', uri: 'file:///tmp/evil.ttl'},
+            {type: 'rendered', version: 0},
+            {type: 'renderError', version: 1, reason: 'other'},
+        ]) {
+            assert.equal(parseGraphicalViewPanelMessage(message), undefined);
+        }
+    });
+
     test('build output contains only the deterministic webview inventory and reference hashes', () => {
         const outputDirectory = join(__dirname, '..', 'webview');
         const expectedFiles = [
@@ -92,6 +120,9 @@ suite('GraphicalView secure panel contract', () => {
         assert.ok(controllerSource.includes('scrollLeft'));
         assert.ok(controllerSource.includes('scrollTop'));
         assert.equal(/setState\([^)]*(?:svg|uri|target|command)/i.test(controllerSource), false);
+        assert.ok(controllerSource.includes("event.key !== 'Enter' && event.key !== ' '"));
+        assert.ok(controllerSource.includes("vscode.postMessage({type: 'navigate', version: currentVersion, targetId: group.id})"));
+        assert.equal(/testMode|testSetViewport|testClickMarker|testKeyMarker|testState|testRenderDiagnostic/.test(controllerSource), false);
     });
 });
 
diff --git a/src/test/graphicalViewProtocol.test.ts b/src/test/graphicalViewProtocol.test.ts
new file mode 100644
index 0000000..ae27cb0
--- /dev/null
+++ b/src/test/graphicalViewProtocol.test.ts
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import * as assert from 'node:assert/strict';
+import type {GraphicalViewRenderResult} from '../graphicalViewProtocol';
+import {acceptGraphicalViewResult, isGraphicalViewRenderResult} from '../graphicalViewResult';
+
+const URI = 'file:///tmp/model.ttl';
+const OWNER = 'urn:samm:example.graphical:1.0.0#Aspect';
+const PREDICATE = 'urn:samm:org.eclipse.esmf.samm:meta-model:2.2.0#description';
+
+suite('Graphical View render-result validation', () => {
+    test('accepts exact header, multilingual attribute, and wrapped locator sidecars', () => {
+        const ids = [
+            'gv-header-aaaaaaaaaaaaaaaa',
+            'gv-attribute-bbbbbbbbbbbbbbbb',
+            'gv-attribute-cccccccccccccccc',
+            'gv-attribute-dddddddddddddddd',
+        ];
+        const result: GraphicalViewRenderResult = {
+            uri: URI,
+            svg: `<svg>${ids.map(id => `<g id="${id}"><text>row</text></g>`).join('')}</svg>`,
+            targets: [
+                {id: ids[0], kind: 'elementHeader', elementUrn: OWNER},
+                {id: ids[1], kind: 'attributeRow', ownerUrn: OWNER, predicateUrn: PREDICATE, selection: 'singleOccurrence', language: 'de'},
+                {id: ids[2], kind: 'attributeRow', ownerUrn: OWNER, predicateUrn: PREDICATE, selection: 'singleOccurrence', language: 'en'},
+                {id: ids[3], kind: 'attributeRow', ownerUrn: OWNER, predicateUrn: PREDICATE, selection: 'singleOccurrence', language: 'en'},
+            ],
+            warnings: [],
+        };
+
+        assert.equal(isGraphicalViewRenderResult(result), true);
+        const accepted = acceptGraphicalViewResult(result, 7, true);
+        assert.equal(accepted.version, 7);
+        assert.equal(accepted.targetById.size, 4);
+        assert.equal(accepted.targetById.get(ids[1])?.kind, 'attributeRow');
+    });
+
+    test('accepts warning results with omitted or explicit-null SVG only when the sidecar is empty', () => {
+        assert.equal(isGraphicalViewRenderResult({uri: URI, targets: [], warnings: ['timeout']}), true);
+        assert.equal(isGraphicalViewRenderResult({uri: URI, svg: null, targets: [], warnings: ['modelTooLarge']}), true);
+        assert.equal(isGraphicalViewRenderResult({uri: URI, targets: [], warnings: []}), false);
+        assert.equal(isGraphicalViewRenderResult({uri: URI, svg: null, targets: [{id: 'x'}], warnings: ['timeout']}), false);
+    });
+
+    test('rejects duplicate IDs, missing or extra markers, and malformed marker grammar', () => {
+        const id = 'gv-header-aaaaaaaaaaaaaaaa';
+        const target = {id, kind: 'elementHeader' as const, elementUrn: OWNER};
+        const candidates = [
+            {uri: URI, svg: `<svg><g id="${id}"/><g id="${id}"/></svg>`, targets: [target], warnings: []},
+            {uri: URI, svg: '<svg/>', targets: [target], warnings: []},
+            {uri: URI, svg: `<svg><g id="${id}"/></svg>`, targets: [], warnings: []},
+            {uri: URI, svg: '<svg><g id="gv-header-short"/></svg>', targets: [{...target, id: 'gv-header-short'}], warnings: []},
+        ];
+        assert.ok(candidates.every(candidate => !isGraphicalViewRenderResult(candidate)));
+    });
+
+    test('rejects target kind/prefix, URN, qualifier, selector, and extra-field inconsistencies', () => {
+        const base = {
+            id: 'gv-attribute-aaaaaaaaaaaaaaaa',
+            kind: 'attributeRow' as const,
+            ownerUrn: OWNER,
+            predicateUrn: PREDICATE,
+            selection: 'singleOccurrence' as const,
+            language: 'en',
+        };
+        const candidates: unknown[] = [
+            {...base, id: 'gv-header-aaaaaaaaaaaaaaaa'},
+            {...base, ownerUrn: 'Aspect'},
+            {...base, predicateUrn: 'description'},
+            {...base, selection: 'predicateStart'},
+            {...base, language: 'EN'},
+            {...base, sourceText: 'forbidden'},
+        ];
+        for (const target of candidates) {
+            const id = (target as {id: string}).id;
+            assert.equal(isGraphicalViewRenderResult({
+                uri: URI,
+                svg: `<svg><g id="${id}"/></svg>`,
+                targets: [target],
+                warnings: [],
+            }), false);
+        }
+    });
+
+    test('allows Graphper marker descendant IDs without treating them as sidecar entries', () => {
+        const id = 'gv-header-aaaaaaaaaaaaaaaa';
+        assert.equal(isGraphicalViewRenderResult({
+            uri: URI,
+            svg: `<svg><g id="${id}"><polygon id="${id}_polygon"/><text id="${id}_text_0">Aspect</text></g></svg>`,
+            targets: [{id, kind: 'elementHeader', elementUrn: OWNER}],
+            warnings: [],
+        }), true);
+    });
+});
diff --git a/src/test/graphicalViewTestHarness.ts b/src/test/graphicalViewTestHarness.ts
index 29d5943..c13157a 100644
--- a/src/test/graphicalViewTestHarness.ts
+++ b/src/test/graphicalViewTestHarness.ts
@@ -15,18 +15,21 @@ import * as vscode from 'vscode';
 import {
     GraphicalViewCommands,
     GraphicalViewController,
-    GraphicalViewDelivery,
     GraphicalViewDocument,
-    GraphicalViewPanelAdapter,
-    GraphicalViewPanelFactory,
     GraphicalViewWindow,
     GraphicalViewWorkspace,
 } from '../graphicalView';
+import type {GraphicalViewClient} from '../graphicalViewClient';
+import {
+    GraphicalViewDelivery,
+    GraphicalViewPanel,
+    GraphicalViewPanelFactory,
+    GraphicalViewStatus,
+} from '../graphicalViewPanel';
 import {
     GraphicalViewRenderParams,
     GraphicalViewRenderResult,
     GraphicalViewElementHeaderTarget,
-    GraphicalViewRequestClient,
     GraphicalViewResolveAttributeTargetParams,
     GraphicalViewResolveAttributeTargetResult,
     GraphicalViewResolveTargetParams,
@@ -50,7 +53,7 @@ export interface RecordedAttributeResolveRequest {
     readonly token: vscode.CancellationToken | undefined;
 }
 
-export class FakeGraphicalViewClient implements GraphicalViewRequestClient {
+export class FakeGraphicalViewClient implements GraphicalViewClient {
     readonly requests: RecordedRenderRequest[] = [];
     readonly resolveRequests: RecordedResolveRequest[] = [];
     readonly attributeResolveRequests: RecordedAttributeResolveRequest[] = [];
@@ -60,32 +63,32 @@ export class FakeGraphicalViewClient implements GraphicalViewRequestClient {
 
     constructor(private available = true) {}
 
-    isGraphicalViewAvailable(): boolean {
+    isAvailable(): boolean {
         return this.available;
     }
 
-    onDidChangeGraphicalViewAvailability(listener: (available: boolean) => void): vscode.Disposable {
+    onDidChangeAvailability(listener: (available: boolean) => void): vscode.Disposable {
         this.listeners.add(listener);
         return new vscode.Disposable(() => this.listeners.delete(listener));
     }
 
-    renderGraphicalView(params: GraphicalViewRenderParams, token: vscode.CancellationToken): Promise<GraphicalViewRenderResult> {
+    render(params: GraphicalViewRenderParams, token: vscode.CancellationToken): Promise<GraphicalViewRenderResult> {
         const deferred = new Deferred<GraphicalViewRenderResult>();
         this.requests.push({params, token, deferred});
         return deferred.promise;
     }
 
-    resolveGraphicalViewTarget(
+    resolveElement(
         params: GraphicalViewResolveTargetParams,
-        token?: vscode.CancellationToken,
+        token: vscode.CancellationToken,
     ): Promise<GraphicalViewResolveTargetResult> {
         this.resolveRequests.push({params, token});
         return this.resolveFailure === undefined ? Promise.resolve(this.resolveResult) : Promise.reject(this.resolveFailure);
     }
 
-    resolveGraphicalViewAttributeTarget(
+    resolveAttribute(
         params: GraphicalViewResolveAttributeTargetParams,
-        token?: vscode.CancellationToken,
+        token: vscode.CancellationToken,
     ): Promise<GraphicalViewResolveAttributeTargetResult> {
         this.attributeResolveRequests.push({params, token});
         return this.resolveFailure === undefined ? Promise.resolve(this.resolveResult) : Promise.reject(this.resolveFailure);
@@ -99,7 +102,7 @@ export class FakeGraphicalViewClient implements GraphicalViewRequestClient {
     }
 }
 
-export class FakeGraphicalViewPanel implements GraphicalViewPanelAdapter {
+export class FakeGraphicalViewPanel implements GraphicalViewPanel {
     readonly deliveries: GraphicalViewDelivery[] = [];
     revealCount = 0;
     disposeCount = 0;
@@ -216,6 +219,24 @@ export function successfulResult(
     };
 }
 
+export async function openGraphicalView(
+    harness: ReturnType<typeof createGraphicalViewHarness>,
+    document: GraphicalViewDocument,
+): Promise<void> {
+    harness.window.activeTextEditor = {document};
+    await harness.commands.execute('turtle.openGraphicalView');
+}
+
+export function lastStatus(panel: FakeGraphicalViewPanel): GraphicalViewStatus | undefined {
+    return panel.deliveries.filter(delivery => delivery.type === 'status').at(-1)?.status;
+}
+
+export function renderDeliveries(panel: FakeGraphicalViewPanel): Array<Extract<GraphicalViewDelivery, {type: 'render'}>> {
+    return panel.deliveries.filter((delivery): delivery is Extract<GraphicalViewDelivery, {type: 'render'}> =>
+        delivery.type === 'render',
+    );
+}
+
 export async function flushPromises(): Promise<void> {
     await new Promise<void>(resolve => setImmediate(resolve));
 }
diff --git a/src/test/graphicalViewWebviewController.test.ts b/src/test/graphicalViewWebviewController.test.ts
new file mode 100644
index 0000000..1042d93
--- /dev/null
+++ b/src/test/graphicalViewWebviewController.test.ts
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import * as assert from 'node:assert/strict';
+import {readFileSync} from 'node:fs';
+import {join} from 'node:path';
+import {runInNewContext} from 'node:vm';
+
+suite('Graphical View webview controller', () => {
+    test('posts only current ID-only navigation for pointer and Enter/Space activation', () => {
+        const source = readFileSync(join(__dirname, '..', '..', 'src', 'webview', 'webview.js'), 'utf8');
+        const posted: unknown[] = [];
+        let currentMarker: FakeElement | undefined;
+        const diagram = new FakeElement();
+        const viewport = new FakeElement();
+        viewport.clientWidth = 1000;
+        viewport.clientHeight = 800;
+        viewport.scrollWidth = 2200;
+        viewport.scrollHeight = 1600;
+        diagram.contains = candidate => candidate === currentMarker;
+        diagram.replaceChildren = fragment => {
+            currentMarker = (fragment as {marker: FakeElement}).marker;
+        };
+
+        const elements = new Map<string, FakeElement>([
+            ['#diagram', diagram],
+            ['#viewport', viewport],
+            ['#status', new FakeElement()],
+            ['#zoom-value', new FakeElement()],
+            ['#refresh', new FakeElement()],
+            ['#zoom-in', new FakeElement()],
+            ['#zoom-out', new FakeElement()],
+            ['#zoom-reset', new FakeElement()],
+            ['#zoom-fit', new FakeElement()],
+        ]);
+        const window = new FakeElement();
+        const state: {value?: unknown} = {};
+        const context = {
+            acquireVsCodeApi: () => ({
+                getState: () => undefined,
+                setState: (value: unknown) => {
+                    state.value = value;
+                },
+                postMessage: (message: unknown) => posted.push(message),
+            }),
+            document: {querySelector: (selector: string) => elements.get(selector)},
+            window,
+            Element: FakeElement,
+            SanitizerContract: {
+                MARKER_PATTERN: /^gv-(?:header|attribute)-[a-z0-9]{16,32}$/,
+                sanitizeSvg: (svgText: string) => {
+                    const id = svgText.match(/gv-(?:header|attribute)-[a-z0-9]{16,32}/)?.[0];
+                    assert.ok(id);
+                    const marker = new FakeElement(id);
+                    const svg = new FakeSvg(marker);
+                    return {fragment: {marker}, svg};
+                },
+            },
+            requestAnimationFrame: (callback: () => void) => callback(),
+            setTimeout: (callback: () => void) => {
+                callback();
+                return 0;
+            },
+            Number,
+            Object,
+            Math,
+            Error,
+        };
+        runInNewContext(source, context);
+
+        const markerId = 'gv-attribute-aaaaaaaaaaaaaaaa';
+        window.fire('message', {data: {type: 'render', version: 4, svg: `<svg><g id="${markerId}"/></svg>`}});
+        assert.ok(currentMarker);
+        assert.equal(currentMarker.attributes.get('tabindex'), '0');
+        assert.equal(currentMarker.attributes.get('role'), 'link');
+
+        diagram.fire('click', {target: currentMarker});
+        let prevented = 0;
+        diagram.fire('keydown', {target: currentMarker, key: 'Enter', preventDefault: () => prevented++});
+        diagram.fire('keydown', {target: currentMarker, key: ' ', preventDefault: () => prevented++});
+        diagram.fire('keydown', {target: currentMarker, key: 'Escape', preventDefault: () => prevented++});
+
+        assert.deepEqual(JSON.parse(JSON.stringify(posted.filter(isNavigateMessage))), [
+            {type: 'navigate', version: 4, targetId: markerId},
+            {type: 'navigate', version: 4, targetId: markerId},
+            {type: 'navigate', version: 4, targetId: markerId},
+        ]);
+        assert.equal(prevented, 2);
+        assert.deepEqual(JSON.parse(JSON.stringify(state.value)), {schemaVersion: 1, zoom: 1, scrollLeft: 0, scrollTop: 0});
+    });
+});
+
+class FakeElement {
+    readonly attributes = new Map<string, string>();
+    readonly listeners = new Map<string, (event: never) => void>();
+    textContent = '';
+    scrollLeft = 0;
+    scrollTop = 0;
+    scrollWidth = 0;
+    scrollHeight = 0;
+    clientWidth = 0;
+    clientHeight = 0;
+    contains: (candidate: unknown) => boolean = () => false;
+    replaceChildren: (fragment: unknown) => void = () => undefined;
+
+    constructor(readonly id = '') {}
+
+    addEventListener(type: string, listener: (event: never) => void): void {
+        this.listeners.set(type, listener);
+    }
+
+    fire(type: string, event: unknown): void {
+        this.listeners.get(type)?.(event as never);
+    }
+
+    closest(): FakeElement {
+        return this;
+    }
+
+    setAttribute(name: string, value: string): void {
+        this.attributes.set(name, value);
+    }
+}
+
+class FakeSvg extends FakeElement {
+    readonly viewBox = {baseVal: {width: 2200, height: 1600}};
+
+    constructor(private readonly marker: FakeElement) {
+        super();
+    }
+
+    getAttribute(name: string): string | null {
+        return name === 'width' ? '2200' : name === 'height' ? '1600' : null;
+    }
+
+    querySelectorAll(): FakeElement[] {
+        return [this.marker];
+    }
+}
+
+function isNavigateMessage(value: unknown): value is {type: 'navigate'; version: number; targetId: string} {
+    return typeof value === 'object' && value !== null && (value as {type?: unknown}).type === 'navigate';
+}
diff --git a/src/test/graphicalViewWebviewLifecycle.test.ts b/src/test/graphicalViewWebviewLifecycle.test.ts
index d2385da..d3563ee 100644
--- a/src/test/graphicalViewWebviewLifecycle.test.ts
+++ b/src/test/graphicalViewWebviewLifecycle.test.ts
@@ -1,30 +1,21 @@
 /*
  * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
- *
- * See the AUTHORS file(s) distributed with this work for additional
- * information regarding authorship.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- *
  * SPDX-License-Identifier: MPL-2.0
  */
 
 import * as assert from 'node:assert/strict';
 import {join} from 'node:path';
 import * as vscode from 'vscode';
-import {createGraphicalViewPanelOptions, createShellHtml} from '../graphicalViewPanel';
+import {createGraphicalViewPanelOptions, createGraphicalViewShell} from '../graphicalViewPanel';
 
-const FIRST_MARKER = 'gv-header-aaaaaaaaaaaaaaaa';
-const SECOND_MARKER = 'gv-attribute-bbbbbbbbbbbbbbbb';
-const WRAPPED_SEE_FIRST_MARKER = 'gv-attribute-cccccccccccccccc';
-const WRAPPED_SEE_CONTINUATION_MARKER = 'gv-attribute-dddddddddddddddd';
+const HEADER_MARKER = 'gv-header-aaaaaaaaaaaaaaaa';
+const GERMAN_MARKER = 'gv-attribute-bbbbbbbbbbbbbbbb';
+const ENGLISH_MARKER = 'gv-attribute-eeeeeeeeeeeeeeee';
 
 suite('GraphicalView real webview lifecycle', function () {
     this.timeout(30_000);
 
-    test('rehydrates viewport state and keeps current/stale clicks bounded across context recreation', async function (this: Mocha.Context) {
+    test('securely renders and rehydrates the stable shell after real context recreation', async function (this: Mocha.Context) {
         this.timeout(30_000);
         const extensionUri = vscode.Uri.file(join(__dirname, '..', '..'));
         const panel = vscode.window.createWebviewPanel(
@@ -35,102 +26,37 @@ suite('GraphicalView real webview lifecycle', function () {
         );
         const messages: unknown[] = [];
         const subscription = panel.webview.onDidReceiveMessage(message => messages.push(message));
-        const shell = createShellHtml(panel.webview, extensionUri, 'lifecycle-test-nonce', true);
+        const shell = createGraphicalViewShell(panel.webview, extensionUri);
 
         try {
             panel.webview.html = shell;
             await waitFor(() => countMessages(messages, 'ready') >= 1, 'initial ready');
-            panel.reveal(vscode.ViewColumn.One, false);
-            await waitFor(() => panel.visible, 'initial webview visibility');
-            await new Promise(resolve => setTimeout(resolve, 100));
-
-            assert.equal(
-                await panel.webview.postMessage({type: 'render', version: 1, svg: graphperSvg(FIRST_MARKER)}),
-                true,
-                `initial render delivery failed; messages=${JSON.stringify(messages)}`,
-            );
-            await waitFor(
-                () => hasMessage(messages, 'rendered', 1) || hasMessage(messages, 'renderError', 1),
-                'initial secure render',
-                3_000,
-            ).catch(error => {
-                throw new Error(`${error instanceof Error ? error.message : String(error)}; messages=${JSON.stringify(messages)}`);
-            });
-            assert.equal(
-                hasMessage(messages, 'renderError', 1),
-                false,
-                `secure render failed: ${JSON.stringify(messages.filter(message => isRecord(message) && message.type === 'testRenderDiagnostic'))}`,
-            );
+            assert.equal(await panel.webview.postMessage({type: 'render', version: 1, svg: graphperSvg(HEADER_MARKER)}), true);
+            await waitFor(() => hasMessage(messages, 'rendered', 1), 'initial secure render');
+            assert.equal(hasMessage(messages, 'renderError', 1), false);
 
-            await panel.webview.postMessage({type: 'testSetViewport', zoom: 1.5, scrollLeft: 280, scrollTop: 190});
-            const firstState = await waitForMessage(messages, message => isViewportState(message, 1.5, 280, 190), 'viewport persistence');
-            assert.deepEqual(firstState.state, {schemaVersion: 1, zoom: 1.5, scrollLeft: 280, scrollTop: 190});
-
-            const hiddenDocument = await vscode.workspace.openTextDocument({
-                content: 'Hide graphical view lifecycle test',
-                language: 'plaintext',
-            });
+            const hiddenDocument = await vscode.workspace.openTextDocument({content: 'Hide graphical view', language: 'plaintext'});
             await vscode.window.showTextDocument(hiddenDocument, {viewColumn: vscode.ViewColumn.One, preview: false});
             await waitFor(() => !panel.visible, 'webview becoming hidden');
-            const renderedBeforeReveal = countMessages(messages, 'rendered');
+            const rendersBeforeReveal = countMessages(messages, 'rendered');
 
             panel.reveal(vscode.ViewColumn.One, false);
             await waitFor(() => countMessages(messages, 'ready') >= 2, 'recreated webview ready');
-            assert.equal(countMessages(messages, 'rendered'), renderedBeforeReveal, 'reveal must not render by itself');
+            assert.equal(countMessages(messages, 'rendered'), rendersBeforeReveal, 'reveal must not render by itself');
             assert.equal(panel.webview.html, shell, 'stable shell must not be reassigned per result');
 
-            await panel.webview.postMessage({type: 'render', version: 1, svg: graphperSvg(FIRST_MARKER)});
+            await panel.webview.postMessage({type: 'render', version: 1, svg: graphperSvg(HEADER_MARKER)});
             await waitFor(() => countMessages(messages, 'rendered') >= 2, 'retained result rehydration');
-            const restoredState = await waitForMessage(
-                messages,
-                message => isViewportState(message, 1.5, 280, 190),
-                'restored viewport state',
-                1,
-            ).catch(error => {
-                throw new Error(`${error instanceof Error ? error.message : String(error)}; messages=${JSON.stringify(messages)}`);
-            });
-            assert.equal(restoredState.state.schemaVersion, 1);
-
-            await panel.webview.postMessage({type: 'testClickMarker', targetId: FIRST_MARKER});
-            await waitFor(() => navigationMessages(messages).length === 1, 'current marker click');
-            assert.deepEqual(navigationMessages(messages)[0], {type: 'navigate', version: 1, targetId: FIRST_MARKER});
-
-            await panel.webview.postMessage({type: 'render', version: 2, svg: graphperSvg(SECOND_MARKER)});
-            await waitFor(() => hasMessage(messages, 'rendered', 2), 'replacement render');
-            await panel.webview.postMessage({type: 'testClickMarker', targetId: FIRST_MARKER});
-            await new Promise(resolve => setTimeout(resolve, 200));
-            assert.equal(navigationMessages(messages).length, 1, 'stale marker must be inert after replacement');
-
-            await panel.webview.postMessage({type: 'testClickMarker', targetId: SECOND_MARKER});
-            await waitFor(() => navigationMessages(messages).length === 2, 'replacement marker click');
-            assert.deepEqual(navigationMessages(messages)[1], {type: 'navigate', version: 2, targetId: SECOND_MARKER});
-            await panel.webview.postMessage({type: 'testKeyMarker', targetId: SECOND_MARKER, key: 'Enter'});
-            await waitFor(() => navigationMessages(messages).length === 3, 'attribute marker Enter activation');
-            await panel.webview.postMessage({type: 'testKeyMarker', targetId: SECOND_MARKER, key: ' '});
-            await waitFor(() => navigationMessages(messages).length === 4, 'attribute marker Space activation');
-            assert.deepEqual(navigationMessages(messages).slice(2), [
-                {type: 'navigate', version: 2, targetId: SECOND_MARKER},
-                {type: 'navigate', version: 2, targetId: SECOND_MARKER},
-            ]);
-
             await panel.webview.postMessage({
                 type: 'render',
-                version: 3,
-                svg: wrappedSeeSvg(WRAPPED_SEE_FIRST_MARKER, WRAPPED_SEE_CONTINUATION_MARKER),
+                version: 2,
+                svg: multilingualSvg(GERMAN_MARKER, ENGLISH_MARKER),
             });
-            await waitFor(() => hasMessage(messages, 'rendered', 3), 'wrapped see render');
-            await panel.webview.postMessage({type: 'testClickMarker', targetId: WRAPPED_SEE_FIRST_MARKER});
-            await waitFor(() => navigationMessages(messages).length === 5, 'wrapped see first-row click');
-            await panel.webview.postMessage({type: 'testClickMarker', targetId: WRAPPED_SEE_CONTINUATION_MARKER});
-            await waitFor(() => navigationMessages(messages).length === 6, 'wrapped see continuation-row click');
-            assert.deepEqual(navigationMessages(messages).slice(4), [
-                {type: 'navigate', version: 3, targetId: WRAPPED_SEE_FIRST_MARKER},
-                {type: 'navigate', version: 3, targetId: WRAPPED_SEE_CONTINUATION_MARKER},
-            ]);
-            assert.equal(
-                messages.some(message => isRecord(message) && message.type === 'renderError'),
-                false,
-            );
+            await waitFor(() => hasMessage(messages, 'rendered', 2), 'multilingual replacement render');
+            assert.equal(messages.some(message => isRecord(message) && message.type === 'renderError'), false);
+
+            await panel.webview.postMessage({type: 'render', version: 3, svg: '<svg><script>alert(1)</script></svg>'});
+            await waitFor(() => hasMessage(messages, 'renderError', 3), 'fail-closed hostile render');
         } finally {
             subscription.dispose();
             panel.dispose();
@@ -151,11 +77,11 @@ function graphperSvg(marker: string): string {
 </svg>`;
 }
 
-function wrappedSeeSvg(firstMarker: string, continuationMarker: string): string {
+function multilingualSvg(germanMarker: string, englishMarker: string): string {
     return `<svg xmlns="http://www.w3.org/2000/svg" height="1600pt" width="2200pt" viewBox="0 0 2200 1600">
 <g id="graph_root" class="graph" transform="scale(1 1) rotate(0)">
-<g id="${firstMarker}" class="node"><polygon points="10,10 2190,10 2190,700 10,700"></polygon><text x="20" y="300">see: https://example.test/reference/with/a/long/path,</text></g>
-<g id="${continuationMarker}" class="node"><polygon points="10,710 2190,710 2190,1590 10,1590"></polygon><text x="20" y="1000">urn:irdi:0173:1:02:AAO677:003</text></g>
+<g id="${germanMarker}" class="node"><polygon points="10,10 2190,10 2190,700 10,700"></polygon><text x="20" y="300">description [de]: Beschreibung</text></g>
+<g id="${englishMarker}" class="node"><polygon points="10,710 2190,710 2190,1590 10,1590"></polygon><text x="20" y="1000">description [en]: Description</text></g>
 </g>
 </svg>`;
 }
@@ -171,21 +97,6 @@ async function waitFor(probe: () => boolean, description: string, timeoutMs = 20
     throw new Error(`Timed out waiting for ${description}`);
 }
 
-async function waitForMessage<T>(
-    messages: readonly unknown[],
-    predicate: (message: unknown) => message is T,
-    description: string,
-    skip = 0,
-): Promise<T> {
-    let result: T | undefined;
-    await waitFor(() => {
-        const matches = messages.filter(predicate);
-        result = matches.at(skip);
-        return result !== undefined;
-    }, description);
-    return result as T;
-}
-
 function countMessages(messages: readonly unknown[], type: string): number {
     return messages.filter(message => isRecord(message) && message.type === type).length;
 }
@@ -194,38 +105,6 @@ function hasMessage(messages: readonly unknown[], type: string, version: number)
     return messages.some(message => isRecord(message) && message.type === type && message.version === version);
 }
 
-function navigationMessages(messages: readonly unknown[]): unknown[] {
-    return messages.filter(message => isRecord(message) && message.type === 'navigate');
-}
-
-function isTestState(
-    message: unknown,
-): message is {type: 'testState'; state: {schemaVersion: number; zoom: number; scrollLeft: number; scrollTop: number}} {
-    return (
-        isRecord(message) &&
-        message.type === 'testState' &&
-        isRecord(message.state) &&
-        typeof message.state.schemaVersion === 'number' &&
-        typeof message.state.zoom === 'number' &&
-        typeof message.state.scrollLeft === 'number' &&
-        typeof message.state.scrollTop === 'number'
-    );
-}
-
-function isViewportState(
-    message: unknown,
-    zoom: number,
-    scrollLeft: number,
-    scrollTop: number,
-): message is {type: 'testState'; state: {schemaVersion: number; zoom: number; scrollLeft: number; scrollTop: number}} {
-    return (
-        isTestState(message) &&
-        message.state.zoom === zoom &&
-        message.state.scrollLeft === scrollLeft &&
-        message.state.scrollTop === scrollTop
-    );
-}
-
 function isRecord(value: unknown): value is Record<string, unknown> {
     return typeof value === 'object' && value !== null;
 }
diff --git a/src/test/languageClientGraphicalView.test.ts b/src/test/languageClientGraphicalView.test.ts
index d9b042c..4b9273c 100644
--- a/src/test/languageClientGraphicalView.test.ts
+++ b/src/test/languageClientGraphicalView.test.ts
@@ -1,151 +1,108 @@
 /*
  * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
- *
- * See the AUTHORS file(s) distributed with this work for additional
- * information regarding authorship.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- *
  * SPDX-License-Identifier: MPL-2.0
  */
 
 import * as assert from 'node:assert/strict';
 import * as vscode from 'vscode';
-import {Trace} from 'vscode-jsonrpc';
-import {State, StateChangeEvent} from 'vscode-languageclient/node';
+import {LspGraphicalViewClient, GraphicalViewRequestTransport} from '../graphicalViewClient';
 import {
     GRAPHICAL_VIEW_RENDER_REQUEST,
     GRAPHICAL_VIEW_RESOLVE_ATTRIBUTE_TARGET_REQUEST,
     GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST,
     GraphicalViewRenderResult,
     GraphicalViewResolveTargetResult,
-    isGraphicalViewRenderResult,
 } from '../graphicalViewProtocol';
-import {LanguageClientAdapter, TurtleLanguageClient} from '../languageClient';
-import type {ExtensionLogger} from '../outputChannel';
 
-suite('TurtleLanguageClient graphical-view integration', () => {
-    test('forwards exact typed methods and render cancellation token', async () => {
-        const adapter = new FakeLanguageClientAdapter();
-        const client = new TurtleLanguageClient(new FakeLogger(), 1846, 'off', () => adapter);
-        await client.connect();
+suite('Graphical View typed LSP client', () => {
+    test('forwards exact render and resolve methods, parameters, and cancellation token', async () => {
+        const transport = new FakeTransport();
+        const client = new LspGraphicalViewClient(transport);
         const cancellation = new vscode.CancellationTokenSource();
 
-        const render = await client.renderGraphicalView({uri: 'file:///model.ttl'}, cancellation.token);
-        const resolve = await client.resolveGraphicalViewTarget({
-            sourceUri: 'file:///model.ttl',
-            elementUrn: 'urn:samm:example:1.0.0#Aspect',
-        });
-        const resolveAttribute = await client.resolveGraphicalViewAttributeTarget({
-            sourceUri: 'file:///model.ttl',
-            ownerUrn: 'urn:samm:example:1.0.0#Aspect',
-            predicateUrn: 'urn:samm:org.eclipse.esmf.samm:meta-model:2.2.0#description',
-            selection: 'singleOccurrence',
-            language: 'en',
-        });
-
-        assert.equal(render.uri, 'file:///model.ttl');
-        assert.equal(resolve.warning, 'notFound');
-        assert.equal(resolveAttribute.warning, 'notFound');
-        assert.equal(adapter.requests[0].method, GRAPHICAL_VIEW_RENDER_REQUEST);
-        assert.equal(adapter.requests[0].token, cancellation.token);
-        assert.equal(adapter.requests[1].method, GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST);
-        assert.equal(adapter.requests[2].method, GRAPHICAL_VIEW_RESOLVE_ATTRIBUTE_TARGET_REQUEST);
+        await client.render({uri: 'file:///model.ttl', includeAttributeRows: true}, cancellation.token);
+        await client.resolveElement(
+            {sourceUri: 'file:///model.ttl', elementUrn: 'urn:samm:example:1.0.0#Aspect'},
+            cancellation.token,
+        );
+        await client.resolveAttribute(
+            {
+                sourceUri: 'file:///model.ttl',
+                ownerUrn: 'urn:samm:example:1.0.0#Aspect',
+                predicateUrn: 'urn:samm:org.eclipse.esmf.samm:meta-model:2.2.0#description',
+                selection: 'singleOccurrence',
+                language: 'en',
+            },
+            cancellation.token,
+        );
+
+        assert.deepEqual(transport.requests.map(request => request.method), [
+            GRAPHICAL_VIEW_RENDER_REQUEST,
+            GRAPHICAL_VIEW_RESOLVE_TARGET_REQUEST,
+            GRAPHICAL_VIEW_RESOLVE_ATTRIBUTE_TARGET_REQUEST,
+        ]);
+        assert.ok(transport.requests.every(request => request.token === cancellation.token));
+        assert.deepEqual(transport.requests[0].params, {uri: 'file:///model.ttl', includeAttributeRows: true});
         cancellation.dispose();
     });
 
-    test('exposes disconnect and reconnect transitions once per availability change', async () => {
-        const adapter = new FakeLanguageClientAdapter();
-        const client = new TurtleLanguageClient(new FakeLogger(), 1846, 'off', () => adapter);
+    test('exposes transport availability without a second lifecycle state', () => {
+        const transport = new FakeTransport();
+        const client = new LspGraphicalViewClient(transport);
         const events: boolean[] = [];
-        const subscription = client.onDidChangeGraphicalViewAvailability(available => events.push(available));
+        const subscription = client.onDidChangeAvailability(available => events.push(available));
 
-        await client.connect();
-        adapter.transition(State.Starting);
-        adapter.transition(State.Stopped);
-        adapter.transition(State.Running);
-        assert.deepEqual(events, [true, false, true]);
+        transport.setAvailable(false);
+        transport.setAvailable(true);
+        assert.equal(client.isAvailable(), true);
+        assert.deepEqual(events, [false, true]);
         subscription.dispose();
     });
 
-    test('accepts Task 2 render warning JSON with omitted or explicit-null svg', () => {
-        const omittedSvg = JSON.parse(
-            '{"uri":"file:///model.ttl","targets":[],"warnings":["timeout"]}',
-        ) as unknown;
-        const nullSvg = JSON.parse(
-            '{"uri":"file:///model.ttl","svg":null,"targets":[],"warnings":["modelTooLarge"]}',
-        ) as unknown;
-        const missingSuccessfulSvg = JSON.parse(
-            '{"uri":"file:///model.ttl","targets":[],"warnings":[]}',
-        ) as unknown;
-
-        assert.equal(isGraphicalViewRenderResult(omittedSvg), true);
-        assert.equal(isGraphicalViewRenderResult(nullSvg), true);
-        assert.equal(isGraphicalViewRenderResult(missingSuccessfulSvg), false);
-    });
-
-    test('models omitted and explicit-null resolve result fields from Task 2 JSON', () => {
-        const omittedLocation = JSON.parse('{"warning":"notFound"}') as GraphicalViewResolveTargetResult;
-        const omittedWarning = JSON.parse(
-            '{"location":{"uri":"file:///model.ttl","range":{"start":{"line":1,"character":2},"end":{"line":1,"character":3}}}}',
-        ) as GraphicalViewResolveTargetResult;
-        const explicitNulls = JSON.parse('{"location":null,"warning":null}') as GraphicalViewResolveTargetResult;
-
-        assert.equal(omittedLocation.location, undefined);
-        assert.equal(omittedLocation.warning, 'notFound');
-        assert.equal(omittedWarning.warning, undefined);
-        assert.equal(omittedWarning.location?.uri, 'file:///model.ttl');
-        assert.equal(explicitNulls.location, null);
-        assert.equal(explicitNulls.warning, null);
+    test('preserves omitted and explicit-null JSON wire fields', async () => {
+        const transport = new FakeTransport();
+        const client = new LspGraphicalViewClient(transport);
+        const cancellation = new vscode.CancellationTokenSource();
+        transport.renderResult = JSON.parse('{"uri":"file:///model.ttl","svg":null,"targets":[],"warnings":["timeout"]}');
+        const render = await client.render({uri: 'file:///model.ttl'}, cancellation.token);
+        transport.resolveResult = JSON.parse('{"location":null,"warning":null}');
+        const resolve = await client.resolveElement(
+            {sourceUri: 'file:///model.ttl', elementUrn: 'urn:samm:example:1.0.0#Aspect'},
+            cancellation.token,
+        );
+
+        assert.equal(render.svg, null);
+        assert.equal(resolve.location, null);
+        assert.equal(resolve.warning, null);
+        cancellation.dispose();
     });
 });
 
-class FakeLanguageClientAdapter implements LanguageClientAdapter {
-    state = State.Stopped;
+class FakeTransport implements GraphicalViewRequestTransport {
     readonly requests: Array<{method: string; params: unknown; token: vscode.CancellationToken | undefined}> = [];
-    private readonly listeners = new Set<(event: StateChangeEvent) => void>();
+    renderResult: GraphicalViewRenderResult = {uri: 'file:///model.ttl', svg: '<svg/>', targets: [], warnings: []};
+    resolveResult: GraphicalViewResolveTargetResult = {location: null, warning: 'notFound'};
+    private available = true;
+    private readonly listeners = new Set<(available: boolean) => void>();
 
-    setTrace(_value: Trace): void {}
-
-    start(): Promise<void> {
-        this.transition(State.Running);
-        return Promise.resolve();
-    }
-
-    stop(): Promise<void> {
-        this.transition(State.Stopped);
-        return Promise.resolve();
+    isAvailable(): boolean {
+        return this.available;
     }
 
-    onDidChangeState(listener: (event: StateChangeEvent) => void): vscode.Disposable {
+    onDidChangeAvailability(listener: (available: boolean) => void): vscode.Disposable {
         this.listeners.add(listener);
         return new vscode.Disposable(() => this.listeners.delete(listener));
     }
 
     sendRequest<R>(method: string, params?: unknown, token?: vscode.CancellationToken): Promise<R> {
         this.requests.push({method, params, token});
-        if (method === GRAPHICAL_VIEW_RENDER_REQUEST) {
-            const result: GraphicalViewRenderResult = {uri: 'file:///model.ttl', svg: '<svg/>', targets: [], warnings: []};
-            return Promise.resolve(result as R);
-        }
-        const result: GraphicalViewResolveTargetResult = {location: null, warning: 'notFound'};
-        return Promise.resolve(result as R);
+        return Promise.resolve((method === GRAPHICAL_VIEW_RENDER_REQUEST ? this.renderResult : this.resolveResult) as R);
     }
 
-    transition(newState: State): void {
-        const oldState = this.state;
-        this.state = newState;
+    setAvailable(available: boolean): void {
+        this.available = available;
         for (const listener of [...this.listeners]) {
-            listener({oldState, newState});
+            listener(available);
         }
     }
 }
-
-class FakeLogger implements ExtensionLogger {
-    trace(_message: string): void {}
-    info(_message: string): void {}
-    warn(_message: string): void {}
-    error(_message: string | Error): void {}
-}
diff --git a/src/webview/webview.js b/src/webview/webview.js
index cf7d599..8005907 100644
--- a/src/webview/webview.js
+++ b/src/webview/webview.js
@@ -22,7 +22,6 @@
     const diagram = document.querySelector('#diagram');
     const status = document.querySelector('#status');
     const zoomValue = document.querySelector('#zoom-value');
-    const testMode = document.documentElement.dataset.testMode === 'true';
     let currentVersion = null;
     let currentSvg = null;
     let baseWidth = 0;
@@ -101,9 +100,6 @@
             if (notifyRendered) {
                 vscode.postMessage({type: 'rendered', version});
             }
-            if (testMode) {
-                vscode.postMessage({type: 'testState', state});
-            }
         });
     }
 
@@ -173,12 +169,6 @@
         } catch (error) {
             status.textContent = 'The new diagram could not be displayed safely. The last valid diagram is retained.';
             vscode.postMessage({type: 'renderError', version: message.version, reason: 'sanitizationFailed'});
-            if (testMode) {
-                vscode.postMessage({
-                    type: 'testRenderDiagnostic',
-                    message: error instanceof Error ? error.message : 'Unknown render failure',
-                });
-            }
         }
     }
 
@@ -237,22 +227,6 @@
             status.textContent = message.status.message;
             return;
         }
-        if (testMode && isExactMessage(message, ['scrollLeft', 'scrollTop', 'type', 'zoom']) && message.type === 'testSetViewport') {
-            state = normalizeState({schemaVersion: 1, zoom: message.zoom, scrollLeft: message.scrollLeft, scrollTop: message.scrollTop});
-            applyZoom();
-            restoreViewport(currentVersion, false);
-            return;
-        }
-        if (testMode && isExactMessage(message, ['targetId', 'type']) && message.type === 'testClickMarker') {
-            const marker = diagram.querySelector(`g[id="${CSS.escape(message.targetId)}"]`);
-            const hitTarget = marker?.querySelector('polygon') ?? marker;
-            hitTarget?.dispatchEvent(new MouseEvent('click', {bubbles: true}));
-            return;
-        }
-        if (testMode && isExactMessage(message, ['key', 'targetId', 'type']) && message.type === 'testKeyMarker') {
-            const marker = diagram.querySelector(`g[id="${CSS.escape(message.targetId)}"]`);
-            marker?.dispatchEvent(new KeyboardEvent('keydown', {key: message.key, bubbles: true}));
-        }
     });
 
     updateZoomLabel();

From 9555968026afded5f39fc1fdf7dac5e5d9303352 Mon Sep 17 00:00:00 2001
From: e-filchenko-bosh <FVI2FE@bosch.com>
Date: Wed, 2 Sep 2026 20:02:31 +0300
Subject: [PATCH 6/7] refactoring

---
 .vscodeignore                     |  1 +
 README.md                         | 10 +++++++
 scripts/copy-webview-assets.mjs   | 26 +++++++++++++++++++
 scripts/verify-webview-assets.mjs | 34 ++++++++++++++++++++++++
 scripts/webview-assets.mjs        | 43 +++++++++++++++++++++++++++++++
 5 files changed, 114 insertions(+)
 create mode 100644 scripts/copy-webview-assets.mjs
 create mode 100644 scripts/verify-webview-assets.mjs
 create mode 100644 scripts/webview-assets.mjs

diff --git a/.vscodeignore b/.vscodeignore
index 3d26b57..b015481 100644
--- a/.vscodeignore
+++ b/.vscodeignore
@@ -1,5 +1,6 @@
 .vscode/**
 .vscode-test/**
+scripts/
 src/**
 out/test/**
 .gitignore
diff --git a/README.md b/README.md
index 5d8fb00..65389b3 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,16 @@ Use the command `Turtle: Select SAMM CLI Executable` to choose either:
 - Manual validation command:
   - `Turtle: Validate document now`
 
+## Graphical View
+
+Use `Turtle: Open Graphical View` (`turtle.openGraphicalView`) from the Turtle editor-title button, the editor context menu, or the Command Palette to open a read-only SVG snapshot in a separate panel. One panel is reused per Turtle document.
+
+The view renders on initial open, manual Refresh, and Save while the main Turtle document is visible. It includes unsaved text from the main document but uses the persisted versions of imported files. Typing, import saves, hidden-document saves, and revealing an existing panel do not trigger a render.
+
+Element headers can navigate to definitions in local files. Eligible attribute rows whose owner is a named model element navigate as a whole row; language-qualified and wrapped rows retain their source mapping, and aggregated rows navigate to the start of the corresponding predicate. Rows with anonymous or otherwise non-deterministic owners remain inert. Navigation to remote URIs and arbitrary referenced values is not supported.
+
+If rendering fails, the last successful diagram remains visible with an error or warning. Rendering is limited to 1,000 boxes and a 30-second request timeout. The graphical view is not an editor, does not update live while typing, and does not claim visual parity with the Aspect Model Editor.
+
 ## Run The Server And Extension Together
 
 1. In this extension project, install dependencies with `npm install`.
diff --git a/scripts/copy-webview-assets.mjs b/scripts/copy-webview-assets.mjs
new file mode 100644
index 0000000..8be932c
--- /dev/null
+++ b/scripts/copy-webview-assets.mjs
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import {copyFileSync, mkdirSync, readdirSync, rmSync} from 'node:fs';
+import {join} from 'node:path';
+import {outputDirectory, sha256, webviewAssets} from './webview-assets.mjs';
+
+for (const asset of webviewAssets) {
+    if (asset.expectedSha256 && sha256(asset.source) !== asset.expectedSha256) {
+        throw new Error(`Pinned webview asset hash mismatch: ${asset.destination}`);
+    }
+}
+
+rmSync(outputDirectory, {recursive: true, force: true});
+mkdirSync(outputDirectory, {recursive: true});
+for (const asset of webviewAssets) {
+    copyFileSync(asset.source, join(outputDirectory, asset.destination));
+}
+
+const actual = readdirSync(outputDirectory).sort();
+const expected = webviewAssets.map(asset => asset.destination).sort();
+if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+    throw new Error('Webview asset copy produced an unexpected inventory.');
+}
diff --git a/scripts/verify-webview-assets.mjs b/scripts/verify-webview-assets.mjs
new file mode 100644
index 0000000..db1355c
--- /dev/null
+++ b/scripts/verify-webview-assets.mjs
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import {readFileSync, readdirSync, statSync} from 'node:fs';
+import {join} from 'node:path';
+import {extensionRoot, outputDirectory, sha256, webviewAssets} from './webview-assets.mjs';
+
+const packageJson = JSON.parse(readFileSync(join(extensionRoot, 'package.json'), 'utf8'));
+if (packageJson.dependencies?.dompurify !== '3.4.13') {
+    throw new Error('DOMPurify must remain pinned exactly to 3.4.13.');
+}
+
+const actual = readdirSync(outputDirectory).sort();
+const expected = webviewAssets.map(asset => asset.destination).sort();
+if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+    throw new Error(`Unexpected out/webview inventory: ${actual.join(', ')}`);
+}
+
+for (const asset of webviewAssets) {
+    const output = join(outputDirectory, asset.destination);
+    if (!statSync(output).isFile() || statSync(output).size === 0) {
+        throw new Error(`Missing or empty webview asset: ${asset.destination}`);
+    }
+    if (sha256(asset.source) !== sha256(output)) {
+        throw new Error(`Copied webview asset differs from its source: ${asset.destination}`);
+    }
+    if (asset.expectedSha256 && sha256(output) !== asset.expectedSha256) {
+        throw new Error(`Pinned webview asset hash mismatch: ${asset.destination}`);
+    }
+}
+
+process.stdout.write(`Verified ${webviewAssets.length} deterministic webview assets.\n`);
diff --git a/scripts/webview-assets.mjs b/scripts/webview-assets.mjs
new file mode 100644
index 0000000..f2b8b7a
--- /dev/null
+++ b/scripts/webview-assets.mjs
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026 Robert Bosch Manufacturing Solutions GmbH
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import {createHash} from 'node:crypto';
+import {readFileSync} from 'node:fs';
+import {dirname, resolve} from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+export const extensionRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+export const outputDirectory = resolve(extensionRoot, 'out', 'webview');
+
+export const webviewAssets = Object.freeze([
+    asset('node_modules/dompurify/LICENSE', 'DOMPurify-LICENSE-Apache-2.0.txt'),
+    asset('node_modules/dompurify/LICENSE-MPL', 'DOMPurify-LICENSE-MPL-2.0.txt'),
+    asset(
+        'node_modules/dompurify/dist/purify.min.js',
+        'purify.min.js',
+        '9ab3d44d73c3e3947f9ab72e0f0bc15c7f1931d60b365ba261fc85fe59013c56',
+    ),
+    asset('src/webview/RobotoCondensed-NOTICE.txt', 'RobotoCondensed-NOTICE.txt'),
+    asset(
+        'src/webview/RobotoCondensed-Regular.ttf',
+        'RobotoCondensed-Regular.ttf',
+        '4a7c36df4318fee50a8159c3a0ebde4572abab65447ae4a651c2fe87212302b5',
+    ),
+    asset('src/webview/sanitizer-contract.js', 'sanitizer-contract.js'),
+    asset('src/webview/webview.css', 'webview.css'),
+    asset('src/webview/webview.js', 'webview.js'),
+]);
+
+export function sha256(file) {
+    return createHash('sha256').update(readFileSync(file)).digest('hex');
+}
+
+function asset(source, destination, expectedSha256) {
+    return Object.freeze({
+        source: resolve(extensionRoot, source),
+        destination,
+        ...(expectedSha256 ? {expectedSha256} : {}),
+    });
+}

From 0d3691daf6ae1c328f1b60dac17e2a20b844afc7 Mon Sep 17 00:00:00 2001
From: e-filchenko-bosh <FVI2FE@bosch.com>
Date: Thu, 3 Sep 2026 14:35:55 +0300
Subject: [PATCH 7/7] resolve merge conflicts

---
 README.md                                      | 2 +-
 package.json                                   | 2 +-
 src/graphicalView.ts                           | 2 +-
 src/graphicalViewPanel.ts                      | 2 +-
 src/test/graphicalViewManifest.test.ts         | 2 +-
 src/test/graphicalViewTestHarness.ts           | 2 +-
 src/test/graphicalViewWebviewLifecycle.test.ts | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index a6d1a0f..f0b1757 100644
--- a/README.md
+++ b/README.md
@@ -43,7 +43,7 @@ Use the command `Semantic Models: Select SAMM CLI Executable` to choose either:
 
 ## Graphical View
 
-Use `Turtle: Open Graphical View` (`turtle.openGraphicalView`) from the Turtle editor-title button, the editor context menu, or the Command Palette to open a read-only SVG snapshot in a separate panel. One panel is reused per Turtle document.
+Use `Semantic Models: Open Graphical View` (`semantic-models.openGraphicalView`) from the Turtle editor-title button, the editor context menu, or the Command Palette to open a read-only SVG snapshot in a separate panel. One panel is reused per Turtle document.
 
 The view renders on initial open, manual Refresh, and Save while the main Turtle document is visible. It includes unsaved text from the main document but uses the persisted versions of imported files. Typing, import saves, hidden-document saves, and revealing an existing panel do not trigger a render.
 
diff --git a/package.json b/package.json
index 12c8870..3465f8c 100644
--- a/package.json
+++ b/package.json
@@ -189,7 +189,7 @@
           {
             "id": "select-samm-cli",
             "title": "Select a SAMM CLI Executable",
-            "description": "Complete the initial setup by downloading or selecting a SAMM CLI executable, which provides the required SAMM Language Server.\n[Download or Select SAMM CLI](command:turtle.selectSammCliExecutable)",
+            "description": "Complete the initial setup by downloading or selecting a SAMM CLI executable, which provides the required SAMM Language Server.\n[Download or Select SAMM CLI](command:semantic-models.selectSammCliExecutable)",
             "media": {
               "image": "media/walkthrough_select_samm_cli.png",
               "altText": "Example of selecting a SAMM CLI executable"
diff --git a/src/graphicalView.ts b/src/graphicalView.ts
index 744b70b..753f8b1 100644
--- a/src/graphicalView.ts
+++ b/src/graphicalView.ts
@@ -24,7 +24,7 @@ import {
 import type {GraphicalViewRenderResult, GraphicalViewRenderWarning, GraphicalViewTarget} from './graphicalViewProtocol';
 import {AcceptedGraphicalViewResult, acceptGraphicalViewResult, isGraphicalViewRenderResult} from './graphicalViewResult';
 
-export const OPEN_GRAPHICAL_VIEW_COMMAND = 'turtle.openGraphicalView';
+export const OPEN_GRAPHICAL_VIEW_COMMAND = 'semantic-models.openGraphicalView';
 
 export interface GraphicalViewDocument {
     readonly languageId: string;
diff --git a/src/graphicalViewPanel.ts b/src/graphicalViewPanel.ts
index b2d4959..9af26c5 100644
--- a/src/graphicalViewPanel.ts
+++ b/src/graphicalViewPanel.ts
@@ -15,7 +15,7 @@ import {randomBytes} from 'node:crypto';
 import * as vscode from 'vscode';
 import {GRAPHICAL_VIEW_MARKER_PATTERN} from './graphicalViewProtocol';
 
-const VIEW_TYPE = 'turtle.graphicalView';
+const VIEW_TYPE = 'semantic-models.graphicalView';
 export const WEBVIEW_ASSET_DIRECTORY = Object.freeze(['out', 'webview'] as const);
 export const WEBVIEW_SCRIPT_ORDER = Object.freeze(['purify.min.js', 'sanitizer-contract.js', 'webview.js'] as const);
 
diff --git a/src/test/graphicalViewManifest.test.ts b/src/test/graphicalViewManifest.test.ts
index 1245c58..cc6dc60 100644
--- a/src/test/graphicalViewManifest.test.ts
+++ b/src/test/graphicalViewManifest.test.ts
@@ -52,7 +52,7 @@ suite('Graphical View editor-title manifest contract', () => {
         assert.deepEqual(commands[0], {
             command: OPEN_GRAPHICAL_VIEW_COMMAND,
             title: 'Open Graphical View',
-            category: 'Turtle',
+            category: 'Semantic Models',
             enablement: 'editorLangId == turtle',
             icon: {light: ICON_PATH, dark: ICON_PATH},
         });
diff --git a/src/test/graphicalViewTestHarness.ts b/src/test/graphicalViewTestHarness.ts
index c13157a..1333d04 100644
--- a/src/test/graphicalViewTestHarness.ts
+++ b/src/test/graphicalViewTestHarness.ts
@@ -224,7 +224,7 @@ export async function openGraphicalView(
     document: GraphicalViewDocument,
 ): Promise<void> {
     harness.window.activeTextEditor = {document};
-    await harness.commands.execute('turtle.openGraphicalView');
+    await harness.commands.execute('semantic-models.openGraphicalView');
 }
 
 export function lastStatus(panel: FakeGraphicalViewPanel): GraphicalViewStatus | undefined {
diff --git a/src/test/graphicalViewWebviewLifecycle.test.ts b/src/test/graphicalViewWebviewLifecycle.test.ts
index d3563ee..5414746 100644
--- a/src/test/graphicalViewWebviewLifecycle.test.ts
+++ b/src/test/graphicalViewWebviewLifecycle.test.ts
@@ -19,7 +19,7 @@ suite('GraphicalView real webview lifecycle', function () {
         this.timeout(30_000);
         const extensionUri = vscode.Uri.file(join(__dirname, '..', '..'));
         const panel = vscode.window.createWebviewPanel(
-            'turtle.graphicalViewLifecycleTest',
+            'semantic-models.graphicalViewLifecycleTest',
             'Graphical View Lifecycle Test',
             vscode.ViewColumn.One,
             createGraphicalViewPanelOptions(extensionUri),