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 01/15] 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 02/15] 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
zcmbq+2Ut``7wD9`yL5KxNCyF>OI1|B-Vjl-As|>06;VO4m)Hv;cI*umQJ1yF5;e9M
zun=R6F~**l7&XQu#wdGvXJ+@puD|);|Gu|;bLY;jXU?29=bX79j1W@6MnK9=$vt|%
z-L^$QxH=M{-Zwh+?$fr}Ov^Edc$gq08=9EXyR+(<(<Fp!65s}h9=$`uk5{2D5W?%=
zDVamYWaX_nngjPb^hd~K{E&(Ho@AR-TZFv+g!AFU^G1w`c-mthLhe`Ko>L>TCgdR#
zWDD<W0_QD8jGjDv-;&BL2n8e~Jn44!u&kkfkyY7ntt*_5&V~bKn@q++I|bT}v&ZBY
zKAzz`7us(TQg$9ac1TwE+L~(!dBgKe{KjMz=E>t}0-P^|>pgR`#thr|e9;<&x5Igv
zL*Cd4`Pa=#CL+8WuJQRPZ~U;ljuwYU!KDk~o*cw*1La`Jv9AYNxB3e?o4^5tF1%8O
zu=<)~bM)?k_8Y}ZlM&D~MT8xNAKYUySo;k^im%>15RWSQ^C#)f@vUIPj=**;azKNS
zOn=@A!6Qg#M4?UTGh7UNNLDI~fJb`hYWfu#&R!$E3ZVyx)FmU&fpE~1J-pM{u_I6d
zLUmdl3?_p~peMpxdayUf%G7X`CnESXyB3}cH7le$>MaDL7W8M7F6)T0gjJ{=jz_&n
zDk>lu$eH>fPg)1ZmZ2!p7j?nEqebKhGNsQ@Cfu_eN)nWAP?|$2fHDe7TPOpdB;mVg
z5x#{6(mAL#{T0ojtI&8l0ENhhpf18V<RT14%Y;@aLzsh>(RWa4p?v@i7w(~D1fvb~
z2h>s+1;>w}WwL6tP`D507ovf}XsA!2bYU^n@c_d+<O9bGgh9wjZjG7>{ZW{Zh#cu_
z)C2#GW|9ZU8EO@IgQBQ2G9x`uGChe>=wp;m*8}{I;ThYZ-(yiIeFXcD(Kvh!&BkBX
zou#FyfbGlvf@>cG{Ety06t<s4CPO_HC6Ii;(_@rJry*~dD{2b04-^NQg%U|G6a%>4
z0JXcY42{O$q1p64;MxpzmzkkdAq08g6KJZ?4)voIXsv83>QC(ej{{IodIe38ZG+=u
z(R6YSO`&&CD)|KsBfp|FG6LlREzPB~P#pdTEyp!zD2C%OW@F&qJ~BTvUp4~GlwC!G
z;QoH{5kOsEp+rFgc=JH>gcvkU_63R(tWhia0wvHV(65)MP`H6y@lAm7HJVA6!~PrO
zCVYwJLI1|fSD<ux7)rrkplKwp?x}Dd-uD)D6TSi5C!johzwRQ#BkhA0(I#j#ZH&gl
zI4&Z&Xg1VcX&017zJSsmctEKg4y6LAv{q1Skh1nL)SHPTIs?yGhTj2w-GuRdjywS7
zRADmm1G*c^XaMSVG6$fc?@>o#4H^bxmMk<v3mE<Z&O~|%rPBGR4}+PCC<nM}C9Ot{
zVJrs;UHEwC)6H<*Gbp7f9<Iw5-l2B%G>R7fLW#2P(Ey<k@OZcGt!x1bk$E9MXb)C&
zL7|Eypv7DiF5E^7gq~=g%m+1<&jMO*f;tP|p+!(agx;uyYy#>g1DJ%9=o9&Lv{Zf_
zEtSQiMzU9^Na&8{3lmX+JQ1xETB9aF=Y4=*W|OCAk`RXiWW~sp&I34KqDk~BnnhnB
zFPSfl32U>Gi~I#GN)o(a{|nS#R*ELcUZ8QpFytef4cApc*#Y#m5_ql#1=A;W&*@Io
zQ}!)9=Ly{Nr0yMij=VL{M<L3lRdv6~-O&o5nL?ot@}d`!O5Or(m-RtQWIv*bG6gD7
ze1$g1FTrz*P!P>V5sZ%LPcZfwK<CquH*W(C$(zG7N1{>kIH)J1Y#|+G(F3Tj&<U~e
z292XNh4L#>islF;DMIgM?EOM2jO!ENr>j6~K4`o^pj{007{C>QXKh1~K$|V)M}Q`N
zK;slPfY0C1I9V4o7<hev+!F-}dw}=L(M0+U8U=XIlf@xd!Kv=PFa*t~-=djJt}vPq
z&H`_hq4rb@yah#YLeb<A3I!Ou%a|;@2RI#xVnNP?0<U(W`%#X3BTA6%gZE!Wi)4FH
z4vb+c$c|*;4r&a~ZzB`~UOz!d{x?EW4KftrDk#x#>>kw5po|9r{5cdQNaoMbM%fCq
zgSsIroQ>k4w8O)po`6EgR1{C<ptc~B;^|qCpMRjfWG>)87wG3UDv~b;+2VtSkVYWO
zTwsiwpw>V?nIKmZW#`didKh(*S)k#xKWeR*jus2aC`}lM7Rauk!SZfU@=+GhOcuzH
zc7Tu7LJ+*;K3WR0G*;n&GJu!Qfn3Od=PZKpTR<yO5nY1(@j;+FjNBOfaxLnuz^E_K
zK@e?<V#z_&OmGGMK2>)VSJ$1zBJ##_0Z-l_3*7Z(Ea-!&a4fejgN^~&<c+fM88i#{
z*Mt57wEhzMAV9qj%4#?s0PO*27QPPcc`zQ|LLH4}$(q2qVNl$FrvpJBiEz9Ic%~G_
ztt*-!$dM=L&`3Dm7xae{^rIut*D%rq_<S7dL6?C%x`<-vCb*{z4F&$|3GeIy?~KR4
zpk#6naQgyaHAkJvdz1wwo2-Uw6)2Ou1pVd#d=r7@kv?c4xdC|o8)WD|Xa>{;bQEd?
z{AVM$pdrxi%lai)!Z?9E#7yskE)}){y|RLlIpEv}bcl@WM5Y%%RzOd}bviw%uL-XE
z4&-Vn)K8&Ytk;iBM;ey`Xg3t58=3z5x59KHlj8;j--Pi5y#Vz!C>30`>U1H~hlV8&
z+6{&2K`5+G?0x@Hvwp$*m>uxZ8f*h$GS~6TI6SQH46c8vnf(CzAn9LgoeUTU_^N?^
z9E17`s1Gn4vc3U6LqXr$LtO%LU<2I-JO_3N({0=q0eb-GX(?PY3+iQ14`VeM3fHl^
z9L?rBipd$Ks|;%TxbAm0E(~A)QG+eR><MPmKs`iXx8?Q?*ckt}T2DisM)gMI$;O?H
z$NyS0`-#~w+<s!?rnjS*Edw?|55rmxHU+mKm@WX>F9>yiu)=u|_*wXu!g!qXH{)@A
z!Po0P10J6Nbv2Z|^}Nma+psX+HYk8|C&TyfXS3()OT8>Hco%yomn%%RNQKLoy2J49
zeL5JB9l%p)AakZMxg!-0ACo_l4AR5M<q(ral00HENh%<l>gAI`AEf?pdBtRvB(Ipv
zf}+?8{J~^GMqQ1pZQWmFSlxSJBed0ZYe3(*kj`~y`1!$l`2gc2+0cw;KeU}0jj(ZL
zb~2Y6Y>dH%;&v0zD`EB$vvHXX$Y_<>nP6MNdoJ?hI)2Y*b`m^m8Mo8G4hNpuz@EqW
zg}s*-u!ZVj1AC5L&+H@)6YwJA11`6iO|O%2J`64{n;4%ndq@91CLfqAf#Snt0O-3(
z%>D)*WOAv3+w06;f@>r?{;-zln$L4!{sZ`32sT(K<8P*a8C=ZPua{E`>r&-;C{$hn
zx<?N?mp=d(w?DyN)Y(9FuN8w(qKN?g0b3C0ra`7L{4)FjeweMu>^rt!{|>!ul=z9`
z6#6IGDbhXl&jtK3yf8fST9PS}O(xY~V=_CC*`o|6|51Z&N}2r#HYu|kIo=s=VQ$0h
zSY~&A2%|w;Mo-oi8?-+z-~UbS>yJx){r9@=OS-*o<-eV0cw~AB>g7NOOvim(zAmh*
z1^K)0U(ZW(ng3h;p*+>keWW?izt%b$(8*ItuCf|)dn$?R7NA{jqcWNY9_4mE;{_NK
zHjiLqCDn}Q82wAMA=BHsFm~gF?sY%20@o1owC=Sqv+fsqpzcXMy)YdJ@8Gl!^NRYh
z*3)S{9k6*+EplcyDzo=k!FLe&Nd%iFxJeVtekvRurVPi8d81)tr`sh$80@fy5{il_
zgP<Z%_|IJ0k?LTKZP|Vk?9M7jXv5E*Z~b6PEiii?{2ZOIUkKZ2QvbLB2jUC|0`06}
z>*njh&SD&lDaKBGmmP;+AU5G!2j0SNHc;ERu?9Piv4uMh!76X;!du>K%ORFA*f_|n
z6Yy&k4jW&->xi+dQ&SuUFJg~t#1F#8N7`wE0e*Oi!WLi*)E$+}1KE?<4g4peBivs)
z0=2I53;=kj8N;M2yFJ7ndd7b2jH~W_GTap4v2#~&<gt?~w!zJuo!Bk@@O%^YLJt${
zim|>E&EP;NT*C&)7Zbvs2gRC?F44V%9nzhFag=^=kpCp8rM6*h4)|h!@I>h^3`UUs
zeel!Mi@g4@5&&W}!+xszKN1Xo{EY5AT)_xN_i!Ad8)trxZW9Q<e*@4NeopLyK;5<G
z=Ilxn6O$nLNzVW(a&-l4VGN-0R{?SWSS3S}{wM9Z5sq*>-WPU|!LL7Q2!t&>2p*+k
zqriV~9lH$ZGmN(lFAkBO&dw;YQ&Xp=I>LmetvA2i@CtrF+DJH;YIa=0o33^s(jRL(
z*Z)aRU|r#l=MY0fhbvQwz;&+{*ySJ}V4ABhu86ng+1#&*kSh|v+kwy%Gz-bmP}n2j
zJGDe!Xa?GfD$ss(23<ne(NE|%BmyE-K#Tr>jox?=9)V}znYaXR!)p8r*AW*ILk5sj
z<O}j8`GNdFF{RX$T2mjom@cIybQ@LE<Ma&ul3t@X=q<rl2o*XAJ%qu+SYfg-U$`cG
zD?Akbl3|%rX6ugK<K5@E|L*>W`#&DtJ<UDsJ>5OMJ^ehxJR>|~JzIIU_ssX4>ABN$
zw`YZy%*)ox!OPpr&nv_$!<%@^y{)}%yc>DDdk1=V_RjPk=3DjV{Ch#HtJBuiK_8`F
zdLnP=<u>T$0dy98=QZdldWGr$<2E1`ngH{q;7pv&d$|=KgkHWQPWoP6f?nQ+UV{5h
z-^;ns%Objx?x2<Q1U*Zu=vUB7B=`woLPsH47$W2eQ-p=Wb>X(~NO&V7GL<`Wk8_{p
zzSaG;`=8KD<Z0{a=;`U{3%v~YY*F9K9ni~tM!g)U@1@G1mqU3kG4!$)dWi)~K~eV?
z_?{o(HZVtwsyhQ(0(|Y*2Z{$2Hz+PpY@yiK+16q4Pw^@4$Iv5Yi3w<__NI21_Ja1H
zc87Mmc9V9Ub{;%!MBQ+9g;oXy*LAFYR|}q%+M`eoK-mFh6WqTFN-^wrLg>eCKbk)|
z`Q*iu9#4LKf*wLN;$e@6Ne>erwtK94*z&RI!|;dn!9U<T{~F4q2RRS2AEe)3{-D<b
zzx$uu+kJo1{fYO--XDEG^M3pL!S@5czhnk61+ogF96HKoz}#gU{qH8!%%=n40qkv1
z7;V@8@Nk@0-}qn$gLeq-8;<9|wp2QaH$v+Pyx9T@L>x#Ql*>?VLwPP;CDr7Cv}ah8
z8n_n9|MDXh`m3m*!aw6*@H6}?evV(DnfM8Qi~qsz@OxZ~wZONtu?XA;VFW_Z9P|mH
zL?ALECkkSM=7J~0me>({kSC7B3C%|fh%;#fyy{Ba&_eu}{s^&vAJJlxNV=0G(t{+E
zo@fc_MS7DI(uedV{YZZ@04)WpCY1~%X(XLwkU=C96`|!Miwq`1$WStj3`fOi1t}mC
z$s|%prjlv+C;Sw@B&K8)SxwfEwPXUxCzHt(v=^0=-_Sntiu_JqGYLcfA@9J8bAZ$m
zEjma<Qis$at|}=;8cHZdhp2!Kqa##C<y1jUfZNQdIkf<Pv=y~RXQ?GkruOI>bwJmt
zBXy$Av=MOfSLg<Hr9Hui_ce7#H>n5pMBh*^bPIipZc}gY&3y-wsWJ7Xe$<~f0YBLt
z^gRurfgtOiqMy+(GzdLIzoO?f7`;F*LH@m>A?SA+O2g1=+6?_c!)Y(@G>J44)zK&#
zO=D<tjF?=eEog5V3-*nGW%NBwp?yHD*n!31K>N~ubO7xSW|=QY229_9obd-q(-a5L
zTB-#x9z_45Z)hqVNT1T5!IlW2BCP{UAdLP3QK)7(97o_t9EGE48cnCa(&sdT4iZcR
zQ~H9w#4)%z{f)lDEpRMuN&msEaBKQEeM>WG79EV^aJ(QF6gUC55r{zP@AS1G2r}Fj
zx1*!!7@AAR(mXm2x5pjmAM{T;pDw^1aVNTvE)vWHbKIFO7A)uzx)cw^!vrhA5>KW-
z;i<TUcBDzP2a*#rMzz404ZNu*V?n9kA^Q5iS3va;1(ktLQXmu1NM^_!S%6-$Le^mI
zs*nvtD(#RxazKvA2|1%i$OUwn8*)b;$P=`eH}XM^kuUN?{-_CRiULp|3PQms1cjn7
z)C`3q@Ij&|6pdm~bJPOGqL!!?YK`JhJW4=qP+QavwMQLLN7M;*MqN->)D0z~?kEXC
zj0*Kcy-;tIg8HDos2}Q&2B1_l5T&7Xlz|4JOz1vvD*g@s4xFk5z7&8bWx$VeVnWP_
z1u-X<#EK}1HBk{8;7@ztPzTT~j=-7Dj5l#E8jA*_A!r21sRHx~8iPjSnP>va#>>!5
z;P}N5)hWWu(J+*c=ivo-KKdLlK{;qLIs!bu0L?&I5Yt+OR^p|g-A17)cszaxa^zQB
z%Q%&dA0CBAgAUI|^Kmh8C(H0e7|DEGz(x~~MHBHzJO)nyx$_#N&mW-s{=#qY-}p}^
zd7y{?Fqs3M<i)5IbZ9Qxh&G|kXcB1CEocKmY82E>ZJOM_662x)pW?cC>bY)}rgTt7
zuo?$>dUhDuUX3$@)g(xb1H6LOG|01~n)-I^)!%1;=VH&rU4}09?C6=DHB>G5@)}MI
zTRb4tQ;mA}9|_x({$A>Y0WS5s!v+k94OR>6F>nW5y?6jTAV>cIsQIB#ZLnGv)Xh^(
z{gV6l?602H-bJ0zet?UYmuCm{+2sD}v+Z5H1`G&R%j;nTSf`J4(m|^TQp*E^)h4<p
z^zN@ta8aWHix;!!_3rQErJl8TvCCrUfz&>0-2N1!4-X_59smq<_!Q4dhDSl=<K@B*
z_;~qv0fYnE2dhnky7lhg0YLNu5Y2+rjva#4=0R#Fs4Rji{qaK2#l8C<PXNvt@~H`0
zn9~0^I5>XJ8{ne$0bo5BeyRk#>5s8qS_Y{T7Jll9Qu|jrq4qAv!Nv7+dpK?ps0Mz~
zU=tFEj^Qq?LcMK~N#HS(+BG)7iS5z)Jz>m%4t_T5n5<W;X1YCjM`=${f6QcDdgsVS
za2?W^DirX19a=SE=6Hf8lWp?YW)|Dju#KlV&ez0S!rmaZnaMVxmT;^G+l*zK<!p11
zZR*&@!x9&;I||qx1?-LjjkPtqmu-Gy8xL!^ZV=lnXPfJ6Q^z*()^PDywmG9>FH*s=
zEo=kLe2ujVPQWqP*uvRCY*WWJ*KOf!s6FhBWt)R+Q^z*(_Hbe*+niyW>uduj;8FJQ
zltFA057&VZ3;_Nq1ihUNe0dP`GqY3d#Y|)`#3DPH8tP?833|(1?gaAg!(SNs6tuxP
z(8<$C8L6Q*G!FF5Xpr2S>2slxFkW~hYa%O>y^}YWA5b(>gef{I3KbQK2PUmdo|^`l
zE;fB&=503Etjt_)o@kzJzS;bVg^5L~#TtvBECVcOSw6B#v?{dHSUs{1u`aZ(u>MJD
zp=_+|tjtp`Rqj-Is^+S0+BCOWWAn^5+g5FR+s?@@!)}V*bNguf8TQW{QXJMfnmG1%
z-0XP8$-ybZsod#_b7SXL&eNPvJO9+EZKDd80GGus<*tdY*{-#2xo%V3*15;JC%YHB
zUvq!p{@TOLBh6#3N2$jZk9%PIhj@1O9PByG^QKp<SH9OP?^fPrK0|$eYHZhdY2!bA
zQ++4;p7N9XwfEcVC;HE6(zr?ACg++qZaS;!wSa(tw186q4+2SGlfbyZ+`x5#H-b=5
zSWw5Hw4mWZ#X(1dE(hHW7J`+*&4Y&rUkd&+Bsyex$evKA(7e!_VZFl6g}rGuyxGn0
zknqCr+Yx3FIT24H!y}hQK8tD<l^s<cZ52H~`d&;@%+cmH&5N49YSFjFx!91{Ik9J3
zDq9Y2d8Jict0}F{wzg=U+j?i~pW+(FjgC7V?-ZXFe>Nc`VOGM+Hi>QW+gxfJ)^=;#
zyY0N&4Q*G^?sa?b_DSuZba3sE(P3kUCmka@F6~&;DZJChPOmzT?|idMLYMNcHeHju
zs=Fz><#l_RI6Cn}ceC#K-5(?+CROwZ>7h<;pM1M#a?kRf&wGXU+S=Qy_o<Y^l(&8I
z`kd`+(KoJd-@c3cZtkn;SKi;Qe}4Z<1HuNR4OlqfZffJyDXCWmx(*yY@NAkzT6Wrr
z^j_(AGdwf0GfoXs4(c`NY-W?p8JSnI{IX_cJsRA0@b<y)hL{a$G$eD#*`aNR9vv1i
zZ0WG)!&8Qz8sRshc*L{pxa{KWM<aXv>tEW);Ui~^+&J>Y$eNK)M!p(Zo8y_2nR71Z
zQO?U8an$Kiw?@4jO-6Sdy>LvUF<WyZbFYn!9ou#6);yBunirjyoR^b#Ht(l#jmNbb
zmpAU!_~zp;Ot6^{KB3oy#S=E>gTYylTX1%w$;4I@hfh2)@%bc&No^;kOxiQ)bzzgj
z+`>-_pH23h+;?)`Wc3uQDH&5XPq{bMd+MC2=ceA9W;ZQ$+Kg$JrjzN3(>KpRGse%@
zJmdCE`OIE3&&_-@D{R)3S$k%QvvX%_<~YrnHRtvxNuM13<iXtLbN9@BKCjojqw}84
z&zyg5fz5(|1#=c0Sn%h<)P<K8ii^~X{T7!jzO|&)lJ-jym!vGISSl>dUV31e&9Z=H
zZI`7k8^3Jnva)3tmenl#xd;_G6@?ddEgD=jrD#=AMbU+#yG4I4w^;7CJZ^d4<+;lj
zF5kNR=<;jJpDce@Y*QRm+_^ZVIH!0{@w#Gl@#W%s#cx(9SNN@HwIXFj&Wc$p)~z_O
z;?jz{EB-98C}~{Ms-#y*PRXp2r6uc1)Fqco9+bRUX|>XCW!%b?m7`bASy{SLz4G$P
zdn@0pvRc(>mEWqkRVk}RubQ)}bd`G5<y8+>qt#BU!&Y}*ow>Sjb@A#wtIw{!z52=O
zS8Ghx*sbwg(|k?xnzS|9Yo@GOx@O&)ooi04saf-2&8xL0YdzNnt!=(GdF}AE)7Gw9
zTfX+(+S_Yiud`U!cwMV?o!6zT8@+DMy3%!;bye#gtb4xh?Ruy6LF?PEPhCHJ{rL4W
z)-PVaef_8FYu5j?UM#gM4JvJ0npQfow79gq^l0h1(mSQEH<)ek+z`8=*M^)8b2gN2
z&}_K8;lYNt8<iWIY>eEPurYDt(2dhJmTcU!@$AMs8{cdqo18X<ZR)rwW7EV<OE>M@
zbb8axP0u$An;UHo+uV6`=H|l9MVreupWb|P^RvxwwpeXxyrtEaUR$!a%-FJOOU0H?
zw_MxuWXrp)He18DcHWw~wQy_k){R>=TdTI--THc~xXo@`<87_Bb>5b_ZQ{12+sd|`
z-d45k!M3;Ct+qGX9=5&J_Fmhwx6jzVX1jWO)%IK4U+xfgxbBGDk+@^<j@%tncFf;V
zvSag(@*PKaoZE44$4@(6?s&69+$rB_wbNmz`%b@|Av>dY#_jC5Gihh`&N(|vcWQQ4
z?R>EF?Jl&-WS4T6)2{GcU3U%MHDy=Hu8Lh3%EHTH%TmhH%7&IrD_d2zv215qMcLu9
zD`hv!?v_0%dtUZuS?z9Nx5aL|-LAXCcgOB-ySrp}>F({jPwc+2`_Ar1yKDCddtCQ~
z@9DZ{@SZ7qO7>LjxwPlro<H}>_qy*5*c-h!X>aD<!o9_NH}2iD_r%^ydvEQ1SuQVk
zEe|h`EpJ<%Rz9(OPI*yzX?a<>ru=mIrSfa#x5{7clkc<I=eMubzP|f%_f6b4W8a#6
z75gsjySMLcg-u0JMf-}hit!aoD|S|#uDDfkui~fuXus3`@cmu)58hw6zhr;;{tNr>
z?tgQ@>Ojzet_S)a7<?e-z{CS{4ip_IJ)k*Ib>PW?+Jg=ULk@O6n0au@!IFaq4qiU^
z=-@lGojOR}QJtYKR2Qo&)R)vZ)c4eHDy=I0DqB_dt<0@lSh=<GMCFaj=NdudsfpF}
z(&T6+YUXH)G^HAirb_cfQ+vqaP{^UqhcXXMIaG4!z@f{B9vpgmSb5m*aNOa(hjS0l
zJzRWv<KaDr4<EjA_{rhgBX&oEj<h|JdSv{O#YeUtsW|fKkqbv^j{JNS9d$Yya`eE_
z6Gtx{y>ay3(Pu~B93#i9jx{>wcP#u^+_A35`W_p6Ece)yWAl%d94kHc?$gvyOFzAH
zJofmy<A;x5JAUW*Psd*$7f+a-a5#~1qT;0dWX8$iCy$;y%m0{9f<PXj7k&?xgAC?R
z!C;hk=&u$+T`C3pxB<Lj1`RXT5R_`7HVf>3+vV;6wMk7_Gh2mEj4DC~+o*`=&9m@2
zY~3OguakL*e_`^ESPOFiczz3TE&c*liVMuUcIlpP0gtq>)<0hf4W-l|&>*JzGmW6p
z2pSqUa~i0Lcf;wLI<~QfjoM9Fi6{fd>$c0E09*|mQOj#Ib>{2}wuy(0+FV&_VsM$c
zQf*ZO2h}z;Y7?c}j^E`_qee=#6F=e({lY%f$JQq*f|m#yVGG6HhZoq|`j9SX6P6@g
z{4VzEr)?LvISb{`<re2|B`g_zHuiH|Dh|h`b8y~Vyj9F(Wv*B}M;s0_Hs(*lD7`L(
zE|RYX>$woA%|g|lp&ZRdIPrj<dq`;ThK4t5cql8I;`%OYXj2Q7O$)V!Qf*qJQCfKD
z8kM#Um#C?-(z&6j@#Pmm2P6Ib{rsXLqha9e9USa^BK>^4<@R<Cj?l1^E9`xu;B<tY
zLqvEqIg^ohNK>)$lNDvvS-txWNS$=(U}fo?^_Qw94@e)0$7fED?s&dp$5*yDZ#liV
zuyFUB5rYd`boqSWo+{hVKUdwkwRzzz=r&MSR^6|{OW8%3p}W9rI|gRcc}U$nR2{49
zKZRaWi46Rp;m1bajQX)|nT1xWIPK{M8@lDx(A0SNQFf6>sM=3i8QgG!AuO_?2?QG%
z9TDze4_)-}miiYJrRzNYFXv?b*fDFx^cgFPr_U%^-Y%|H+jgy6x5W=i;LwU`GgcON
zXcZsN4vDR^$$)HO-K_olXLX;oZ{Mu0BeT18@0OF(t@i57{S~v4X78(*)iq~C_oT$^
z?8HCgh4Jx#8;aTiZbkuayubs|0%qr&B1{1ZrV>UZUf^dW^3a5tHiDjO{B#u!W607d
z{lZwK(jBzdRj#_q*;NJSD!mPfLgfmF)TYYHn1-VqS23JM7{-7m6gVb28fZeUaP;w)
zGX%=Qqhqi_&gg~$>9ErrmF=caZQu6L`Xv?pduC%_xrfiLgf@p>bnjM{cIFY@9XBOP
zJnPslINv%rC_CIYF`-=-Jah8#%)wiFmz_8?JF~b=UvUzSU77O9oxZQKTPNJ_5E_gt
zZ97ko&RsztMT}|Nt4aT;gmlO%2VUw0`LMrm+12O+$;F4ANh;_GaC20|FEN>TjVxOH
z1)KfG?=28xNSwSMc#2HHn;5FL424UTC?>*DPE__v8%KqYA5s-y*?PHe-i{r4zVcGB
zmL%b+Bx2y`;i9W}&`vxkx{n^7Mgs9HcqG8%EXLqxA3PH)k;2D6+C~+nB>piG4oHQc
ziElQ@{c?Bh&GD0$VsjEF&ehfo96lVpFFoyWcl_(f;RCf*B1CK9nVw`Y6+nJkf$vFe
zu45K1pn)_rL@;M#O?8!AS1ELrg|4#X6)?STjEqK5Uq_j(f>M7REdCLMEzDO~V0n=E
z^3cTXTPD)mnM)_(A>!J}%Z7^2`eA?ZKFi$4;OQ!%M}(uGA^edVhgOmXN@0?hFv+XN
zOc1fHIg_DY_FgI<l~<IPDuN8ceZ}%iVma=6iOLU%vG~#ftY*)R5`V|R;BS?&F%Ux4
z81D4t!-a!qPHy>`llUDDIi|yH7w|wS$Z_Bn8#Z2*r~wA{x+pKA5ZmI@#2s8q?AeQ8
z(+5?<^?KSsz)y(DQ3KlW0x^&KT)9%MyT`Qd6S5d^O~H4lMmk(`l?1pBYv$;KBlc{;
zkG4#g2ea!5%B=g9F4D`imO2XL>QdrbF4Wj7&6Jg@26&lVc4}w>_)6mAO;jqSO+>hj
z%3mjuR9yZ>(M8{#IQjjZ6DPi}8aa6Ih>?S{vPp#aqxdz1x*Opx5cdlcYs9B+m#V5S
ziZd=<ss2LOm*sULnJB9S+{Wr4lR^Jw5@ZrGG=dB<_7_6Io8F*X2$jLnux2tJl`P7a
zOso<g<EKP;YWqnV!)+1>tu@eZXYg%uiKK#OtN!EJ1Tkr&0Y@!+g-TgzYVZmRepKV2
zJBdEPh?f`muk`}O-pAh$5W~d~_M&TQujAsZ?pb|CjXF<+d!K8r&zvm2AQ20Q)uKZw
z6IN_pEc*-#506j(V~tp#!$mh3r<nk60Aw<Ac&!0mYYAQ#Xt=;ARr(l!hkdLW&^T0W
zt*lfSoG`O?;U|ohv3*m_y6VAC!hnM2)GHPMo@*VDoLswt<cx{Y=~i}y4^CM!EIli|
z&zR4taJT&M?co`@Ilmk&|5c#p#-|S+n=@(&4PP)};(`Ua^1Y9~y^vKI()3v2rH9|1
zl}{*MGHc;%Mu*K|JdOa}nt|`Ti>`-8+JnmrrcaSz%78~kqs^EX3?PddjftF_6sF8d
zVx6$}VLa>)@dPiGzk)h%+*qak4a8%O_9^Zmx5K}0U`#!p{#@IJtj7U>Y>Wy3*Gm8v
z4++;8(2FHpTS3E$aRgQx5u6FOVt|>1R=OJCTIOoPj#?=z9Sn}zIxvl;@o=?;3WT;T
z$Ql|Q9TRP1ZwGwj7f*DY!`Vo&v?Ez2y88JJj<2|I_2SM40y#6X?~tL{S$+GcND=kk
zEhhUlBSh3b_)h$z=DbXpHviy;lFDvf0k5N=FFS#58iCyFufr>69H}>U&>K6}8z5gp
z8nHrl9PZFc7X!G>tvKb_DGl{6pgG*ZQQ^leF#BjA6<sfwG(fiAV2nwfAsyOI3HJ|9
zYdvLc_`;sM&fL|Ue1)x6cOUCEV@PVw7}-T{x79ALzg}$GB3^v;&0X<F2n4Ahykm_M
zwPU&_%)fA_dgZE9e2m%xy{v*UvVb@S=Ld7>h`H3O25K=E7@~=;Qt*md)COz};1fb&
z3SeUs12UMd`f7uxWtD~3#R}~N+Dm39J`<_9c*zo+Nh1G(04YTS0H;NOQ%8uughE7w
zzuz9-Z!f){lP=>&F9YNSd)YIT1{<T4x&$)_t%Esc?Umr+t`}kengP!-Yge*os7}Cg
z#2W4A<z|eU`S|GZ$1_G}jIJr)d$VHVz_bbDG6&{+4(^dWD6?meOd)c@{(#_<Q!an=
z&E=^lg9G-DKXc<o?Z(2jYbH-$RzzKMmoAtvZvK2GcL+*?zRu9okG`jt&{IpPrxN`b
zDl?73&XV<1Vcb(e!Mdn%vgDLy`2h|2g1CudRvC$k<T^yfG>V^pjDv$Mm}z=ZWaofS
zj$ITmrSpO6ANPLtW9=7l3u9fP#tcmw<C-_L&$touu72LBQx|Oc(|z1jd?5ZV&K2K?
z-+Q>Na&yK%4CuJ`)cG5wrJqCQ0N1TT3y7UT%nmEq7Bb$Hy0Mf)59O9jVL~oI9U2Ha
zzBhQP{gJXxOUGh4vhrj3Xnfqca@Ai8vZFO*WDBsi#}wjjfB?;P1<d2NDDXH<9os;2
zoF<fQ2C);cmtHA18gPZZqs$&cpZ3@;ApyVAwt!TV7%REetFyRpEuMH5#$*nj5Ao2;
zK#2;7<Y~Yb3e+emJg$aqX2FK3X9Md(GmE`U2^+OSSt%I3kJ&ej>@&2D$z4`xldam*
zTbUdj4}Iy*`x1lHBvcbhSP$5yj%~K+o6rpc-7r+XCX~QXgJ5I*i1Lkz@*hvW*ZLA6
zKAwi05*M!(7k>7)C8Wo48iPy&+KAJbJH#6~R*kf=q}|kRj5C-?tU+!}FM}5NxM~JX
z&6ELHsvHc^!}Yd3Q^k@t1IwSykRdc3ozbb=z?6<d&l7rmN9C83hc<H-YHIMhdHLz7
zD+cFI9XC|I|NM<3b8e1^NFN|(U*d3g5nIabWJM5VZHJ~Ib+b@)pw8fu*k4U+G}g_y
zzOoM0$W6IEHlF&an<*>Z8)kUwKxJiPgC?8P7&JkVw`pi<Vq@Cq`X}eC!sj%gL%`5*
zR76m@1E}yA8|3AQC_!GZ?+90TB3ph4>rO{T#@KSnEti{AU+ys2HgHPMNi&u9HLEfU
zI#OAPBFumEY!hqo7x9kxN<3ttgebm!_pQx6TOR8t?iH6Pm3TAm2`NO`wIj`1Bs5R+
zB>_(1jdBXG_O^H_wO8LhuP)T#sHkYFJu{)tv!l2W?-XOjC1R1-DZqPFKqy3A)p##h
zz7E>jqAhVf71ox-$=vb|(76lbdJdGSfy&JxM$PF$nl?1B9@kyq@!>oR4UMV5Xisfw
zWM4Daj~O@WDVV^J8R-Ri5k6vA&NY1Y0zP$3`xl;YRF3n+Vww6~GDNJW0e3Bf_bcH2
zRv_s;Ar8)8YGeyYHfW`?fu}T1N@hr@okA<E4UU>vJF%l+G<Y-|4Qm#m^3s`wI?D<}
zlbc<>dh^R?8D4Yk>B#hnGap|TYq2o8U}(1Z^#0KClO|Nl)E6#fZ}Dw({*y1iCcCwN
z%$qiKMaksxg@wSo86dY`08hC|*3`%KqjkMTG<3QM%F0F!Kx*8i`4^)fZ{R6r<O7NM
z=v2PW%8#MXDE{fjtvaOr`qobrQo{;oPhY%j){FvzPss25hCLydZxs~pXAk9D)>NGo
zN1m=)xt-}4hUWmlvnkA3^mCApVwoY&tN|`&vY0nCb+|+@@rC4N6&NAl7a@SY;-9gv
z`2EipPp_}6TrX3L+r<~x#pmKqnce&OSYGqhHOy8+0}QkZU@(W70Uu{hPm-3C><PnZ
zqsE-b*@&7O6Pg^{b%sEJ-N`1BywH5@6EeQ`JdM$=g50E?+Bc;#^+qvJ|Nbi+2dV#s
z(lsVJ;x+-rVuI5T|7KEWLO}kqeGijR6Ee<F>;ut%pj`NbmO(=cw2!N4yml#ZBMY>X
z85C9^(=ZwiejHz*8&Anv{OD{@V`au2Rxl~FY3S^S&N@%sMV_IRZVeZ~^jJ?tk?12-
zr1FXK5`4oS9{f@K8Jpd`|J;O}mCc(wuXI;Y_5{~|@P+IBmtvMYt=3|Pht=|hMQ4tR
zNhi*CioxAh>hLHe^Ks13;ZXs)Tp^94QD>w<ZD4CAK1>7!jOsM7<DE3KOhC;Q19CN)
zurbtdVa>c?S^-lF;9pgQkX)s`QC&?!s>mGe44GOxhA>!Q8jptoEEKq~L10O+NV0=J
zDgqCyV&uoipe68bA805ci-+H5WU=!}Fc)-)&2TF%4RMPjRNOUKKR+W&s_s@C|4yLi
zN2T`~EmOb${mU2M*2otxDxJgM#dvQ7yvst;yhd|u6F{Dc1hA23n>%|M6lNA|f}>HG
zF<_X<XJB`L{mQ0a5vmA~xgc~OFR8AcjAy?Vqw$NkWSMpXplTMGrR}bTTsR#Mg8YT~
ze$)TL1I91#WsDVp`;+Fi+UinZCwLBcon&ocPX(Dv|A{{%6~d(=bc0{Ur_@qI(kIN-
zj%%3y0M`(oV?wX^bkav<>kpk$*g_ZaGMpmEeX#sX8@afBzPLkf`z0VdP1p(AB$R~V
z_gjTQSo@XsD}YPiS3RA!)4^yYZ;a?vA`}i|J<-aQYQh0xaSSg2gCQD2G=mZ2Z8=b5
z6M2=;lDz){;J8c#SO&~w?Lgq~AmDH2!~XyC_aL1r047Es_<MvP@z00%#CKTn!vkzt
zwQk9xl9daWt|iu@R=khBAZM@`^gv_rt|-#e7cZU`$DF-%@pBz~j2=AzM`oZ4+UhW4
z<X7j4fzh2g<y!Uw=?lh{fk1+h0<7p1tdFl=vwGqF)%f0(pMSn0zQDE<CKlv_>m^Qm
zPNx3j(ig8cZksY~2jD5a&PSLFc(MhLwjNJLVV-&uPpPbQY~VoVgm!Oe>LzfG3hr)Z
zit}UG3h9_|ckZL`v8_Iave{QUJ{$X&qr<<WO{YKG$PU6B-$$bOkK&9IkPWc34MU)d
z4uLL49IG)yd>#sTH1Mz+;*q(4Se(Tkv_FqL)LSYHuNSXB8aZT4mW$U{-nL`2#22ro
z7L3n-M<!^O$qwGSJia{4w{p(Rb`!iDz2<eDI;CjCyeZQcbADj+%-4W#e`!8#<o$62
zpxprIO5X<DGE^IQBsJ8RyXq`W-IySP4j2rJ#)}_?en@d6P(2F82T>y*@5Ykcr2hFU
zYVQ4guIg`rod0CfxT$m3eNpq~@_F$G89Bdc=J?q-cf{QA`0CviKhzzT&)hO^MEcCg
zxLf6iZalpqUsF7j_sIurirYZT3dqFdxHsbQdT|OCgMrLs-e?)OR2k{Q#O$`XxLRBa
z&M~`p&t-NSLB4^1O0ehhE&3z!%}8cT;^G4>p|TTTZXE@ZS?8Kj3HGA)t83zyOD9b$
zlBsL0AH9D4i2hz{y>aup?euqerxWmHCwQl+QG``e4My**mz>NOjvXUnxWOGkob2TG
zxaqfI*9&5|+qi9?6k+T;rm8uvnu5%J01a!2f+eRlN1Ty7<PJFL%~A*XWgHA9z(HE0
z8gRO)CBGm50zps~7G?IoE&K^R<QKjW@0|Qw{?AGA`!6oa-)_U(1*><-g4z2wATnPI
zU=U%@z(@!OxL^gn4%bF-8HGG0#mqsG<b%fCg3teSS_HN*ys%X;)abRM4=52FL7K|3
z@S8XfFZo0KLoWXL3eOeizo3Prxi(bmMLKFvko)8-jw?riDUy!`%*$D{+XyD3v5;T_
zCpn)L0b=;5uvas+6+wLDIN+g}QY8*}OkR-lwQ1Tvi8Ecx`rZTRcOQR`e)eT#OG)%=
zNW2<B!CwPj23Z5AYD@{Uslf6BWgW!=9roCt%&px?#%R~l_NArMg>@Sy>*!#n_&I(c
zUkE${aT-M^3#q`vjQGRI?FwiFy~j*i{9x58aSP6p{q|4JI>i?Nzca)_9s>M47D9AW
zbIFtf-vp3@^F=~0%GCeBstmYZ1@F%1?`{lu4P_x3178U!e?t!`JOExA6~VALMBKDy
zjeOzT7VG3|;5kv`J938O&F91MksKJn;w<LG$iUVI$kB)T`zRjl)2^s3Uv4Hhg9m)8
zZHiBY0r_EMR+mkgbxtAsn~%2?lrh8$L^_zXu&S-4!n$?5Kgq&Ld=F%*0G5yj^6&$X
zS_>Yq9*L$itkIYVe6Rcoc??&{V4({^DIkNhg(R^31JOj?o18)LI)itMzt+eQk+@t#
z<<86iv~=dPA<Iy;v$0&ZQ!!`YVKci%b|hU5!p^`ass=Bhfk+2K#?Ma|ngwTPM1<by
z=dbtJfUt4|H(^YaF4Rvpm|KzHg}oPT`1;J+{yn=4_?*galx_XOS|!GHDsU-HAJNgb
zQ{yga`&VqJ96My}&~8{h{rqPKMYH&V<_l8df0)#_ODf=rpnT}}YKXzAz~ete*Kf|g
zQvL`RI1&;#4=@?S7*84qjogY+xW=4U%-e6@K>kb@8H5A?_uR+tuV9w3&RwokL<*Gy
zbJ;}E)hG7$nHgxUt_~>dvF}9HkWuXixwvF@7?p+3e=F8?>oQaBq*b@+Ainr<<LRF5
zwQt*YDPI9}!eT^eFn(^5w}czC65x_>G$a}gHDNv}jh!`*Qh<BOKxqQM0x%Jd4%{ir
zy|N8D6HEa7JTdzy5x!kt_3gJ`?z~Fr(ILI^v$EzD43@9Ifo*QCzKQL=KOi5y;8gMI
zk`sVursGHH@tmo{GsmWcXO2w?TuFd(JWDYbjhr%R3dSF+{wtDgbxsOEu`bw8^w}UW
zDxKFN>1280q`<05>%i$f_nxdCoYOYl%`H74XDCsEf!eZt0!jMk=V_g~V$WCmE_ZH2
ztlB00bOOi)`q2yeF&Oad04p){F%{kq33Q21G%gArHUtyPz)!*Ch_Zn?G`30>0B2Ip
z2=_8@gzIo_Z||jxpfLX(g?Ne=@CAPV`Ol9JetJoJV(Pe*!svvEiUs|1<am0TJ+}C2
zGhqJx&82}$k3~hyi0w+h*!M}(2_;-6ghB@jAo%MDt2j7nIaz#k1Z;u#Z9nW2BW9R<
z*Jmx6C=I<_;Gt35*QgyptO4GmfPtB-wLUh)qH!meF5R`-t+k(>D!{2-htEEvdsi%}
zIAw0OS|-oVTC$?HpAN@KVmCUL({doJ_h?`?2_7Sab2V(P=SeBg1Zah)mMD1zNk)cw
zMH)xl(MHDN2s+oKp>rUcSttS$L-ez17K~sFs*h9XLZI~ob*8-6v>@w)KU`|Rp><%y
zl(u6>1y1U|_jL8pQ9xSmX$d(aNatU$TlX$=-dEQ=3uwH~!>4G`;JA29zbW3=K90B~
zbi2Hj$@_62>c<10*uq*I-g9oVe{_tDq!FK>Fw-7UCXLuoSs3;P+~Cj~d(c?AxFYOC
z;8wwNdzNgk?$<Xi%cHuQ?oH}<`++uxtXus_r?}d001AR;15k;u$Knn8{5r1urLmCc
zooO^#y@rzm5rC6~(*aJbhMy3NUC+VC1J8=xV7BZ8ww^8I3h^EqNh)sB!EhRJjkQv(
zs(-c(GoN&x4rxqO+>@WOX_<SNtGTkNO;j9z<NIj`J~K7lAU7E{LYT{55BP<UI^6*8
zulITI7fSf$3?X$*GIBVOlCwZ#M)W=pE;awn=K%%=Saz%XR#o->?S*&=k9dw>iAuRs
z?F4*KbkZK+{Mdk7Lm!a@i-cJnCK(n1Y<^!p*vqqkKYW2&IB>iV64=~cmKyvaQbUrY
z{2qx_c*6(S-G@;RHe-Qo@aXV(Hn{i<UBey>^NyU5blV1U@-rqa9Bdx6aNvMhUI9xp
z7jLQVmE0lS9t%||$qA{>RYL5_<bFejW#l~mSv#G~Et@~GpGiAwZ7P|&ZAqv2+FKB9
zWAP_M$3Y+K`M{`;M%|K>8}A7Z9`T+Ce1O0WYV0KY5OQY21(^pg?pL(Ax^KU@Om`sF
zt$haF_(7XRHm#l3y>0D%00@2rC4%f<128fFN%N1$C60M`ccsD9lrf@FvJ4k1HZYB5
zIWu~_BxUg>KD==L(Zll>A6AbZJ9^BRF}b5j*0<O}{Pp(Y@0i2lyH%%8uUcGk=JZMq
zPrjH*R{=cCcF|LUk-5Uvs5JOoT1axzz;<E2T(DhurP5V4y!sz4874?LPHpswnDv&-
zs#Cjr6b4owu?(EnYwxM*k=bq1TwT)IjU0i`-x9^RR@(QnJJULJ6Q4ZW@@3Zq?GLTn
z99+)(l?447uJ2dwNAPSU|9K~+en}J#@}JYOxvo;_DjQz?cgvw(==-Rct6CbNdO?3`
zZ;#1AV4Vf#cjcBte5#vkY8+S&ou6UX&g~1|`4Jr33X@yK2NGJ6X01AWxefY+5%4U@
zfIeBnDoakNTyGf-j?|FmZ7esIi*Oe8JRFaEU^4FTa=ZnD*Wc7am*Ir{!6v950tZLZ
zaZr43hw9_j-npIa0xalqSz?D;tq{ATZ<Ye=e2fx+h9dwDe^`&j;V>eS|J~QZ=-R+$
z(O5Zh4@@H~aF~1hGHN<3^S1XUY`XE^{Vpt@h^tmIy7z?L+b(Y1eF^+7{kkXi=`y)|
z*OjtE*JR`~VRUkj0oXdeUu2t=1=A0HwoKlAY~R?p&atgGOrF1|dZBz|dQXmL&$?ep
zJ6R{NaeC_d$DM`}YI&lD)Tnp)8YlCxj46XC4s=v)TLZb)OzSWshI>tTIF)%(z|c|Q
zNqhH(H*sp}YVX}Ac*4wO%VeFzKUQd`rF4?Zms+XT?jUnlU`qfG@Sg|x9|r=(7FOJH
z{2LK7*Wwa<lDCduR?o3WX#>bLR_;8i0>J29I^YOa`H+Kw^ZTvbS=FOQw_)zpM^+^F
zee{yd)Xpqh(y<K<e18dG@dg<?2w*Yx>qxIR(uLBDPv=1ZzYd#0gCF65O0N3!EAiAJ
z@x%?>Ati<U_5Ko<-{8{`euF)0SVzn|z!j+UY$GvcWKS3g^LkDICp<WG6gAAov}7Z}
zvf8;rhvm1!{yO>cb8mN_lb_l1_FRelYzZDjzJGs-T-P=eVzq(f8;*PClS>7djQu$h
zOhyb@|7JGRlcpmYb5ovR20k3{FxC5Wm=m6RnDj0tK+C7{@}I?rxareMx#lTuB0l_y
z9K=hs&$M^(Ix(9xCJu}i9Kg;U4)EAZb2g(%5YMiWfa7QZDW|bD;TbfxAR1W4zo7vR
zP&fiEFq2z6cZQ_^FbCXDYkAEN;yk}OQ=D74I+**Jx9nisSk&Cb1)ZqHd-uFe=882$
z7}g<Ih~juk1U$I`T&5CSMl>p!MMiVU|JnBwfd9~j;yYp((Ug|XqHddJ==dT=oJYdt
ztzlN>h1AyIuL;$dShE=vkH%F(C|;U&KsWW?=O|{5Lt+$6jaXK^<eesFJD2qA-Mi<K
zo&LQ$B=_u@+#yAr7xP>B&Ab^UQ^$R~@3)xojgQR#HfLKv(Dsox=WBe~SZokq<HnM|
z=s$92nV$(aUbIMjEkCV;*B#((B*E(rX_lcH2Wxi@uS2L)rK2IdwvY;{PvC;t8#7v&
z7d^rr7A-Ka-FtWL)u&IdPQ9D#SlXjcO7hYj;#=QC^KOpb*0jmCG2hNR;yXU(w|(D^
zn_4m>?`HXLF?@_h;}QY#7$Ao=9BCYsG*Ine<Qr2%Y{DSXjY%<!8aSwSX4J~#gs_N$
zIaB;~^EBP;M(|oSw#(Fxp<S9rbSx?!*Lh}#pe{|ryO3XszHHw$JS;E8ZrO!S9V0{X
z`>?rzxELn^ov^t9c<l68<D!Dmtst4~kl@Yd!W44U878^4-o3gSU%e_Wrd3$Q*b~Me
ztInL}%ltqt_0q`<BXKQB1|zzoCOoeW7Q>j=sO{Op7>%<%H~b)*&dBj1`7`+P5I(&&
zUOoaNLP%ovF-msN+_81fo~=9PZ$B+LHDvR?aDMu;JC>hVeF7^y9^7~SdZXmqz%Wxo
z^gQ_5ywOM<+?;hKFSR5(4gHB4Pl2;BgvX8Dn`)C9eXP;4M(wFoTZ87|i+dpL(x^Mw
z5h#bbR3m`6{6Py*K8*Eo4ah3RWwNkfQc!zV5fC6-y1?YZu7hVNJ)hR4OCM9*ndB@>
z-`l#h)beu9iVawC_4%!X@~Qc27Kr~q=$fF^x*vt(!tXrGaWGQb>pZBE7BWm!1Y64=
z=pMX#AQd&Hlnn^10_QmbFbKg7vrvtVJ<E4g+wdO2q|OC8t5kadMd~z|zrtUa<rw21
zqn~HQIO_6_6^;sQ$8rN%Vuv@OSK61Q4&2p#V*c!~i0H_L`Lo+?>DPBl`?>i`nnj0)
z%+0U8^8LorJ9kPqexH}nzFqvni7S&%jTm({c~jx)7IE>h>n3mQc_w@K@uanr$ka>X
zuh{<51#Bm>HDwsAX(X6|EO3OcQgGen2-71+X*{|7lNvl9l1(?1c94jNESU%Vu(h2B
zb9chPfx{mL&TtL|It-W)Mj80iAVo;G>VSFX!Jp0kz@`J2F8c#Ny^S0zABo%l7H{Gp
z@n*GH!;<DP5_deJ%}JrwZ^NPuurkCED#CK7rh+VM!DX2OVmC&732<xRn=OIh-T)(k
z8IDs=pFS<Vrpnq^^fG*>o{fD!(Usl@dX9kagMk0VR5$iMY>vq8cQo~3qv)utY;7>M
z)Uh=?`axh$Zx%N5;eimycZ)Q*#VxWKyTwOY8E9~{NwYvW%7v7aa^AQhCtAPqOUi|<
zr+2>k%a?nQfs-8_9Dsg6*wXv`dbIEG^!yo7l#z2QMr2PKxB2S%lpgKc{&McihXOfQ
zn3I<`a_3iPMc>A)8%2hXEOU!>i)xjRPo*#Rk61Fi;#~Fja#H+BL0amt*n}e$1D7-n
zUpB0)>i(DVi5n-TWescIwz9XGy@f+&+hHSGnc15;WVT6z|6zgF3V%~u{TRTC4;fn>
zqL%TX6k!q=I9A5E*7o{!F{P$P`1|<r;~+**|GHmg@v;lx$88E(qy;+q3kK8&OC%Qo
zjR-c&^fIZ}iRxg;9d2l91TW5#La4^v-;3ecJXE9P>0Xt#4LO7mDywYN&@{;PVs2j+
z;blIfdKBv%kx{<7KsIDrc_XSsUY-a-+pwiSP+GcZSy|b#MH?ucoYJ#zdV1epy|k$~
z;?5l$Azr=ny?AXnd~!vOWq7PuEY^ze#S)StU$gm}1C#dO+Ok?cJabK9;ndX`Bj-W(
z?o#+xi#4{u;~`z}Puvo##boiKctK3U8o=);a)@jK8fEbckWb7^<M9ecpz<IVm4K{3
zCXn<Y3JV^oP+RCi6b7BPbLKW3i%m2fWgbJnh9->H|4VGbQejG62DKeJwrJ7Bi165i
zd04i5V%}Uc3-Nq#nsq_j&JpBuhj7>MgsCIPOl;mMDZYh;eDIv2`QpWh{sE)gHksC`
zSyT(iJ?;trc>&WR<cITL-a`t&hiBbAkWUlv6j%zy*1SSY$av{X!-SEmS{4<G*sgs<
z&f+Q9dO1Xc`T>2#0ezW+bPI><h8a5CaltN8m}Ku(S~rjsoA22-G&RoFT=6=GYFzDk
zYO8Cg#v9h>f$Wd)=1cM-LJgNWLS#rCSfh4TR>m6Q6_%{k6A<jPd=gGrEI`Tpl?_&1
zea?ZulpWa*=W<%g6;}W)y%S4@<B0FSW0dyY_u^H&bjDxv*0pRN8zncHZ9-djDE=g_
zZ|DA#$aluHgj;<;YX`+WwAUxo;?q4`Ms;f*kYKO0?->xC*fGCjT=%vhA2FIP3nFhh
zZ!6h)GBxjzZnYj?$@Nw{k4%*X&1JH53Oz$Q1D!H_Lsocw;E2(wwG&s8)}fWA4LIS5
zZfG(;H22)<QoD2^d+x%WvM4is;ew3JMFs7eg|=xE+6+FYpR-{@&gj*vN4M;e)T&j_
zp78!uWKZY9%-<YlVy!r|zydJgHCzJ+#BQjHKxu(97oz7d+4}gBI9s4Al8ht8D@Vn%
zIN|6EZ5%mAM{W`a<IS7!+V}QgLIC{^BO6Gr><b8~RKxdRHz2?k>%WxW9o7u4Nh8b2
zOxY#4<_f~3RJw*w5CKP!g%5LP;S@o#OS)Jlf{gd0)}W(95szg?I6_q4^$~fwU3N((
zzGvez7yL)__`FKLzUx2Th0?r=$2lbLk>tPQP)gnbBeTuI#7w7~^j-iq(bmN*{efU{
zQor8aG8$E#ko%2j6V=-bJe}I2<BK|Xp#JYK^^a=q?kz^i?f?k^jO^=rzXJ`K!B@Qa
z`?z^4aiHY;g)bB_%Nbn2D*fUJFBS3YeDVA5FJfC_g6UV+vFsiE|04KST?S5rFSSvQ
zL5N>V#<xz_;Iyk(NyaVRyN8M$;age+D58n(-BMrGoWXTT_K@_b24e-RG`5(^SFeiw
zVamm(Fxbwld6yOQ<WX&6J2fJ)W<7fj&L0;Z5$>;GYe)FFuE*K3i!iQL$bzhw#+A>j
zb>m9V7?9zIfH#;w^+Vn;bLG78UzbkT^9G0srmytN(f~j<uNkvt?!3*L=FZ=;Jh5x1
z#O|FtCkhi+ojkd!VD<6is|V%h4=PA2C`e<l_JObME2#$LYyohJ0=^Iid=AH<E5eT;
zEB&Dl(PSOe6XC0SCRl;55;hCd({n?g;2y~S5&q=&Ohn(nm)+RCp=2H0Q%%^4Sp7X*
z#Bw~qJ%hlXKM%fV56{Qb_&rz2w?HHc;0d9DZ@fYAdrP?MCr+eofW{laj2S#hDxHnS
zS4%M3{@7{>%2z~uu#i!|TEda9V+2}}%N2Z0H1i$k!oPf_Js4B$3j(AwiO%TUB^6dn
z;PZskY_I%c($Fv$SS~@f&CgFuTb`LaHE$R!m-y=FteYdk(^K(!zMhi+T_Sn3jOF;)
zqA5D6;}fF~DW3BJ_w_TYS|#TbN0srKUE?%sHN;e{4D3g9D=9VGAOOZ@C$>PxUS1St
z&1`uuTXtvb1#1EP<<VNDrI@+%H912Qv=3CcN^EIEg5Fo+L?;;@DXx{NH;KU;v~O@B
zEE5D?OGFRpG+{i*)G!3$XfXT*$`>-5nKPo*V1Y>qHszMpKq!T+LSx<{Q+PjoeK!Wa
zAq}5n#yAmj(|?!_pNMvzF5bod)5RyS=&e6|c{X{HcnY_lB&x;zlW<27BF_|Z63c`r
z+0QWF_l2+f=~v1aWhK_n%|aTG!Dbl-xqKS;5N`&chj$38n(C@Reh|i<X<k1_O<;2{
zp03EEpN#P_Sk#VS0x`Do0`~XEdT&7pBztz491&kQs9Q2*d=A_k*M4$tcvS6M2M0N>
z@*Ce}Q3;7t$mC)-&tBnD7O1Q1^v^ne2g&&?5j3*d!tXmCA1mf17B<0jWlW2Ur+wQw
z<J$Eu&X5*L&^+k;H$XQQ;3ey!qZ=+9CAyJhwgysV7@l#c#?*`x4NO}=&lv=N*xbZ`
zP@uzl6T^okD#Lt;%QhdJ{Poozf4us2b@kWz6DH)ts)2hiPoI4u!jcQIo%V;#<0otd
z8kh!t+!u1@_ZY;jd#2bVsokLE7!4nkv1EN&oebReV_{zt$~LAl<}Wu44Qbp|JdIig
ztAH9tkVpR{3&7qE=|r6r_>4qgqwD1z?pSrLV)=<7SaqVTLy=b#pX}%!y~P*Vy`qvb
zgoJNj?cX}~s}70clV#=mnz)y`1`g@f7dtKO|4mY#oGry5nJ9_^+i(fQ27)2Fm4H6e
zVVi%gK~k4SDM6BBgLhZzyJT;-M*NE&twRr=X??vl%!a|A@nLe1B~Kn|WC!SQ)nyR1
zRvNBiW}I!XB2p9J&nKS1{)Qy(qg032u#aW5FvOY+D49D#*(BzJWFmdI%HE4pF>@ap
zWENq4l7$eIx4(I_!_(LAzItAr+%-A<9FbiuPg@ZhwY<-vFSN&T;q=~l@hw9uw7A7|
z?*kbllgRmj!_4rs{`RRU-G&@kyIGwyX7ZS1rF_Y!?GobKi*@&=m0gYspBvVFRdVF(
zf|TTR8nI`I`?U3ddxBa4Jsps}fcZ=q^CG$E<T-b|G9t2c;Zc3d(8I`5X$h31<Oei%
zy2_qchXd_f+QT__-9Zmt8DdZki6#dA7~lYh`beZc@CEZ6?u20!<{0A$>r3HdDva-S
zmM3|fl_Q=x``3@3b(j(;C_9ARNvQJa;v3&~a^(5=L)d+4zuf7wN00tQW?m>Bz0&VJ
zn1}Y)e!_OqAwtIH_>znTuEDBJ&YeQ$WYpFw+!V3htJcrG@a!m{0O&6PouZ{e8SJrD
zUro^=_|&Wr$TJIS)N;w7VP>frIF6(?^a9LLUlxdA6YA31GMXx$yb3>(x$pM*T8H!O
z*@<-p5WD@%SblPmDbco+L19E(FzYdtpKkw6e%2?9Fp;TS%dHotV3;^Yd_;aiyf-+-
zuhrx}iM<}459sdGYI5)1{i^LicB&jA-Ev3c!!}B}_=jDv%jhvY60A}dUuj!2gGGa_
zELU7k_-0<av5m<}E9L2xvBP|@c9OaI=~bMb3c&_m4+#S-hh3l7#v?FNc7ai(iIbUR
z1xtDa{CY~JB`lTP68j+69T4+Dt~+0b2!a$QZXeHVTd#`;<LZFPNgs~~<E@a~rb%f3
zVMrMG!xikRv!DlTVIDPACz+%<0+&BLSSBe2$$sExB)_o+TX9Wn`~eV+z3!-esNr%c
zMsq-8KxyDKhpm!NiCAir^i=`YQJ^@!1c=d}(0#%Lwh$;cmn{X-nvf9f4Pn8&_aa*r
zB#?QqB>7w1R6FKJ&>geEwoBxGbHlt3i4G-6+K~4Fm%<M-+mc>@hH>tSbRX}h)R2NS
z90MQbuE=#Ji9FOWn+v+88#|tv?1guxR#zutw_0&Eo+XO-OEE@>6<gwqqD=cazyjkz
z=fQYb!Z(5WON`Q?CDow87Tg$vNisytKA3h=U}~ck$;@J^_kV*wpD)^su~+Z~bc!el
zYvS%d{J>WG3?E)iQ+llJq5Ywh6f|DjnCxWuVc&bd3p8&I-!kSfapORucqya@{!hK7
z@GmgcsA1lN_}rI=_80^{D&6}BO`l#pX;L*Uh+G?~^(KqL*M^g~?A`OkZbE0khZD00
zm@!}!18@S<-ASTOqqr_7Rf+ZL=V9QOGt3$UPcl#-OvN|_8s|Pm)vx{$I&WF(9_eaf
z-OMhcrS?0v49H&&OIqbD3u>**WX#~MLJ)a>3liMF2Dz%Esqqkl%mtnA0pED$aQ}Or
zjg%a~FXJ@D0+Lu@Yc32|-Y~bK!FRiWuynqBdt<;G644<4CS*aMqAfb`mEks#u_-BS
z2C+<>4ZYKDKG3?d9&D1Cj?5yD*UxCzs`ff?0b8f@tGqSLA05FaUZjJbgC!xFqf=@a
z$pneV0H>A82D5<~9EM2^wvODjWgA*)XK)d8&mf}*EPLZsy<T4WHIB@k<>1JC`Mk(r
zMy1a`1@D2pwU#E0ZSlSM5-ab<PHs>BX3IkP5>d;Lw4mUDp$kekn3=;Q!4&=*g(*(7
zFongUFbT0!D1?P_lc!&a*KYjG#*nhyZP~9dhF;(kiGgoa^8qr_ZAM8RoEX8V;Fq}r
zWx6v9Lrz)rQWNRKJ@t{HMwYYF$I`krF78}2xEtkh0~1#U8DI;H?y!a?o3it?N?q==
zfeFT@9)=k=Qcjd)kEJ{~pS`Pj^rj5Rdp$`e=k=Ks1BtKWviCHP*_nOuK@}uRLBiCS
z(X>bM2n#$poizO&N2aHwq>I`+Gqzpj$*==cQU>B?uPc7|p~9v7{)4@E(VqFPg{6#t
zr-2a`4Y{$_@C~yDK9FQbJ-rw+Cd+i?wz-t$s+zWIm3w?+dplppcAbQaEVs2pCLfjc
zz9qb)?y1;~jDmOg7{!&OcW|-rf0%m@u&A!>Z+P}OXAU4J0|+RHbWl-I5U}@Nu-7Qq
zd%@lnOKhl#-PkpWDH<IorkSFNB@ryxa??$WNlZ-dQD*c0);_a`bBOuhd;j12KF^nX
z8RtwpYwx}G+N=JSl;6VEmlr~Ek&KA5Rztv2Fq^m#S&$Mz#T1#bp3O*FAqR=H8XlCL
ztE3#=vo<;{BA_BxsPWphPi(H<JTWAg@^p`?&y-a3$`JJzbIvaKPq7UK|0V0WVjp%i
zW=}|7x%IpnMMa}1xT1rg3z1xCf|nt-F=<*58p023l+B4?4uQ8pv9iKTX?48ihV#y}
z9y0XVEo*{9{;}$CP`|Ke3SR#)xxuW~*5X5j^5@aT<cfI=mK`LqPOwiz<QDz}STqRk
z{ZC`?^148tlUkw7DU%%D<+C$6k2P%AXy5ozRU`kN{nxHVwUr|aUQ2GYw8P)B07X5R
zeWu<7ejrbsj$l<e^U~ESINBSlRBQsG1v(DgyQso2p%Y==Ln(4bll_1~G5w)_&m22y
zE*CqiRC;dPd%st9k1kg>hCPK`CvApy7`lR|u3b<dxjGDzCrn;gq_d1axT=H+jjf8q
z2`~-axPUydR(TSo9w)3h14;}-o3VH~@()dkP<o?u?eH#VSjmg!GNPs_6{n9DXJYAD
z<S0{~5IRyC+$`qQLMnEn`Gm%_mD^%$5VDc$R|{~|4M}gJH8xU_#UZSTxIiy-Mjozp
zhgTyCofX9TSnlGr`~qyk@`KkNhm*-o?+OkOhZ9UX)A~8#%eS7r0AzwKl1vo^vBHw`
zNzTj+!C6Fw1?=TFzy9LLD`%8;>ij8vXJ@o(aA;NcF_rj=!CH5I{hQS9_+`dyA1>Tm
zoSC+$QP+~Jr&mVK6Y_Gkc3U}Z{~X@R7@*K-$Ui}OnNr-+FVH92C)KBgk4AViSU2LR
zc-TQ1S?S8@C+5%F|H(Y<Uf8y6;dFR0+eG}%3-&MYJ5e^5FCx=U1W9ehF9!M&rhz(y
za85<lT2^`}fCvHD@@U=*w^n@iyuJI@pdWt-rr(&R?NgqC?iEPbdWeSwn8PPb)UcF+
zmMM=b+G9(XJ!V(7HEY$pncb<++Pry|-nvg8IDLV;r`=`4?a$*>g{QV$YzGQI8~*<L
z+TC}EPmuqjjc0ez+nQoKmC?(^57Z-{0XZ8`WJAf@CmlBszFDTw&64q5I*%RGrR%sM
z>4^#T>Lnzm+oQ9`kI(KgYIOISS(&v`8Ul6}eara>_9VQ0AvCUvFi?EF0bdvgUN<fL
z7x;ZjFk*cgWW=OYO$v#s-Z`!B#DNbr9FP%P-{C(qr0ST#T?-oEH}kYlm8<r<_)X*u
z>F`|=tq=py#4DPRW+9Corb|d{@}3%bLuE-r<S|pOj_lfOZAxt2DI>eq+g>|1)qY{{
zqTy}oR~xi+MB6kmPkGvHHPrq+;y1qVZlG{VEU+hp1K%mR>#Abms*u)=xDzOX1`d8Q
zGV2iFLAWzsX>~>Y<H$poi=VK6uLBOH0{<OrunlqI<E4b%L2Ix8KVF4~Q?>@-|F8zz
z`ZR6Qt7p?@z5B*htr8PcrE1*m7Jd7+XwkD*^T?#cYSojHh(Fz<wU_u(dkOfV5_T!#
zDnRuC$P(rPMDe9dcRZ)P#M%)*F!y2Y1b^FJYJ66V(iLbEp9T56+M#{(?WO!xd=zcE
zDrujV=3yOtZ2L;~(AV*Om-aFLP@fDwj>KNDVQnxUBFzu;;i_b#qIcXF`<GmPSw?s?
z)P2UMRaS?l`ns*1v$T&_+vAf{lE;kb+pddmE1ObsT)SO5&@=al7K5X;;^R~b2$viT
zTg*1*SyZHoqCgtdz$1UCSJ;&&iZ5%onWppKnbGvdy@x-~mz2)O`1~=`3T9gDOl%9j
z<nzz@^Y4JaPHJv;P9G-cz}12fscf_tFbDUG9v`U><Gb+gI_;k7tDnF#^7UZv`+H;v
z#w#d-Fd?V8U;*5Lk|jdYed1N$*IwhTUw?hVmHb)Sy%%46kyW@yu^LbO3;0~KFqb-E
zR*BdlFa^}@kPUW=UMJ5-ubB+J&XkCSNfrq>>UQ_3BGq41UyE90MdSvdYE;mjYLeUK
zf6*K^G}szH3LwJ7SQf8DoMB(xAH?j+ZvGlsXgzkI&RRvz)m<$G_6#-z?&HCtv3NP;
zsbJ0pb19WXyj`*8l3D8zX+%gRGU-(1fg98azLL#lL0)~z0^hK92T-8?X9Ndk!;aCi
zF*iQ6%gF{7r+WFB5${L`0j)K02a<^eHj~m!=WkwR$Ih{1SG6ba0|5%rO|o&&H3Z4*
z#=LuRdMq(hxt8XIblGhp8PIO^?jUd0ge6q3KF&fB4^r{(NHwM8Mqg!-dueCYx8%<q
zJJkBy)o=u~1xAV1Q;g43x%BTNSWd`Q#cckdDoU`H*0a!krAR$f##@9_Yg6eQ3y`{;
zWqeYLHal%xc9q8G^6?dxSov`=3Up;KmVtkma)578W|iz<tN0wXz56H|ue|SmbH^fO
zjM8=SPWMfcK`IcVY+5mB2oi`Ao;pEGoXP7?3v`INrDR>?{rQr!kaEQ!QlO)mYhbOV
zrOxUiQ<Jj(SQz3NHj$BuK!yzonTRxHWd$WC>GlRmK0ZO=VVTO$#jFzlx%m85WVKbg
zdY)I`l&|ago0LB{E!6deo3y_)e);?F`6cyv_>1fR@B>R%UveiLyQnG3uZnu*$k9uR
z;;yKu#TXyM%-S@<_pB<h24wVBu%$&`wm5CPKD01@3fwruL_!yGZp{HE;jkk08Ggaa
zsC$nON>U7+G#t(=<$^wCanUaq3NQRvxOkFYi0*cd;v-73`~5%od*S>!)+>zF{FAN^
z6$dl*c|q?e&>IVx5HGQ6WtNkm*XuB%-6m{Cvg<M5<_aW0#>4rB;EM_4lfu3+#YXC7
zCZS~sAAe}&;BYWZI;hStl5wCq`XD1wnLRvj-TZk4(?;>ZpH0YTJ~wVK|0UzU<PSZO
zz^b{Yd~)yJCsR1T9sk76A*{g*lMvL*<@@=aNiXmVL$G%gTMxuHuE0l84f$Hr4Cx@|
zS8CPOU=3807jm-8)`W%yM~kT>-&LuKh`C0Je=we7F=hMA35SKHm=o%G7=^SAUCHBU
z$S}%;k<1|8%kX$-)X}lgy1!3IME&aRbHYUN(reG6lF7kG4jbQMV6~|J&Bu+@8kPJu
zsJ*JL4-Dwiqic5-`vVHxSmSP;mbl+KRMf3QDEquizdH!sV(csVO!XYrurd&Q;T?2f
z!^mi%6pq4sib0xfU{@&c*1&3TO`FEz(rXwQwl<Ns2BW}afnrN}lco%lA3WHA)P2ti
zd#cQ_-0>Mo(Ba}i*%M|JKi6hSdeN8rhYZN+(`!<~#MUFHjT<t`e)eC^Vf*W*oL+YE
zi<&igL;GRZ&+b(Vrw&`Uby~@(+Vvh=IPbt#3=exM4zUKRBk_l>S~fJfm_kU(3n9eF
zZRn?y!~(q@EQ%1+lql=3@N<Ry?W-qHRRWvoE8c<?X@PG4zJ0|!iuyb3-72ul%r=vp
zL}@qTytN2Pm5IV}hfTP)F#V8Eretagl3RcX7~E1eBZ6ZjiX#aUG4bS#5JQK@TzYcn
z)rS1hv&@f-_BZ#cx}v77?l_Wa_j1})s$Ow2Ft;8%$X8s7{26vs?H?kGSv0yT>&;d+
zTTznp+(+<2Ejf=46gQtW=5bKzcj`>^iLWIiHWs&C4eXE_#3Cj>cZJ7@F@>jEK>O5)
za3PE>azK`7#Ye=5nTK&=BwL$vJTX9|d3eKpo(zydg9l{yyZZdz_mM+8Hha*({sW$T
zGH2N6Ap<AA1yt?5&);Hohb)PSpWkKk<3|eg&bdQ7bm_OQ-+=6q6T9nspFKo8(w7fY
zDJMBb*1uW&6he-Xhl@6ba13Ce2<eA`QcE!wR@Um;3Pr{W#U?3P5V<QJ-B{Q|!CA;t
z!wOv+(SP8;<V73Ux`~|{WH)PDXU~(<W_|0vXLnBK^|rmgC~v`{SyK-uEsGe`GA;AQ
zzJ)CLFzc}sG*1J~<QxA_Yf$9?Of{(DtblT9IwipK(jRUr#x{K5kM1rqdA=`yasO?t
z;bZx2o0eR{_QHRvZ9L@YCdiVCKp=>gHEs{|wwYPnRjHbYc~nXzx0^X19crS<;|<y@
zSnhxoF-`_35(e+9n<SpQ`vBWaknU_VpZHI(?gM8DT=$=6c!1rRZ4>JAVt~E-VBd-q
z{ANK9nk>RQBZ%ds)CiA>sGi)h&aC+m#9#Dj?dQKHENJT!YGvZJgwkJ7kMTYH;fMnP
zl!TbdizDk5y~JT2PZ)e)CLmsCq{HIxho3A4%1UfJGj=^O8F}`R1Oxpf%SYGoda@et
z!)zb14)wx2)c1?8s6^L`n7cHAr8^oWR0s_63#k)4W`6Q^y^<EWDtnm59`*IxJGrE9
zhe7C`sczGKn7Tcm{n!d?%xt;5mpTi3r7pTomdR5o<;1ZmSxxrRC@1nL9m1pnxcm&5
zdf=j(^j=p|1tC0O2G%Zi)**c?G~TnDqzrh#w(>}gtoRJIPDyU=gy{?BY<z6N#O_Nr
zvw|tD(z6>iYxLILHOq6xG;Q>%-MPni?n61_ckkRWe@p(H8BZlIsMfb-X4Bh68_uRA
zt?HjWJ6RaN0>4B{2a|_OyT{@lw1mv$SxFU7W;GL@Zy1kofSKTjFsAYqo1}gNXi~j1
z+r&lutHL?zZuJ0)HYG193rlj;1KV+aQ=Roj$N{p-JUK{~0>*y`pZ~X2)X5YX2@diA
zlSw?7jVGSUo|{snC?7q4>T=QWu{lGjhI$mc|0DmjNkguvUu!?GVE#70|LRwtY~pV<
zYgKdzJk*sBP<w;sI7zX^yC@2)Bo7JIi*^I@$?4dDj5XK4B4yj;cEp5QO9D`8Q6_kk
zNpoxv%<eq?j;g#ou<wM?i<WQSpsbtFsX@2)ov&Q`K+C@Nl6}hZn@=R|Iu{x~W#*J;
zA$R+?sGm_WiUr<G`i5m-zUiF53SMv^x6y;}E)EE(L`VyS6kU_mPUVp1I31iPk;1er
zbG#F%O01#oNu5`{`hE70Pv1EE>8EGdEqB|AQ^t)SKYsE=b$7d~3nD(|?;&0k`8BKI
zzAnz|{nxJT7kjh?gz*s2=!2M>*rOITN7|xf{+TJ%h#q18fdPl`>lgS3YISvQ$uM;<
zv}D@*gh%uUemB%+#&?q=7lK}1$YbV#!ZIUCNlr(0j{s7K$ZS5k-?(9F{aWW!GF~r!
z{R%RZ_a1xv=c6l_-@|#_y`PuzbHA1-$VA2bx8ZTxG0;#25)@U`K;j~yX~`I|=<Z&<
z%P{@S?&yeOQpHUg3-J$(K4~052T9izALPem1%;61lmxR+`S2Q3Z~t8M<HwEapQ+P8
znX_Ck(pM~23g+m@K{)lz`}}$Yug{9BvF6|Ix;JrYsV#r+?MOx4Q<AHMU)k{FmpT)3
znaO*q`?U^;4x8nuoIcBfS@OVziG|(aiZrs)A{}s=;Z&gHgb-`Y4KIenyebz04#DXl
zN^wJQM5LwB5fP6gBAEc_RId~M;LODdZS_|!@f!!j(h~xLD%ykVR~|YextCsiiM4*D
zO4s@oq8)0rhFXVR6W?O5yX*0kj=fc7m#%9YSKi^kL1Npw4AGP=x}U*2U3r>z80#i*
zpFLKF*ei0#7MW@h2vWeBjR|<*uv$UJs(_hLjp13gAhK_1$&`0#T^iImo7(uZ--_P-
z`a=FB9S8DoCGy+H7u;Ji_V>qr<F7}evCXM!ECp$=-|)(3-wk6bF*~DP3ic(Sx0cLj
zwU8u=?j+?hOf5Ju0h(|EX~HIh*5w~g@oPjtU9sXBNEeKig)`c)!LzdP%)Bj<MZ7tv
zL2wp(ym1?~_dq>+*wx(b`oP{=n?~oGbU60rn9Vh6Y##mA(e_QX#t-v9R=jk_&g@Sf
zXIcFG@h9>0tCv@@3d^Q&_W{~Kd6OsSp)EOkoN1G2A5DTkuO@Ug>c4?~6mIMzONxSb
z-c3@%RXtdsLRGgy(82sQb$BrVx~S2aQKc1X)XfA1WnpDtr(kj5L5WY&LzPa8Hyr)=
z*_8$R_+Rhe;D23x<n-7<di^?jovebJ=lueHf2FhY`sEkgKl5Mt8P<{6lw*p!+Z*4g
z<7e*H6*gh~I87Tr4(nBlL>KjQ`$_mB+88oVSaVV@5yyzU@H!?CNHD1!h>EykRf=0-
zc?>Pe$Jh@lPUW(#LF$#T2-nn`@le&;p`rFF{xS6e|0w*`Q7^{7sumnvJ7Um`dIb*H
ziA5_W2Lx<UebSn^=eyrk8YuIdr1_{@0s<zk;Nv=V!aCFipN#{bg+ZelX;5ydES7;$
z!CcbCifUrZX@Xi+Xcy2FO%Qgjq)4OLg{6WKLyN~|F<Mx7SS%CjQY;mbA#4L_Czul5
z>&V*`mT4b1uUgFBBO@M7N`7Sck-gQUCfS?tKa{xY?ru@BN~;cfr-!Z%>a4eGtsd<A
z#w6mj$rC3|Mj4ZB(i?p@yT2WJYAF8y(jA@YPagmE*W*v($sO#kq|)ECo6sYx*~S>7
z7D}*OBC)@)i^Qm<;!V1*nHBAk!jeS!BG}Jl#5j?AU^XLg){4UNSdscibz8~FRGx1v
zF4h*_XY~s{u+_ABSHAo3ef{AHY{BfT>5VS%<LXKDS;-8Gxclkbzi3Lq?p2$1hK0C$
z5Zo!oFdT8xpHTY~EAy%>+ee0t%|@Xsyt>#v;V5|w7tcVtnO3Anm_nqk*s2s{#-a(|
z(BBa5MLDjpeX`W=AAoYtUgjMQr2AJNgmgb==W+w;9()M=H6I1*L6+NiV?``huvf34
z<5un<Si!>0N-1>Ky;RQ4hwM6&B}WcE^n?_PB2kbD`(07s`GJ}l62fG=0j&#T7ry!C
z0?**fnR4-Fa_o{ZFiISZO`kh&8eqE5|9R%zA6O(CAI1xI0D*m^vJ1eZuRgP2_A?~s
z5M%N2#khhIx0+*&ODI5+(=1+9FQ-`sX;Z{XQBM!!8L&SwTr<bPiZ-tz7S*KeVfg?B
zZW<_94xS|s>@y(3>lR{=ckg150<HZ|3~t`M>1ti1XFm7c$x}Zmo7|Hy)L{1~yJt<?
zZJeiwUTSwSu5gL;C(chfDzDZ<1Cer^Y!b`<2@@t3;t!_E1B{FkU?@Tis)ZN~1--)3
zCZ{p&m9O}KhVz>L>x;sf3mYwHa)F;D5MbV=QqTwA^UmzWgDZmq-OW6EWF_CFbpf6J
z)bGL9IAtu1Wr@QGy+`hQp-|FMY6?;y#!2Bi0=G9}6)Ta_3K-%dJ|E$jZ|q_BdhlHg
z0U26*)Mse4_EewYLEN$IQ12{Zy-X8BE;!SSAciH@A2BS`l8fo_Ab5j!z00XS>ORG6
zm%h1sk!Ps>^nB)=IWsXmoxgtT?Dts35cj|K&7X<Hdc{@~a|1|UL~lb0QIFUP%Vi-^
z239B*1rd)E%amY3k!au*AlC;2Fj<?RO+<3k^i1p}OciMxAX5AM<&yI+h7NBz!8ckd
z-Qlk6Hv~0Pd>!8nq}W}IcVM}!iIQ>e8|AYSzJ9tk4>B$i0n72AG1Ruu*gay>B%g`X
zNnTjClGn<hAz7Byo2?Y0&;jLggoty>VGR*NsRfRVz#=g42Pgs9KqN*l0sIfnSr)I=
zUr|`V-*Tfh?2_MDy%mK^S)Jb?DYlg;Tig@qPpzmt?p_5T0{Y7>`HAFqN7ymfq5F7y
z)>-115`50$?zY7V&^ZLz;gmA@V_bff2+Wb>f!PmUxdwU1T~QJAEi8xE$8BozLpm$a
zuD#IS<jo?-_sqQcvxhD@t=RuKe(8rvxf7@J(#tRKzku((a>BfVh4VM4>C0y3tzSD?
zcYX5ixiQbA);ya3_NVV&)MxD6ICs?&WWdlESA+MvihbwNhb)^;NOQSv|FBfTus|xA
z2ppk)AqY(cF!AB)5}^IL-^T+5K(!?0KCr~^f2bJut&988eh;*HvhBoKA#df~al{qg
z`{J-L1y5-Enbb1O9*G^#;Xn+nbt&W%753_-^thQ1F&tVz>!t%>C||onVIgdkg43Di
zpb>Oj!p*T_7)e?zNzn3m`?nZIU^|i0l8hP@3fcg}NC8+5^ZSJNX}D}@XjTR0n-<uz
zWn?wp`(x#^v1-=+?1$Iu>Q+_h(<@s;X{L&NzBBez`?sL0I<)T&qE~U{R98r4;Rg+Y
z7$|o6R}iUu=t_!BZnfc%Y3)R2l}XogRwHrkDNv6`k6~(ofFM~qYEBG)x!5uW7pidq
zpRjoT@h1U=m2UD+S<KB!h3{=VcyME-!b*=mb#Q|{j=u;!j`Nq^d53jC9h|~2;oH7B
zbLLBRK*`g0&Yb=lbGwr7*FF;bh05)JE7u<=%Jni)j{J+DScvjEMH?Njl%TFni1Kf_
zo#o<Q%fM50aIX+l;Rq3F;bn`1+1rKz$t|=mQNM25tp+cN^)t*aTEQT#PEp&9UElkn
zaK_?xkF_OsQbvSTdH+Y|;@MBHs2Zl=aImdK9W2#Ei*t;)*FuBE*brK}<TA<e=Ae($
zj+`c1G0!nZM;YtSmKU-mMfY}k1~1Ms+>q|g_v<V1G?1`|Jbh~a!`n;q;qSMnOeC?j
zy+nvb@Dj4s@yfkRCR)DXJ}j5$QD8IL#JNT1s;Ao1LXI3WT-ZXxAc%8o(STxApR5Ni
z4tN|^B32lWCzvIJaU+xj&&is}57KjSvO3*I#K{`!J|a(6+GFdnUPD1{1<@sI@V`5|
zyq1;s1cu__viXVpM)dSFc^PT%Im*JhSVk|cz@4*bc9Pse&9|`d{+|ZLYL1}^P>+E!
zZGh%=1?H9X6;qE9%V{f#G|^?Q!~k8UlxquJL2?dR4=+ttYRV|V>!sgn;li%*%$r3=
zlS;B#<8?)Zh-}!1RI{EhZ5(LFrofmhHo`D!LPYOb(S3w+5RJ~Qi1$Oq6hKOP=t5Qd
z^BVkZ9Id;4N2{P^ix;iqZP{z<7A;<;eyqQbJi8~*{jG%mz@Or`^!<mJa-rLf=!;A}
zbO7_Y9kw-{^P%txcn~Em%9T)z%WqU6V5Hh*_71u##RxsHQmWav0|m@%v0>JYJf;lN
zS0HsWj9dk4X1M*jk;$~buyFrBHlrEiUIPXhww@}H%eSOafR12OUk0yGtgWBH-IhaL
zY{>GOv@1+NHXw>=<`kC_K(S16QJd6W5mYjuj6_r-#1nZ<XUYex%A~xz#cW5>Z@*oh
zJ$K&ptIFK0Q!B521<Bb^`DokfW#oreY<;0;?a_l_<JXcIB0@)$RRv}I9OT(&u1X>p
z<Y|y-ZqMb4Kx;)12`0BxATuL}m=GwCGLZ!@Eyac5)bxRGFdT=UCpHM}N(p}X`e$d(
zeEQXExdV48+U{q@t_e}=uSuT-hXnv_)j#=n??-+~C*qe|aPTdu5!Sk`{^ZQ4kb|4;
z4O;CywIOov#fy6*H=ZQ<vIGy0!Ef{T9(>X*C|AHNEdD?B;8SH4crxLtk+!&mO*>xL
zzsJZ4ZydRGt4FV%J#W3xyU(COPiu|0Y|5TjJ$&^;+jg*z_-nm;bnW{H>(;qD(BN>M
z%*Nut%U&+;P}1#H%O0F}s9fQBg~}jxcgYC+gjnZV{FGKv%ta`5BcXI~9FRh2$RG78
z0A@Q2E_o<7K$68#<U{y)NaTf~W3`>Jq==OV8HZE6YM3(dGrG0&^;709bewQMe<GM2
z@$J@}E%|!Kz)wGC%S(pxB-Rquy&ovmUgdubQ2xT0Q4?sN0UE7#j3m#J{4aP^zT=$@
z8qz=6F%(IM9U}tj|B)S|#-g(d%vk)7(74fgdwk)zk9a9-#cz~c8&){-+I@Zl7o1(<
zY4oRb21a))c2fK~+*FiIamnx0Mj|I;v>^d3k-z`aj<Jbi$Oqdo(KQH~0kZ9%>=;V&
z_6Tr;Gc(xv?Dn0yx2MYVOWU4#GrL`nK3AUI_7RdahW6~;uV<e}l)PTuI_2bc)(egt
z*wSTweDu;GTMs?ESMNS?ME8NcH+c9|orN{?mp)ywrR2&8aVIbSVVVBPhEWa|7V3N#
zY#5~SoKrqw?pQ>f;wdzPdCkY(ejWGye_YEdR-QRW6%`Hr%gvo^BLA~oDJy7+1ub(x
zi`SmA%z;#Q#fFnM3@KZtrne;5|87rF7h}{tq-6#LsdI|>&ySr*iSFNwW<%Z0-{Eia
z4-T-mn2p^44Ul!(K0$*AFIUXAoO%n>NvCHyg0OeIk#Q7FAmy(T8J0o|PJ}5>)+I9O
z$-$JatkYQ_zo7rM=AK?y`ls3&3-lIqH&Y6k8+E>*2l5NKNW>SOOe;&cOo$puoD{-k
z5{dLW1BGJ&GD6Wy(T`0%p68eErwlPWn&|iw9wy;yQfC(N?EnQGTSS`?fxf!zs=+Hn
z3-PFr>=<C7<$<@Sz^lon<-Jp^I;)6pD^g0!WGjPxXj9vX-%m64xaIe~Z2z}dE^G|a
z0LgTQ$F5zuaIR_tj=6RO^~ljc)Mz3-qvAl8r?b$3<UESilNZ7}FC+9KIw=(m8Lo#=
zHwT0$GFhukWp>st2C$;DA=!UMnj-`uxf+9m5XOTjNe0;>IFXU)aXcEBF0qEMTXsr0
zav-Kj<b}wV3Hy&6-J94FPn*W>J*sXQJTx>uuu?+!&_V9ZenUgz0|VoNhxJGQ6gz8F
z(VyMokrgXZQbOoY{IiMyd@wuUAAoi$p(pO>ddb(iR&?lap=MVjH2urhgdBp0^Jl?t
zEv&Y#oR9|}b*422ql-cYkLOYxX0wafxS|Dtue!TyjZ22A`*3U}vQ~7z0a$awuJzix
z!U~W#6I!dhkPPOk6fE*Fp`2PWOu)qD&E0f0yRcT@8n2x%95_6sSFJ*}s$#`+*I63B
zw03%6B?VbZ9@%S;7Gs9r)@$#|+gf--aE*LN+J1jGIKhryQxo=XYnD*N5(@7RkfT@k
z33zUde=0v|e+l>go4qS<^3S*bU)Z}%4MO%fPTXH!MvJi;AOd=9Jmeqc|CsDuVMj=E
z%Jf)&j~+`7Su?^hB(lkOOiHXp(}wGY!ct`IX2c?ZZ5*@gkHY89o_&r_M3u|+!oIzF
z^;Isuy=U)v<YT!1;NzwZ=sSnjO6a26_n`0ZwyvbmqTfhz#j;9k4*0PDk*({c)MM*P
zTDy2?EmR*bDk>RbBA3n-9Ijr9Mc)>6rJ&c_OVh&PlEDAe&Ml*<Z0@}DSSTr@f_S_e
z?32F8LyDI1JBvyogIsienzdGVD^0O1S5&wNfkmad)F|45mSoq;BH0z34@1Oo{dzEM
zyxLM0Ry-+*z0!Ha%c}P7);B-=@YLgln(|6+_u->`_y;V}Z<OkqIZWSngBN|1bQega
zN9~hWytS=h!^>EE#kLeSZX1yY8Y^vFi!`!G3kf4*S$WH7Sh%p`fkR?qP}0dw20Vs?
zzyhSTOhXo?t~GOsbvvwn_9it9IdkhU4$j%$rXiEBqGZC;G$iOfUK^~j+uS+?W2)nk
ze<s`ZpS2z@bVjh@@e58hD?ctDm0A*zN@NPqkthPuYCKxZQ;LF0NxDEW)FB#QD8BmH
zpkZ$xda6g)!jrxF68Ey*D0X}!dH0yjuk%A)Ca^qYP=J3*zXd+Ubey3n=<F+|v<9U?
z%kxtZCO2Rl-iec^q|lfshbN_mK-Ee~bp@sXXzC;$%&g{8?4);7$iWodq42h8H83=1
zLa{T&;Y^|vKi(6w3q=-;xvn1m2yYAzK~}`~)0OZKMUN$h;`;Qc07qI#dShnvTYC86
zq7Sv#`M1<`>6-f&qrl#8^6<{G|C09lx=WX65B0<zqMl>1vTv8zHgecfCAEyIn&|De
zz*!Ag^ri;fp8Z3KbLRb3xf(_J|L2}>C?SHG&whST-!}rcd0_81p8^%#-)Ij($F}c>
zJfhfl-UCiMISR4HQY`$Bv2Sybu3YRJ(!_+&L7eCnU-4e097%EV6i`Q<f9~8loB}^S
z@oKH=y}KzZ&iC!z8+^&9ytZ}wNujNu;s4sjZv4V-xUcgyc|E%#BZkHW-PBIGa^+*+
za&;_*t~?0J4KhghyntM%8P5=;EQeeN;b7WYbn^W@_U#=aDWr&f%TuE@G-}WANWWIn
z#n_as><MFZtb}V25Z+O-(tD5%)PpQic3%_Oeh=JpQWX&+l0k4+WEHXJBC+QpY0u%o
z!kvoUh>BZ|Xxe0miX)>g%)H4kn7?hR#IMbb%Yeu8wRVnwZtY&Com+SIEUgi28NS<N
z<3i8!WHVZXokiD?!cGiHj?bcM8F_K=mk8rU=vm{6_?;qt+t6+9pQC6mm;(1+jI-kv
z_z+_x27<V;bckAlq85~Si;*WiJ1!p^9UT^45Me2g9I~pR-tbFCko}eGhlgygle#VU
znM;K^-TRNZJiJfu;Rq@Ibp2NEo;`bic0&ui|5L$+4FzTY8gn-m^jF1Dtn^Fnw%DbX
zguQ>DUmSh^3;L^`+}(RgjoJ_Q*>R$%Q_If%3%hq{(+ynP^_^=S+PCj;?H%Q~yX)em
zOBa{@OY|$HKY*84fR|~1da|H|bdlUF7uXdXD0mV_n@JIIDaNZJx`G(FClvsp74vpP
zXvMl6vHzs9iF1HFP+q^H()^e6hQ_&JL(wn4U@!LRqc!43E<SOvSZlP7_2Ng|D|q(&
zA%pTkKeKHp{now~ae|sa{}LQ2&OgaNmg2=EoPSC3{ENXw3@*%q&=qX#%U}`xtPm{W
zCe3OyT<xZzxgtZTSO|w7DI{?IVqD?KDm1DEjU$2Ld+DCsDZ?Yr9y)+v!k4OgN}aQ0
z;TpD&4;2|wZ+g<F4ipxut%kwp9{0^>`rfUDua4Zgosy(H`BU57gRo&R_Bn_x-^96>
zY+GrJ-J*4g;YvnKz;G!gR7{af7IitQ({@>a)MY>m2)Cyxc;oVOhzdGXf0;@poIo=&
zB`~|H1_{4CvZ><490>FxFC@Nq2FhBc8j4z*0#jR5a+D66={-0LAcV(Ull@U2S?9O$
zglwDY$CF5G80V$d1Jgjb-4BXAc)b#T^O<^uMMYogMnS+4CXS{|W_X7P(;0e<P|y%=
z2O=(9Lu}fMV;5azFP~x0U**xP;dY(904NmviGXdk5(?5lTM+itlc3Wd&&;&R#rUsi
zGdC19XbUV)TRJsJR_65BlRfw{8*_$@yUZW`axiri2Ld_$2?g>rOYPTB(02g&G-$vB
z+df>LV1gvMYb-G-i=eV-Azp79O|ew#U4W#dSuLl%Lo~q6&cq3(cup{M?x2oP9xd27
zl`+k1BCE@En&X9HzL%HU3JckvG~G(JI{aP_IqB?0-WmPa_h8x;TLJV8IK?ogs+KXy
zIk(s#|Mi%H|AR4w3;u^gwQNiVuZ!hj{XV`*E0ZHuY4j1;BfE_?I<3rxdhb~&mcfDQ
z=3ebxt63Nq67LW@h_OvDcDW@>Rc11YjV(P7;zFL&uBw$IX+^4%RHHIyQ{b5VpJ+S~
zMQVjP&PdV>657x$;>jgSkvF;oSS-WBg~Y1I{jYskIBE7^d*S3clZrmPQJo*sBHTaf
zAM;jf)P>LaMmBlJTz~f(Wy!q9=;HGW$RXUssLUMeH52}f4OlP2=k}l<S-^9pOV3p$
zL^P|YBB)0?7BbC{x`3hyb2uEq8-O4o1sTIL*(DeT)waZoK$RQ?U1nw>`ay$ea?n{c
za6}X<N*pn$@cAS60FBy1U(LT#1_YeHeEj&fISOiQPtVzQ{P?wZDzMLRQQx2+8Tvj0
zur6^xby#7ni`X1;4~fkoFN97brLS<F$_qJ6v0}0Y&*g7~Nc~gIgCWUOosw2v@y6Tm
zZ(7Q7W3f6}VjCf00mFO10@9e3VX?9Nt-?a(JU^^O@I&ThL}NBAADi5NO}cv#BEOTB
zjqXW*TT8VKt)lRu=smE8v8W&^FwKG7a~6l~KhJ?wi^Uwsh>^=bKsXaI2j;viAfBLH
zABl)ySrnGwGES7VS>mw>-FqhjaOMwS0Wl8^qNDi-IBPoor4G7p;se%!IN*5y)oHvj
zOq^JDlUFat4a!`}2enZ{lk77Q=qVYtM@@4emtGd@iopqlNOD@k05jEQP*SX^biq|S
zUbu5=r&{{{1g6xcZH%v`39R4P_ac8Ch_Xayn!}kP!G2#1%!tlN%>XV`T@puz6OR&_
z$+t)Fa4^V?AbL0o3&`)_F@xeWLc9o4LuO3QoA|>IC+|!hIdkDxuckI`ke${#Z_SR?
zsiWsCTRi6j17J#Rw0PRsCA*7Wn*3Dl8poEL{iI1|tNsxS5)RH-uyp;5l@ISxcY6@1
zh*#2iU)8P?dZ2ZlB(MDcdY-5S+ymxm=<vbAa=!b{_1?f9xudTgs@XiNbG_ChSF_E_
zY7Ut&b<*PF#zZNj(POFamfh>J=O@H0=)d(@F;R1ppPW2<QBHQ>KI_yFIZ=dTe^;xE
zd=aC5*^}=oR2Iom!WbjX)l{PI3N-4M(Pb|+5OC^?10M-gfT|u?iho?ufo!VlGG2G(
z(!*Z5Jc)<$wa!+r2iV6*BN0&dwxGY)I%@=P{|Ucmq>q&RsWjhSK!En{w>GVkVD=D1
zs)1xr`6CandgJWbH~6=UPn`pLJ=7$^6;!uCho$jGQRJSK35&fc^)<6M&=sjtp5g+O
zEmtw?<CL6ia@-)cBWgyalaTfUuwGCAgwqTzPaq4Dd+_XM?BK*nyz9it1S!o7C~4^*
z40)d)d1EtUo8M6DytZM(YtXyHaCT+dPeZ#y-XYN|oW*i|EMPFg03>0L#A$fktuat)
z6N-=%3<hAT6TXk4SJo@PQ!9T$q7qaqGl*Y2!ykH|W%ui=X75_d9&g+4J~GVd`~ju}
zCU1$>4Y>qn8su&gT7kUq%2$I1lQn}S_Rv6Pi>J_taE5jT>W;BViyn$dsT^XjS|KjY
z|K{`jB0896XEXPjC8D0FNi(DBo^WPoXm#~;Xp^b3YpZ1vq%WOLFo%N@EMQYan__X*
z#N?Qgm(dD|*w057*f+^ZfVs@d6#WRp!-A3<Bqt@~6i0?lXi(+wuy8mMGqW-?w7M%s
zJ+|-VY0H*Pe{tVqqgEDnt<!qnutuFaH6FIFb?vT7Aa`$=6p=sAv2cUIlN%R1rp}I>
zypePDjp2=}jGf`g9{vWObZSI)(5!J)8jYa-3SCQ=0vG)yF*fAK(`sAdE?!;UIGLc^
z;#h+HYucR7XptOm>fz?Bf#CtMD=C@E)4U@Cn_|SwG^7mEP?gsE*AC3f8?=7k>H$-y
z4k+L^GGiL-Pm9UQimtyeGd6QkUf9Gn@2~k+!Q}8Mc~vH^K~L;86T{dSn{yjhnK&W5
zVJ<pj=VpZu9~IU(m-=I?!uR6zX@;t=mcael?CoOcWm+1oRQX-?8USz&EhNE3DE%_+
zGV%?ZlrCp7A*|y3aRt_cjH%~1mRg24=n8BgUPIv3*#HglOz*U9AWEs)raD{6(+oV2
zl?gS}@FIJ>Hw`kw!>Ki>0eWC^;=m0Sg1Y<!I^Tqnhf^<|B@^3dS^5)~i=P>?rEcn$
zA<ta8_=Mg)hul18$Mo->o7;VGwMm>O)=HZ^E~lwGm(OjRw%vYEv48i8`^L@hx@Tv1
z|L&%e^2v90W#jHG?i*WoZ75)ed7pv}yS6GRTXwTOd8=DB3XU5;t$^ocO<%u+=5_+)
zc!~Wh&)gn0ILA^|CuiB!pq_VPk&)nA?24--5N!O7eE<J&vRl-HXvd5XDL>;a8qgbf
zz#9*m_Rt2TR{XcqE{gN$OeF8)1E)PXJY3zYZ$J6UwjN7r)XeX`{pB|v)7xfuXx^sx
znO^Ohb?VV(U$x1cC)7%xJTAAHJBKf7Rf}y@v}TI^qszRs_~VZF@8e>|E+b=S!@3o`
zbXCE!MIU^yXxZA8jICJ5oO!ESH4Kg&KfQo&@71qE^f1yhgg;T|$c3n3TW-v{MK8CM
zC<$~3DYq@=tXF160|QX9qf_8ZQu`;T5MJULlEyT!y07q+z&m6@8#3HN8L_~)j?b`L
zxtI!s#q@cfu%pT)#y{Mw{Q4kYq`q^+h`Dp`{u_s+ViW#I`!O+o4~~?@@8}&Ew&;H_
zFmmVxV0gh|Z<ZS#egdKm4(SByFCv5*^Nd!)z5b)em7zhQ#=qF4JozBcr9FGZi2Qv1
z?Z5M1GTSh|USrUgs-hRC?BpqYmU3C8fOb{%6Yd^3BhBtCh-zyn#K0t@jM-q18%u$x
z2~JN}UMYIvJ!Zdt<7YI9&0n-=!-hqR`Fb|8I?Mh8&{hsMxYYKUzW-V7F5>qta<_3#
z_v7n<gOL4q`sC>>>7$a9e<ln`sa3E|ArJ+9gwtS!nE-v03-=!V;H~|IK$aNRZNlhL
z6BmHIQPo-U6~c}9@Th&_O5jR7^|8<&Mng#5wl{~rB*f?^4N))MBDhPq4|1VG&}CNq
zrK`ABv|pS2zT?q1erxjQ;oqA6zGwZLe>DG<y>fW!v-|{Ge<<$|n{#N|A=ZzNIFv_#
zP0X!nM@n<;e}NbMY|pE{HVti6S!i-rY;t(0d&>sKirAy}l!fe*iR>bM-p?Lhx>gT`
zURB%X3ZS0NFmctgBZ8C%QH^yhsO&}jWLg5*Hze}mch!(m=1v&OShL&-dFizh`TZ$T
z_B935$HxXYY_%$n?sL~3!(Y~iBKH(Hn2ee(XQZQluKVsTme$(-(ejPcn-KlnAD??q
zeom#&C1)k4hw|(;X>6B0rpfe;fGW26-uo1F;hpVA;fbWKdo6${l53j+e>6POBU7C-
zQc1Y>F(sseHID_9^@?=%5pJ<Qj$?yOFG438DR$OK$FYf~*8xQ{!{KZ|kH;36UT<3L
zZ0k7Iwd@rlH;I6Fyx!RI*GPW1yswtKF8}%R*X2K7{`cHNRW+wq&!L*yzeY-}nrs&?
zd-lYO18UYvNp7!dxjlR3s%rn5DK%?wdaqZGs`jgyQmcmhG+p-2rEk`*S;LLK%=oPM
zq1v@-e21$Z^k%=Bc(Z}34i#78quMWe_c3F$^_0eqQ}|ueb3Z+M?3nI)?M97L+<%ol
z=ePA9qeu79>ojas+a6(jo<74ppQqn3e;(_7-;PjxB4Q32__~ttI95k~P7QcL2)j2q
z6;Wjryi%16P!Qvcg_kA*^giJAhN#KFdu3Vn&_ugWVuqb%C5A)u^RXvqsmW?q2n!GK
zQTcekF}<4B_aED{346z%Meq+xYWnl9Sb|zfVHF!kzvrH)@Sht0l~`$E=F`gifeW(^
zHmwAh#9`WjN{Ex}<3RxnhIeQ}5A2BJv9{sIO4bKG*6tnUw!+%CLz3_33V*c&qed4p
z4m3=}fjqU>!kZ|?sEE_b3mFtb5w+QO?ouk2)!I-r2+d*syHF6N1pJSoAbXtqEQNyX
zaqEvAE7>IjL88W5i-vI&2v2Ei<J=ckq$F92S(igG+Vxny{;(TO8auWQe4V1C#s`8S
zS&vVQO%px0NyNmm0Y&VS3wLH{(*`UWynuhlLYmbbKVWQ)nKSrzWc}Kmznpt}uC}({
zjyk)-m-fr=IC8<`q?-^<(q^0mVc?a%291^gp>PJub3v#hGQm+Q;grM}VKSWH3^JAA
zfoycY5cC@Pi|MF8z&RFbKqmPJ$RuMJ>gF8QZ&1HZ!+_gZ1O)g6y-Xd4+SVB}uuoNX
z`rRdLa=*OV&6~RK+do*)u8XPdP{PW-lRA!o9g6y9b-Paxc7mrbgm7=lS(hiu-_lK4
zywSoNk-zP}01;L?71~4Dy>IPK1~m@9I}H<d%f6)C@5;&f4}Mp<6^0@K_GFQ|SD`Wi
z)<OL4I{vPTyI>8_`_$99Td3udWUogSdbcSq<WfUJNKeKF$3bl_c>?R0&TXs#0^exU
zTUkj}pdQ1hrYJxxK_zehjs?DZU1#~D*^aH-1#mJ?;qURUe&ax6E%@lAt5@9!IveBX
zU#nf=TMZ?>#zW_Wt$OrWu+UjqBpa!zW<S4&D!Bg?F9aY_rCi{79WLE}e0QhZ+|@HX
zh?)xi<*&CN=0DUfNPKeA_I*4GL|{FrE^HiVt1SB&S)_xdj#WCSgt08WH!ddnLbyVh
zsI*4Q7_(a!r#f8w6xi}p000fr=zk(IjOqlf9i-Z9)Pw$#`EZZI!X6K&{R!Xn(2^gO
z^`#)qO&APIm_PqbSuExbkLo>;U0FsJEUAZ<S+r!FNW#l#74@$uh7ByXKz>nPGYC~h
znX5r4Nv;s}Hvf?&arbM<i@Ksa)S{&4;6L_ppJeARTrm1Wq0=`dT`*e%#C0CWd{&ZJ
zmX>{EarjBmCFWCxcw7MrdB9wL0is|R$aN+rpzUUwUaY?0LF9EBCF^Q*K@p#z44uoC
z{LC}icYiAD+|%u$JKgz8zPp=S1%1$fG{g<d(I@wxpif@>U!@Q6GZw3y996^*E76vk
z1f-mr`fII23={C7@Edxvr34jn6I-G$mVk?wA8i%LVp{;4p^EEKpwPR9(nG!t?g^Y(
zrrD#sJyRa7*h+|NW7&<6C9pG;FWtAPxml4KrEJ=H?=C<y5Iqs=JQee}8}nGvHq4Ot
zf=)SgmI%qerSrcetSKAI{^D0f)qpaVUENtS%%~h7{#(o6*Ktq*!wiT&o}3>`f{i%v
zWtd7xNL;vVLBbFO1_8X8rdgp$GRGBxA!ACDz??lmB+?9OJ!YAO;w%I7TWwuVD&~4%
zz$q{LuKh*KXE@a%d*~K6y_`}Rh!(p=>~%r6L!>E`tD;5R#gru{sMI_n640-P;3g{7
zyh%5hc3^ksp*f6gTrkNfkx(A~?Q@f$jP#UDD8S^ogC56kq2jPH*#Nqs0a^s6NI#L>
z>J5!y+nRGLR9z4aOeJ%y6EkhDW5Dr~YSIW|9LF-tE}?Bg6Cfkp7KH2+!*K=_Yj_^A
z3@AcU4`|3JZb0^II92sQ#}U9-+OIi>IyYb2^>=>p*7N$1NhkJ1HH@4z<Mf^<E({xx
zGAz^m&A`5Tn=bvk=pA}jf!8gL6|h=wq2>G_ooz2Yb>?e+-Pdm@3w!Dg%ujy)w{Q3G
zUvrV&pRw-qc5Oah@w@Ai-G1c|^djJ#X_cWD(R_JoWGxa~OqN_<?_`m4Qf`?CO&eyy
zJTd5a5$15#Dn^LFnMLkb&%_8oMobKVJ&iI=0{x}Hn3x!fnWd|8M(_ceA+2(cwN28d
zH9LRrrAPFvHcO{Cq8(kjZC{+fr*+e~uC>2xkfNugHO$ZxYdIn!qoP>bKe}CH{%EM8
z99`M{`8%4{^~(I&uc2o6%#3O0ItNr>yXGv|uj`v;&mX!oEp>~K8@2g<`!Vd#K=P=2
zFj_4lPPz|CD426Z5FCd;))Z)<#0$8kMWYBLdP8ziW}YbjV1s$FT8m%tVjhI<+<E_D
z0N5C)2P7wI@{`&$tqJIWzT~N@w1_aFn##p76J<V+;P^M_G65k_?twoRA_T}^p(IQ_
zME!9|>Hmf-OHudj+*xwZTbRPAdxaK*d8tNNKEwilhgFl?N{~sLzp^4a0aZ@5NGuRk
znY{Jb_SoaP4}}`y;E)F$@W7MqfuI7A8Dfgsb_!bYuW8c?8#h|CLigz=;TZzdKYy4w
z$$)5R(*{XQfKaMPNDVY^6QF|(gPamrgI+r2JXsQyWdWV5GJ6o6DBJPS8B1i!kcfxQ
za7kynI;^l(il6U_HN8d_){abF;a8!iD6Byz?d{tfJw_PiHI3sdvJiepVZKymgMK%d
z&j`$?x6VgUBd5@^*}O-mUP0hmpg*QbE>W*Hqk>B2jUcEMlvmVhbGLteSvYf1`^VZq
zP1_Y#^@AUHHgi3-G9uL79aDw<U#;|O?Nh|l2#Lg#3nC_{JQc1Oo0y=ORP*8D1arkW
z$lQcvH2Lx<i95j}3S%GyvAL<+tSE^`sh0<~nQ-sX0EGNUN~qcqojkr=Ua+ZI3s(8U
z=Rdo{9zQyCQ^T4`PF_!`zIe^Djp3{p%FipG-Sg0#&<d;~8v<kd;@pv!OB&SNkla?y
zNq8HZoAf-T^d{n)#gJ`L@D6y!X0iF?47=iN0^KJr)qEt;*y7~a{yF4A(hPFUGd8mM
z;0`klP4)C_R>r+~XY%y5DYXMXc^qv5Pt2d%XHF)%1g;z~US|sjhq8bxZ6l7Z={T~=
z$zShZUz@V_CD9g8ef!X|n$tH5zFxu4BR)--U+9MkxNKr=i(InkvEI>XHsO3l^C{CP
zT)vvnCLpg&x<fsxdIT>a3>g*-Gs*zU!_uJhcwylvHs^QV=hD~zx~}Js-nr#-@YGsm
zhI?@+|B#pbic~jc?T0U2y(VZ~%)eKuW;Bd2)jg-M@PEr~Xo<&olj=hP$%0zo3_)z!
zRDt5MRU!)z;)2pBgdLRypnH#@g5YiM?MH+m#qy_ZqTaBTN|ZqfAHTGe|5>XbVb{2I
z8+~PuSnRuX=!Z)Ai{Vl)6jLQR-r~BD%9ogHA#SN|gTYTqR5Ijl!VO^BiAb|6mv1YC
ztECh}=&l0x4NXPUsV8bkdQ)hyn9fPcCT~mB$-|Tj9#s}JQ!mshLih6MvVvwgnSy3{
z@&AtIW^7E+9)sq3mD3yZ$B-{arLd+Ba!M7dj|B@rwxBjd8-n;i7^KUCaAIU^+7;j<
z@{No>awc{pMc2f$<dQadV89KKDxpY}AmQS{3^6*$1&a=HN_7^*>hcf&Rchlus;ypp
zWAv`ZHIq-gy?VdyUbD-7mT%%Wo&@i%VrUGqDE(6wo>5~%a{GH{S>TnL?;txHV`vME
z$3EzVM`JMeb&!+&Z^z&YF;aQ|-B4sX6%-&t7>b4gAy5`YZOfrI?|gpr<#S4Vv)tgz
zs2AR^SN2@z-<o7bNux5E(H}DK3GjNPZIsCdlDzIU!J){QbOs4@h*}PlCE>D%2ti^8
zc%?r*GXtME(Hc)6T0_kt^m$5lDvt@E>~MdrGKD{N{Pd5fp7~W%&rHvqFn`Hnz~k-8
z=P|)wo)b7`Gk0v9yMHT;OghW^qd&<LV5msKIrLy3Nge2aL$Zl~{v(nfb^oYp3V+V|
z=8vbI{>?-3()=0f?%hjxbmcG3oVoR0p+0TLrkMw}tV6G_OzhJSFyBeG!>w($BzFB+
zhRuiVWHcJ;1(u5UD`PxKwmWTXwq$m_^x4wI^a<Ms_<#Z&K%06Q-zN+pimE}xTeJeN
zpTwpLMS$AAS$$$SiA|a0q+y{JMD*Yz&`HGS5&TrOBA#*an{O^MTd8g4?AbHb8A{W8
zJ^na%<`;L8(&F*i3!VWjLp**G!rJ!uOfB(T?+N2$Bt?=*Xi<M%K?Xi(Rgq(2o_Zv{
zQj;YQT|)l^&PQevK{*4wB|cG7s)Sy=dlzIDwdpfhWf4`+R;#Y4AMNEogKhvT{&DW~
zub}*Ewq{=Tp<d&+cY5dD9bWnelzweriu#H;Te@wyF_&Vy%K8e6)D#)8(&qNIE<jGJ
zX);~GRYj33W<04(yMb5|9SX{7+4V43Ds(^rB+dt@rn+n&%tW4#$=Dh2>a*>q0ztoZ
z<KdIEhzN|1sox$Mw;{34vVl*(rgW&@ztQ-S!^gLLC`!{%z^<|;O|z6{_dAWA$*#UU
ztY|b_@akaxJHM^;8PsP08vU^5SuMXj5qjvIHqC--M`HgpF1=&7fuCy28dsqK$^Bmw
zr3p1jO}Ez+8W6BR&E6L%2j<a-YN9Hmro~_HiW6T2pOKn?Y)1hA0x954dkpnX2Q98K
z9ZI`#17BRVY}T~7)O!Bft!Wdcjbxd12aLiboU0zm)UTdiv(1OioAv0f{D-G6-hJux
z?B`PBpUdx<J(PXm9Cl&!+UEvAQ~X%n`y6d7W=k!-t+mF!@{UssO-gCuU7>Ntgx7@N
zazcwW<v_XAXi-T5$BD^y1A3MCEQXt0w%8b_k<95CRT;}-k)gyU$0vKHfS!aY4|nU*
zzZ;8A>e5SN)gsPSi&oSNTUM>~ZQbl5+tsIM?>?W{KX;y1N_x&nh?qN|eMTc?@A|G!
zbRW67!@s^z^OkmNo2_o^)1}Ao9YC|CadzOJtAquYAbX-)k}9Nha4N;FimKtkuwXq=
zx~r*{)D;yVT*9!+6J(|ZN-Ys2Lmdq{BjT;Y@g%Z_Rt`^BS1z8LH7>65<l&dtk@+*G
z&G=3I^U|$x!zT@6n=A15SycRrj`QcO-?3u;f;BteeP`<7)I{g9#g#)ahVlF(^sZ@)
zed+1zZgC?0_hYCi@;@+!xPKUf<Vvw5at!I}<i&FvO%L<$*Yn2Nf&Kaq_(Q$tI^UyP
z|E{Z5(4P=Cy#ByGIUD-->^<zULyz^Imsow-P>6KU-?H?M{t(t6)}j%}JtecKh3uA|
zJoC14RRHE0m=Lnkv=q(=hq)S-<TeDgAr#BR2y{mQ+yW0tP>|NT6~qRlBKRtb<i_@c
zzI@}!kL$$G7=!w`V`FBJkSH9(7QgZk2?_OuGpft|9iPV6?_||k2Zh|E7*7+(h>=(i
zZw;@-H7aWv#CT-+5~*S)g#kyYC8-*PN~X9BP_Jo)FeIbGH4Csa85oHn7qEk9e7X>m
z%E6m^UdmDvdUsT2u(nOR_fuJ9#5wqJ)a$!;JngIQ;#c`wy!aq{_a}D2os1E_u<xNa
zhp~l+`~JvFF+dv6YOK!?tWT6}q9OGy`n{z|ofHiJ!(thTWRc-i3L%nSUHOqn;(e3~
zM@=3>S}@Ci3_&N9eJaM(+OSrQM@-T%p0iQa746$2+Yb7=KSB;XAWH8agFwIX%Fx2G
zrnO=*?!~YPCMuh0&v@3zJ0=l^lk&~t2$H@RF(%24E?v|HEr2an<#?W+uLJJJ?79N?
znUYgoArX`Yk1+{9JIGJB4o<EXfAqoymRF>-ZPvY?F|;VAU8AM)0Oh2zEAC_r?r+P4
zF;P!ZJM4p488w!HdO^9=F31QlnS$lEjVn_0pe8F^APGX|8rigp$Q<%274R`C{crIv
zSmdpoEltuJ&F`@G;K8*MW~wZ_^4Zux_4iPg!vf$y^=G*$HP^+)^FL4XKhN<$*se7_
zUBh3^>G}bhLNn1TupfL1vB)(MWLiR6GD2kD8!o+~2xTEwXv$B6lr>ZYoQa@K;Ma-7
zB2O+b=?IG6p^4(>bJjmVeP#27Z$3NSeGam3$26WeY32$xuy4aznH|TcJ^mDHbi39q
z);KPDb7a&PJ8JE@O>`!}4-Wi5<UV<DcrA_sA#h3AvFiQg@_=g&XM`!d;0g>QWuJIK
zcrYKp<m@0{q+aHW1czhCRy~7rPW$#baJW5W_wJHx>{D>}`EhLS8$w;7jmm7TKw~K6
zj+I8q)Bjg!^r(|Kn^_+u2$b@htX;G2{Yk1|7cvb}<yl`uw|2VU0+a4q)9vYAW43kr
z;Es?aG>@~vqs_si*1mUA*4Kdk^tZluRgAuORZ`9NkxQ*gNo3_R&Cn=PV8_MBkaVGx
zd830BlBzUs>JWib$evdaoWM6E*y!2wXO5l8Y@eKDx~81oIDU0O{>lRf)~?&NX4baT
zipIY=^$D^gHs&9#S@+p7=idFqrB7bFK5yo-9ZOct-MDjxe(~K;$sXCQtk%-i1Y3Ky
z>ML9C^p^D66Uu6PCF8X-w$Y=-YnAvUH5jKwGP)jVrFN#<T4^>|#V!48ibIJ}>M7cg
z<NFk+qM-jY=B<V1U^Sq7+fijE_KC1!Nb}ap4(Sji;)KSxcz9&`i`qG)%{=#lIFH(B
zL9Dj<yF%8{cZD8Csh{9RC@JX4TKnOVX)oCa^A}jBH)y?Dlm@XH%n$eV6Nu{61)B63
ze6+@*3286Y;9oO8GVL+Wy0}lcUIkc>W7!~^?Ud5eW^)+S$~)GpkI!K&N@LKI#Kz!@
zK5PubOyKp_T9DFOygs&+ULT8|v1G%wC{0vSStMxiM@|pnx+8BJVRn>G5#p{vj@=+C
zc6m;klU1U}KKu$xDt;S}wF~h(%+?IH;4<uCf7zGNVtol`pWG}D4ho~6p81d#yW1nv
zv6sm%RG0Bng-D@mTF6?eJ4;5XJNL3#d<|}o`}af64B&`ii7ql`#S+@J+|uG#6{1F_
z&v?Z+nX)o>#0<(zAro^?FVqt{ik(3KhjSQ^kT4TP#1|BMsHQlIx|5$Q;%~D?^j8F|
z#FO|N%J%J0)!j6N-6hBZ1$Ld{uh`X35d+4`B7vlWiTfzf1ZS=ARAej}H(=m+`ctd+
z&&%uIap0s$1F^=y5mr936~SJ2*s;bo2U{uD9<OUXyssx4uhaX=eaxLseZusPkQ-I8
zV={nW*b^2sP-1#{vk^r-nv^3_*16O$fpSWjE+S@zmO%+oLXS^CMw{bUN?GzH+5Ksz
z%M^#Rktj%OS?o-39D{aOA!UG3s21fomR)uU4iF<32}*MOB2bx>VZ0;f#ER)-H?pRM
zryljqmaC9t7OuR$erAi|G0`Ji&RV~IX3LS$F~ghBUhjTn&GcF8*Ug+!ptxH#Y}&X*
zqsGnHvX*$(9M4Mh=1m$lYtgWAvvXsWfn(XIMMs)7$Y}c9;_UpxO)@f?9L`slEI#sF
zez(Pk4=*mc(0Tmm?Ch>%$9B#3K2yHzGIng2Ze7NY?{feB7TUBH2Jeor?P8y)POOBl
ztturNVALV;Y6fx~0<RYQ@=Jk|#AmT3AuQkcd=J}Bc1d-4K5wVbhlGS;kE$Qy!&k1T
zF1{!PCtLvo5;*v(j%}*)J#-G0<P1SDAVoC`ldy$`F;&u`*qT8yegHloY%W9-X%om4
zX_wsqaDYF}W`K^^Qjb#}t1<);m1BC@iaFI{m#;36So|m_9Am+WfS6fqGCE2FI#EIS
z)B!$AWviY#px;nOEqdvtVah`HJ~mz9sLlqxLzM#MQTvIqSd&F37W)#+=nASVs;z@k
zT}%^33fK?;FBQvZ!Mu1F2a!7p+91*tAM|lV^`XtjPe0JOVV!1<1NOu7T6NgEn``WY
zNx7Nz+^5u7qM<9~*=cc>K4Z*;z;2OyK*p0@H4~A2jBvaO$PT-~HKitUL@v`q3wk(;
z2PbTEb37j9sWlyt9<CON^jSO{4@`_sL>b-`df_M@oQYQ74dhIsNCCFCf^$X1BpON&
znTrVAW{BuK{2R&iC-#r`fJTi0)fup7;$oE{C8vC9)!MjDU9(&}^W;$^&z>IKsZ(E#
zb>wfT4E4-<=Y5TK?5KFMzrHhn=cbF_zI#-kKV$34O}L`7V+}A(W<%!2!;`Vhm?cY;
zH4Yj_oRs=9Y$Di7YWftk!g&*C@!gVUhnSp6&bksJL`TI0i<;s@N5$F}Z$}U~&8U~~
zG^ox9ibo{WNYF?_1z36z5=;!#SMAU<&!p9;QnOlUT;Dp=7mp1dGX2uzE3C!E={dn;
z-SZ~rO`AG(vb_WUWdnLycF^^;m4dcCt}Nd^YJt1h?p!!(Gpp!c_0+t12aP@10lw=V
z;FlDehhHq!_u?=jpH51$n&SGw1E4k4l}pc3=^-Bv0LHSMfv{W6d<9$|Z~#PSaPf<Q
z$<fKF$?6c-56SrQ$z&LLx%6x?9-PSzbAu0OXfa*^7!cL&$64mf6#5fNJ=i6K{;bM9
zI3_e!4d-*0=he@t9aL{@gLnQ|g#UhjCvAA6pgOtrrY>bG`CPV=-Syl0c2LmnKnJV#
zq2JDRJHv0XSV!PKN67ids_rBwxn>&;9rb0*Qxs;Z5wwOSHfQ5hXHz3UC|vw<k4b&i
zrTNz&ZB!#yzS!~P>Mz^mwC5wrE?rR?2_IK%4IzVKQ=K)C;8FIzGuCk|v+NS$2^idP
z{~Ng+Wl8Wxl1B!#T+_jekTCI&=UB1RLDEiD^QTN(zHDmV5><UTqkdXOW_rB_KNifH
zyO#de%5#KwB5A8t)km#Al;17?xkpFoncc>B>DGB%w+4XRdG2t2_L4(~^Sx)quO_(+
z>|{U8StRm-J+Wa+-K11oTz)nO%@mUSOq+)a4dK2q*>hA@X-Wr%o-gp&>^?eX0rnjl
zj-l(FXWWX9aKdBABH4%97%J2BH%`~;U#DLG<gLr6Z*cAGJt8SFQcp<ITXzglwePP7
zRH(2sAb@@N>WyQYYwh8$5AXBnF7?gY*}Zi=FONT~v^*p95~yxI0my$!vekqBlWd!-
z4J>s-FA3D1FYN>QGFaWBo`8G_MD)|+(-+Ez<Pfil34sB~3Z(6XNR5e-S=3^vu!wn5
zdN~|!Mq*E>_Y*;MG$jMBMMP#p2;v$&dvHEbQ`;PUVuL(=$c$O~?8$?9r<o(Bvo6{-
z#@}RJ_zOxTpTkzUzhLJm(XcQ08olWed%F!=oBE_6`r|!2rTCMcLR2J+-1kUyXez70
zApIz~?9vq)EL@#_$nz?D723GS(8_2)MMntSi#+YjEC4q8!0VBeq|WcWx5q00;&vQ5
z`ipyZ-8rp#?C#9Zx0qd@oll*SlhuTEx^s(l=Y?OT@|PPlZrWU})v6J{%c^HI73(p)
z^f&u>y9<$?LR+x10{_mk-Ns?)!>%ZoF-niUA;FS_y+Pl(V?Tw@UO-c}&Ga3%$oP(m
z_>laL^yG{03@iOj53(P{X93HntQX&bYn<UeD)M&ZcVsL{e#c%QzEf-q^L!`BL)(vK
z-;ojob{+b!LM9)ve~0|uSmde7sxNO8w4(6FP|_5<HfHZ866vf-{$U8+64<Zek&H<F
zN)918V1!5j=lA6IERvsm{io}%Wv{BG1)hIw{n(Y!OCOpzX@UK_PJ9Oc@T1@Oc@}!<
zYZlZz(|-2HCik0teq>I&A?J24$6kQGv86OrO9ij{P<03bWyC--MZ%20jIE6G5iTSn
ztuz(}oBNzo-EmiEf0gPumhoH7_%B*T{8j+@eW0GxZ+Z6$IL!q1>$0olJahT@ifRWW
z2$-S@*dORu9-F}!Ia8Rb@)YG}Nj>%x4^$s_cVq7=t=(OBE>dnPpDo_$?kMiPR#~lP
z!yZ@3nnW8ilTC-8gH5DnyPGR-DXWQ8(2DT8it`k9W18qKM6^l`uWS;?{R2G#HloSd
zL!vt!J&g!R2TdU_M!-CdKFlZXee(cIX1(Xm)rO$S!(h6RYRiF*<HG(lY#dK?Tu4#5
zLxpIO7jnCnZDf#O_IZ;GHDwK<5ZxK&aHf$=F<_xBelnxHLKr2%S?HZgrN^<PkV3kK
zQI=(f?)v<-m8V;^IrH%ApMCb)iZg9mon3k2^Lw)<jmg^+8n%1t=t<hiNu#E3j|khH
zH+nL=cZ**;zh&z?tj?`Aw^-`=&705j;?LSVafQW>N*>9oUEhD;8vk};@>qWB$`hF9
z(zkdQrM+GUXGlXsItg#TCAtVJ*u45wv|~z>0?S!5Lkzpj$JhdFz}|IH^{WLq>V`CE
z{KV$!%@ZqEP7H6`zOw<x={sq-J@D{r{uMUb^$DW>HiuPHSF3+wJ<^e@=ZaFHM?*;a
zdBrm>Ah#g_9c3yDiAj?io9g@!uEo5^d%uQ@Btq=A=-RL;>zRI~mcyBjg$lu{WQK(s
zy|Iwk1tlOkDai-YRQ<<yM%NhIuyOk?ZQC@=99Pq?=Gd%8?OOF})i`Tx4M&Z!Sxwqx
zcW6oP_~M<0?OJzl(<Ez5O?7zNY*xK?t!mxcA86Mtszz!xmfen*;>D;sDb>2Sdz@aZ
z8-*9KA6DDesH3#guzmX2Ty_R+(ZQhC71KjL9w=$Yynh{bdIJwmgf+@#O(M;qqR8ol
ztpP|aao|BiR<W6VlF>*NAU_$gS>ehH&inJ&Ox|)<@4-j!&E@OZ8?$<=@9g7zUrEC=
z`<Sxtej{-{th7~B2WgqW|Eo^+VM|-19gx|pYys}&umr_c@g`~b6d%9rbJIte>I(E>
z<Yp88i2!w+_<juXGRwa2>s|(ZP<&tJ4muGOys1E|4OGOpv4<6C2sU*TWQ83XK~3ZH
z7R#_~(^48Mu~S9bkJNk*xNN{aQ>hm&n{b@9=dV7`Pbd>#L*v_*Ud01q7s>9L%D>qC
zh7Gx$+q1H;7TKjUS&;2h+z<7i8jR*dpLn1Iu%NLIr9ayD)326;rYO*~82c(5JIm9v
zQ;1s2&XQ8aQn)2-Ao-3|;lv~eQ<Fp<*xelW_*?oGsrF$QA~YA$+DT*cy5z|eq6E2T
z*R4B!r1`>5(P?9w4Ic2)OG*WlA3U>R%8A10s6AnklP68tP|_ccZTLrf^J)64_9O5=
zQ5T#h@Sb)+jz@3gRt&R^vW>G%vP}gZ*CN|eRQardw`rqoD~q)`TNx)zXIOik$u8gA
z4qUrx3mzU_jfY+v@Ss*O_BS{Y$$%AvHWo+?3Y~q6U9<X%bj?|*E&VRfx;g8IS*5cy
zm@>22kd}T^W-Xre$gI7yv}w*h#jdbEvq-_k_hX8keH{cL5$GV<n<9RzUa_-YD!mTW
zh;|NV^I~T!hqGm|t7}U(jh;>`c1|vKjxTn$E_SwbIHwmorxZIU6g%4#J3Bj^U5Z_`
zyP&M2m&4hu*xAM599`@jUhK>%c4mwB#}qq96gzW^o!yHmk#te9bCtunxY)Vc;apnm
zeAMAwR_xs1aIPqJZgw~eik({=&h_FvFqs!94kL5Ii?KwB2n0i6*cE6lVNFFsK1^sj
z8T3HEL_!SwD2eba#%Hil!;DQPXED7m{!pImeI7zS0E&q-k5Nbe%0FTk<<!J}113)B
z-*0lGJ^gYL<7(6$n9WbN%*<@wykTZ@H931w+inBxN{70&;_BWzk$X@Z@^sE$+nN2K
z9er(bO1>SRQYWRR=Dh1Z^9}ybUhzEHJD_%I{RY|Yak=<U_shxo>ks4KoE&z2_}sa}
z^M=l!Ka{_$BzEbN+&r*i`#N2_vyN@McW;~5zFT%XXs0W(hxF{G*R7M4QgWU(DV#dB
zke}6~S=5YYo|(Zvf2QQcXHse;)m7BaGsJ&?HJmE`Q_rxPNy#z%TFIh&?zJWEb$_ux
z@0Eo9h27iFeM5iNcQ~|w>WJeffw#kLu8KCWWn?HGqBT4yaVo0L{Zu=m8ph1U>F7Og
z<j7*VkoF%QkD^nOpY*p#tzB}x<UMstSX|Q{k1Uw6PE{XgX^C~~rzEtgf9TMm7OJYK
zs@|)leo1}x@=qDfB9fP7=WkoOR8McvA|ow3vf;o14?XMds#RF0kseeVa^#4%4tuYM
zA=!juItW65G$P?YkQbI9w=A)B`TL2?0)GdYLU@EtghwAC0I66CN)j*=Aq?;67ry1E
zS-Wqp>sP*mBz)_x@-cI|Pr8q@6TH3BRcYnX%akucPXNy6GRZDUkiK!3&1;cc6*FB4
zg3Aw0u5iLAUv6JkbYLwHP!6lV+(EmR?_PNYq07P7c3|A~OF8=qI23kyA8B2Pn@X|h
z((EGZ5_!R<ZZSd&_Q^<OKNbGYPAQr@cr6SW#g+%X{}Aluijc{jOy`QU8|69S@~J>t
zudAZ?hqOymA^-_ri~7T;5xD|{A?Rzt02dM)*MrWX9{Tv?$xlBydGhA@$zw)OoIHB;
zBqg1H!LI?LGJ<ttRare=%)g2{S6FzCFFJRj=xx%;UgYm9538+h4)7#wcSuO6J7&B$
znC&L*r(S)vTy<3EYv!V;Yvs$K=pLs4Jle;01Scj=T(5FXs-CGf6(^e!S@3iU&B$PV
zcCV{mubRIjH6*>!kv~a`+imw7Hw>-ofhonOut#iJ&{0A>`v@H@hd3(&DFp0>1PSYp
zA<^iE9zCWF$jYu>Eu>Dh)WozpS?Q}g4<21LWQM<^er#Ibbi)=HgvP#!w%uMoHO0eV
zk*Bl7q9VRaL0+O_o2Xq^3iK-&PdpH<T!A5&H5>r}UIkD%58;EQLQ(j<@CX$Vt^oi6
z;yI2DQWxom4Y!ZC6I6(hyd;bbk0}XQWw~PCv|!;TUD=$~tVzSAJ(|>;8W)++uUoUE
zxd~O1>`pyr&YT=QvrU^!=GSFR&&(QOoyPUdswwDvUs>Z54mzo8jVmzvAL)#CIID{o
z68tn(9za-fvLTPMjB~?BS*F-GE?l?~L^W*ExX}wf&9d4xvaj0IA(Mfi!82zL)-zhQ
zZjd-ltrim(-J@HZhK+rozj@|vgZ?mR3PDa5kedIIreN|+|9y^<(|zKVHHv-9!o{0)
zWouURCXKr6d}NAu9$L4_xB<?ldp)FmseG+}iik!vSaz-eU);;rK|UD;UixC><d8!K
zkHO*y$4cS3u~Gtw+b2F5|IbR#deE|btsLFD^{DdO6I;4u)t($vC9X%OtoT{6;qltH
z`oV+xk9XUS%x;_*+IC#mtVGZ<NV~1N^pl{a3R%Q{sV-kdO=;;D=o{^u>f6Fs8zM;~
zvFQr*gG${357>^*3Npfn=b{Ek5*A*5S-w|~ZQXiI{qDqRpN6ST)9tgDv`A&zH~P_|
z`X6&=Yt>>BVjt?$sc8$JhM1qy9PPI9y}k@I1pxbrX!5}^<kTFPA5i8K?UU-$!UvT3
z(4+~Ph#V15ktEoWBc^<>o?Nx+r1JYy{NTnTXK}y1d-XpC-lsLl#kha;+yhcP0I?fg
zjN5}hf?wCgL1A+^?YKt(jT;ZN6n?b)1UW~`z_9MD@4?@3tCc4erSR>eo9zFGy6+CJ
zs%ZW{yL(FrA%xI-=t@a$8bt(2qZ5$cA&`)Sl0XVwMMXt4DhP^nu%V)ah}e4v3o6)q
zjT+Qfv6Fj$pPk*a=iGqr`+lG2{pSbIX3sfy&g|^$?Ck99?4HklmnE@VP?9Vw$8#Is
z;@bz=Y9eJT=AUH?leQ*jlP%fW9OpW1z4WrJUVeRAR%Y5cd-jVXkgl?g8_Rry#*7)%
z>6jP#XN_k)8|jO|n1M5Cq)s#I^>V{C&Zoo{tu;9dTHf#N_`|7<ioW(3U;n~*=7*<Y
zuuBu#BN`32(&m=<%<@h>4@HsJ*)@$uqOZ})Lx^Eh$upn%o5AvNC)ky5u(ij77qT8V
z`j|iXr>ElYQnm+&pbBdZ%HM$U&-@0XO@TeuxmEuE_#2FC*un>nOdC6I(c|}i^wEW*
z$Bg;tp7E2WOxx?J*tKKg6>%*#<?gwiM+UE(F?I6Xb$rUWDcN8i*5g7yg7zJl>trg<
z(JarV+qMO?-GN>m9*Pf{uCo(@G%xL^ge~m%t5YXz8(6I8p0^))@Y`=6eC&jWKa-m`
zd+E~IxpUb?z9(O1k;i{|i$%Wtgm2aI2P#foe|Raj@N?qrZt%7q<U#uRY>BWbv^gv1
z&Mx<s^ooZKf`~EDI~xRj^+DRtYgoxczy0>mzI}5pyKIi9B6#Y}H{T5YDt<YA`$H9P
zt$&#KBinWm%CB!_tI|n+?9y%igiYJ)bNYlKPOWu0$j}?zj(c=K#16>#0h##k!Ex-j
z+CluOU?jVj#{}1H@l<RLJ}CPG${$Yk*Q*0mq+Px(*;PiEs}4Z99r~o+kNA$<q4xC>
zkX5zEr{%(EL94mk2}BDfl#&v`g2RsRBSDKj$bJh(N-B05Ie7$f5@*Mn(rn(Q!&qH$
z%G`=esA>>LhZ4Z>a&51chF43Mw<fMmtSLFcZRu&q!=lu&deuQZlJx417k~flsVCnN
z_!wWoy!n@1zGPfpt5?`fJG17qdMBg^J#(v%7tTL??Wr3c=o$CZ29U4$_y)D(=(DtA
zSY?bz8IuaS12&wj4}Gi8-P(ch@AJL!N-zs2l|T9lI~i>3si^&v`%U>wwxd8#BPkA>
z1K33pwq!Q^$Ps`N-3jQQKHS9MR4ICoKyAL8=>lvb_=sGQlTyRinQ-#+kG!;f|BGJ!
z?6mBRNuG++@9%%*(7nEb{FOKe%;wQUC@cJXlXh9;`mk?o!6TAv$52%yCx^2yl9uwY
zH`L|f070}EqmG~G!1hi)a%2?t#|3w?6~S8eb1)h`Fp8b3{iIgLnXW<S{{ysmZEw(7
z<=!pTFm$B|gL~}0+I2^^pbIHHo?W<V2w%sUe5a)gyH0jzCNQe4J!aTTywa4w3=EzP
zm=4k&KI5B_*UE239`*fo_22kr<ey^G-=+LCtHpegoetUbi1%@2z9kx_PyVwU%26Fw
z7DjcsnY%+LCZisbSs!fXe*b7N%?IIo(sxvJ<EKB6EzIGr$3NH$kfX=Yf91SM>(Q{n
z>>m6dXG+oou6t-K%xSlaLp=7wlTZKn!&6WGbY$g%h09kgn!kd*`cCjq=6~mx6D%V5
z#|d`R{{1(dy5-(`Z;>?34qYX_22G9i8V+<jdF|~6vFE?iAMf6NhnbY?tWgLS=J4{w
zBlu$eiLxhB0@q$~O|QAVpZe)XN#CmZ3s<aMxB&Fcxpm+z^EWqd<|1<Qy*80*{MnB7
zYK1w8{*D8&%BGRb6I)K~gB7c=aYXvEun_1P0uXOchwwuOhA-8l1zo#Turs--z3aj3
z;ebkDS5&<`dHl@r^%}ep>76*{l}D#cnmqYY_HOVTPsO1<GuCx$dwt=8o>QAPYMPr;
zIDOvMIn$=jmu)Y<&-<ge2z>4aFCPgvG1jgD1%ROj?t|oEjvjQ)m#ah<3c>;9u6C%3
zZZ4NQ54Dc&5sgtMG8!gkM<L_Js=OVgXBQ4IINg=+(wG9Mo;``Q=V$!>8LOYT_w~vL
zj>0IIF>U&kN$VcG?}LXQ`O+(%SvDhg9t#Yea&GEPn>SQFcBgM<$*f@`CUj5Ty78v{
zmG}FK=gg!!%C)A+XeYm1Ych78T}Pv?Fbca`L{3(uSxM35a{X#@@U0`k_e49`01d=1
z(uYwB-pO&Jk=6Sw`Zr7`+WMo88dh336;Y1L5!gt)@x#+k|8Qh=;rvw?Aw182^wIPD
zbgk#&Yp=bSpO)<vhq`=(GV5V>Np%U+ePLzV)+|=gPz`yIvou<h*^g1asK4G0u74xA
z{v8&Pid`~)mjWZ5IpmSHviV|4*f<oX68;P22y0pCLm#Omn!$hs>5jsGEW6`+n{Vxj
ze?4=rZ~wFZdV8&J{{gm=iCE~xKWZbOp}rSQsr@FxuX7{(I^C^#s?K4%|Lw0LgdLI3
zI+1Ic;b^8X*Gg5SpSC2zB0SfzHL9APE1y=yb&|WOz%1oul}-WmMMRh9w$6r8HtU-C
zIeBv?EP6(GKECVWj|ykwX#9uo{@x>=T{2@{dC`(<MAB8IORu`B$amN0?>v`tFuwcY
z<u82p&Qrd!>#tdJ^%~ixEzqV?kJN*2h1xWX?_q6f59)A?(F}!{ED1*2LRFx3-|>C=
zNpR26;2j_HV&1N{S#Sp1&p#tR4n{dssT@5Mq9yUV{lMJ`u*sG-6Jnv<6_Hd`&#$8G
z<)E5MA@?kapL4o~w+wQAa?6%{aqZSz6bU_^hd#3Me=@c}gLh5U;VE^za4X-fs(SC;
zs)O$z&7U%5UjCHH`E1*ZUw!=ooAlf_-#o`wZ`!mvxbNc4n=osT{KlqMb}MM|VilVB
zO<cA4VB1^xvZ3@n{*wz5Yb??QdFzpz*lh8oe^&>E8%I`%hQQrYo`)iJ4XwAHiJP`p
zRSDX-BUfBqZq%x%dQ@<8vjr>6AK3vcw>{Nv@$`2P4QofToT2BXXN(;GEcZTl$Ii-S
z7eCG(*}^u@TG@ZXqNP)On_oM$ujJ7+P$l5QaI{SVXf^#RtXJEydhP+K%2H=eBTxYm
z(XM#{OyK|Vx7i;bHGItQj0vd6i<|a6H-7l|sc+r2>4cX*J!3@nv~lBh@LOh1%r2Nc
z%6EO$Jv+y)>(b$xdAkqozs)yh(Zcb0Gp?7i*9UE}8uA_qji&v<VWXR^l&e@h`};kv
zB~}=5@E2)qA&(D%8-_mngk=C7){3#Ao1gz!QE@cbHj;h+YOoz*^*LL+^}Fv@iE~c>
z&T6>_e3oPE0MOCi)?Z{8*fK#(msSFFlFP|m6~Sn`Yea%OD5c8VMw-!*`>qA?s>aP^
zoMct|HtGb5#*NW2v6w9nM<+kp1ze3UWRm$8_vbT$lUj9{)_co+k36;eUHQTL(NiW)
z&K{8+!~W(QcLg79(~XIj4^_Q+>rQXf#JQ_W=CAHAoweM`MO~&tW?I2w(D6=Tvkv=2
zEjh_{xwNb5TXKU@RWxN-3k-`(!?vSvtH-sTX|KfS-j6RcP+%Iov?*PA#Gs|UJI2o(
zFl$x!r9-#h_13=I-ur1|+U#b9V@6FM=h@M!<&7<x?7b{Eq4x{--E|yiCM3N0XYKy}
z$-OSwciHR(<+2Z42pQRmu_e5}+A9W*F8JT|S9vnCTnL2wXzS_M*oK@@ITIEvc#eBM
zdAjQLOI8GHc*<2gdj0+5N;m9Y?|qzkK7070Uv3J5T99gu2LC65|IJ}@CRo#zj-k^u
zY<aRRV|S=uRj&?BrP%Ze<9n58-Agt~!(L>2;y}x@Z6YQCf}w`sCuOb)W!RHMg<bcZ
zF?xE@d$->G*^=4gXTP>{%S-nb4j)rgG<JA?+sOknXUxnRFiFgsd{vjO8)xl);DOz<
zHg@fD)#RJ+yt8(~ghh)cOkS{n=Z>5`V{~@T99dVnN99M+L(7`>aM0#8yQa3Rg^yUY
zldY<?+R&yyp?T2nl?w%Grvbve!lbQ>jOd~;5LG{H%9CS_ToY-Gh)C%Tf+2uluiayd
zy3Xx;`=iJ2*!9-OcMMp2eut#F;|5G_kvDSq^vUZsEzaxS<F);FeD>#a!Fvx^w`#Gm
zc@ws0U|`hhTQ|;}w-&NC1_C!-^u)NM*Vbs<X{?=(M%G+wUha5RJ>X2=wTMOWt>WV5
z;1R>=kQQGEoUOvfn=^3YqjR#QUE_^|`pogBrSl`^k^eN_H1EI{)`pm;Psd&fseNwZ
z-VH0uFP}7LC1-tBu=?j`_exD0+}D?T{l#V37v<c5ohg#uX`x>^)==w=IX1n{nB!1T
zXUuW^P|rt;gU~eRxSlpShepr#9cA<|Oe4}1|BWe^%JTa{Wd{0e;=UV;R&N-PdVbo?
z7nN=E^3CV>?vpm~{CVuy`F#Qd`}FeVEMK;$@AOv9XJ-|yTDsVma>2mfg9a>-GK*+9
zejm0H)E#r|8lG*;afqiehmmE+V)U4!Vp*IqCs~d;Bj?Q75!@5O=IspbdB#_tHC?%F
z+brI#_7qEFjU}HEYsqf_9pPh+O-0z4;}q{6b6ihdV~*=-<2G{7PgVQIa_EseQ84EC
z|8dM&-IF~PJQ~|PqigY+_17)i4W?%H88~2Ia__!TY#MuE^~;T0F@D|Z)f<Wz`s(%W
zKYU2m*v@fMX5=>ue&x52jCX^+Caa1%i(MOA573z7qR=(iI8Sj{+QE*_trQR^c*Z^0
zKpBJ$Hf(3FN!?m@7~DN$Qu~Q1B`bEUTDhxoL9eu!VZHlaaK7l-IA&?XhI!-9Z{O+a
z<>fc-U-#PjdxBFtwQDoBFneIeFxe&}P?<q!lkl~5yB0<=Tx;uLbjlM5afZEGTOU+B
zeaFi2!Q0ud{EpqPJ$%U}hnaWbD#<Sa-^s6h8~AnR7-5&?j1f)=?lHpk^vp5B`4P-B
z5iN9j%YPgr_*LnB2W9VCe(@b+GW%!VQoeZ8x?#!vMvXczd1$l#JrXZS3v}<#$Mm1x
zs!i^o;#I4Q2IaMGHNAg9S!u9mpTUFs^iE4-TNC>ANlZE)EB;b8rl78uY1z<Tcp4+@
zn%c5)&~nJG@;9L{Yd=Oq=PA~)!v*7valu*M4j&h0oHwfV(5}nZ-?C!a?tK^anAN>i
z=OF`o4Tv6+l5)X-qG>}j+sECoqGa2>>%O{pS8UAEM$xQgj}DzLESz$F`Z!y@51<Zp
z;}+~X*#5V(#4WhUmvIZuEj5j_ne><z?v3LIc3-}B_wLIt+q-k<zzc>988l!h>v+xH
zz1MuW{<hoJvvIR#jr(ZAtXVR|9ddgGPNuAcv+y5ddwFH;3EqR>Onzx$t@BL6UexW_
z^$~+rV8k<8(K6gdo}YUO{u~NegDeCHCPX97?-J=5YA^ppM3Xj;NT|Z6AfQqZ!Cd7L
z@~S0*@LEXEY7+|UZzbIsa*5Kf_A1b5-N$9%vWp(&FJC@ydPdr`X=xeL$MxvY?%Z?R
zb?D*S?tA9_p|f*_44FQCNSDOKE?rY_%rdv;d5ZaL*nn~`Y*(dU!gl%F0qJs07S3Jr
z3N=o~#yhNBV#$$Bopj)t%u|<6$-K#PE$i1b`1FQnUbz~02ca`Qj=06TV}Wg5njZhp
z^N)WR3#3;NtFtu!5OF(p9Km-rdCaleYL@M5%>K14csH9^BC1cP@ja|7wc*9^p=<&z
z;p2f#N!WPc@{9b#93+BvW&O8vkXVYL?;1V_**utE8*J01%bW}LKlj>mw|(m2Pt2b<
zH@6^X;)Ga!o#=RHa7@=k&V#j|z8C!E*t1^G>MIXy+jwxqaPYMpbvc0csyhd<Yh(BM
zDvz3N)R~I7h6SgpG%Pr`XATRh7BUXV3L6&qnDiA%U3*O*uyRY%)fe9W<cC#{{lpq>
z$}Vnm$=s>)i@eWwY`eL2o9~}Lx8DW9pH6&;(;bp<;@kPGAsbn{Xyl-^&%J;2#!Zh=
z8?}PG3_u%&j}LaOjI_AMhcJRU7l>1hrSU-wc;dRY(MO`%Kd_^AkLcuW68tvEgV$bj
z4V%SNe%p@XWN!`*7Z)QoUVf8gl>LRy9th{`VTY$uM5^2+-6N(l;aFt?B0lYao2rNw
zJ!CIMe{B>&#|AV?a7SBLwF{8R**Sv1uywJYLoF6d4raJ+u>o$la|`Bof*)9`TMT>X
z+iKDz6`DO0kz<WgZp}L|I;>YmQ^H;k-}oyozNB5;@jK(rZynpDZ}QE14uoEN>fIT`
zTD9uiD|^zLcX!T;W68BAo5V$Tj$c@~{MsSof`8^-m_0Xl^q9Hg!JdWZHQW4(KcaD<
zeW2^+8`iwHcj?qC&S`c*_dzo|Cv2b5Y{$#>>;3&Z7tLn&A3Af{kRc=Zp0O)djBPey
z#fk~w@m$F2gOJrT$6~u(ow3;AfO{-<Jw0<Qc77y<ufO2w;u824Hb=83Gs#K4#g@{X
z;<evD{#4CnOL7;#S5^7JJ(uL<u3DKtXLb996Q&f*pE9w~lTvzb_g;^#eCfoAmsUN}
ztH=J*C*OSY^!DX9-?ZYQit9w1qHC`zU2^4>Ql7Xa{j^u=eyL}sG#1-6wfp7S=4)n1
zu4+Luw=n;}KhD_H#vB|oBxCf>GGlwLXkGV}L+(5J<=u~eb^3)1*7a+Zx?tYOqBg~O
z6P6TQ@#@pLgNL$uAHB=k1wRe`E4ViJd+`1CZ8x`T$^M?4Rq^;UFKyiTIO??qokhkO
z$n);p-wv_oq4qjYReg2dU7gi^49u=&ZnTqG({T>2l504(+<*M|{ja}1b<Uirud`c%
z`JRdscij2rwl&jdUZMCqM#>WUYb;g)W~*_Eobq;WB`t2>*rz&?xoj*5EL5Y@BJxpY
zZWoeV+iUBVCVRPEeY3t#vS_S(751^vgqVL7e`DePC!f4`-iG)V4^7K?DA+b<{`9#q
z4f3WH<~~=r7$?0om50F<=RZ^XdF_|%?|Y6Oy<_06PpTi0djd*4yZK$-O763ujBv02
z;a<@FFy4;)`NOzxh@ZHOll2URZj?5XKBtpr&$evYv*&{`P9>^Z#n54JtrD=9<6dvB
zM6e2$#9h$_I+h-5ZR)hn##lH_iiLjR*hHLs&n1_z8>(5C;0M)hK6~Ppg9mSU;xoRp
zf?pBb8$9`XuqJpL-&uQ_`HsEu8uJD*G5`OKUIxp@5;x$Skk(e2k}OjF_HG7ZwJlk;
z!Xn9XmNi=tuWg5mYb6biblUm|j)$L-B<(qT9Zv3K!1}+Md!cWTilVP^%lP-E$-MW6
zz1Cj1aqrPd69?wBKe~49(GNW*g2%Hbz58kHe7<G#<wFLZKH)i0ariK7)lR6#yO0yJ
zrcXV@mJ-tsd@2^jCqv_KMwV-F1FL1SFSz{i*i9l=*2(v)_K6~3h>jUTr#N`@z=7bk
z;(_4$gQCmn4@8#=HfQ^G85qMXZ|HlT;T-~-t5ETj6ot)3^C21deO(6{V)GAuNCw9o
zx;OLU!#=KK4rQ<b!bZI@m8}p}DNi+(8-3bIM#{bLO_A#EhX*ea{ojZ!yX&rpA9ihk
z-?y)#g0{QAQ4xH9{1Cn2opr5vV*_h|u7|$a8hvjXB0#%J?lM1g;9G1a;{8Yf$SeVW
z4>s_e!ge1AKF+|GVsGfwGvFK6fgfn#w_5wyv@_tNz2W#r8Tj4S-E58xZ)=5v4eP*1
z8u$WhIp}Gw=r`~Uyr(Gm)m`U{%{x0;b9Sfwj;V7~&nfU;R@>A&BE^1(oxmwSTM)kx
z#;3|wA66Y}h3zKLL9Jw9vf3jxGngh$dY{L;U4YDQEo1qizrlM<sl*ZDeK*bfn;qWM
z3U4^?6};rVf-hy~IlMRU4(}Db<h_F5YAtklZ{TALFBQDxrGhW8&Ubie&zcTKxp^6S
z50vLq9eSubgsyh#Kx>_{4qhV<TcJR^`(+&ze5uvlse^&{+wh@p0N=qc>!9GbhGsf-
zFz^v}9YW6oKFu%dpx_Ha@lG8`MG!rxgN&n5ZHsz)#`vYo1*i_YtydhGvvrJ1=BDAi
zgP#7rfCmEVGe=mdEu#j$tz8HBMJ0TyfiGo?Sn(O~?d!mgGw@rjU2O3g@a^n6Yy5Kz
z{BCOxTXqI~`#SLL4Sa!B40?2*ap(t+NP<cJF)#BprFO>38`b$0r=7_jk$i1z>Y(6d
zJ1h87R_wI1fkz*cjex$O;AJ~2_^qge(Gv!~iK&Bvm+h?J3#=thI~(}MsDm7WR693E
zJE!>D;GO<dhf*BnKhfrsktIjhjfYKE;Qb8n8G!d$=`-8d&~%6+wEe+ee$)W;E7*@U
ztluhSa_wL1Q3IVIp{c$K{<OipHM!*((D6POZeM)^yE`@R4A=xWtoJ1YTOeB4Eo-Rg
z<vUdw(7K7}@SShy-f8W%^3Hf86}qs$;iG!zXZsy?!nz+ZQhG0nT}tJ7A6E7}R(W1b
z<p6pSJQ@K#INg(t_p-Dej3GTZ7JQ!L{T$DSC_d-3wd+S(NAfvN^I5@uqG2VUJy_q<
zd^XS>4WAW!t--yucdIj?J80f1*q04#fv=^_34=Kfypvl^AhV&TKy9}76~N=v3)v?^
zi=o{$EhJBpa<8G~Qs|~eUWs4A`>fJN;tXiNs%J=^q7dQz#^Bx>%7V|WE^eQsT*^~u
zKj6>t-f!RwLQP?9>po3-k7xn)j@~Q5__KuMO0Hh{tlguGT+t{f-)OFRgY(41P1F}I
zB-r#7rY{)mZFL(dSlJgOtZbt;PG2z4?G0ZPyzC1K_ttFFq6WI1n+~E`!R{VoXg09z
z-LTXb6l_5|(-#bETX4i4r{x~ACDfjiR2`R@)}%lk$&aSGjtW+`rG%ArYz2Pn_A$`S
zO&t}yY)^%I>qyg@_K5`tn`ycgtZYjKThPX|q=9V;y5-IysXLqDO!s*tSJM<N);A6<
zrlu_oEec-Zm+(HT;CqALK%?DZe=7WBBl`XTys{CCtW9jFT~}jcMM>&iy6rIFmEJ6B
z@3Wz8?QpQCt}Eg8k1@EnTTimxHng$D92-UHo@j%6`*35e8r%UJcW|x;-(pj^(KB~(
zSSwOj2j_}wNDqNN`J8=C&vBlFI7#C)>@;fAY0fxJ!On7w>tM#L5rCiWm2wV!CgH7L
z9XY2sHYqV34Br)gIj$@GTdfLbTsQdR%owNe%YGs8`>d_qOusPLp^s?%QMh{<+&f?!
zuC)1Ra62}G!u__PeTQ`%t*hnNV5eT^;>~1(e;dYUWAhmN9m8q&F+=;d{zhLI>>V}j
z(*El1&j2j^+2G?gSjeVTZ3q3qmIik=Y>_4M+)Hb)gl8MXY;PYcM%m(>;p6O#xviE(
zvS~?nl}%e@O?G70*uV`WB~(u}20RE_)L2y1(dYm(2H5&V*~?OP74GfU<&Nwc+>Y!L
zZXdQcXx!UJ&9XUeaCdTeg1JEpgL?<|o95Zj1~=w4VRXNvar?33@(Zi84R5d$<y6lK
z^Z{(cQuwJ4cvby_Tg4pe8>l}$zs2f<KBMX?+ep=Qo3+MiBSTN4aC&@P)8n(Y4L@^C
zx9cj;59{KW{o-6||E<;zr(YO*w3ES|Ex$$MmHk34y`o<XF#W>lFWYufxbqC|?bado
zfXx?!yGuB3pVTi3_xABd5)E!!zbM?Y&ndchU<-oja|U;ZaNJ(m=Ok{~M&CJo&R~ai
zrrUI0u#Kk+%^L|n+rU-^@5CEb30>KeLqB#6b(KePbjAAG^>|SAy1XjJANjh}bHpd#
z61zNh2W+JryY8mEfT2(J!!b11>aN@21;++A^>OCvOJF~g_y++0a1GxCHn`ruM=lWQ
zV`}lCrYCd^HcArBv((&dcWAaV&mwxHe)Ze*gdPNZOYd*Muk5Scp&{^PX&q(g_uKpm
zy$JYp>gx)BQE0f+*A0G;fxi#%=X!57_=`e`p<itLj{RofzX5zZ8mkok?Kn%sj8$g-
z;LJs(4d?a#Y4C3kO-IYuwc#Rc{P;G@T!u5V0T28*pJdlpsvVo+`C^~c1tZk+qv|=f
zL9zv;BNRP5ta^@)F!XqBep=gbw&O(j&lG;Y)l+W2hMZiA{?w85sl@NMM#?k1@Vr0z
zrN<vYx$w|JUbi9uWt2_7(aV@)DR~V&kMoEcc;5s376l&~9{SCOCnv5P4`WSzE3kzj
zpX%F7mJ9iw5WFAdmIu2ddR*3blzv`6_yC??3wgW2cM{Lz34f{8hINDI9!tmv>&a0W
zFl)f`82=2wWNVlhcC&=RxmDy<089n&-$3O850#ri`169@u?JO_i+AO7t2sTFy3fGN
z@rE7p9J9w8yI<%&D{cH7;w6<2*fGx7M0R2L*yO?st+%xH8F?;E1kR-aof6j-4lexO
zsaBp4i@mJ$yXvoUj;;I_rEH5c$0nUG`;+4jB72|g6>0BFo3*85uQ(RJu~)z+`JFO_
zpZK(k_)!A>Euk?2c<6bY%_ry&IYuaYwpkxLV}zl{86(vEL)r+E9*hyQjE!KZX(6Qr
z^P7LsT&0<YMH_@}_4c;gfGj_Uugc%j0I*PmsArLN4Vz)hq1|2w+ZZ`i^N+)TzmVuC
zI?vdvM#~U1+C<@&<B7t(-8y`h@x-y=2se!<3itNBGshF#hEup_8{B)WldQy^!x_5a
z$5As->Z20>L0>&hyWiS_HJ8@*JBE6Uw3Y2?8ZP^_l$$j2!68I~<RIOV8>1(?89TQO
za(Erd&3FZmbApU-gZ9YDe%&}sZqmF5Kojtjd<-M`n2WRKW|G_h5B0C6!NZ0gDK~%z
zJ=?5xj@%e}&b9RneAE`si;!|7>4Dt5ZREyK(?rP)&U^Y^{7g1|s;+B>W7E@WhwLLg
zOkD>7KAGx@02#>}>qn=q1TX8_!_-ybm$r+-ztt*tY!`#SyP;j-m$r+<58I`Kv0V)I
z?l$egf#PQx|A8BNc^R7?`UCtL6dWXyiI2cR&spd%JkJg`bKpr&T^QU$_ChadFZ2ra
zlJ-I`X)oYG)$8)A7=LVgVNkGzgIB(9{T93xt8(g{5Z(c#EQfeH+0=QPb+t1WFm>)3
zUT11ARp)J~roBv^?fGD*U{|@u1Kho}>;!@bQD$5)POi7$`9v){hlBUvd8gn=H#~UM
z-|`VWj=gc<t!38J)L$@z74P~7Df}dB#g2_*>{!RHj>9_7-M(`zDwlYAi+7l<cj#nf
zNAD<~<S5|oL$b5my4A67j8C$u;ftE*OZ!I6^LJ+(>&DFUZT}15Cfi2gF2dZ=%)t$A
zXKYotrEQ~d7xgukjhPL=hd|?qqI-;?d%N|JW7nAWY*vSEY1b&++vggq#&|xo-qwEI
ziw*9bEXG-DF}Pd9zbL=QhNeZ^5$(Qi8o%G#X+4S&Li@5z3GlDG^q{K42vg1;>qqE(
z{f^-ec#i`~+~pkbo-*a^v9@A#)$h1lz_kuk4xd6(l25b)`ra-!Qqhe0)JD&F3Ku;;
zNzY-qdp{+cx*y5JRyNy_H)Es48r}ll^CS8FrYLy$a*U_Q%$%KeZVvbqzbv=EhF{Aj
z*<+o-k2M=vY4BG0exx5t`F^&xG}!Ggq8@Ce<wD{18QcZdc=*dTe+=$O@Kmm!s<xAR
zr0$`y1wouNw!}GOi?IP5A3L}w+LG^Tx`MYpaeP;%ts5A9tME%3P2t~Rg&dpL;ID7$
ztMES!c!ht5^#soA&^EZ~3H4=-i9ZUz9E%kGZPq+zEHe0=^+$!jM&rj=)a6WnK|{??
z0i(V*@dlgKByad|hc`y|G&f^WD(v-ZywcabR>Ma+zHa(Npd5=b4R2<I?(n4gX96CU
zBk_J6)+lvdNuK3cm+J5)R1Tl+hk(CI^Zrkq7+80HW#BP4vSh3b@5=5b9eg}g6e@>p
z_7BhL99Znl1^mN+_p#&Wd`3KO4?KT)KgIJqsoZqyde|(wT(bNSedAhlR`4Gg_)?Yx
zDXa_c*trV+Zw-$zHrH4y<gJw0qxF1&V0~CeB3j@BpV!{TY+xHo4x{fVye}Hqf|TZV
zZ!oZsRJGD<!~6Ohx_4S{S-JKbrk>&J%!;0W+3#R&<x5x!?sL9mWKydS-Al}}U(XI^
z$n#wA-d&`Zma$%;T0CC^UJoK(-veG_4Qra=G)bJ{w1Jg;max+H2|9c>&<>v!Zpmkb
zduzb(nR<$w&k9!ZPQexcv(_XA*2TNf<Dg&!(S1P4NNABGBcyvIc4u7~=Tq}&ucTeV
zV{IkcNQi;f^S{thz<RxsZiRbmDBZE~$ljE=eRe+#fup>OSJJNF3qr9D^#&g6Jg&7B
zS>N|bt_~4ByH^{zB1>MDV9OPq(cqPB{(!10`eRR93JtWgo~+=1Fz}_UJ5G_;{lUOH
z>&XP~i_-Au57W;*1G=5=4+^%mf!#eba0V=`+(2Fw9q$_0f}ZEtZEC2%nvhvvp*{6-
z4T(LX>$wY(t?4FPKyt-dLsszcuWR^H=4vMz(<QvKhOFRWTN6C$S!Qf&1KmW|Q^8`L
zRKpfznzbPViy4htJw{z=AGh~?z&}B>mog5@HSI>ioN-O*iU$BMb)3&C8soL0P0y!M
z4Y*aG$9z@8ZeL|)s|Gg4)<Lj8T9Zx%UTJ4=oURTWbe@y<Byd1lN%yz6y4fX?e_ry+
zS-T*3xsFEg;MIjjf(&$==9R+zmBGCOdLiiy-0jRbq;SU=+}rYcoB`cY<Cgtox6cAB
z#uV^rTL+_`$ipP5Zs~#@<dr;CI;5zL;i=IfQJPPrZ+w!c3U>Pt!&9TlY@QOV_k@O(
ze%X(3rl@XP1MS!#Yhdf)Y$ydU+ravm+CY^l>!QlsmTBr@urzY<^bz9!y;Se5GY$Vu
z-{}+v+ZK2g?Dq0SHgyKJi>|li{Ucu4RuUF<Ve%CAy1KzxlbRiDD{#J(4G(`+|KPs=
zgO6F(`3=&g_o;d;K64C+QS}Hx6Y^%H6O|s_9m<64Yubz+_1kh30vCB#YHtN!6pF__
zj=Jz31Ai3ooZ4K$Zx2nuImdP3BW!r93H++X)Q*6M<-h9)GW4b8sL6#S4-${h+VP{2
z2Gi5Mn&0xArbkG3R}#OsTE9E?rIBDqr>(*K_8}_spoGU9`>)_ZoETUYilynbEPplX
z@rPWuW>r*vX_VA86lrGc4CC(%o+HmoQn2Jxd6RsoXcy->&08mmd+m9vEj8Natpf|0
zX<ge9{ILCy_#NLAmt(6O%cS3MDD=Fh$n-pyT@XA+o^_<)$^SFjrU_%B>>moxHu#ZD
z53y-FNYX;>pvIRM058Wy=+L3YIyKO3bUUbVtDS+}URq>RXkg=9uuuA0YFOzryBi*N
zZH*XcjB>8|rR2eO;=zN82k;9S9vInmd}eFF1DyMTG5}BQ@|)qocH)7=1AUijIAE}x
ztNT5j-{Y0z{6m`WerKFF<E7)fB6u3-B|LO`KQqo7=<YUd#Nyy=AcY$`Y#D1wu{a7x
zBV8uw8)YmJgQKU$aUSaE*!NPFPf;D|Odf9#IAHh7Iy$jUMi0_R30bFcnDn5u31ELO
zHSru~9JXUF)R+xFtsb+BW*a{(tuDy1B38Gt!i#l0Z98nYuCa{g)nINWp-I*h{P_lc
zC)Q6*9F&0%_fyDs-jTjnUB({k8OXDiBl8ZZcljJjF?QfwA@vUV33^faDVWFqMSAox
zYU{1m4~|Vr^M0zG<UGMEd*lz`k@g7MI;E*C??y*O>2^}E&l%VPPZOI;16v<d(kvcr
zf>m`fm1O-%qNNl%&B(gx?~bjb;N|$K;CEPWJL9K;M+usCf~P(p;UOObOdl}Nq)k8z
z<k3G0=LAq6KtFm&9HaWHn3NpMUE$G#uDa_3WSEQMS5Lfeu7!2#TxlQO6>5Z&Swo>;
z@%)f42hY3f=kPD$`QM=6WqRI2KgYZu<+jG!*C2YH*hJx(PVhGY&lY;#U%?08QSf-4
zO3xn%gMSkK!}EM)pi|k6cZZTfk68LFK;zG80`B8GU`=GSH<%>L2R?k`8+#;BKipT~
z9tR!ZzO#K#>-RobdGhzsXtR6hcSXO1muojZ?8cYBZ$mxtodw+Yu-~V(Hy_TLlE1Hm
zpDLYxPcXl$_XBiKYZLHA`{cTZrl&o@C(%9mRq3Ai3VDHFithW<@4(_oqI+lu@cns=
zPyZOFOHwI)6<AB9Et%A|3MW3)ZTq^;?vH}+$K{V217GzUzQK6sFgO5tU=2cF**%5!
zK}a7;g7Jw=#do>NeOZ84bCkQR&q80?@T37Hd@loE63h`rgkSaByR2^<{A9gL_~r)w
zM#w{)FQDZCa{JfoHg+Qow4w?gmx1={edU0C0kr$9y91Bf{no6ewu0oyGmK@MTml(*
z4n9a9be+7XwI{3-_~g14?$_dbs#nnOWpv*W@U!TCvT761mgcR}wE3|&KOVbXv_3P`
zVP%CrJEGczXr#D9MPorv6HDgMh&OB+)q0q056~pr!}`wQ7ma|DUrwBo;z6S3frS49
zeO%ifrUWN8XbOC0m--|;j5%uWFV6xWZ`uR>1aUV15c5u>m6SuQSz@P%R9}*h@|`XI
zIFzxU$|z<19X}qmxqOE#G`t|cIf6AP?49do&8-sW$YaQqF-PJAP_pd)`{Vek8q`xC
zX$?P>uLC{BE|GtK`d(-I^gYq7Y{RjSe}Cr4@A!W6<;#|=TD#@NW52!hZ15wT6uRS*
zl1o`p{@SDqj^4TdqtGGWCA+T3pK(dbz_;(d|IKgS^xbp=giZ3Ij$Zlq{hHcW@&+*p
zE?-H1@Mi+)hMqQm!*r9>W%<N!=qj{nDRxIswPk=TVu{nS8~Z_bccwUv_X&PGELsz%
zVQ6S&WZ=KiwOfcjw6|`589Qa`-m5|1NGk7LUEU{7c_gDmpDFL3b*<9XXVbM8Qh5jM
z@;z?dOR;~Xo4e5Ob#-wa-K%2NNiSp&JjJEa{Sdle2Kin}aVs^b4|eetn)Myi<6^W=
zyRMEYgO1rmxW<y~Q=B38HMX?|E1|db2njto_~jXt?k!~^LZ0te)ubVvhJ`c!TxU<>
z=vAEgf=`h9%$c8Ir%kh(kp+jj=bc-Qyz|b>x4kOF;kjeWa&oRHpX0mbO%{86^KsVX
zgZq37uX^l;%^M#<The+6>A-1*cT?$ps>2&vp8#*bi~kT4j&(+hzd`WTBnzcjk2i6_
zW<028Y#~|?CVpXU6!b{Xy^KNe$ygtZlaRRoYh1VbJ_O+yNjTS_Js+ny=#z>j76HBP
zo>5AjOWqKIS8GIaeGfd5?H@4hZ#1;MMszN%Z*>B!THi{?7mAIYO>G_CHvy0JEg3Vf
z*0<7GEUYw5i@nM9U?amHg<tAgg};=`{XA}XiJ!cBM7zQ-<FXb0Qp_C<{|$cFTiO;?
z_@(|=_zPG7`1P1a@Pr@wN`7if={!}2jGtCz6j%?U4EH;dpW)*q*+YK0=cYfkLArIo
zsfV$5B8`2o+CcJ2wLyBO;gVUWYc6X6nHlS8Z++`)A$&Mx(tK%=WX)Nd9_Q)6{w5d?
zV6^>7x)U(e7ir?FUI0$$C=u^PteB?};QjbgJ#;Ca!#Wg?;@enV<!MN0xolo6pHu8t
zV~U&DLiO7gni=}jZYQHPC@O>SWB_ANNe?UdN18!{H=Xo8N|kz_H*|Pr^s3|kg;nES
zLo|%m@Ttxm%JjYNrtMn?E6B!Ha|pk+m$k*$Rb+hl22p@MN%8BLTkKs)v9Y147*~4w
zFn3e2KkV(`DeEQhyb|9=Z>w!EQ0o1`;SbxW_#^q|>u#QRvxds&l7AlMJCruX|79=W
z)imbFey7Hqbn6$V-`R$RYYk1sHUD>eY?S_&vZwTa`b9?eOiS9nYs}?5*U;E>h}v~z
zFv+u@^ykZT-weO^_NQZR*p%AjPO%Z+u5r(iW&e_%cG}HAvh*`}ajCB>-oe{w_dCTv
zeBn^P<48ZOO8Hq4un}!GGC0CN4C4&hmEh|%@dZ7fhUY)P_M$eE&pnVTzz+=$7RM>J
z<{jA%YzG?~x*N|&1c!)zo{^~g_xiavB;!nG28X%#Z~}f|=w5;!=HAnU=S}H3^>^Y6
z`a9q{Vq8?V_Cs{P4K;Jm$67-^=93NaHr07M4&pa9i+$3<LC0ok134?BG5R|VKh}vY
zC3vZWNK5}ydD!<WV?JOlfXDySeHUo+X=GC?++llijeU%`c$ZC0`#Sy)`_=^b)tmSW
zLlpd_wQ?Fq*V4V}PqKcPA5;DQcd_{wLJ!Q4x*Y3K5_f?$(b+#~^b+FLUHd09@h#!;
z<kQW-JFp`foAoBsr(~3#y%$NzgB+KXJQT3S&bZ{32Q{;zIxCrw<C2nz0{H&Txa5`z
z*E>UDdmpE93H^ZTGQg>e8UHXp#%4aduZ_SQxu0AQm3>6k<!7^&Yerb?M^ta1ZAe#9
z?2^(|MTo&48a6ga9pLOAQu;^6E-C#}G|<E@IT0b+{#1HU@=4(?uw)FZ))fRTafi>}
z6n@Dkg}<Pq;gXr*!@gD03Hr$%CmuoB5RcBbUluW+Y80ThAiJ34`9j5`v+O;SdkO7v
zV+Ld@UfS^Th(DAm?dHu=o*CRpxToJq=I}ewu*GR78oFgYJA(!%j*4)2zl59uhis<?
zDK=+}9fv(QDl!yhl!t0O&8ePW=rZ!1GEBeiiZW;iB+)gB=5BJo>EEi1ppk3SR-I7>
zQH3&SZbq`8=4M4!i6aYUZbm!d2*0v}q%2G${6$_P3#JbCzBx7Tld_<2%YJEOfyNEV
zBj`|<{44xY78HKhUN|$-K#Lmxg(^eFnW-}NSjU|>GebZ85iVJfWvr$+GgZc(d=q76
z>d?|93ztKG_9FfHk!}Z<Ow+y!Sr6=mcE(Jc*K3Jv^25N>Dcd@DrcBE+nrb`cI*cE)
z{gGBz>+=Z9>Spy2vi+dTSXYN<My}eTEGKRba}>`H-uv<HUl=31;p?`0HJx(bq3(P1
zt{j8p4om0VKyZZTYUu5*GCBz3?lzH1?c51GdJJ|$S8J+z&S4iqUZn420nKG#Y2ZFS
zIKr#q@7~kzKTXd&0B<_I|AT%XIpA9d?+>%__Idi#^YOt4T{fQI+9$SH9tlrl*HfUQ
z6V>Ss&p<ZT)>Wnt&?>XS1NsVl7Xx1Eb-#6ocp0l~dVXSdBs#IM690|<w`~0EHpGaU
z*ha^f5!SXC8$IoO8*~{yc3Zss;uIO}rUdLs!WUAZp-~4|s~CS}pQJjlTdg};mi>mQ
zgB*WJ8e}~}H&8vUG-ceHWLnacfjw1~sk#isr{7H(dr=Q#qnR?~xf`Yo@;iL$lY8qV
zuY7E8{2w+|rVP0^J*<p~C{xBBlp#;Pq?-SmG75asc2#BUiLbHWIC~jVJ}5pDyn-y#
z`6OsZk`ucfO}jXIpGbaa4;sorPr&|t`IeL-`z=$Ry%$aK4C^GiU3Ob9IBjq0gL$~i
zt|hz3ccZD#?hDV-_TcjQ?skdjWy-kSdYxTibKu{W@x3YI_Nf{68>SA}C03`5d{f3Q
z>!ts$9{w(-j9ugYn|eriv<ud+cj8PAGjI5}_4vY+v2&7))2h=?-1VTg*ETTPo^0T{
zZSRz2{CCv$KCCTD8AID+5Ar{@y}ehkBKUaNe#?CxW<{c}jt$-)w%>A}fX>HrWxq;2
zr0mx_JlxSk#xL#YA+@*k62MD8mDEG8;M*ly57DZc)Wz64B8@nMf0V($+bVKm)eU|p
z&Q;-;eNp+rcK7XY26p#;-btk6h<50>d`CXqxLvvd_&ptb8*TjTw#0^Z+ZpPmt#Xc%
z^AKj2m@i8mr^>k1THxq7Q%0En31RI;%<)}i%D6Svb4D4`Cevlmnp;c1)N!hey{L!L
zac3{Xl6?BY_mC-LZ{nZ-sSI(1bet+<56Un)?%$L#$M>o!V^8AAe_w`_J<@R~19hQu
zfFL6zgLW&LvM?@a86ny9)~a%(j_ch@z9l8pe#^9teTK$1NZ+e|DYre89P*zXxix++
z6SG79&O^QhfM2iS-wV~+*a=?Bt;f)GeehvcLiPjjV?Mu+|BLo}lm{PYlWFhX2>tvW
z>R;1>_j!8KJYPBrWSvte&S7Nm9&r=-cwnE)=i&?6Tcd1!siOgp+9INw<=gZadx)Y=
zs2{2IEIIxIkAxRrI^(~w?%EjoCI0pPY8yZL##Y3yyKN?E+sQp%U8JPjWqA70_%F-A
z_&?0(PE!JQcB?lqmY+r$J^hH+(SE91t)2g1)0r~h<G}eIJ~{rYGHxAZ#(z_WwB+aw
z=nq+sktDYu68d>B>M`n!dPuv`ltJr}f7AG{%Gf*1jQ{^wM$d>2rXJXz!P5SVGH#;r
zUzM?Em>K`iUWSwp+Ix<ASh8>6tR*SsQclijcV}Ia<cG$8lq35_wi^E-MfO{!Jp1gD
z=~$cW=5LPrY$91HW$W36Hnfo~ivFQ?$NbF`Ab;j&4S%+CRL(X2OohLd!Jlq@!zP@8
z--%ID_z{n5N&JWnKg*de-L#Kc;g+_WqWuofSY}oQ4DDSFErgrwVnzGe`vvBbTGuH2
znFjxE>j^gH4BDMNfC@k2S2gXs$C$Vw!}oKwk6?Q6es4G5EQOnN0Q@$P;Ss@mJOR%e
z3WrMvlm`!l?eW>?>5V>xeMuOrm(UzzlGYhp2#?x(Bz0aNYNtCqeH@)<e6bXnMDS{V
zlhk>@LptMgN9UPYbJ$r|-g5GT-=yW>D)eVPw$mYvq%+Lg0q}duXbtLS4d41KYamVx
zDCh@%=}T7l)2%NZU$Vj9rVf5-V@v#yo8`toZ2UhI4Gf+s+>$p6_Z^<m4sQ(Z)<$lK
zb{Y>9?RP*goAJP4hhEWgqwq^RM&aLWJ?hvo^vMay8>inY-pD<7iuT>3&7QkvI60)5
z9Bu6VxaGlnz2$QMhQv*BGm7?ELJmA-p8X03$;~a)uFZpwQ_Ksk@eq7V8iSezW5qm@
zn`s))!q6=6ra9(mDgMWRr@xW|Pb-#fx2utxNW&ZQRS<80hvepf!yDtRaQ5jb{KE|X
z-PV;(yPC1s?BCaW!z6Dce#GLnHoP%?3O)pIp3}Vi5A02E37vVBvayMO_G*&dRAhZq
zS@y>g$z;GyRm*1d5u}z0RZq6WIi2n$U{AFCPDWKD%H-$7ThamX_*9we9NS79Qr_7)
z5f+gTIKk8Y8l*bfwh@lSl*f#!Go$-7Qm5OBKPnD3>~YbBcRl*(-6NOvIDY&{MQw*U
z^V4UvZ98Mo{9Mo5e|KL!WH^iaiO#sq9K@n39(dsNmU~_rn#Q9uvcHz=#@WHI1?tbc
zim#|m)2z!v7vp(FaJy$S*(bf^bGAb)CfQgM+%A45891q)^H=G)gny6VyKDGE^n4lM
zg9QJRhKIic_&edbdw=W>hPWF%?}q1D1dr7dTF<zMo(F&*XX~O(mA_?&z<f&MSw-;5
z-?D>Gr016d{xHEyD^JqDfu2tW{&xueS4~fqf$!yp=c-%@pY4Xn3{IAd`U)9KL9sIu
zzlFFdJV$-`8w6ji@LN~X^VY%bzK00@ZS~xHBRy{u-0s~&@bGm@Jf7A1d6wr>@3ZiE
zp0DX#9J&iO(I>$R#W88`u>tBiyDcQolvsj!L<#wqhT}O8p>$6K);(k43CdS;ZLeaJ
zC{wqT(i_{54!(^I|I{Z}PdN@#r*FK(#>f+9dCbAaj-cXWV+Wf!w^DAKs_%ey>R=13
zz-h(uD_EU)<7b)m+IRT=Snr)Xk35T;^5x6RJ>!4-_L=8@@Qkl`{dF9`{Lb!G<xoNY
z|I^Q)SrA(V{x?AU12Nq8;fE=bss<7CA)N+c+?SvAY!FlFlV6f>e-vD42FY6b*mW}R
zb>iqX*NFPHPo3cR)sE%&Rq*odK{+>KA@m+8hjq%wsPMlmzwL)duDF6v4KDtWeHx5o
zpH{F}cLa}7`QJkRR-yh)tfgnEzrBewj2ODHPaLj_<uOuqHjI^7Wy3HARr%>d&6W5#
zitAKj{pkxFHB6r)(#If6wTY94lM!o$FN^+u&C!P*I=XM)3U=ww!QSlTAH1Tr)U&Q)
z+qR0}KE9@QRIQNm#}F%Ni31oHnqc=J5oYhBrW@)#_7D*^D%j`8SH(8@H}pqx>U5C_
z?r*KiW{-@i^kcpxM*zDEN#gP4Ob~z9#3Q%ge&n&o#{GCQ_yWtXVLt_9JTFu{|9nO5
z^Xx#dMJ=|jNF8)_@HNkGb{rSRwe1$-xG>H}i<d(moiQ#u^W<fCFV2pa!dw9HQt~bS
zOP#l*ZDGevRp6b!NUxFJM;Wh%J|aE%nx{SKHPZXQ@-sbO7kth8J;5WA0JcT6=Lvd#
zDV`4__#gH2HuO9m_<tpM@{<GqOZ2=0o_8d8@{<Gqub`4CTLf|!W9jdt+x7vq+u2p1
zw;pvuFO(gfx$gRAWMvecV6DDy1rdTM=~KU1GVkPL-9HQ7yy!lD<X~y=<}dgU{F&1~
zR`_a9@z@G{#td>~ub0DzHO18r?0$Hrbs;}wAwS7Ui>bD$LB2cOxW8s8zr2MLzhfXR
zUM(&7!m9d$ZZiMi@R5723x4_LBaM8G9(p7A)y)EXgmzSj%G&zl$MauLkCC(m&_@x=
zjFYbBDB9@M5!jiIz}q)rGEOcQId(LrK3ds0taC~+#-I^#tg<nEiUxnxvE-0o`kyNM
zBK;Rb*Rc7&1b^`bPyNJlmn{lbo@7`l^!yk+u#E4moyiB+KEn4_@Jnl7;(cqeK(5YC
zM_gMSnr(iDb<+P0&GJjY3@TTD4LF&<aWV6MbI@1y4f9^M>esLD@ZDYg+cNfLunpT1
zEMQ+&u$P17?3!R7)fXua8*vyu8HWw}TSBkA0-iUraum<)HE`m&;cSeLzWx*w_6hnb
z?jvQ0BcR-e!GqJB25EeP!gY8(v`7b1eWXcf#ONT(Yrm+eIa*dGE~vehx8+xTwM~BB
ze48hFdoY@G$8G#-Z#2H6G?=Y>&YCxG5QY&ML&e5}W`X{isHhI>RknCm`pt(|Ec*H`
zq?mMBa$_)%jXQdjz48kCN*w)b%qw7q)tU_lN7TRe$ka7M-^F*B=rKo$3Hn-K$3Sm=
z?Lj=$RDJEmUjGt(E!QL0>1#iB4D8a^`0}guvc9g5Q?y>!*HMt8_w;oGoW@n7ucL9A
zcPo7zOJxa*dFp|tfh-ezkk|OmHM>k-b1NF2BlTQZLz(22gz;Db_J_Xq;+(Q`^tI25
z=i~LY-x|+tJoT(7{<eOOISc<>Uq@M8`EUBVfi+#U(bv(|c(HtNaZy=ZZcbTF+}z^D
zD@qFU3(De#6c^_&%!^A3Bqoh5o>N>_9G6jCl$%#nnwL8^FTZ?YPKkmzukNpL`sefT
zYVtq*I5DrJw6M4+E-^ka5J*f(>@N$_(59ST8q*m_3QOa1;>t>La`P7Dlq`rVo~Nme
zS0t&w@pFq8WfYVYmX;Of6vY8YUP)PLanZ=axm1a`a@3|IuB;$0E^TqnTx9x}o^dvD
zN%4V#va-eJB_u3cwk$q}pyG>5@)H&+9Hj{(hh=1CkIU)>NJRA(<9w|$D-I_c<RH(%
z)m%JVY^{KF6~cxtpkIgJSuySwT6us-f(}i@-?4Z$2dNAx4y!2=S1urmU_IpFYApWd
zTjh8w2iV*=&ijw=#?^WIJY8z?|M|^{prQm66%u`MpgbNaKy^sLRew{XaNK9sr&k@C
z{!{(qP-ZExORkoIh8*I~BI3pZJS(>5;jf!7@nLu2zsPo31TGg)%aj6RAutsIgQ7#$
zvJB<PRv3xj=DJ!U4y~Ztri5rIz;AI@8rnGraOy7nou2r;F6WZKxd2H-8Qwe(Iw}DX
z)AD~j@Hn{QK|={zJ^?N7rlS;3Mk3BF!^*-LedF-A7g|-~l=_zbh311tXZh!eg`(tu
z5?CMiK|e+yax)U=Nk+lekH$AeVlcMELa#NknnE)+hxTfTuaLFI2?cGfcF?SGRtM~A
z>jZ7u1vXwc?8H15nz9E@YUl+D5=a`7@b%XeoCMYzp1{6{C_WFealSRc8i=oO4Fb2)
zL3t*q9*kBRih2ykEN3K6In0LDH3pvdv8dB{ocA#ip25kme5S$^GaY-FXIitY+2GKv
z)>`Wd>v8y_sxd#l4*Ps|U`Nbt)_Nwa%dH!&pRHf8YIQTtPxD|;`oC~;(%m?d_>}b<
zPIbS*`pMd0okTR&Zp4Q@WbLtjU|#DT_<26JzJLcm0wdHxR?oVFMY8%ViZx)-tRbSR
zKC?csKE#grPoeQY!RbwnSS)MIny{v<8NQp*0_W1UVy#&l)|Rzn?O7bd2fN@y@5DN@
zE{G-RhVNvY%eu23tS9SbZDa8)0TI^tFefaT6o#*zvp%dZ>xa{d`{ToD1K2=z0ULyK
zCev94%Vb$>FdM>#vSBz`bp#v9MzL%*nvG!>;^h8uY&@I5CbCIvGMmDt;zOg;*$g(5
z&B6&wIcyG_%W_#Bo5%850V`zl*#fo@-(4uecL)}<C9H&%vNBeVua_)i%h?LHlC5H^
z*+uMPb_rX<E@hXo%h_6X1-p`6#n!Q_;i<odUCS!ib?ka}19r)8WH+)+Y%{xw-HcNg
zZ(&>6HnttnpF7zu%o+Buz3f(Y8@nB6uHMP^vAfva>>jqC-OKJ{2UsOL$g0@=3@6dD
z!-(^Ih&{|6VUM!M*yHR8_9T0XJ<XnB&$8#(^XvuoB72Fw%#JV^0qj-w8hahzT)dwh
z!+y30t>@Sq)*<Tw>v`)k>^;4Ty=mQpy<$&TPg;+$x7cxfrQ~h)4ttlqhv@BV*$3=H
z_7VG-eS-5jw_3Mg2lMULM$B^V#Q8g$;75O$eQG_$K4YJ=FW8stEA}<}hE=m~*>~)F
zR>MxRAJ~uVC-yJ)Gy8>|V!yKA*zfEQ_9y#`{mo9ZS{7s>bTG#8u{!SIUhczJo+5ZX
z9?9$TDBgfa^M*WzH{!9pF>k_~@@Bj_Z^2vgR=hQD1FNbXZ_nd+2i}o);+;9x{&_ck
z4nLQ7$M+|D@?JdN+Rqbs!1|Ua@+6*Y-3!~~Me9C{Aai*Ndi_!8q?fSo>viiD>s9MD
z=*G9KW7Zqi0ceu9alZ8lXrAw_`Oqi}pa&OPMLZRHW(o9;)b8cbeM_N<mRl<^cCE55
z!an><tc$HRSfi}59^t)tAKsVu<LB}IR;?A}=ko!4Ain_TPg#5rPvhx4gJ<$AK9~>T
zL-{a1oR8om`6%lT>rbA|NAofKLOzy{<Ky`RK9Nu2llc@rl~3c-`3ydj&*HOr4xhv4
z@?4(B=ka`Azzg|&zJM>}i+B+)=8O3fUcyUx887Ec`7*wouiz{BD!!Uu#4qNT@HPBW
z#NeIgm+{MSX3$rBEx&?a$*<z;_|<$pzlLASEBJN%dVT}nz&G+6`6j-Z--NG!ZsE6B
zkMga28{f`%SYKP;@SS`Y-_7^%z5G^w8^4|3!SCez_+9*Neh=Tz@8$RL1H6(S<W>BB
zeuzK75Az54L-?N8Bm7bR7=N5U!Jp($@u&GS{8|1Sf1ba<U*s?Gm-!KXl)u7X<*)JA
z`7!<mf0Mt(kMk4!ZT=2_m%qo~=O6G7`A7U?{t5q-f5t!OU+^#aSNv=K4X@_k^6&Wf
zyoR5|bn!?26aN?gng7C1@n89G{CEBb|C9g4|K_K8Ef4aLumlra2;mW4;S+ulA?k@p
zQC~!f1|nKC6fvTah!u@R6VX&O6U{{n(NeS$twkHrR<slCMV#m$I*LxBv*;qaif-Z@
zajxhtdWfE)mxvb$A|Mh)l1LUQB31MjeMDc;Pn;+Ei}S?*F;H9}28lG0E;2->$P$Ca
z5HVB?6T`&_F;a{Y*<!R9BQ6wU#W*ouOb`>rBr#b`5mUu9F<s0MGsP@1TjYp2Vy?&)
zd19W(7X_kF%ohv9La|5`iDI!>ED<H5RFsKwu~aM*%f$+@QmhiI#YN&`afw(XE)|!F
z%f(u8g}72&CDw_n#d>j#xK>n%>%{fq2C+eG6gP@ZVzanO+$^?;Tf|neO>7rC#7?nG
z>=t{(UU93qP24W-5O<1w;x2KwxJT?4_lo<(0Z}OqiYjrxI3ykrhsA^9A@Q(yL_8`U
z6OW50#FOGF@w9kGJS(0P&x;qti{d5mvN$4+idV#|;x+NQI40f@Z;H3XadAStE#49D
ziuc6(;sf!a_(*&#J`taa&&22A3-P7+N_;K85!K>b@tycy)QFSf2l1o$N&HLvEPfHE
z#INEv@w@m#{3-qte~Z(iRs==JV|kc|dxXd1@p^n7zbC>|&lBmX?}_p>@I-qWdSX0{
zJh7g}o+h5Ao@UnXp5~qwo|cx!lRaVNNZ+EIxh2I#(Tnp+3X5}LIG5#><mGyX&dDi>
zT999omshkfrzp2@uE;9N7kNeb-i5_Q`K8{`1;r&r-eUSYf&P}uzy9)~!a!1TA8+a0
zf@L}CZg6tF{F0odc`(-J)XSM$UZ$?f3K!<mm8YP%cmaVX2L?yv7MIP*TUflzTUK0D
zT-qSF5ag7?!k2gTa*B$}@)qV5=6HwXELxP~&CFX^mg5~?kXM%D8=13cPHqmLT*${1
zddC&!FUk>P3JS%T(n4>}!o>wSo;iT>=F@w*@;!gv;?hFY#<LPX2>Bys3S~K-!eU@s
zsIV<B6eR`4zEX)U(My>q%PIGlt5?NhlrR?wx8CAKdHJf!$(f0&KAA~6?@f71K;5SV
zQuKX4ou}zMUFU;Uo~ZDoBx?9XjVG~>{=Kix^?OOl>OM)sCu#U34WFdplXSUBy4)oD
z{S5tnrp~i;uIWkE^d#$gB<u2$b$Q9UykuQovMw)Kmy@i^N!H~g>vEDc{uGTjMdM4+
z_);{!6pb%M)1RX8rf9q=8gGimo1*DY(fCs}{#1=WRpUw3cv3Z<R1M!dpz7aS*Soi_
zZ*Tp6?^OM}rn9%Ev$v+Rx5nRF<L|BU_ttdw)^zsPboSQe_R)0Wv&^zXrS#F|_0i?^
z(fImke0?;&J{n&ijjxZ!*H_o0udYX5jlZwP-&f=BtMT{M_35kY(O1`_ug2e3<L|5S
z_tW_MY5e^(zJ3~CKTTgh{eGH;Pt)*e8a_?Kr|I(3G(Xcc9ch}5bPb=b;nVf+>GtoM
zKk2$$Y$zl?X6X86==U=;{tW$ork!g%S(?r)P3K^Zcd+7nYC!#-s{3_nK;ci-{W~?F
z=t~W#`lJR_d8q+aPHI4vlNwNXQv)_$MR#gI(VZGl{7wxhey1i<xk&+4K60WDIkhWt
zq60bA6FJd=oajJKbRZ`>kP{uqi4NrH4aj#=I=2{u!JLH+mXt&BmgFskPbV)|@-iuq
zq;d91saI55PQyouXJKJUj&E^Zsnnxc<t4=gny8CUOjKkgCibqE2cONNoU**!dc{R~
zdD0zK5LH%y;YMAT)}L3n)V_`?MZrb(4;V%k<>btjBbCHHIBPI5W$@s^#5ClYzRB^W
zi{>tlr1$7D0;R++EGl1AZ)ILdF<nK&zm<<cPZo^<C~7XeVhiE+kvB2!n}vDv%Iez>
z$_nR3&ykEU!&d{km2b%bPW@;`xyEw~OXij@nzt}-xp^Vhd1k-m0y9IU>zP5Pup5v@
zE?$&i)GEvKrBQW#=_<=mS*FUeR5n;;LsT|YWy4f9TxBCvHd1AyRF<u>(JH%8Wn)z~
zPG#d&HbG?*RW^yTNNQc;yl;y7VJc;+MPz$XBhf|KvSRm3@>#uk#pNaH1t}VI6;WEa
zTwTZ)Wb;Onlqj&GLbSPj)h`<#BI+l!<%{bnQt%`~A(a<|6EK7lFj{tSrBMP%VZ;Rq
zk$fMfQ)wworFtcWMfucB^>TAc3v-H>7v?C6N$3c>ydsK;P=#M!dh_FR7M5ws37pE2
zSH3Z-DrCS&s0OwilF*S-3#4WGGC@a9nWq4hc*e^=W%v`BW{8T+F_-={W$^iPRPIY7
zRK6UAF|9Zs+*;tzQF;9gM_B96b*`!8M6I?G1L>e32Uesnmok5rE(6Y6X<YiUR2g}c
zMP|XqQyn-m&s_Smbjf)t_hl)Jd6d;3;*?!K-?>(FBq=qVn3Nbb#MLFD@?AIehdOW7
zFL17X!>D8W3Mums)09Iw5#_@a<%Nnn!!(VBDvumy$mhd`^TPS{hdYSt&v&k)Mz|=6
zl8VAsVK7^zMGSjWW>F(uKSeEc-S|c-b}XdKGZF=R7UGXDTfJYT-p_Wu5>@27@nx&`
zixfMHauyetmX#DQF39tb)>SUnRUWOXTufPm(FNs@?2__D3v<fL8Wg+ld}CGFC93SP
zuHvFfTsOY4s_YV#jZ<%xQdWPQ!=?JA&NVe`Qlc6slM>Z9nb=#|Es5F=OG;GZW>R9h
zZ@fZYrm_jDQOi}MPS7<h*EO7=YFJL0cY^F2-g5c3!31~x8kD>5{1bHJm#e(~B!}Ai
z%Ust}T-Pg{Yu{8=@0FBAPBo$vxzb$v)3WGSe@>p_&gjyGIi&^ay4ZECI=s?-S!D%E
zOURy2SM}3qh|t&cHeJW0IppXci9vK7oo3Iq=vHYDx@_nu61s1YF*h$4V`UEA)z5Mj
zrpTw~F<EsAi_Quwp#Ct|d&68r4y*g#u<-Y?9h&QpcHtQ9!ZErIj{2jWm!e09<D1~Z
zF~NmnLLD5@6T;t{;=o2}rK%XBG%8(3X??1G$Z+0>aVb^>DGgL;R1HaDtge-6RX|#?
zsvneArR#={PSt=)NHw5?Eykrt)sI7{7pS+0hNJ-9G;*s_dJ^MOq3T_wJJq{dbLt;l
zNVU?W9~wFulkQ_&3X>i*a%)P3OKC{;t6M+nU!A(ulUh+dRa#NK<JO7#SLdB5t^L#w
zO7+ooY?$IxKP!Dl*NxoTPXFp)t*>+(J&$o|IC{`vTv+!R=e*Wvyi02;q)M%+Yo*la
zI!dcF{e#2pNYZBXI5td~>DOFh5#v%|^lOYubJ2t7Dd7^YG#LHV(9vIXUw^7ojfOC*
z7r|*XXJIM*7MUjfFXX|A%2JLKx{1hw$x42mVbXY&S7?qxIqs^P2`=Es(bBy_&l^b(
zjZGOn@lpw%bWA(^x&+Tu+z6E5k;uIxauzSn;iJlVb~y$-DnpDdC>G=4%+bY&jDo@_
z32dWosDH5UBgqU?q-oy~-9(@yx~L}!qpK#`L1e#554{T{5&mLTJdJS4=^4DJJjz|6
zhIL+z((r^LO8-bVk>qirOG1{Srh$PJJq=CK)6Wz={Y=r*&lElVOwq$<N<dGO^)xd@
zO)mo}iP}w|=54sw(``K*rzGn467}>tQM&~awOc^jWhqH|`kbWksi|WiC0S3elQrIC
zJ?&1`cvAH5Df;~sJ$+Bn@TvNFs(zkoKiBSqR6V^<)zkV^O>b(JZxShe-!hd=BE{@m
zMp?Z{cB|D}W?%WHD8LmeTU1yijkZ$wFN<>P<t?8JcOk@Gw!+|a?F>j9tf)^?PKd-T
zRV(Dgoy06Pc}GsQNF1!3R(PLkgIqf)w38u4I|EWuHCIwK*Zb)EKAIbSbnW}-+V|01
z?W4KS&(8JpH0{(#)6S$c&HXgpiWwSzhQ^<vTQNibo~eJ=PR|tW^i0Xrt&*whk*QlJ
zQ`48J>C4pRXX^4Zbt`4+`ekZ*GIe=by8JASKTG4!()hD9{w$3@OV>9`*EdU-m!-?g
z(&c68^0IV!S-L#kjwyq6{Rivv2kY_&>+%Qd@(1hk2J7;aUm}n)Sm96Ay);$#u2j{#
z60?+347rkrtTZYI_f!sYDhD~0gPiJ#oa%|3%0*7)BBy#Hr+Ol%dLkz}kW)R8Q#}*2
z(y1Mh>+;ie`RTfR<#faEy8Luqe!4DSIpOfTE<atDpRUWd`+;)C0Zx~nuFF?)mYAjF
z47n~}Iqh(->z|>^&(P&7Cmw#+_0Q1dXXx@Xbom*&{u#Rd8M=HW$B9`=j*;v7D>=r!
zuD_CF-0Sj{9OGWsUpWtPugh0*jeA|bl55=S@|9fUUe{ka8xymXvk|$jzmjv@>-sA>
z$Gxt<l5^ba`YSody{^BKbKL9tD>=u#uD_D=#4IJ}$aVddT;pEXcd#yRu&%F?bNt>9
z(|+lHkm@ffV5^aSRD2+%A5}k)qQn`w?lwvsaj&{XiW0X#iV`>ER2*_DE|8*{5xMTJ
ziX3z+{d+$R-%sBw@xuGM8!Iskr1aJA>$zk~KVmcJ)O7VDw%}gB*H_o0udas@FVLZ%
zD{;cTeou)f?rr+DdQ{yC^lCWewhW}IH6Fyq5u4%CRrJ6oi@+W%w<C53XF4Nhhv7aF
z(K$UWmN|Ijcs%#W&>#FJe_;#qN{aAIz9W-|VuZLAnfj^4#B>SE?h3pec-vRyk4Rh|
zSc9;F&Pfse=+us>9g`NP91kGJRp-F^$f1!(k~SqR4tyA>OkSIs8JJl=CGoq&CQ0q;
zFOAxrG(53MU`&IXl9o0&mHc(m(&*^KCedS3ViT7qbxvF!eWc-`n7xhG#I{RX8rwNG
zzR6F`jx;}%*rdgMEe^H1uho}rmbTf~wrg@ta!vcbsU6$D7WY*0+Kxe4a$>yv+vz3w
zTbG$#<GSA0Evnns$t%xUnEZA8{&Q|R_jF>Do-2DEieDeUKCwx!kK<>{D_k#68XovC
zX=(ia#3m`R$tzQiryNgem%LKeRsD~DJH9$0I-x~EyM#c()P%(emnCdUcqHMegtrqu
z4fq0Wz=zIBn-Z6Y{pU#$>c6B){U<mH+c{~m`k$H!zPSD;wbTEHC)xj(CM^Zt?@U5C
zhx`v55rD0e?2=@z+9c3X{x{_h$9t3lW8{CdlKii!k$IppH8W|cY%}>Eyon%Ook1zu
zJSieDQ{JZ>S5E`$lQyMhqK!M^t>H;aks?xJ={HD3%5lVQ;;oce8%tn4DBqO4Ht{>q
z4mn6#3JCzOla>Z5<$qbW;yKzAwN|y1t&_-!u8zrTlfPEK(eJYU?c_767ceHq16C*b
z-0;oK!+&#Km!oy>RlOAtZC-}u!zC9L4<#RymP%g9IwyZErAy|?H7T)*gQ=MoV|Sr%
z$>_R9VexWjkCv+&D<>o5WOUppiiaDISU5WpZU$nMZ^4<%_af%!0HW0p2ZiXT!-!>j
z7+(mKQBO}H3hFsTL%oPNpqCK|^cuzgyoop<8U6FN^$z0M-owdFA0j&L6GXIqj#K^-
zD<h*`5K;Fn;^MwXgq)0`JB2gv|G@c1h^UbfK8#`CeLWrZ)=tN?^+GIL2IA9Xgqeyj
zy9v==cO%YA#&@aME<3VI#&vy6aaCXcPhzU<h$<(J>dg45Zit=gfw(EeOv&!WlX(hH
z)p1N|h*ru%q|z`%DP<!zX)NNBCL$(jD&mo5hD9P3APQ+A;*C}y*61R{8C}XRM`Y1e
zh$^yUif%wWkvk&iKSkp-K>STC#oe4O>PE%fxFc?4yp0`gBV%j^Ail<qu90yyDyn7-
z;%Q_g&GfUz&&b#r6*(iLWmeURl9ACd|NFR@2mftM%xj2%c`Gc^<r~Dfd{6N$c3g{$
zX9*&X#p8)URBB(uruIXOYJaO4PSb3{xz&tcZN>6ykXIm`vYH8j<U{Ij#fkw)7a*nK
zexlVx%tZbP(q~9tSj~X58AioMp*ZxD=uk5&2B{NH@a`G>0}-rEtc=jdR#xbHYcSFf
zq+v)n`_LMPG(PmTH7WF+H5of5ry*^?v&~31<JrByaRBKs?jOQ$&mw;g=>`1u8t}e}
z^b77oq3>C}(DSSb@@AoG)(Uw$qy(!8>y5k*@(koCmkme4SxBrf)Ql}cT7p!9v@i4&
zs|Jp5k-kIv9;pWDB+?I|=eY=d%soh6Bp;F=DFUe;QY6m1ua6Xk)Bq_O3AFI0NX?L%
zBeg(k8TyX5LTZiF2B~eRnzuu05Bzb!(*b!$<lr6ejJzw}IR~jbQct9KqySP9QVJ64
z#`_|jhjc#DKqQ<4&9j4l@HxnHk>(*SLmRI^T7`5m%3XtW8PZy$E0NYAT?;yXM7h6*
zo)><c;ZZ;Ioj_eg!%($ogzH#bH%8tn_=ji*m~$ZqJwhJ~&?P{Z09_&xu*t~JL!OQ_
z0&pV%BhRv#g!{?JasHr~h3j1WmWSWwA<sv?0M8d8Ekjy?v<m4Gz+H-TInsLER{-`p
zz+R912IL!%Z$y40@=eG$Bfkmx&B(VPzXkbL<lB&MN4^93PUO3g??%1{`CjC=BEJp!
z9VlZT(%ne=k?upPM5;nMg!Bl~V@OXRJ%#iP668_5fb<g55u{g;UPC&D^d|Uq9O-SO
zcah#l`Vi@3q)$<&&yl`F`W|u|XY~%9u=--(W4}<1)gOE5Uc>#Hp%XX<_Dhz4ybsbo
z?6c#ckNC3C3BCep71GtA8h#C)RUn-TeIx{u59!>{3DF;?g$_Wv04WX6CWgKgGm(FS
z^cm6@NZ*G}cp^|<D^O4g3QnT*V<^26rB|Z#lPJ9srB|ZlV<@>2C0C;4N|bsGr5;16
z$584qlzI%MR-&Y1DCs0hI);*tp`>Fd=@?3?L`laGA>T9fgViVW0}CRBLO*Z|i6Lbp
zU4(QA(xph3BVB=XRp<xN3h51`xA5+8*ab1L3}O&>-vlx7vCuEo&@a`{FV)sCq;W{I
z5QV=1`DUcUNY5fYhx7|li1b7?^h7muL^bq7HS|L@^g}iDLp95{VsN5#44aR%0BNBW
zgMMC(eqN1!UX6ZUjed^vcaY9O>W<VCDIO_+l!TOm1l;JO)##(u=%dx>qt)o6)#zi@
z=sVTuH?q%EiwrA9WFiek8jE}AL-dtu^owfri)!=<*$1j2qt%enYRG6cWV9MGS`8Vk
zhKyE2Mynx*)sVw#$YC{Puo`;?vLH``k%k}*LmG#)0ckVRVWek~o<sTtDHN)K_N)O{
zYQU8maHR%ZsR37Nz?B+spavYM0S9Wpff{h21{|mX2Wr598gQTn9H;>YYQTXSaG(Yp
zr~wCRz=0ZYpavYM0S9Wpff{h21{|mX2Wn938q~T5wXQ*}Yf$SN)Vc<>u0gG9Q0p4h
zx(2nbL9J_0>ze=9-krzURg`%HuXE4sPN&nIP6*jBfE&sVMnH_90y;zxL3RX1ki}tD
z5fB(Q0davrKyVvJT!&#097O~S30t!S8c6~fi5;`hxwkv%^u3)<iyJxbx2n5IvxtuG
z`{#Sl=XX!tbI(#$&r?tR>N%&*qtv}h-K*5SO5Ll}y-FS5)bn9E-qe*MCc_k%3e(_t
zH~~(ww^Fcey=+)7+tbVL^lIn5+Ig>b-m9JWYUjP$d9QZft8Mq1^)bG<TrYQd_RnxS
zd>TFzx6$lgn%zsYduetr&F-byy)?U*X7|$UUYgxYvwLZFFU{_y*}XKomuB}GgO<%5
z9}7o{hkG>K1?!5zY)UbZom{NTJ_)D5sc>4cPA@W`7a3r|2UzO?R(OB~9$<k7@_mYR
z`TJlt9O3t|a4}p8m%(ya30<x+D{SR^8*qm3cCc6YDtrxYgL!7S{8}!`FbSr@ba)-e
zMYby(0yX#}{0aUHe}Na|(D_Sm1=lET2k(S;!JhCQI1WAmC&G;|AZGy_mv0RRz)^4v
zoCBYO^Wkpz72FH+;C^@z+Tjs+3?7FLkbk^qE39K1cpJPOE`_hc*WfnzdGUbKPEgv4
z(pHqVqO=vIttf3pX)8)wQQC^qR+P4)v=ybTC~ZY)D@t2Y+KSRvl(wR@6{W2xZAED-
zN?TFdiqck;wxYBZrL8D!MQJNaTT$AI(pHqVqO=vIttf3pX)8)wQQC^qR+P4)v=ybT
zC~ZY)D@t2Y+KL%OZ_=yGDi*Tqi*TwgoT@9#D^`ZZ#X`KPE9-_HSPg5S7uG^w(Z%L3
z!cV$zldh8Uu=$JF{6)Az7rVa*U+7}{7v<$*A^X1wH|WZ@mEKEw|J2(o%8&E=1nHCD
z4Cybz)za6%wQxP$0AGi1!nff&@Ll*G`~a3Y-wJpR);fN$Sg0>qWd79nVhe3?3#IH(
zx(=o52oGo*V~Y;$a|`Wr3+;0Y?Q;ty?NHJVCGAks4khhS(heo<P|6Oa>`=-MrRz|#
z4yEZ(iVnH&koyj~?vU#ax$cnb4!Q1->khf@kn0Y)?vU#ax$cnb4y<^dIbo&Hu2*HF
z;@sV$lQr&SjXPQ6&Tt@oJP1BqEcVX70oJ(_A6}~Uuh9Beu+*I_btgW&l(p_;4OWD^
z^?>(~>>T^wi~r6odcu80J=|YZS@TZTyweq*3lBTyk>bhlSn+h2U;H+7+rJmqf;JlJ
z&<_LlUvK?;cpkLdpv~$HI<rjM-LzQD`mE41bm|#8vzfN-X1$m7KGyqMD~n#DQ!mk}
zm*~_>bm}EK^%9+WiOv#x!4@xOix;!Si`nAEZ1G~8cqvZ26enJa6E9`WR<LH?CFYo|
zVO!W9c7&Z_ChP*PuUF~Rt90sBI`t}@dX>)7(XR7RVChO9hvQx21ULyUa{f!;^KdzQ
z0lo-V6)W^co%vYyVH`%(S}bNsSKz%%^$m;h-lck~&U^>|@96hV*7CyAuF!LJ=DYaK
zma)1kSlt!*e$ofq&K9z|EA(oedbLj0cZHs<Q_t3!pXI-^;aulC&+iMYFZTbXa2Z_b
zzc1VVW4IY^fm`7=_$mAh?tpt7HwWgzeeeK01P{Zb{+|y|z>|JIWxY^Yo`%Kn8(0FJ
z@H<%Ux+|dz=t{mC=tY?hlyhjH6X)okmgt|B(BwKzuG8c?O|H}2I?b)o+)kR?NptHo
zw@!0wG`CK3J85gL7STpiSJTuwO|8?^PMTVysa2X-r*(DO)=Asyw5?9l>a?s*!|F7w
zPQ&W@!6o{^CHlc7`oSgo!6me=PV4Hlu1@Rfw60FOYP73HyK1znM!Py`mq_*g+Zwio
z?O{jQ8D_#R;F`3nPP^)~t4_P>w5v{oYBZ=ugK9LWMuTcJs78Z2X;7W^)M!p8&8g9v
z8m+0*lsZl6q$zb8(n&))^L>gX`sF41<s~$wPD?szNu8F|X-Ow7sne1=&8X9gPFm4P
zD>`XJokrAYM4d*|X+)hy)M-SWM$~CUoz&~3UMKZBiPuTIM&dORuaS6-#A_s8Bk>xE
zcanG~iFfM%%f(G3dsCRro*Ys1lVm$dwv%8#>9vzyU+NX_C&l(+E~)j0N7eomW8{;I
zn@Hp)61j;)ZX%JJ)PBF(?^pZ%YQJCYx2yejwb-u~`_*E<TI^Sg{c5paEw-z{el^&x
z2K&`uznW`TYwc>SU9H`u)^1X3H>t69HPx<m+SN|G+G$tPekJW!(taiFSJHkZ?N`!%
zC2d#Ib|q~$i}w9=?Vn&@_y8ON*TM~OCqx~6(E1@5fTF0<$0~iS(#I-&tkTCSeXP>Q
zD&4Eny(-<S(!DC(tJ1M59jnr@DjloRu__&_(y=NXtJ1M59jnr@DjloRu__&_(xWQ9
zsnVM&ovG4~D&45kjVisU(u*p+sM3WhU8vH9DqX13g(_XB(uFErsM3WhU8vH9DqX13
zg{uCj-H7QTqo)?5rxx|Fanv;1?>KV$u(laTPe<DGXc#?$y36mo^=0>4kBp|;9XB$f
z+O$}mO$p=F)oYEcT8yk(jI3IWtXhn$TC$sqdD$(-f_Qy)rxE8bt?$Np@9|!TIiXcN
z&{lQ)%F&nW=}}heQC90wR_jrCRl>N^7Vr;_%=8$m^%$%57`!539C>u>5mx7I(wkVv
zQQMBzapd+k+v4bLmi6ASPiQfUYcYyzA-C@Q2-`+Ra>q)KjONaDd>qkTV12Rem%?T6
z_l)rFam*Z;3-`eT@DT8dk@v>Y-;;hD0p`n{cO`U@S!?h<lyFR9BP+t{Vr}UfxE8KA
zUY`la!<q0U=!4(e_XPSfj=qeeFB`phv;7|O<n_>(HS}c2a~HjJLkwjd9U1c2JrXU2
zHZ`A}AMx02TJ+G9Ax~ZO(!Jb6cQQTtB%A`L!f9mM%$xN}Pg@Ti=%E8WbfAY0^pO2O
z<~cjwu_wSuMGv{JA@?3K?;-Q(<?12xHRQd9oX3&#IC36G&TGhc$g{Q4i`7HE(TmkX
zrfam*zvWr#A=4f*?IF`1GVLML9y0AA)6t%#9x`2{#eKvG@fcWb1b7Wx3)dUv&4lCO
zO!yM?!SC(2C2PJu9d)#|5fqEQJ|4|_uV<Opv&`#R;PuWn;A{iV7RQt8S>W~Qth225
zh9lru7`e*D(wD+z5U;r0dL?wh$ki{`x6IeK%n!R6hwP4zI$Ii#99S#}2f@K`Bu@Jg
z8gjJtU5Vc=2v6F7AuP8461un)|6S?$Zu_scZ?E-Qs6ie2VV$>nuebg^JP&_@zZ45_
z*#%icv5HUYX{D}YGm7W<wiaeP7Z2gI3;4JeX79vv_mbWh_P5^$S)l`1`NRBoc=4Ei
zZoYnQzJ6}Ler|qtS}{M3ktP)j)M7;~R&dY-IOqZ#bO8>!pmc7ruyh_=0CD_um3`tE
z%J?ZC8au7e<Jf6zu|SPi^3AooZH#fYRf9X&wi6hsl0psFT!3pX$Y=Q-$5?w??^Ddz
zFV5F5&c{6$;GGNd!;7a$s*-=qKF3-g=Um4-{tW9gt<SR0*>I6-UF`o$tc`;6&s$$+
zeR<-b3yjsGRBLJcwcPeN23u(z$6;O8<bWqG;M-ehToxr>%WID92Qn~DTTlOLIOGBx
zasdvxAdTC$q6u?JJW9Jp+BK4%OVV>m_c0P&MpA1@sYXgX`NdpPT1G;1vpv|2D3!yD
z<!Zd9#%pSLt{R@JhUco?$iZrAaIRXbsi~S;s;P~dny4vlO-XA?8Tn65X=+MRQ-ZnP
zv9TMy(<{@@b@a1JAN%F3B4-skxQ-6?(ZO!HtkA!HIem&gRpqcEhfm63g${MoohrRq
zOK&Q2`V<|h%4J0^D{@((2UR*yr2|zuP&IyDM+d58-zVo4vX5=KpNy+yStZ9R8OFBV
zPlmC5_mf>8x%H7*A9;0?Rc!P9WK|`nDj8LkszNT&4)l{tH@S3^Nwf+5<WTj-hBxtZ
zY^6lo01rNYNVi&8t`?T7fn|XQo^Pa^Z=~BD(+T_|-R_!BP%F#Bucf0uccJt%Jh9J8
z54F(c?t)GddwfC|ES7t0VnS9{D?GM*Dcx#pc{bI0I=l|t2~mT~`Bb{q;PTW8XIby5
zHSSH``;+|v#qY8M9e;>@4)gm6wyWFk9#{=)pcmGH>t;&JFVoF0)6Fl_%`elPy?{fM
zie;rOd2`<Y%Fa*IU3x1he`z})J${;QewuE6n(oqZ@Ci5(&ZTqb!3FRY=eZhgw7up$
z1J>*Pex3(6sO7v^Mxx7d-ih2ba$aJRT~4CQ^8IZ)z;8O7A7y<Ee9ZO}Y(ELk@%wXd
zKE#%Ih5f!_`&Do?Tm#p_^>71x9li<QhVQ_4;d}4{xZ62?1^2={xF2vg{-SRFqHg}8
zZvLWf{-W-jJZaA|+Ov%IETcWkQ){kU#}>V=SYB=n6Ut+tiEhjc)3u4+w1eH*=OLS3
zry2d>DUs6g@npB3m0qI9Sy}Xx{Cbk^C*^)pT}P_xvIDi|!}MPzBdl|c1I~jB;46M#
z4eO0!awxMUjn<p%nYN+N(LV0w_u<wbvyL_{+P91Re+hgZqW$_xF{o5^rK&4cU8(w$
ztzw(Xjm4mn)V=ZJP58-B>#rCKji>t+`rby@+mZ!%%C=|)o}t%^rJsc*IM7mYr=vA^
zP7U<96VYe?bz0USeG8$D&bKLbW!OSghb_da%pCzWP*DRFdOd#FQdH@58=Y>W(`|IR
zjZU}G={7puriLnXw~g+$(cQL}S(MnTROn)x8mrL5HnmpC%ih`8XpI-s#kL{qV%uJ}
z?eF*D)*pl8Y&*g4li&>Li|l_1d>$?@R?$Hg#`dqkRra|Wu7PXedbk0;4&Q`t!*}4j
z@ICkeEOU(&@Ejzo<UBR!tvheO^*ZZ8@1x{hr(bQPQt>XN-T1L)so{6=Sw1QKl=MRD
zXOjPNRe09#CC00LMjion(x<-z4%E*d#z$F#bBpKb)N^#|IXcy)mZI-6`YpTY)GD>p
zMW=ey%yV>Vm70ln$-3y%D*CjFKK0P29{SWnpH|VQRryue^)macfahS1W7pa~SgfK`
ztIA`F)k@Gst9FyqSt<7`<-SYqSIYegEu%~ByHf6XUzK2u62!i4r4p=Ef|&D_a=uc|
zSIX%~E?3HB%w6=RcD*cjU2@kYcWdNmr5tt1QI{Nb$<Z43MKEo3IiN1r$Vt4K`{USh
z3FC9`)z#Lx+8XsVpq{)JMH}M#QAe@Otx-1v>SjRM2b6t4*#}%{jj|57*MFdX{2(|O
zKB864vF?T*z2<7ad!^Sx4eHPj>-@Lg8cV>|YS>y0TdQRmG_V#t2YS{ThE~JOYM5C~
zk6J77uV7j=Osj@z)iA9Z235nDY8X>Z?^(x|YS>Z@E2?2dHN9s&KNHT9J{zutFZnHx
zSWHbXS;tyxddGU%^~*Ul$j=+_*O9w2gBZ&o#xf}9>*X-snHiMB$Vdk9!&kdQGl-=O
zVkU!_$skrTh?NXtC4;!z=sPrn7|I}qGKirJVkm<c${>a^h@lL64ys2VyABH;gg?-c
zoiU7A5bw5L0d<J~A7!NWQt#Z*^A`0m;+2aYxe*WCh}X?C3z_E>ve)vwxi_BOrbjl)
zGfH1mYG$8b?sa>$XCMAikK3r{7>vm3d3+{e6NsL*9j&8xEqd0X7j49YHsU=SdX}JW
z6t*V+vj6{<=j^rb?{D;~4c*_bd%I=Xh<YsWPpa`gKBYcBr9MxcwT2H^N3Z@N)*F2(
zec=Yb?}X?}dC>YH=qYZ|{%<!n?&E9fV+U>@^12)MP9taczOxzpBwJYT2K#{X^FQ@v
zAGFVh;85w4`AR+sr@*Oj8vH%J6}_vcTk53-(8HG0bV;vR8Vk+tzmJ0!Xod0cYM%TN
zzsu_#^G0|xyv4p-!?xg_KOa~hA6OqBSRWr)UrAZ`!20;W`uM>5_`v%3!1_v~z4k*s
zm_Cx{mDd+VkNkF|>3lR`F%9S&_QUjz^24+mpSK#Hw|W94YDeF&FQ$(ltuK$hm=kS3
z8BX>4bQto)_t6%fc>izo$@H<Ow|nxW?x~Y{ejR)bZiH{Zx8UF4-{B_sKKu}V?3_0P
zzgB)L+y*~|pTQmQ+MfG9e!D(?yS`!1ecxz54qJXZ_7SZ?WZ3Iy-ypm|Ln71GCRl|y
z?x?d0^~4(M*7l3cE$rvbfi2!0*y8y}K0i1Fu7w-mPIwR=f*wq$&l?Qa>2U}A9xR>@
zMY_tgY_q73urvMK&3cwzm;WnsKJS%n$qt3X^|;O6sX7i?pcTf$TVQM07Pf~SVP}{L
zyMXhRc86K82fQ2J%cnL5?4R2=e>)ruN5V&eFEKwI&Vwt8=kqUHUlpe1KeoOZZh>3j
zHux$04DNtOVLm(oPeI+W>x$>q)HF}!40%oJZ2tP>G3n78#Gb6rJummB+5VS!PuTYn
zk4g0QzuaRo)cd^DV?sXq(3g5m>Zu1Bqfc$t^DO2$S*&MS%=54~I|WXK)9C3w@IIJr
zpC(eeM}PEdJ?3vo<scIIj*)Ub`;b2A@Zy8%T!YRPd#OR^8g#Bf=Nfdb*b@yp*PwF^
zdg;|IdX?MQ_+dLA#%4Dbzp-_lt?O)E$NI0!?(x*zulQ=`6pv){ig{kzccZh-VZ}0b
zXJI<eOZtn@Y>)UH(?sX0J6E4`)tsyDT)!GV*Dsyxj?mx?1Ge@#Uw`IV3|m(_<BfjZ
zqX+UNmMyE&7M^0ciTllS?XiE4%}Y6~rK>zLT&}vj)MH+h!#%g?eU9Z$HuS!i*NA`H
z_@*cDO;3ntq3uH@+IW^&2hXtbM-@Mm>uc>Z$vy*0-9KD|u_W(O>Lv1isJy?&TSaFZ
zKO9c;j`GxVlVewT8sTyGaJwAeIw}{va@s4Wt!zIpgMR36`MtRKF7NALnCF?x2ORrM
zakJiKel}a{yt#Ndd2!o3G1U?d#Q={r?zp*l+*y0%sw!7iXN~s>j*{=_@r_ScO|<XI
z_%xM$@38N)_I=jA&)WCd=o@zR_h=tjm=XJ0&&RZr6kl}Wee1}{Gd?u1*XZb(;x<o9
zZxX6J20g`3!Wx?UM<dA>_}6kH{%L$DTNg{SZCRBa{oVy;$=#mnXm)XLcCeBEVRAGh
zyrFn7;DKsrS-6qZf3CE5@bt~|Z+r1*8mGDAqgBjz{qOQAeAt;T;6Ix0Y)knS)){}D
zZTvM~{T(QOSCP_EWgAqss8NrQOh3tVkjz8g^vZr}U;WzGfHU@MTLaowk0Td(7wl|#
zILZj*MlENKJ?GJ*%rROVsVoaW)tY~1Th!ub{9dVKhr!MEpPTj?s<qYX<u1pqcCGp_
z`&~2a@$!Cb`>&Cg$S|Uu<DD3H0NmGMt&2z1U%zL24=sKnFOP&%H{2D@FSd651H$FS
zzlJM|@2RKT9Ql|h2rde9i<8}pz0w&@RA>M09_%UP_Mf!vEWY}W$>)zqt1VQFPpa+=
z_7tBbu}kFcXQXyv__Op2#d#!mq1;~V>fey#B_wz$34VhFFH}=MC&io8{lBRDZ>js!
z)P03CPgSbx)ZkA@^#W3DQ<K*wzfNr9H{(FJ6nB%y-Q;mMUAx;op*iFdt-)GPRrK)3
zPE+gCl<8?@s=GtEc3A$))BWVf=!AZhE^ML<J@WlO^7B9PvPfPQ%S*ewRI~lHtOHVi
zwK!e>rR||dt;c#DOJ)x`$FH5^N%~ZEj%9Rc0Uhck%bVnXfidf$#p!DQs&MKH^TPQX
zE({lMn4|W$Q~UeN>2Y#;joNPub2oIW{Vl@-8&;|Pe+rLmh);<e6&~C0LYTkdS+#$#
z+Ha8ad)592LeGW`YJZX(d{XU?SNoIH{us4CUhPkm$34{kt!jU=+TTO%kC)R^)cyyQ
zxJ7Q?lkK^oUy1L_W^bse{kN(8W7U4M+Ha8ios~ZNH;yXqm(zB+y2I7~#})5(g`c^?
zLRWayS))8--E}$36VCF4qaSy4jm)~qtU_i(wxmhzPsSuBtFbOet&)!}wf3A^TdCH%
z!ka@A`x0$UOY!UUH0Nv@eQ5C;?R#~!JK<D1d%ovsE~bN*%iER3ee(BI_@)1c?lnDZ
z=0+>|_t5FZYPFkA-y{D$^x*MiiyrgL!hCJ|Q)KVyGWzvj^4cM<kIU=h^y_iDH9)s&
zp)}^p>{@6(a+7V1{WcGwxS{xB@nq3n^cD|#GWLJ*Da1qi$3BJk{ttcF)=&%<JlA3n
z{i^uB^po2AM6Gxey7V_cS^<wFh;};q!y^5S58n58f7qo_pL9(zmFQFY@OTV=if<LG
z$>n7qEjL8?Y&!Cn@>WLDe`W1$+#5e5xusJ>pNUcvV@`ZxJdjZzn)840DOi(K!WT;=
z_dPUr_*4Ag#ngQ-rp}?sFMf)78`c){iw_r{E+!UF7Z<$v$EzlabI6>uUPWSUwvwx!
z*k{9>f{)Fw-A7JS{C9Cp@f|U1zf)YLHYV6UfkmHCe6P5xcu3m_;*G_aS8s_&6w`_c
zMZNfWO8=r*$gT!F?j_ePqAz09hXwQTeA$biLjM-!JuGvPErveB@*VjZiYsDL-};hI
z%0FGgL*geLU93sxiZYzY#twgC&PG03#V?C_#c$wYdN7ft*o4eCDW274SB~uEtUIt1
zp?IP&RvXsB_&Z)NVwAoW{COLXdu57M{;MCo#cO;<^z_wsA?I`~f78o8ar;Ya{$)G7
z=FeB2Z{zN-qE#FJ4Eoi7@PqOF)lbnsblz8<J=u|{r^z0?$~j)z=93PMx=d^j@u^1N
zqqe>zsYmlEL==7HCtmMWuKCIxU$G^Y<dvm)#cnU#P`ta?zIb2pc6cj|8sqOV`us7)
z{>5jCFBI1~XIs&tWuG4p+;F_#3$V1H2YktAgEoov2An#5=uv7vNvmI!;7|`x{HVCL
zxR)KiR|}8#EQUVAYj^2`UWSF<aC-cs_|owI!>iY>p^Y|h^ijomqkp|L?J3pa&yWop
z`Q^%kSl+pMVtq086=S}Px0G102}Vk9^7L<6?1Y*A+0DJ%O;S9E>AV{I8XxRu*<3t?
zgFRD!sO62ka7Q}kBO)QZIegLbR&zja4_ouZ-DT$Y9Lo;oeLf%xLwwu&PG);95|v}I
zWv2O_OT=X8wCrZi=kGjKz1*@pezp?d?zYS_>vOed%RNskFMqJ?ndW`IJI?wH?=|mJ
zgi~`r$A*2(|C|!uXZGi|Vc%?rY=^L4wo|rK*xxMBeZmLL1l>0rU^eLK;X^UPKsYSU
z_Y6mPkA5W_m6>-EKH|;y)54|Rb-zQn(!9*w!#BJ+exLAtb1~l^eq=u8zTwB_WPTw0
zhk2R%i*Eg)(ucx-mJTW%6mBs`^WgAbr9(@HdJq2LrNhHd%-1|J+-A<^N#S<yi~nSp
zW3J{Y;a>AKPYZL+**rJQGjH>}aG$xG7lixG-@Gt9U=HWS;X(5_FAWcw%XwL7H=py0
z@US_ZSB6K->-<u9)ZEVN!((Q3t`7@K&zn*B8}Cma8$3~!w}u|`H`{`_W%(vyO`OLW
zdc8mW4WZBb(zgnK@V4~r!=Jq+eU~hY??lg<%-GyBYc^~1J=r)jH{X|e(kee7o8T?z
z2W3;t+dMd%8s~0i)6CvHIomA0={$Rj`I={DTj%C$X4{#uc|o>=S(}$-JH~gJXS<rO
z`HSow-aP)x?BnKHKAaurz2Z-1XPQ;HAp4Y=m5Z`Zn_bzJea73vtJ&wwt?bFpGrw|8
zc7B{=nO)%R;lIx=^xp74W|zh{hi9Mn=I{;K<>p(KvMbEFEN5Tv-teaEN~84yk_N{Z
zOA~1Gn=B>T_-5L?m8C2q$Xm4jw^|xgRFE+=b9;V(9V}yM=8n8LF-Ay?1obw1&a{l9
zlRRd0@*Vcv-O@@Y-|0%TENyi1U9Pr=Wug|ck9P7t%OqaF_v2czwM<T}WlD-3GR1u9
z54%%zuw_zeInz?hnXcu0#4NF+Ez`B3W5hIxt!R=~bgTCE6HCdA>f7Y%c1tO>tLdp-
zO-b!)QfgP5r*<_awW}Bx<XL4|V%Z|Kt}&@~jY+L*^VGUFPpxaq)VelHt!q+hU9Z==
z{=`r6XUnA2#$KP=*y~dpD`{h!hN+^9Og6TgqP<Pm-nO>qHrX~|hDajYhAmUu8=KnR
z*wpqWr?$7HI3NG4(VngaW~l{csRcHq7T99mbstIAvKrr0JsSv(qFDSPj1j@&1*519
zr7SdwUBOC;UoqCa+Gak`O~tMlA0}(JlgzN)RO_7@BUOayVpVJzO5#<#-kxu8XSXD7
z#T%vH<PL91{E9bAZ&jij;#j=JdEQ!L^~AH-T6&w(HqzVjqi$-3_IA?S^QUfVuJ#V0
zfnC@sG@7%$v+H^>g7i!t*2(5?zg>D4p4Q3caqlX<8;|Q`aVg#*y*q0%nKjufj1h}s
zZ@JxvWf_w!%a~+Y#w5!!CRvs-$+9#h%QChUElYDLT9)QyS(=k&X=YhI;tWTZj&`<V
zO2<flwDeKwkCi?qEoO!Eai!zr`S{ZDYUUHAPe`9oIzjrx(uvY1u}xExZJL&B)3jup
zrX}0dl5A5;vP~_?HZ>*N)Rb&fQ?gA>$u>15+tie7(|ESYGZo@lTty03oB2FJT#J7V
z6UDZ;CcI93i?2#wTe?>Iy3%#h*Ry4>W6O*W#f_+|E3qTw-%KSrT+hZ$5JBR3|Nf!$
zhmeaT@kjgosq`nuiYQ^v7fLULu`#Yh7$dSo2o0i3WbQRk6rN`v&ua)a;BI+Cjsu7|
z;c1IxF{dPpIW<|#>B(YFWicm*Mo}lGgc&jJg#9<mHw#TM`a~Ej{)Bi#Vo+=mO5#v#
z8S?z~`RncZ1{St4Mx?O+R_ts8JNs67*gD@jltri5MozZPx0Q$O^6kv}-kuen%nI)q
zrkX#$Q<x-X#m;8`zRg{i>0(#R44a8x@pk*{lJ63>WT|J_{w_1e$47hZo4xkESH73B
z?Cm+(>E_yhz}5H5_cMche@`Kl#IyLIYaNguAU~|R9J1!ld3b)fdpJkrM>y)3+`Cr9
zwfJb9gKif31o177wf*Dy$DQrC{5W|&K0jW5K9PUImJ{+5ocYB3L}xz9a}A~Z<osmm
zQ}R=s|J3|c=RZ9^-S-*!8IC<OKhv@2<mbr4x%s)utGDodVSb@fU*w61Ekwk)*cC6y
zFOj~~J)-HNV|-rvGSBZ$*Q0#VdA^i?$$75!ghWY<jDK~-Ydk4Y5-a1Y(${)oq9kU<
zb<)@8*Gqpb|C;m-o}eg+p>d=1*F8y55=-M7(%<w%MM+GJZ%KdKlNBYgHU3TdJD#v8
ziLvqT(%<!@MM<m;V;=D~z9;?t{QJ^B@Z?2F?2R8v|0w^FQvcZfkjdh3{D<_-?u$$o
zkK;e3Z*hNQvbY@oC4H;=B$LJG_=)sw?w3p!r{i|%pSo`{S-g(_mj0RhCzHkP___2Q
z?xRc=zvCC`TtDjj?)+|bcu#(h+WS@hE9p7;9O--Wd!^^*bEW6y^Q7;~?~}eizhC-+
z`~m3)^9Q9L${&($&)cOR&L5W6EBn?f({R1A?`8QiI<P!nuI5*G8^HvTK2}OU=dA=2
zMEvNI)@N%A`fRz<XVdMqxu<Ew{^%p4fqX!VSf8(_w}YNOX%hqF_qOZHY385vKZnh|
zIpHt%(W8g4u}2SMVvp`ykFHlO=?fx1&GdRrFS69;IL1sp{S^IgoBlHP_fz!0Z?t`5
zuOCvc-=xpq+V*WMO{v!psn_33pTD#1v8QiJJ$=AI-!8q2C5R8Ut3EjP{bN(#-<<mX
zajEZbNqzs+)c3chzJD4%y0@bu1IQBt2>Snh<$bm#xDWUN>HWfoqz@EDtReA$#>4{}
z+#x)~zmZ1=am5bPXCH0};)@-joRL|#xo2>cEs-V6NGzc(v4jcYj$LB=rIse~rJ}#;
ztCl8r9ItiG>%<!i;zoVVmK!W(QORz!<?EL5B23*Xy^&iq4Red1idGfetGv_xzqEwJ
zHrmn~Ttea;4dR<UVEcpaWS05I+od12jQ3WT4(TT?W5sy-wd+1*nTYc*u-)^<wlCtf
z42h#mO>cV%c*?W(iA-g3iewhVGFysE{mwgILgFY5yqwXm6~_THya9$kA@q6=OoMx<
zeRz`RU8L7pLgF!HZ--fL%b;abvDKcJ7Ujvmk=ZmPW)r+O<}cDBMcH0h%D7IzV|=iU
zQl=Zp1gQy4SwltxhuKeaW;7?h+9cZ}6KYIMXk21KZQ`v>wS8JP%|6q!>C&5Jn>q9A
zve!w^$Y$8SdA7Oq7Vhzu#bevimN-Tko9&#vO?qZF)78aZlioGk)t<Y#3tSe3?H%^n
zJ$tY1du4msXYY*GC3aO7iS3`H<M^gQG&WinBeFSae@`$35!nuOU+|#pVCh4$L!9$a
zcah7YvwgxAQP^;}ld_Yfy(tGXi!5!5H|Cr+%+;o3XJnu9ZyYmC5toezN(?d<0ed5(
zQM|1QZ~KESk+C%;#@3t|TdR(Ete(3WS1XG$rVbNhYe<Z(QH-$}-oOxfTiYn!mXG3X
z`6%9&C*IbScw0H~wx-0}%89o%CEiv}ysatmwsPWap|qp>;pN2MLSk>_#NI+;Z{@_^
zLSk>_#NI+;Z{@_^LSk=a(Z$}0gU)jQyj*&hIAcwsjO`)4XK7FAce|fnF1<(0u_h76
z-YdOV=>R2-W5mr$2jXfWakYlT)k5NG4T-CT#MK%SS8GaKtub-6ro`166IW|WT&=Nm
za_KbZIlXi`&U8lU4D9F3(wWkqDt$`&)1^;Kf2Q;q>9a~_Nq@HVS?RM&XG@<`I!8K=
zJI9Jo_BrQ?qtCJ8l<|Tjo;Oy!GG5EX_L{{lyNF!kc(hskvP-1nsI*xOv(HP%v1zk7
zW|vFH5o)t|W?ztw<J4wx%{<kZ7-5U}W?y#B$O~H&FKkP^ur=|*X^9t3NW5@b;)N3u
zFPxTm;e;3m&9OI@Zd9vZFZD@}Fh%V>am1#?5nE%VF<VBMqV}FR;xrtw5S=*k!X~`1
zBpn%HYhr{`6C(_X5w?m$HU<-F%C+~z4jaTIYnC3DkHfTDa{i*k7aPSW8!sKl*)dkx
z1nG$)V~<Y^vQgZ!Nz$9*jv;Z!6uC?~a>vOpa>qB@5}9ICj9?}mnPO97ienQ~oSK+o
zo|s};Tr*>j#1|VAUu;Nxv7Go~TjGl|5??GQzStn{*{=HL-EtmlvCrP=*vKH;5`%0J
z2W=1ABadtm5AEI3kxjOUi^jqvPT86`Wm}Aq=52iM&-b-`c0OA=vdoZJX2U3!nJ1Rn
zBzoG1{To?kS^Ts^TvrS=TO#8eml$W8Xlh6L_o)0R<rP)UzmbDBB@S9n9JDoY(6;>J
z`N#bmIq1|pa?lxxgN9KYG|xA3&^-Sn4jK{%E$64@T1sM~<-|m%=8=ic$Ul{T#`d%F
zv*hiw`Ddli&d-*P47Dkb47E|bw$DkQ=c$)+etv$wbmXj!x%h4NkDPUK;;e0nvrbN&
zwJmYh$%(VJiR^Ycc6dd81y=oq{0ok{GQZMQBA1<-xa<rO-`o!q_3bNRqR4MoVZ$5Q
zZ9a<K=A+ncK8oGuqu6aeirwa;*lj+F-R7g%Z9a<K=A+ncK8oGuiQR_8Zp(??hQw~m
ziQR_8Zp(??hQw~miQR_8Zp(??hQw~miQR_8Zp(??hQw~m*zH|vCi2>*#A_Q9uWd@a
zwlVSAro?L-6R&MbytXm%+NQ*78xyZ>O1!o)@!F=uYa7M1d&D^(^&C=JY`e##=X)Nh
zEXLjA(of`1NO$BN(vbl-ig|~zh<o>x?U4;Pi+{IJD~_DFSsc8lrJu>M7xC~sr!FQQ
zZ@0L3zma}6e^z=)zC`-BxjQ!E<aJ6f&G}%(%ln;lWYw*SRktNp-I`c+TVmC%iB-3W
zrKdj?ORt-rL~b3#)LShb8TMGQ^?GfIJbP;5*)zo1tI@G~UZ-RIdB60!e4TXU-y!ku
zhQz<8CjLDme?B^Vks1sqac)H|i?^GYcMyrMLAueC;uA&W8xtlaF5W6KAJ#1@-*|jm
z=MK$y^=Du4PS3{lZ;7ETV^)pF3H}n^a@s$id|XI@Zo)1xvQ3zE)>%8hExgzFOwY<O
z(!=M>qJehyn8o-G(fHkvzGF1t38fE}PALCN`QOTqmOE1(c!P`*7KV!GuHO)a_1=+4
zsws-<f4pW?*WbM?uIr5{uIuPyZhKiA*jGJ5q|0w+%VLC1@i~VhbpEfSbEdeS|Ldbx
zi|To&xSlbxXN>I`qkG;Xx@U~<86$kg7@sl9=Y8UQ-Y?Q;jP)6#eLf`G=fmQCJ|g00
zjQJU(e#W?;Ly<o_#QuCz^v@XoGe!W7F+gJ!&_&{aJ}naHGh%_pXrM73Xp9INV}i!0
zpfN6Jj0_rMgU0BfF+S*W5kg~((3Pd<EL|y5Xp9wF5iK;v3yl#&hhm1tsG%`#=-SdZ
z$bACt|2lGilhIYPG1Y8d-2IGrwiQA7GGnbPEbmSul=md>;d`?RpWWX0-X7r!>}&t<
zb-HqF_#rm+nQ$lO^Ev+V3;39x(7slAo8*w5HH8eL8PcMkWWODyQ*%S---rtQs@m|6
z91}I@|Lf2HQ~ha8niI$4$MC90o!KSn%&tjWc1zl_d(xH*lD1r(wB=h#TW(F-V!k77
zc_3-aZ-?y>ZK0P@TUe;<I(oXlR7N|aJxp5UYR#`^i|iYZjXFKDZ)V(honIN>!02t;
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 03/15] 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 04/15] 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 05/15] 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 06/15] 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 07/15] 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),

From 89af6c17eb52c9061d77366383eabeadf40c9adb Mon Sep 17 00:00:00 2001
From: e-filchenko-bosh <FVI2FE@bosch.com>
Date: Thu, 10 Sep 2026 14:57:43 +0300
Subject: [PATCH 08/15] Enhance graphical view with accessible controls and
 status indicators

---
 src/graphicalViewPanel.ts                     |  22 ++-
 src/test/graphicalViewPanel.test.ts           |  37 ++++
 .../graphicalViewWebviewController.test.ts    |  60 +++++++
 src/webview/webview.css                       | 163 +++++++++++++++++-
 src/webview/webview.js                        |  27 ++-
 5 files changed, 289 insertions(+), 20 deletions(-)

diff --git a/src/graphicalViewPanel.ts b/src/graphicalViewPanel.ts
index 9af26c5..cf283e6 100644
--- a/src/graphicalViewPanel.ts
+++ b/src/graphicalViewPanel.ts
@@ -147,13 +147,21 @@ export function createGraphicalViewShell(
 </head>
 <body>
     <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 id="toolbar-controls">
+            <button id="refresh" class="primary-action" type="button" aria-label="Refresh graphical view" title="Refresh">Refresh</button>
+            <span class="toolbar-separator" aria-hidden="true"></span>
+            <div id="zoom-controls" role="group" aria-label="Zoom controls">
+                <button id="zoom-out" class="toolbar-action icon-action" type="button" aria-label="Zoom out" title="Zoom out">−</button>
+                <output id="zoom-value" aria-live="polite">100%</output>
+                <button id="zoom-in" class="toolbar-action icon-action" type="button" aria-label="Zoom in" title="Zoom in">+</button>
+                <button id="zoom-reset" class="toolbar-action" type="button" aria-label="Reset zoom to 100 percent" title="Reset zoom">Reset</button>
+                <button id="zoom-fit" class="toolbar-action" type="button" aria-label="Fit diagram to view" title="Fit to view">Fit</button>
+            </div>
+        </div>
+        <p id="status" role="status" aria-live="polite" aria-atomic="true" data-kind="loading" title="Preparing graphical view...">
+            <span id="status-indicator" aria-hidden="true"></span>
+            <span id="status-text">Preparing graphical view...</span>
+        </p>
     </div>
     <main id="viewport" tabindex="0" aria-label="Scrollable graphical view">
         <div id="diagram" aria-live="off"></div>
diff --git a/src/test/graphicalViewPanel.test.ts b/src/test/graphicalViewPanel.test.ts
index 460198e..572039d 100644
--- a/src/test/graphicalViewPanel.test.ts
+++ b/src/test/graphicalViewPanel.test.ts
@@ -71,6 +71,43 @@ suite('GraphicalView secure panel contract', () => {
         assert.ok(first.includes('/out/webview/webview.css'));
     });
 
+    test('creates accessible compact controls and a live status presentation', () => {
+        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 shell = createGraphicalViewShell(webview, extensionUri);
+
+        assert.match(shell, /id="zoom-reset"[^>]*aria-label="Reset zoom to 100 percent"[^>]*>Reset<\/button>/);
+        assert.match(shell, /id="zoom-controls" role="group" aria-label="Zoom controls"/);
+        assert.match(shell, /id="status" role="status" aria-live="polite" aria-atomic="true" data-kind="loading"/);
+        assert.match(shell, /id="status-indicator" aria-hidden="true"/);
+        assert.match(shell, /id="status-text">Preparing graphical view\.\.\.<\/span>/);
+    });
+
+    test('styles all status kinds with theme-aware responsive layout and a loading indicator', () => {
+        const stylesheet = readFileSync(join(__dirname, '..', '..', 'src', 'webview', 'webview.css'), 'utf8');
+
+        for (const kind of ['ready', 'loading', 'stale', 'unsupported', 'disconnected']) {
+            assert.ok(stylesheet.includes(`#status[data-kind="${kind}"]`));
+        }
+        for (const themeVariable of [
+            '--vscode-testing-iconPassed',
+            '--vscode-progressBar-background',
+            '--vscode-notificationsWarningIcon-foreground',
+            '--vscode-notificationsErrorIcon-foreground',
+            '--vscode-panel-border',
+            '--vscode-foreground',
+        ]) {
+            assert.ok(stylesheet.includes(themeVariable));
+        }
+        assert.match(stylesheet, /#toolbar\s*{[^}]*flex-wrap: wrap;/s);
+        assert.match(stylesheet, /#status\[data-kind="loading"\] #status-indicator\s*{[^}]*animation: status-spin/s);
+        assert.match(stylesheet, /#status\[data-kind="stale"\],[\s\S]*flex: 1 0 100%;/);
+        assert.match(stylesheet, /@media \(max-width: 520px\)/);
+    });
+
     test('accepts only exact production webview messages', () => {
         assert.deepEqual(parseGraphicalViewPanelMessage({type: 'ready'}), {type: 'ready'});
         assert.deepEqual(parseGraphicalViewPanelMessage({type: 'refresh'}), {type: 'refresh'});
diff --git a/src/test/graphicalViewWebviewController.test.ts b/src/test/graphicalViewWebviewController.test.ts
index 1042d93..5011141 100644
--- a/src/test/graphicalViewWebviewController.test.ts
+++ b/src/test/graphicalViewWebviewController.test.ts
@@ -28,6 +28,7 @@ suite('Graphical View webview controller', () => {
             ['#diagram', diagram],
             ['#viewport', viewport],
             ['#status', new FakeElement()],
+            ['#status-text', new FakeElement()],
             ['#zoom-value', new FakeElement()],
             ['#refresh', new FakeElement()],
             ['#zoom-in', new FakeElement()],
@@ -90,6 +91,65 @@ suite('Graphical View webview controller', () => {
         assert.equal(prevented, 2);
         assert.deepEqual(JSON.parse(JSON.stringify(state.value)), {schemaVersion: 1, zoom: 1, scrollLeft: 0, scrollTop: 0});
     });
+
+    test('applies only allow-listed status kinds and preserves complete status text safely', () => {
+        const source = readFileSync(join(__dirname, '..', '..', 'src', 'webview', 'webview.js'), 'utf8');
+        const status = new FakeElement();
+        const statusText = new FakeElement();
+        const elements = new Map<string, FakeElement>([
+            ['#diagram', new FakeElement()],
+            ['#viewport', new FakeElement()],
+            ['#status', status],
+            ['#status-text', statusText],
+            ['#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();
+        runInNewContext(source, {
+            acquireVsCodeApi: () => ({
+                getState: () => undefined,
+                setState: () => undefined,
+                postMessage: () => undefined,
+            }),
+            document: {querySelector: (selector: string) => elements.get(selector)},
+            window,
+            Element: FakeElement,
+            SanitizerContract: {MARKER_PATTERN: /^$/, sanitizeSvg: () => undefined},
+            requestAnimationFrame: () => undefined,
+            setTimeout: () => 0,
+            Number,
+            Object,
+            Math,
+            Error,
+        });
+
+        for (const kind of ['loading', 'ready', 'stale', 'unsupported', 'disconnected']) {
+            const message = `${kind} <b>complete text</b>`;
+            window.fire('message', {data: {type: 'status', status: {kind, message}}});
+            assert.equal(status.attributes.get('data-kind'), kind);
+            assert.equal(status.attributes.get('title'), message);
+            assert.equal(statusText.textContent, message);
+            assert.equal(status.textContent, '');
+        }
+
+        const acceptedKind = status.attributes.get('data-kind');
+        const acceptedText = statusText.textContent;
+        for (const malformed of [
+            {type: 'status', status: {kind: 'unknown', message: 'Unknown'}},
+            {type: 'status', status: {kind: 'ready', message: 42}},
+            {type: 'status', status: null},
+            {type: 'status', status: ['ready']},
+            {type: 'status', status: {kind: 'ready', message: 'Injected'}, extra: true},
+        ]) {
+            window.fire('message', {data: malformed});
+            assert.equal(status.attributes.get('data-kind'), acceptedKind);
+            assert.equal(statusText.textContent, acceptedText);
+        }
+    });
 });
 
 class FakeElement {
diff --git a/src/webview/webview.css b/src/webview/webview.css
index 92d72c8..5feda8f 100644
--- a/src/webview/webview.css
+++ b/src/webview/webview.css
@@ -38,25 +38,73 @@ body {
 #toolbar {
     display: flex;
     flex: 0 0 auto;
+    flex-wrap: wrap;
     align-items: center;
-    gap: 0.35rem;
-    padding: 0.45rem;
+    gap: 0.35rem 0.75rem;
+    box-sizing: border-box;
+    padding: 0.35rem 0.5rem;
     border-bottom: 1px solid var(--vscode-panel-border);
 }
 
+#toolbar-controls,
+#zoom-controls {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
+    min-width: 0;
+}
+
+#toolbar-controls {
+    flex: 0 1 auto;
+    gap: 0.4rem;
+}
+
+#zoom-controls {
+    gap: 0.15rem;
+}
+
 #toolbar button {
-    min-width: 2rem;
-    min-height: 1.75rem;
+    min-height: 1.65rem;
+    padding: 0 0.55rem;
+    font: inherit;
+    cursor: pointer;
+    border-radius: 2px;
+}
+
+#toolbar .primary-action {
     color: var(--vscode-button-foreground);
     background: var(--vscode-button-background);
     border: 1px solid transparent;
-    border-radius: 2px;
 }
 
-#toolbar button:hover {
+#toolbar .primary-action:hover {
     background: var(--vscode-button-hoverBackground);
 }
 
+#toolbar .toolbar-action {
+    color: var(--vscode-foreground);
+    background: transparent;
+    border: 1px solid transparent;
+}
+
+#toolbar .toolbar-action:hover {
+    background: var(--vscode-toolbar-hoverBackground, var(--vscode-list-hoverBackground));
+}
+
+#toolbar .icon-action {
+    width: 1.75rem;
+    min-width: 1.75rem;
+    padding: 0;
+    font-size: 1.1rem;
+}
+
+.toolbar-separator {
+    align-self: stretch;
+    width: 1px;
+    min-height: 1.25rem;
+    background: var(--vscode-panel-border);
+}
+
 #toolbar button:focus-visible,
 #viewport:focus-visible {
     outline: 1px solid var(--vscode-focusBorder);
@@ -64,18 +112,115 @@ body {
 }
 
 #status {
-    min-width: 12rem;
-    margin: 0 0 0 0.5rem;
+    display: flex;
+    align-items: center;
+    gap: 0.4rem;
+    min-width: 0;
+    max-width: 50%;
+    margin: 0 0 0 auto;
+    padding: 0.2rem 0;
+}
+
+#status-text {
     overflow: hidden;
     text-overflow: ellipsis;
     white-space: nowrap;
 }
 
+#status-indicator {
+    flex: 0 0 auto;
+    box-sizing: border-box;
+    width: 0.55rem;
+    height: 0.55rem;
+    border-radius: 50%;
+}
+
+#status[data-kind="ready"] #status-indicator {
+    background: var(--vscode-testing-iconPassed, var(--vscode-foreground));
+}
+
+#status[data-kind="loading"] #status-indicator {
+    width: 0.8rem;
+    height: 0.8rem;
+    border: 2px solid var(--vscode-panel-border);
+    border-top-color: var(--vscode-progressBar-background, var(--vscode-foreground));
+    animation: status-spin 0.8s linear infinite;
+}
+
+#status[data-kind="stale"],
+#status[data-kind="unsupported"],
+#status[data-kind="disconnected"] {
+    flex: 1 0 100%;
+    order: 2;
+    box-sizing: border-box;
+    width: 100%;
+    max-width: none;
+    margin: 0;
+    padding: 0.4rem 0.55rem;
+    border: 1px solid var(--vscode-panel-border);
+    border-left-width: 3px;
+}
+
+#status[data-kind="stale"] #status-indicator,
+#status[data-kind="unsupported"] #status-indicator,
+#status[data-kind="disconnected"] #status-indicator {
+    width: auto;
+    height: auto;
+    border-radius: 0;
+}
+
+#status[data-kind="stale"],
+#status[data-kind="unsupported"] {
+    border-left-color: var(--vscode-notificationsWarningIcon-foreground, var(--vscode-foreground));
+}
+
+#status[data-kind="stale"] #status-indicator::before,
+#status[data-kind="unsupported"] #status-indicator::before {
+    color: var(--vscode-notificationsWarningIcon-foreground, var(--vscode-foreground));
+    content: "⚠";
+}
+
+#status[data-kind="disconnected"] {
+    border-left-color: var(--vscode-notificationsErrorIcon-foreground, var(--vscode-foreground));
+}
+
+#status[data-kind="disconnected"] #status-indicator::before {
+    color: var(--vscode-notificationsErrorIcon-foreground, var(--vscode-foreground));
+    content: "×";
+    font-weight: 700;
+}
+
 #zoom-value {
-    min-width: 3.5rem;
+    min-width: 3rem;
     text-align: center;
 }
 
+@keyframes status-spin {
+    to {
+        transform: rotate(360deg);
+    }
+}
+
+@media (prefers-reduced-motion: reduce) {
+    #status[data-kind="loading"] #status-indicator {
+        animation: none;
+    }
+}
+
+@media (max-width: 520px) {
+    #toolbar-controls {
+        flex: 1 1 100%;
+        justify-content: space-between;
+    }
+
+    #status[data-kind="ready"],
+    #status[data-kind="loading"] {
+        flex: 1 1 100%;
+        max-width: none;
+        margin-left: 0;
+    }
+}
+
 #viewport {
     box-sizing: border-box;
     flex: 1 1 auto;
diff --git a/src/webview/webview.js b/src/webview/webview.js
index 8005907..073346b 100644
--- a/src/webview/webview.js
+++ b/src/webview/webview.js
@@ -21,7 +21,9 @@
     const viewport = document.querySelector('#viewport');
     const diagram = document.querySelector('#diagram');
     const status = document.querySelector('#status');
+    const statusText = document.querySelector('#status-text');
     const zoomValue = document.querySelector('#zoom-value');
+    const STATUS_KINDS = Object.freeze(['loading', 'ready', 'stale', 'unsupported', 'disconnected']);
     let currentVersion = null;
     let currentSvg = null;
     let baseWidth = 0;
@@ -60,6 +62,21 @@
         zoomValue.textContent = `${Math.round(state.zoom * 100)}%`;
     }
 
+    function updateStatus(candidate) {
+        if (
+            !candidate ||
+            typeof candidate !== 'object' ||
+            Array.isArray(candidate) ||
+            !STATUS_KINDS.includes(candidate.kind) ||
+            typeof candidate.message !== 'string'
+        ) {
+            return;
+        }
+        status.setAttribute('data-kind', candidate.kind);
+        status.setAttribute('title', candidate.message);
+        statusText.textContent = candidate.message;
+    }
+
     function captureViewport() {
         state = {...state, scrollLeft: Math.max(0, viewport.scrollLeft), scrollTop: Math.max(0, viewport.scrollTop)};
     }
@@ -167,7 +184,10 @@
             applyZoom();
             restoreViewport(currentVersion, true);
         } catch (error) {
-            status.textContent = 'The new diagram could not be displayed safely. The last valid diagram is retained.';
+            updateStatus({
+                kind: 'stale',
+                message: 'The new diagram could not be displayed safely. The last valid diagram is retained.',
+            });
             vscode.postMessage({type: 'renderError', version: message.version, reason: 'sanitizationFailed'});
         }
     }
@@ -222,10 +242,9 @@
             isExactMessage(message, ['status', 'type']) &&
             message.type === 'status' &&
             message.status &&
-            typeof message.status.message === 'string'
+            typeof message.status === 'object'
         ) {
-            status.textContent = message.status.message;
-            return;
+            updateStatus(message.status);
         }
     });
 

From f520453f95b1becb730a674a091ab47e5bb4b480 Mon Sep 17 00:00:00 2001
From: e-filchenko-bosh <FVI2FE@bosch.com>
Date: Wed, 16 Sep 2026 09:47:50 +0300
Subject: [PATCH 09/15] improve graphical view open tab management

---
 src/graphicalView.ts                          |  37 +++-
 ...raphicalViewEditorReuse.acceptance.test.ts | 175 ++++++++++++++++++
 src/test/graphicalViewNavigation.test.ts      | 155 ++++++++++++++++
 src/test/graphicalViewTestHarness.ts          |  28 ++-
 4 files changed, 390 insertions(+), 5 deletions(-)
 create mode 100644 src/test/graphicalViewEditorReuse.acceptance.test.ts

diff --git a/src/graphicalView.ts b/src/graphicalView.ts
index 753f8b1..4298819 100644
--- a/src/graphicalView.ts
+++ b/src/graphicalView.ts
@@ -33,10 +33,41 @@ export interface GraphicalViewDocument {
 
 export interface GraphicalViewWindow {
     readonly activeTextEditor: {readonly document: GraphicalViewDocument} | undefined;
+    readonly tabGroups: {
+        readonly all: readonly GraphicalViewTabGroup[];
+    };
     showWarningMessage(message: string): Thenable<unknown>;
     showTextDocument(uri: vscode.Uri, options?: vscode.TextDocumentShowOptions): Thenable<vscode.TextEditor>;
 }
 
+export interface GraphicalViewTabGroup {
+    readonly viewColumn: vscode.ViewColumn;
+    readonly tabs: readonly {
+        readonly input: unknown;
+        readonly isActive: boolean;
+    }[];
+}
+
+export function findReusableTextEditorViewColumn(
+    uri: vscode.Uri,
+    groups: readonly GraphicalViewTabGroup[],
+): vscode.ViewColumn | undefined {
+    const canonicalUri = uri.toString();
+    let firstMatchingColumn: vscode.ViewColumn | undefined;
+    for (const group of groups) {
+        for (const tab of group.tabs) {
+            if (!(tab.input instanceof vscode.TabInputText) || tab.input.uri.toString() !== canonicalUri) {
+                continue;
+            }
+            if (tab.isActive) {
+                return group.viewColumn;
+            }
+            firstMatchingColumn ??= group.viewColumn;
+        }
+    }
+    return firstMatchingColumn;
+}
+
 export interface GraphicalViewWorkspace {
     onDidSaveTextDocument(listener: (document: GraphicalViewDocument) => void): vscode.Disposable;
     onDidChangeDocumentAvailability(listener: (sourceUri: string, available: boolean) => void): vscode.Disposable;
@@ -401,7 +432,11 @@ export class GraphicalViewController implements vscode.Disposable {
             }
 
             try {
-                const editor = await this.window.showTextDocument(resolution.uri, {preview: false});
+                const viewColumn = findReusableTextEditorViewColumn(resolution.uri, this.window.tabGroups.all);
+                const options: vscode.TextDocumentShowOptions = viewColumn === undefined
+                    ? {preview: false}
+                    : {preview: false, viewColumn};
+                const editor = await this.window.showTextDocument(resolution.uri, options);
                 if (!this.isCurrentNavigationResult(state, accepted, target)) {
                     return;
                 }
diff --git a/src/test/graphicalViewEditorReuse.acceptance.test.ts b/src/test/graphicalViewEditorReuse.acceptance.test.ts
new file mode 100644
index 0000000..db2f1af
--- /dev/null
+++ b/src/test/graphicalViewEditorReuse.acceptance.test.ts
@@ -0,0 +1,175 @@
+/*
+ * 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 type {GraphicalViewRenderResult} from '../graphicalViewProtocol';
+import {createGraphicalViewHarnessWithWindow, FakeGraphicalViewClient, flushPromises} from './graphicalViewTestHarness';
+
+const OWNER = 'urn:samm:example.graphical:1.0.0#Aspect';
+const TARGET_ID = 'gv-header-aaaaaaaaaaaaaaaa';
+const createdUris: vscode.Uri[] = [];
+
+suite('Graphical View editor reuse acceptance', () => {
+    setup(async () => {
+        await vscode.commands.executeCommand('workbench.action.closeAllEditors');
+    });
+
+    teardown(async () => {
+        await vscode.commands.executeCommand('workbench.action.closeAllEditors');
+        for (const uri of createdUris.splice(0)) {
+            try {
+                await vscode.workspace.fs.delete(uri);
+            } catch (_error) {
+                // The test owns these unique temporary files; a missing file is already clean.
+            }
+        }
+    });
+
+    test('reuses the original visible source tab and does not create a second instance', async () => {
+        const source = await createTurtleFile('visible-source', 'line 0\nline 1 target\n');
+        const distracting = await createTurtleFile('visible-distracting', 'other\n');
+        await vscode.window.showTextDocument(source, {viewColumn: vscode.ViewColumn.One, preview: false});
+        const harness = await createAcceptedHarness(source);
+        await vscode.window.showTextDocument(distracting, {viewColumn: vscode.ViewColumn.Two, preview: false});
+
+        clickTarget(harness, source, 1, 7, 1, 13);
+        await waitForNavigation(source, new vscode.Selection(1, 7, 1, 13));
+
+        assert.equal(textTabs(source).length, 1);
+        assert.equal(activeTextTabGroup(source)?.viewColumn, vscode.ViewColumn.One);
+        assert.ok(vscode.window.activeTextEditor?.selection.isEqual(new vscode.Selection(1, 7, 1, 13)));
+        harness.controller.dispose();
+    });
+
+    test('finds and reuses a source tab hidden behind another tab in its group', async () => {
+        const source = await createTurtleFile('hidden-source', 'line 0\nline 1 target\n');
+        const cover = await createTurtleFile('hidden-cover', 'cover\n');
+        const distracting = await createTurtleFile('hidden-distracting', 'other\n');
+        await vscode.window.showTextDocument(source, {viewColumn: vscode.ViewColumn.One, preview: false});
+        const harness = await createAcceptedHarness(source);
+        await vscode.window.showTextDocument(cover, {viewColumn: vscode.ViewColumn.One, preview: false});
+        await vscode.window.showTextDocument(distracting, {viewColumn: vscode.ViewColumn.Two, preview: false});
+        assert.equal(textTabs(source)[0]?.isActive, false);
+
+        clickTarget(harness, source, 1, 7, 1, 13);
+        await waitForNavigation(source, new vscode.Selection(1, 7, 1, 13));
+
+        assert.equal(textTabs(source).length, 1);
+        assert.equal(activeTextTabGroup(source)?.viewColumn, vscode.ViewColumn.One);
+        assert.ok(vscode.window.activeTextEditor?.selection.isEqual(new vscode.Selection(1, 7, 1, 13)));
+        harness.controller.dispose();
+    });
+
+    test('opens an unopened target once through the existing fallback placement', async () => {
+        const source = await createTurtleFile('fallback-source', 'source\n');
+        const target = await createTurtleFile('fallback-target', 'line 0\nline 1 target\n');
+        const distracting = await createTurtleFile('fallback-distracting', 'other\n');
+        await vscode.window.showTextDocument(source, {viewColumn: vscode.ViewColumn.One, preview: false});
+        const harness = await createAcceptedHarness(source);
+        await vscode.window.showTextDocument(distracting, {viewColumn: vscode.ViewColumn.Two, preview: false});
+        assert.equal(textTabs(target).length, 0);
+
+        clickTarget(harness, target, 1, 7, 1, 13);
+        await waitForNavigation(target, new vscode.Selection(1, 7, 1, 13));
+
+        assert.equal(textTabs(target).length, 1);
+        assert.equal(activeTextTabGroup(target)?.viewColumn, vscode.ViewColumn.Two);
+        assert.ok(vscode.window.activeTextEditor?.selection.isEqual(new vscode.Selection(1, 7, 1, 13)));
+        harness.controller.dispose();
+    });
+
+    test('retained target resolving to notFound does not open or focus another tab', async () => {
+        const source = await createTurtleFile('not-found-source', 'source\n');
+        const distracting = await createTurtleFile('not-found-distracting', 'other\n');
+        await vscode.window.showTextDocument(source, {viewColumn: vscode.ViewColumn.One, preview: false});
+        const harness = await createAcceptedHarness(source);
+        await vscode.window.showTextDocument(distracting, {viewColumn: vscode.ViewColumn.Two, preview: false});
+        const activeBefore = vscode.window.activeTextEditor?.document.uri.toString();
+        harness.client.resolveResult = {location: null, warning: 'notFound'};
+
+        harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: TARGET_ID});
+        await flushPromises();
+
+        assert.equal(vscode.window.activeTextEditor?.document.uri.toString(), activeBefore);
+        assert.equal(textTabs(source).length, 1);
+        harness.controller.dispose();
+    });
+});
+
+async function createAcceptedHarness(source: vscode.Uri) {
+    const client = new FakeGraphicalViewClient();
+    const harness = createGraphicalViewHarnessWithWindow(vscode.window, client);
+    harness.workspace.available.add(source.toString());
+    await harness.commands.execute('semantic-models.openGraphicalView');
+    client.requests[0].deferred.resolve(renderResult(source));
+    await flushPromises();
+    return harness;
+}
+
+function clickTarget(
+    harness: ReturnType<typeof createGraphicalViewHarnessWithWindow<typeof vscode.window>>,
+    target: vscode.Uri,
+    startLine: number,
+    startCharacter: number,
+    endLine: number,
+    endCharacter: number,
+): void {
+    harness.client.resolveResult = {
+        location: {
+            uri: target.toString(),
+            range: {
+                start: {line: startLine, character: startCharacter},
+                end: {line: endLine, character: endCharacter},
+            },
+        },
+    };
+    harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: TARGET_ID});
+}
+
+function renderResult(source: vscode.Uri): GraphicalViewRenderResult {
+    return {
+        uri: source.toString(),
+        svg: `<svg><g id="${TARGET_ID}"/></svg>`,
+        targets: [{id: TARGET_ID, kind: 'elementHeader', elementUrn: OWNER}],
+        warnings: [],
+    };
+}
+
+function textTabs(uri: vscode.Uri): vscode.Tab[] {
+    return vscode.window.tabGroups.all
+        .flatMap(group => group.tabs)
+        .filter(tab => tab.input instanceof vscode.TabInputText && tab.input.uri.toString() === uri.toString());
+}
+
+function activeTextTabGroup(uri: vscode.Uri): vscode.TabGroup | undefined {
+    return vscode.window.tabGroups.all.find(group =>
+        group.tabs.some(tab => tab.isActive && tab.input instanceof vscode.TabInputText && tab.input.uri.toString() === uri.toString()),
+    );
+}
+
+async function createTurtleFile(name: string, contents: string): Promise<vscode.Uri> {
+    const uri = vscode.Uri.file(`/tmp/esmf-task7-${process.pid}-${name}.ttl`);
+    createdUris.push(uri);
+    await vscode.workspace.fs.writeFile(uri, Buffer.from(contents));
+    return uri;
+}
+
+async function waitFor(predicate: () => boolean): Promise<void> {
+    const deadline = Date.now() + 5_000;
+    while (!predicate()) {
+        if (Date.now() >= deadline) {
+            assert.fail('Timed out waiting for the VS Code editor state.');
+        }
+        await new Promise(resolve => setTimeout(resolve, 10));
+    }
+}
+
+async function waitForNavigation(uri: vscode.Uri, selection: vscode.Selection): Promise<void> {
+    await waitFor(() => {
+        const editor = vscode.window.activeTextEditor;
+        return editor?.document.uri.toString() === uri.toString() && editor.selection.isEqual(selection);
+    });
+}
diff --git a/src/test/graphicalViewNavigation.test.ts b/src/test/graphicalViewNavigation.test.ts
index c1227bb..c206655 100644
--- a/src/test/graphicalViewNavigation.test.ts
+++ b/src/test/graphicalViewNavigation.test.ts
@@ -5,6 +5,7 @@
 
 import * as assert from 'node:assert/strict';
 import * as vscode from 'vscode';
+import {findReusableTextEditorViewColumn} from '../graphicalView';
 import {resolveGraphicalViewNavigation, validateGraphicalViewResolveResult} from '../graphicalViewNavigation';
 import type {GraphicalViewRenderResult} from '../graphicalViewProtocol';
 import {
@@ -78,6 +79,136 @@ suite('Graphical View source navigation', () => {
         assert.ok(invalid.every(candidate => validateGraphicalViewResolveResult(candidate).kind === 'warning'));
     });
 
+    test('finds visible and hidden regular text tabs while ignoring diff and custom inputs', () => {
+        const target = vscode.Uri.file('/tmp/reused.ttl');
+        const groups = [
+            tabGroup(vscode.ViewColumn.One, [
+                tab(new vscode.TabInputTextDiff(vscode.Uri.file('/tmp/original.ttl'), target), true),
+                tab(new vscode.TabInputCustom(target, 'test.customEditor'), false),
+            ]),
+            tabGroup(vscode.ViewColumn.Two, [
+                tab(new vscode.TabInputText(target), false),
+                tab(new vscode.TabInputText(vscode.Uri.file('/tmp/visible.ttl')), true),
+            ]),
+        ];
+
+        assert.equal(findReusableTextEditorViewColumn(target, groups), vscode.ViewColumn.Two);
+    });
+
+    test('uses complete canonical URI identity and rejects similar resource identifiers', () => {
+        const target = vscode.Uri.parse('file://server/tmp/a%20model.ttl?revision=1#definition');
+        const groups = [
+            tabGroup(vscode.ViewColumn.One, [
+                tab(new vscode.TabInputText(vscode.Uri.parse('untitled://server/tmp/a%20model.ttl?revision=1#definition')), false),
+                tab(new vscode.TabInputText(vscode.Uri.parse('file://other/tmp/a%20model.ttl?revision=1#definition')), false),
+                tab(new vscode.TabInputText(vscode.Uri.parse('file://server/tmp/a%20model.ttl?revision=2#definition')), false),
+                tab(new vscode.TabInputText(vscode.Uri.parse('file://server/tmp/a%20model.ttl?revision=1#other')), false),
+                tab(new vscode.TabInputText(vscode.Uri.parse('file://server/tmp/a%2520model.ttl?revision=1#definition')), false),
+            ]),
+            tabGroup(vscode.ViewColumn.Three, [tab(new vscode.TabInputText(vscode.Uri.parse(target.toString())), false)]),
+        ];
+
+        assert.equal(findReusableTextEditorViewColumn(target, groups), vscode.ViewColumn.Three);
+    });
+
+    test('prefers an active duplicate match and otherwise keeps stable group order', () => {
+        const target = vscode.Uri.file('/tmp/duplicate.ttl');
+        assert.equal(
+            findReusableTextEditorViewColumn(target, [
+                tabGroup(vscode.ViewColumn.One, [tab(new vscode.TabInputText(target), false)]),
+                tabGroup(vscode.ViewColumn.Two, [tab(new vscode.TabInputText(target), true)]),
+                tabGroup(vscode.ViewColumn.Three, [tab(new vscode.TabInputText(target), true)]),
+            ]),
+            vscode.ViewColumn.Two,
+        );
+        assert.equal(
+            findReusableTextEditorViewColumn(target, [
+                tabGroup(vscode.ViewColumn.One, [tab(new vscode.TabInputText(target), false)]),
+                tabGroup(vscode.ViewColumn.Two, [tab(new vscode.TabInputText(target), false)]),
+            ]),
+            vscode.ViewColumn.One,
+        );
+    });
+
+    test('reuses a matching tab group and preserves fallback, selection, and centered reveal', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = createGraphicalViewDocument('/tmp/reuse-controller.ttl');
+        harness.workspace.available.add(document.uri.toString());
+        await openGraphicalView(harness, document);
+        const id = successfulHeaderId();
+        harness.client.requests[0].deferred.resolve(headerResult(document, id));
+        await flushPromises();
+        harness.client.resolveResult = {
+            location: {uri: document.uri.toString(), range: positions(4, 2, 4, 9)},
+        };
+        harness.window.tabGroups.all = [
+            tabGroup(vscode.ViewColumn.Three, [tab(new vscode.TabInputText(document.uri), false)]) as vscode.TabGroup,
+        ];
+
+        harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: id});
+        await flushPromises();
+        assert.deepEqual(harness.window.openedEditors[0].options, {preview: false, viewColumn: vscode.ViewColumn.Three});
+        assert.ok(harness.window.openedEditors[0].editor.selection.isEqual(new vscode.Selection(4, 2, 4, 9)));
+        assert.deepEqual(harness.window.openedEditors[0].revealedRanges, [new vscode.Range(4, 2, 4, 9)]);
+        assert.deepEqual(harness.window.openedEditors[0].revealTypes, [vscode.TextEditorRevealType.InCenterIfOutsideViewport]);
+
+        harness.window.tabGroups.all = [];
+        harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: id});
+        await flushPromises();
+        assert.deepEqual(harness.window.openedEditors[1].options, {preview: false});
+        harness.controller.dispose();
+    });
+
+    test('does not select or reveal when navigation becomes stale while editor reveal is pending', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = createGraphicalViewDocument('/tmp/stale-reuse.ttl');
+        harness.workspace.available.add(document.uri.toString());
+        await openGraphicalView(harness, document);
+        const id = successfulHeaderId();
+        harness.client.requests[0].deferred.resolve(headerResult(document, id));
+        await flushPromises();
+        harness.client.resolveResult = {
+            location: {uri: document.uri.toString(), range: positions(1, 2, 1, 7)},
+        };
+        let resolveEditor!: (editor: vscode.TextEditor) => void;
+        harness.window.showTextDocumentPromise = new Promise(resolve => {
+            resolveEditor = resolve;
+        });
+        const revealed: vscode.Range[] = [];
+        const editor = {
+            selection: new vscode.Selection(0, 0, 0, 0),
+            revealRange: (range: vscode.Range) => revealed.push(range),
+        } as unknown as vscode.TextEditor;
+
+        harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: id});
+        await flushPromises();
+        harness.panels.panels[0].dispose();
+        resolveEditor(editor);
+        await flushPromises();
+
+        assert.ok(editor.selection.isEqual(new vscode.Selection(0, 0, 0, 0)));
+        assert.deepEqual(revealed, []);
+        harness.controller.dispose();
+    });
+
+    test('resolver warnings do not inspect tabs or open an editor', async () => {
+        const harness = createGraphicalViewHarness();
+        const document = createGraphicalViewDocument('/tmp/not-found-before-tabs.ttl');
+        harness.workspace.available.add(document.uri.toString());
+        await openGraphicalView(harness, document);
+        const id = successfulHeaderId();
+        harness.client.requests[0].deferred.resolve(headerResult(document, id));
+        await flushPromises();
+        harness.client.resolveResult = {location: null, warning: 'notFound'};
+
+        harness.panels.panels[0].emitMessage({type: 'navigate', version: 1, targetId: id});
+        await flushPromises();
+
+        assert.deepEqual(harness.window.warnings, ['The graphical target no longer exists in the current model.']);
+        assert.deepEqual(harness.window.openedEditors, []);
+        harness.controller.dispose();
+    });
+
     test('opens current multilingual and wrapped attribute targets using only the accepted sidecar', async () => {
         const harness = createGraphicalViewHarness();
         const document = createGraphicalViewDocument('/tmp/navigation.ttl');
@@ -170,3 +301,27 @@ function positions(startLine: number, startCharacter: number, endLine: number, e
         end: {line: endLine, character: endCharacter},
     };
 }
+
+function tab(input: unknown, isActive: boolean): Pick<vscode.Tab, 'input' | 'isActive'> {
+    return {input, isActive};
+}
+
+function tabGroup(
+    viewColumn: vscode.ViewColumn,
+    tabs: Array<Pick<vscode.Tab, 'input' | 'isActive'>>,
+): Pick<vscode.TabGroup, 'viewColumn' | 'tabs'> {
+    return {viewColumn, tabs: tabs as vscode.Tab[]};
+}
+
+function successfulHeaderId(): string {
+    return 'gv-header-aaaaaaaaaaaaaaaa';
+}
+
+function headerResult(document: ReturnType<typeof createGraphicalViewDocument>, id: string): GraphicalViewRenderResult {
+    return {
+        uri: document.uri.toString(),
+        svg: `<svg><g id="${id}"/></svg>`,
+        targets: [{id, kind: 'elementHeader', elementUrn: OWNER}],
+        warnings: [],
+    };
+}
diff --git a/src/test/graphicalViewTestHarness.ts b/src/test/graphicalViewTestHarness.ts
index 1333d04..f7fe953 100644
--- a/src/test/graphicalViewTestHarness.ts
+++ b/src/test/graphicalViewTestHarness.ts
@@ -191,9 +191,19 @@ export class FakeGraphicalViewPanelFactory implements GraphicalViewPanelFactory
 }
 
 export function createGraphicalViewHarness(client = new FakeGraphicalViewClient()) {
+    return createHarness(client, new FakeWindow());
+}
+
+export function createGraphicalViewHarnessWithWindow<TWindow extends GraphicalViewWindow>(
+    window: TWindow,
+    client = new FakeGraphicalViewClient(),
+) {
+    return createHarness(client, window);
+}
+
+function createHarness<TWindow extends GraphicalViewWindow>(client: FakeGraphicalViewClient, window: TWindow) {
     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);
@@ -254,16 +264,19 @@ class FakeCommands implements GraphicalViewCommands {
     }
 }
 
-class FakeWindow implements GraphicalViewWindow {
+export class FakeWindow implements GraphicalViewWindow {
     activeTextEditor: {document: GraphicalViewDocument} | undefined;
+    readonly tabGroups: {all: vscode.TabGroup[]} = {all: []};
     readonly warnings: string[] = [];
     readonly openedEditors: Array<{
         uri: vscode.Uri;
         options: vscode.TextDocumentShowOptions | undefined;
         editor: vscode.TextEditor;
         revealedRanges: vscode.Range[];
+        revealTypes: Array<vscode.TextEditorRevealType | undefined>;
     }> = [];
     showTextDocumentFailure: unknown | undefined;
+    showTextDocumentPromise: Promise<vscode.TextEditor> | undefined;
 
     showWarningMessage(message: string): Promise<unknown> {
         this.warnings.push(message);
@@ -274,12 +287,19 @@ class FakeWindow implements GraphicalViewWindow {
         if (this.showTextDocumentFailure !== undefined) {
             return Promise.reject(this.showTextDocumentFailure);
         }
+        if (this.showTextDocumentPromise !== undefined) {
+            return this.showTextDocumentPromise;
+        }
         const revealedRanges: vscode.Range[] = [];
+        const revealTypes: Array<vscode.TextEditorRevealType | undefined> = [];
         const editor = {
             selection: new vscode.Selection(0, 0, 0, 0),
-            revealRange: (range: vscode.Range) => revealedRanges.push(range),
+            revealRange: (range: vscode.Range, revealType?: vscode.TextEditorRevealType) => {
+                revealedRanges.push(range);
+                revealTypes.push(revealType);
+            },
         } as unknown as vscode.TextEditor;
-        this.openedEditors.push({uri, options, editor, revealedRanges});
+        this.openedEditors.push({uri, options, editor, revealedRanges, revealTypes});
         return Promise.resolve(editor);
     }
 }

From 91d79b4f6c145d2946f51ffbd6ddedc201bdc2fa Mon Sep 17 00:00:00 2001
From: e-filchenko-bosh <FVI2FE@bosch.com>
Date: Wed, 16 Sep 2026 16:59:28 +0300
Subject: [PATCH 10/15] remove graphical SVG sanitizer

---
 README.md                                     |   2 +
 package-lock.json                             |  17 --
 package.json                                  |   1 -
 scripts/verify-webview-assets.mjs             |   9 +-
 scripts/webview-assets.mjs                    |   9 +-
 src/graphicalView.ts                          |   6 +-
 src/graphicalViewPanel.ts                     |  10 +-
 src/test/graphicalViewController.test.ts      |   4 +-
 src/test/graphicalViewPanel.test.ts           |  24 ++-
 src/test/graphicalViewTestHarness.ts          |   2 +-
 .../graphicalViewWebviewController.test.ts    |  53 +++--
 .../graphicalViewWebviewLifecycle.test.ts     |  29 ++-
 .../RobotoCondensed-LICENSE-Apache-2.0.txt    | 201 ++++++++++++++++++
 src/webview/RobotoCondensed-NOTICE.txt        |   4 +-
 src/webview/sanitizer-contract.js             | 155 --------------
 src/webview/webview.js                        |  57 +++--
 16 files changed, 336 insertions(+), 247 deletions(-)
 create mode 100644 src/webview/RobotoCondensed-LICENSE-Apache-2.0.txt
 delete mode 100644 src/webview/sanitizer-contract.js

diff --git a/README.md b/README.md
index f0b1757..bf47872 100644
--- a/README.md
+++ b/README.md
@@ -51,6 +51,8 @@ Element headers can navigate to definitions in local files. Eligible attribute r
 
 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.
 
+Graphical View supports SVG only from the shipped/current trusted SAMM language server and generator contract. The extension strict-parses each SVG as XML but does not sanitize or filter its elements and attributes. Its restrictive webview CSP and extension-side message, sidecar, and local-file navigation validation remain enforced. External, substituted, incompatible, or compromised language servers are outside the supported security model; future Graphper or generator changes must preserve the tested style-free passive-output invariant.
+
 ## Running the Server and Extension Together
 
 1. In this extension project, install the dependencies using `npm install`.
diff --git a/package-lock.json b/package-lock.json
index 3500327..04c2e22 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,7 +9,6 @@
       "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"
@@ -562,13 +561,6 @@
       "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",
@@ -1430,15 +1422,6 @@
         "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 3465f8c..c4573ab 100644
--- a/package.json
+++ b/package.json
@@ -233,7 +233,6 @@
     "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/scripts/verify-webview-assets.mjs b/scripts/verify-webview-assets.mjs
index db1355c..56d3124 100644
--- a/scripts/verify-webview-assets.mjs
+++ b/scripts/verify-webview-assets.mjs
@@ -3,14 +3,9 @@
  * SPDX-License-Identifier: MPL-2.0
  */
 
-import {readFileSync, readdirSync, statSync} from 'node:fs';
+import {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.');
-}
+import {outputDirectory, sha256, webviewAssets} from './webview-assets.mjs';
 
 const actual = readdirSync(outputDirectory).sort();
 const expected = webviewAssets.map(asset => asset.destination).sort();
diff --git a/scripts/webview-assets.mjs b/scripts/webview-assets.mjs
index f2b8b7a..ca47898 100644
--- a/scripts/webview-assets.mjs
+++ b/scripts/webview-assets.mjs
@@ -12,12 +12,10 @@ 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',
+        'src/webview/RobotoCondensed-LICENSE-Apache-2.0.txt',
+        'RobotoCondensed-LICENSE-Apache-2.0.txt',
+        '8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90',
     ),
     asset('src/webview/RobotoCondensed-NOTICE.txt', 'RobotoCondensed-NOTICE.txt'),
     asset(
@@ -25,7 +23,6 @@ export const webviewAssets = Object.freeze([
         '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'),
 ]);
diff --git a/src/graphicalView.ts b/src/graphicalView.ts
index 4298819..2bc6ba2 100644
--- a/src/graphicalView.ts
+++ b/src/graphicalView.ts
@@ -393,11 +393,11 @@ export class GraphicalViewController implements vscode.Disposable {
         } else if (state.lastSuccess?.version !== version) {
             return;
         }
-        this.outputChannel.warn('Graphical view rejected an SVG payload at the secure rendering boundary.');
+        this.outputChannel.warn('Graphical view rejected an SVG payload at the strict XML rendering boundary.');
         this.setStale(
             state,
-            'sanitizationFailed',
-            'The new diagram could not be displayed safely. The last successful diagram is retained.',
+            'xmlParsingFailed',
+            'The new diagram is not a usable SVG document. The last successful diagram is retained.',
         );
     }
 
diff --git a/src/graphicalViewPanel.ts b/src/graphicalViewPanel.ts
index cf283e6..91c3e14 100644
--- a/src/graphicalViewPanel.ts
+++ b/src/graphicalViewPanel.ts
@@ -17,7 +17,7 @@ import {GRAPHICAL_VIEW_MARKER_PATTERN} from './graphicalViewProtocol';
 
 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);
+export const WEBVIEW_SCRIPT_ORDER = Object.freeze(['webview.js'] as const);
 
 export type GraphicalViewStatus =
     | Readonly<{kind: 'loading'; message: string}>
@@ -34,7 +34,7 @@ export type GraphicalViewPanelMessage =
     | Readonly<{type: 'ready'}>
     | Readonly<{type: 'refresh'}>
     | Readonly<{type: 'rendered'; version: number}>
-    | Readonly<{type: 'renderError'; version: number; reason: 'sanitizationFailed'}>
+    | Readonly<{type: 'renderError'; version: number; reason: 'xmlParsingFailed'}>
     | Readonly<{type: 'navigate'; version: number; targetId: string}>;
 
 export interface GraphicalViewPanel extends vscode.Disposable {
@@ -167,8 +167,6 @@ export function createGraphicalViewShell(
         <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>`;
 }
@@ -188,9 +186,9 @@ export function parseGraphicalViewPanelMessage(value: unknown): GraphicalViewPan
     }
     if (value.type === 'renderError'
         && hasExactKeys(keys, ['reason', 'type', 'version'])
-        && value.reason === 'sanitizationFailed'
+        && value.reason === 'xmlParsingFailed'
         && isDisplayedVersion(value.version)) {
-        return value as {type: 'renderError'; version: number; reason: 'sanitizationFailed'};
+        return value as {type: 'renderError'; version: number; reason: 'xmlParsingFailed'};
     }
     if (value.type === 'navigate'
         && hasExactKeys(keys, ['targetId', 'type', 'version'])
diff --git a/src/test/graphicalViewController.test.ts b/src/test/graphicalViewController.test.ts
index 91b5c65..3f3e734 100644
--- a/src/test/graphicalViewController.test.ts
+++ b/src/test/graphicalViewController.test.ts
@@ -178,7 +178,7 @@ suite('GraphicalViewController lifecycle', () => {
         harness.controller.dispose();
     });
 
-    test('retains the last accepted diagram for warning, transport, and sanitizer failures', async () => {
+    test('retains the last accepted diagram for warning, transport, and XML parsing failures', async () => {
         const harness = createGraphicalViewHarness();
         const document = track(harness, '/tmp/retention.ttl');
         await openGraphicalView(harness, document);
@@ -202,7 +202,7 @@ suite('GraphicalViewController lifecycle', () => {
 
         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')));
+        assert.ok(harness.outputChannel.lines.some(line => line.includes('strict XML rendering boundary')));
         harness.controller.dispose();
     });
 
diff --git a/src/test/graphicalViewPanel.test.ts b/src/test/graphicalViewPanel.test.ts
index 572039d..5741578 100644
--- a/src/test/graphicalViewPanel.test.ts
+++ b/src/test/graphicalViewPanel.test.ts
@@ -56,8 +56,8 @@ suite('GraphicalView secure panel contract', () => {
             "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.match(/<script /g) ?? []).length, 3);
-        assert.equal(first.split(`nonce="${firstNonce}"`).length - 1, 3);
+        assert.equal((first.match(/<script /g) ?? []).length, 1);
+        assert.equal(first.split(`nonce="${firstNonce}"`).length - 1, 1);
         assert.equal(first.includes(`<script nonce="${firstNonce}">`), false);
         assert.equal(first.includes('http://'), false);
         assert.equal(first.includes('https://'), false);
@@ -112,6 +112,11 @@ suite('GraphicalView secure panel contract', () => {
         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: 'renderError', version: 1, reason: 'xmlParsingFailed'}), {
+            type: 'renderError',
+            version: 1,
+            reason: 'xmlParsingFailed',
+        });
         assert.deepEqual(
             parseGraphicalViewPanelMessage({type: 'navigate', version: 2, targetId: 'gv-attribute-aaaaaaaaaaaaaaaa'}),
             {type: 'navigate', version: 2, targetId: 'gv-attribute-aaaaaaaaaaaaaaaa'},
@@ -121,7 +126,7 @@ suite('GraphicalView secure panel contract', () => {
             {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'},
+            {type: 'renderError', version: 1, reason: 'sanitizationFailed'},
         ]) {
             assert.equal(parseGraphicalViewPanelMessage(message), undefined);
         }
@@ -130,17 +135,13 @@ suite('GraphicalView secure panel contract', () => {
     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-LICENSE-Apache-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',
@@ -149,8 +150,11 @@ suite('GraphicalView secure panel contract', () => {
 
     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("new DOMParser().parseFromString(svgText, 'image/svg+xml')"));
+        assert.ok(controllerSource.includes('document.importNode(svg, true)'));
+        assert.ok(controllerSource.includes('diagram.replaceChildren(parsedSvg)'));
+        assert.equal(/innerHTML|outerHTML|insertAdjacentHTML|document\.write/.test(controllerSource), false);
+        assert.equal(/DOMPurify|SanitizerContract|ALLOWED_TAGS|ALLOWED_ATTR/.test(controllerSource), false);
         assert.ok(controllerSource.includes('vscode.getState()'));
         assert.ok(controllerSource.includes('vscode.setState(state)'));
         assert.ok(controllerSource.includes('schemaVersion: 1'));
diff --git a/src/test/graphicalViewTestHarness.ts b/src/test/graphicalViewTestHarness.ts
index f7fe953..0fc8533 100644
--- a/src/test/graphicalViewTestHarness.ts
+++ b/src/test/graphicalViewTestHarness.ts
@@ -125,7 +125,7 @@ export class FakeGraphicalViewPanel implements GraphicalViewPanel {
             this.emitMessage(
                 this.renderOutcome === 'success'
                     ? {type: 'rendered', version: delivery.version}
-                    : {type: 'renderError', version: delivery.version, reason: 'sanitizationFailed'},
+                    : {type: 'renderError', version: delivery.version, reason: 'xmlParsingFailed'},
             );
         }
     }
diff --git a/src/test/graphicalViewWebviewController.test.ts b/src/test/graphicalViewWebviewController.test.ts
index 5011141..074027e 100644
--- a/src/test/graphicalViewWebviewController.test.ts
+++ b/src/test/graphicalViewWebviewController.test.ts
@@ -46,19 +46,13 @@ suite('Graphical View webview controller', () => {
                 },
                 postMessage: (message: unknown) => posted.push(message),
             }),
-            document: {querySelector: (selector: string) => elements.get(selector)},
+            document: {
+                querySelector: (selector: string) => elements.get(selector),
+                importNode: (node: FakeElement) => node,
+            },
             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};
-                },
-            },
+            DOMParser: FakeDomParser,
             requestAnimationFrame: (callback: () => void) => callback(),
             setTimeout: (callback: () => void) => {
                 callback();
@@ -115,10 +109,13 @@ suite('Graphical View webview controller', () => {
                 setState: () => undefined,
                 postMessage: () => undefined,
             }),
-            document: {querySelector: (selector: string) => elements.get(selector)},
+            document: {
+                querySelector: (selector: string) => elements.get(selector),
+                importNode: (node: FakeElement) => node,
+            },
             window,
             Element: FakeElement,
-            SanitizerContract: {MARKER_PATTERN: /^$/, sanitizeSvg: () => undefined},
+            DOMParser: FakeDomParser,
             requestAnimationFrame: () => undefined,
             setTimeout: () => 0,
             Number,
@@ -165,7 +162,11 @@ class FakeElement {
     contains: (candidate: unknown) => boolean = () => false;
     replaceChildren: (fragment: unknown) => void = () => undefined;
 
-    constructor(readonly id = '') {}
+    constructor(
+        readonly id = '',
+        readonly localName = 'g',
+        readonly namespaceURI = 'http://www.w3.org/2000/svg',
+    ) {}
 
     addEventListener(type: string, listener: (event: never) => void): void {
         this.listeners.set(type, listener);
@@ -185,10 +186,8 @@ class FakeElement {
 }
 
 class FakeSvg extends FakeElement {
-    readonly viewBox = {baseVal: {width: 2200, height: 1600}};
-
     constructor(private readonly marker: FakeElement) {
-        super();
+        super('', 'svg');
     }
 
     getAttribute(name: string): string | null {
@@ -200,6 +199,26 @@ class FakeSvg extends FakeElement {
     }
 }
 
+class FakeDomParser {
+    parseFromString(svgText: string, mediaType: string): FakeXmlDocument {
+        assert.equal(mediaType, 'image/svg+xml');
+        const id = svgText.match(/gv-(?:header|attribute)-[a-z0-9]{16,32}/)?.[0];
+        const marker = new FakeElement(id ?? '');
+        return new FakeXmlDocument(new FakeSvg(marker), svgText.includes('<parsererror'));
+    }
+}
+
+class FakeXmlDocument {
+    constructor(
+        readonly documentElement: FakeSvg,
+        private readonly parserError: boolean,
+    ) {}
+
+    getElementsByTagName(name: string): unknown[] {
+        return name === 'parsererror' && this.parserError ? [{}] : [];
+    }
+}
+
 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 5414746..002901d 100644
--- a/src/test/graphicalViewWebviewLifecycle.test.ts
+++ b/src/test/graphicalViewWebviewLifecycle.test.ts
@@ -55,8 +55,30 @@ suite('GraphicalView real webview lifecycle', function () {
             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');
+            await panel.webview.postMessage({
+                type: 'render',
+                version: 3,
+                svg: '<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"><text>&#1;</text></svg>',
+            });
+            await waitFor(() => hasMessage(messages, 'renderError', 3), 'XML-forbidden control rejection');
+            await panel.webview.postMessage({type: 'render', version: 4, svg: '<html width="10" height="10"/>'});
+            await waitFor(() => hasMessage(messages, 'renderError', 4), 'non-SVG root rejection');
+            await panel.webview.postMessage({
+                type: 'render',
+                version: 5,
+                svg: '<svg xmlns="http://www.w3.org/2000/svg" width="0" height="10"/>',
+            });
+            await waitFor(() => hasMessage(messages, 'renderError', 5), 'invalid dimension rejection');
+            await panel.webview.postMessage({type: 'render', version: 6, svg: ''});
+            await waitFor(() => hasMessage(messages, 'renderError', 6), 'missing root rejection');
+            await panel.webview.postMessage({
+                type: 'render',
+                version: 7,
+                svg: '<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"/><svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"/>',
+            });
+            await waitFor(() => hasMessage(messages, 'renderError', 7), 'multiple root rejection');
+            await panel.webview.postMessage({type: 'render', version: 8, svg: '<svg width="10" height="10"/>'});
+            await waitFor(() => hasMessage(messages, 'renderError', 8), 'wrong namespace rejection');
         } finally {
             subscription.dispose();
             panel.dispose();
@@ -65,8 +87,7 @@ suite('GraphicalView real webview lifecycle', function () {
 });
 
 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>
+    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="${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>
diff --git a/src/webview/RobotoCondensed-LICENSE-Apache-2.0.txt b/src/webview/RobotoCondensed-LICENSE-Apache-2.0.txt
new file mode 100644
index 0000000..11069ed
--- /dev/null
+++ b/src/webview/RobotoCondensed-LICENSE-Apache-2.0.txt
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+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
+
+    http://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.
diff --git a/src/webview/RobotoCondensed-NOTICE.txt b/src/webview/RobotoCondensed-NOTICE.txt
index fb40b42..8fc3164 100644
--- a/src/webview/RobotoCondensed-NOTICE.txt
+++ b/src/webview/RobotoCondensed-NOTICE.txt
@@ -15,5 +15,5 @@ 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.
+The full Apache License 2.0 text is distributed alongside this notice as
+RobotoCondensed-LICENSE-Apache-2.0.txt.
diff --git a/src/webview/sanitizer-contract.js b/src/webview/sanitizer-contract.js
deleted file mode 100644
index 0e4e621..0000000
--- a/src/webview/sanitizer-contract.js
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * 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|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+)?';
-    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.js b/src/webview/webview.js
index 073346b..dec58de 100644
--- a/src/webview/webview.js
+++ b/src/webview/webview.js
@@ -17,6 +17,9 @@
     const MIN_ZOOM = 0.25;
     const MAX_ZOOM = 4;
     const ZOOM_FACTOR = 1.2;
+    const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+    const MARKER_PATTERN = /^gv-(?:header|attribute)-[a-z0-9]{16,32}$/;
+    const POSITIVE_DIMENSION_PATTERN = /^(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:pt)?$/;
     const vscode = acquireVsCodeApi();
     const viewport = document.querySelector('#viewport');
     const diagram = document.querySelector('#diagram');
@@ -82,15 +85,37 @@
     }
 
     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) {
+        const width = parseDimension(svg.getAttribute('width'));
+        const height = parseDimension(svg.getAttribute('height'));
+        if (width === undefined || height === undefined) {
             throw new Error('SVG dimensions are unavailable');
         }
-        return {width: resolvedWidth, height: resolvedHeight};
+        return {width, height};
+    }
+
+    function parseDimension(value) {
+        if (typeof value !== 'string' || !POSITIVE_DIMENSION_PATTERN.test(value)) {
+            return undefined;
+        }
+        const parsed = Number(value.endsWith('pt') ? value.slice(0, -2) : value);
+        return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+    }
+
+    function parseTrustedSvg(svgText) {
+        const parsed = new DOMParser().parseFromString(svgText, 'image/svg+xml');
+        if (parsed.getElementsByTagName('parsererror').length > 0) {
+            throw new Error('SVG is not well-formed XML');
+        }
+        const svg = parsed.documentElement;
+        if (!svg || svg.localName !== 'svg' || svg.namespaceURI !== SVG_NAMESPACE) {
+            throw new Error('SVG document root is invalid');
+        }
+        dimensions(svg);
+        const imported = document.importNode(svg, true);
+        if (!(imported instanceof Element) || imported.localName !== 'svg' || imported.namespaceURI !== SVG_NAMESPACE) {
+            throw new Error('SVG document root could not be imported');
+        }
+        return imported;
     }
 
     function applyZoom() {
@@ -173,11 +198,11 @@
             if (currentSvg) {
                 captureViewport();
             }
-            const sanitized = SanitizerContract.sanitizeSvg(message.svg);
-            const size = dimensions(sanitized.svg);
-            makeNavigationMarkersInteractive(sanitized.svg);
-            diagram.replaceChildren(sanitized.fragment);
-            currentSvg = sanitized.svg;
+            const parsedSvg = parseTrustedSvg(message.svg);
+            const size = dimensions(parsedSvg);
+            makeNavigationMarkersInteractive(parsedSvg);
+            diagram.replaceChildren(parsedSvg);
+            currentSvg = parsedSvg;
             currentVersion = message.version;
             baseWidth = size.width;
             baseHeight = size.height;
@@ -186,9 +211,9 @@
         } catch (error) {
             updateStatus({
                 kind: 'stale',
-                message: 'The new diagram could not be displayed safely. The last valid diagram is retained.',
+                message: 'The new diagram is not a usable SVG document. The last valid diagram is retained.',
             });
-            vscode.postMessage({type: 'renderError', version: message.version, reason: 'sanitizationFailed'});
+            vscode.postMessage({type: 'renderError', version: message.version, reason: 'xmlParsingFailed'});
         }
     }
 
@@ -207,7 +232,7 @@
 
     function makeNavigationMarkersInteractive(svg) {
         for (const group of svg.querySelectorAll('g[id]')) {
-            if (SanitizerContract.MARKER_PATTERN.test(group.id)) {
+            if (MARKER_PATTERN.test(group.id)) {
                 group.setAttribute('tabindex', '0');
                 group.setAttribute('role', 'link');
                 group.setAttribute('aria-label', group.id.startsWith('gv-attribute-')
@@ -219,7 +244,7 @@
 
     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)) {
+        if (!group || !diagram.contains(group) || !MARKER_PATTERN.test(group.id) || !Number.isInteger(currentVersion)) {
             return false;
         }
         vscode.postMessage({type: 'navigate', version: currentVersion, targetId: group.id});

From f48f58df8c1dbea2e3ea1fc90567303322680b6b Mon Sep 17 00:00:00 2001
From: e-filchenko-bosh <FVI2FE@bosch.com>
Date: Thu, 17 Sep 2026 09:43:45 +0300
Subject: [PATCH 11/15] improve graphical viewport controls

---
 .vscode-test.mjs                              |  16 +-
 src/test/graphicalViewPanel.test.ts           |  16 +-
 src/test/graphicalViewViewport.test.ts        | 531 ++++++++++++++++++
 .../graphicalViewWebviewController.test.ts    |   8 +-
 .../graphicalViewWebviewLifecycle.test.ts     | 270 ++++++++-
 src/webview/webview.css                       |  64 ++-
 src/webview/webview.js                        | 235 ++++++--
 7 files changed, 1058 insertions(+), 82 deletions(-)
 create mode 100644 src/test/graphicalViewViewport.test.ts

diff --git a/.vscode-test.mjs b/.vscode-test.mjs
index b36d3f4..f781185 100644
--- a/.vscode-test.mjs
+++ b/.vscode-test.mjs
@@ -1,12 +1,14 @@
-import { defineConfig } from '@vscode/test-cli';
+import {defineConfig} from '@vscode/test-cli';
 
 const vscodeExecutablePath = process.env.VSCODE_EXECUTABLE_PATH;
+const runSuffix = process.env.VSCODE_TEST_RUN_ID?.replace(/[^a-zA-Z0-9_-]/g, '-');
+const testDirectorySuffix = runSuffix ? `-${runSuffix}` : '';
 
 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'
-	],
+    files: 'out/test/**/*.test.js',
+    ...(vscodeExecutablePath ? {useInstallation: {fromPath: vscodeExecutablePath}} : {}),
+    launchArgs: [
+        `--user-data-dir=/tmp/extension-vscode-test-user-data${testDirectorySuffix}`,
+        `--extensions-dir=/tmp/extension-vscode-test-extensions${testDirectorySuffix}`,
+    ],
 });
diff --git a/src/test/graphicalViewPanel.test.ts b/src/test/graphicalViewPanel.test.ts
index 5741578..960c380 100644
--- a/src/test/graphicalViewPanel.test.ts
+++ b/src/test/graphicalViewPanel.test.ts
@@ -90,7 +90,7 @@ suite('GraphicalView secure panel contract', () => {
         const stylesheet = readFileSync(join(__dirname, '..', '..', 'src', 'webview', 'webview.css'), 'utf8');
 
         for (const kind of ['ready', 'loading', 'stale', 'unsupported', 'disconnected']) {
-            assert.ok(stylesheet.includes(`#status[data-kind="${kind}"]`));
+            assert.match(stylesheet, new RegExp(`#status\\[data-kind=['"]${kind}['"]\\]`));
         }
         for (const themeVariable of [
             '--vscode-testing-iconPassed',
@@ -103,8 +103,8 @@ suite('GraphicalView secure panel contract', () => {
             assert.ok(stylesheet.includes(themeVariable));
         }
         assert.match(stylesheet, /#toolbar\s*{[^}]*flex-wrap: wrap;/s);
-        assert.match(stylesheet, /#status\[data-kind="loading"\] #status-indicator\s*{[^}]*animation: status-spin/s);
-        assert.match(stylesheet, /#status\[data-kind="stale"\],[\s\S]*flex: 1 0 100%;/);
+        assert.match(stylesheet, /#status\[data-kind=['"]loading['"]\] #status-indicator\s*{[^}]*animation: status-spin/s);
+        assert.match(stylesheet, /#status\[data-kind=['"]stale['"]\],[\s\S]*flex: 1 0 100%;/);
         assert.match(stylesheet, /@media \(max-width: 520px\)/);
     });
 
@@ -117,10 +117,11 @@ suite('GraphicalView secure panel contract', () => {
             version: 1,
             reason: 'xmlParsingFailed',
         });
-        assert.deepEqual(
-            parseGraphicalViewPanelMessage({type: 'navigate', version: 2, targetId: 'gv-attribute-aaaaaaaaaaaaaaaa'}),
-            {type: 'navigate', version: 2, targetId: 'gv-attribute-aaaaaaaaaaaaaaaa'},
-        );
+        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'},
@@ -160,6 +161,7 @@ suite('GraphicalView secure panel contract', () => {
         assert.ok(controllerSource.includes('schemaVersion: 1'));
         assert.ok(controllerSource.includes('scrollLeft'));
         assert.ok(controllerSource.includes('scrollTop'));
+        assert.ok(controllerSource.includes('viewportInitialized'));
         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})"));
diff --git a/src/test/graphicalViewViewport.test.ts b/src/test/graphicalViewViewport.test.ts
new file mode 100644
index 0000000..ead9448
--- /dev/null
+++ b/src/test/graphicalViewViewport.test.ts
@@ -0,0 +1,531 @@
+/*
+ * 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';
+
+const source = readFileSync(join(__dirname, '..', '..', 'src', 'webview', 'webview.js'), 'utf8');
+
+suite('Graphical View viewport', () => {
+    test('first valid render fits, centers, persists initialization, and only then acknowledges', () => {
+        const harness = new WebviewHarness();
+        harness.render(1, 2200, 1600);
+
+        assert.equal(harness.hasPosted('rendered', 1), false);
+        assert.equal(harness.svg?.width, 976);
+        harness.flushFrame();
+
+        assert.equal(harness.hasPosted('rendered', 1), true);
+        assert.deepEqual(harness.savedState, {
+            schemaVersion: 1,
+            zoom: 976 / 2200,
+            scrollLeft: 0,
+            scrollTop: 0,
+            viewportInitialized: true,
+        });
+        const bounds = harness.svgBounds();
+        assert.equal(bounds.left, 112);
+        assert.equal(bounds.top, 50 + 12 + (776 - 1600 * (976 / 2200)) / 2);
+    });
+
+    test('rejected first SVG leaves Fit pending for the next valid render', () => {
+        const harness = new WebviewHarness();
+        harness.message({type: 'render', version: 1, svg: '<parsererror'});
+        assert.equal(harness.hasPosted('renderError', 1), true);
+        assert.equal(harness.savedState.viewportInitialized, false);
+
+        harness.render(2, 2000, 1000);
+        harness.flushFrame();
+        assert.equal(harness.savedState.zoom, 976 / 2000);
+        assert.equal(harness.savedState.viewportInitialized, true);
+        assert.equal(harness.hasPosted('rendered', 2), true);
+    });
+
+    test('migrates valid schema-1 state as initialized and strips non-passive data', () => {
+        const harness = new WebviewHarness({
+            schemaVersion: 1,
+            zoom: 2,
+            scrollLeft: 240,
+            scrollTop: 160,
+            svg: '<svg/>',
+            uri: 'file:///secret',
+            command: 'workbench.action.closeWindow',
+            pointer: {x: 1},
+        });
+        harness.render(1, 900, 700);
+        harness.flushFrame();
+
+        assert.deepEqual(harness.savedState, {
+            schemaVersion: 1,
+            zoom: 2,
+            scrollLeft: 240,
+            scrollTop: 160,
+            viewportInitialized: true,
+        });
+        assert.equal(harness.svg?.width, 1800);
+    });
+
+    test('normalizes malformed persisted values without treating them as a valid legacy viewport', () => {
+        const harness = new WebviewHarness({
+            schemaVersion: 1,
+            zoom: Number.POSITIVE_INFINITY,
+            scrollLeft: -20,
+            scrollTop: Number.NaN,
+        });
+        assert.deepEqual(harness.savedState, {
+            schemaVersion: 1,
+            zoom: 1,
+            scrollLeft: 0,
+            scrollTop: 0,
+            viewportInitialized: false,
+        });
+        harness.render(1, 100, 100);
+        harness.flushFrame();
+        assert.equal(harness.savedState.zoom, 4);
+        assert.equal(harness.savedState.viewportInitialized, true);
+    });
+
+    test('subsequent renders preserve zoom and clamp only unreachable scroll positions', () => {
+        const harness = new WebviewHarness(initializedState(2, 1000, 800));
+        harness.render(1, 1000, 800);
+        harness.flushFrame();
+        assert.equal(harness.savedState.scrollLeft, 1000);
+        assert.equal(harness.savedState.scrollTop, 800);
+
+        harness.render(2, 600, 400);
+        harness.flushFrame();
+        assert.deepEqual(harness.savedState, initializedState(2, 224, 24));
+        assert.equal(harness.hasPosted('rendered', 2), true);
+    });
+
+    test('Fit obeys both bounds, centers free axes, and leaves oversized edges reachable', () => {
+        const large = new WebviewHarness(initializedState(1, 0, 0));
+        large.render(1, 10_000, 1000);
+        large.flushFrame();
+        large.click('#zoom-fit');
+        large.flushFrame();
+        assert.equal(large.savedState.zoom, 0.25);
+        assert.equal(large.svgBounds().left, 112);
+        large.viewport.scrollLeft = large.viewport.maximumLeft;
+        assert.equal(large.svgBounds().right, 100 + 1000 - 12);
+
+        const small = new WebviewHarness(initializedState(1, 0, 0));
+        small.render(1, 100, 100);
+        small.flushFrame();
+        small.click('#zoom-fit');
+        small.flushFrame();
+        assert.equal(small.savedState.zoom, 4);
+        const bounds = small.svgBounds();
+        assert.equal(bounds.left, 100 + 12 + (976 - 400) / 2);
+        assert.equal(bounds.top, 50 + 12 + (776 - 400) / 2);
+    });
+
+    test('modifier wheel is coalesced and pointer anchored while ordinary input remains native', () => {
+        const harness = new WebviewHarness(initializedState(1, 500, 300));
+        let prevented = 0;
+        harness.render(1, 2000, 1400);
+        harness.flushFrame();
+        const anchor = {clientX: 420, clientY: 310};
+        const before = harness.contentPoint(anchor);
+
+        harness.wheel({...anchor, deltaY: 40, deltaMode: 0, ctrlKey: false, metaKey: false, preventDefault: () => prevented++});
+        assert.equal(prevented, 0);
+        assert.equal(harness.frameCount, 0);
+
+        for (let index = 0; index < 3; index++) {
+            harness.wheel({...anchor, deltaY: -20, deltaMode: 0, ctrlKey: true, metaKey: false, preventDefault: () => prevented++});
+        }
+        assert.equal(prevented, 3);
+        assert.equal(harness.frameCount, 1);
+        harness.flushFrame();
+        harness.flushFrame();
+
+        assert.ok(Number(harness.savedState.zoom) > 1);
+        const after = harness.contentPoint(anchor);
+        assert.ok(Math.abs(before.x - after.x) < 0.001);
+        assert.ok(Math.abs(before.y - after.y) < 0.001);
+        assert.equal(harness.wheelOptions?.passive, false);
+    });
+
+    test('unavailable and bound-blocked modifier wheel avoid layout and state changes', () => {
+        const empty = new WebviewHarness();
+        let emptyPrevented = 0;
+        empty.wheel(wheelEvent(-100, () => emptyPrevented++));
+        assert.equal(emptyPrevented, 0);
+        assert.equal(empty.frameCount, 0);
+
+        const bounded = new WebviewHarness(initializedState(4, 10, 10));
+        bounded.render(1, 1000, 1000);
+        bounded.flushFrame();
+        const callsBefore = bounded.setStateCalls;
+        let prevented = 0;
+        bounded.wheel(wheelEvent(-100, () => prevented++));
+        assert.equal(prevented, 1);
+        assert.equal(bounded.frameCount, 0);
+        assert.equal(bounded.setStateCalls, callsBefore);
+        assert.deepEqual(bounded.savedState, initializedState(4, 10, 10));
+    });
+
+    test('line and page wheel deltas are bounded and rapid events schedule one frame', () => {
+        const line = new WebviewHarness(initializedState(1, 300, 200));
+        line.render(1, 2000, 1200);
+        line.flushFrame();
+        line.wheel(wheelEvent(-10, () => undefined, 1));
+        line.wheel(wheelEvent(-1, () => undefined, 2));
+        assert.equal(line.frameCount, 1);
+        line.flushFrame();
+        line.flushFrame();
+        assert.ok(Math.abs(Number(line.savedState.zoom) - Math.exp(0.2)) < 0.000001);
+    });
+
+    test('toolbar zoom and Reset preserve the viewport-center content point; Fit is distinct', () => {
+        const harness = new WebviewHarness(initializedState(1, 500, 300));
+        harness.render(1, 2000, 1400);
+        harness.flushFrame();
+        const center = {clientX: 600, clientY: 450};
+        const before = harness.contentPoint(center);
+        harness.click('#zoom-in');
+        harness.flushFrame();
+        assert.equal(harness.savedState.zoom, 1.2);
+        assertContentPointClose(before, harness.contentPoint(center));
+
+        harness.click('#zoom-reset');
+        harness.flushFrame();
+        assert.equal(harness.savedState.zoom, 1);
+        assertContentPointClose(before, harness.contentPoint(center));
+
+        harness.click('#zoom-fit');
+        harness.flushFrame();
+        assert.equal(harness.savedState.zoom, 976 / 2000);
+        assert.equal(harness.savedState.scrollLeft, 0);
+        assert.equal(harness.savedState.scrollTop, 0);
+    });
+
+    test('a stale queued layout callback cannot reposition or acknowledge a newer render', () => {
+        const harness = new WebviewHarness();
+        harness.render(1, 2200, 1600);
+        harness.render(2, 1000, 500);
+        harness.flushFrame();
+
+        assert.equal(harness.hasPosted('rendered', 1), false);
+        assert.equal(harness.hasPosted('rendered', 2), true);
+        assert.equal(harness.savedState.zoom, 0.976);
+        assert.equal(harness.savedState.viewportInitialized, true);
+    });
+
+    test('a queued wheel frame cannot zoom a newer render', () => {
+        const harness = new WebviewHarness(initializedState(1, 100, 100));
+        harness.render(1, 2000, 1200);
+        harness.flushFrame();
+        harness.wheel(wheelEvent(-100, () => undefined));
+        assert.equal(harness.frameCount, 1);
+
+        harness.render(2, 1000, 600);
+        harness.flushFrame();
+
+        assert.equal(harness.savedState.zoom, 1);
+        assert.equal(harness.hasPosted('rendered', 2), true);
+    });
+
+    test('toolbar layout supersedes a pending restore without losing initialization or acknowledgement', () => {
+        const harness = new WebviewHarness();
+        harness.render(1, 2200, 1600);
+        harness.click('#zoom-in');
+        harness.flushFrame();
+
+        assert.equal(harness.savedState.viewportInitialized, true);
+        assert.equal(harness.savedState.zoom, (976 / 2200) * 1.2);
+        assert.equal(harness.hasPosted('rendered', 1), true);
+    });
+
+    test('a render arriving during anchor correction preserves the corrected viewport', () => {
+        const harness = new WebviewHarness(initializedState(1, 500, 300));
+        harness.render(1, 2000, 1400);
+        harness.flushFrame();
+        harness.click('#zoom-in');
+
+        harness.render(2, 2000, 1400);
+        harness.flushFrame();
+
+        assert.equal(harness.savedState.zoom, 1.2);
+        assert.ok(Math.abs(Number(harness.savedState.scrollLeft) - 697.6) < 0.001);
+        assert.ok(Math.abs(Number(harness.savedState.scrollTop) - 437.6) < 0.001);
+        assert.equal(harness.hasPosted('rendered', 2), true);
+    });
+});
+
+function initializedState(zoom: number, scrollLeft: number, scrollTop: number): Record<string, number | boolean> {
+    return {schemaVersion: 1, zoom, scrollLeft, scrollTop, viewportInitialized: true};
+}
+
+function wheelEvent(deltaY: number, preventDefault: () => void, deltaMode = 0): Record<string, unknown> {
+    return {clientX: 420, clientY: 310, deltaY, deltaMode, ctrlKey: true, metaKey: false, preventDefault};
+}
+
+function assertContentPointClose(expected: Point, actual: Point): void {
+    assert.ok(Math.abs(expected.x - actual.x) < 0.001);
+    assert.ok(Math.abs(expected.y - actual.y) < 0.001);
+}
+
+interface Point {
+    x: number;
+    y: number;
+}
+
+class WebviewHarness {
+    readonly viewport = new FakeViewport();
+    readonly diagram = new FakeElement();
+    readonly window = new FakeElement();
+    readonly posted: unknown[] = [];
+    readonly frames: Array<() => void> = [];
+    savedState: Record<string, unknown> = {};
+    setStateCalls = 0;
+    svg?: FakeSvg;
+    wheelOptions?: {passive?: boolean};
+    private readonly elements: Map<string, FakeElement>;
+
+    constructor(savedState?: unknown) {
+        this.viewport.onWheelOptions = options => {
+            this.wheelOptions = options;
+        };
+        this.diagram.replaceChildren = child => {
+            this.svg = child as FakeSvg;
+            this.svg.viewport = this.viewport;
+        };
+        this.viewport.currentSvg = () => this.svg;
+        this.elements = new Map([
+            ['#diagram', this.diagram],
+            ['#viewport', this.viewport],
+            ['#status', new FakeElement()],
+            ['#status-text', 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()],
+        ]);
+        runInNewContext(source, {
+            acquireVsCodeApi: () => ({
+                getState: () => savedState,
+                setState: (value: Record<string, unknown>) => {
+                    this.savedState = JSON.parse(JSON.stringify(value)) as Record<string, unknown>;
+                    this.setStateCalls++;
+                },
+                postMessage: (message: unknown) => this.posted.push(message),
+            }),
+            document: {
+                querySelector: (selector: string) => this.elements.get(selector),
+                importNode: (node: FakeSvg) => node,
+            },
+            window: this.window,
+            Element: FakeElement,
+            DOMParser: FakeDomParser,
+            requestAnimationFrame: (callback: () => void) => {
+                this.frames.push(callback);
+                return this.frames.length;
+            },
+            setTimeout: () => 0,
+            clearTimeout: () => undefined,
+            Number,
+            Object,
+            Math,
+            Error,
+        });
+    }
+
+    get frameCount(): number {
+        return this.frames.length;
+    }
+
+    render(version: number, width: number, height: number): void {
+        this.message({
+            type: 'render',
+            version,
+            svg: `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}"/>`,
+        });
+    }
+
+    message(data: unknown): void {
+        this.window.fire('message', {data});
+    }
+
+    click(selector: string): void {
+        this.elements.get(selector)?.fire('click', {});
+    }
+
+    wheel(event: Record<string, unknown>): void {
+        this.viewport.fire('wheel', event);
+    }
+
+    flushFrame(): void {
+        const callbacks = this.frames.splice(0);
+        for (const callback of callbacks) {
+            callback();
+        }
+    }
+
+    hasPosted(type: string, version: number): boolean {
+        return this.posted.some(message => isRecord(message) && message.type === type && message.version === version);
+    }
+
+    svgBounds(): Bounds {
+        assert.ok(this.svg);
+        return this.svg.getBoundingClientRect();
+    }
+
+    contentPoint(anchor: {clientX: number; clientY: number}): Point {
+        const bounds = this.svgBounds();
+        return {x: (anchor.clientX - bounds.left) / (this.svg?.zoom ?? 1), y: (anchor.clientY - bounds.top) / (this.svg?.zoom ?? 1)};
+    }
+}
+
+class FakeElement {
+    readonly attributes = new Map<string, string>();
+    readonly listeners = new Map<string, (event: never) => void>();
+    textContent = '';
+    replaceChildren: (child: unknown) => void = () => undefined;
+
+    addEventListener(type: string, listener: (event: never) => void, options?: {passive?: boolean}): void {
+        this.listeners.set(type, listener);
+        this.onWheelOptions?.(options);
+    }
+
+    onWheelOptions?: (options?: {passive?: boolean}) => void;
+
+    fire(type: string, event: unknown): void {
+        this.listeners.get(type)?.(event as never);
+    }
+
+    setAttribute(name: string, value: string): void {
+        this.attributes.set(name, value);
+    }
+}
+
+class FakeViewport extends FakeElement {
+    readonly clientWidth = 1000;
+    readonly clientHeight = 800;
+    currentSvg: () => FakeSvg | undefined = () => undefined;
+    private left = 0;
+    private top = 0;
+
+    get maximumLeft(): number {
+        return Math.max(0, this.scrollWidth - this.clientWidth);
+    }
+
+    get maximumTop(): number {
+        return Math.max(0, this.scrollHeight - this.clientHeight);
+    }
+
+    get scrollWidth(): number {
+        return Math.max(this.clientWidth, (this.currentSvg()?.width ?? 0) + 24);
+    }
+
+    get scrollHeight(): number {
+        return Math.max(this.clientHeight, (this.currentSvg()?.height ?? 0) + 24);
+    }
+
+    get scrollLeft(): number {
+        return this.left;
+    }
+
+    set scrollLeft(value: number) {
+        this.left = Math.min(this.maximumLeft, Math.max(0, value));
+    }
+
+    get scrollTop(): number {
+        return this.top;
+    }
+
+    set scrollTop(value: number) {
+        this.top = Math.min(this.maximumTop, Math.max(0, value));
+    }
+
+    getBoundingClientRect(): Bounds {
+        return {left: 100, top: 50, width: this.clientWidth, height: this.clientHeight, right: 1100, bottom: 850};
+    }
+}
+
+class FakeSvg extends FakeElement {
+    viewport?: FakeViewport;
+    width: number;
+    height: number;
+    readonly baseWidth: number;
+    readonly baseHeight: number;
+    readonly localName = 'svg';
+    readonly namespaceURI = 'http://www.w3.org/2000/svg';
+
+    constructor(width: number, height: number) {
+        super();
+        this.width = this.baseWidth = width;
+        this.height = this.baseHeight = height;
+    }
+
+    get zoom(): number {
+        return this.width / this.baseWidth;
+    }
+
+    getAttribute(name: string): string | null {
+        return name === 'width' ? String(this.width) : name === 'height' ? String(this.height) : null;
+    }
+
+    override setAttribute(name: string, value: string): void {
+        super.setAttribute(name, value);
+        if (name === 'width') {
+            this.width = Number(value);
+        } else if (name === 'height') {
+            this.height = Number(value);
+        }
+    }
+
+    querySelectorAll(): FakeElement[] {
+        return [];
+    }
+
+    getBoundingClientRect(): Bounds {
+        assert.ok(this.viewport);
+        const viewportBounds = this.viewport.getBoundingClientRect();
+        const availableWidth = this.viewport.clientWidth - 24;
+        const availableHeight = this.viewport.clientHeight - 24;
+        const left = viewportBounds.left + 12 + Math.max(0, (availableWidth - this.width) / 2) - this.viewport.scrollLeft;
+        const top = viewportBounds.top + 12 + Math.max(0, (availableHeight - this.height) / 2) - this.viewport.scrollTop;
+        return {left, top, width: this.width, height: this.height, right: left + this.width, bottom: top + this.height};
+    }
+}
+
+class FakeDomParser {
+    parseFromString(svgText: string, mediaType: string): FakeXmlDocument {
+        assert.equal(mediaType, 'image/svg+xml');
+        const width = Number(svgText.match(/width="([^"]+)"/)?.[1] ?? 0);
+        const height = Number(svgText.match(/height="([^"]+)"/)?.[1] ?? 0);
+        return new FakeXmlDocument(new FakeSvg(width, height), svgText.includes('<parsererror'));
+    }
+}
+
+class FakeXmlDocument {
+    constructor(
+        readonly documentElement: FakeSvg,
+        private readonly parserError: boolean,
+    ) {}
+
+    getElementsByTagName(name: string): unknown[] {
+        return name === 'parsererror' && this.parserError ? [{}] : [];
+    }
+}
+
+interface Bounds {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    right: number;
+    bottom: number;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null;
+}
diff --git a/src/test/graphicalViewWebviewController.test.ts b/src/test/graphicalViewWebviewController.test.ts
index 074027e..74b1c3a 100644
--- a/src/test/graphicalViewWebviewController.test.ts
+++ b/src/test/graphicalViewWebviewController.test.ts
@@ -83,7 +83,13 @@ suite('Graphical View webview controller', () => {
             {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});
+        assert.deepEqual(JSON.parse(JSON.stringify(state.value)), {
+            schemaVersion: 1,
+            zoom: 0.44363636363636366,
+            scrollLeft: 0,
+            scrollTop: 0,
+            viewportInitialized: true,
+        });
     });
 
     test('applies only allow-listed status kinds and preserves complete status text safely', () => {
diff --git a/src/test/graphicalViewWebviewLifecycle.test.ts b/src/test/graphicalViewWebviewLifecycle.test.ts
index 002901d..94d8897 100644
--- a/src/test/graphicalViewWebviewLifecycle.test.ts
+++ b/src/test/graphicalViewWebviewLifecycle.test.ts
@@ -26,7 +26,9 @@ suite('GraphicalView real webview lifecycle', function () {
         );
         const messages: unknown[] = [];
         const subscription = panel.webview.onDidReceiveMessage(message => messages.push(message));
-        const shell = createGraphicalViewShell(panel.webview, extensionUri);
+        const shell = instrumentShell(createGraphicalViewShell(panel.webview, extensionUri));
+        const themeConfiguration = vscode.workspace.getConfiguration('workbench');
+        const originalTheme = themeConfiguration.get<string>('colorTheme');
 
         try {
             panel.webview.html = shell;
@@ -35,6 +37,102 @@ suite('GraphicalView real webview lifecycle', function () {
             await waitFor(() => hasMessage(messages, 'rendered', 1), 'initial secure render');
             assert.equal(hasMessage(messages, 'renderError', 1), false);
 
+            const initial = await probe(panel, messages, 'snapshot');
+            assert.equal(initial.state.viewportInitialized, true);
+            const expectedFit = Math.max(
+                0.25,
+                Math.min(4, Math.min((initial.viewport.clientWidth - 24) / 2200, (initial.viewport.clientHeight - 24) / 1600)),
+            );
+            assert.ok(Math.abs(initial.state.zoom - expectedFit) < 0.000_001);
+            assertCenteredFreeAxes(initial);
+
+            await panel.webview.postMessage({type: 'render', version: 101, svg: sizedSvg(10_000, 10_000)});
+            await waitFor(() => hasMessage(messages, 'rendered', 101), 'oversized render');
+            await probe(panel, messages, 'fit');
+            const oversizedStart = await probe(panel, messages, 'snapshot');
+            assert.equal(oversizedStart.state.zoom, 0.25);
+            assert.ok(oversizedStart.viewport.maximumLeft > 0);
+            assert.ok(oversizedStart.viewport.maximumTop > 0);
+            assert.ok(oversizedStart.svg.left >= oversizedStart.viewport.left);
+            assert.ok(oversizedStart.svg.top >= oversizedStart.viewport.top);
+            const oversizedEnd = await probe(panel, messages, 'scrollEnd');
+            assert.ok(oversizedEnd.svg.right <= oversizedEnd.viewport.right + 1);
+            assert.ok(oversizedEnd.svg.bottom <= oversizedEnd.viewport.bottom + 1);
+
+            await panel.webview.postMessage({type: 'render', version: 102, svg: sizedSvg(2200, 1600)});
+            await waitFor(() => hasMessage(messages, 'rendered', 102), 'anchor fixture render');
+            await probe(panel, messages, 'fit');
+            const ordinary = await probe(panel, messages, 'ordinaryWheel');
+            assert.equal(ordinary.prevented, false);
+            assert.equal(ordinary.beforeZoom, ordinary.afterZoom);
+
+            const wheel = await probe(panel, messages, 'modifierWheel');
+            assert.equal(wheel.prevented, true);
+            assert.ok(wheel.afterZoom > wheel.beforeZoom);
+            assert.ok(
+                Math.abs(wheel.beforePoint.x - wheel.afterPoint.x) * wheel.afterZoom < 0.5,
+                `wheel x anchor drift: ${JSON.stringify(wheel)}`,
+            );
+            assert.ok(
+                Math.abs(wheel.beforePoint.y - wheel.afterPoint.y) * wheel.afterZoom < 0.5,
+                `wheel y anchor drift: ${JSON.stringify(wheel)}`,
+            );
+
+            const metaPinch = await probe(panel, messages, 'metaPinch');
+            assert.equal(metaPinch.prevented, true);
+            assert.ok(metaPinch.afterZoom < metaPinch.beforeZoom);
+            const rapidWheel = await probe(panel, messages, 'rapidWheel');
+            assert.equal(rapidWheel.prevented, true);
+            assert.ok(rapidWheel.afterZoom > rapidWheel.beforeZoom);
+            assert.ok(rapidWheel.afterZoom / rapidWheel.beforeZoom <= Math.exp(0.2) + 0.000_001);
+
+            const button = await probe(panel, messages, 'zoomIn');
+            assert.ok(button.afterZoom > button.beforeZoom);
+            assert.ok(Math.abs(button.beforePoint.x - button.afterPoint.x) * button.afterZoom < 0.5);
+            assert.ok(Math.abs(button.beforePoint.y - button.afterPoint.y) * button.afterZoom < 0.5);
+            const reset = await probe(panel, messages, 'reset');
+            assert.equal(reset.state.zoom, 1);
+
+            const resizedFit = await probe(panel, messages, 'resizeAndFit');
+            const resizedExpected = Math.max(
+                0.25,
+                Math.min(4, Math.min((resizedFit.viewport.clientWidth - 24) / 2200, (resizedFit.viewport.clientHeight - 24) / 1600)),
+            );
+            assert.ok(Math.abs(resizedFit.state.zoom - resizedExpected) < 0.000_001);
+            assertCenteredFreeAxes(resizedFit);
+            assert.equal(resizedFit.styles.overflow, 'auto');
+            assert.notEqual(resizedFit.styles.buttonDisplay, 'none');
+            assert.notEqual(resizedFit.styles.diagramDisplay, 'none');
+
+            await panel.webview.postMessage({type: 'render', version: 103, svg: sizedSvg(200, 1600)});
+            await waitFor(() => hasMessage(messages, 'rendered', 103), 'horizontal free-space fixture');
+            await probe(panel, messages, 'fit');
+            const horizontallyCentered = await probe(panel, messages, 'snapshot');
+            assert.ok(horizontallyCentered.viewport.clientWidth - 24 - horizontallyCentered.svg.width > 0.5);
+            assertCenteredFreeAxes(horizontallyCentered);
+
+            await panel.webview.postMessage({type: 'render', version: 104, svg: sizedSvg(2200, 200)});
+            await waitFor(() => hasMessage(messages, 'rendered', 104), 'vertical free-space fixture');
+            await probe(panel, messages, 'fit');
+            const verticallyCentered = await probe(panel, messages, 'snapshot');
+            assert.ok(verticallyCentered.viewport.clientHeight - 24 - verticallyCentered.svg.height > 0.5);
+            assertCenteredFreeAxes(verticallyCentered);
+
+            for (const theme of ['Default Light Modern', 'Default Dark Modern', 'Default High Contrast']) {
+                await themeConfiguration.update('colorTheme', theme, vscode.ConfigurationTarget.Global);
+                const themed = await probe(panel, messages, 'snapshot');
+                assert.notEqual(themed.styles.bodyColor, '');
+                assert.notEqual(themed.styles.bodyBackground, 'rgba(0, 0, 0, 0)');
+                assert.notEqual(themed.styles.buttonDisplay, 'none');
+                assert.notEqual(themed.styles.diagramDisplay, 'none');
+            }
+
+            await probe(panel, messages, 'clearResize');
+            await panel.webview.postMessage({type: 'render', version: 105, svg: graphperSvg(HEADER_MARKER)});
+            await waitFor(() => hasMessage(messages, 'rendered', 105), 'restoration fixture');
+            await probe(panel, messages, 'reset');
+            const restorationState = (await probe(panel, messages, 'zoomIn')).state;
+
             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');
@@ -45,15 +143,34 @@ suite('GraphicalView real webview lifecycle', function () {
             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(HEADER_MARKER)});
-            await waitFor(() => countMessages(messages, 'rendered') >= 2, 'retained result rehydration');
+            // The host cannot inspect webview state directly. Reload a fresh test-instrumented shell only after
+            // proving that production reveal did not assign HTML or render; VS Code must retain getState() data.
+            const readyBeforeInstrumentedReload = countMessages(messages, 'ready');
+            panel.webview.html = instrumentShell(createGraphicalViewShell(panel.webview, extensionUri));
+            await waitFor(() => countMessages(messages, 'ready') > readyBeforeInstrumentedReload, 'instrumented state reload');
+            const rendersBeforeRedelivery = countMessages(messages, 'rendered');
+            const snapshotsBeforeRedelivery = countMessages(messages, 'acceptanceAutoSnapshot');
+            await panel.webview.postMessage({type: 'render', version: 105, svg: graphperSvg(HEADER_MARKER)});
+            await waitFor(() => countMessages(messages, 'rendered') > rendersBeforeRedelivery, 'retained result rehydration');
+            await waitFor(
+                () => countMessages(messages, 'acceptanceAutoSnapshot') > snapshotsBeforeRedelivery,
+                'rehydrated viewport snapshot',
+            );
+            const rehydrated = latestMessage(messages, 'acceptanceAutoSnapshot') as ViewportProbeResult;
+            assert.equal(rehydrated.state.zoom, restorationState.zoom);
+            assert.equal(rehydrated.state.scrollLeft, restorationState.scrollLeft);
+            assert.equal(rehydrated.state.scrollTop, restorationState.scrollTop);
+            assert.equal(rehydrated.state.viewportInitialized, true);
             await panel.webview.postMessage({
                 type: 'render',
                 version: 2,
                 svg: multilingualSvg(GERMAN_MARKER, ENGLISH_MARKER),
             });
             await waitFor(() => hasMessage(messages, 'rendered', 2), 'multilingual replacement render');
-            assert.equal(messages.some(message => isRecord(message) && message.type === 'renderError'), false);
+            assert.equal(
+                messages.some(message => isRecord(message) && message.type === 'renderError'),
+                false,
+            );
 
             await panel.webview.postMessage({
                 type: 'render',
@@ -82,6 +199,7 @@ suite('GraphicalView real webview lifecycle', function () {
         } finally {
             subscription.dispose();
             panel.dispose();
+            await themeConfiguration.update('colorTheme', originalTheme, vscode.ConfigurationTarget.Global);
         }
     });
 });
@@ -107,6 +225,146 @@ function multilingualSvg(germanMarker: string, englishMarker: string): string {
 </svg>`;
 }
 
+function sizedSvg(width: number, height: number): string {
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}"><path d="M0 0 L${width} ${height}" stroke="#000000"/></svg>`;
+}
+
+function instrumentShell(shell: string): string {
+    const scriptMatch = shell.match(/(<script nonce="([^"]+)" src="[^"]+"><\/script>)/);
+    assert.ok(scriptMatch);
+    const [, controllerScript, nonce] = scriptMatch;
+    const bootstrap = `<script nonce="${nonce}">globalThis.__gvTestApi=acquireVsCodeApi();globalThis.acquireVsCodeApi=()=>globalThis.__gvTestApi;</script>`;
+    const probeScript = `<script nonce="${nonce}">
+const testApi=globalThis.__gvTestApi;
+const nextFrames=(count,callback)=>count<=0?callback():requestAnimationFrame(()=>nextFrames(count-1,callback));
+const measure=()=>{
+  const viewport=document.querySelector('#viewport');
+  const svg=document.querySelector('#diagram svg');
+  const button=document.querySelector('#zoom-in');
+  const viewportBounds=viewport.getBoundingClientRect();
+  const svgBounds=svg.getBoundingClientRect();
+  const state=testApi.getState();
+  return {
+    state,
+    viewport:{left:viewportBounds.left,top:viewportBounds.top,right:viewportBounds.right,bottom:viewportBounds.bottom,clientWidth:viewport.clientWidth,clientHeight:viewport.clientHeight,maximumLeft:viewport.scrollWidth-viewport.clientWidth,maximumTop:viewport.scrollHeight-viewport.clientHeight},
+    svg:{left:svgBounds.left,top:svgBounds.top,right:svgBounds.right,bottom:svgBounds.bottom,width:svgBounds.width,height:svgBounds.height},
+    styles:{overflow:getComputedStyle(viewport).overflow,buttonDisplay:getComputedStyle(button).display,diagramDisplay:getComputedStyle(svg).display,bodyColor:getComputedStyle(document.body).color,bodyBackground:getComputedStyle(document.body).backgroundColor}
+  };
+};
+const center=()=>{const viewport=document.querySelector('#viewport');const bounds=viewport.getBoundingClientRect();return {x:bounds.left+viewport.clientWidth/2,y:bounds.top+viewport.clientHeight/2};};
+const point=(position)=>{const snapshot=measure();return {x:(position.x-snapshot.svg.left)/snapshot.state.zoom,y:(position.y-snapshot.svg.top)/snapshot.state.zoom};};
+addEventListener('message',event=>{
+  const command=event.data;
+  if(command&&command.type==='render'){
+    nextFrames(3,()=>testApi.postMessage({type:'acceptanceAutoSnapshot',version:command.version,...measure()}));return;
+  }
+  if(!command||command.type!=='acceptanceProbe')return;
+  const viewport=document.querySelector('#viewport');
+  const finish=extra=>nextFrames(3,()=>testApi.postMessage({type:'acceptanceResult',id:command.id,...measure(),...extra}));
+  if(command.action==='snapshot'){finish({});return;}
+  if(command.action==='fit'){document.querySelector('#zoom-fit').click();finish({});return;}
+  if(command.action==='scrollEnd'){
+    viewport.scrollLeft=viewport.scrollWidth;viewport.scrollTop=viewport.scrollHeight;
+    testApi.postMessage({type:'acceptanceResult',id:command.id,...measure()});return;
+  }
+  if(command.action==='ordinaryWheel'){
+    const position=center();const beforeZoom=testApi.getState().zoom;
+    const event=new WheelEvent('wheel',{deltaY:40,clientX:position.x,clientY:position.y,bubbles:true,cancelable:true});
+    const dispatched=viewport.dispatchEvent(event);finish({prevented:!dispatched,beforeZoom,afterZoom:testApi.getState().zoom});return;
+  }
+  if(command.action==='modifierWheel'){
+    const position={x:viewport.getBoundingClientRect().left+viewport.clientWidth*.37,y:viewport.getBoundingClientRect().top+viewport.clientHeight*.43};
+    const beforePoint=point(position);const beforeZoom=testApi.getState().zoom;
+    const event=new WheelEvent('wheel',{deltaY:-60,ctrlKey:true,clientX:position.x,clientY:position.y,bubbles:true,cancelable:true});
+    const dispatched=viewport.dispatchEvent(event);
+    nextFrames(3,()=>testApi.postMessage({type:'acceptanceResult',id:command.id,...measure(),prevented:!dispatched,beforeZoom,afterZoom:testApi.getState().zoom,beforePoint,afterPoint:point(position)}));return;
+  }
+  if(command.action==='metaPinch'){
+    const position=center();const beforeZoom=testApi.getState().zoom;
+    const event=new WheelEvent('wheel',{deltaY:40,metaKey:true,clientX:position.x,clientY:position.y,bubbles:true,cancelable:true});
+    const dispatched=viewport.dispatchEvent(event);
+    nextFrames(3,()=>testApi.postMessage({type:'acceptanceResult',id:command.id,...measure(),prevented:!dispatched,beforeZoom,afterZoom:testApi.getState().zoom}));return;
+  }
+  if(command.action==='rapidWheel'){
+    const position=center();const beforeZoom=testApi.getState().zoom;let prevented=true;
+    for(let index=0;index<5;index++){
+      const event=new WheelEvent('wheel',{deltaY:-40,ctrlKey:true,clientX:position.x,clientY:position.y,bubbles:true,cancelable:true});
+      prevented=prevented&&!viewport.dispatchEvent(event);
+    }
+    nextFrames(3,()=>testApi.postMessage({type:'acceptanceResult',id:command.id,...measure(),prevented,beforeZoom,afterZoom:testApi.getState().zoom}));return;
+  }
+  if(command.action==='zoomIn'){
+    const position=center();const beforePoint=point(position);const beforeZoom=testApi.getState().zoom;
+    document.querySelector('#zoom-in').click();
+    nextFrames(3,()=>testApi.postMessage({type:'acceptanceResult',id:command.id,...measure(),beforeZoom,afterZoom:testApi.getState().zoom,beforePoint,afterPoint:point(position)}));return;
+  }
+  if(command.action==='reset'){document.querySelector('#zoom-reset').click();finish({});return;}
+  if(command.action==='clearResize'){viewport.style.flex='';viewport.style.width='';viewport.style.height='';finish({});return;}
+  if(command.action==='resizeAndFit'){viewport.style.flex='none';viewport.style.width='640px';viewport.style.height='420px';document.querySelector('#zoom-fit').click();finish({});}
+});
+</script>`;
+    return shell.replace(controllerScript, `${bootstrap}${controllerScript}${probeScript}`);
+}
+
+let probeId = 0;
+
+async function probe(panel: vscode.WebviewPanel, messages: readonly unknown[], action: string): Promise<ViewportProbeResult> {
+    const id = ++probeId;
+    const attempts = ['snapshot', 'fit', 'clearResize'].includes(action) ? 3 : 1;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        assert.equal(await panel.webview.postMessage({type: 'acceptanceProbe', id, action}), true);
+        try {
+            await waitFor(
+                () => messages.some(message => isRecord(message) && message.type === 'acceptanceResult' && message.id === id),
+                `viewport probe ${action}`,
+                5_000,
+            );
+            return messages.find(
+                (message): message is ViewportProbeResult => isRecord(message) && message.type === 'acceptanceResult' && message.id === id,
+            ) as ViewportProbeResult;
+        } catch (error) {
+            if (attempt === attempts - 1) {
+                throw error;
+            }
+        }
+    }
+    throw new Error(`Viewport probe ${action} did not complete.`);
+}
+
+function assertCenteredFreeAxes(result: ViewportProbeResult): void {
+    const horizontalFreeSpace = result.viewport.clientWidth - 24 - result.svg.width;
+    if (horizontalFreeSpace > 0.5) {
+        assert.ok(Math.abs(result.svg.left - (result.viewport.left + 12 + horizontalFreeSpace / 2)) < 1);
+    }
+    const verticalFreeSpace = result.viewport.clientHeight - 24 - result.svg.height;
+    if (verticalFreeSpace > 0.5) {
+        assert.ok(Math.abs(result.svg.top - (result.viewport.top + 12 + verticalFreeSpace / 2)) < 1);
+    }
+}
+
+interface ViewportProbeResult {
+    type: 'acceptanceResult';
+    id: number;
+    state: {zoom: number; scrollLeft: number; scrollTop: number; viewportInitialized: boolean};
+    viewport: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+        clientWidth: number;
+        clientHeight: number;
+        maximumLeft: number;
+        maximumTop: number;
+    };
+    svg: {left: number; top: number; right: number; bottom: number; width: number; height: number};
+    styles: {overflow: string; buttonDisplay: string; diagramDisplay: string; bodyColor: string; bodyBackground: string};
+    prevented: boolean;
+    beforeZoom: number;
+    afterZoom: number;
+    beforePoint: {x: number; y: number};
+    afterPoint: {x: number; y: number};
+}
+
 async function waitFor(probe: () => boolean, description: string, timeoutMs = 20_000): Promise<void> {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
@@ -126,6 +384,10 @@ function hasMessage(messages: readonly unknown[], type: string, version: number)
     return messages.some(message => isRecord(message) && message.type === type && message.version === version);
 }
 
+function latestMessage(messages: readonly unknown[], type: string): unknown {
+    return [...messages].reverse().find(message => isRecord(message) && message.type === type);
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
     return typeof value === 'object' && value !== null;
 }
diff --git a/src/webview/webview.css b/src/webview/webview.css
index 5feda8f..8c10d1d 100644
--- a/src/webview/webview.css
+++ b/src/webview/webview.css
@@ -12,8 +12,8 @@
  */
 
 @font-face {
-    font-family: "Roboto Condensed";
-    src: url("./RobotoCondensed-Regular.ttf") format("truetype");
+    font-family: 'Roboto Condensed';
+    src: url('./RobotoCondensed-Regular.ttf') format('truetype');
     font-style: normal;
     font-weight: 400;
 }
@@ -135,11 +135,11 @@ body {
     border-radius: 50%;
 }
 
-#status[data-kind="ready"] #status-indicator {
+#status[data-kind='ready'] #status-indicator {
     background: var(--vscode-testing-iconPassed, var(--vscode-foreground));
 }
 
-#status[data-kind="loading"] #status-indicator {
+#status[data-kind='loading'] #status-indicator {
     width: 0.8rem;
     height: 0.8rem;
     border: 2px solid var(--vscode-panel-border);
@@ -147,9 +147,9 @@ body {
     animation: status-spin 0.8s linear infinite;
 }
 
-#status[data-kind="stale"],
-#status[data-kind="unsupported"],
-#status[data-kind="disconnected"] {
+#status[data-kind='stale'],
+#status[data-kind='unsupported'],
+#status[data-kind='disconnected'] {
     flex: 1 0 100%;
     order: 2;
     box-sizing: border-box;
@@ -161,32 +161,32 @@ body {
     border-left-width: 3px;
 }
 
-#status[data-kind="stale"] #status-indicator,
-#status[data-kind="unsupported"] #status-indicator,
-#status[data-kind="disconnected"] #status-indicator {
+#status[data-kind='stale'] #status-indicator,
+#status[data-kind='unsupported'] #status-indicator,
+#status[data-kind='disconnected'] #status-indicator {
     width: auto;
     height: auto;
     border-radius: 0;
 }
 
-#status[data-kind="stale"],
-#status[data-kind="unsupported"] {
+#status[data-kind='stale'],
+#status[data-kind='unsupported'] {
     border-left-color: var(--vscode-notificationsWarningIcon-foreground, var(--vscode-foreground));
 }
 
-#status[data-kind="stale"] #status-indicator::before,
-#status[data-kind="unsupported"] #status-indicator::before {
+#status[data-kind='stale'] #status-indicator::before,
+#status[data-kind='unsupported'] #status-indicator::before {
     color: var(--vscode-notificationsWarningIcon-foreground, var(--vscode-foreground));
-    content: "⚠";
+    content: '⚠';
 }
 
-#status[data-kind="disconnected"] {
+#status[data-kind='disconnected'] {
     border-left-color: var(--vscode-notificationsErrorIcon-foreground, var(--vscode-foreground));
 }
 
-#status[data-kind="disconnected"] #status-indicator::before {
+#status[data-kind='disconnected'] #status-indicator::before {
     color: var(--vscode-notificationsErrorIcon-foreground, var(--vscode-foreground));
-    content: "×";
+    content: '×';
     font-weight: 700;
 }
 
@@ -202,7 +202,7 @@ body {
 }
 
 @media (prefers-reduced-motion: reduce) {
-    #status[data-kind="loading"] #status-indicator {
+    #status[data-kind='loading'] #status-indicator {
         animation: none;
     }
 }
@@ -213,8 +213,8 @@ body {
         justify-content: space-between;
     }
 
-    #status[data-kind="ready"],
-    #status[data-kind="loading"] {
+    #status[data-kind='ready'],
+    #status[data-kind='loading'] {
         flex: 1 1 100%;
         max-width: none;
         margin-left: 0;
@@ -230,23 +230,33 @@ body {
     padding: 0.75rem;
 }
 
+#diagram {
+    display: flex;
+    box-sizing: border-box;
+    width: max-content;
+    min-width: 100%;
+    min-height: 100%;
+}
+
 #diagram svg {
     display: block;
+    flex: none;
+    margin: auto;
 }
 
-#diagram svg g[id^="gv-header-"],
-#diagram svg g[id^="gv-attribute-"] {
+#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 {
+#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 {
+#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 dec58de..7fd974e 100644
--- a/src/webview/webview.js
+++ b/src/webview/webview.js
@@ -17,6 +17,11 @@
     const MIN_ZOOM = 0.25;
     const MAX_ZOOM = 4;
     const ZOOM_FACTOR = 1.2;
+    const VIEWPORT_PADDING = 24;
+    const WHEEL_LINE_PIXELS = 16;
+    const MAX_WHEEL_DELTA = 100;
+    const WHEEL_ZOOM_SENSITIVITY = 0.002;
+    const WHEEL_GESTURE_IDLE_MS = 160;
     const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
     const MARKER_PATTERN = /^gv-(?:header|attribute)-[a-z0-9]{16,32}$/;
     const POSITIVE_DIMENSION_PATTERN = /^(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:pt)?$/;
@@ -31,18 +36,38 @@
     let currentSvg = null;
     let baseWidth = 0;
     let baseHeight = 0;
-    let restoreGeneration = 0;
+    let layoutGeneration = 0;
+    let wheelFrame = null;
+    let pendingWheelDelta = 0;
+    let pendingWheelAnchor = null;
+    let wheelGeneration = 0;
+    let wheelGestureAnchor = null;
+    let wheelGestureTimeout = null;
+    let pendingRenderedVersion = null;
+    let pendingViewportInitialization = false;
+    let viewportLayoutPending = false;
+    let pendingAnchorCorrection = null;
     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: 1, scrollLeft: 0, scrollTop: 0, viewportInitialized: false};
         }
+        const legacyStateIsValid =
+            !Object.hasOwn(candidate, 'viewportInitialized') &&
+            Number.isFinite(candidate.zoom) &&
+            candidate.zoom >= MIN_ZOOM &&
+            candidate.zoom <= MAX_ZOOM &&
+            Number.isFinite(candidate.scrollLeft) &&
+            candidate.scrollLeft >= 0 &&
+            Number.isFinite(candidate.scrollTop) &&
+            candidate.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,
+            viewportInitialized: typeof candidate.viewportInitialized === 'boolean' ? candidate.viewportInitialized : legacyStateIsValid,
         };
     }
 
@@ -56,6 +81,7 @@
             zoom: state.zoom,
             scrollLeft: Math.max(0, viewport.scrollLeft),
             scrollTop: Math.max(0, viewport.scrollTop),
+            viewportInitialized: state.viewportInitialized,
         };
         vscode.setState(state);
         updateZoomLabel();
@@ -128,51 +154,167 @@
         updateZoomLabel();
     }
 
-    function restoreViewport(version, notifyRendered) {
-        const generation = ++restoreGeneration;
-        afterLayout(() => {
-            if (generation !== restoreGeneration || version !== currentVersion) {
-                return;
-            }
+    function restoreViewport(version) {
+        viewportLayoutPending = true;
+        pendingAnchorCorrection = null;
+        afterLayout(version, () => {
             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});
-            }
+            viewportLayoutPending = false;
+            completeLayout(version);
         });
     }
 
-    function afterLayout(callback) {
+    function completeLayout(version) {
+        if (pendingRenderedVersion === version && pendingViewportInitialization) {
+            state = {...state, viewportInitialized: true};
+        }
+        persistState();
+        if (pendingRenderedVersion === version) {
+            pendingRenderedVersion = null;
+            pendingViewportInitialization = false;
+            vscode.postMessage({type: 'rendered', version});
+        }
+    }
+
+    function afterLayout(version, callback) {
+        const generation = ++layoutGeneration;
         let completed = false;
         const complete = () => {
-            if (!completed) {
-                completed = true;
+            if (completed) {
+                return;
+            }
+            completed = true;
+            if (generation === layoutGeneration && version === currentVersion) {
                 callback();
             }
         };
-        requestAnimationFrame(() => requestAnimationFrame(complete));
+        requestAnimationFrame(complete);
         setTimeout(complete, 100);
     }
 
-    function setZoom(zoom) {
-        captureViewport();
-        state = {...state, zoom: clamp(zoom, MIN_ZOOM, MAX_ZOOM)};
+    function viewportCenter() {
+        const bounds = viewport.getBoundingClientRect();
+        return {clientX: bounds.left + viewport.clientWidth / 2, clientY: bounds.top + viewport.clientHeight / 2};
+    }
+
+    function zoomAround(zoom, anchor) {
+        if (!currentSvg) {
+            return false;
+        }
+        const nextZoom = clamp(zoom, MIN_ZOOM, MAX_ZOOM);
+        if (nextZoom === state.zoom) {
+            return false;
+        }
+        const version = currentVersion;
+        applyPendingAnchorCorrection(version);
+        layoutGeneration++;
+        const svgBounds = currentSvg.getBoundingClientRect();
+        const anchorRatioX = svgBounds.width > 0 ? (anchor.clientX - svgBounds.left) / svgBounds.width : 0;
+        const anchorRatioY = svgBounds.height > 0 ? (anchor.clientY - svgBounds.top) / svgBounds.height : 0;
+        state = {...state, zoom: nextZoom};
         applyZoom();
-        restoreViewport(currentVersion, false);
+        viewportLayoutPending = true;
+        pendingAnchorCorrection = {version, anchor, anchorRatioX, anchorRatioY};
+        applyPendingAnchorCorrection(version);
+        completeLayout(version);
+        return true;
+    }
+
+    function applyPendingAnchorCorrection(version) {
+        const correction = pendingAnchorCorrection;
+        if (!correction || correction.version !== version || version !== currentVersion || !currentSvg) {
+            return;
+        }
+        const updatedBounds = currentSvg.getBoundingClientRect();
+        viewport.scrollLeft += updatedBounds.left + correction.anchorRatioX * updatedBounds.width - correction.anchor.clientX;
+        viewport.scrollTop += updatedBounds.top + correction.anchorRatioY * updatedBounds.height - correction.anchor.clientY;
+        captureViewport();
+        pendingAnchorCorrection = null;
+        viewportLayoutPending = 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);
+        cancelPendingWheel();
+        const availableWidth = Math.max(1, viewport.clientWidth - VIEWPORT_PADDING);
+        const availableHeight = Math.max(1, viewport.clientHeight - VIEWPORT_PADDING);
+        state = {
+            ...state,
+            zoom: clamp(Math.min(availableWidth / baseWidth, availableHeight / baseHeight), MIN_ZOOM, MAX_ZOOM),
+            scrollLeft: 0,
+            scrollTop: 0,
+        };
+        applyZoom();
+        restoreViewport(currentVersion);
+    }
+
+    function normalizeWheelDelta(event) {
+        const unit = event.deltaMode === 1 ? WHEEL_LINE_PIXELS : event.deltaMode === 2 ? Math.max(1, viewport.clientHeight) : 1;
+        return clamp(event.deltaY * unit, -MAX_WHEEL_DELTA, MAX_WHEEL_DELTA);
+    }
+
+    function handleWheel(event) {
+        if (!currentSvg || (!event.ctrlKey && !event.metaKey)) {
+            return;
+        }
+        event.preventDefault();
+        const delta = normalizeWheelDelta(event);
+        const proposedZoom = clamp(state.zoom * Math.exp(-delta * WHEEL_ZOOM_SENSITIVITY), MIN_ZOOM, MAX_ZOOM);
+        if (proposedZoom === state.zoom && pendingWheelDelta === 0) {
+            return;
+        }
+        if (!wheelGestureAnchor) {
+            wheelGestureAnchor = {clientX: event.clientX, clientY: event.clientY};
+        }
+        if (wheelGestureTimeout !== null) {
+            clearTimeout(wheelGestureTimeout);
+        }
+        wheelGestureTimeout = setTimeout(() => {
+            wheelGestureAnchor = null;
+            wheelGestureTimeout = null;
+        }, WHEEL_GESTURE_IDLE_MS);
+        pendingWheelDelta = clamp(pendingWheelDelta + delta, -MAX_WHEEL_DELTA, MAX_WHEEL_DELTA);
+        pendingWheelAnchor = wheelGestureAnchor;
+        if (wheelFrame !== null) {
+            return;
+        }
+        const generation = ++wheelGeneration;
+        wheelFrame = requestAnimationFrame(() => {
+            if (generation !== wheelGeneration) {
+                return;
+            }
+            wheelFrame = null;
+            const accumulatedDelta = pendingWheelDelta;
+            const anchor = pendingWheelAnchor;
+            pendingWheelDelta = 0;
+            pendingWheelAnchor = null;
+            if (!anchor || accumulatedDelta === 0) {
+                return;
+            }
+            zoomAround(state.zoom * Math.exp(-accumulatedDelta * WHEEL_ZOOM_SENSITIVITY), anchor);
+        });
+    }
+
+    function cancelPendingWheel() {
+        wheelGeneration++;
+        if (wheelGestureTimeout !== null) {
+            clearTimeout(wheelGestureTimeout);
+        }
+        wheelFrame = null;
+        pendingWheelDelta = 0;
+        pendingWheelAnchor = null;
+        wheelGestureAnchor = null;
+        wheelGestureTimeout = null;
+    }
+
+    function toolbarZoom(zoom) {
+        cancelPendingWheel();
+        zoomAround(zoom, viewportCenter());
     }
 
     function isExactMessage(message, keys) {
@@ -195,19 +337,38 @@
         }
 
         try {
-            if (currentSvg) {
-                captureViewport();
-            }
             const parsedSvg = parseTrustedSvg(message.svg);
             const size = dimensions(parsedSvg);
+            if (currentSvg) {
+                applyPendingAnchorCorrection(currentVersion);
+                if (!viewportLayoutPending) {
+                    captureViewport();
+                }
+            }
             makeNavigationMarkersInteractive(parsedSvg);
+            cancelPendingWheel();
             diagram.replaceChildren(parsedSvg);
             currentSvg = parsedSvg;
             currentVersion = message.version;
             baseWidth = size.width;
             baseHeight = size.height;
-            applyZoom();
-            restoreViewport(currentVersion, true);
+            pendingRenderedVersion = currentVersion;
+            pendingViewportInitialization = !state.viewportInitialized;
+            if (state.viewportInitialized) {
+                applyZoom();
+                restoreViewport(currentVersion);
+            } else {
+                const availableWidth = Math.max(1, viewport.clientWidth - VIEWPORT_PADDING);
+                const availableHeight = Math.max(1, viewport.clientHeight - VIEWPORT_PADDING);
+                state = {
+                    ...state,
+                    zoom: clamp(Math.min(availableWidth / baseWidth, availableHeight / baseHeight), MIN_ZOOM, MAX_ZOOM),
+                    scrollLeft: 0,
+                    scrollTop: 0,
+                };
+                applyZoom();
+                restoreViewport(currentVersion);
+            }
         } catch (error) {
             updateStatus({
                 kind: 'stale',
@@ -218,6 +379,7 @@
     }
 
     viewport.addEventListener('scroll', persistState, {passive: true});
+    viewport.addEventListener('wheel', handleWheel, {passive: false});
     diagram.addEventListener('click', event => {
         activateNavigationTarget(event.target);
     });
@@ -235,9 +397,10 @@
             if (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');
+                group.setAttribute(
+                    'aria-label',
+                    group.id.startsWith('gv-attribute-') ? 'Navigate to attribute source statement' : 'Navigate to element definition',
+                );
             }
         }
     }
@@ -252,9 +415,9 @@
     }
 
     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-in').addEventListener('click', () => toolbarZoom(state.zoom * ZOOM_FACTOR));
+    document.querySelector('#zoom-out').addEventListener('click', () => toolbarZoom(state.zoom / ZOOM_FACTOR));
+    document.querySelector('#zoom-reset').addEventListener('click', () => toolbarZoom(1));
     document.querySelector('#zoom-fit').addEventListener('click', fitDiagram);
 
     window.addEventListener('message', event => {

From 9a8e971820617b91375e31a216f6fc220f175fb9 Mon Sep 17 00:00:00 2001
From: e-filchenko-bosh <FVI2FE@bosch.com>
Date: Thu, 17 Sep 2026 15:45:47 +0300
Subject: [PATCH 12/15] stabilize graphical viewport layout

---
 src/test/graphicalViewViewport.test.ts        | 49 +++++++++++++++++--
 .../graphicalViewWebviewLifecycle.test.ts     |  8 ++-
 src/webview/webview.js                        | 34 +++++++------
 3 files changed, 73 insertions(+), 18 deletions(-)

diff --git a/src/test/graphicalViewViewport.test.ts b/src/test/graphicalViewViewport.test.ts
index ead9448..a3c4315 100644
--- a/src/test/graphicalViewViewport.test.ts
+++ b/src/test/graphicalViewViewport.test.ts
@@ -32,6 +32,24 @@ suite('Graphical View viewport', () => {
         assert.equal(bounds.top, 50 + 12 + (776 - 1600 * (976 / 2200)) / 2);
     });
 
+    test('first Fit is recomputed after transient scrollbar geometry settles', () => {
+        const harness = new WebviewHarness();
+        harness.viewport.clientWidth = 985;
+        harness.viewport.clientHeight = 785;
+        harness.render(1, 2200, 1600);
+
+        assert.equal(harness.svg?.width, 961);
+        harness.viewport.clientWidth = 1000;
+        harness.viewport.clientHeight = 800;
+        harness.flushFrame();
+
+        assert.equal(harness.hasPosted('rendered', 1), false);
+        assert.equal(harness.svg?.width, 976);
+        harness.flushFrame();
+        assert.equal(harness.hasPosted('rendered', 1), true);
+        assert.equal(harness.savedState.zoom, 976 / 2200);
+    });
+
     test('rejected first SVG leaves Fit pending for the next valid render', () => {
         const harness = new WebviewHarness();
         harness.message({type: 'render', version: 1, svg: '<parsererror'});
@@ -182,6 +200,20 @@ suite('Graphical View viewport', () => {
         assert.ok(Math.abs(Number(line.savedState.zoom) - Math.exp(0.2)) < 0.000001);
     });
 
+    test('modifier wheel completes through the timeout fallback when an animation frame is throttled', () => {
+        const harness = new WebviewHarness(initializedState(1, 300, 200));
+        harness.render(1, 2000, 1200);
+        harness.flushFrame();
+
+        harness.wheel(wheelEvent(-100, () => undefined));
+        assert.equal(harness.savedState.zoom, 1);
+        harness.flushTimeout();
+
+        assert.ok(Number(harness.savedState.zoom) > 1);
+        harness.flushFrame();
+        assert.equal(harness.savedState.zoom, Math.exp(0.2));
+    });
+
     test('toolbar zoom and Reset preserve the viewport-center content point; Fit is distinct', () => {
         const harness = new WebviewHarness(initializedState(1, 500, 300));
         harness.render(1, 2000, 1400);
@@ -282,6 +314,7 @@ class WebviewHarness {
     readonly window = new FakeElement();
     readonly posted: unknown[] = [];
     readonly frames: Array<() => void> = [];
+    readonly timeouts: Array<() => void> = [];
     savedState: Record<string, unknown> = {};
     setStateCalls = 0;
     svg?: FakeSvg;
@@ -329,7 +362,10 @@ class WebviewHarness {
                 this.frames.push(callback);
                 return this.frames.length;
             },
-            setTimeout: () => 0,
+            setTimeout: (callback: () => void) => {
+                this.timeouts.push(callback);
+                return this.timeouts.length;
+            },
             clearTimeout: () => undefined,
             Number,
             Object,
@@ -369,6 +405,13 @@ class WebviewHarness {
         }
     }
 
+    flushTimeout(): void {
+        const callbacks = this.timeouts.splice(0);
+        for (const callback of callbacks) {
+            callback();
+        }
+    }
+
     hasPosted(type: string, version: number): boolean {
         return this.posted.some(message => isRecord(message) && message.type === type && message.version === version);
     }
@@ -407,8 +450,8 @@ class FakeElement {
 }
 
 class FakeViewport extends FakeElement {
-    readonly clientWidth = 1000;
-    readonly clientHeight = 800;
+    clientWidth = 1000;
+    clientHeight = 800;
     currentSvg: () => FakeSvg | undefined = () => undefined;
     private left = 0;
     private top = 0;
diff --git a/src/test/graphicalViewWebviewLifecycle.test.ts b/src/test/graphicalViewWebviewLifecycle.test.ts
index 94d8897..c084109 100644
--- a/src/test/graphicalViewWebviewLifecycle.test.ts
+++ b/src/test/graphicalViewWebviewLifecycle.test.ts
@@ -236,7 +236,13 @@ function instrumentShell(shell: string): string {
     const bootstrap = `<script nonce="${nonce}">globalThis.__gvTestApi=acquireVsCodeApi();globalThis.acquireVsCodeApi=()=>globalThis.__gvTestApi;</script>`;
     const probeScript = `<script nonce="${nonce}">
 const testApi=globalThis.__gvTestApi;
-const nextFrames=(count,callback)=>count<=0?callback():requestAnimationFrame(()=>nextFrames(count-1,callback));
+const afterFrame=callback=>{
+  let completed=false;
+  const complete=()=>{if(completed)return;completed=true;callback();};
+  requestAnimationFrame(complete);
+  setTimeout(complete,100);
+};
+const nextFrames=(count,callback)=>count<=0?callback():afterFrame(()=>nextFrames(count-1,callback));
 const measure=()=>{
   const viewport=document.querySelector('#viewport');
   const svg=document.querySelector('#diagram svg');
diff --git a/src/webview/webview.js b/src/webview/webview.js
index 7fd974e..ab4110b 100644
--- a/src/webview/webview.js
+++ b/src/webview/webview.js
@@ -154,10 +154,14 @@
         updateZoomLabel();
     }
 
-    function restoreViewport(version) {
+    function restoreViewport(version, fitMeasurement) {
         viewportLayoutPending = true;
         pendingAnchorCorrection = null;
         afterLayout(version, () => {
+            if (fitMeasurement && (fitMeasurement.width !== viewport.clientWidth || fitMeasurement.height !== viewport.clientHeight)) {
+                applyFit(version);
+                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);
@@ -241,6 +245,10 @@
             return;
         }
         cancelPendingWheel();
+        applyFit(currentVersion);
+    }
+
+    function applyFit(version) {
         const availableWidth = Math.max(1, viewport.clientWidth - VIEWPORT_PADDING);
         const availableHeight = Math.max(1, viewport.clientHeight - VIEWPORT_PADDING);
         state = {
@@ -250,7 +258,7 @@
             scrollTop: 0,
         };
         applyZoom();
-        restoreViewport(currentVersion);
+        restoreViewport(version, {width: viewport.clientWidth, height: viewport.clientHeight});
     }
 
     function normalizeWheelDelta(event) {
@@ -284,7 +292,12 @@
             return;
         }
         const generation = ++wheelGeneration;
-        wheelFrame = requestAnimationFrame(() => {
+        let completed = false;
+        const completeWheel = () => {
+            if (completed) {
+                return;
+            }
+            completed = true;
             if (generation !== wheelGeneration) {
                 return;
             }
@@ -297,7 +310,9 @@
                 return;
             }
             zoomAround(state.zoom * Math.exp(-accumulatedDelta * WHEEL_ZOOM_SENSITIVITY), anchor);
-        });
+        };
+        wheelFrame = requestAnimationFrame(completeWheel);
+        setTimeout(completeWheel, 100);
     }
 
     function cancelPendingWheel() {
@@ -358,16 +373,7 @@
                 applyZoom();
                 restoreViewport(currentVersion);
             } else {
-                const availableWidth = Math.max(1, viewport.clientWidth - VIEWPORT_PADDING);
-                const availableHeight = Math.max(1, viewport.clientHeight - VIEWPORT_PADDING);
-                state = {
-                    ...state,
-                    zoom: clamp(Math.min(availableWidth / baseWidth, availableHeight / baseHeight), MIN_ZOOM, MAX_ZOOM),
-                    scrollLeft: 0,
-                    scrollTop: 0,
-                };
-                applyZoom();
-                restoreViewport(currentVersion);
+                applyFit(currentVersion);
             }
         } catch (error) {
             updateStatus({

From 9b2868412cac6dd47b54a2db14e9e8007eba54aa Mon Sep 17 00:00:00 2001
From: e-filchenko-bosh <FVI2FE@bosch.com>
Date: Thu, 17 Sep 2026 15:58:23 +0300
Subject: [PATCH 13/15] stabilize graphical viewport layout

---
 src/test/graphicalViewViewport.test.ts | 23 +++++++++++++++++++++++
 src/webview/webview.js                 |  7 ++++---
 2 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/src/test/graphicalViewViewport.test.ts b/src/test/graphicalViewViewport.test.ts
index a3c4315..1d7248d 100644
--- a/src/test/graphicalViewViewport.test.ts
+++ b/src/test/graphicalViewViewport.test.ts
@@ -50,6 +50,27 @@ suite('Graphical View viewport', () => {
         assert.equal(harness.savedState.zoom, 976 / 2200);
     });
 
+    test('first Fit retains the geometry used by its formula when applying zoom synchronously removes scrollbars', () => {
+        const harness = new WebviewHarness();
+        harness.viewport.clientWidth = 985;
+        harness.viewport.clientHeight = 785;
+        harness.viewport.onSvgResize = () => {
+            harness.viewport.onSvgResize = undefined;
+            harness.viewport.clientWidth = 1000;
+            harness.viewport.clientHeight = 800;
+        };
+
+        harness.render(1, 2200, 1600);
+        assert.equal(harness.svg?.width, 961);
+        harness.flushFrame();
+
+        assert.equal(harness.hasPosted('rendered', 1), false);
+        assert.equal(harness.svg?.width, 976);
+        harness.flushFrame();
+        assert.equal(harness.hasPosted('rendered', 1), true);
+        assert.equal(harness.savedState.zoom, 976 / 2200);
+    });
+
     test('rejected first SVG leaves Fit pending for the next valid render', () => {
         const harness = new WebviewHarness();
         harness.message({type: 'render', version: 1, svg: '<parsererror'});
@@ -453,6 +474,7 @@ class FakeViewport extends FakeElement {
     clientWidth = 1000;
     clientHeight = 800;
     currentSvg: () => FakeSvg | undefined = () => undefined;
+    onSvgResize?: () => void;
     private left = 0;
     private top = 0;
 
@@ -523,6 +545,7 @@ class FakeSvg extends FakeElement {
         } else if (name === 'height') {
             this.height = Number(value);
         }
+        this.viewport?.onSvgResize?.();
     }
 
     querySelectorAll(): FakeElement[] {
diff --git a/src/webview/webview.js b/src/webview/webview.js
index ab4110b..11928b6 100644
--- a/src/webview/webview.js
+++ b/src/webview/webview.js
@@ -249,8 +249,9 @@
     }
 
     function applyFit(version) {
-        const availableWidth = Math.max(1, viewport.clientWidth - VIEWPORT_PADDING);
-        const availableHeight = Math.max(1, viewport.clientHeight - VIEWPORT_PADDING);
+        const fitMeasurement = {width: viewport.clientWidth, height: viewport.clientHeight};
+        const availableWidth = Math.max(1, fitMeasurement.width - VIEWPORT_PADDING);
+        const availableHeight = Math.max(1, fitMeasurement.height - VIEWPORT_PADDING);
         state = {
             ...state,
             zoom: clamp(Math.min(availableWidth / baseWidth, availableHeight / baseHeight), MIN_ZOOM, MAX_ZOOM),
@@ -258,7 +259,7 @@
             scrollTop: 0,
         };
         applyZoom();
-        restoreViewport(version, {width: viewport.clientWidth, height: viewport.clientHeight});
+        restoreViewport(version, fitMeasurement);
     }
 
     function normalizeWheelDelta(event) {

From 2dd6e187753147015ae2e3008376e32a1c52732d Mon Sep 17 00:00:00 2001
From: Andreas Textor <Andreas.Textor@de.bosch.com>
Date: Mon, 12 Oct 2026 16:15:14 +0200
Subject: [PATCH 14/15] Adjust 'temporarilyUnresolvable' to 'unresolvable'

---
 src/graphicalView.ts                 | 2 +-
 src/graphicalViewNavigation.ts       | 6 +++---
 src/graphicalViewProtocol.ts         | 4 ++--
 src/graphicalViewResult.ts           | 2 +-
 src/test/graphicalViewTestHarness.ts | 2 +-
 5 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/graphicalView.ts b/src/graphicalView.ts
index 2bc6ba2..cb28938 100644
--- a/src/graphicalView.ts
+++ b/src/graphicalView.ts
@@ -488,7 +488,7 @@ export class GraphicalViewController implements vscode.Disposable {
             case 'unsupportedUri':
                 this.setStale(state, warning, 'The source URI is not supported for graphical rendering.');
                 return;
-            case 'temporarilyUnresolvable':
+            case 'unresolvable':
             default:
                 this.setStale(state, warning ?? 'renderFailure', 'The model could not be loaded or parsed. The last successful diagram is retained.');
         }
diff --git a/src/graphicalViewNavigation.ts b/src/graphicalViewNavigation.ts
index 3ea9305..af69a6d 100644
--- a/src/graphicalViewNavigation.ts
+++ b/src/graphicalViewNavigation.ts
@@ -23,7 +23,7 @@ const RESOLVE_WARNINGS: ReadonlySet<string> = new Set([
     'notFound',
     'ambiguous',
     'unsupportedUri',
-    'temporarilyUnresolvable',
+    'unresolvable',
 ]);
 
 export async function resolveGraphicalViewNavigation(
@@ -118,8 +118,8 @@ function resolveWarningMessage(warning: GraphicalViewResolveTargetWarning): stri
             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.';
+        case 'unresolvable':
+            return 'The graphical target is unavailable. Fix any model syntax errors and try again.';
     }
 }
 
diff --git a/src/graphicalViewProtocol.ts b/src/graphicalViewProtocol.ts
index cb547ec..9aa42a8 100644
--- a/src/graphicalViewProtocol.ts
+++ b/src/graphicalViewProtocol.ts
@@ -23,9 +23,9 @@ export type GraphicalViewRenderWarning =
     | 'missingDocument'
     | 'modelTooLarge'
     | 'timeout'
-    | 'temporarilyUnresolvable';
+    | 'unresolvable';
 
-export type GraphicalViewResolveTargetWarning = 'notFound' | 'ambiguous' | 'unsupportedUri' | 'temporarilyUnresolvable';
+export type GraphicalViewResolveTargetWarning = 'notFound' | 'ambiguous' | 'unsupportedUri' | 'unresolvable';
 
 export interface GraphicalViewRenderParams {
     uri: string;
diff --git a/src/graphicalViewResult.ts b/src/graphicalViewResult.ts
index 4c25d86..49d00bb 100644
--- a/src/graphicalViewResult.ts
+++ b/src/graphicalViewResult.ts
@@ -35,7 +35,7 @@ const RENDER_WARNINGS: ReadonlySet<string> = new Set([
     'missingDocument',
     'modelTooLarge',
     'timeout',
-    'temporarilyUnresolvable',
+    'unresolvable',
 ]);
 const ASPECT_MODEL_URN_PATTERN = /^urn:samm:[^\s#]+#[^\s#]+$/;
 const LANGUAGE_PATTERN = /^[a-z]{2,8}(?:-[a-z0-9]{1,8})*$/;
diff --git a/src/test/graphicalViewTestHarness.ts b/src/test/graphicalViewTestHarness.ts
index 10a8fc4..db93a2d 100644
--- a/src/test/graphicalViewTestHarness.ts
+++ b/src/test/graphicalViewTestHarness.ts
@@ -57,7 +57,7 @@ export class FakeGraphicalViewClient implements GraphicalViewClient {
     readonly requests: RecordedRenderRequest[] = [];
     readonly resolveRequests: RecordedResolveRequest[] = [];
     readonly attributeResolveRequests: RecordedAttributeResolveRequest[] = [];
-    resolveResult: GraphicalViewResolveTargetResult = {location: null, warning: 'temporarilyUnresolvable'};
+    resolveResult: GraphicalViewResolveTargetResult = {location: null, warning: 'unresolvable'};
     resolveFailure: unknown | undefined;
     private readonly listeners = new Set<(available: boolean) => void>();
 

From cfbe83b15478a3bb61eff13a9b93a4d5b06b1684 Mon Sep 17 00:00:00 2001
From: Andreas Textor <Andreas.Textor@de.bosch.com>
Date: Mon, 12 Oct 2026 16:29:13 +0200
Subject: [PATCH 15/15] Fix copyright headers

---
 scripts/copy-webview-assets.mjs                      | 8 ++++++++
 scripts/verify-webview-assets.mjs                    | 8 ++++++++
 scripts/webview-assets.mjs                           | 8 ++++++++
 src/test/graphicalViewEditorReuse.acceptance.test.ts | 8 ++++++++
 src/test/graphicalViewNavigation.test.ts             | 8 ++++++++
 src/test/graphicalViewProtocol.test.ts               | 8 ++++++++
 src/test/graphicalViewViewport.test.ts               | 8 ++++++++
 src/test/graphicalViewWebviewController.test.ts      | 8 ++++++++
 src/test/graphicalViewWebviewLifecycle.test.ts       | 8 ++++++++
 src/test/languageClientGraphicalView.test.ts         | 8 ++++++++
 10 files changed, 80 insertions(+)

diff --git a/scripts/copy-webview-assets.mjs b/scripts/copy-webview-assets.mjs
index 8be932c..dd017b6 100644
--- a/scripts/copy-webview-assets.mjs
+++ b/scripts/copy-webview-assets.mjs
@@ -1,5 +1,13 @@
 /*
  * 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
  */
 
diff --git a/scripts/verify-webview-assets.mjs b/scripts/verify-webview-assets.mjs
index 56d3124..c679697 100644
--- a/scripts/verify-webview-assets.mjs
+++ b/scripts/verify-webview-assets.mjs
@@ -1,5 +1,13 @@
 /*
  * 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
  */
 
diff --git a/scripts/webview-assets.mjs b/scripts/webview-assets.mjs
index ca47898..9421180 100644
--- a/scripts/webview-assets.mjs
+++ b/scripts/webview-assets.mjs
@@ -1,5 +1,13 @@
 /*
  * 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
  */
 
diff --git a/src/test/graphicalViewEditorReuse.acceptance.test.ts b/src/test/graphicalViewEditorReuse.acceptance.test.ts
index db2f1af..0587d0d 100644
--- a/src/test/graphicalViewEditorReuse.acceptance.test.ts
+++ b/src/test/graphicalViewEditorReuse.acceptance.test.ts
@@ -1,5 +1,13 @@
 /*
  * 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
  */
 
diff --git a/src/test/graphicalViewNavigation.test.ts b/src/test/graphicalViewNavigation.test.ts
index c206655..2cf83c1 100644
--- a/src/test/graphicalViewNavigation.test.ts
+++ b/src/test/graphicalViewNavigation.test.ts
@@ -1,5 +1,13 @@
 /*
  * 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
  */
 
diff --git a/src/test/graphicalViewProtocol.test.ts b/src/test/graphicalViewProtocol.test.ts
index ae27cb0..95feaeb 100644
--- a/src/test/graphicalViewProtocol.test.ts
+++ b/src/test/graphicalViewProtocol.test.ts
@@ -1,5 +1,13 @@
 /*
  * 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
  */
 
diff --git a/src/test/graphicalViewViewport.test.ts b/src/test/graphicalViewViewport.test.ts
index 1d7248d..221c575 100644
--- a/src/test/graphicalViewViewport.test.ts
+++ b/src/test/graphicalViewViewport.test.ts
@@ -1,5 +1,13 @@
 /*
  * 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
  */
 
diff --git a/src/test/graphicalViewWebviewController.test.ts b/src/test/graphicalViewWebviewController.test.ts
index 74b1c3a..c4caf10 100644
--- a/src/test/graphicalViewWebviewController.test.ts
+++ b/src/test/graphicalViewWebviewController.test.ts
@@ -1,5 +1,13 @@
 /*
  * 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
  */
 
diff --git a/src/test/graphicalViewWebviewLifecycle.test.ts b/src/test/graphicalViewWebviewLifecycle.test.ts
index c084109..474f6e1 100644
--- a/src/test/graphicalViewWebviewLifecycle.test.ts
+++ b/src/test/graphicalViewWebviewLifecycle.test.ts
@@ -1,5 +1,13 @@
 /*
  * 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
  */
 
diff --git a/src/test/languageClientGraphicalView.test.ts b/src/test/languageClientGraphicalView.test.ts
index 4b9273c..33ab973 100644
--- a/src/test/languageClientGraphicalView.test.ts
+++ b/src/test/languageClientGraphicalView.test.ts
@@ -1,5 +1,13 @@
 /*
  * 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
  */