diff --git a/examples/iceberg/App.vue b/examples/iceberg/App.vue
index 4befdf0069..01ec40645c 100644
--- a/examples/iceberg/App.vue
+++ b/examples/iceberg/App.vue
@@ -45,6 +45,7 @@
 import kernExtraIcons from 'virtual:kern-extra-icons'
 import { computed, ref } from 'vue'
 
+import GfiConfig from './components/GfiConfig.vue'
 import IcebergMap from './components/IcebergMap.vue'
 import LayoutChooser from './components/LayoutChooser.vue'
 import TaskMenu from './components/TaskMenu.vue'
@@ -55,6 +56,11 @@ const configTasks = [
 		label: 'Layout wählen',
 		component: LayoutChooser,
 	},
+	{
+		id: 'configure-gfi',
+		label: 'GFI konfigurieren',
+		component: GfiConfig,
+	},
 ]
 const tasks = computed(() => [
 	'menu',
diff --git a/examples/iceberg/components/GfiConfig.vue b/examples/iceberg/components/GfiConfig.vue
new file mode 100644
index 0000000000..51b1dde222
--- /dev/null
+++ b/examples/iceberg/components/GfiConfig.vue
@@ -0,0 +1,86 @@
+<template>
+	<fieldset class="kern-fieldset">
+		<legend class="kern-label">
+			Wie soll die Auswahl für das GFI-Plugin ablaufen?
+		</legend>
+		<div class="kern-fieldset__body">
+			<div
+				v-for="mode of selectionModes"
+				:key="mode.value"
+				class="kern-form-check"
+			>
+				<input
+					:id="`${id}-${mode.value}`"
+					v-model="selectionMode"
+					class="kern-form-check__radio"
+					:name="`${id}-layout`"
+					type="radio"
+					:value="mode.value"
+				/>
+				<label :for="`${id}-${mode.value}`" class="kern-label">
+					{{ mode.label }}
+				</label>
+			</div>
+		</div>
+	</fieldset>
+</template>
+
+<script setup lang="ts">
+import type { MapConfiguration } from '@polar/polar'
+
+import { isEqual } from 'es-toolkit'
+import { computed, useId } from 'vue'
+
+import { useIcebergStore } from '../stores/iceberg'
+
+const id = useId()
+const store = useIcebergStore()
+
+const selectionModes = [
+	{
+		value: 'direct',
+		label: 'Direkte Auswahl',
+		config: {
+			directSelect: true,
+		},
+	},
+	{
+		value: 'multi',
+		label: 'Mehrfachauswahl',
+		config: {
+			directSelect: true,
+			multiSelect: {
+				mode: 'box',
+			},
+		},
+	},
+	{
+		value: 'pins',
+		label: 'Auswahl über das Pins-Plugin',
+		config: {
+			coordinateSources: [
+				{
+					plugin: 'pins',
+					key: 'coordinate',
+				},
+			],
+		},
+	},
+] satisfies {
+	value: 'direct' | 'multi' | 'pins'
+	label: string
+	config: Partial<MapConfiguration['gfi']>
+}[]
+
+const selectionMode = computed({
+	get: () =>
+		selectionModes.find((mode) =>
+			isEqual(mode.config, store.mapConfiguration.gfi)
+		)?.value || 'direct',
+	set: (value) => {
+		store.mapConfiguration.gfi = selectionModes.find(
+			(mode) => mode.value === value
+		)?.config as MapConfiguration['gfi']
+	},
+})
+</script>
diff --git a/examples/iceberg/components/IcebergMap.vue b/examples/iceberg/components/IcebergMap.vue
index 5933cf3fa9..bd200b1f41 100644
--- a/examples/iceberg/components/IcebergMap.vue
+++ b/examples/iceberg/components/IcebergMap.vue
@@ -49,6 +49,7 @@ import pluginAttributions from '@polar/polar/plugins/attributions'
 import pluginExport from '@polar/polar/plugins/export'
 import pluginFilter from '@polar/polar/plugins/filter'
 import pluginFullscreen from '@polar/polar/plugins/fullscreen'
+import pluginGfi from '@polar/polar/plugins/gfi'
 import pluginIconMenu from '@polar/polar/plugins/iconMenu'
 import pluginLayerChooser from '@polar/polar/plugins/layerChooser'
 import pluginPins from '@polar/polar/plugins/pins'
@@ -130,6 +131,16 @@ watch(map, (map) => {
 			layoutTag: 'TOP_LEFT',
 			searchMethods: [],
 		}),
+		pluginGfi({
+			displayComponent: true,
+			layoutTag: 'TOP_LEFT',
+			layers: {
+				'1454': {
+					window: true,
+					geometry: true,
+				},
+			},
+		}),
 		pluginPins({
 			coordinateSources: [{ plugin: 'addressSearch', key: 'chosenAddress' }],
 			boundary: {
diff --git a/examples/iceberg/components/TaskMenu.vue b/examples/iceberg/components/TaskMenu.vue
index e75f306c9e..f05a7ef330 100644
--- a/examples/iceberg/components/TaskMenu.vue
+++ b/examples/iceberg/components/TaskMenu.vue
@@ -5,12 +5,12 @@
 		</div>
 		<ul class="kern-task-list__list">
 			<li
-				v-for="(task, idx) of configTasks"
-				:key="idx"
+				v-for="(task, index) of configTasks"
+				:key="index"
 				class="kern-task-list__item"
 			>
-				<span class="kern-number">{{ idx + 1 }}</span>
-				<div :id="`task${idx + 1}-title`" class="kern-task-list__title">
+				<span class="kern-number">{{ index + 1 }}</span>
+				<div :id="`task${index + 1}-title`" class="kern-task-list__title">
 					<a
 						href="#"
 						class="kern-link kern-link--stretched"
diff --git a/examples/iceberg/stores/iceberg.ts b/examples/iceberg/stores/iceberg.ts
index e18498dff1..0509b503bc 100644
--- a/examples/iceberg/stores/iceberg.ts
+++ b/examples/iceberg/stores/iceberg.ts
@@ -31,7 +31,6 @@ export const useIcebergStore = defineStore('iceberg', () => {
 				name: 'Ausgleichsflächen',
 				styleId: 'panda',
 				visibility: true,
-				minZoom: 5,
 			},
 			{
 				id: '1693',
@@ -69,6 +68,7 @@ export const useIcebergStore = defineStore('iceberg', () => {
 				visibility: true,
 				type: 'mask',
 				name: 'snowbox.layers.mml',
+				minZoom: 5,
 			},
 		],
 		startCenter: [565874, 5934140],
@@ -132,6 +132,9 @@ export const useIcebergStore = defineStore('iceberg', () => {
 			displayComponent: true,
 			layoutTag: 'TOP_RIGHT',
 		},
+		gfi: {
+			directSelect: true,
+		} as MapConfiguration['gfi'],
 		markers: {
 			layers: [
 				{
diff --git a/examples/snowbox/debug-assistant.js b/examples/snowbox/debug-assistant.js
new file mode 100644
index 0000000000..49a8b521ff
--- /dev/null
+++ b/examples/snowbox/debug-assistant.js
@@ -0,0 +1,25 @@
+import { getStore } from '@polar/polar'
+
+function initializeDebugAssistant() {
+	const map = document.getElementById('snowbox')
+	const coreStore = getStore(map, 'core')
+	const activePluginIds = coreStore.activePluginIds
+
+	window.map = map
+	window.olMap = coreStore.map
+	window.coreStore = coreStore
+	window.activePluginIds = activePluginIds
+	for (const pluginId of activePluginIds) {
+		window[`${pluginId}Store`] = coreStore.getPluginStore(pluginId)
+	}
+}
+
+// We want to load as late as possible.
+// Especially, the timeout stuff from snowbox code should be done when doing this.
+setTimeout(() => {
+	initializeDebugAssistant()
+
+	// 7 seconds may be long sometimes, inform the developer about it.
+	// eslint-disable-next-line no-console
+	console.info('POLAR debug assistant was successfully initialized')
+}, 7000)
diff --git a/examples/snowbox/index.html b/examples/snowbox/index.html
index 4358f22741..bad7774339 100644
--- a/examples/snowbox/index.html
+++ b/examples/snowbox/index.html
@@ -8,6 +8,7 @@
 		<meta http-equiv="Cache-Control" content="no-cache, no-store, must-revalidate, max-age=0" />
 		<link rel="stylesheet" href="@polar/polar/polar.css" />
 		<script type="module" defer src="index.js"></script>
+		<script type="module" defer src="debug-assistant.js"></script>
 		<style>
 			/* style just for example page, not directly related to POLAR */
 			:root {
@@ -19,7 +20,6 @@
 				font-family: sans-serif;
 				padding: 2em;
 				background: var(--not-quite-white);
-				color: var(--eigengrau);
 			}
 
 			h1 {
@@ -61,6 +61,7 @@ <h1>POLAR map client</h1>
 			</select>
 		</label>
 		<button id="color-scheme-switcher">Switch to dark mode</button>
+		<button id="kiel-teleport">Go to Kiel</button>
 		<div>
 			Coordinates of currently selected feature: <span id="selected-feature-coordinates"></span>
 		</div>
diff --git a/examples/snowbox/index.js b/examples/snowbox/index.js
index 764b14f1e5..81b621088b 100644
--- a/examples/snowbox/index.js
+++ b/examples/snowbox/index.js
@@ -3,6 +3,7 @@ import {
 	createMap,
 	createMapElement,
 	getStore,
+	isVisible,
 	removePlugin,
 	subscribe,
 	updateState,
@@ -13,6 +14,7 @@ import pluginExport from '@polar/polar/plugins/export'
 import pluginFilter from '@polar/polar/plugins/filter'
 import pluginFullscreen from '@polar/polar/plugins/fullscreen'
 import pluginGeoLocation from '@polar/polar/plugins/geoLocation'
+import pluginGfi from '@polar/polar/plugins/gfi'
 import pluginIconMenu from '@polar/polar/plugins/iconMenu'
 import pluginLayerChooser from '@polar/polar/plugins/layerChooser'
 import pluginLoadingIndicator from '@polar/polar/plugins/loadingIndicator'
@@ -32,6 +34,7 @@ const basemapGreyId = '23421'
 const ausgleichsflaechen = '1454'
 const reports = '6059'
 const denkmal = 'denkmaelerWMS'
+const kielPolygon = 'kiel_polygon'
 const hamburgBorder = '6074'
 
 let colorScheme = 'light'
@@ -149,6 +152,12 @@ const map = await createMap(
 					},
 				},
 			},
+			{
+				id: kielPolygon,
+				type: 'mask',
+				name: 'Kiel Polygone',
+				visibility: true,
+			},
 		],
 		layout: 'nineRegions',
 		checkServiceAvailability: true,
@@ -213,6 +222,18 @@ const map = await createMap(
 							label_off: 'Mach klein',
 						},
 					},
+					gfi: {
+						layer: {
+							[reports]: {
+								property: {
+									addr: 'Adresse',
+									statu: 'Status',
+									beschr: 'Beschr.',
+									kat_text: 'Kat.',
+								},
+							},
+						},
+					},
 					iconMenu: {
 						hints: {
 							attributions: 'LMAO',
@@ -409,6 +430,91 @@ addPlugin(
 					plugin: pluginLayerChooser({}),
 				},
 			],
+			[
+				{
+					plugin: pluginGfi({
+						layers: {
+							[reports]: {
+								window: true,
+								geometry: false,
+								title: (feature) =>
+									`Meldung ${feature.properties.str} ${feature.properties.hsnr}`,
+								properties: [
+									'addr',
+									'statu',
+									'beschr',
+									'pic',
+									'kat_text',
+									'skat_text',
+								],
+								exportProperty: 'pic',
+								showTooltip: (feature) => {
+									const olMap = getStore(map, 'core').map
+									const features = feature.get('features') || [feature]
+									const visibleFeatures = features.filter((f) => isVisible(f))
+									if (visibleFeatures.length > 1) {
+										return [
+											['h2', 'Mehrere Anliegen'],
+											[
+												'span',
+												`Klick zum ${olMap.getView().getZoom() !== olMap.getView().getMaxZoom() ? 'Zoomen' : 'Öffnen'}`,
+											],
+										]
+									}
+									const tooltipFeature = visibleFeatures[0]
+									return [
+										[
+											'h2',
+											`${tooltipFeature.get('str')} ${tooltipFeature.get('hsnr')}`,
+										],
+										[
+											'span',
+											`layer.${reports}.category.skat.knownValue.${tooltipFeature.get('skat')}`,
+											{ ns: 'filter' },
+										],
+									]
+								},
+								isSelectable: (feature) => isEvenId(feature.properties.mmlid),
+							},
+							[kielPolygon]: {
+								window: true,
+							},
+						},
+						afterLoadFunction: (featuresByLayerId) => {
+							Object.values(featuresByLayerId).forEach((featureList) => {
+								featureList.forEach((feature) => {
+									if (feature.properties) {
+										feature.properties = {
+											addr: [
+												feature.properties.str,
+												feature.properties.hsnr,
+											].join(' '),
+											...feature.properties,
+										}
+									}
+								})
+							})
+							return featuresByLayerId
+						},
+						featureList: {
+							icon: 'kern-icon--checklist',
+							activeLayers: {
+								plugin: 'layerChooser',
+								key: 'activeMaskIds',
+							},
+							mode: 'visible',
+							bindWithCoreHoverSelect: true,
+							pageLength: 5,
+							text: {
+								title: (feature) =>
+									feature.get('str') + ' ' + feature.get('hsnr'),
+								subtitle: 'Michels Meldung',
+								subSubtitle: (feature) => feature.get('skat_text'),
+							},
+						},
+					}),
+				},
+			],
 			[
 				{
 					plugin: pluginFilter({
@@ -583,3 +689,7 @@ document
 		colorScheme = colorScheme === 'light' ? 'dark' : 'light'
 		updateState(map, 'core', 'colorScheme', colorScheme)
 	})
+
+document.getElementById('kiel-teleport').addEventListener('click', () => {
+	updateState(map, 'core', 'center', [575609, 6023501])
+})
diff --git a/examples/snowbox/services.js b/examples/snowbox/services.js
index fb26bfacfe..d8f6a63160 100644
--- a/examples/snowbox/services.js
+++ b/examples/snowbox/services.js
@@ -62,7 +62,7 @@ export default [
 		maxScale: '2500000',
 		legendURL: '',
 		urlIsVisible: true,
-		clusterDistance: 20,
+		clusterDistance: 40,
 	},
 	{
 		id: 'denkmaelerWMS',
@@ -86,4 +86,14 @@ export default [
 		featureNS: 'http://www.deegree.org/app',
 		featurePrefix: 'app',
 	},
+	{
+		id: 'kiel_polygon',
+		name: 'Kiel Polygon',
+		url: 'https://polar.dataport.de/qgisserver?MAP=/home/qgis/projects/dev_services.qgz',
+		typ: 'WFS',
+		featureType: 'polygon_kiel',
+		outputFormat: 'XML',
+		version: '1.1.0',
+		legendURL: '',
+	},
 ]
diff --git a/src/client.ts b/src/client.ts
index 6fc6cd943b..dc9f58475a 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -14,6 +14,7 @@ import {
 import AddressSearch from '@/plugins/addressSearch'
 import Fullscreen from '@/plugins/fullscreen'
 import GeoLocation from '@/plugins/geoLocation'
+import Gfi from '@/plugins/gfi'
 import IconMenu from '@/plugins/iconMenu'
 import LayerChooser from '@/plugins/layerChooser'
 import LoadingIndicator from '@/plugins/loadingIndicator'
@@ -37,6 +38,12 @@ function addPlugins(map: typeof PolarContainer, enabledPlugins: string[]) {
 					plugin: LayerChooser({}),
 					icon: 'kern-icon-fill--layers',
 				},
+				enabledPlugins.includes('gfi') && {
+					plugin: Gfi({
+						renderType: 'iconMenu',
+						layers: {},
+					}),
+				},
 				enabledPlugins.includes('geoLocation') && {
 					plugin: GeoLocation({ renderType: 'iconMenu' }),
 				},
@@ -90,9 +97,9 @@ function addPlugins(map: typeof PolarContainer, enabledPlugins: string[]) {
  * @param containerId - ID of the container the map will render itself in.
  * @param serviceRegister - Service register given as an array, or a URL to fetch this from.
  * @param mapConfiguration - Configuration options. Only plugins that have a configuration will be created.
- * 													To enable a plugin with default configuration, add its key with an empty object.
- * 													The plugins with the ids 'fullscreen', 'geoLocation', 'routing' and 'layerChooser' are added
- * 													to the IconMenu. The IconMenu, Toast, LayerChooser and LoadingIndicator are enabled by default.
+ *                           To enable a plugin with default configuration, add its key with an empty object.
+ *                           The plugins with the ids 'fullscreen', 'geoLocation', 'gfi', 'routing' and 'layerChooser' are added
+ *                           to the IconMenu. The IconMenu, Toast, LayerChooser and LoadingIndicator are enabled by default.
  * @param modifyServiceRegister - Optionally modify the serviceRegister. This may be useful if a pre-existing register is used.
  *
  * @example
diff --git a/src/components/kern/KernPagination.ce.vue b/src/components/kern/KernPagination.ce.vue
new file mode 100644
index 0000000000..cc5d86d784
--- /dev/null
+++ b/src/components/kern/KernPagination.ce.vue
@@ -0,0 +1,168 @@
+<template>
+	<p class="kern-subline kern-subline--small">
+		{{
+			$t(($) => $.pagination.entries, {
+				ns: 'shared',
+				start: startIndex + 1,
+				end: Math.min(count, startIndex + pageSize),
+				total: count,
+			})
+		}}
+	</p>
+	<nav
+		v-if="pageCount > 1"
+		:aria-label="$t(($) => $.pagination.wrapper, { ns: 'shared' })"
+	>
+		<ul>
+			<li>
+				<button
+					class="kern-btn kern-btn--secondary"
+					:disabled="currentPage <= 1"
+					@click="currentPage--"
+				>
+					<span class="kern-icon kern-icon--arrow-back" />
+					<span class="kern-label kern-sr-only">
+						{{ $t(($) => $.pagination.previous, { ns: 'shared' }) }}
+					</span>
+				</button>
+			</li>
+			<li
+				v-for="option of visibleOptions"
+				:key="'dots' in option ? option.dots : option.page"
+			>
+				<template v-if="'dots' in option">…</template>
+				<button
+					v-else-if="option.page"
+					class="kern-btn kern-btn--secondary"
+					:class="{ active: currentPage === option.page }"
+					:aria-label="
+						$t(($) => $.pagination.page, { ns: 'shared', page: option.page })
+					"
+					@click="currentPage = option.page"
+				>
+					<span class="kern-label">
+						{{ option.page }}
+					</span>
+				</button>
+			</li>
+			<li>
+				<button
+					class="kern-btn kern-btn--secondary"
+					:disabled="currentPage >= pageCount"
+					@click="currentPage++"
+				>
+					<span class="kern-icon kern-icon--arrow-forward" />
+					<span class="kern-label kern-sr-only">
+						{{ $t(($) => $.pagination.next, { ns: 'shared' }) }}
+					</span>
+				</button>
+			</li>
+		</ul>
+	</nav>
+</template>
+
+<script lang="ts" setup>
+import { computed, watch } from 'vue'
+
+const props = defineProps<{
+	count: number
+	pageSize: number
+}>()
+
+const startIndex = defineModel<number>({ required: true })
+const currentPage = computed({
+	get: () => startIndex.value / props.pageSize + 1,
+	set: (page) => {
+		startIndex.value = (page - 1) * props.pageSize
+	},
+})
+
+const pageCount = computed(() => Math.ceil(props.count / props.pageSize))
+
+watch([() => props.count, () => props.pageSize], () => {
+	if (currentPage.value > pageCount.value) {
+		startIndex.value = 0
+	}
+})
+
+const visibleOptions = computed(() => {
+	const generatePageInterval = (start: number, end: number) =>
+		new Array(end - start + 1).fill(null).map((_, index) => ({
+			page: index + start,
+		}))
+
+	if (pageCount.value <= 7) {
+		return generatePageInterval(1, pageCount.value)
+	}
+
+	if (currentPage.value <= 2 || currentPage.value >= pageCount.value - 1) {
+		return [
+			...generatePageInterval(1, 3),
+			{ dots: 'center' },
+			...generatePageInterval(pageCount.value - 2, pageCount.value),
+		]
+	}
+
+	if (currentPage.value < 5) {
+		return [
+			...generatePageInterval(1, 5),
+			{ dots: 'late' },
+			...generatePageInterval(pageCount.value, pageCount.value),
+		]
+	}
+
+	if (currentPage.value > pageCount.value - 4) {
+		return [
+			...generatePageInterval(1, 1),
+			{ dots: 'early' },
+			...generatePageInterval(pageCount.value - 4, pageCount.value),
+		]
+	}
+
+	return [
+		...generatePageInterval(1, 1),
+		{ dots: 'early' },
+		...generatePageInterval(currentPage.value - 1, currentPage.value + 1),
+		{ dots: 'late' },
+		...generatePageInterval(pageCount.value, pageCount.value),
+	]
+})
+</script>
+
+<style scoped>
+ul {
+	display: flex;
+	list-style-type: none;
+	padding: 0;
+	align-items: stretch;
+	justify-content: center;
+	gap: var(--kern-metric-space-small);
+}
+
+.kern-btn {
+	padding: 0;
+	min-width: var(--kern-metric-dimension-large);
+	min-height: calc(
+		var(--kern-metric-dimension-large) + var(--kern-metric-dimension-2x-small)
+	);
+	height: 100%;
+
+	&:has(.kern-sr-only) {
+		width: var(--kern-metric-dimension-large);
+	}
+
+	.kern-label {
+		font-size: var(--kern-typography-font-size-small-static);
+		line-height: var(--kern-typography-line-height-medium-static);
+	}
+
+	&.active {
+		background-color: var(--kern-color-action-default);
+		pointer-events: none;
+
+		.kern-label {
+			color: var(--kern-color-action-on-default);
+		}
+	}
+}
+</style>
diff --git a/src/composables/useOlVectorSources.ts b/src/composables/useOlVectorSources.ts
new file mode 100644
index 0000000000..2a25124ca2
--- /dev/null
+++ b/src/composables/useOlVectorSources.ts
@@ -0,0 +1,49 @@
+import type VectorSource from 'ol/source/Vector'
+import type { Ref } from 'vue'
+
+import { debounce } from 'es-toolkit'
+import { onWatcherCleanup, shallowRef, watch } from 'vue'
+
+/**
+ * Generate a reactive value based on the provided callback, which is re-evaluated when any of the provided sources emit a 'change' event.
+ * The callback is debounced to prevent excessive re-evaluation.
+ *
+ * The value is also re-evaluated when the extent changes.
+ *
+ * @param sources - A ref containing an array of OpenLayers VectorSources to watch for changes.
+ * @param reactivitySource - A reactive source to watch for changes, such as the map view, to trigger re-evaluation of the callback when it changes.
+ * @param callback - A function that generates the value to be returned.
+ * @param waitMs - The debounce delay in milliseconds.
+ * @returns A ref containing the reactive value generated by the callback.
+ */
+export function useOlVectorSources<T>(
+	sources: Ref<VectorSource[]>,
+	reactivitySource: Ref<unknown>,
+	callback: () => T,
+	waitMs: number = 50
+): Ref<T> {
+	const result = shallowRef(callback()) as Ref<T>
+	const refresh = () => {
+		result.value = callback()
+	}
+	const debouncedRefresh = debounce(refresh, waitMs)
+
+	watch(sources, (sources) => {
+		refresh()
+		sources.forEach((source) => {
+			source.on('addfeature', debouncedRefresh)
+			source.on('removefeature', debouncedRefresh)
+		})
+		onWatcherCleanup(() => {
+			sources.forEach((source) => {
+				source.un('addfeature', debouncedRefresh)
+				source.un('removefeature', debouncedRefresh)
+			})
+		})
+	})
+
+	watch(reactivitySource, refresh)
+
+	refresh()
+	return result
+}
diff --git a/src/composables/useRefStore.ts b/src/composables/useRefStore.ts
new file mode 100644
index 0000000000..d183f6e22b
--- /dev/null
+++ b/src/composables/useRefStore.ts
@@ -0,0 +1,14 @@
+import type { StoreReference } from '@/core'
+
+import { useCoreStore } from '@/core/stores'
+
+/**
+ * Get the store for a `StoreReference`.
+ *
+ * @param ref - Store reference
+ * @returns Referenced store
+ */
+export function useRefStore(ref: StoreReference) {
+	const coreStore = useCoreStore()
+	return ref.plugin ? coreStore.getPluginStore(ref.plugin) : coreStore
+}
diff --git a/src/core/components/PolarContainer.ce.vue b/src/core/components/PolarContainer.ce.vue
index b443445824..aec8d30efa 100644
--- a/src/core/components/PolarContainer.ce.vue
+++ b/src/core/components/PolarContainer.ce.vue
@@ -314,6 +314,17 @@ onBeforeUnmount(() => {
 		box-sizing: border-box;
 	}
 }
+
+/*
+ * We use KERN also within tooltips.
+ * However, the tooltip has even more space restrictions than the map itself,
+ * so we introduce some styling to match the tooltip's needs.
+ */
+.ol-overlay-container.ol-selectable {
+	h2 {
+		margin: var(--kern-metric-space-small) 0;
+	}
+}
 </style>
 
 <style scoped>
diff --git a/src/core/components/PolarMap.ce.vue b/src/core/components/PolarMap.ce.vue
index a3e62b3417..f57c76755a 100644
--- a/src/core/components/PolarMap.ce.vue
+++ b/src/core/components/PolarMap.ce.vue
@@ -33,11 +33,13 @@ defineExpose({ el: polarMapContainer })
 const emit = defineEmits(['updateListeners', 'wheel'])
 
 const mainStore = useMainStore()
-const { hasWindowSize, hasSmallDisplay, center, zoom } = storeToRefs(mainStore)
+const { hasWindowSize, hasSmallDisplay, center, extent, zoom } =
+	storeToRefs(mainStore)
 const contextMenuStore = useContextMenuStore()
 
 function onMove() {
 	center.value = mainStore.map.getView().getCenter() || center.value
+	extent.value = mainStore.map.getView().calculateExtent()
 	zoom.value = mainStore.map.getView().getZoom() ?? zoom.value
 }
 
diff --git a/src/core/index.ts b/src/core/index.ts
index 8c5b87afbb..e50bbef3aa 100644
--- a/src/core/index.ts
+++ b/src/core/index.ts
@@ -43,5 +43,7 @@ export * from './utils/export/createMap'
 export * from './utils/export/plugin'
 export * from './utils/export/store'
 
+export { isVisible } from '@/lib/invisibleStyle'
+
 export type * from './types'
 export { type PolarContainer }
diff --git a/src/core/stores/index.ts b/src/core/stores/index.ts
index 5d55749a4e..a81c6d0b07 100644
--- a/src/core/stores/index.ts
+++ b/src/core/stores/index.ts
@@ -4,9 +4,12 @@
  */
 /* eslint-enable tsdoc/syntax */
 
+import type { Feature } from 'ol'
+
 import { acceptHMRUpdate, defineStore, storeToRefs } from 'pinia'
 import { computed } from 'vue'
 
+import { updateSelection } from '../utils/map/setupMarkers'
 import { useContextMenuStore } from './contextMenu'
 import { useMainStore } from './main'
 import { useMarkerStore } from './marker'
@@ -25,21 +28,26 @@ export const useCoreStore = defineStore('core', () => {
 	const mainStoreRefs = storeToRefs(mainStore)
 
 	const contextMenuStore = useContextMenuStore()
+
 	const markerStore = useMarkerStore()
+	const markerStoreRefs = storeToRefs(markerStore)
+
 	const moveHandleStore = useMoveHandleStore()
+
 	const pluginStore = usePluginStore()
 
 	return {
 		/**
-		 * The current center coordinates of the map.
+		 * Read or modify center coordinate of the map.
 		 *
 		 * @alpha
-		 * @readonly
 		 */
-		center: computed(() => mainStore.center),
+		center: mainStoreRefs.center,
 
 		/**
 		 * Color scheme the client should be using.
+		 *
+		 * @alpha
 		 */
 		colorScheme: mainStoreRefs.colorScheme,
 
@@ -75,6 +83,14 @@ export const useCoreStore = defineStore('core', () => {
 		 */
 		deviceIsHorizontal: computed(() => mainStore.deviceIsHorizontal),
 
+		/**
+		 * Extent of the map.
+		 *
+		 * @alpha
+		 * @readonly
+		 */
+		extent: computed(() => mainStore.extent),
+
 		/**
 		 * Whether the map has a maximum height of {@link SMALL_DISPLAY_HEIGHT} and
 		 * a maximum width of {@link SMALL_DISPLAY_WIDTH}.
@@ -120,6 +136,53 @@ export const useCoreStore = defineStore('core', () => {
 		 */
 		zoom: mainStoreRefs.zoom,
 
+		/**
+		 * Returns the layer with the given ID.
+		 *
+		 * @param layerId - ID of the layer
+		 * @alpha
+		 */
+		getLayer: mainStore.getLayer,
+
+		/**
+		 * Masks an interaction for a plugin.
+		 * If the interaction is already masked by another plugin, an error is thrown.
+		 *
+		 * This may, for example, be used for interactions that should not be triggered while drawing.
+		 *
+		 * @param pluginId - ID of the plugin that wants to mask the interaction
+		 * @param interaction - Name of the interaction to be masked
+		 * @alpha
+		 */
+		maskInteraction: mainStore.maskInteraction,
+
+		/**
+		 * Unmasks an interaction for a plugin.
+		 * If the interaction is not masked by the plugin, nothing happens.
+		 *
+		 * @param pluginId - ID of the plugin that wants to unmask the interaction
+		 * @param interaction - Name of the interaction to be unmasked
+		 * @alpha
+		 */
+		unmaskInteraction: mainStore.unmaskInteraction,
+
+		/**
+		 * Checks whether an interaction is masked by another plugin.
+		 *
+		 * @param interaction - Name of the interaction to be checked
+		 * @returns `true` if the interaction is masked by another plugin, `false` otherwise
+		 * @alpha
+		 */
+		isInteractionMasked: mainStore.isInteractionMasked,
+
+		/**
+		 * List of all active plugin's IDs.
+		 *
+		 * @readonly
+		 * @alpha
+		 */
+		activePluginIds: computed(() => pluginStore.activePluginIds),
+
 		/**
 		 * Before instantiating the map, all required plugins have to be added. Depending on how you use POLAR, this may
 		 * already have been done. Ready-made clients (that is, packages prefixed `@polar/client-`) come with plugins prepared.
@@ -216,18 +279,33 @@ export const useCoreStore = defineStore('core', () => {
 		moveHandleTop: computed(() => moveHandleStore.top),
 
 		/**
-		 * Currently hovered marker feature or null.
+		 * Feature that is hovered by the user with a marker.
 		 *
-		 * @readonly
+		 * @remarks
+		 * The attribute _polarLayerId needs to be set.
+		 *
+		 * @alpha
 		 */
-		hovered: computed(() => markerStore.hovered),
+		hoveredFeature: markerStoreRefs.hovered,
 
 		/**
-		 * Currently selected marker feature or null.
+		 * Feature that was selected by the user with a marker.
 		 *
-		 * @readonly
+		 * If this value is modified, the newly selected feature is centered on the map.
+		 *
+		 * @remarks
+		 * The attribute _polarLayerId needs to be set.
+		 *
+		 * Wait at least one `nextTick` after modifying {@link hoveredFeature} before mutating this value.
+		 *
+		 * @alpha
 		 */
-		selected: computed(() => markerStore.selected),
+		selectedFeature: computed({
+			get: () => markerStore.selected,
+			set: (feature) => {
+				updateSelection(mainStore.map, feature as Feature, true)
+			},
+		}),
 
 		/**
 		 * Coordinates that were selected by the user with a marker.
diff --git a/src/core/stores/main.ts b/src/core/stores/main.ts
index fcecf83ac4..959065fef9 100644
--- a/src/core/stores/main.ts
+++ b/src/core/stores/main.ts
@@ -4,6 +4,7 @@ import type {
 	ColorScheme,
 	MapConfigurationIncludingDefaults,
 	MasterportalApiServiceRegister,
+	PluginId,
 } from '../types'
 
 import { rawLayerList } from '@masterportal/masterportalapi'
@@ -11,6 +12,8 @@ import { toMerged } from 'es-toolkit'
 import { acceptHMRUpdate, defineStore } from 'pinia'
 import { computed, ref, shallowRef, watch } from 'vue'
 
+import { findLayer } from '@/lib/findLayer'
+
 import { addInterceptor } from '../utils/addInterceptor'
 import { SMALL_DISPLAY_HEIGHT, SMALL_DISPLAY_WIDTH } from '../utils/constants'
 import defaults from '../utils/defaults'
@@ -27,6 +30,7 @@ export const useMainStore = defineStore('main', () => {
 			defaults
 		)
 	)
+	const extent = ref([0, 0, 0, 0])
 	const language = ref('')
 	const lightElement = ref<HTMLElement | null>(null)
 	const map = shallowRef({} as Map)
@@ -78,6 +82,10 @@ export const useMainStore = defineStore('main', () => {
 		center.value = (feature.getGeometry() as Point).getCoordinates()
 	}
 
+	function getLayer(layerId: string) {
+		return findLayer(map.value, layerId)
+	}
+
 	function getLayerMapConfiguration(layerId: string) {
 		const polar = configuration.value.layers.find(
 			(layer) => layer.id === layerId
@@ -89,6 +97,27 @@ export const useMainStore = defineStore('main', () => {
 		return { ...register, ...polar } as typeof polar
 	}
 
+	// TODO: Check if this works as expected in all combinations when draw is migrated
+	const maskedInteractions = ref(new globalThis.Map<string, PluginId>())
+	function maskInteraction(pluginId: PluginId, interaction: string) {
+		if (maskedInteractions.value.has(interaction)) {
+			throw new Error(
+				`Interaction "${interaction}" is already masked by plugin "${maskedInteractions.value.get(
+					interaction
+				)}"`
+			)
+		}
+		maskedInteractions.value.set(interaction, pluginId)
+	}
+	function unmaskInteraction(pluginId: PluginId, interaction: string) {
+		if (maskedInteractions.value.get(interaction) === pluginId) {
+			maskedInteractions.value.delete(interaction)
+		}
+	}
+	function isInteractionMasked(interaction: string) {
+		return maskedInteractions.value.has(interaction)
+	}
+
 	function setup() {
 		addEventListener('resize', updateHasSmallDisplay)
 		updateHasSmallDisplay()
@@ -113,6 +142,7 @@ export const useMainStore = defineStore('main', () => {
 		serviceRegister,
 		shadowRoot,
 		center,
+		extent,
 		zoom,
 		// Getters
 		layout,
@@ -122,8 +152,12 @@ export const useMainStore = defineStore('main', () => {
 		deviceIsHorizontal,
 		// Actions
 		centerOnFeature,
+		getLayer,
 		updateHasSmallDisplay,
 		getLayerMapConfiguration,
+		maskInteraction,
+		unmaskInteraction,
+		isInteractionMasked,
 		setup,
 		teardown,
 	}
@@ -132,3 +166,49 @@ export const useMainStore = defineStore('main', () => {
 if (import.meta.hot) {
 	import.meta.hot.accept(acceptHMRUpdate(useMainStore, import.meta.hot))
 }
+
+if (import.meta.vitest) {
+	const { expect, test: _test } = import.meta.vitest
+	const { createPinia, setActivePinia } = await import('pinia')
+
+	/* eslint-disable no-empty-pattern */
+	const test = _test.extend<{
+		store: ReturnType<typeof useMainStore>
+	}>({
+		store: async ({}, use) => {
+			setActivePinia(createPinia())
+			const store = useMainStore()
+			store.setup()
+			await use(store)
+			store.teardown()
+		},
+	})
+	/* eslint-enable no-empty-pattern */
+
+	test('Masking interactions works as expected', ({ store }) => {
+		const pluginId = 'external-test-plugin'
+		const interaction = 'click'
+
+		expect(store.isInteractionMasked(interaction)).toBe(false)
+
+		store.maskInteraction(pluginId, interaction)
+		expect(store.isInteractionMasked(interaction)).toBe(true)
+
+		store.unmaskInteraction(pluginId, interaction)
+		expect(store.isInteractionMasked(interaction)).toBe(false)
+	})
+
+	test('Masking interactions twice fails', ({ store }) => {
+		const pluginId = 'external-test-plugin'
+		const interaction = 'click'
+
+		expect(store.isInteractionMasked(interaction)).toBe(false)
+
+		store.maskInteraction(pluginId, interaction)
+		expect(store.isInteractionMasked(interaction)).toBe(true)
+
+		expect(() => {
+			store.maskInteraction(pluginId, interaction)
+		}).toThrow()
+	})
+}
diff --git a/src/core/stores/marker.ts b/src/core/stores/marker.ts
index abb9894cc5..cf91f5dad7 100644
--- a/src/core/stores/marker.ts
+++ b/src/core/stores/marker.ts
@@ -3,7 +3,7 @@ import type { Point } from 'ol/geom'
 import type { CallOnMapSelect } from '../types'
 
 import { acceptHMRUpdate, defineStore } from 'pinia'
-import { computed, shallowRef } from 'vue'
+import { computed, shallowRef, watch } from 'vue'
 
 import { useMainStore } from './main'
 
@@ -28,12 +28,25 @@ export const useMarkerStore = defineStore('marker', () => {
 			: (selected.value.getGeometry() as Point).getCoordinates()
 	)
 
+	const selectedBaseFeature = shallowRef<Feature | null>(null)
+	watch(selected, (feature) => {
+		if (feature) {
+			const childFeatures = feature.get('features') as Feature[] | undefined
+			if (childFeatures?.length === 1 && childFeatures[0]) {
+				selectedBaseFeature.value = childFeatures[0]
+			}
+		} else {
+			selectedBaseFeature.value = null
+		}
+	})
+
 	return {
 		configuration,
 		callOnMapSelect,
 		clusterClickZoom,
 
 		hovered,
+		selectedBaseFeature,
 		selected,
 		selectedCoordinates,
 	}
diff --git a/src/core/stores/plugin.ts b/src/core/stores/plugin.ts
index d38d36da26..a710afe784 100644
--- a/src/core/stores/plugin.ts
+++ b/src/core/stores/plugin.ts
@@ -10,7 +10,7 @@ import type {
 import { toMerged } from 'es-toolkit'
 import i18next from 'i18next'
 import { acceptHMRUpdate, defineStore } from 'pinia'
-import { markRaw, reactive } from 'vue'
+import { computed, markRaw, reactive } from 'vue'
 
 import { useMainStore } from './main'
 
@@ -18,6 +18,8 @@ export const usePluginStore = defineStore('plugin', () => {
 	const plugins = reactive<PluginContainer[]>([])
 	const mainStore = useMainStore()
 
+	const activePluginIds = computed(() => plugins.map((plugin) => plugin.id))
+
 	function addPlugin(plugin: PluginContainer) {
 		const { id, locales, options, storeModule } = plugin
 
@@ -81,6 +83,7 @@ export const usePluginStore = defineStore('plugin', () => {
 
 	return {
 		plugins,
+		activePluginIds,
 		addPlugin,
 		removePlugin,
 		getPluginStore,
diff --git a/src/core/types.ts b/src/core/types.ts
index f76740ce9d..a77fea15ae 100644
--- a/src/core/types.ts
+++ b/src/core/types.ts
@@ -9,3 +9,4 @@ export * from './types/theme'
 export * from './types/utils'
 
 export const CoreId = 'core'
+export const SharedId = 'shared'
diff --git a/src/core/types/locales.ts b/src/core/types/locales.ts
index 150b6ce1c3..6116a1ac45 100644
--- a/src/core/types/locales.ts
+++ b/src/core/types/locales.ts
@@ -1,12 +1,17 @@
+import type { resourcesEn as shared } from '@/locales'
 import type { resourcesEn as core } from '../locales'
-import type { CoreId } from '../types'
+import type { CoreId, SharedId } from '../types'
 import type { BundledPluginId, BundledPluginLocaleResources } from './plugin'
 
 /** @internal */
 export type LocaleResources = {
-	[T in typeof CoreId | BundledPluginId]: T extends BundledPluginId
+	[
+		T in typeof CoreId | typeof SharedId | BundledPluginId
+	]: T extends BundledPluginId
 		? BundledPluginLocaleResources<T>
-		: typeof core
+		: T extends typeof SharedId
+			? typeof shared
+			: typeof core
 }
 
 type ToLocaleOverride<T> = T extends string
diff --git a/src/core/types/main.ts b/src/core/types/main.ts
index bb4850a518..e1d68ab3eb 100644
--- a/src/core/types/main.ts
+++ b/src/core/types/main.ts
@@ -6,6 +6,7 @@ import type { FilterPluginOptions } from '@/plugins/filter'
 import type { FooterPluginOptions } from '@/plugins/footer'
 import type { FullscreenPluginOptions } from '@/plugins/fullscreen'
 import type { GeoLocationPluginOptions } from '@/plugins/geoLocation'
+import type { GfiPluginOptions } from '@/plugins/gfi'
 import type { IconMenuPluginOptions } from '@/plugins/iconMenu'
 import type { LoadingIndicatorOptions } from '@/plugins/loadingIndicator'
 import type { PinsPluginOptions } from '@/plugins/pins'
@@ -340,6 +341,9 @@ export interface MapConfiguration extends MasterportalApiConfiguration {
 	/** Configuration for geoLocation plugin. */
 	geoLocation?: GeoLocationPluginOptions
 
+	/** Configuration for gfi plugin. */
+	gfi?: GfiPluginOptions
+
 	/** Configuration for iconMenu plugin. */
 	iconMenu?: IconMenuPluginOptions
 
diff --git a/src/core/types/plugin.ts b/src/core/types/plugin.ts
index 28c6eae760..eff773791f 100644
--- a/src/core/types/plugin.ts
+++ b/src/core/types/plugin.ts
@@ -22,6 +22,9 @@ import type { useFullscreenStore as FullscreenStore } from '@/plugins/fullscreen
 import type { PluginId as GeoLocationPluginId } from '@/plugins/geoLocation'
 import type { resourcesEn as GeoLocationResources } from '@/plugins/geoLocation/locales'
 import type { useGeoLocationStore as GeoLocationStore } from '@/plugins/geoLocation/store'
+import type { PluginId as GfiPluginId } from '@/plugins/gfi'
+import type { resourcesEn as GfiResources } from '@/plugins/gfi/locales'
+import type { useGfiStore as GfiStore } from '@/plugins/gfi/store'
 import type { PluginId as IconMenuPluginId } from '@/plugins/iconMenu'
 import type { resourcesEn as IconMenuResources } from '@/plugins/iconMenu/locales'
 import type { useIconMenuStore as IconMenuStore } from '@/plugins/iconMenu/store'
@@ -81,6 +84,7 @@ export interface Locale {
 export interface PluginOptions {
 	/**
 	 * Should the component be visible at all.
+	 *
 	 * Only relevant if {@link MapConfiguration.layout | layout} is set to `'nineRegions'`.
 	 *
 	 * @defaultValue `false`
@@ -89,12 +93,23 @@ export interface PluginOptions {
 
 	/**
 	 * The region where the plugin should be rendered.
+	 *
 	 * Required if {@link MapConfiguration.layout | layout} is set to `'nineRegions'`,
 	 * ignored otherwise.
 	 */
 	layoutTag?: keyof typeof NineLayoutTag
 }
 
+export interface InterfacePluginOptions extends PluginOptions {
+	/**
+	 * Defines if the plugin is rendered independent or as part of the icon menu.
+	 * This is automatically set by the icon menu; you should not need to touch this.
+	 *
+	 * @defaultValue `'independent'`
+	 */
+	renderType?: 'independent' | 'iconMenu' | 'footer'
+}
+
 export interface BoundaryOptions {
 	/**
 	 * ID of the vector layer to restrict requests to.
@@ -148,6 +163,7 @@ export type BundledPluginId =
 	| typeof FooterPluginId
 	| typeof FullscreenPluginId
 	| typeof GeoLocationPluginId
+	| typeof GfiPluginId
 	| typeof IconMenuPluginId
 	| typeof LayerChooserPluginId
 	| typeof LoadingIndicatorId
@@ -177,6 +193,7 @@ export type BundledPluginStores<T extends BundledPluginId> =
 	| GetPluginStore<T, typeof FooterPluginId, typeof FooterStore>
 	| GetPluginStore<T, typeof FullscreenPluginId, typeof FullscreenStore>
 	| GetPluginStore<T, typeof GeoLocationPluginId, typeof GeoLocationStore>
+	| GetPluginStore<T, typeof GfiPluginId, typeof GfiStore>
 	| GetPluginStore<T, typeof IconMenuPluginId, typeof IconMenuStore>
 	| GetPluginStore<T, typeof LayerChooserPluginId, typeof LayerChooserStore>
 	| GetPluginStore<T, typeof LoadingIndicatorId, typeof LoadingIndicatorStore>
@@ -223,6 +240,7 @@ export type BundledPluginLocaleResources<T extends BundledPluginId> =
 			typeof GeoLocationPluginId,
 			typeof GeoLocationResources
 	  >
+	| GetPluginResources<T, typeof GfiPluginId, typeof GfiResources>
 	| GetPluginResources<T, typeof IconMenuPluginId, typeof IconMenuResources>
 	| GetPluginResources<
 			T,
diff --git a/src/core/utils/map/setupMarkers.ts b/src/core/utils/map/setupMarkers.ts
index de632359f7..32709db16e 100644
--- a/src/core/utils/map/setupMarkers.ts
+++ b/src/core/utils/map/setupMarkers.ts
@@ -10,6 +10,7 @@ import RenderFeature from 'ol/render/Feature'
 import Cluster from 'ol/source/Cluster'
 import { markRaw, toRaw, watch } from 'vue'
 
+import { findLayer } from '@/lib/findLayer'
 import getCluster from '@/lib/getCluster'
 import { isVisible } from '@/lib/invisibleStyle'
 
@@ -69,13 +70,6 @@ function layerFilter(layer: BaseLayer) {
 	return layers.some(({ id }) => id === (layer.get('id') as string))
 }
 
-function findLayer(map: Map, layerId: string) {
-	return map
-		.getLayers()
-		.getArray()
-		.find((layer) => layer.get('id') === layerId) as VectorLayer | undefined
-}
-
 function resolveClusterClick(map: Map, feature: Feature) {
 	const features = feature.get('features') as Feature[]
 
@@ -90,7 +84,14 @@ function resolveClusterClick(map: Map, feature: Feature) {
 	})
 }
 
-function updateSelection(
+/**
+ * Update the selected marker in the map.
+ *
+ * @param map - Map
+ * @param feature - Feature to select
+ * @param centerOnFeature - Whether the map should center on the feature
+ */
+export function updateSelection(
 	map: Map,
 	feature: Feature | null,
 	centerOnFeature = false
@@ -208,20 +209,25 @@ export function setupMarkers(map: Map) {
 
 	stopWatcher = watch(
 		() => store.hovered,
-		(feature) => {
-			if (feature !== null && feature !== toRaw(store.selected)) {
-				store.hovered?.setStyle(undefined)
-				store.hovered = null
+		(feature, oldFeature) => {
+			if (oldFeature !== null && oldFeature !== toRaw(store.selected)) {
+				oldFeature.setStyle(undefined)
 			}
 			if (feature !== null && feature !== toRaw(store.selected)) {
 				store.hovered = markRaw(feature)
-				const isMultiFeature = store.hovered.get('features')?.length > 1
-				const style = getMarkerStyle(
-					getLayerConfiguration(feature.get('_polarLayerId') as string)
-						.hoverStyle,
-					isMultiFeature
+				const layerId = feature.get('_polarLayerId') as string
+				const selectedCluster =
+					// @ts-expect-error | Found layers always have a source and getDistance is defined on cluster sources.
+					typeof findLayer(map, layerId)?.getSource().getDistance === 'function'
+						? getCluster(map, feature, '_polarLayerId')
+						: feature
+				selectedCluster.setStyle(
+					getMarkerStyle(
+						getLayerConfiguration(feature.get('_polarLayerId') as string)
+							.hoverStyle,
+						selectedCluster.get('features')?.length > 1
+					)
 				)
-				store.hovered.setStyle(style)
 			}
 		}
 	)
@@ -260,8 +266,9 @@ function mapMoveEnd({ map }: MapEvent) {
 	if (zoom !== lastZoom) {
 		lastZoom = zoom
 		if (store.selected) {
-			const baseFeature = (store.selected.get('features')?.[0] ||
-				store.selected) as Feature
+			const baseFeature =
+				store.selectedBaseFeature ||
+				((store.selected.get('features')?.[0] || store.selected) as Feature)
 			setLayerId(map, baseFeature)
 			updateSelection(map, baseFeature)
 		}
diff --git a/src/core/utils/markers.ts b/src/core/utils/markers.ts
index 3f855b38c3..35f3d0a359 100644
--- a/src/core/utils/markers.ts
+++ b/src/core/utils/markers.ts
@@ -71,7 +71,7 @@ const anchor = [0.5, 1]
 /**
  * The map became a little laggy due to constant re-generation of styles.
  * This memoization function optimises this issue by reusing styles.
- * */
+ */
 const memoizeStyle = (getMarker: GetMarkerFunction): GetMarkerFunction => {
 	const singleCache = new Map()
 	const multiCache = new Map()
diff --git a/src/core/vuePlugins/i18next.ts b/src/core/vuePlugins/i18next.ts
index 1fd14adb43..93577ed6a0 100644
--- a/src/core/vuePlugins/i18next.ts
+++ b/src/core/vuePlugins/i18next.ts
@@ -4,8 +4,10 @@ import i18next from 'i18next'
 import LanguageDetector from 'i18next-browser-languagedetector'
 import I18NextVue from 'i18next-vue'
 
+import sharedLocales from '@/locales'
+
 import locales from '../locales'
-import { CoreId } from '../types'
+import { CoreId, SharedId } from '../types'
 
 export const I18Next: Plugin = {
 	async install(app) {
@@ -27,6 +29,11 @@ export const I18Next: Plugin = {
 				supportedLngs: locales.map(({ type }) => type),
 			})
 
+			// This is no plugin itself, but bundled for usage of all plugins
+			sharedLocales.forEach((lng) => {
+				i18next.addResourceBundle(lng.type, SharedId, lng.resources, true)
+			})
+
 			// eslint-disable-next-line no-console
 			console.info(`Successfully initialized i18next.`)
 		} catch (error: unknown) {
diff --git a/src/lib/findLayer.ts b/src/lib/findLayer.ts
new file mode 100644
index 0000000000..c5e06805e1
--- /dev/null
+++ b/src/lib/findLayer.ts
@@ -0,0 +1,12 @@
+import type { Map } from 'ol'
+
+/**
+ * Returns the layer with the given ID.
+ *
+ * @param map - The OpenLayers map instance
+ * @param layerId - ID of the layer
+ * @returns The layer with the given ID, or `undefined` if no such layer exists
+ */
+export function findLayer(map: Map, layerId: string) {
+	return map.getAllLayers().find((layer) => layer.get('id') === layerId)
+}
diff --git a/src/lib/getCluster.ts b/src/lib/getCluster.ts
index ddb4e76ef0..5069e70479 100644
--- a/src/lib/getCluster.ts
+++ b/src/lib/getCluster.ts
@@ -4,6 +4,10 @@ import type VectorSource from 'ol/source/Vector'
 import { Feature } from 'ol'
 import VectorLayer from 'ol/layer/Vector'
 
+import { findLayer } from '@/lib/findLayer'
+
+const clusterByFeature = new WeakMap<Feature, Feature>()
+
 /*
  * Helper function to retrieve the related cluster of a feature.
  * Returns the feature if it's a cluster feature, or the cluster the feature is in.
@@ -13,11 +17,7 @@ export default function (map: Map, feature: Feature, layerId: string): Feature {
 		return feature
 	}
 
-	const layer = map
-		.getLayers()
-		.getArray()
-		.find((layer) => layer.get('id') === feature.get(layerId))
-
+	const layer = findLayer(map, feature.get(layerId))
 	if (!(layer instanceof VectorLayer)) {
 		throw new Error(
 			`@polar/lib-get-cluster: The layer with the id ${layerId} either does not exist or is not a VectorLayer.`
@@ -25,20 +25,34 @@ export default function (map: Map, feature: Feature, layerId: string): Feature {
 	}
 
 	// If the layer can be found, it has a source
-	const cluster = (layer.getSource() as VectorSource)
-		.getFeatures()
-		.find((candidate: Feature) => candidate.get('features').includes(feature))
+	const source = layer.getSource() as VectorSource
+	const cachedCluster = clusterByFeature.get(feature)
+	const cluster =
+		cachedCluster &&
+		source.hasFeature(cachedCluster) &&
+		cachedCluster.get('features').includes(feature)
+			? cachedCluster
+			: source
+					.getFeatures()
+					.find((candidate: Feature) =>
+						candidate.get('features').includes(feature)
+					)
 
 	if (!(cluster instanceof Feature)) {
 		throw new Error(
 			'@polar/lib-get-cluster: No cluster could be found for the given feature.'
 		)
 	}
+	clusterByFeature.set(feature, cluster)
 	// The given feature should be the last in the array, as it the one "above" all thus added last
-	cluster.set('features', [
-		...cluster.get('features').filter((f: Feature) => f !== feature),
-		feature,
-	])
+	const clusterFeatures = cluster.get('features') as Feature[]
+	if (clusterFeatures.at(-1) !== feature) {
+		cluster.set(
+			'features',
+			[...clusterFeatures.filter((f) => f !== feature), feature],
+			true
+		)
+	}
 	// true = silent change (prevents cluster recomputation & rerender)
 	cluster.set(layerId, feature.get(layerId), true)
 	return cluster
diff --git a/src/lib/passesBoundaryCheck.ts b/src/lib/passesBoundaryCheck.ts
index 56a0a2adf0..5be4abccfb 100644
--- a/src/lib/passesBoundaryCheck.ts
+++ b/src/lib/passesBoundaryCheck.ts
@@ -4,6 +4,8 @@ import type { Coordinate } from 'ol/coordinate'
 import VectorLayer from 'ol/layer/Vector'
 import VectorSource from 'ol/source/Vector'
 
+import { findLayer } from '@/lib/findLayer'
+
 // arbitrarily give up after 10s of stalling (100 * 100ms)
 const readinessCheckLimit = 100
 const readinessWaitTime = 100
@@ -52,11 +54,7 @@ export async function passesBoundaryCheck(
 		return true
 	}
 
-	const boundaryLayer = map
-		.getLayers()
-		.getArray()
-		.find((layer) => layer.get('id') === boundaryLayerId)
-
+	const boundaryLayer = findLayer(map, boundaryLayerId)
 	if (!(boundaryLayer instanceof VectorLayer)) {
 		console.error(
 			`No layer configured to match boundaryLayerId "${boundaryLayerId}".`
diff --git a/src/locales.ts b/src/locales.ts
new file mode 100644
index 0000000000..885a4c7cdb
--- /dev/null
+++ b/src/locales.ts
@@ -0,0 +1,61 @@
+/* eslint-disable tsdoc/syntax */
+/**
+ * This is the documentation for the locales keys for POLAR shared components.
+ * These locales are *NOT* exported, but documented only.
+ *
+ * @module locales/shared
+ */
+/* eslint-enable tsdoc/syntax */
+
+import type { Locale } from '@/core/types'
+
+/**
+ * German locales for POLAR shared components.
+ * For overwriting these values, pass a partial object of this in `locales`.
+ */
+export const resourcesDe = {
+	pagination: {
+		currentPage: 'Aktuelle Seite, Seite {{page}}',
+		page: 'Seite {{page}}',
+		next: 'Nächste Seite',
+		previous: 'Vorherige Seite',
+		wrapper: 'Seitenauswahl',
+		entries: 'Eintrag {{start}} bis {{end}} von {{total}}',
+	},
+} as const
+
+/**
+ * English locales for POLAR shared components.
+ * For overwriting these values, pass a partial object of this in `locales`.
+ */
+export const resourcesEn = {
+	pagination: {
+		currentPage: 'Current page, page {{page}}',
+		page: 'Page {{page}}',
+		next: 'Next page',
+		previous: 'Previous page',
+		wrapper: 'Pagination',
+		entries: 'Entry {{start}} to {{end}} of {{total}}',
+	},
+} as const
+
+/**
+ * POLAR shared components locales.
+ *
+ * @privateRemarks
+ * The first entry will be used as fallback.
+ *
+ * @internal
+ */
+const locales: Locale[] = [
+	{
+		type: 'de',
+		resources: resourcesDe,
+	},
+	{
+		type: 'en',
+		resources: resourcesEn,
+	},
+]
+
+export default locales
diff --git a/src/plugins/attributions/types.ts b/src/plugins/attributions/types.ts
index 714f13296d..00cdaeccb9 100644
--- a/src/plugins/attributions/types.ts
+++ b/src/plugins/attributions/types.ts
@@ -1,4 +1,4 @@
-import type { PluginOptions, StoreReference } from '@/core'
+import type { InterfacePluginOptions, StoreReference } from '@/core'
 
 export const PluginId = 'attributions'
 
@@ -63,7 +63,7 @@ export interface Attribution {
  * All parameters are optional. However, setting neither {@link layerAttributions}
  * nor {@link staticAttributions} results in an empty window.
  */
-export interface AttributionsPluginOptions extends PluginOptions {
+export interface AttributionsPluginOptions extends InterfacePluginOptions {
 	/**
 	 * Optional icon override.
 	 */
diff --git a/src/plugins/fullscreen/types.ts b/src/plugins/fullscreen/types.ts
index aa1e5c3864..9d9a7515b3 100644
--- a/src/plugins/fullscreen/types.ts
+++ b/src/plugins/fullscreen/types.ts
@@ -1,4 +1,4 @@
-import type { PluginOptions } from '@/core'
+import type { InterfacePluginOptions } from '@/core'
 
 /**
  * Plugin identifier.
@@ -8,16 +8,7 @@ export const PluginId = 'fullscreen'
 /**
  * Plugin options for fullscreen plugin.
  */
-export interface FullscreenPluginOptions extends PluginOptions {
-	/**
-	 * Defines if the fullscreen button is rendered independent or as part of the icon menu.
-	 *
-	 * This is only applicable if the layout is `'nineRegions'`.
-	 *
-	 * @defaultValue `'independent'`
-	 */
-	renderType?: 'independent' | 'iconMenu'
-
+export interface FullscreenPluginOptions extends InterfacePluginOptions {
 	/**
 	 * Defines the target container to show in fullscreen mode.
 	 * This defaults to the web component (i.e., the map with its plugin controls).
diff --git a/src/plugins/geoLocation/store.ts b/src/plugins/geoLocation/store.ts
index 7d839c3c36..cc2acf0ddf 100644
--- a/src/plugins/geoLocation/store.ts
+++ b/src/plugins/geoLocation/store.ts
@@ -58,7 +58,7 @@ export const useGeoLocationStore = defineStore('plugins/geoLocation', () => {
 		)
 	)
 	const boundary = computed(() => configuration.value.boundary)
-	const renderType = computed<'independent' | 'iconMenu'>(
+	const renderType = computed<GeoLocationPluginOptions['renderType']>(
 		() => configuration.value.renderType || 'independent'
 	)
 	const state = computed<PluginState>(() => {
diff --git a/src/plugins/geoLocation/types.ts b/src/plugins/geoLocation/types.ts
index 3e99ddd847..12a6fb5a85 100644
--- a/src/plugins/geoLocation/types.ts
+++ b/src/plugins/geoLocation/types.ts
@@ -1,4 +1,4 @@
-import type { LayerBoundPluginOptions } from '@/core'
+import type { InterfacePluginOptions, LayerBoundPluginOptions } from '@/core'
 
 /**
  * Plugin identifier.
@@ -13,7 +13,8 @@ export type PluginState = 'LOCATABLE' | 'LOCATED' | 'DISABLED'
 /**
  * Plugin options for geoLocation plugin.
  */
-export interface GeoLocationPluginOptions extends LayerBoundPluginOptions {
+export interface GeoLocationPluginOptions
+	extends LayerBoundPluginOptions, InterfacePluginOptions {
 	/**
 	 * If `true`, the location check will be run on map start-up. If `false`, the
 	 * feature has to be triggered with a button press by the user.
@@ -32,16 +33,6 @@ export interface GeoLocationPluginOptions extends LayerBoundPluginOptions {
 	 */
 	keepCentered?: boolean
 
-	/**
-	 * Defines if the geoLocation button is rendered independent or as part of the
-	 * icon menu.
-	 *
-	 * This is only applicable if the layout is `'nineRegions'`.
-	 *
-	 * @defaultValue `'independent'`
-	 */
-	renderType?: 'independent' | 'iconMenu'
-
 	/**
 	 * If set to `true`, a tooltip will be shown when hovering the geoposition
 	 * marker on the map, indicating that it shows the user's position.
diff --git a/src/plugins/gfi/components/GfiFeature.ce.vue b/src/plugins/gfi/components/GfiFeature.ce.vue
new file mode 100644
index 0000000000..56d7ba9703
--- /dev/null
+++ b/src/plugins/gfi/components/GfiFeature.ce.vue
@@ -0,0 +1,148 @@
+<template>
+	<div class="action-bar">
+		<div class="action-bar-group">
+			<KernButton
+				v-if="gfiStore.featureIndex > 0"
+				class="kern-btn--tertiary"
+				icon="kern-icon--arrow-back"
+				:label-sr-only="true"
+				@click="gfiStore.featureIndex--"
+			>
+				{{ $t(($) => $.switch.previous, { ns: PluginId }) }}
+			</KernButton>
+			<KernButton
+				v-if="gfiStore.featureIndex + 1 < gfiStore.features.length"
+				class="kern-btn--tertiary"
+				icon="kern-icon--arrow-forward"
+				:label-sr-only="true"
+				@click="gfiStore.featureIndex++"
+			>
+				{{ $t(($) => $.switch.next, { ns: PluginId }) }}
+			</KernButton>
+		</div>
+		<div class="action-bar-group">
+			<KernButton
+				v-if="gfiStore.exportProperty"
+				class="kern-btn--tertiary"
+				icon="kern-icon--download"
+				:label-sr-only="true"
+				@click="startDownload(gfiStore.exportProperty)"
+			>
+				{{ $t(($) => $.property.export, { ns: PluginId }) }}
+			</KernButton>
+			<KernButton
+				class="kern-btn--tertiary"
+				icon="kern-icon--close"
+				:label-sr-only="true"
+				@click="gfiStore.selectedFeatures = markRaw({})"
+			>
+				{{ $t(($) => $.header.close, { ns: PluginId }) }}
+			</KernButton>
+		</div>
+	</div>
+	<table class="kern-table kern-table--striped">
+		<caption v-if="gfiStore.title" class="kern-title">
+			{{
+				gfiStore.title
+			}}
+		</caption>
+		<thead class="kern-table__head">
+			<tr class="kern-table__row">
+				<th scope="col" class="kern-table__header">
+					{{ $t(($) => $.header.field, { ns: PluginId }) }}
+				</th>
+				<th scope="col" class="kern-table__header">
+					{{ $t(($) => $.header.value, { ns: PluginId }) }}
+				</th>
+			</tr>
+		</thead>
+		<tbody class="kern-table__body">
+			<tr
+				v-for="[key, value] of Object.entries(gfiStore.properties)"
+				:key="key"
+				class="kern-table__row"
+			>
+				<td class="kern-table__cell">
+					{{
+						$t(($) => $['layer'][layerId]['property'][key], {
+							ns: PluginId,
+							defaultValue: key,
+						})
+					}}
+				</td>
+				<td class="kern-table__cell">
+					<template v-if="isValidHttpUrl(value)">
+						<template
+							v-if="
+								['jpg', 'jpeg', 'png', 'gif', 'webp'].some((ext) =>
+									value.endsWith(`.${ext}`)
+								)
+							"
+						>
+							<a :href="value" target="_blank">
+								<img
+									:src="value"
+									:alt="$t(($) => $.property.imageAlt, { ns: PluginId })"
+									:title="$t(($) => $.property.linkTitle, { ns: PluginId })"
+									:height="Math.min(200, coreStore.clientHeight * 0.15)"
+									width="auto"
+								/>
+							</a>
+						</template>
+						<template v-else>
+							<a
+								:href="value"
+								target="_blank"
+								:title="$t(($) => $.property.linkTitle, { ns: PluginId })"
+							>
+								{{ $t(($) => $.property.linkText, { ns: PluginId }) }}
+							</a>
+						</template>
+					</template>
+					<template v-else>
+						{{ value }}
+					</template>
+				</td>
+			</tr>
+		</tbody>
+	</table>
+</template>
+
+<script setup lang="ts">
+import { markRaw } from 'vue'
+
+import KernButton from '@/components/kern/KernButton.ce.vue'
+import { useCoreStore } from '@/core/stores'
+
+import { useGfiStore } from '../store'
+import { PluginId } from '../types'
+import { isValidHttpUrl } from '../utils/isValidHttpUrl'
+
+const coreStore = useCoreStore()
+const gfiStore = useGfiStore()
+
+defineProps<{
+	layerId: string
+}>()
+
+function startDownload(url: string) {
+	open(url)
+}
+</script>
+
+<style scoped>
+.action-bar {
+	width: 100%;
+	display: flex;
+	justify-content: space-between;
+
+	.action-bar-group {
+		display: flex;
+		gap: var(--kern-metric-space-default);
+	}
+}
+
+td {
+	white-space: normal;
+}
+</style>
diff --git a/src/plugins/gfi/components/GfiFeatureList.ce.vue b/src/plugins/gfi/components/GfiFeatureList.ce.vue
new file mode 100644
index 0000000000..7d256383da
--- /dev/null
+++ b/src/plugins/gfi/components/GfiFeatureList.ce.vue
@@ -0,0 +1,139 @@
+<template>
+	<header class="kern-card__header">
+		<hgroup>
+			<h2 class="kern-heading-medium">
+				<span
+					v-if="gfiStore.configuration.featureList?.icon"
+					class="kern-icon"
+					:class="gfiStore.configuration.featureList?.icon"
+				/>
+				{{ $t(($) => $.list.header, { ns: PluginId }) }}
+			</h2>
+			<KernPagination
+				v-if="gfiStore.listPaginationActive && gfiStore.listFlatFeatures.length"
+				v-model="gfiStore.listPaginationStartIndex"
+				:count="gfiStore.listFlatFeatures.length"
+				:page-size="gfiStore.listPageLength"
+			/>
+		</hgroup>
+	</header>
+	<section class="kern-card__body" @mouseleave="clearHoveredFeatures">
+		<p
+			v-if="gfiStore.listFlatFeatures.length === 0"
+			class="kern-body kern-body--small polar-plugin-gfi-list-empty-view"
+		>
+			{{ $t(($) => $.list.emptyView, { ns: PluginId }) }}
+		</p>
+		<template v-else>
+			<section
+				v-for="(
+					{ layerId, feature, hovered, text }, index
+				) of gfiStore.listEnrichedPaginatedFeatures"
+				:key="index"
+				tabindex="0"
+				class="feature-list-item"
+				:class="{ hovered }"
+				@click="setSelectedFeature(layerId, feature)"
+				@mouseenter="setHoveredFeature(layerId, feature)"
+				@focus="setHoveredFeature(layerId, feature)"
+				@blur="clearHoveredFeatures"
+			>
+				<h3 class="kern-title kern-title--small">
+					{{ text.title }}
+				</h3>
+				<p class="kern-subline kern-subline--small">
+					{{ text.subtitle }}
+				</p>
+				<p class="kern-body kern-body--small">
+					{{ text.subSubtitle }}
+				</p>
+			</section>
+		</template>
+	</section>
+</template>
+
+<script setup lang="ts">
+import type { Feature } from 'ol'
+
+import { markRaw, nextTick } from 'vue'
+
+import KernPagination from '@/components/kern/KernPagination.ce.vue'
+
+import { useGfiStore } from '../store'
+import { PluginId } from '../types'
+
+const gfiStore = useGfiStore()
+
+function setHoveredFeature(layerId: string, feature: Feature) {
+	if (gfiStore.hoveredFeatures[layerId]?.[0] !== feature) {
+		gfiStore.hoveredFeatures = markRaw({
+			[layerId]: markRaw([feature]),
+		})
+	}
+}
+
+async function setSelectedFeature(layerId: string, feature: Feature) {
+	gfiStore.hoveredFeatures = markRaw({})
+	await nextTick()
+	gfiStore.selectedFeatures = markRaw({
+		[layerId]: markRaw([feature]),
+	})
+}
+
+function clearHoveredFeatures() {
+	if (Object.keys(gfiStore.hoveredFeatures).length) {
+		gfiStore.hoveredFeatures = markRaw({})
+	}
+}
+</script>
+
+<style scoped>
+header.kern-card__header {
+	padding: 0 var(--kern-metric-space-small);
+}
+
+hgroup {
+	width: 100%;
+}
+
+h2.kern-heading-medium {
+	display: flex;
+	align-items: center;
+	gap: var(--kern-metric-space-small);
+}
+
+.polar-plugin-gfi-list-empty-view {
+	padding: var(--kern-metric-space-small);
+	text-wrap: wrap;
+}
+
+section.kern-card__body {
+	gap: 0;
+}
+
+section.feature-list-item {
+	width: 100%;
+	padding: var(--kern-metric-space-small);
+	overflow: hidden;
+	text-overflow: ellipsis;
+	border-width: var(--kern-metric-border-width-default);
+	border-style: dashed;
+	border-color: transparent;
+
+	&.hovered,
+	&:hover {
+		background-color: #dff0dd;
+	}
+
+	&:hover {
+		border-radius: var(--kern-metric-border-radius-default);
+		border-color: #3fa535;
+		cursor: pointer;
+	}
+
+	& > .kern-subline,
+	& > .kern-body {
+		padding: 0;
+	}
+}
+</style>
diff --git a/src/plugins/gfi/components/GfiUI.ce.vue b/src/plugins/gfi/components/GfiUI.ce.vue
new file mode 100644
index 0000000000..7529429536
--- /dev/null
+++ b/src/plugins/gfi/components/GfiUI.ce.vue
@@ -0,0 +1,46 @@
+<template>
+	<PolarCard
+		v-if="gfiStore.features.length > 0 || gfiStore.configuration.featureList"
+		id="polar-card-gfi"
+		:class="{
+			standard: coreStore.layout === 'standard',
+			independent: gfiStore.renderType === 'independent',
+		}"
+	>
+		<GfiFeature v-if="gfiStore.feature" v-bind="gfiStore.feature" />
+		<GfiFeatureList v-else-if="gfiStore.configuration.featureList" />
+	</PolarCard>
+</template>
+
+<script setup lang="ts">
+import PolarCard from '@/components/PolarCard.ce.vue'
+import { useCoreStore } from '@/core/stores'
+
+import { useGfiStore } from '../store'
+import GfiFeature from './GfiFeature.ce.vue'
+import GfiFeatureList from './GfiFeatureList.ce.vue'
+
+const coreStore = useCoreStore()
+const gfiStore = useGfiStore()
+</script>
+
+<style scoped>
+#polar-card-gfi {
+	&.standard {
+		position: absolute;
+	}
+
+	&.independent {
+		width: calc(
+			var(--kern-metric-dimension-5x-large) +
+				var(--kern-metric-dimension-5x-large)
+		);
+		max-height: 80%;
+		overflow: auto;
+	}
+}
+
+button {
+	margin-top: var(--kern-metric-space-small);
+}
+</style>
diff --git a/src/plugins/gfi/composables/useFeatureDisplayLayer.ts b/src/plugins/gfi/composables/useFeatureDisplayLayer.ts
new file mode 100644
index 0000000000..8f35d2b123
--- /dev/null
+++ b/src/plugins/gfi/composables/useFeatureDisplayLayer.ts
@@ -0,0 +1,86 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+import type { Feature, Map } from 'ol'
+import type { Style } from 'ol/style'
+import type { Ref } from 'vue'
+
+import { GeoJSON } from 'ol/format'
+import VectorLayer from 'ol/layer/Vector'
+import { Vector } from 'ol/source'
+import { onScopeDispose, watch } from 'vue'
+
+function getFeatureDisplayLayer() {
+	const featureDisplayLayer = new VectorLayer({
+		source: new Vector({
+			features: [],
+		}),
+	})
+
+	featureDisplayLayer.set('polarInternalId', 'pluginGfiFeatureDisplay')
+	featureDisplayLayer.setZIndex(90)
+	// NOTE: This may be changed in the future to not use the default styling of @masterportal/masterportalapi
+	featureDisplayLayer.set('styleId', 'defaultHighlightFeaturesPoint')
+
+	return featureDisplayLayer
+}
+
+function isVectorSource(source): source is Vector {
+	return source instanceof Vector
+}
+
+/**
+ * reset feature layer's features.
+ */
+function clear(featureDisplayLayer: VectorLayer): void {
+	const source = featureDisplayLayer.getSource()
+	if (isVectorSource(source)) {
+		source.clear()
+	}
+}
+
+/**
+ * add feature from jsonable GeoJson object.
+ */
+function addFeature(
+	feature: GeoJsonFeature,
+	featureDisplayLayer: VectorLayer
+): void {
+	const source = featureDisplayLayer.getSource()
+	if (isVectorSource(source)) {
+		// Since ol@10, readFeature may also return a Feature[]?
+		source.addFeature(new GeoJSON().readFeature(feature) as Feature)
+	}
+}
+
+export function useFeatureDisplayLayer(
+	map: Map,
+	features: Ref<GeoJsonFeature[]>,
+	style: Ref<Style>
+) {
+	const layer = getFeatureDisplayLayer()
+
+	map.addLayer(layer)
+	onScopeDispose(() => {
+		map.removeLayer(layer)
+	})
+
+	watch(
+		style,
+		(newStyle) => {
+			layer.setStyle(newStyle)
+		},
+		{ immediate: true }
+	)
+
+	watch(
+		features,
+		(newFeatures) => {
+			clear(layer)
+			newFeatures.forEach((feature) => {
+				addFeature(feature, layer)
+			})
+		},
+		{ immediate: true, deep: true }
+	)
+
+	return {}
+}
diff --git a/src/plugins/gfi/composables/useMultiSelection.ts b/src/plugins/gfi/composables/useMultiSelection.ts
new file mode 100644
index 0000000000..b0d39fc1bd
--- /dev/null
+++ b/src/plugins/gfi/composables/useMultiSelection.ts
@@ -0,0 +1,57 @@
+import type { Map } from 'ol'
+import type { Options as DrawOptions } from 'ol/interaction/Draw'
+import type { GfiPluginOptions } from '../types'
+
+import { platformModifierKeyOnly } from 'ol/events/condition'
+import Draw, { createBox } from 'ol/interaction/Draw'
+import { Fill, Stroke, Style } from 'ol/style'
+import { onScopeDispose, ref } from 'vue'
+
+export function useMultiSelection(
+	map: Map,
+	{ mode }: NonNullable<GfiPluginOptions['multiSelect']>
+) {
+	const drawOptions: DrawOptions = {
+		stopClick: true,
+		type: 'Circle',
+		style: new Style({
+			stroke: new Stroke({ color: 'white', width: 1.5 }),
+			fill: new Fill({ color: [255, 255, 255, 0.75] }),
+		}),
+		freehandCondition: (event) => {
+			if (event.type === 'pointermove') {
+				return false
+			} else if (event.type === 'pointerup') {
+				return true
+			}
+			return platformModifierKeyOnly(event)
+		},
+		condition: () => false,
+	}
+
+	if (mode === 'box') {
+		drawOptions.geometryFunction = createBox()
+	} else {
+		delete drawOptions.geometryFunction
+	}
+
+	const selection = ref<[number, number, number, number] | null>(null)
+
+	const draw = new Draw(drawOptions)
+	draw.on(
+		'drawend',
+		(e) =>
+			(selection.value =
+				(e.feature.getGeometry()?.getExtent() as
+					[number, number, number, number] | undefined) ?? null)
+	)
+
+	map.addInteraction(draw)
+	onScopeDispose(() => {
+		map.removeInteraction(draw)
+	})
+
+	return {
+		selection,
+	}
+}
diff --git a/src/plugins/gfi/composables/useTooltip.ts b/src/plugins/gfi/composables/useTooltip.ts
new file mode 100644
index 0000000000..a2a617d00b
--- /dev/null
+++ b/src/plugins/gfi/composables/useTooltip.ts
@@ -0,0 +1,40 @@
+import type { Feature, Map, MapBrowserEvent } from 'ol'
+
+import { Overlay } from 'ol'
+import { onScopeDispose } from 'vue'
+
+import { updateTooltip } from '../utils/updateTooltip'
+
+export function useTooltip(
+	map: Map,
+	tooltipGenerators: Record<string, (feature: Feature) => [string, string][]>
+) {
+	if (!Object.keys(tooltipGenerators).length) {
+		return
+	}
+
+	const overlay = new Overlay({
+		positioning: 'bottom-center',
+		offset: [0, -5],
+	})
+	map.addOverlay(overlay)
+
+	let teardownTooltip: (() => void) | null = null
+	map.on('pointermove', (evt) => {
+		if (teardownTooltip) {
+			teardownTooltip()
+		}
+
+		teardownTooltip = updateTooltip(
+			evt as MapBrowserEvent<PointerEvent>,
+			overlay,
+			tooltipGenerators
+		)
+	})
+	onScopeDispose(() => {
+		if (teardownTooltip) {
+			teardownTooltip()
+		}
+		map.removeOverlay(overlay)
+	})
+}
diff --git a/src/plugins/gfi/index.ts b/src/plugins/gfi/index.ts
new file mode 100644
index 0000000000..da086d3d9f
--- /dev/null
+++ b/src/plugins/gfi/index.ts
@@ -0,0 +1,32 @@
+/* eslint-disable tsdoc/syntax */
+/**
+ * @module \@polar/polar/plugins/gfi
+ */
+/* eslint-enable tsdoc/syntax */
+
+import type { PluginContainer, PolarPluginStore } from '@/core'
+import type { GfiPluginOptions } from './types'
+
+import component from './components/GfiUI.ce.vue'
+import locales from './locales'
+import { useGfiStore } from './store'
+import { PluginId } from './types'
+
+/**
+ * Creates a plugin which fetches and optionally displays GFI (GetFeatureInfo) from WMS and WFS services or layers based on GeoJSON files.
+ * The feature information is accessible in the store and can also be accessed for custom display logic.
+ *
+ * @returns Plugin for use with {@link addPlugin}
+ */
+export default function pluginGfi(options: GfiPluginOptions): PluginContainer {
+	return {
+		id: PluginId,
+		component,
+		locales,
+		storeModule: useGfiStore as PolarPluginStore,
+		options,
+		icon: 'kern-icon-fill--location-on',
+	}
+}
+
+export * from './types'
diff --git a/src/plugins/gfi/locales.ts b/src/plugins/gfi/locales.ts
new file mode 100644
index 0000000000..24c05b17ba
--- /dev/null
+++ b/src/plugins/gfi/locales.ts
@@ -0,0 +1,88 @@
+/* eslint-disable tsdoc/syntax */
+/**
+ * This is the documentation for the locales keys in the gfi plugin.
+ * These locales are *NOT* exported, but documented only.
+ *
+ * @module locales/plugins/gfi
+ */
+/* eslint-enable tsdoc/syntax */
+
+import type { Locale } from '@/core'
+
+/**
+ * German locales for gfi plugin.
+ * For overwriting these values, use the plugin's ID as namespace.
+ */
+export const resourcesDe = {
+	header: {
+		close: 'Informationsfenster schließen',
+		field: 'Feld',
+		value: 'Wert',
+	},
+	property: {
+		export: 'Export als PDF',
+		imageAlt:
+			'Bitte entnehmen Sie Informationen zum Inhalt des Bildes aus den umliegenden Tabellenfeldern',
+		linkTitle: 'In neuem Tab öffnen',
+		linkText: 'Link',
+	},
+	switch: {
+		previous: 'Vorangehender Datensatz',
+		next: 'Nächster Datensatz',
+	},
+	noActiveLayer:
+		'Derzeit ist kein Kartenmaterial mit passenden Objekten eingeschaltet.',
+	list: {
+		header: 'Objektliste',
+		emptyView: 'Im aktuellen Kartenausschnitt sind keine Objekte enthalten.',
+	},
+} as const
+
+/**
+ * English locales for gfi plugin.
+ * For overwriting these values, use the plugin's ID as namespace.
+ */
+export const resourcesEn = {
+	header: {
+		close: 'Close information window',
+		field: 'Field',
+		value: 'Value',
+	},
+	property: {
+		export: 'Export as a PDF document',
+		imageAlt:
+			'Please refer to the other table fields for further information about the topics of the displayed picture',
+		linkTitle: 'Open in a new tab',
+		linkText: 'Link',
+	},
+	switch: {
+		previous: 'Previous data',
+		next: 'Next data',
+	},
+	noActiveLayer: 'Currently, no map layer with fitting objects is active.',
+	list: {
+		header: 'Feature list',
+		emptyView: 'There are no features in the current view.',
+	},
+} as const
+
+/**
+ * Gfi plugin locales.
+ *
+ * @privateRemarks
+ * The first entry will be used as fallback.
+ *
+ * @internal
+ */
+const locales: Locale[] = [
+	{
+		type: 'de',
+		resources: resourcesDe,
+	},
+	{
+		type: 'en',
+		resources: resourcesEn,
+	},
+]
+
+export default locales
diff --git a/src/plugins/gfi/store.ts b/src/plugins/gfi/store.ts
new file mode 100644
index 0000000000..fb12076660
--- /dev/null
+++ b/src/plugins/gfi/store.ts
@@ -0,0 +1,209 @@
+/* eslint-disable tsdoc/syntax */
+/**
+ * @module \@polar/polar/plugins/gfi/store
+ */
+/* eslint-enable tsdoc/syntax */
+
+import { acceptHMRUpdate, defineStore, storeToRefs } from 'pinia'
+
+import { useGfiFeatureStore } from './stores/feature'
+import { useGfiListStore } from './stores/list'
+import { useGfiMainStore } from './stores/main'
+
+/* eslint-disable tsdoc/syntax */
+/**
+ * @function
+ *
+ * Plugin store for feature information requests.
+ */
+/* eslint-enable tsdoc/syntax */
+export const useGfiStore = defineStore('plugins/gfi', () => {
+	const gfiMainStore = useGfiMainStore()
+	const gfiMainStoreRefs = storeToRefs(gfiMainStore)
+
+	const gfiListStore = useGfiListStore()
+	const gfiListStoreRefs = storeToRefs(gfiListStore)
+
+	const gfiFeatureStore = useGfiFeatureStore()
+	const gfiFeatureStoreRefs = storeToRefs(gfiFeatureStore)
+
+	return {
+		/**
+		 * Plugin configuration.
+		 *
+		 * @alpha
+		 */
+		configuration: gfiMainStoreRefs.configuration,
+
+		/**
+		 * Render type for the plugin.
+		 *
+		 * @alpha
+		 */
+		renderType: gfiMainStoreRefs.renderType,
+
+		/**
+		 * Hovered features.
+		 * This is only used for the list view.
+		 *
+		 * @alpha
+		 */
+		hoveredFeatures: gfiListStoreRefs.hoveredFeatures,
+
+		/**
+		 * Selected features.
+		 * This is only used if the feature is loaded from the list view.
+		 *
+		 * @alpha
+		 */
+		selectedFeatures: gfiMainStoreRefs.selectedFeatures,
+
+		/**
+		 * Feature information for the currently selected feature(s).
+		 *
+		 * @alpha
+		 */
+		featureInformation: gfiMainStoreRefs.featureInformation,
+
+		/**
+		 * List of features that should be displayed in a list view.
+		 *
+		 * @alpha
+		 */
+		listFeatures: gfiListStoreRefs.features,
+
+		/**
+		 * Flattened list of features for the list view.
+		 *
+		 * @alpha
+		 */
+		listFlatFeatures: gfiListStoreRefs.flatFeatures,
+
+		/**
+		 * `true` if pagination is configured for the list view.
+		 *
+		 * @alpha
+		 */
+		listPaginationActive: gfiListStoreRefs.paginationActive,
+
+		/**
+		 * If pagination is configured, the number of features per page.
+		 * Otherwise, the behaviour is undefined.
+		 *
+		 * @alpha
+		 */
+		listPageLength: gfiListStoreRefs.pageLength,
+
+		/**
+		 * If pagination is configured, the page that is currently selected in the list view.
+		 * Otherwise, the behaviour is undefined.
+		 *
+		 * @alpha
+		 */
+		listPage: gfiListStoreRefs.page,
+
+		/**
+		 * If pagination is configured, the index of the first feature that is shown on the current page.
+		 * Otherwise, the value is zero.
+		 *
+		 * The index refers to `listFlatFeatures`.
+		 *
+		 * @alpha
+		 */
+		listPaginationStartIndex: gfiListStoreRefs.paginationStartIndex,
+
+		/**
+		 * If pagination is configured, the index of the last feature that is shown on the current page.
+		 * Otherwise, the value is `undefined`.
+		 *
+		 * The index refers to `listFlatFeatures`.
+		 *
+		 * To mutate this value, change `listPage` or `listPaginationStartIndex`.
+		 *
+		 * @readonly
+		 * @alpha
+		 */
+		listPaginationEndIndex: gfiListStoreRefs.paginationEndIndex,
+
+		/**
+		 * Paginated list of features to display in the list view.
+		 * If pagination is not configured, this equals `listFlatFeatures`.
+		 *
+		 * @alpha
+		 */
+		listPaginatedFeatures: gfiListStoreRefs.paginatedFeatures,
+
+		/**
+		 * Enriched paginated list of features to display in the list view.
+		 * This includes additional text information for each feature.
+		 *
+		 * @alpha
+		 */
+		listEnrichedPaginatedFeatures: gfiListStoreRefs.enrichedPaginatedFeatures,
+
+		/**
+		 * Get the text description of a feature for the list view.
+		 *
+		 * @param feature - The feature to get the text description for
+		 * @param type - Type of text to retrieve (e.g., `'title'`)
+		 * @alpha
+		 */
+		listGetText: gfiListStore.getText,
+
+		/**
+		 * Features that should be displayed in a detail view.
+		 *
+		 * @alpha
+		 */
+		features: gfiFeatureStoreRefs.visibleFeatures,
+
+		/**
+		 * Index of the selected feature for the detail view.
+		 * This is used to calculate `feature`.
+		 *
+		 * @alpha
+		 */
+		featureIndex: gfiFeatureStoreRefs.selectedFeatureIndex,
+
+		/**
+		 * Selected feature for the detail view.
+		 * This is the currently shown feature.
+		 *
+		 * To mutate this value, change `featureIndex`.
+		 *
+		 * @readonly
+		 * @alpha
+		 */
+		feature: gfiFeatureStoreRefs.selectedFeature,
+
+		/**
+		 * Properties for the selected feature in detail view.
+		 * The properties are already filtered by configuration.
+		 *
+		 * @readonly
+		 * @alpha
+		 */
+		properties: gfiFeatureStoreRefs.selectedFeatureProperties,
+
+		/**
+		 * If an export property is configured and defined, the value of that property.
+		 * Otherwise `null`.
+		 *
+		 * @readonly
+		 * @alpha
+		 */
+		exportProperty: gfiFeatureStoreRefs.exportProperty,
+
+		/**
+		 * The title for the selected feature in detail view.
+		 *
+		 * @readonly
+		 * @alpha
+		 */
+		title: gfiFeatureStoreRefs.title,
+	}
+})
+
+if (import.meta.hot) {
+	import.meta.hot.accept(acceptHMRUpdate(useGfiStore, import.meta.hot))
+}
diff --git a/src/plugins/gfi/stores/feature.ts b/src/plugins/gfi/stores/feature.ts
new file mode 100644
index 0000000000..56be4518e4
--- /dev/null
+++ b/src/plugins/gfi/stores/feature.ts
@@ -0,0 +1,281 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+import type { MapBrowserEvent } from 'ol'
+import type { GfiLayerConfiguration, RequestGfiParameters } from '../types'
+
+import { rawLayerList } from '@masterportal/masterportalapi'
+import { debounce, isEqual } from 'es-toolkit'
+import { acceptHMRUpdate, defineStore } from 'pinia'
+import { computed, nextTick, onScopeDispose, ref, watch } from 'vue'
+
+import { useRefStore } from '@/composables/useRefStore'
+import { useStoreWatcher } from '@/composables/useStoreWatcher'
+import { useCoreStore } from '@/core/stores'
+
+import { useMultiSelection } from '../composables/useMultiSelection'
+import { useTooltip } from '../composables/useTooltip'
+import { PluginId } from '../types'
+import { requestGfi } from '../utils/requestGfi'
+import { useGfiMainStore } from './main'
+
+export const useGfiFeatureStore = defineStore('plugins/gfi/feature', () => {
+	const coreStore = useCoreStore()
+	const gfiMainStore = useGfiMainStore()
+
+	async function getFeatureInfo(
+		coordinateOrExtent: RequestGfiParameters['coordinateOrExtent'],
+		options: {
+			toggleSelection?: boolean
+		} = {}
+	) {
+		let result = Object.fromEntries(
+			(
+				await Promise.all(
+					Object.entries(gfiMainStore.configuration.layers)
+						.map(([layerId, layerConfiguration]) => ({
+							layerId,
+							layerConfiguration,
+							layer: coreStore.getLayer(layerId),
+						}))
+						.filter(
+							(
+								layer
+							): layer is {
+								[K in keyof typeof layer]: NonNullable<(typeof layer)[K]>
+							} => Boolean(layer.layer)
+						)
+						.map(async ({ layerId, layer, layerConfiguration }) => {
+							return [
+								layerId,
+								(
+									await requestGfi({
+										coordinateOrExtent,
+										layer,
+										layerConfiguration,
+										layerSpecification: rawLayerList.getLayerWhere({
+											id: layerId,
+										}),
+										map: coreStore.map,
+										mode:
+											coreStore.configuration.layers.find(
+												(layer) => layer.id === layerId
+											)?.gfiMode ||
+											gfiMainStore.configuration.mode ||
+											'bboxDot',
+									})
+								)
+									.filter(
+										(feature) =>
+											!layerConfiguration.isSelectable ||
+											layerConfiguration.isSelectable(feature)
+									)
+									.slice(
+										0,
+										gfiMainStore.configuration.maxFeatures ||
+											Number.POSITIVE_INFINITY
+									),
+							]
+						})
+				)
+			).filter((it): it is GeoJsonFeature[][] => Boolean(it))
+		) as Record<string, GeoJsonFeature[]>
+
+		if (gfiMainStore.configuration.afterLoadFunction) {
+			result = gfiMainStore.configuration.afterLoadFunction(result)
+		}
+
+		if (options.toggleSelection) {
+			Object.entries(result).forEach(([layerId, features]) => {
+				if (!gfiMainStore.featureInformation[layerId]) {
+					gfiMainStore.featureInformation[layerId] = []
+				}
+				const layerFeatureList = gfiMainStore.featureInformation[layerId]
+
+				features.forEach((feature) => {
+					const oldFeatureIndex = layerFeatureList.findIndex((oldFeature) =>
+						isEqual(oldFeature.properties, feature.properties)
+					)
+					if (oldFeatureIndex < 0) {
+						layerFeatureList.push(feature)
+					} else {
+						layerFeatureList.splice(oldFeatureIndex, 1)
+					}
+				})
+			})
+			return
+		}
+
+		gfiMainStore.featureInformation = result
+	}
+
+	const waitMs = computed(() => gfiMainStore.configuration.waitMs || 50)
+	const debouncedGetFeatureInfo = debounce(getFeatureInfo, waitMs.value)
+
+	useStoreWatcher(
+		gfiMainStore.configuration.coordinateSources || [],
+		(coordinate) => {
+			if (coordinate) {
+				debouncedGetFeatureInfo(
+					coordinate as RequestGfiParameters['coordinateOrExtent']
+				)
+			} else {
+				gfiMainStore.featureInformation = {}
+			}
+		},
+		{ immediate: true }
+	)
+
+	if (gfiMainStore.configuration.multiSelect) {
+		const multiSelection = useMultiSelection(
+			coreStore.map,
+			gfiMainStore.configuration.multiSelect
+		)
+		watch(multiSelection.selection, (selection) => {
+			if (selection) {
+				debouncedGetFeatureInfo(selection, {
+					toggleSelection:
+						gfiMainStore.configuration.multiSelect?.toggleSelection ?? true,
+				})
+			} else {
+				gfiMainStore.featureInformation = {}
+			}
+		})
+	}
+
+	if (gfiMainStore.configuration.directSelect) {
+		function onMapClick({ coordinate, originalEvent }: MapBrowserEvent) {
+			if (coreStore.isInteractionMasked('click')) {
+				return
+			}
+			debouncedGetFeatureInfo(coordinate as [number, number], {
+				toggleSelection:
+					navigator.userAgent.indexOf('Mac') !== -1
+						? originalEvent.metaKey
+						: originalEvent.ctrlKey,
+			})
+		}
+
+		coreStore.map.on('click', onMapClick)
+		onScopeDispose(() => {
+			coreStore.map.un('click', onMapClick)
+		})
+	}
+
+	const visibleFeatures = computed(() =>
+		Object.entries(gfiMainStore.featureInformation)
+			.filter(([layerId]) => gfiMainStore.configuration.layers[layerId]?.window)
+			.flatMap(([layerId, features]) =>
+				features.map((feature) => ({ layerId, feature }))
+			)
+	)
+
+	const selectedFeatureIndex = ref(0)
+	const selectedFeature = computed(
+		() => visibleFeatures.value[selectedFeatureIndex.value]
+	)
+
+	const selectedFeatureLayerConfiguration = computed(() =>
+		gfiMainStore.getLayerConfiguration(selectedFeature.value?.layerId || '')
+	)
+
+	const exportPropertyLayerConfiguration = computed(
+		() => selectedFeatureLayerConfiguration.value?.exportProperty
+	)
+
+	const exportProperty = computed(() =>
+		exportPropertyLayerConfiguration.value
+			? selectedFeature.value?.feature.properties?.[
+					exportPropertyLayerConfiguration.value
+				]
+			: null
+	)
+
+	const titleLayerConfiguration = computed(() =>
+		typeof selectedFeatureLayerConfiguration.value?.title === 'string'
+			? () => selectedFeatureLayerConfiguration.value?.title ?? null
+			: (selectedFeatureLayerConfiguration.value?.title ?? null)
+	)
+
+	const title = computed(() =>
+		titleLayerConfiguration.value && selectedFeature.value
+			? titleLayerConfiguration.value(selectedFeature.value.feature)
+			: null
+	)
+
+	const selectedFeaturePropertiesLayerConfiguration = computed(
+		() => selectedFeatureLayerConfiguration.value?.properties
+	)
+
+	const selectedFeatureProperties = computed(() =>
+		Object.fromEntries(
+			Object.entries(selectedFeature.value?.feature.properties || {})
+				.filter(
+					([key]) =>
+						(!selectedFeaturePropertiesLayerConfiguration.value ||
+							selectedFeaturePropertiesLayerConfiguration.value.includes(
+								key
+							)) &&
+						(!exportPropertyLayerConfiguration.value ||
+							key !== exportPropertyLayerConfiguration.value)
+				)
+				.map(([key, value]) => [key, value])
+		)
+	)
+
+	watch(
+		visibleFeatures,
+		() => {
+			selectedFeatureIndex.value = 0
+		},
+		{ deep: true }
+	)
+
+	watch(
+		[() => gfiMainStore.configuration.coordinateTarget, selectedFeature],
+		([target, feature], [, oldFeature]) => {
+			if (target && !feature && oldFeature) {
+				const targetStore = useRefStore(target)
+				if (!targetStore) {
+					return
+				}
+				targetStore[target.key] = null
+			}
+		}
+	)
+
+	useTooltip(
+		coreStore.map,
+		Object.fromEntries(
+			Object.entries(gfiMainStore.configuration.layers)
+				.filter(([, { showTooltip }]) => Boolean(showTooltip))
+				.map(([layerId, { showTooltip }]) => [layerId, showTooltip])
+		) as Record<string, NonNullable<GfiLayerConfiguration['showTooltip']>>
+	)
+
+	if (gfiMainStore.configuration.renderType === 'iconMenu') {
+		// TODO: Find a better solution to wait for this plugin
+		// As, in this case, we render as part of the iconMenu, the iconMenu store will be available soon.
+		void nextTick(() => {
+			const iconMenuStore = coreStore.getPluginStore('iconMenu')
+			if (iconMenuStore) {
+				watch(selectedFeature, (newFeature) => {
+					if (newFeature) {
+						iconMenuStore.openMenuById(PluginId)
+					}
+				})
+			}
+		})
+	}
+
+	return {
+		visibleFeatures,
+		selectedFeatureIndex,
+		selectedFeature,
+		selectedFeatureProperties,
+		exportProperty,
+		title,
+	}
+})
+
+if (import.meta.hot) {
+	import.meta.hot.accept(acceptHMRUpdate(useGfiFeatureStore, import.meta.hot))
+}
diff --git a/src/plugins/gfi/stores/list.ts b/src/plugins/gfi/stores/list.ts
new file mode 100644
index 0000000000..b06f7c4e11
--- /dev/null
+++ b/src/plugins/gfi/stores/list.ts
@@ -0,0 +1,276 @@
+import type { Feature } from 'ol'
+import type { FeatureList } from '../types'
+
+import ClusterSource from 'ol/source/Cluster'
+import { acceptHMRUpdate, defineStore, storeToRefs } from 'pinia'
+import { computed, markRaw, ref, shallowRef, watch } from 'vue'
+
+import { useOlVectorSources } from '@/composables/useOlVectorSources'
+import { useRefStore } from '@/composables/useRefStore'
+import { useCoreStore } from '@/core/stores'
+import getCluster from '@/lib/getCluster'
+import { getVectorSource } from '@/lib/getVectorSource'
+import { isVisible } from '@/lib/invisibleStyle'
+
+import { filterSelectableFeatures } from '../utils/filterSelectableFeatures'
+import { getSourceFeatures } from '../utils/getSourceFeatures'
+import { useGfiMainStore } from './main'
+
+export const useGfiListStore = defineStore('plugins/gfi/list', () => {
+	const coreStore = useCoreStore()
+	const gfiMainStore = useGfiMainStore()
+
+	const hoveredFeatures = shallowRef<Record<string, Feature[]>>({})
+	const { selectedFeatures } = storeToRefs(gfiMainStore)
+
+	const configuration = computed(() => gfiMainStore.configuration.featureList)
+
+	const activeLayers = computed((): string[] => {
+		if (!configuration.value) {
+			return []
+		}
+
+		const activeLayersRef = configuration.value.activeLayers
+		const store = useRefStore(activeLayersRef)
+		if (!store) {
+			return []
+		}
+		return store[activeLayersRef.key]
+	})
+
+	const activeLayerList = computed(() =>
+		activeLayers.value
+			.map((layerId) => ({
+				layerId,
+				layerConfiguration: gfiMainStore.getLayerConfiguration(layerId),
+				layer: coreStore.getLayer(layerId),
+			}))
+			.filter(
+				(
+					layer
+				): layer is {
+					[K in keyof typeof layer]: NonNullable<(typeof layer)[K]>
+				} => Boolean(layer.layerConfiguration) && Boolean(layer.layer)
+			)
+			.map(({ layerId, layerConfiguration, layer }) => ({
+				layerId,
+				layerConfiguration,
+				source: getVectorSource(layer),
+			}))
+	)
+
+	function isHovered(feature: Feature) {
+		return (
+			coreStore.hoveredFeature === feature ||
+			coreStore.hoveredFeature?.get('features')?.includes(feature)
+		)
+	}
+
+	const features = useOlVectorSources(
+		computed(() => activeLayerList.value.map(({ source }) => source)),
+		computed(() => coreStore.extent),
+		() =>
+			markRaw(
+				Object.fromEntries(
+					activeLayerList.value
+						.map(({ layerId, layerConfiguration, source }) => [
+							layerId,
+							filterSelectableFeatures(
+								getSourceFeatures(
+									coreStore.map,
+									source,
+									configuration.value?.mode || 'visible'
+								).filter((feature) => isVisible(feature)),
+								layerConfiguration.isSelectable
+							).map((feature) => ({ feature })),
+						])
+						.filter(
+							(
+								layer
+							): layer is [string, { feature: Feature; hovered?: boolean }[]] =>
+								Boolean(layer)
+						)
+				)
+			)
+	)
+
+	watch(
+		[
+			() => configuration.value?.bindWithCoreHoverSelect,
+			() => coreStore.selectedFeature,
+		],
+		([bindMarkers, feature]) => {
+			if (bindMarkers) {
+				if (feature) {
+					const layerId = feature.get('_polarLayerId')
+					const newFeatures = filterSelectableFeatures(
+						feature.get('features') || [feature],
+						gfiMainStore.getLayerConfiguration(layerId)?.isSelectable
+					)
+					selectedFeatures.value = markRaw({
+						...(newFeatures.length ? { [layerId]: markRaw(newFeatures) } : {}),
+					})
+				} else {
+					selectedFeatures.value = markRaw({})
+				}
+			}
+		},
+		{ immediate: true }
+	)
+
+	watch(
+		[
+			() => configuration.value?.bindWithCoreHoverSelect,
+			() => hoveredFeatures.value,
+		],
+		([bindMarkers, featureMap]) => {
+			if (bindMarkers) {
+				const features = Object.entries(featureMap).flatMap(
+					([layerId, features]) =>
+						features.map((feature) => ({ layerId, feature }))
+				)
+
+				// The second condition is necessary for TypeScript checks.
+				if (features.length <= 0 || !features[0]) {
+					coreStore.hoveredFeature = null
+					return
+				}
+
+				const { feature, layerId } = features[0]
+				feature.set('_polarLayerId', layerId, true)
+				coreStore.hoveredFeature = markRaw(
+					coreStore.getLayer(layerId)?.getSource() instanceof ClusterSource
+						? getCluster(coreStore.map, feature, '_polarLayerId')
+						: feature
+				)
+			}
+		},
+		{ immediate: true }
+	)
+
+	watch(
+		[
+			() => configuration.value?.bindWithCoreHoverSelect,
+			() => selectedFeatures.value,
+		],
+		([bindMarkers, featureMap]) => {
+			if (bindMarkers) {
+				const features = Object.entries(featureMap).flatMap(
+					([layerId, features]) =>
+						features.map((feature) => ({ layerId, feature }))
+				)
+
+				// The second condition is necessary for TypeScript checks.
+				if (features.length <= 0 || !features[0]) {
+					coreStore.selectedFeature = null
+					return
+				}
+
+				const selectedFeature = coreStore.selectedFeature
+				const selectedClusterFeatures =
+					selectedFeature?.get('features') ||
+					(selectedFeature ? [selectedFeature] : [])
+				if (
+					selectedFeature?.get('_polarLayerId') === features[0].layerId &&
+					selectedClusterFeatures.length === features.length &&
+					features.every(({ feature }) =>
+						selectedClusterFeatures.includes(feature)
+					)
+				) {
+					return
+				}
+
+				features[0].feature.set('_polarLayerId', features[0].layerId, true)
+				coreStore.selectedFeature = markRaw(features[0].feature)
+			}
+		},
+		{ immediate: true }
+	)
+
+	const flatFeatures = computed(() =>
+		Object.entries(features.value).flatMap(([layerId, features]) =>
+			features.map((feature) => ({
+				layerId,
+				...feature,
+			}))
+		)
+	)
+
+	const page = ref(0)
+
+	const pageLength = computed(() => configuration.value?.pageLength ?? 0)
+
+	const paginationActive = computed(
+		() => typeof configuration.value?.pageLength === 'number'
+	)
+
+	const paginationStartIndex = computed({
+		get: () => (paginationActive.value ? page.value * pageLength.value : 0),
+		set: (value) => {
+			page.value = paginationActive.value
+				? Math.round(value / pageLength.value)
+				: 0
+		},
+	})
+
+	const paginationEndIndex = computed(() =>
+		paginationActive.value
+			? paginationStartIndex.value + pageLength.value
+			: undefined
+	)
+
+	const paginatedFeatures = computed(() =>
+		flatFeatures.value.slice(
+			paginationStartIndex.value,
+			paginationEndIndex.value
+		)
+	)
+
+	function getText(
+		feature: Feature,
+		type: keyof NonNullable<FeatureList['text']>
+	) {
+		const text = configuration.value?.text?.[type]
+		if (typeof text === 'string') {
+			return text
+		}
+		if (typeof text === 'function') {
+			return text(feature)
+		}
+		return null
+	}
+
+	const enrichedPaginatedFeatures = computed(() =>
+		paginatedFeatures.value.map((feature) => ({
+			...feature,
+			get hovered() {
+				return configuration.value?.bindWithCoreHoverSelect
+					? isHovered(feature.feature)
+					: undefined
+			},
+			text: {
+				title: getText(feature.feature, 'title'),
+				subtitle: getText(feature.feature, 'subtitle'),
+				subSubtitle: getText(feature.feature, 'subSubtitle'),
+			},
+		}))
+	)
+
+	return {
+		features,
+		hoveredFeatures,
+		flatFeatures,
+		paginationActive,
+		pageLength,
+		page,
+		paginationStartIndex,
+		paginationEndIndex,
+		paginatedFeatures,
+		enrichedPaginatedFeatures,
+		getText,
+	}
+})
+
+if (import.meta.hot) {
+	import.meta.hot.accept(acceptHMRUpdate(useGfiListStore, import.meta.hot))
+}
diff --git a/src/plugins/gfi/stores/main.ts b/src/plugins/gfi/stores/main.ts
new file mode 100644
index 0000000000..326ee9f471
--- /dev/null
+++ b/src/plugins/gfi/stores/main.ts
@@ -0,0 +1,91 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+import type { Feature } from 'ol'
+import type { CustomHighlightStyle, GfiPluginOptions } from '../types'
+
+import { GeoJSON } from 'ol/format'
+import { Fill, Stroke, Style } from 'ol/style'
+import { acceptHMRUpdate, defineStore } from 'pinia'
+import { computed, ref, shallowRef, watch } from 'vue'
+
+import { useCoreStore } from '@/core/stores'
+
+import { useFeatureDisplayLayer } from '../composables/useFeatureDisplayLayer'
+import { PluginId } from '../types'
+
+const defaultHighlightStyle = {
+	stroke: {
+		color: '#003064',
+		width: 3,
+	},
+	fill: {
+		color: 'rgb(255, 255, 255, 0.7)',
+	},
+} satisfies CustomHighlightStyle
+
+export const useGfiMainStore = defineStore('plugins/gfi/main', () => {
+	const coreStore = useCoreStore()
+
+	const configuration = computed(
+		() => coreStore.configuration[PluginId] as GfiPluginOptions
+	)
+
+	const renderType = computed(
+		() => configuration.value.renderType ?? 'independent'
+	)
+
+	function getLayerConfiguration(layerId: string) {
+		return configuration.value.layers[layerId]
+	}
+
+	const selectedFeatures = shallowRef<Record<string, Feature[]>>({})
+	const featureInformation = ref<Record<string, GeoJsonFeature[]>>({})
+
+	watch(
+		selectedFeatures,
+		(features) => {
+			featureInformation.value = Object.fromEntries(
+				Object.entries(features).map(([layerId, features]) => [
+					layerId,
+					features.map((feature) => new GeoJSON().writeFeatureObject(feature)),
+				])
+			)
+		},
+		{ immediate: true }
+	)
+
+	const customHighlightStyle = computed(
+		() =>
+			new Style({
+				stroke: new Stroke(
+					configuration.value.customHighlightStyle?.stroke ||
+						defaultHighlightStyle.stroke
+				),
+				fill: new Fill(
+					configuration.value.customHighlightStyle?.fill ||
+						defaultHighlightStyle.fill
+				),
+			})
+	)
+	const highlightedFeatures = computed(() =>
+		Object.entries(featureInformation.value)
+			.filter(([layerId]) => getLayerConfiguration(layerId)?.geometry ?? true)
+			.flatMap(([, features]) => features)
+	)
+	useFeatureDisplayLayer(
+		coreStore.map,
+		highlightedFeatures,
+		customHighlightStyle
+	)
+
+	return {
+		configuration,
+		renderType,
+		getLayerConfiguration,
+		selectedFeatures,
+		featureInformation,
+	}
+})
+
+if (import.meta.hot) {
+	import.meta.hot.accept(acceptHMRUpdate(useGfiMainStore, import.meta.hot))
+}
diff --git a/src/plugins/gfi/types.ts b/src/plugins/gfi/types.ts
new file mode 100644
index 0000000000..ed39748b85
--- /dev/null
+++ b/src/plugins/gfi/types.ts
@@ -0,0 +1,407 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+import type { Feature, Map } from 'ol'
+import type BaseLayer from 'ol/layer/Base'
+import type ImageLayer from 'ol/layer/Image'
+import type TileLayer from 'ol/layer/Tile'
+import type { ImageWMS, TileWMS } from 'ol/source'
+import type { Options as Fill } from 'ol/style/Fill'
+import type { Options as Stroke } from 'ol/style/Stroke'
+import type { Icon, InterfacePluginOptions, StoreReference } from '@/core'
+
+/**
+ * Plugin identifier.
+ */
+export const PluginId = 'gfi'
+
+/**
+ * Gfi configuration for a layer.
+ *
+ * @example
+ * ```ts
+ * {
+ * 	geometry: true,
+ * 	window: true,
+ * 	maxFeatures: 10,
+ * 	geometryName: 'app:geometry',
+ * 	exportProperty: 'Export',
+ * 	properties: {
+ * 		status: 'status',
+ * 		type: 'type',
+ * 	},
+ * 	showTooltip: (feature: Feature): [string, string][] => [
+ * 		['div', `Feature ID: ${feature.properties.id}`],
+ * 		['span', `Coordinates: ${feature.geometry.coordinates.join(', ')}`],
+ * 	],
+ * 	isSelectable: (feature: Feature): boolean => Boolean(Math.random() < 0.5)
+ * }
+ * ```
+ */
+export interface GfiLayerConfiguration {
+	/**
+	 * Property of the features of a service having a url usable to trigger a download of features as a document.
+	 *
+	 * If defined, that property is hidden within the properties.
+	 */
+	exportProperty?: string
+
+	/**
+	 * (WMS-only)
+	 * Some WMS services may return features close to the clicked position.
+	 * By setting the value `clickPosition`, only features that intersect the clicked position are shown to the user.
+	 *
+	 * @defaultValue Show all features
+	 */
+	filterBy?: 'clickPosition'
+
+	/**
+	 * (WMS-only)
+	 * If the `infoFormat` is not set to `'application/geojson'` for the layer in the service register, this can be configured to be the known file format of the response.
+	 * If not given, the format is parsed from the response data.
+	 *
+	 * @remarks
+	 * The format `'text'` expects a plain text response in an undocumented, yet common format.
+	 * The behaviour of the format `'text'` may change in future versions.
+	 */
+	format?: 'GML' | 'GML2' | 'GML3' | 'GML32' | 'text'
+
+	/**
+	 * If `true`, feature geometry will be highlighted within the map.
+	 *
+	 * @defaultValue true
+	 */
+	geometry?: boolean
+
+	/**
+	 * Name of the geometry property if not the default field of the service.
+	 */
+	geometryName?: string
+
+	/**
+	 * A function can be defined to allow filtering features to be either selectable (return `true`) or not.
+	 * Unselectable features will be filtered out by the GFI plugin and have neither GFI display nor store presence, but may be visible in the map nonetheless, depending on your other configuration.
+	 * Please also mind that usage in combination with `extendedMasterportalapiMarkers` requires further configuration of that feature for smooth UX.
+	 *
+	 * @param feature - Feature to check
+	 * @returns `true` if the feature should be selectable, `false` otherwise
+	 */
+	isSelectable?: (feature: GeoJsonFeature) => boolean
+
+	/**
+	 * In case {@link GfiLayerConfiguration.window | `window`} is `true`, this will be used to determine which contents to show.
+	 * The property names can be localized, regardless if this is set or all properties are shown.
+	 *
+	 * @defaultValue Display all properties
+	 */
+	properties?: string[]
+
+	/**
+	 * (WFS- and GeoJSON-only)
+	 * If given, a tooltip will be shown with the values calculated for the feature.
+	 * The first string is the HTML tag to render, the second its contents; contents may be locale keys.
+	 *
+	 * Please mind that tooltips will only be shown if a mouse is used or the hovering device could not be detected.
+	 * Touch and pen interactions do not open tooltips since they will open the GFI window, rendering the gatherable information redundant.
+	 *
+	 * @defaultValue undefined
+	 * @param feature - Feature to calculate the tooltip for
+	 * @returns Array of tuples of the form [HTML tag to render, content or locale key]
+	 */
+	showTooltip?: (feature: Feature) => [string, string][]
+
+	/**
+	 * Title to be shown in the GFI window.
+	 * If a function is given, it will be called with the feature to determine the title.
+	 *
+	 * @defaultValue Title will be omitted
+	 * @param feature - Feature to calculate the title for
+	 * @returns Title string or `null` if no title should be shown
+	 */
+	title?: string | ((feature: GeoJsonFeature) => string | null)
+
+	/**
+	 * If `true`, properties will be shown in the map client.
+	 *
+	 * @defaultValue `false`
+	 */
+	window?: boolean
+}
+
+/**
+ * Custom highlight style configuration.
+ *
+ * @example
+ * ```ts
+ * {
+ * 	stroke: {
+ * 		color: '#FFFF00',
+ * 		width: 3,
+ * 	},
+ * 	fill: {
+ * 		color: 'rgb(255, 255, 255, 0.7)',
+ * 	},
+ * }
+ * ```
+ */
+export interface CustomHighlightStyle {
+	/**
+	 * Object for defining the fill style.
+	 * See [OpenLayers documentation](https://openlayers.org/en/latest/apidoc/module-ol_style_Fill-Fill.html) for full options.
+	 */
+	fill?: Fill
+
+	/**
+	 * Object for defining the stroke style.
+	 * See [OpenLayers documentation](https://openlayers.org/en/latest/apidoc/module-ol_style_Stroke-Stroke.html) for full options.
+	 */
+	stroke?: Stroke
+}
+
+/**
+ * Configuration for visible features in the feature information window.
+ *
+ * @example
+ * ```ts
+ * {
+ * 	mode: 'visible',
+ * 	bindWithCoreHoverSelect: true,
+ * 	pageLength: 5,
+ * 	text: ['Nature reserves', (feature) => `${feature.get('str')} ${feature.get('hsnr')}`],
+ * }
+ * ```
+ */
+export interface FeatureList {
+	activeLayers: StoreReference
+
+	/**
+	 * Icon to be shown in the list view title.
+	 */
+	icon: Icon
+
+	/**
+	 * Whether to show only features currently visible in the map view's bounding box or to display all loaded features.
+	 * In the latter case, if you desire to display all features of a layer (seen or not), set its loading strategy to `'all'`.
+	 * The loading strategy is a value in the OpenLayers vector source configuration; see [ol/loadingStrategy](https://openlayers.org/en/latest/apidoc/module-ol_loadingstrategy.html) for further details.
+	 */
+	mode: 'visible' | 'loaded'
+
+	/**
+	 * If `true`, the hover/select fields in the core's state will be listened to and interacted with.
+	 * This will result in a bilateral hovering and selecting of features with the core.
+	 *
+	 * @defaultValue false
+	 */
+	bindWithCoreHoverSelect?: boolean
+
+	/**
+	 * A number \>0 that sets the limit to the feature list's length.
+	 * If the length is surpassed, additional features can be reached by using the pagination that is generated in such a case.
+	 * If not defined, the list can be of arbitrary length.
+	 */
+	pageLength?: number
+
+	/**
+	 * Object with one to three entries that will produce title, subtitle, and an additional subtitle for the list view.
+	 *
+	 * If a parameter is a string, the text item will simply be that feature's value for the denoted property.
+	 * If it is a function, it's assumed to match the function signature `(feature: Feature): string`
+	 * and the returned string will be used for the text item.
+	 */
+	text?: {
+		title: ((feature: Feature) => string) | string
+		subtitle?: ((feature: Feature) => string) | string
+		subSubtitle?: ((feature: Feature) => string) | string
+	}
+}
+
+/**
+ * Configuration for multi-selection behavior in the gfi plugin.
+ */
+export interface MultiSelect {
+	/**
+	 * If set to `'box'`, the selection will be done in a box.
+	 * If set to `'circle'`, the selection will be done in a circle.
+	 */
+	mode: 'box' | 'circle'
+
+	/**
+	 * Defines the behaviour of a new selection.
+	 * If `true`, features can be added and removed by selection / unselecting them.
+	 * If `false`, a new selection will always replace the old one.
+	 *
+	 * @defaultValue `true`
+	 */
+	toggleSelection?: boolean
+}
+
+/**
+ * Plugin options for gfi plugin.
+ *
+ * @example
+ * ```ts
+ * {
+ * 	mode: 'bboxDot',
+ * 	afterLoadFunction,
+ * 	layers: {
+ * 		'layerId': {
+ * 			geometry: true,
+ * 			window: true,
+ * 			maxFeatures: 10,
+ * 			geometryName: 'app:geometry',
+ * 			exportProperty: 'Export',
+ * 		},
+ * 	},
+ * 	coordinateSources: [
+ * 		{ plugin: 'pins', key: 'transformedCoordinate' },
+ * 		{ plugin: 'pins', key: 'coordinatesAfterDrag' },
+ * 	],
+ * 	customHighlightStyle: {
+ * 		stroke: {
+ * 			color: '#FFFF00',
+ * 			width: 3,
+ * 		},
+ * 		fill: {
+ * 			color: 'rgb(255, 255, 255, 0.7)',
+ * 		},
+ * 	},
+ * }
+ *
+ * function afterLoadFunction(featuresByLayerId: Record<string, GeoJsonFeature[]>): Record<string, GeoJsonFeature[]> {
+ * 	const filteredFeaturesByLayerId: Record<string, GeoJsonFeature[]> = {};
+ * 	for (const layerId in featuresByLayerId) {
+ * 		if (featuresByLayerId.hasOwnProperty(layerId)) {
+ * 			const features = featuresByLayerId[layerId];
+ * 			filteredFeaturesByLayerId[layerId] = features.filter(feature => feature.properties.type === 'desiredType');
+ * 		}
+ * 	}
+ * 	return filteredFeaturesByLayerId;
+ * }
+ * ```
+ */
+export interface GfiPluginOptions extends InterfacePluginOptions {
+	/**
+	 * Maps a string (must be a layer ID) to a behaviour configuration for that layer.
+	 */
+	layers: Record<string, GfiLayerConfiguration>
+
+	/**
+	 * This method can be used to extend, filter, or otherwise modify a GFI result.
+	 *
+	 * @param featuresByLayerId - List of features by layer ID
+	 * @returns Extended, filtered, or otherwise modified result
+	 */
+	afterLoadFunction?: (
+		featuresByLayerId: Record<string, GeoJsonFeature[]>
+	) => Record<string, GeoJsonFeature[]>
+
+	/**
+	 * The plugin will react to these coordinate positions in the store.
+	 * This allows it to react to e.g. the address search or the pins plugin.
+	 * Please see the example configuration for the common use-cases.
+	 */
+	coordinateSources?: StoreReference[]
+
+	/**
+	 * It may be desirable to clear a store value when the GFI plugin is closed.
+	 * This allows it to e.g. clear the pin.
+	 * Usually, this is a store value that is also used in {@link GfiPluginOptions.coordinateSources | `coordinateSources`}.
+	 */
+	coordinateTarget?: StoreReference
+
+	/**
+	 * If required, a user can change the stroke and fill of the highlighted feature.
+	 * The default style as seen in the example will be used for each part that is not customized.
+	 * An empty object will return the complete default style while e.g. for an object without a configured fill the default fill will be applied.
+	 */
+	customHighlightStyle?: CustomHighlightStyle
+
+	/**
+	 * If `true`, a feature can be selected without defining a value in {@link GfiPluginOptions.coordinateSources | `coordinateSources`}.
+	 *
+	 * It is also possible to add multiple features to the selection by using the modifier key (CTRL on Windows or Command on macOS).
+	 * To deselect a feature, simply re-click it with the modifier key pressed.
+	 * To create a new selection, click anywhere else without pressing the modifier key.
+	 *
+	 * Does not work together with {@link MapConfiguration.markers}.
+	 *
+	 * @remarks
+	 * Be careful when using this parameter together with some values set in {@link GfiPluginOptions.coordinateSources | `coordinateSources`} as it may lead to unexpected results.
+	 * The features need to be distinguishable by their properties for the functionality to properly work.
+	 *
+	 * @defaultValue `false`
+	 */
+	directSelect?: boolean
+
+	/**
+	 * If defined, a list of available vector layer features is visible when no feature is selected.
+	 * Only usable if {@link GfiPluginOptions.renderType | `renderType`} is set to `iconMenu` and {@link GfiLayerConfiguration.window | `window`} is set to `true` for at least one configured layer.
+	 */
+	featureList?: FeatureList
+
+	/**
+	 * Limits the viewable results per layer by this number.
+	 * The first n elements are chosen arbitrarily.
+	 * Useful if you e.g. just want one result, or to limit an endless stream of returns to e.g. 10.
+	 *
+	 * @defaultValue `Infinity`
+	 * @example `10`
+	 */
+	maxFeatures?: number
+
+	/**
+	 * Method of calculating which feature has been chosen by the user.
+	 * `bboxDot` utilizes the `bbox`-url parameter using the clicked coordinate while `intersects` uses a `Filter` to calculate the intersected features.
+	 * Layers can have their own `gfiMode` parameter which would override this global mode.
+	 * To apply this, add the desired value to the parameter in the {@link MapConfiguration | `mapConfiguration`}.
+	 *
+	 * @defaultValue `'bboxDot'`
+	 */
+	mode?: 'bboxDot' | 'intersects'
+
+	/**
+	 * If configured, multiple features can be selected at once by using the modifier key (CTRL on Windows or Command on macOS) and dragging the mouse.
+	 * Can only be used in desktop environments.
+	 *
+	 * Similar to {@link GfiPluginOptions.directSelect | `directSelect`},
+	 * features can be added and removed by selection / unselecting them.
+	 * The features need to be distinguishable by their properties for the functionality to properly work.
+	 * Does not work together with {@link MapConfiguration.markers}.
+	 *
+	 * @defaultValue Disabled by default
+	 */
+	multiSelect?: MultiSelect
+
+	/**
+	 * Time passed in milliseconds before another request is started.
+	 *
+	 * @defaultValue `50`
+	 * @alpha
+	 */
+	waitMs?: number
+}
+
+/**
+ * parameter specification for request method
+ * @internal
+ */
+export interface RequestGfiParameters {
+	coordinateOrExtent: [number, number] | [number, number, number, number]
+	layer: BaseLayer
+	layerConfiguration: GfiLayerConfiguration
+
+	/** rawLayerList entry, see https://bitbucket.org/geowerkstatt-hamburg/masterportal/src/dev/doc/services.json.md */
+	layerSpecification: Record<string, unknown>
+
+	map: Map
+
+	/** defaults to bboxDot (get from minimal coordinate bbox) */
+	mode?: 'bboxDot' | 'intersects'
+}
+
+/** @internal */
+export interface RequestGfiWmsParameters {
+	coordinate: [number, number]
+	layer: TileLayer<TileWMS> | ImageLayer<ImageWMS>
+	layerConfiguration: RequestGfiParameters['layerConfiguration']
+	layerSpecification: RequestGfiParameters['layerSpecification']
+	map: RequestGfiParameters['map']
+}
diff --git a/src/plugins/gfi/utils/filterSelectableFeatures.ts b/src/plugins/gfi/utils/filterSelectableFeatures.ts
new file mode 100644
index 0000000000..0217c0e25e
--- /dev/null
+++ b/src/plugins/gfi/utils/filterSelectableFeatures.ts
@@ -0,0 +1,44 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+
+import Feature from 'ol/Feature'
+import { GeoJSON } from 'ol/format'
+
+export function filterSelectableFeatures(
+	features: Feature[],
+	isSelectable?: (feature: GeoJsonFeature) => boolean
+) {
+	if (!isSelectable) {
+		return features
+	}
+
+	const geoJson = new GeoJSON()
+	return features.filter((feature) =>
+		isSelectable(geoJson.writeFeatureObject(feature))
+	)
+}
+
+if (import.meta.vitest) {
+	const { expect, test, vi } = import.meta.vitest
+
+	test('filters unselectable features from a cluster', () => {
+		const selectableFeature = new Feature({ selectable: true })
+		const unselectableFeature = new Feature({ selectable: false })
+		const isSelectable = vi.fn(
+			(feature) => feature.properties?.selectable === true
+		)
+
+		expect(
+			filterSelectableFeatures(
+				[selectableFeature, unselectableFeature],
+				isSelectable
+			)
+		).toEqual([selectableFeature])
+		expect(isSelectable).toHaveBeenCalledTimes(2)
+	})
+
+	test('keeps all features without an isSelectable callback', () => {
+		const features = [new Feature(), new Feature()]
+
+		expect(filterSelectableFeatures(features)).toBe(features)
+	})
+}
diff --git a/src/plugins/gfi/utils/getSourceFeatures.ts b/src/plugins/gfi/utils/getSourceFeatures.ts
new file mode 100644
index 0000000000..00dcb6b1d2
--- /dev/null
+++ b/src/plugins/gfi/utils/getSourceFeatures.ts
@@ -0,0 +1,17 @@
+import type { Map } from 'ol'
+import type VectorSource from 'ol/source/Vector'
+
+export function getSourceFeatures(
+	map: Map,
+	source: VectorSource,
+	mode: 'visible' | 'loaded'
+) {
+	if (mode === 'loaded') {
+		return source.getFeatures()
+	}
+
+	return source.getFeaturesInExtent(
+		map.getView().calculateExtent(map.getSize()),
+		map.getView().getProjection()
+	)
+}
diff --git a/src/plugins/gfi/utils/isValidHttpUrl.ts b/src/plugins/gfi/utils/isValidHttpUrl.ts
new file mode 100644
index 0000000000..e660b9fc77
--- /dev/null
+++ b/src/plugins/gfi/utils/isValidHttpUrl.ts
@@ -0,0 +1,17 @@
+/**
+ * Checks if a string is a possibly valid HTTP or HTTPS URL.
+ *
+ * @param string - String to check
+ * @returns true if the string could be an HTTP(S) URL, false otherwise
+ */
+export function isValidHttpUrl(string) {
+	let url
+
+	try {
+		url = new URL(string)
+	} catch {
+		return false
+	}
+
+	return url.protocol === 'http:' || url.protocol === 'https:'
+}
diff --git a/src/plugins/gfi/utils/requestGfi.ts b/src/plugins/gfi/utils/requestGfi.ts
new file mode 100644
index 0000000000..d79473585e
--- /dev/null
+++ b/src/plugins/gfi/utils/requestGfi.ts
@@ -0,0 +1,66 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+import type { RequestGfiParameters } from '../types'
+
+import { rawLayerList } from '@masterportal/masterportalapi'
+import ImageLayer from 'ol/layer/Image'
+import TileLayer from 'ol/layer/Tile'
+import VectorLayer from 'ol/layer/Vector'
+
+import requestGfiGeoJson from './requestGfiGeoJson'
+import requestGfiWfs from './requestGfiWfs'
+import requestGfiWms from './requestGfiWms'
+
+/**
+ * The requestGfi method abstracts from service-specific implementation and
+ * retrieves feature information. Not all formats are supported yet.
+ *
+ * Namely, services returning any GML variant, or fitting text responses by
+ * default, should work. All others are not yet implemented.
+ * @param parameters - parameter object
+ * @returns found features for GFI request
+ */
+export function requestGfi({
+	map,
+	layer,
+	coordinateOrExtent,
+	layerConfiguration,
+	layerSpecification,
+	mode,
+}: RequestGfiParameters): Promise<GeoJsonFeature[]> {
+	const layerId = layer.get('id')
+	try {
+		const params = {
+			map,
+			layerConfiguration,
+			layerSpecification,
+		}
+		if (layer instanceof TileLayer || layer instanceof ImageLayer) {
+			return coordinateOrExtent.length === 2
+				? requestGfiWms({
+						...params,
+						coordinate: coordinateOrExtent,
+						layer,
+					})
+				: Promise.reject(
+						new Error(
+							`An extent can not be used for ${layerId} as it is a WMS layer which only support coordinates for gfi requests.`
+						)
+					)
+		}
+		if (
+			rawLayerList.getLayerWhere({ id: layerId })?.typ === 'GeoJSON' &&
+			// NOTE: This is the case by design of @masterportal/masterportalapi but is added here for type safety
+			layer instanceof VectorLayer
+		) {
+			return requestGfiGeoJson({ ...params, coordinateOrExtent, layer })
+		}
+		if (layer instanceof VectorLayer) {
+			return requestGfiWfs({ ...params, coordinateOrExtent, mode })
+		}
+		const notImplemented = `Layer ${layerId} was neither a Tile- nor a VectorLayer. GFI not implemented.`
+		return Promise.reject(new Error(notImplemented))
+	} catch {
+		const error = `An error occurred while requesting features from layer with the id ${layerId}.`
+		return Promise.reject(new Error(error))
+	}
+}
diff --git a/src/plugins/gfi/utils/requestGfiGeoJson.ts b/src/plugins/gfi/utils/requestGfiGeoJson.ts
new file mode 100644
index 0000000000..cce8ad08d7
--- /dev/null
+++ b/src/plugins/gfi/utils/requestGfiGeoJson.ts
@@ -0,0 +1,51 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+import type { Map } from 'ol'
+import type { FeatureLike } from 'ol/Feature'
+import type VectorLayer from 'ol/layer/Vector'
+
+import { Feature } from 'ol'
+import { GeoJSON } from 'ol/format'
+
+const writer = new GeoJSON()
+
+const getNestedFeatures = (
+	feature: Feature | FeatureLike
+): Feature | Feature[] | FeatureLike =>
+	feature instanceof Feature
+		? feature.get('features')?.length
+			? feature.get('features')
+			: feature
+		: feature
+
+/**
+ * Returns features from GeoJSON layer as GeoJSON.
+ */
+export default ({
+	map,
+	coordinateOrExtent,
+	layer,
+}: {
+	map: Map
+	coordinateOrExtent: [number, number] | [number, number, number, number]
+	layer: VectorLayer
+}): Promise<GeoJsonFeature[]> =>
+	Promise.resolve(
+		(coordinateOrExtent.length === 2
+			? map.getFeaturesAtPixel(map.getPixelFromCoordinate(coordinateOrExtent), {
+					layerFilter: (candidate) => candidate === layer,
+				})
+			: // @ts-expect-error | Layers reaching this place have a source
+				layer
+					.getSource()
+					.getFeaturesInExtent(coordinateOrExtent)
+					.map(getNestedFeatures)
+					.flat(1)
+		)
+			.map((feature) =>
+				feature instanceof Feature
+					? JSON.parse(writer.writeFeature(feature))
+					: false
+			)
+			// remove FeatureLikes
+			.filter((x) => x)
+	)
diff --git a/src/plugins/gfi/utils/requestGfiWfs.ts b/src/plugins/gfi/utils/requestGfiWfs.ts
new file mode 100644
index 0000000000..9bd89cc576
--- /dev/null
+++ b/src/plugins/gfi/utils/requestGfiWfs.ts
@@ -0,0 +1,119 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+import type { RequestGfiParameters } from '../types'
+
+import { GeoJSON, WFS } from 'ol/format'
+
+/**
+ * Parses WFS reply to jsonable objects.
+ * NOTE This method may break on unexpected formats and require further
+ * detection. For now, all WFS seem to "behave".
+ * @param xmlString - Features as returned by WFS service
+ * @param wfsVersion - Version of WFS service
+ * @returns features as flat GeoJSON (NOT ol/GeoJSON)
+ */
+const xml2GeoJson = (
+	xmlString: string,
+	wfsVersion: string
+): GeoJsonFeature[] => {
+	const parser = new WFS({ version: wfsVersion })
+	const writer = new GeoJSON()
+	const features = parser.readFeatures(xmlString)
+	const geoJsonFeatures = features.map((f) =>
+		JSON.parse(writer.writeFeature(f))
+	)
+
+	return geoJsonFeatures
+}
+
+/**
+ * Executes gfi request on wfs layer and returns result as GeoJSON.
+ * NOTE Optimization idea: For layers where features are regularly loaded,
+ * no new request should be started. Instead, wait for any running load to
+ * finish and use feature at layer source coordinate. (Not trivial.)
+ */
+export default ({
+	map,
+	coordinateOrExtent,
+	layerConfiguration,
+	layerSpecification,
+	mode,
+}: Pick<
+	RequestGfiParameters,
+	| 'map'
+	| 'coordinateOrExtent'
+	| 'layerConfiguration'
+	| 'layerSpecification'
+	| 'mode'
+>): Promise<GeoJsonFeature[]> => {
+	if (coordinateOrExtent.length === 4 && mode !== 'bboxDot') {
+		return Promise.reject(
+			new Error(
+				`Configuration error in requestGfiWfs.ts: mode must be "bboxDot" to be able to use an extent for gfi requests, but was "${mode}".`
+			)
+		)
+	}
+	const { featureType, url, version } = layerSpecification
+	const { geometryName } = layerConfiguration
+	const code = map.getView().getProjection().getCode()
+	const typeName = version === '2.0.0' ? 'typeNames' : 'typename'
+
+	const featureUrl = new URL(url as string)
+	featureUrl.searchParams.set('service', 'WFS')
+	featureUrl.searchParams.set('version', version as string)
+	featureUrl.searchParams.set('request', 'GetFeature')
+	featureUrl.searchParams.set(typeName, featureType as string)
+	featureUrl.searchParams.set('srsName', code)
+
+	if (mode === 'bboxDot') {
+		const extent =
+			coordinateOrExtent.length === 2
+				? /* The extended extent is necessary because an extent with the same
+					 * coordinates could lead to an empty featureCollection. */
+					[
+						coordinateOrExtent[0] - 0.1,
+						coordinateOrExtent[1] - 0.1,
+						coordinateOrExtent[0] + 0.1,
+						coordinateOrExtent[1] + 0.1,
+					]
+				: coordinateOrExtent
+
+		featureUrl.searchParams.set('bbox', `${extent.join(',')},${code}`)
+	} else if (mode === 'intersects') {
+		const point =
+			`<gml:Point srsName="${code}">` +
+			`<gml:coordinates>${coordinateOrExtent[0]},${coordinateOrExtent[1]}</gml:coordinates>` +
+			'</gml:Point>'
+		featureUrl.searchParams.set(
+			'FILTER',
+			// NOTE: fes as a namespace and ValueReference for a property has been introduced in 2.0.0
+			version === '2.0.0'
+				? '<fes:Filter>' +
+						'<fes:Intersects>' +
+						`<fes:ValueReference>${geometryName}</fes:ValueReference>` +
+						point +
+						'</fes:Intersects>' +
+						'</fes:Filter>'
+				: '<ogc:Filter xmlns:ogc="http://www.opengis.net/ogc">' +
+						'<ogc:Intersects>' +
+						`<ogc:PropertyName>${geometryName}</ogc:PropertyName>` +
+						point +
+						'</fes:Intersects>' +
+						'</fes:Filter>'
+		)
+	} else {
+		return Promise.reject(
+			new Error(
+				`Type error in requestGfiWfs.ts: mode must be "intersects" or "bboxDot", but was "${mode}".`
+			)
+		)
+	}
+
+	return (
+		fetch(featureUrl, { method: 'GET' })
+			.then((response) => response.text())
+			// TODO: Type of layerSpecification needs an update to better reflect the possibilities of the services
+			//  and get rid of this @ts-expect-error
+			// @ts-expect-error | Better typing is needed here
+			.then((xmlText) => xml2GeoJson(xmlText, version))
+	)
+}
diff --git a/src/plugins/gfi/utils/requestGfiWms.ts b/src/plugins/gfi/utils/requestGfiWms.ts
new file mode 100644
index 0000000000..26863a890e
--- /dev/null
+++ b/src/plugins/gfi/utils/requestGfiWms.ts
@@ -0,0 +1,210 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+import type { TileWMS } from 'ol/source'
+import type { RequestGfiWmsParameters } from '../types'
+
+import { Feature } from 'ol'
+import { GeoJSON } from 'ol/format'
+import GML from 'ol/format/GML'
+import GML2 from 'ol/format/GML2'
+import GML3 from 'ol/format/GML3'
+import GML32 from 'ol/format/GML32'
+import WFS from 'ol/format/WFS'
+
+// list of supported reply formats that can be used from OL
+const formats = {
+	GML,
+	GML2,
+	GML3,
+	GML32,
+}
+
+/**
+ * This is a custom text response reader working on an unspecified format that
+ * commonly occurs in WMS GFI replies. It can be used by specifying "text" as
+ * "format" on a GFI specification. Please mind that it's written from
+ * experience, not from a clear definition, and may need attention whenever
+ * new cases arise.
+ * @param text - Custom text response, hopefully in the implemented format
+ * @returns array of OpenLayers features
+ */
+function readTextFeatures(text: string): Feature[] {
+	const lines = text.split('\n')
+	const features: Feature[] = []
+	let feature: Feature | undefined
+
+	/* Format supposedly looks like this – however, this is probably not standardized!
+	 * See https://docs.ogc.org/is/06-042/06-042.pdf#page=40 for the WMS specification.
+		GetFeatureInfo results:
+			LayerName:
+				FeatureId:
+					Horse: Yes
+					Speed: Fast
+					Horsepower: 4
+	*/
+
+	for (const line of lines) {
+		if (
+			line === '' ||
+			line.startsWith('GetFeatureInfo results') ||
+			line.startsWith('Layer')
+		) {
+			continue
+		}
+		if (line.startsWith('    ')) {
+			if (typeof feature !== 'undefined') {
+				const equalIndex = line.indexOf('=')
+				const [key, value] = [
+					line.substring(0, equalIndex),
+					line.substring(equalIndex + 3, line.length - 1),
+				].map((s) => s.trim()) as [string, string]
+				feature.set(key, value)
+			} else {
+				console.error(
+					'Found property before feature declaration in readTextFeatures.',
+					line,
+					'Skipping ...'
+				)
+			}
+			continue
+		}
+		if (line.startsWith('  ')) {
+			if (line.includes('Search returned no results')) {
+				break
+			}
+			const id = line.substring(0, line.length - 2).trim()
+			feature = new Feature()
+			feature.setId(id)
+			features.push(feature)
+		}
+	}
+	return features
+}
+
+/**
+ * In case the layer configuration does not specify a parser, we're trying to
+ * detect the returned XML format by searching for a GML namespace. Any return
+ * format outside GML will currently not work with this automated parsing.
+ * @param data - data as parsed from response body
+ * @returns WFS capable of parsing data
+ */
+function getParserFromData(data: string): WFS {
+	// NOTE: Tested for GML32 and GML, may break on GML2/GML3
+	const GMLFormat = data.includes('xmlns:gml="http://www.opengis.net/gml/3.2"')
+		? GML32
+		: data.includes('xmlns:gml="http://www.opengis.net/gml"')
+			? GML
+			: data.includes('xmlns:gml="http://www.opengis.net/gml/2')
+				? GML2
+				: GML3
+
+	return new WFS({
+		gmlFormat: new GMLFormat(),
+	})
+}
+
+/**
+ * A layer may have its parser specified in the configuration. In this case,
+ * the specified parser is retrieved from a list of supported GML parsers, or a
+ * custom text parser is used in case it fits.
+ * @param format - format as specified by mapConfiguration
+ * @returns object that supplies 'readTextFeatures' method
+ */
+function getParserFromFormat(format: string): Pick<WFS, 'readFeatures'> {
+	if (formats[format]) {
+		return new WFS({
+			gmlFormat: new formats[format](),
+		})
+	}
+
+	if (format === 'text') {
+		return {
+			readFeatures: readTextFeatures,
+		}
+	}
+
+	throw new Error(`Format '${format}' not yet implemented in requestGfiWms.ts.`)
+}
+
+/**
+ * @param parameters - map, layer, and coordinate to use for GFI request
+ * @returns url to request for feature information
+ */
+function getWmsGfiUrl(
+	{ map, layer, coordinate }: RequestGfiWmsParameters,
+	{ infoFormat }: Record<string, unknown>
+): string {
+	// Only layers with a valid source reach this point
+	const source = layer.getSource() as TileWMS
+	const view = map.getView()
+	const url = source.getFeatureInfoUrl(
+		coordinate,
+		// The view always has a resolution if this function is called
+		view.getResolution() as number,
+		view.getProjection(),
+		{
+			feature_count: 10,
+		}
+	)
+	const suffix =
+		infoFormat && typeof infoFormat === 'string'
+			? `&info_format=${infoFormat}`
+			: ''
+	return (url || '') + suffix
+}
+
+/**
+ * Method fetches WMS feature information. Result will be filtered and modified
+ * according to layerConfiguration.
+ * @param parameters - parameter object
+ * @returns promise of all features that hold relevant feature information
+ */
+export default (
+	parameters: RequestGfiWmsParameters
+): Promise<GeoJsonFeature[]> => {
+	const { coordinate, layerConfiguration, layerSpecification } = parameters
+	const { filterBy, geometryName, format } = layerConfiguration
+
+	const url = getWmsGfiUrl(parameters, layerSpecification)
+
+	return fetch(url)
+		.then((response) => response.text())
+		.then((data) => {
+			/* NOTE: test block for WMS GFI
+			import WMSGetFeatureInfo from 'ol/format/WMSGetFeatureInfo'
+			try {
+				console.error('WMS GFI', url)
+				console.error(new WMSGetFeatureInfo().readFeatures(data))
+			} catch (e) {
+				console.error(e)
+			}
+			*/
+
+			const parser =
+				layerSpecification.infoFormat === 'application/geojson'
+					? new GeoJSON()
+					: format
+						? getParserFromFormat(format)
+						: getParserFromData(data)
+
+			const parsedFeatures: Feature[] = parser.readFeatures(data)
+			const writer = new GeoJSON()
+
+			if (geometryName) {
+				parsedFeatures.forEach((f) => {
+					f.setGeometryName('geometry')
+				})
+			}
+
+			const jsonFeatures = parsedFeatures
+				// WMS may return features nearby - filter to hit features
+				.filter((feature) =>
+					filterBy === 'clickPosition'
+						? feature.getGeometry()?.intersectsCoordinate(coordinate)
+						: true
+				)
+				// transform to jsonable object representation
+				.map((f) => JSON.parse(writer.writeFeature(f)))
+
+			return jsonFeatures
+		})
+}
diff --git a/src/plugins/gfi/utils/updateTooltip.ts b/src/plugins/gfi/utils/updateTooltip.ts
new file mode 100644
index 0000000000..3726237f2e
--- /dev/null
+++ b/src/plugins/gfi/utils/updateTooltip.ts
@@ -0,0 +1,52 @@
+import type { Overlay } from 'ol'
+import type { MapBrowserEvent } from 'ol'
+import type { Tooltip } from '@/lib/tooltip'
+
+import { Feature } from 'ol'
+
+import { getTooltip } from '@/lib/tooltip'
+
+export function updateTooltip(
+	{ pixel, dragging, originalEvent, map }: MapBrowserEvent<PointerEvent>,
+	overlay: Overlay,
+	tooltipGenerators: Record<string, (feature: Feature) => [string, string][]>
+) {
+	if (dragging || ['touch', 'pen'].includes(originalEvent.pointerType)) {
+		return null
+	}
+
+	let hasFeatureAtPixel = false
+	let unregister: Tooltip['unregister'] | null = null
+
+	// stops on return `true`, thus only using the uppermost feature
+	map.forEachFeatureAtPixel(
+		pixel,
+		(feature, layer) => {
+			if (!(feature instanceof Feature)) {
+				return false
+			}
+			hasFeatureAtPixel = true
+			overlay.setPosition(map.getCoordinateFromPixel(pixel))
+			if (unregister) {
+				unregister()
+			}
+			let element: Tooltip['element']
+			;({ element, unregister } = getTooltip(
+				tooltipGenerators[layer.get('id')]?.(feature) as [string, string][]
+			))
+			overlay.setElement(element)
+			return true
+		},
+		{
+			layerFilter: (layer) =>
+				Object.keys(tooltipGenerators).includes(layer.get('id')),
+		}
+	)
+
+	// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+	if (!hasFeatureAtPixel) {
+		overlay.setPosition(undefined)
+	}
+
+	return unregister
+}
diff --git a/src/plugins/iconMenu/store.ts b/src/plugins/iconMenu/store.ts
index f0fd4ac858..694d3fc7f8 100644
--- a/src/plugins/iconMenu/store.ts
+++ b/src/plugins/iconMenu/store.ts
@@ -89,7 +89,14 @@ export const useIconMenuStore = defineStore('plugins/iconMenu', () => {
 			.concat(focusMenus.value)
 			.flat()
 			.forEach(({ plugin }) => {
-				coreStore.addPlugin(toMerged(plugin, { independent: false }))
+				coreStore.addPlugin(
+					toMerged(plugin, {
+						independent: false,
+						options: {
+							renderType: 'iconMenu',
+						},
+					})
+				)
 			})
 
 		const initiallyOpen = coreStore.configuration.iconMenu?.initiallyOpen
diff --git a/src/plugins/layerChooser/components/LayerOptions.ce.vue b/src/plugins/layerChooser/components/LayerOptions.ce.vue
index d8af39d8bf..33fb918525 100644
--- a/src/plugins/layerChooser/components/LayerOptions.ce.vue
+++ b/src/plugins/layerChooser/components/LayerOptions.ce.vue
@@ -72,12 +72,7 @@ onMounted(() => {
 	const layersInSource: string =
 		(
 			(
-				coreStore.map
-					.getLayers()
-					.getArray()
-					.find((l) => l.get('id') === openedOptionsId.value) as Layer<
-					ImageWMS | TileWMS
-				>
+				coreStore.getLayer(openedOptionsId.value) as Layer<ImageWMS | TileWMS>
 			).getSource() as ImageWMS | TileWMS
 		).getParams().LAYERS || ''
 	// NOTE: Reversing the array is needed to preserve the order that is displayed in the map.
diff --git a/src/plugins/layerChooser/index.ts b/src/plugins/layerChooser/index.ts
index 3e406f2f19..5fd26f2d70 100644
--- a/src/plugins/layerChooser/index.ts
+++ b/src/plugins/layerChooser/index.ts
@@ -4,7 +4,11 @@
  */
 /* eslint-enable tsdoc/syntax */
 
-import type { PluginContainer, PluginOptions, PolarPluginStore } from '@/core'
+import type {
+	InterfacePluginOptions,
+	PluginContainer,
+	PolarPluginStore,
+} from '@/core'
 
 import component from './components/LayerChooser.ce.vue'
 import locales from './locales'
@@ -25,7 +29,7 @@ import { PluginId } from './types'
  * @returns Plugin for use with {@link addPlugin}.
  */
 export default function pluginLayerChooser(
-	options: PluginOptions
+	options: InterfacePluginOptions
 ): PluginContainer {
 	return {
 		id: PluginId,
diff --git a/src/plugins/layerChooser/store.ts b/src/plugins/layerChooser/store.ts
index 2925c5a767..8f932bbc28 100644
--- a/src/plugins/layerChooser/store.ts
+++ b/src/plugins/layerChooser/store.ts
@@ -200,12 +200,7 @@ export const useLayerChooserStore = defineStore('plugins/layerChooser', () => {
 
 	function toggleOpenedOptionsServiceLayer(layerIds: string[]) {
 		const olSource = (
-			coreStore.map
-				.getLayers()
-				.getArray()
-				.find((l) => l.get('id') === openedOptionsId.value) as Layer<
-				ImageWMS | TileWMS
-			>
+			coreStore.getLayer(openedOptionsId.value) as Layer<ImageWMS | TileWMS>
 		).getSource()
 
 		if (!olSource) {
diff --git a/src/plugins/pins/store.ts b/src/plugins/pins/store.ts
index 7fdbbf4d6d..39e37a3d8a 100644
--- a/src/plugins/pins/store.ts
+++ b/src/plugins/pins/store.ts
@@ -13,7 +13,7 @@ import type { PinMovable, PinsPluginOptions } from './types'
 
 import { toMerged } from 'es-toolkit'
 import { pointerMove } from 'ol/events/condition'
-import { Draw, Modify, Select, Translate } from 'ol/interaction'
+import { Select, Translate } from 'ol/interaction'
 import { toLonLat } from 'ol/proj'
 import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
@@ -167,28 +167,12 @@ export const usePinsStore = defineStore('plugins/pins', () => {
 	}
 
 	async function click(coordinate: Coordinate) {
-		const isDrawing = coreStore.map
-			.getInteractions()
-			.getArray()
-			.some(
-				(interaction) =>
-					(interaction instanceof Draw &&
-						// @ts-expect-error | internal hack to detect it from gfi plugin
-						(interaction._isMultiSelect ||
-							// @ts-expect-error | internal hack to detect it from routing plugin
-							interaction._isRoutingDraw ||
-							// @ts-expect-error | internal hack to detect it from draw plugin
-							interaction._isDrawPlugin)) ||
-					interaction instanceof Modify ||
-					// @ts-expect-error | internal hack to detect it from draw plugin
-					interaction._isDeleteSelect
-			)
 		const { minZoomLevel, movable } = configuration.value
 		if (
 			(movable === 'drag' || movable === 'click') &&
 			// NOTE: It is assumed that getZoom actually returns the currentZoomLevel, thus the view has a constraint in the resolution.
 			(coreStore.map.getView().getZoom() as number) >= minZoomLevel &&
-			!isDrawing &&
+			!coreStore.isInteractionMasked('click') &&
 			(await isCoordinateInBoundaryLayer(
 				coordinate,
 				coreStore.map,
diff --git a/src/plugins/reverseGeocoder/store.ts b/src/plugins/reverseGeocoder/store.ts
index a867aa744e..fcc3cb35d7 100644
--- a/src/plugins/reverseGeocoder/store.ts
+++ b/src/plugins/reverseGeocoder/store.ts
@@ -16,6 +16,7 @@ import { Point } from 'ol/geom'
 import { acceptHMRUpdate, defineStore } from 'pinia'
 import { computed, ref, toRaw } from 'vue'
 
+import { useRefStore } from '@/composables/useRefStore'
 import { useStoreWatcher } from '@/composables/useStoreWatcher'
 import { useCoreStore } from '@/core/stores'
 import { indicateLoading } from '@/lib/indicateLoading'
@@ -60,9 +61,7 @@ export const useReverseGeocoderStore = defineStore(
 			target: NonNullable<ReverseGeocoderPluginOptions['addressTarget']>,
 			feature: ReverseGeocoderFeature
 		) {
-			const targetStore = target.plugin
-				? coreStore.getPluginStore(target.plugin)
-				: coreStore
+			const targetStore = useRefStore(target)
 			if (!targetStore) {
 				return
 			}
diff --git a/vue2/packages/plugins/Gfi/CHANGELOG.md b/vue2/packages/plugins/Gfi/CHANGELOG.md
deleted file mode 100644
index 98b4c31c9f..0000000000
--- a/vue2/packages/plugins/Gfi/CHANGELOG.md
+++ /dev/null
@@ -1,69 +0,0 @@
-# CHANGELOG
-
-## 3.1.0
-
-- Feature: Extend detection if a `Draw`-interaction is currently active to also check for `@polar/plugin-routing`.
-- Fix: When using the gfi with `renderType` set to `'independent'` the window was not added to the MoveHandle to be displayed on mobile devices. Also, the closeIcon was incorrectly set if `ƒeatureList` was configured. This has been fixed by watching for changes to `windowFeatures`.
-
-## 3.0.2
-
-- Fix: Allow layers that have `singleTile` set to `true` and thus being an `ImageLayer` instead a `TileLayer` to be used for GFI-requests as well.
-
-## 3.0.1
-
-- Fix: Clean-up internal flag used for `multiSelect` if a drawing is aborted. This is always the case if a user simply clicks into the map holding CTRL / Command.
-
-## 3.0.0
-
-- Breaking: Upgrade `@masterportal/masterportalapi` from `2.40.0` to `2.45.0` and subsequently `ol` from `^9.2.4` to `^10.3.1`.
-- Feature: Add new configuration parameter `multiSelect` to enable the possibility to choose between the selecting multiple features through a box or through a circle. The addition of this parameter deprecates the previously used parameter `boxSelect`.
-- Fix: Correctly disable `directSelect` if the user is currently using functionality of `@polar/plugin-draw`.
-
-## 2.1.0
-
-- Feature: Add new action `setFeatureInformation` to be able to set feature information in the store and trigger all relevant processes so that the information displayed to the user is as if he has selected the features himself.
-
-## 2.0.0
-
-- Breaking: Upgrade `@masterportal/masterportalapi` from `2.8.0` to `2.40.0` and subsequently `ol` from `^7.1.0` to `^9.2.4`.
-- Feature: Add new configuration parameter `isSelectable` that can be used to filter features to be unselectable.
-- Feature: Add new configuration parameters `directSelect` and `boxSelect` to be able to select multiple features at once.
-- Fix: Adjust documentation to properly describe optionality of configuration parameters.
-- Fix: Add missing configuration parameters `featureList` and `maxFeatures` to the general documentation and `filterBy` and `format` to `gfi.gfiLayerConfiguration`
-- Fix: Add missing entry of `gfiContentComponent` to `GfiGetters`.
-- Fix: Fix issue rendering properties of a feature if a value is not a string.
-- Refactor: Replace redundant prop-forwarding with `getters`.
-- Refactor: Use core getter `clientWidth` instead of local computed value.
-- Chore: expand on the description to `gfiContentComponent` in the Readme.md.
-
-## 1.2.2
-
-- Fix: The `close` method previously always removed the pin when not in `extendedMasterportalapiMarkers` mode. This issue has been resolved by distinguishing whether a close operation happened in effect to a direct closing user interaction or was technically motivated.
-
-## 1.2.1
-
-- Fix: Add missing deregistration of event listeners on destruction.
-
-## 1.2.0
-
-- Feature: Improved implementation to make plugin SPA-ready.
-- Feature: Improve WFS list highlighting with focus/hover styles that are easier to decipher for end users.
-- Feature: Add the possibility to update the close-button to e.g. indicate movement to the vector layer feature list.
-- Feature: Prevent tooltip windows on touch and pen events; now only mouse hover events produce such tooltips now.
-- Feature: If a feature with related features (cluster) is selected in the feature list, users can now toggle between the features with forward/backward buttons, just like when selecting clustered features in the map.
-- Feature: If a feature becomes clustered / is no longer clustered when zooming out / in, the selected features are updated properly now based on the selected cluster in the map.
-
-## 1.1.0
-
-- Feature: Add cluster-ready vector layer feature list with pagination, see configuration parameter `gfiLayerConfiguration.featureList`.
-- Feature: Can now be rendered as child of icon menu, see configuration parameter `renderType`.
-- Feature: Add optional configuration parameter `activeLayerPath` to allow checking for whether any fitting layer is active.
-- Feature: Add support for type `GeoJSON` layers.
-- Feature: Render mobile content in `MoveHandle` of `@polar/core`.
-- Fix: Add space to dev GFI window to fully contain close button effects.
-- Fix: Documentation error regarding plugin state.
-- Fix: `<img>`s constantly firing `onload`-event thus constantly firing `resize`.
-
-## 1.0.0
-
-Initial release.
diff --git a/vue2/packages/plugins/Gfi/LICENSE b/vue2/packages/plugins/Gfi/LICENSE
deleted file mode 100644
index c29ce2f835..0000000000
--- a/vue2/packages/plugins/Gfi/LICENSE
+++ /dev/null
@@ -1,287 +0,0 @@
-                      EUROPEAN UNION PUBLIC LICENCE v. 1.2
-                      EUPL © the European Union 2007, 2016
-
-This European Union Public Licence (the ‘EUPL’) applies to the Work (as defined
-below) which is provided under the terms of this Licence. Any use of the Work,
-other than as authorised under this Licence is prohibited (to the extent such
-use is covered by a right of the copyright holder of the Work).
-
-The Work is provided under the terms of this Licence when the Licensor (as
-defined below) has placed the following notice immediately following the
-copyright notice for the Work:
-
-        Licensed under the EUPL
-
-or has expressed by any other means his willingness to license under the EUPL.
-
-1. Definitions
-
-In this Licence, the following terms have the following meaning:
-
-- ‘The Licence’: this Licence.
-
-- ‘The Original Work’: the work or software distributed or communicated by the
-  Licensor under this Licence, available as Source Code and also as Executable
-  Code as the case may be.
-
-- ‘Derivative Works’: the works or software that could be created by the
-  Licensee, based upon the Original Work or modifications thereof. This Licence
-  does not define the extent of modification or dependence on the Original Work
-  required in order to classify a work as a Derivative Work; this extent is
-  determined by copyright law applicable in the country mentioned in Article 15.
-
-- ‘The Work’: the Original Work or its Derivative Works.
-
-- ‘The Source Code’: the human-readable form of the Work which is the most
-  convenient for people to study and modify.
-
-- ‘The Executable Code’: any code which has generally been compiled and which is
-  meant to be interpreted by a computer as a program.
-
-- ‘The Licensor’: the natural or legal person that distributes or communicates
-  the Work under the Licence.
-
-- ‘Contributor(s)’: any natural or legal person who modifies the Work under the
-  Licence, or otherwise contributes to the creation of a Derivative Work.
-
-- ‘The Licensee’ or ‘You’: any natural or legal person who makes any usage of
-  the Work under the terms of the Licence.
-
-- ‘Distribution’ or ‘Communication’: any act of selling, giving, lending,
-  renting, distributing, communicating, transmitting, or otherwise making
-  available, online or offline, copies of the Work or providing access to its
-  essential functionalities at the disposal of any other natural or legal
-  person.
-
-2. Scope of the rights granted by the Licence
-
-The Licensor hereby grants You a worldwide, royalty-free, non-exclusive,
-sublicensable licence to do the following, for the duration of copyright vested
-in the Original Work:
-
-- use the Work in any circumstance and for all usage,
-- reproduce the Work,
-- modify the Work, and make Derivative Works based upon the Work,
-- communicate to the public, including the right to make available or display
-  the Work or copies thereof to the public and perform publicly, as the case may
-  be, the Work,
-- distribute the Work or copies thereof,
-- lend and rent the Work or copies thereof,
-- sublicense rights in the Work or copies thereof.
-
-Those rights can be exercised on any media, supports and formats, whether now
-known or later invented, as far as the applicable law permits so.
-
-In the countries where moral rights apply, the Licensor waives his right to
-exercise his moral right to the extent allowed by law in order to make effective
-the licence of the economic rights here above listed.
-
-The Licensor grants to the Licensee royalty-free, non-exclusive usage rights to
-any patents held by the Licensor, to the extent necessary to make use of the
-rights granted on the Work under this Licence.
-
-3. Communication of the Source Code
-
-The Licensor may provide the Work either in its Source Code form, or as
-Executable Code. If the Work is provided as Executable Code, the Licensor
-provides in addition a machine-readable copy of the Source Code of the Work
-along with each copy of the Work that the Licensor distributes or indicates, in
-a notice following the copyright notice attached to the Work, a repository where
-the Source Code is easily and freely accessible for as long as the Licensor
-continues to distribute or communicate the Work.
-
-4. Limitations on copyright
-
-Nothing in this Licence is intended to deprive the Licensee of the benefits from
-any exception or limitation to the exclusive rights of the rights owners in the
-Work, of the exhaustion of those rights or of other applicable limitations
-thereto.
-
-5. Obligations of the Licensee
-
-The grant of the rights mentioned above is subject to some restrictions and
-obligations imposed on the Licensee. Those obligations are the following:
-
-Attribution right: The Licensee shall keep intact all copyright, patent or
-trademarks notices and all notices that refer to the Licence and to the
-disclaimer of warranties. The Licensee must include a copy of such notices and a
-copy of the Licence with every copy of the Work he/she distributes or
-communicates. The Licensee must cause any Derivative Work to carry prominent
-notices stating that the Work has been modified and the date of modification.
-
-Copyleft clause: If the Licensee distributes or communicates copies of the
-Original Works or Derivative Works, this Distribution or Communication will be
-done under the terms of this Licence or of a later version of this Licence
-unless the Original Work is expressly distributed only under this version of the
-Licence — for example by communicating ‘EUPL v. 1.2 only’. The Licensee
-(becoming Licensor) cannot offer or impose any additional terms or conditions on
-the Work or Derivative Work that alter or restrict the terms of the Licence.
-
-Compatibility clause: If the Licensee Distributes or Communicates Derivative
-Works or copies thereof based upon both the Work and another work licensed under
-a Compatible Licence, this Distribution or Communication can be done under the
-terms of this Compatible Licence. For the sake of this clause, ‘Compatible
-Licence’ refers to the licences listed in the appendix attached to this Licence.
-Should the Licensee's obligations under the Compatible Licence conflict with
-his/her obligations under this Licence, the obligations of the Compatible
-Licence shall prevail.
-
-Provision of Source Code: When distributing or communicating copies of the Work,
-the Licensee will provide a machine-readable copy of the Source Code or indicate
-a repository where this Source will be easily and freely available for as long
-as the Licensee continues to distribute or communicate the Work.
-
-Legal Protection: This Licence does not grant permission to use the trade names,
-trademarks, service marks, or 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 copyright notice.
-
-6. Chain of Authorship
-
-The original Licensor warrants that the copyright in the Original Work granted
-hereunder is owned by him/her or licensed to him/her and that he/she has the
-power and authority to grant the Licence.
-
-Each Contributor warrants that the copyright in the modifications he/she brings
-to the Work are owned by him/her or licensed to him/her and that he/she has the
-power and authority to grant the Licence.
-
-Each time You accept the Licence, the original Licensor and subsequent
-Contributors grant You a licence to their contributions to the Work, under the
-terms of this Licence.
-
-7. Disclaimer of Warranty
-
-The Work is a work in progress, which is continuously improved by numerous
-Contributors. It is not a finished work and may therefore contain defects or
-‘bugs’ inherent to this type of development.
-
-For the above reason, the Work is provided under the Licence on an ‘as is’ basis
-and without warranties of any kind concerning the Work, including without
-limitation merchantability, fitness for a particular purpose, absence of defects
-or errors, accuracy, non-infringement of intellectual property rights other than
-copyright as stated in Article 6 of this Licence.
-
-This disclaimer of warranty is an essential part of the Licence and a condition
-for the grant of any rights to the Work.
-
-8. Disclaimer of Liability
-
-Except in the cases of wilful misconduct or damages directly caused to natural
-persons, the Licensor will in no event be liable for any direct or indirect,
-material or moral, damages of any kind, arising out of the Licence or of the use
-of the Work, including without limitation, damages for loss of goodwill, work
-stoppage, computer failure or malfunction, loss of data or any commercial
-damage, even if the Licensor has been advised of the possibility of such damage.
-However, the Licensor will be liable under statutory product liability laws as
-far such laws apply to the Work.
-
-9. Additional agreements
-
-While distributing the Work, You may choose to conclude an additional agreement,
-defining obligations or services consistent with this Licence. However, if
-accepting obligations, You may act only on your own behalf and on your sole
-responsibility, not on behalf of the original Licensor or 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
-the fact You have accepted any warranty or additional liability.
-
-10. Acceptance of the Licence
-
-The provisions of this Licence can be accepted by clicking on an icon ‘I agree’
-placed under the bottom of a window displaying the text of this Licence or by
-affirming consent in any other similar way, in accordance with the rules of
-applicable law. Clicking on that icon indicates your clear and irrevocable
-acceptance of this Licence and all of its terms and conditions.
-
-Similarly, you irrevocably accept this Licence and all of its terms and
-conditions by exercising any rights granted to You by Article 2 of this Licence,
-such as the use of the Work, the creation by You of a Derivative Work or the
-Distribution or Communication by You of the Work or copies thereof.
-
-11. Information to the public
-
-In case of any Distribution or Communication of the Work by means of electronic
-communication by You (for example, by offering to download the Work from a
-remote location) the distribution channel or media (for example, a website) must
-at least provide to the public the information requested by the applicable law
-regarding the Licensor, the Licence and the way it may be accessible, concluded,
-stored and reproduced by the Licensee.
-
-12. Termination of the Licence
-
-The Licence and the rights granted hereunder will terminate automatically upon
-any breach by the Licensee of the terms of the Licence.
-
-Such a termination will not terminate the licences of any person who has
-received the Work from the Licensee under the Licence, provided such persons
-remain in full compliance with the Licence.
-
-13. Miscellaneous
-
-Without prejudice of Article 9 above, the Licence represents the complete
-agreement between the Parties as to the Work.
-
-If any provision of the Licence is invalid or unenforceable under applicable
-law, this will not affect the validity or enforceability of the Licence as a
-whole. Such provision will be construed or reformed so as necessary to make it
-valid and enforceable.
-
-The European Commission may publish other linguistic versions or new versions of
-this Licence or updated versions of the Appendix, so far this is required and
-reasonable, without reducing the scope of the rights granted by the Licence. New
-versions of the Licence will be published with a unique version number.
-
-All linguistic versions of this Licence, approved by the European Commission,
-have identical value. Parties can take advantage of the linguistic version of
-their choice.
-
-14. Jurisdiction
-
-Without prejudice to specific agreement between parties,
-
-- any litigation resulting from the interpretation of this License, arising
-  between the European Union institutions, bodies, offices or agencies, as a
-  Licensor, and any Licensee, will be subject to the jurisdiction of the Court
-  of Justice of the European Union, as laid down in article 272 of the Treaty on
-  the Functioning of the European Union,
-
-- any litigation arising between other parties and resulting from the
-  interpretation of this License, will be subject to the exclusive jurisdiction
-  of the competent court where the Licensor resides or conducts its primary
-  business.
-
-15. Applicable Law
-
-Without prejudice to specific agreement between parties,
-
-- this Licence shall be governed by the law of the European Union Member State
-  where the Licensor has his seat, resides or has his registered office,
-
-- this licence shall be governed by Belgian law if the Licensor has no seat,
-  residence or registered office inside a European Union Member State.
-
-Appendix
-
-‘Compatible Licences’ according to Article 5 EUPL are:
-
-- GNU General Public License (GPL) v. 2, v. 3
-- GNU Affero General Public License (AGPL) v. 3
-- Open Software License (OSL) v. 2.1, v. 3.0
-- Eclipse Public License (EPL) v. 1.0
-- CeCILL v. 2.0, v. 2.1
-- Mozilla Public Licence (MPL) v. 2
-- GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3
-- Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) for
-  works other than software
-- European Union Public Licence (EUPL) v. 1.1, v. 1.2
-- Québec Free and Open-Source Licence — Reciprocity (LiLiQ-R) or Strong
-  Reciprocity (LiLiQ-R+).
-
-The European Commission may update this Appendix to later versions of the above
-licences without producing a new version of the EUPL, as long as they provide
-the rights granted in Article 2 of this Licence and protect the covered Source
-Code from exclusive appropriation.
-
-All other changes or additions to this Appendix require the production of a new
-EUPL version.
\ No newline at end of file
diff --git a/vue2/packages/plugins/Gfi/README.md b/vue2/packages/plugins/Gfi/README.md
deleted file mode 100644
index a7c9e9e05f..0000000000
--- a/vue2/packages/plugins/Gfi/README.md
+++ /dev/null
@@ -1,242 +0,0 @@
-# GFI
-
-## Scope
-
-The GFI plugin can be used to fetch and optionally display GFI (GetFeatureInfo) from WMS and WFS services as well as layers based on GeoJSON files. In a first step, the information is stored in the VueX store to allow for easy access. Display is optional and quite obstructive within the map client.
-
-> ⚠️ The display feature is currently not meant for production. Please use data bindings for display to avoid obstructing the map client.
-
-## Configuration
-
-### gfi
-
-| fieldName | type | description |
-| - | - | - |
-| coordinateSources | string[] | The GFI plugin will react to these coordinate positions in the store. This allows it to react to e.g. the address search of the pins plugin. Please see example configuration for the common use-cases. Please mind that, when referencing another plugin, that plugin must be in `addPlugins` before this one. |
-| layers | Record<string, gfiLayerConfiguration> | Maps a string (must be a layer ID) to a behaviour configuration for that layer. |
-| activeLayerPath | string? | Optional store path to array of active mask layer ids. If used with `LayerChooser`, setting this to `'plugin/layerChooser/activeMaskIds'` will result in an info text in the GFI box, should no layer be active. If used without `LayerChooser`, the active mask layers have to be provided by another plugin or the client. If not set, the GFI plugin may e.g. show an empty list, which may be confusing to some users. |
-| afterLoadFunction | function (featuresByLayerId: Record<string, GeoJsonFeature[]>): Record<layerId, GeoJsonFeature[]>? | This method can be used to extend, filter, or otherwise modify a GFI result. |
-| boxSelect | boolean? | **This parameter has been deprecated. Please use `multiSelect` to `'box'` instead.** If set to `true`, multiple features can be selected at once by using the modifier key (CTRL on Windows or Command on macOS) and dragging the mouse. Can only be used in Desktop environments. Similar to `gfi.directSelect`, features can be added and removed by selection / unselecting them. The features need to be distinguishable by their properties for the functionality to properly work. Does not work together with `extendedMasterportalapiMarkers` of `@polar/core`. Defaults to `false`. |
-| customHighlightStyle | customHighlightStyle? | If required a user can change the stroke and fill of the highlighted feature. The default style as seen in the example will be used for each part that is not customized. An empty object will return the complete default style while e.g. for an object without a configured fill the default fill will be applied. |
-| directSelect | boolean? | If set to `true`, a feature can be selected without defining a value in `gfi.coordinateSources`. It is also possible to add multiple features to the selection by using the modifier key (CTRL on Windows or Command on macOS). To delesect a feature, simply reclick it with the modifier key pressed. To create a new selection, click anywhere else without pressing the modifier key. Be careful when using this parameter together with some values set in `coordinateSources` as it may lead to unexpected results. The features need to be distinguishable by their properties for the functionality to properly work. Does not work together with `extendedMasterportalapiMarkers` of `@polar/core`. Defaults to `false`. |
-| featureList | featureList? | If defined, a list of available vector layer features is visible when no feature is selected. Only usable if `renderType` is set to `iconMenu` and `window` is set to `true` for at least one configured layer. |
-| gfiContentComponent | VueConstructor? | Allows overriding the GfiContent.vue component for custom design and functionality. Coding knowledge is required to use this feature, as any implementation will have to rely upon the VueX store model. Please refer to the implementation. |
-| maxFeatures | number? | Limits the viewable GFIs per layer by this number. The first n elements are chosen arbitrarily. Useful if you e.g. just want one result, or to limit an endless stream of returns to e.g. 10. Infinite by default. |
-| mode | enum["bboxDot", "intersects"]? | Method of calculating which feature has been chosen by the user. `bboxDot` utilizes the `bbox`-url parameter using the clicked coordinate while `intersects` uses a `Filter` to calculate the intersected features. Layers can have their own `gfiMode` parameter which would override this global mode. To apply this, add the desired value to the parameter in the `mapConfiguration`. Defaults to `'bboxDot'`. |
-| multiSelect | enum["box", "circle"]? | If configured, multiple features can be selected at once by using the modifier key (CTRL on Windows or Command on macOS) and dragging the mouse. Can only be used in Desktop environments. If set to `'box'`, the selection will be done in a box. If set to `'circle'`, the selection will be done in a circle. Similar to `gfi.directSelect`, features can be added and removed by selection / unselecting them. The features need to be distinguishable by their properties for the functionality to properly work. Does not work together with `extendedMasterportalapiMarkers` of `@polar/core`. Is disabled by default. |
-| renderType | ('iconMenu' \| 'independent')? | Only relevant if `window` is set to `true` for at least one layer. Whether the gfi plugin is rendered independently or as part of the IconMenu. Defaults to 'independent'. |
-
-For details on the `displayComponent` attribute, refer to the [Global Plugin Parameters](../../core/README.md#global-plugin-parameters) section of `@polar/core`.
-
-<details>
-<summary>Example configuration</summary>
-
-```ts
-import Component from '.component/vue'
-
-gfi: {
-  mode: 'bboxDot',
-  activeLayerPath: 'plugin/layerChooser/activeMaskIds',
-  afterLoadFunction: afterLoadFunction,
-  layers: {
-    'layerId': {
-      geometry: true,
-      window: true,
-      maxFeatures: 10,
-      geometryName: 'app:geometry',
-      exportProperty: 'Export',
-    },
-  },
-  coordinateSources: [
-    'plugin/pins/transformedCoordinate',
-    'plugin/pins/coordinatesAfterDrag',
-  ],
-  customHighlightStyle: {
-    stroke: {
-      color: '#FFFF00',
-      width: 3,
-    },
-    fill: {
-      color: 'rgb(255, 255, 255, 0.7)',
-    },
-  },
-  gfiContentComponent: Component,
-}
-
-function afterLoadFunction(featuresByLayerId: Record<string, GeoJsonFeature[]>): Record<string, GeoJsonFeature[]> {
-  const filteredFeaturesByLayerId: Record<string, GeoJsonFeature[]> = {};
-
-  for (const layerId in featuresByLayerId) {
-    if (featuresByLayerId.hasOwnProperty(layerId)) {
-      const features = featuresByLayerId[layerId];
-      filteredFeaturesByLayerId[layerId] = features.filter(feature => feature.properties.type === 'desiredType');
-    }
-  }
-
-  return filteredFeaturesByLayerId;
-}
-```
-
-</details>
-
-#### gfi.gfiLayerConfiguration
-
-| fieldName | type | description |
-| - | - | - |
-| exportProperty | string? | Property of the features of a service having an url usable to trigger a download of features as a document. |
-| geometry | boolean? | If true, feature geometry will be highlighted within the map. Defaults to `false`. |
-| geometryName | string? | Name of the geometry property if not the default field. |
-| isSelectable | ((feature: GeoJsonFeature) => boolean)? | A function can be defined to allow filtering features to be either selectable (return `true`) or not. Unselectable features will be filtered out by the GFI plugin and have neither GFI display nor store presence, but may be visible in the map nonetheless, depending on your other configuration. Please also mind that usage in combination with `extendedMasterportalapiMarkers` requires further configuration of that feature for smooth UX; see the respective documentation of `@polar/core`. |
-| properties | Record<propertyName, displayName>/string[]? | In case `window` is `true`, this will be used to determine which contents to show. In case of an array, keys are used to select properties. In case of an object, keys are used to select properties, but will be titles as their respective values. Displays all properties by default. |
-| showTooltip | ((feature: Feature) => [string, string][])? | If given, a tooltip will be shown with the values calculated for the feature. The first string is the HTML tag to render, the second its contents; contants may be locale keys. For more information regarding the strings, see the documentation of the `@polar/lib-tooltip` package. Defaults to `undefined`. Please mind that tooltips will only be shown if a mouse is used or the hovering device could not be detected. Touch and pen interactions do not open tooltips since they will open the GFI window, rendering the gatherable information redundant. |
-| window | boolean? | If true, properties will be shown in the map client. Defaults to `false`. |
-
-Example configuration:
-
-```js
-layers: {
-  'layerId': {
-    geometry: true,
-    window: true,
-    maxFeatures: 10,
-    geometryName: 'app:geometry',
-    exportProperty: 'Export',
-    properties: {
-      status: 'status',
-      type: 'type',
-    },
-    showTooltip: (feature: Feature): [string, string][] => {
-      return [
-        ['div', `Feature ID: ${feature.properties.id}`],
-        ['span', `Coordinates: ${feature.geometry.coordinates.join(', ')}`]
-      ];
-    },
-    isSelectable: (feature: Feature): boolean => Boolean(Math.random() < 0.5)
-  },
-}
-```
-
-Additionally, if using a WMS service, the following properties can be configured as well.
-
-| fieldName | type | description |
-| - | - | - |
-| filterBy | 'clickPosition'? | Some WMS services may return features close to the clicked position. By setting the value `clickPosition`, only features that intersect the clicked position are shown to the user. Defaults to showing all features. |
-| format | 'GML' \| 'GML2' \| 'GML3' \| 'GML32' \| 'text'? | If the `infoFormat` is not set to `'application/geojson'`´, this can be configured to be the known file format of the response. If not given, the format is parsed from the response data. |
-
-Example configuration:
-
-```js
-layers: {
-  'layerId': {
-    geometry: true,
-    window: true,
-    maxFeatures: 10,
-    geometryName: 'app:geometry',
-    filterBy: 'clickPosition',
-    format: 'text',
-  },
-}
-```
-
-#### gfi.customHighlightStyle
-
-| fieldName | type | description |
-| - | - | - |
-| fill | ol/style/Fill? | Object for defining the fill style. See [OpenLayers documentation](https://openlayers.org/en/latest/apidoc/module-ol_style_Fill-Fill.html) for full options. |
-| stroke | ol/style/Stroke? | Object for defining the stroke style. See [OpenLayers documentation](https://openlayers.org/en/latest/apidoc/module-ol_style_Stroke-Stroke.html) for full options. |
-
-Example configuration:
-```js
-customHighlightStyle: {
-  stroke: {
-    color: '#FFFF00',
-    width: 3,
-  },
-  fill: {
-    color: 'rgb(255, 255, 255, 0.7)',
-  },
-},
-```
-
-#### gfi.featureList
-
-| fieldName | type | description |
-| - | - | - |
-| mode | 'visible' \| 'loaded' | Whether to show only features currently visible in the map view's bounding box or to display all loaded features. In the latter case, if you desire to display all features of a layer (seen or not), set its loading strategy to `'all'`. The loading strategy is a value in the OpenLayers vector source configuration; see [ol/loadingStrategy](https://openlayers.org/en/latest/apidoc/module-ol_loadingstrategy.html) for further details. |
-| bindWithCoreHoverSelect | boolean? | If `true`, the hover/select fields in the core's state will be listened to and interacted with. This will result in a bilateral hovering and selecting of features with the core. Defaults to `false`. |
-| pageLength | number? | A number >0 that sets the limit to the feature list's length. If the length is surpassed, additional features can be reached by using the pagination that is generated in such a case. If not defined, the list can be of arbitrary length. |
-| text | (function \| string)[]? | Array of one to three entries that will produce title, subtitle, and an additional subtitle for the list view. If string, the text item will simply be that feature's value for the denoted property. If function, it's assumed to match the function signature `(feature: OpenLayersFeature): string`, and the returned string will be used for the text item. |
-
-Example configuration:
-```js
-featureList: {
-  mode: 'visible',
-  bindWithCoreHoverSelect: true,
-  pageLength: 5,
-  text: ['Nature reserves', (feature) => `${feature.get('str')} ${feature.get('hsnr')}`]
-}
-```
-
-## Store
-
-### Actions
-
-#### setFeatureInformation
-
-This method can be used to set the feature information in the store and trigger all relevant processes so that the information displayed to the user is as if he has selected the features himself.  
-Note that calling this method completely overrides the previously set feature information.
-
-If a layer has a `isSelectable`-function configured, the features are filtered using that function.
-
-```js
-map.$store.dispatch('plugin/gfi/setFeatureInformation', {
-  "anotherLayer": [],
-  "yetAnotherLayer": [],
-  "relevantInformation": [
-    {
-      "type": "Feature",
-      "geometry": {
-        "type": "Point",
-        "coordinates": [
-          565669.6521397199,
-          5930516.358614317
-        ]
-      },
-      "properties": {
-        "propertyOne": "B0",
-        "propertyTwo": "B1"
-      }
-    },
-    {
-      "type": "Feature",
-      "geometry": {
-        "type": "Point",
-        "coordinates": [
-          565594.9377660984,
-          5930524.52634174
-        ]
-      },
-      "properties": {
-        propertyOne: "A0",
-        propertyTwo: "A1"
-      }
-    }
-  ]
-})
-```
-
-The payload object expects a layer id as a key and an array of GeoJSON-Features as its value.
-
-The selected feature information can be reset by calling the method with an empty object.
-
-### State
-
-If a successful query has been sent and a response has been received, the result will be saved in the store and can be subscribed through the path `'plugin/gfi/featureInformation'`. If, however, a query for a layer fails, a `Symbol` containing the error will be saved in the store instead to indicate the error.
-
-The exact value of `featureInformation` may vary wildly depending on the service used, but is always given as json representation here.
-
-```js
-map.subscribe('plugin/gfi/featureInformation', (featureInformation) => {
-  /* Your code here */
-})
-```
diff --git a/vue2/packages/plugins/Gfi/package.json b/vue2/packages/plugins/Gfi/package.json
deleted file mode 100644
index 00ec840b2e..0000000000
--- a/vue2/packages/plugins/Gfi/package.json
+++ /dev/null
@@ -1,44 +0,0 @@
-{
-  "name": "@polar/plugin-gfi",
-  "version": "3.1.0",
-  "description": "Gfi plugin for POLAR that adds feature information retrieval. UI elements can be provided by configuration, else it works as a store integration.",
-  "keywords": [
-    "OpenLayers",
-    "ol",
-    "POLAR",
-    "plugin",
-    "gfi",
-    "feature information"
-  ],
-  "license": "EUPL-1.2",
-  "type": "module",
-  "author": "Dataport AöR <polar@dataport.de>",
-  "main": "src/index.ts",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Dataport/polar.git",
-    "directory": "packages/plugins/Gfi"
-  },
-  "files": [
-    "src/**/*",
-    "CHANGELOG.md"
-  ],
-  "peerDependencies": {
-    "@masterportal/masterportalapi": "2.48.0",
-    "@repositoryname/vuex-generators": "^1.1.2",
-    "ol": "^10.4.0",
-    "vue": "^2.6.14",
-    "vuex": "^3.6.2"
-  },
-  "dependencies": {
-    "just-compare": "^2.3.0",
-    "lodash.debounce": "^4.0.8"
-  },
-  "devDependencies": {
-    "@polar/lib-custom-types": "^2.2.0",
-    "@polar/lib-get-cluster": "^3.0.0",
-    "@polar/lib-invisible-style": "^3.0.0",
-    "@polar/lib-test-mount-parameters": "^1.4.0",
-    "@polar/lib-tooltip": "^1.0.0"
-  }
-}
diff --git a/vue2/packages/plugins/Gfi/src/components/Feature.vue b/vue2/packages/plugins/Gfi/src/components/Feature.vue
deleted file mode 100644
index 243eaf5636..0000000000
--- a/vue2/packages/plugins/Gfi/src/components/Feature.vue
+++ /dev/null
@@ -1,70 +0,0 @@
-<template>
-  <div>
-    <div
-      v-if="!hasWindowSize || !hasSmallWidth"
-      class="polar-plugin-gfi-button-container"
-    >
-      <v-btn
-        id="polar-plugin-gfi-close-button"
-        icon
-        small
-        :aria-label="$t(closeLabel)"
-        @click="close(true)"
-      >
-        <v-icon>fa-xmark</v-icon>
-      </v-btn>
-    </div>
-    <v-simple-table class="polar-edgy-table" dense>
-      <template #default>
-        <FeatureTableHead></FeatureTableHead>
-        <FeatureTableBody></FeatureTableBody>
-      </template>
-    </v-simple-table>
-    <FeatureButtonGroup
-      v-if="exportProperty || showSwitchButtons"
-    ></FeatureButtonGroup>
-  </div>
-</template>
-
-<script lang="ts">
-import Vue from 'vue'
-import { mapActions, mapGetters } from 'vuex'
-import FeatureButtonGroup from './FeatureButtonGroup.vue'
-import FeatureTableBody from './FeatureTableBody.vue'
-import FeatureTableHead from './FeatureTableHead.vue'
-
-export default Vue.extend({
-  name: 'GfiFeature',
-  components: {
-    FeatureButtonGroup,
-    FeatureTableBody,
-    FeatureTableHead,
-  },
-  data: () => ({ closeLabel: 'plugins.gfi.header.close' }),
-  computed: {
-    ...mapGetters(['hasSmallWidth', 'hasWindowSize']),
-    ...mapGetters('plugin/gfi', ['exportProperty', 'showSwitchButtons']),
-  },
-  methods: {
-    ...mapActions('plugin/gfi', ['close']),
-  },
-})
-</script>
-
-<style lang="scss" scoped>
-.polar-plugin-gfi-button-container {
-  display: grid;
-  align-items: center;
-  background-color: #ffffff;
-  padding: 0.25em;
-
-  #polar-plugin-gfi-close-button {
-    grid-column: 3;
-    justify-self: end;
-  }
-}
-
-.polar-edgy-table {
-  border-radius: 0;
-}
-</style>
diff --git a/vue2/packages/plugins/Gfi/src/components/FeatureButtonGroup.vue b/vue2/packages/plugins/Gfi/src/components/FeatureButtonGroup.vue
deleted file mode 100644
index d40a83342f..0000000000
--- a/vue2/packages/plugins/Gfi/src/components/FeatureButtonGroup.vue
+++ /dev/null
@@ -1,56 +0,0 @@
-<template>
-  <div id="polar-plugin-gfi-button-group">
-    <div>
-      <v-btn
-        v-if="exportProperty"
-        id="polar-plugin-gfi-export-link"
-        elevation="2"
-        class="ma-2 text-none reticent-button primaryContrast--text"
-        color="primary"
-        :href="exportProperty"
-        target="_blank"
-        :title="$t('plugins.gfi.property.linkTitle')"
-        :aria-label="$t('plugins.gfi.property.export')"
-        onmousedown="return false"
-      >
-        {{ $t('plugins.gfi.property.export') }}
-      </v-btn>
-    </div>
-    <FeatureSwitchButtons v-if="showSwitchButtons"></FeatureSwitchButtons>
-  </div>
-</template>
-
-<script lang="ts">
-import Vue from 'vue'
-import { mapGetters } from 'vuex'
-import FeatureSwitchButtons from './FeatureSwitchButtons.vue'
-
-export default Vue.extend({
-  name: 'GfiFeatureButtonGroup',
-  components: {
-    FeatureSwitchButtons,
-  },
-  computed: {
-    ...mapGetters('plugin/gfi', ['exportProperty', 'showSwitchButtons']),
-  },
-})
-</script>
-
-<style lang="scss" scoped>
-#polar-plugin-gfi-button-group {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  background-color: #ffffff;
-
-  #polar-plugin-gfi-export-link {
-    text-decoration: none;
-    color: white !important;
-  }
-
-  .reticent-button {
-    font-size: 14px;
-    letter-spacing: normal;
-  }
-}
-</style>
diff --git a/vue2/packages/plugins/Gfi/src/components/FeatureSwitchButtons.vue b/vue2/packages/plugins/Gfi/src/components/FeatureSwitchButtons.vue
deleted file mode 100644
index 4afd420dd9..0000000000
--- a/vue2/packages/plugins/Gfi/src/components/FeatureSwitchButtons.vue
+++ /dev/null
@@ -1,69 +0,0 @@
-<template>
-  <div id="polar-gfi-switch-buttons">
-    <v-btn
-      elevation="2"
-      class="ma-2"
-      fab
-      x-small
-      :aria-label="$t('plugins.gfi.switch.previous')"
-      @click="switchFeature(-1)"
-    >
-      <v-icon>fa-chevron-left</v-icon>
-    </v-btn>
-    <v-btn
-      elevation="2"
-      class="ma-2"
-      fab
-      x-small
-      :aria-label="$t('plugins.gfi.switch.next')"
-      @click="switchFeature(1)"
-    >
-      <v-icon>fa-chevron-right</v-icon>
-    </v-btn>
-  </div>
-</template>
-
-<script lang="ts">
-import Vue from 'vue'
-import { mapGetters, mapMutations } from 'vuex'
-
-type GfiIndexStep = -1 | 1
-
-export default Vue.extend({
-  name: 'GfiFeatureSwitchButtons',
-  computed: {
-    ...mapGetters('plugin/gfi', [
-      'windowFeatures',
-      'visibleWindowFeatureIndex',
-    ]),
-  },
-  methods: {
-    ...mapMutations('plugin/gfi', ['setVisibleWindowFeatureIndex']),
-    /** switch to next or previous feature */
-    switchFeature(by: GfiIndexStep): void {
-      const {
-        visibleWindowFeatureIndex,
-        windowFeatures,
-        setVisibleWindowFeatureIndex,
-      } = this
-      const maxIndex = windowFeatures.length - 1
-      const nextIndex = visibleWindowFeatureIndex + by
-      if (nextIndex < 0) {
-        setVisibleWindowFeatureIndex(windowFeatures.length - 1)
-        return
-      }
-      if (nextIndex > maxIndex) {
-        setVisibleWindowFeatureIndex(0)
-        return
-      }
-      setVisibleWindowFeatureIndex(nextIndex)
-    },
-  },
-})
-</script>
-
-<style lang="scss" scoped>
-#polar-gfi-switch-buttons {
-  float: right !important;
-}
-</style>
diff --git a/vue2/packages/plugins/Gfi/src/components/FeatureTableBody.vue b/vue2/packages/plugins/Gfi/src/components/FeatureTableBody.vue
deleted file mode 100644
index 242f38c226..0000000000
--- a/vue2/packages/plugins/Gfi/src/components/FeatureTableBody.vue
+++ /dev/null
@@ -1,71 +0,0 @@
-<template>
-  <tbody>
-    <tr v-for="[key, value] of Object.entries(filteredProperties)" :key="key">
-      <td>{{ key }}</td>
-      <td
-        v-if="
-          typeof value === 'string' &&
-          value.match(/\.(jpeg|jpg|gif|png)$/) !== null
-        "
-      >
-        <a :href="value" target="_blank">
-          <img
-            :src="value"
-            :alt="$t('plugins.gfi.property.imageAlt')"
-            :title="$t('plugins.gfi.property.linkTitle')"
-            :aria-label="$t('plugins.gfi.property.linkTitle')"
-            :height="photoHeight"
-            width="auto"
-          />
-        </a>
-      </td>
-      <td v-else-if="isValidHttpUrl(value)">
-        <a
-          :href="value"
-          target="_blank"
-          :title="$t('plugins.gfi.property.linkTitle')"
-          :aria-label="$t('plugins.gfi.property.linkTitle')"
-        >
-          {{ 'Link' }}
-        </a>
-      </td>
-      <td v-else>
-        {{ value }}
-      </td>
-    </tr>
-  </tbody>
-</template>
-
-<script lang="ts">
-import Vue from 'vue'
-import { mapGetters } from 'vuex'
-import isValidHttpUrl from '../utils/isValidHttpUrl'
-
-export default Vue.extend({
-  name: 'GfiFeatureTableBody',
-  computed: {
-    ...mapGetters(['clientWidth']),
-    ...mapGetters('plugin/gfi', ['currentProperties']),
-    /** Removes polarInternalLayerKey as it shouldn't be displayed to the user. */
-    filteredProperties() {
-      if (this.currentProperties) {
-        return Object.fromEntries(
-          Object.entries(this.currentProperties).filter(
-            ([key]) => key !== 'polarInternalLayerKey'
-          )
-        )
-      }
-      return {}
-    },
-    photoHeight() {
-      const height = this.clientWidth * 0.15
-      return height < 200 ? 200 : height
-    },
-  },
-  methods: {
-    isValidHttpUrl,
-  },
-})
-</script>
-
-<style lang="scss" scoped></style>
diff --git a/vue2/packages/plugins/Gfi/src/components/FeatureTableHead.vue b/vue2/packages/plugins/Gfi/src/components/FeatureTableHead.vue
deleted file mode 100644
index 890b2f3d39..0000000000
--- a/vue2/packages/plugins/Gfi/src/components/FeatureTableHead.vue
+++ /dev/null
@@ -1,18 +0,0 @@
-<template>
-  <thead>
-    <tr>
-      <th class="text-left">{{ $t('plugins.gfi.header.field') }}</th>
-      <th class="text-left">{{ $t('plugins.gfi.header.value') }}</th>
-    </tr>
-  </thead>
-</template>
-
-<script lang="ts">
-import Vue from 'vue'
-
-export default Vue.extend({
-  name: 'GfiFeatureTableHead',
-})
-</script>
-
-<style lang="scss" scoped></style>
diff --git a/vue2/packages/plugins/Gfi/src/components/Gfi.vue b/vue2/packages/plugins/Gfi/src/components/Gfi.vue
deleted file mode 100644
index f81b8c34c3..0000000000
--- a/vue2/packages/plugins/Gfi/src/components/Gfi.vue
+++ /dev/null
@@ -1,103 +0,0 @@
-<template>
-  <div v-if="renderUi" id="polar-plugin-gfi">
-    <v-card v-if="!windowLayerKeysActive">
-      <v-card-text>{{ $t('plugins.gfi.noActiveLayer') }}</v-card-text>
-    </v-card>
-    <component :is="contentComponent" v-else-if="!renderMoveHandle" />
-  </div>
-</template>
-
-<script lang="ts">
-import { t } from 'i18next'
-import Vue from 'vue'
-import { mapActions, mapGetters, mapMutations } from 'vuex'
-import { MoveHandleProperties } from '@polar/lib-custom-types'
-import Feature from './Feature.vue'
-import List from './List.vue'
-
-export default Vue.extend({
-  name: 'GfiPlugin',
-  computed: {
-    ...mapGetters(['moveHandle']),
-    ...mapGetters('plugin/gfi', [
-      'gfiContentComponent',
-      'gfiConfiguration',
-      'renderMoveHandle',
-      'renderType',
-      'showList',
-      'windowFeatures',
-      'windowLayerKeysActive',
-    ]),
-    contentComponent(): Vue {
-      return this.showList ? List : this.gfiContentComponent || Feature
-    },
-    moveHandleProperties() {
-      return {
-        closeIcon: this.gfiConfiguration.featureList
-          ? 'fa-angles-right'
-          : 'fa-xmark',
-        closeLabel: t('plugins.gfi.header.close'),
-        closeFunction: this.closeWindow,
-        component: this.contentComponent,
-        plugin: this.renderType === 'independent' ? 'gfi' : 'iconMenu',
-      } as MoveHandleProperties
-    },
-    renderUi(): boolean {
-      return this.windowFeatures.length > 0 || this.showList
-    },
-  },
-  watch: {
-    windowFeatures() {
-      if (this.windowFeatures.length) {
-        this.setMoveHandle(this.moveHandleProperties)
-      } else if (
-        !this.windowFeatures.length &&
-        this.moveHandle !== null &&
-        this.moveHandle.component === this.contentComponent
-      ) {
-        this.setMoveHandle(null)
-      }
-    },
-  },
-  methods: {
-    ...mapMutations(['setMoveHandle']),
-    ...mapActions('plugin/gfi', ['close']),
-    closeWindow(userInteraction: boolean) {
-      this.close(userInteraction)
-      // The list view is currently only implemented if the gfi is rendered as part of the iconMenu.
-      // TODO: Finding a different solution may be a task to be tackled in the future
-      if (
-        this.gfiConfiguration.featureList &&
-        this.$store.hasModule(['plugin', 'iconMenu']) &&
-        this.$store.getters['plugin/iconMenu/open'] !== null
-      ) {
-        this.$store.dispatch(
-          'plugin/iconMenu/openInMoveHandle',
-          this.$store.getters['plugin/iconMenu/menus'].findIndex(
-            ({ id }) => id === 'gfi'
-          )
-        )
-      }
-    },
-  },
-})
-</script>
-
-<style lang="scss" scoped>
-@media only screen and (min-width: 769px) {
-  #polar-plugin-gfi {
-    margin-left: 1em;
-    margin-bottom: 1em;
-    overflow-y: auto;
-    overflow-x: hidden;
-    scrollbar-gutter: stable;
-    pointer-events: all;
-    min-width: 300px;
-
-    &::v-deep .v-data-table__wrapper {
-      /* table cell padding underlaps scrollbar; prevent horizontal scroll */
-      overflow-x: clip;
-    }
-  }
-}
-</style>
diff --git a/vue2/packages/plugins/Gfi/src/components/List.vue b/vue2/packages/plugins/Gfi/src/components/List.vue
deleted file mode 100644
index 32ecd7c103..0000000000
--- a/vue2/packages/plugins/Gfi/src/components/List.vue
+++ /dev/null
@@ -1,212 +0,0 @@
-<template>
-  <v-scroll-x-reverse-transition>
-    <v-card class="plugin-gfi-list">
-      <v-card-title>
-        <v-icon>fa-list</v-icon>
-        {{ $t('plugins.gfi.list.header') }}
-      </v-card-title>
-      <v-card-subtitle v-if="maxPage > 1">
-        {{
-          `${$t('plugins.gfi.list.entry')} ${page * pageLength + 1} ${$t(
-            'plugins.gfi.list.to'
-          )} ${Math.min((page + 1) * pageLength, listFeatures.length)} ${$t(
-            'plugins.gfi.list.of'
-          )} ${listFeatures.length}`
-        }}
-        <v-pagination
-          v-model="_page"
-          color="primary"
-          :length="maxPage"
-          :current-page-aria-label="
-            $t('plugins.gfi.list.pagination.currentPage', {
-              page: _page,
-              maxPage,
-            })
-          "
-          :page-aria-label="
-            $t('plugins.gfi.list.pagination.page', {
-              page: _page,
-              maxPage,
-            })
-          "
-          :next-aria-label="$t('plugins.gfi.list.pagination.next')"
-          :previous-aria-label="$t('plugins.gfi.list.pagination.previous')"
-          :wrapper-aria-label="$t('plugins.gfi.list.pagination.wrapper')"
-        ></v-pagination>
-      </v-card-subtitle>
-      <v-list>
-        <v-list-item v-if="!visibleListFeatures.length">
-          {{ $t('plugins.gfi.list.emptyView') }}
-        </v-list-item>
-        <v-list-item
-          v-for="feature of visibleListFeatures"
-          :key="`gfi-feature-list-${feature.ol_uid}`"
-          :two-line="listText.length === 2"
-          :three-line="listText.length === 3"
-          :class="{
-            'gfi-feature-list-item-hovered': isFeatureHovered(feature),
-          }"
-          @click="
-            setOlFeatureInformation({
-              feature: getCluster(map, feature, '_gfiLayerId'),
-              centerOnFeature: true,
-            })
-          "
-          @keydown.space.prevent="
-            setOlFeatureInformation({
-              feature: getCluster(map, feature, '_gfiLayerId'),
-              centerOnFeature: true,
-            })
-          "
-          @mouseleave="unhover"
-          @mouseover="hover(feature)"
-          @focusout="unhover"
-          @focus="hover(feature)"
-        >
-          <v-list-item-content>
-            <component
-              :is="index === 0 ? 'v-list-item-title' : 'v-list-item-subtitle'"
-              v-for="(_, index) of listText"
-              :key="`gfi-feature-list-${feature.ol_uid}-${index}`"
-            >
-              {{ $t(applyListText(feature, index)) }}
-            </component>
-          </v-list-item-content>
-        </v-list-item>
-      </v-list>
-    </v-card>
-  </v-scroll-x-reverse-transition>
-</template>
-
-<script lang="ts">
-import { Feature } from 'ol'
-import Vue from 'vue'
-import { mapGetters, mapMutations, mapActions } from 'vuex'
-import getCluster from '@polar/lib-get-cluster'
-
-export default Vue.extend({
-  name: 'GfiList',
-  computed: {
-    ...mapGetters(['map']),
-    ...mapGetters('plugin/gfi', [
-      'listFeatures',
-      'listText',
-      'page',
-      'gfiConfiguration',
-      'isFeatureHovered',
-    ]),
-    _page: {
-      get() {
-        return this.page + 1
-      },
-      set(value) {
-        this.setPage(value - 1)
-      },
-    },
-    pageLength() {
-      return (
-        this.gfiConfiguration.featureList.pageLength || Number.MAX_SAFE_INTEGER
-      )
-    },
-    maxPage() {
-      return Math.ceil(this.listFeatures.length / this.pageLength)
-    },
-    visibleListFeatures() {
-      return this.listFeatures.slice(
-        (this._page - 1) * this.pageLength,
-        this._page * this.pageLength
-      )
-    },
-  },
-  watch: {
-    maxPage: function (nextMaxPage) {
-      if (this._page > nextMaxPage) {
-        this._page = Math.max(nextMaxPage, 1)
-      }
-    },
-  },
-  mounted() {
-    if (this._page > this.maxPage) {
-      this._page = Math.max(this.maxPage, 1)
-    }
-  },
-  methods: {
-    ...mapActions('plugin/gfi', [
-      'setOlFeatureInformation',
-      'setPage',
-      'hover',
-      'unhover',
-    ]),
-    ...mapMutations('plugin/gfi', ['setPage']),
-    getCluster,
-    applyListText(feature: Feature, index: number) {
-      const text: string | ((f: Feature) => string) | undefined =
-        this.listText[index]
-      if (text === undefined) {
-        console.error(
-          `@polar/plugin-gfi: Missing text entry in configuration. See documentation of gfi.featureList.text for more information. Fallback to ol_uid.`
-        )
-        // @ts-expect-error | It does exist.
-        return feature.ol_uid
-      }
-      if (typeof text === 'string') {
-        return feature.get(text)
-      }
-      return text(feature)
-    },
-  },
-})
-</script>
-
-<style lang="scss">
-.plugin-gfi-list {
-  .v-pagination__navigation,
-  .v-pagination__item {
-    &:focus {
-      outline: thick solid #3fa535;
-    }
-  }
-}
-</style>
-
-<style lang="scss" scoped>
-.v-card {
-  @media only screen and (min-width: 769px) {
-    /* magic number; leaves minimal space to minimal size AddressSearch in IconMenu mode */
-    max-width: 420px;
-  }
-}
-
-.v-card__title {
-  display: flex;
-  flex-direction: row;
-  flex-wrap: nowrap;
-  gap: 0.5em;
-  word-break: normal;
-}
-
-.v-list-item__title + .v-list-item__subtitle {
-  font-style: italic;
-}
-
-.v-list-item {
-  // needed for FF
-  outline-offset: -2px;
-
-  &::before {
-    background: transparent;
-  }
-
-  &:hover {
-    outline: dashed 2px #3fa535;
-  }
-
-  &:focus {
-    outline: solid 2px #3fa535;
-  }
-}
-
-.gfi-feature-list-item-hovered {
-  background: #dff0dd;
-}
-</style>
diff --git a/vue2/packages/plugins/Gfi/src/components/index.ts b/vue2/packages/plugins/Gfi/src/components/index.ts
deleted file mode 100644
index 317c7e8a7c..0000000000
--- a/vue2/packages/plugins/Gfi/src/components/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { default as Gfi } from './Gfi.vue'
diff --git a/vue2/packages/plugins/Gfi/src/index.ts b/vue2/packages/plugins/Gfi/src/index.ts
deleted file mode 100644
index 7ed287870b..0000000000
--- a/vue2/packages/plugins/Gfi/src/index.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import Vue from 'vue'
-import { GfiConfiguration } from '@polar/lib-custom-types'
-import { Gfi } from './components'
-import locales from './locales'
-import { makeStoreModule } from './store'
-
-export default (options: GfiConfiguration) => (instance: Vue) =>
-  instance.$store.dispatch('addComponent', {
-    name: 'gfi',
-    plugin: Gfi,
-    locales,
-    storeModule: makeStoreModule(),
-    options,
-  })
diff --git a/vue2/packages/plugins/Gfi/src/locales.ts b/vue2/packages/plugins/Gfi/src/locales.ts
deleted file mode 100644
index b083d9c770..0000000000
--- a/vue2/packages/plugins/Gfi/src/locales.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-import { Locale } from '@polar/lib-custom-types'
-
-export const resourcesDe = {
-  plugins: {
-    gfi: {
-      header: {
-        close: 'Informationsfenster schließen',
-        field: 'Feld',
-        value: 'Wert',
-      },
-      property: {
-        export: 'Export als PDF',
-        imageAlt:
-          'Bitte entnehmen Sie Informationen zum Inhalt des Bildes aus den umliegenden Tabellenfeldern',
-        linkTitle: 'In neuem Tab öffnen',
-      },
-      switch: {
-        previous: 'Vorangehender Datensatz',
-        next: 'Nächster Datensatz',
-      },
-      noActiveLayer:
-        'Derzeit ist kein Kartenmaterial mit passenden Objekten eingeschaltet.',
-      list: {
-        header: 'Objektliste',
-        entry: 'Eintrag',
-        to: 'bis',
-        of: 'von',
-        emptyView:
-          'Im aktuellen Kartenausschnitt sind keine Objekte enthalten.',
-        pagination: {
-          currentPage: 'Aktuelle Seite, Seite {{page}}',
-          page: 'Seite {{page}}',
-          next: 'Nächste Seite',
-          previous: 'Vorherige Seite',
-          wrapper: 'Seitenauswahl',
-        },
-      },
-    },
-  },
-} as const
-
-export const resourcesEn = {
-  plugins: {
-    gfi: {
-      header: {
-        close: 'Close information window',
-        field: 'Field',
-        value: 'Value',
-      },
-      property: {
-        export: 'Export as a PDF document',
-        imageAlt:
-          'Please refer to the other table fields for further information about the topics of the displayed picture',
-        link: 'Open in a new tab',
-      },
-      switch: {
-        previous: 'Previous data',
-        next: 'Next data',
-      },
-      noActiveLayer: 'Currently, no map layer with fitting objects is active.',
-      list: {
-        header: 'Feature list',
-        entry: 'Entry',
-        to: 'to',
-        of: 'of',
-        emptyView: 'There are no features in the current view.',
-        pagination: {
-          currentPage: 'Current page, page {{page}}',
-          page: 'Page {{page}}',
-          next: 'Next page',
-          previous: 'Previous page',
-          wrapper: 'Pagination',
-        },
-      },
-    },
-  },
-} as const
-
-const locales: Locale[] = [
-  {
-    type: 'de',
-    resources: resourcesDe,
-  },
-  {
-    type: 'en',
-    resources: resourcesEn,
-  },
-]
-
-export default locales
diff --git a/vue2/packages/plugins/Gfi/src/store/actions/debouncedGfiRequest.ts b/vue2/packages/plugins/Gfi/src/store/actions/debouncedGfiRequest.ts
deleted file mode 100644
index 3076019bca..0000000000
--- a/vue2/packages/plugins/Gfi/src/store/actions/debouncedGfiRequest.ts
+++ /dev/null
@@ -1,175 +0,0 @@
-import debounce from 'lodash.debounce'
-import { rawLayerList } from '@masterportal/masterportalapi'
-import { Feature as GeoJsonFeature } from 'geojson'
-import {
-  GfiConfiguration,
-  MapConfig,
-  PolarActionContext,
-} from '@polar/lib-custom-types'
-import { Map } from 'ol'
-import VectorLayer from 'ol/layer/Vector'
-import compare from 'just-compare'
-import { filterFeatures } from '../../utils/filterFeatures'
-import { requestGfi } from '../../utils/requestGfi'
-import sortFeatures from '../../utils/sortFeatures'
-import { FeaturesByLayerId, GfiGetters, GfiState } from '../../types'
-import { renderFeatures } from '../../utils/renderFeatures'
-
-interface GetFeatureInfoParameters {
-  coordinateOrExtent: [number, number] | [number, number, number, number]
-  modifierPressed?: boolean
-}
-
-const filterAndMapFeaturesToLayerIds = (
-  layerKeys: string[],
-  gfiConfiguration: GfiConfiguration,
-  features: (symbol | GeoJsonFeature[])[],
-  srsName: string
-): FeaturesByLayerId => {
-  const generalMaxFeatures =
-    gfiConfiguration.maxFeatures || Number.POSITIVE_INFINITY
-  const featuresByLayerId = layerKeys.reduce(
-    (accumulator, key, index) => ({
-      ...accumulator,
-      [key]: Array.isArray(features[index])
-        ? (features[index] as [])
-            .filter(gfiConfiguration.layers[key].isSelectable || (() => true))
-            .slice(
-              0,
-              gfiConfiguration.layers[key].maxFeatures || generalMaxFeatures
-            )
-        : features[index],
-    }),
-    {}
-  )
-  return Object.entries(featuresByLayerId).reduce(
-    (accumulator, [layerKey, layerValues]) => ({
-      ...accumulator,
-      [layerKey]:
-        Array.isArray(layerValues) && layerValues.length >= 2
-          ? layerValues.sort((a, b) => sortFeatures(a, b, srsName))
-          : layerValues,
-    }),
-    {}
-  )
-}
-
-const getPromisedFeatures = (
-  map: Map,
-  configuration: MapConfig,
-  layerKeys: string[],
-  coordinateOrExtent: [number, number] | [number, number, number, number]
-) =>
-  layerKeys.map((key) => {
-    const layer = map
-      .getLayers()
-      .getArray()
-      .find((layer) => layer.getProperties().id === key)
-
-    if (!layer) {
-      console.error(
-        `@polar/plugin-gfi: No layer with id "${key}" found during run-time. GFI skipped.`
-      )
-      return [] as GeoJsonFeature[]
-    }
-
-    const layerConfiguration = configuration.gfi?.layers[key] || {}
-    const layerSpecification = rawLayerList.getLayerWhere({ id: key })
-    const mainLayerConfiguration = configuration.layers.find(
-      (element) => element.id === key
-    )
-    const layerGfiMode =
-      mainLayerConfiguration?.gfiMode || configuration?.gfi?.mode || 'bboxDot'
-
-    return requestGfi({
-      map,
-      layer,
-      coordinateOrExtent,
-      layerConfiguration,
-      layerSpecification,
-      mode: layerGfiMode,
-    })
-  })
-
-const createSelectionDiff = (
-  oldSelection: FeaturesByLayerId,
-  newSelection: FeaturesByLayerId
-): FeaturesByLayerId =>
-  Object.entries(newSelection).reduce(
-    (acc, [layerId, features]) => ({
-      ...acc,
-      [layerId]:
-        Array.isArray(features) && Array.isArray(oldSelection[layerId])
-          ? features.reduce((acc, newFeature) => {
-              // If the feature is already in the old selection, remove it
-              const oldFeatureIndex = acc.findIndex((oldFeature) =>
-                compare(oldFeature.properties, newFeature.properties)
-              )
-              return oldFeatureIndex === -1
-                ? [...acc, newFeature]
-                : acc.filter((_, i) => i !== oldFeatureIndex)
-            }, oldSelection[layerId] as GeoJsonFeature[])
-          : features,
-    }),
-    {}
-  )
-
-const errorSymbol = (err) => Symbol(err)
-
-/**
- * Code from `getFeatureInfo`, pulled to avoid overly requesting feature
- * information. Since sources in Pins plugin update right after each other
- * (and such effects are to be expected across the system), we're debouncing
- * this *after* resetting the module state, as something is bound to happen.
- */
-const gfiRequest =
-  (featureDisplayLayer: VectorLayer) =>
-  async (
-    {
-      commit,
-      getters,
-      rootGetters: { map, configuration },
-    }: PolarActionContext<GfiState, GfiGetters>,
-    { coordinateOrExtent, modifierPressed = false }: GetFeatureInfoParameters
-  ): Promise<void> => {
-    const { afterLoadFunction, layerKeys } = getters
-    // fetch new feature information for all configured layers
-    const features = (
-      await Promise.allSettled(
-        getPromisedFeatures(map, configuration, layerKeys, coordinateOrExtent)
-      )
-    ).map((result) =>
-      result.status === 'fulfilled'
-        ? result.value
-        : errorSymbol(result.reason.message)
-    )
-    const srsName: string = map.getView().getProjection().getCode()
-    let featuresByLayerId = filterAndMapFeaturesToLayerIds(
-      layerKeys,
-      getters.gfiConfiguration,
-      features,
-      srsName
-    )
-    // store features in state, if configured via client after specific function
-    if (typeof afterLoadFunction === 'function') {
-      featuresByLayerId = await afterLoadFunction(
-        filterFeatures(featuresByLayerId),
-        srsName
-      )
-    }
-    if (modifierPressed) {
-      featuresByLayerId = createSelectionDiff(
-        getters.featureInformation,
-        featuresByLayerId
-      )
-    }
-    commit('setFeatureInformation', featuresByLayerId)
-    renderFeatures(
-      featureDisplayLayer,
-      getters.geometryLayerKeys,
-      featuresByLayerId
-    )
-  }
-
-export const debouncedGfiRequest = (featureDisplayLayer: VectorLayer) =>
-  debounce(gfiRequest(featureDisplayLayer), 50)
diff --git a/vue2/packages/plugins/Gfi/src/store/actions/index.ts b/vue2/packages/plugins/Gfi/src/store/actions/index.ts
deleted file mode 100644
index 58d3996d60..0000000000
--- a/vue2/packages/plugins/Gfi/src/store/actions/index.ts
+++ /dev/null
@@ -1,202 +0,0 @@
-import debounce from 'lodash.debounce'
-import { Feature as GeoJsonFeature } from 'geojson'
-import { Fill, Stroke, Style } from 'ol/style'
-import { GeoJSON } from 'ol/format'
-import { Feature } from 'ol'
-import { PolarActionTree } from '@polar/lib-custom-types'
-import { filterFeatures } from '../../utils/filterFeatures'
-import { renderFeatures } from '../../utils/renderFeatures'
-import { clear, getFeatureDisplayLayer } from '../../utils/displayFeatureLayer'
-import { FeaturesByLayerId, GfiGetters, GfiState } from '../../types'
-import { debouncedGfiRequest } from './debouncedGfiRequest'
-import { setupCoreListener, setupTooltip, setupZoomListeners } from './setup'
-import { setupMultiSelection } from './setupMultiSelection'
-
-export const makeActions = () => {
-  const writer = new GeoJSON()
-  const featureDisplayLayer = getFeatureDisplayLayer()
-
-  let debouncedVisibilityChangeIndicator
-
-  const actions: PolarActionTree<GfiState, GfiGetters> = {
-    /**
-     * Responsible for setting up the module by
-     * - adding watchers to configured coordinate sources. Whenever one of these
-     *   sources changes, the module is reset and all information is fetched
-     *   anew.
-     * - adding the geometry display layer to the map.
-     */
-    setupModule({
-      getters: { gfiConfiguration, defaultHighlightStyle },
-      rootGetters,
-      dispatch,
-    }): void {
-      const { coordinateSources, customHighlightStyle } = gfiConfiguration
-      const { map } = rootGetters
-
-      const reaction = (coordinate) => {
-        clear(featureDisplayLayer)
-        if (coordinate && coordinate.length) {
-          dispatch('getFeatureInfo', { coordinateOrExtent: coordinate })
-        }
-      }
-
-      coordinateSources.forEach((coordinateSource) =>
-        this.watch(() => rootGetters[coordinateSource], reaction)
-      )
-
-      map.addLayer(featureDisplayLayer)
-      featureDisplayLayer.setStyle(
-        new Style({
-          stroke: new Stroke(
-            customHighlightStyle?.stroke || defaultHighlightStyle.stroke
-          ),
-          fill: new Fill(
-            customHighlightStyle?.fill || defaultHighlightStyle.fill
-          ),
-        })
-      )
-
-      dispatch('setupTooltip')
-      dispatch('setupFeatureVisibilityUpdates')
-      dispatch('setupCoreListener')
-      dispatch('setupZoomListeners')
-      dispatch('setupMultiSelection')
-    },
-    setupCoreListener,
-    setupMultiSelection,
-    setupTooltip,
-    setupZoomListeners,
-    setupFeatureVisibilityUpdates({ commit, state, getters, rootGetters }) {
-      // debounce to prevent update spam
-      debouncedVisibilityChangeIndicator = debounce(
-        () =>
-          commit(
-            'setVisibilityChangeIndicator',
-            state.visibilityChangeIndicator + 1
-          ),
-        10
-      )
-      rootGetters.map
-        .getLayers()
-        .getArray()
-        .forEach((layer) => {
-          if (getters.layerKeys.includes(layer.get('id'))) {
-            layer
-              // @ts-expect-error | layers reaching this have a source
-              .getSource()
-              .on('addfeature', debouncedVisibilityChangeIndicator)
-          }
-        })
-    },
-    close({ commit, dispatch, rootGetters }, userInteraction = false) {
-      commit('clearFeatureInformation')
-      commit('setImageLoaded', false)
-      // NOTE: null is needed, as the payload is always the second argument...
-      if (
-        !rootGetters.configuration?.extendedMasterportalapiMarkers &&
-        userInteraction
-      ) {
-        dispatch('plugin/pins/removeMarker', null, { root: true })
-      }
-      dispatch('setCoreSelection', { feature: null })
-      clear(featureDisplayLayer) // ... features of gfi layer
-    },
-    /**
-     * Action getFeatureInfo
-     * 1. resets the module state
-     * 2. fetches new feature information for each configured layer
-     * 3. adds features to the display layer optionally (if configured)
-     */
-    async getFeatureInfo(
-      { commit, dispatch },
-      coordinateOrExtent: [number, number] | [number, number, number, number]
-    ): Promise<GeoJsonFeature[]> {
-      if (coordinateOrExtent.length === 2) {
-        commit('clearFeatureInformation')
-        commit('setVisibleWindowFeatureIndex', 0)
-      }
-      clear(featureDisplayLayer)
-      // call further stepped in a debounced fashion to avoid a mess
-      return await dispatch('debouncedGfiRequest', coordinateOrExtent)
-    },
-    debouncedGfiRequest: debouncedGfiRequest(featureDisplayLayer),
-    setCoreSelection(
-      { commit, dispatch, rootGetters },
-      {
-        feature,
-        centerOnFeature = false,
-      }: { feature: Feature | null; centerOnFeature?: boolean }
-    ) {
-      if (rootGetters.selected !== feature) {
-        commit('setSelected', feature, { root: true })
-        dispatch(
-          'updateSelection',
-          { feature, centerOnFeature },
-          { root: true }
-        )
-      }
-    },
-    setOlFeatureInformation(
-      { commit, dispatch },
-      {
-        feature,
-        centerOnFeature = false,
-      }: { feature: Feature | null; centerOnFeature?: boolean }
-    ) {
-      commit('clearFeatureInformation')
-      commit('setVisibleWindowFeatureIndex', 0)
-      clear(featureDisplayLayer)
-      if (feature !== null) {
-        commit('setFeatureInformation', {
-          [feature.get('_gfiLayerId')]: feature.get('features')?.length
-            ? feature
-                .get('features')
-                .map((feature) => JSON.parse(writer.writeFeature(feature)))
-            : [JSON.parse(writer.writeFeature(feature))],
-        })
-        dispatch('setCoreSelection', { feature, centerOnFeature })
-      }
-    },
-    setFeatureInformation(
-      { commit, getters },
-      featuresByLayerId: FeaturesByLayerId
-    ) {
-      commit('clearFeatureInformation')
-      commit('setVisibleWindowFeatureIndex', 0)
-      clear(featureDisplayLayer)
-
-      const filteredFeatures = Object.fromEntries(
-        Object.entries(filterFeatures(featuresByLayerId)).map(
-          ([layerId, features]) => {
-            const { isSelectable } = getters.gfiConfiguration.layers[layerId]
-            return [
-              layerId,
-              typeof isSelectable === 'function'
-                ? features.filter((feature) => isSelectable(feature))
-                : features,
-            ]
-          }
-        )
-      )
-      commit('setFeatureInformation', filteredFeatures)
-      renderFeatures(
-        featureDisplayLayer,
-        getters.geometryLayerKeys,
-        filteredFeatures
-      )
-    },
-    hover({ commit, rootGetters }, feature: Feature) {
-      if (rootGetters.configuration.extendedMasterportalapiMarkers) {
-        commit('setHovered', feature, { root: true })
-      }
-    },
-    unhover({ commit, rootGetters }) {
-      if (rootGetters.configuration.extendedMasterportalapiMarkers) {
-        commit('setHovered', null, { root: true })
-      }
-    },
-  }
-
-  return actions
-}
diff --git a/vue2/packages/plugins/Gfi/src/store/actions/setup.ts b/vue2/packages/plugins/Gfi/src/store/actions/setup.ts
deleted file mode 100644
index e4450e51c1..0000000000
--- a/vue2/packages/plugins/Gfi/src/store/actions/setup.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-import { PolarActionContext, PolarStore } from '@polar/lib-custom-types'
-import { GeoJsonProperties } from 'geojson'
-import getCluster from '@polar/lib-get-cluster'
-import { getTooltip, Tooltip } from '@polar/lib-tooltip'
-import Overlay from 'ol/Overlay'
-import { Feature } from 'ol'
-import { GfiGetters, GfiState } from '../../types'
-import { getOriginalFeature } from '../../utils/getOriginalFeature'
-
-export function setupCoreListener(
-  this: PolarStore<GfiState, GfiGetters>,
-  {
-    getters: { gfiConfiguration },
-    rootGetters,
-    dispatch,
-  }: PolarActionContext<GfiState, GfiGetters>
-) {
-  if (gfiConfiguration.featureList?.bindWithCoreHoverSelect) {
-    this.watch(
-      () => rootGetters.selected,
-      (feature) => dispatch('setOlFeatureInformation', { feature }),
-      { deep: true }
-    )
-  }
-}
-
-export function setupTooltip({
-  getters: { gfiConfiguration },
-  rootGetters: { map },
-}: PolarActionContext<GfiState, GfiGetters>) {
-  const tooltipLayerIds = Object.keys(gfiConfiguration.layers).filter(
-    (key) => gfiConfiguration.layers[key].showTooltip
-  )
-  if (!tooltipLayerIds.length) {
-    return
-  }
-
-  let element: Tooltip['element'], unregister: Tooltip['unregister']
-  const overlay = new Overlay({
-    positioning: 'bottom-center',
-    offset: [0, -5],
-  })
-  map.addOverlay(overlay)
-  map.on('pointermove', ({ pixel, dragging, originalEvent }) => {
-    if (dragging || ['touch', 'pen'].includes(originalEvent.pointerType)) {
-      return
-    }
-    let hasFeatureAtPixel = false
-    // stops on return `true`, thus only using the uppermost feature
-    map.forEachFeatureAtPixel(
-      pixel,
-      (feature, layer) => {
-        if (!(feature instanceof Feature)) {
-          return false
-        }
-        hasFeatureAtPixel = true
-        overlay.setPosition(map.getCoordinateFromPixel(pixel))
-        if (unregister) {
-          unregister()
-        }
-        ;({ element, unregister } = getTooltip({
-          localeKeys:
-            // @ts-expect-error | it exists by virtue of layerFilter below
-            gfiConfiguration.layers[layer.get('id')].showTooltip(feature, map),
-        }))
-        overlay.setElement(element)
-        return true
-      },
-      { layerFilter: (layer) => tooltipLayerIds.includes(layer.get('id')) }
-    )
-    if (!hasFeatureAtPixel) {
-      overlay.setPosition(undefined)
-    }
-  })
-}
-
-export function setupZoomListeners(
-  this: PolarStore<GfiState, GfiGetters>,
-  { dispatch, getters, rootGetters }: PolarActionContext<GfiState, GfiGetters>
-) {
-  if (getters.gfiConfiguration.featureList) {
-    this.watch(
-      () => rootGetters.zoomLevel,
-      () => {
-        const {
-          featureInformation,
-          listableLayerSources,
-          visibleWindowFeatureIndex,
-          windowFeatures,
-        } = getters
-
-        if (windowFeatures.length) {
-          const layerId: string =
-            // @ts-expect-error | if windowFeatures has features, visibleWindowFeatureIndex is in the range of possible features
-            windowFeatures[visibleWindowFeatureIndex].polarInternalLayerKey
-          const selectedFeatureProperties: GeoJsonProperties = {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            _gfiLayerId: layerId,
-            ...featureInformation[layerId][visibleWindowFeatureIndex]
-              .properties,
-          }
-          const originalFeature = getOriginalFeature(
-            listableLayerSources,
-            selectedFeatureProperties
-          )
-          if (originalFeature) {
-            dispatch('setOlFeatureInformation', {
-              feature: getCluster(
-                rootGetters.map,
-                originalFeature,
-                '_gfiLayerId'
-              ),
-            })
-          }
-        }
-      }
-    )
-  }
-}
diff --git a/vue2/packages/plugins/Gfi/src/store/actions/setupMultiSelection.ts b/vue2/packages/plugins/Gfi/src/store/actions/setupMultiSelection.ts
deleted file mode 100644
index a84d632519..0000000000
--- a/vue2/packages/plugins/Gfi/src/store/actions/setupMultiSelection.ts
+++ /dev/null
@@ -1,102 +0,0 @@
-import { Map } from 'ol'
-import { Modify } from 'ol/interaction'
-import Draw, {
-  createBox,
-  type Options as DrawOptions,
-} from 'ol/interaction/Draw'
-import { platformModifierKeyOnly } from 'ol/events/condition'
-import { Fill, Stroke, Style } from 'ol/style'
-import { PolarActionContext } from '@polar/lib-custom-types'
-import { GfiGetters, GfiState } from '../../types'
-
-const isDrawing = (map: Map) =>
-  map
-    .getInteractions()
-    .getArray()
-    .some(
-      (interaction) =>
-        (interaction instanceof Draw &&
-          // @ts-expect-error | internal hack to detect it from @polar/plugin-gfi
-          (interaction._isMultiSelect ||
-            // @ts-expect-error | internal hack to detect it from @polar/plugin-routing
-            interaction._isRoutingDraw ||
-            // @ts-expect-error | internal hack to detect it from @polar/plugin-draw
-            interaction._isDrawPlugin)) ||
-        interaction instanceof Modify ||
-        // @ts-expect-error | internal hack to detect it from @polar/plugin-draw
-        interaction._isDeleteSelect ||
-        // @ts-expect-error | internal hack to detect it from @polar/plugin-measure
-        interaction._isMeasureSelect
-    )
-
-const drawOptions: DrawOptions = {
-  stopClick: true,
-  type: 'Circle',
-  style: new Style({
-    stroke: new Stroke({ color: 'white', width: 1.5 }),
-    fill: new Fill({ color: [255, 255, 255, 0.75] }),
-  }),
-  freehandCondition: (event) => {
-    if (event.type === 'pointermove') {
-      return false
-    } else if (event.type === 'pointerup') {
-      return true
-    }
-    return platformModifierKeyOnly(event)
-  },
-  condition: () => false,
-}
-
-export function setupMultiSelection({
-  dispatch,
-  getters: {
-    gfiConfiguration: { boxSelect, directSelect, multiSelect },
-  },
-  rootGetters,
-}: PolarActionContext<GfiState, GfiGetters>) {
-  if (boxSelect || multiSelect === 'box' || multiSelect === 'circle') {
-    if (boxSelect) {
-      console.warn(
-        '@polar/plugin-gfi: Configuration parameter "boxSelect" has been deprecated. Please use the new parameter "multiSelect" set to "box" instead.'
-      )
-    }
-    if (multiSelect !== 'circle') {
-      drawOptions.geometryFunction = createBox()
-    } else {
-      delete drawOptions.geometryFunction
-    }
-    const draw = new Draw(drawOptions)
-    draw.on('drawstart', () => {
-      // @ts-expect-error | internal hack to detect it in @polar/plugin-pins
-      draw._isMultiSelect = true
-    })
-    draw.on('drawabort', () => {
-      // @ts-expect-error | internal hack to detect it in @polar/plugin-pins
-      draw._isMultiSelect = false
-    })
-    draw.on('drawend', (e) =>
-      dispatch('getFeatureInfo', {
-        // @ts-expect-error | A feature that is drawn has a geometry.
-        coordinateOrExtent: e.feature.getGeometry().getExtent(),
-        modifierPressed: true,
-      }).finally(() => {
-        // @ts-expect-error | internal hack to detect it in @polar/plugin-pins
-        draw._isMultiSelect = false
-      })
-    )
-    rootGetters.map.addInteraction(draw)
-  }
-  if (directSelect) {
-    rootGetters.map.on('click', ({ coordinate, originalEvent }) => {
-      if (!isDrawing(rootGetters.map)) {
-        dispatch('getFeatureInfo', {
-          coordinateOrExtent: coordinate,
-          modifierPressed:
-            navigator.userAgent.indexOf('Mac') !== -1
-              ? originalEvent.metaKey
-              : originalEvent.ctrlKey,
-        })
-      }
-    })
-  }
-}
diff --git a/vue2/packages/plugins/Gfi/src/store/getInitialState.ts b/vue2/packages/plugins/Gfi/src/store/getInitialState.ts
deleted file mode 100644
index 4604a6b610..0000000000
--- a/vue2/packages/plugins/Gfi/src/store/getInitialState.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import { GfiState } from '../types'
-
-const getInitialState = (): GfiState => ({
-  featureInformation: {},
-  imageLoaded: false,
-  visibleWindowFeatureIndex: 0,
-  visibilityChangeIndicator: 0,
-  defaultHighlightStyle: {
-    stroke: {
-      color: '#003064',
-      width: 3,
-    },
-    fill: {
-      color: 'rgb(255, 255, 255, 0.7)',
-    },
-  },
-  page: 0,
-})
-
-export default getInitialState
diff --git a/vue2/packages/plugins/Gfi/src/store/getters.ts b/vue2/packages/plugins/Gfi/src/store/getters.ts
deleted file mode 100644
index 36b2b01c6b..0000000000
--- a/vue2/packages/plugins/Gfi/src/store/getters.ts
+++ /dev/null
@@ -1,254 +0,0 @@
-import { generateSimpleGetters } from '@repositoryname/vuex-generators'
-import { GfiConfiguration, PolarGetterTree } from '@polar/lib-custom-types'
-import noop from '@repositoryname/noop'
-import { isVisible } from '@polar/lib-invisible-style'
-import { Cluster as ClusterSource } from 'ol/source'
-import { GeoJSON } from 'ol/format'
-import { GfiGetters, GfiState } from '../types'
-import { listableLayersFilter } from '../utils/listableLayersFilter'
-import getInitialState from './getInitialState'
-
-const getters: PolarGetterTree<GfiState, GfiGetters> = {
-  ...generateSimpleGetters(getInitialState()),
-  gfiConfiguration(_, __, ___, rootGetters) {
-    return <GfiConfiguration>(rootGetters.configuration?.gfi || {
-      afterLoadFunction: null,
-      coordinateSources: [],
-      layers: {},
-    })
-  },
-  renderType(_, __, ___, rootGetters) {
-    return rootGetters.configuration?.gfi?.renderType || 'independent'
-  },
-  renderMoveHandle(_, getters, __, rootGetters) {
-    return (
-      getters.renderType === 'independent' &&
-      rootGetters.hasWindowSize &&
-      rootGetters.hasSmallWidth
-    )
-  },
-  gfiContentComponent(_, { gfiConfiguration }) {
-    return gfiConfiguration.gfiContentComponent || null
-  },
-  afterLoadFunction(_, { gfiConfiguration }) {
-    return typeof gfiConfiguration?.afterLoadFunction === 'function'
-      ? gfiConfiguration.afterLoadFunction
-      : null
-  },
-  currentProperties(
-    _,
-    { exportPropertyLayerKeys, visibleWindowFeatureIndex, windowFeatures }
-  ) {
-    const properties = {
-      ...windowFeatures[visibleWindowFeatureIndex],
-    }
-    const exportProperty =
-      exportPropertyLayerKeys[properties.polarInternalLayerKey]
-    if (exportProperty?.length > 0) {
-      delete properties[exportProperty]
-    }
-    return properties
-  },
-  layerKeys(_, { gfiConfiguration }) {
-    return Object.keys(gfiConfiguration.layers)
-  },
-  exportProperty(
-    _,
-    {
-      currentProperties,
-      exportPropertyLayerKeys,
-      visibleWindowFeatureIndex,
-      windowFeatures,
-    }
-  ) {
-    if (currentProperties) {
-      const property =
-        exportPropertyLayerKeys[currentProperties.polarInternalLayerKey]
-      return property.length > 0
-        ? (windowFeatures[visibleWindowFeatureIndex]?.[property] as string)
-        : ''
-    }
-    return ''
-  },
-  exportPropertyLayerKeys(_, { gfiConfiguration }) {
-    return Object.entries(gfiConfiguration.layers).reduce(
-      (accumulator, [key, { exportProperty }]) => ({
-        ...accumulator,
-        [key]: typeof exportProperty === 'string' ? exportProperty : '',
-      }),
-      {} as Record<string, string>
-    )
-  },
-  /** only show switch buttons if multiple property sets are available */
-  showSwitchButtons(_, { windowFeatures }) {
-    return windowFeatures.length > 1
-  },
-  windowLayerKeys(_, { gfiConfiguration }) {
-    return Object.entries(gfiConfiguration.layers).reduce(
-      (accumulator, [key, { window }]) => {
-        if (window) {
-          return [...accumulator, key]
-        }
-        return accumulator
-      },
-      [] as string[]
-    )
-  },
-  windowLayerKeysActive(
-    _,
-    { windowLayerKeys, gfiConfiguration },
-    __,
-    rootGetters
-  ) {
-    const { activeLayerPath } = gfiConfiguration
-    if (!activeLayerPath) {
-      // if not configured, restriction does not apply
-      return true
-    }
-    // update on change indicator
-    noop(rootGetters[activeLayerPath])
-    return Boolean(
-      rootGetters.map
-        .getLayers()
-        .getArray()
-        .filter(
-          (layer) =>
-            windowLayerKeys.includes(layer.get('id')) && layer.getVisible()
-        ).length
-    )
-  },
-  geometryLayerKeys(_, { gfiConfiguration }) {
-    return Object.entries(gfiConfiguration.layers).reduce(
-      (accumulator, [key, { geometry }]) => {
-        if (geometry) {
-          return [...accumulator, key]
-        }
-        return accumulator
-      },
-      [] as string[]
-    )
-  },
-  windowFeatures(_, { featureInformation, windowLayerKeys, gfiConfiguration }) {
-    return Object.entries(featureInformation)
-      .map(([key, features]) =>
-        /*
-          NOTE: When displaying the features in the map, the first feature is rendered first
-            thus lying under every other following feature. However, when using the gfi window,
-            the first feature is initially displayed in the window.
-            To have both in line, the feature displayed on top, the order of the features is reversed here for the window.
-         */
-        windowLayerKeys.includes(key) && Array.isArray(features)
-          ? features.reverse().map(({ properties }) => {
-              const baseProperties = { polarInternalLayerKey: key }
-              const propertyReducer = gfiConfiguration.layers[key].properties
-
-              // if it is an Array, just forward properties named in it
-              if (Array.isArray(propertyReducer)) {
-                return {
-                  ...Object.fromEntries(
-                    Object.entries(properties || {}).filter(([key]) =>
-                      propertyReducer.includes(key)
-                    )
-                  ),
-                  ...baseProperties,
-                }
-              }
-              // if of type object, map keys, forward properties named in object keys
-              if (typeof propertyReducer === 'object') {
-                const relevantKeys = Object.keys(propertyReducer)
-                return {
-                  ...Object.fromEntries(
-                    Object.entries(properties || {})
-                      .filter(([key]) => relevantKeys.includes(key))
-                      .map(([key, value]) => [propertyReducer[key], value])
-                  ),
-                  ...baseProperties,
-                }
-              }
-
-              // if neither, just forward properties
-              return { ...properties, ...baseProperties }
-            })
-          : []
-      )
-      .flat(1)
-  },
-  listMode(_, { gfiConfiguration }) {
-    if (gfiConfiguration.featureList && !gfiConfiguration.featureList.mode) {
-      console.error(
-        '@polar/plugin-gfi: When using featureList a mode has to be chosen.'
-      )
-    }
-    return gfiConfiguration.featureList?.mode
-  },
-  listText(_, { gfiConfiguration }) {
-    return gfiConfiguration.featureList?.text || []
-  },
-  showList(_, { windowFeatures, gfiConfiguration }) {
-    return Boolean(gfiConfiguration.featureList && !windowFeatures.length)
-  },
-  listableLayerSources(_, { layerKeys }, __, rootGetters) {
-    return rootGetters.map
-      .getLayers()
-      .getArray()
-      .filter((layer) => layerKeys.includes(layer.get('id')))
-      .filter(listableLayersFilter)
-      .map((layer) => {
-        // @ts-expect-error | no sourceless layers in masterportalAPI generation
-        let source = layer.getSource()
-        while (source instanceof ClusterSource) {
-          source = source.getSource()
-        }
-        source.set('_gfiLayerId', layer.get('id'), true)
-        return source
-      })
-  },
-  listFeatures(
-    { visibilityChangeIndicator },
-    { gfiConfiguration, listableLayerSources, listMode },
-    __,
-    rootGetters
-  ) {
-    const { map, clientHeight, clientWidth, center, zoomLevel } = rootGetters
-    const writer = new GeoJSON()
-    // trigger getter on those who indicate feature change possibility
-    noop(clientHeight, clientWidth, center, zoomLevel)
-    noop(visibilityChangeIndicator)
-    return listableLayerSources
-      .map((source) => {
-        const layerId = source.get('_gfiLayerId')
-        return (
-          listMode === 'loaded'
-            ? source.getFeatures()
-            : source.getFeaturesInExtent(
-                map.getView().calculateExtent(map.getSize()),
-                map.getView().getProjection()
-              )
-        )
-          .filter(isVisible)
-          .filter((feature) => {
-            const { isSelectable } = gfiConfiguration.layers[layerId]
-            return typeof isSelectable === 'function'
-              ? isSelectable(JSON.parse(writer.writeFeature(feature)))
-              : true
-          })
-          .map((feature) => {
-            // true = silent change (prevents cluster recomputation & rerender)
-            feature.set('_gfiLayerId', layerId, true)
-            return feature
-          })
-      })
-      .flat(1)
-  },
-  isFeatureHovered: (_, __, ___, rootGetters) => (feature) => {
-    const { hovered } = rootGetters
-    return (
-      hovered !== null &&
-      (hovered === feature || hovered.get('features')
-        ? hovered.get('features').includes(feature)
-        : false)
-    )
-  },
-}
-
-export default getters
diff --git a/vue2/packages/plugins/Gfi/src/store/index.ts b/vue2/packages/plugins/Gfi/src/store/index.ts
deleted file mode 100644
index dc8a4ed3ee..0000000000
--- a/vue2/packages/plugins/Gfi/src/store/index.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { PolarModule } from '@polar/lib-custom-types'
-import { GfiGetters, GfiState } from '../types'
-
-import getInitialState from './getInitialState'
-import { makeActions } from './actions'
-import mutations from './mutations'
-import getters from './getters'
-
-export const makeStoreModule = () => {
-  const storeModule: PolarModule<GfiState, GfiGetters> = {
-    namespaced: true,
-    state: getInitialState(),
-    actions: makeActions(),
-    mutations,
-    getters,
-  }
-
-  return storeModule
-}
diff --git a/vue2/packages/plugins/Gfi/src/store/mutations.ts b/vue2/packages/plugins/Gfi/src/store/mutations.ts
deleted file mode 100644
index 50d0333c91..0000000000
--- a/vue2/packages/plugins/Gfi/src/store/mutations.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import { generateSimpleMutations } from '@repositoryname/vuex-generators'
-import getInitialState from './getInitialState'
-
-const mutations = {
-  ...generateSimpleMutations(getInitialState()),
-  clearFeatureInformation(state) {
-    state.featureInformation = {}
-  },
-}
-
-export default mutations
diff --git a/vue2/packages/plugins/Gfi/src/types.ts b/vue2/packages/plugins/Gfi/src/types.ts
deleted file mode 100644
index 3e4a24c842..0000000000
--- a/vue2/packages/plugins/Gfi/src/types.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-import { Map, Feature } from 'ol'
-import BaseLayer from 'ol/layer/Base'
-import ImageLayer from 'ol/layer/Image'
-import TileLayer from 'ol/layer/Tile'
-import { ImageWMS, TileWMS } from 'ol/source'
-import VectorSource from 'ol/source/Vector'
-import { Feature as GeoJsonFeature, GeoJsonProperties } from 'geojson'
-import {
-  HighlightStyle,
-  GfiAfterLoadFunction,
-  GfiConfiguration,
-  GfiLayerConfiguration,
-  RenderType,
-  FeatureList,
-} from '@polar/lib-custom-types'
-import { VueConstructor } from 'vue'
-
-/** parameter specification for request method */
-export interface RequestGfiParameters {
-  map: Map
-  layer: BaseLayer
-  coordinateOrExtent: [number, number] | [number, number, number, number]
-  layerConfiguration: GfiLayerConfiguration
-  /** rawLayerList entry, see https://bitbucket.org/geowerkstatt-hamburg/masterportal/src/dev/doc/services.json.md */
-  layerSpecification: Record<string, unknown>
-  /** defaults to bboxDot (get from minimal coordinate bbox) */
-  mode?: 'bboxDot' | 'intersects'
-}
-
-export interface RequestGfiWmsParameters {
-  map: RequestGfiParameters['map']
-  coordinate: [number, number]
-  layerConfiguration: RequestGfiParameters['layerConfiguration']
-  layerSpecification: RequestGfiParameters['layerSpecification']
-  layer: TileLayer<TileWMS> | ImageLayer<ImageWMS>
-}
-
-export type FeaturesByLayerId = Record<string, GeoJsonFeature[] | symbol>
-
-/** GFI Vuex Module State */
-export interface GfiState {
-  /** default style for stroke and fill of the highlighted feature. */
-  defaultHighlightStyle: HighlightStyle
-  /** mapping of layer id to features found for last GFI call */
-  featureInformation: Record<string, GeoJsonFeature[]>
-  imageLoaded: boolean
-  page: number
-  /** currently visible feature index regarding  */
-  visibleWindowFeatureIndex: number
-  /** count up if something in relevant features changed */
-  visibilityChangeIndicator: number
-}
-
-export interface GfiGetters extends GfiState {
-  afterLoadFunction: GfiAfterLoadFunction | null
-  currentProperties: GeoJsonProperties
-  exportProperty: string
-  exportPropertyLayerKeys: Record<string, string>
-  /** subset of layerKeys, where features' geometries are to be shown on map */
-  geometryLayerKeys: string[]
-  /** module configuration */
-  gfiConfiguration: GfiConfiguration
-  gfiContentComponent: VueConstructor | null
-  isFeatureHovered: (feature: Feature) => boolean
-  /** all layer keys to retrieve GFI information for */
-  layerKeys: string[]
-  listableLayerSources: VectorSource[]
-  listFeatures: Feature[]
-  listMode: FeatureList['mode'] | undefined
-  listText: FeatureList['text']
-  renderMoveHandle: boolean
-  renderType: RenderType
-  showList: boolean
-  showSwitchButtons: boolean
-  /** subset of layerKeys, where features' properties are to be shown in UI */
-  windowLayerKeys: string[]
-  /**
-   * features' properties from featureInformation where windowLayerKeys
-   * includes the key of the layer
-   */
-  windowFeatures: GeoJsonProperties[]
-  windowLayerKeysActive: boolean
-}
diff --git a/vue2/packages/plugins/Gfi/src/utils/displayFeatureLayer.ts b/vue2/packages/plugins/Gfi/src/utils/displayFeatureLayer.ts
deleted file mode 100644
index 88b75608bd..0000000000
--- a/vue2/packages/plugins/Gfi/src/utils/displayFeatureLayer.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { Feature } from 'ol'
-import VectorLayer from 'ol/layer/Vector'
-import { Vector } from 'ol/source'
-import { GeoJSON } from 'ol/format'
-import { Feature as GeoJsonFeature } from 'geojson'
-
-export function getFeatureDisplayLayer() {
-  const featureDisplayLayer = new VectorLayer({
-    source: new Vector<Feature>({
-      features: [],
-    }),
-  })
-
-  featureDisplayLayer.set('polarInternalId', 'pluginGfiFeatureDisplay')
-  featureDisplayLayer.setZIndex(90)
-  // NOTE: This may be changed in the future to not use the default styling of @masterportal/masterportalapi
-  featureDisplayLayer.set('styleId', 'defaultHighlightFeaturesPoint')
-
-  return featureDisplayLayer
-}
-
-function isVectorSource(source): source is Vector {
-  return source instanceof Vector
-}
-
-/**
- * reset feature layer's features.
- */
-export function clear(featureDisplayLayer: VectorLayer): void {
-  const source = featureDisplayLayer.getSource()
-  if (isVectorSource(source)) {
-    source.clear()
-  }
-}
-
-/**
- * add feature from jsonable GeoJson object.
- */
-export function addFeature(
-  feature: GeoJsonFeature,
-  featureDisplayLayer: VectorLayer
-): void {
-  const source = featureDisplayLayer.getSource()
-  if (isVectorSource(source)) {
-    // Since ol@10, readFeature may also return a Feature[]?
-    source.addFeature(new GeoJSON().readFeature(feature) as Feature)
-  }
-}
diff --git a/vue2/packages/plugins/Gfi/src/utils/filterFeatures.ts b/vue2/packages/plugins/Gfi/src/utils/filterFeatures.ts
deleted file mode 100644
index 3e63bb1d37..0000000000
--- a/vue2/packages/plugins/Gfi/src/utils/filterFeatures.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { Feature as GeoJsonFeature } from 'geojson'
-import { FeaturesByLayerId } from '../types'
-
-export function filterFeatures(
-  featuresByLayerId: FeaturesByLayerId
-): Record<string, GeoJsonFeature[]> {
-  const entries = Object.entries(featuresByLayerId)
-  const filtered = entries.filter((keyValue) => Array.isArray(keyValue[1])) as [
-    string,
-    GeoJsonFeature[]
-  ][]
-  return Object.fromEntries(filtered)
-}
diff --git a/vue2/packages/plugins/Gfi/src/utils/getOriginalFeature.ts b/vue2/packages/plugins/Gfi/src/utils/getOriginalFeature.ts
deleted file mode 100644
index 73d36750e3..0000000000
--- a/vue2/packages/plugins/Gfi/src/utils/getOriginalFeature.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import { GeoJSON } from 'ol/format'
-import { Geometry } from 'ol/geom'
-import { Feature } from 'ol'
-import compare from 'just-compare'
-import { isVisible } from '@polar/lib-invisible-style'
-import { GeoJsonProperties } from 'geojson'
-import VectorSource from 'ol/source/Vector'
-
-export const getOriginalFeature = (
-  sources: VectorSource<Feature<Geometry>>[],
-  properties: GeoJsonProperties
-) =>
-  sources
-    .map((source) =>
-      source
-        .getFeatures()
-        .filter(isVisible)
-        .map((feature) => {
-          // true = silent change (prevents cluster recomputation & rerender)
-          feature.set('_gfiLayerId', source.get('_gfiLayerId'), true)
-          return feature
-        })
-    )
-    .flat(1)
-    .find((f) =>
-      compare(JSON.parse(new GeoJSON().writeFeature(f)).properties, properties)
-    )
diff --git a/vue2/packages/plugins/Gfi/src/utils/isValidHttpUrl.js b/vue2/packages/plugins/Gfi/src/utils/isValidHttpUrl.js
deleted file mode 100644
index 7632b7dc2d..0000000000
--- a/vue2/packages/plugins/Gfi/src/utils/isValidHttpUrl.js
+++ /dev/null
@@ -1,11 +0,0 @@
-export default function isValidHttpUrl(string) {
-  let url
-
-  try {
-    url = new URL(string)
-  } catch (_) {
-    return false
-  }
-
-  return url.protocol === 'http:' || url.protocol === 'https:'
-}
diff --git a/vue2/packages/plugins/Gfi/src/utils/listableLayersFilter.ts b/vue2/packages/plugins/Gfi/src/utils/listableLayersFilter.ts
deleted file mode 100644
index 4ff598f9ca..0000000000
--- a/vue2/packages/plugins/Gfi/src/utils/listableLayersFilter.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import { Vector as VectorLayer } from 'ol/layer'
-import BaseLayer from 'ol/layer/Base'
-
-export const listableLayersFilter = (layer: BaseLayer): boolean =>
-  Boolean(
-    layer instanceof VectorLayer ||
-      console.warn(
-        `@polar/plugin-gfi: Layer ${layer.get(
-          'id'
-        )} will not produce list results since it is not a vector layer.`
-      )
-  )
diff --git a/vue2/packages/plugins/Gfi/src/utils/renderFeatures.ts b/vue2/packages/plugins/Gfi/src/utils/renderFeatures.ts
deleted file mode 100644
index cba31f8b2d..0000000000
--- a/vue2/packages/plugins/Gfi/src/utils/renderFeatures.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import VectorLayer from 'ol/layer/Vector'
-import { FeaturesByLayerId } from '../types'
-import { addFeature } from './displayFeatureLayer'
-import { filterFeatures } from './filterFeatures'
-
-export function renderFeatures(
-  featureDisplayLayer: VectorLayer,
-  geometryLayerKeys: string[],
-  features: FeaturesByLayerId
-) {
-  const filteredFeatures = filterFeatures(features)
-  geometryLayerKeys
-    .filter((key) => Array.isArray(features[key]))
-    .forEach((key) =>
-      filteredFeatures[key].forEach((feature) =>
-        addFeature(feature, featureDisplayLayer)
-      )
-    )
-}
diff --git a/vue2/packages/plugins/Gfi/src/utils/requestGfi.ts b/vue2/packages/plugins/Gfi/src/utils/requestGfi.ts
deleted file mode 100644
index 308b392be3..0000000000
--- a/vue2/packages/plugins/Gfi/src/utils/requestGfi.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-import { Feature as GeoJsonFeature } from 'geojson'
-import ImageLayer from 'ol/layer/Image'
-import TileLayer from 'ol/layer/Tile'
-import VectorLayer from 'ol/layer/Vector'
-import { rawLayerList } from '@masterportal/masterportalapi'
-import { RequestGfiParameters } from '../types'
-
-import requestGfiWms from './requestGfiWms'
-import requestGfiWfs from './requestGfiWfs'
-import requestGfiGeoJson from './requestGfiGeoJson'
-
-/**
- * The requestGfi method abstracts from service-specific implementation and
- * retrieves feature information. Not all formats are supported yet.
- *
- * Namely, services returning any GML variant, or fitting text responses by
- * default, should work. All others are not yet implemented.
- * @param parameters - parameter object
- * @returns found features for GFI request
- */
-export function requestGfi({
-  map,
-  layer,
-  coordinateOrExtent,
-  layerConfiguration,
-  layerSpecification,
-  mode,
-}: RequestGfiParameters): Promise<GeoJsonFeature[]> {
-  const layerId = layer.get('id')
-  try {
-    const params = {
-      map,
-      layerConfiguration,
-      layerSpecification,
-    }
-    if (layer instanceof TileLayer || layer instanceof ImageLayer) {
-      return coordinateOrExtent.length === 2
-        ? requestGfiWms({
-            ...params,
-            coordinate: coordinateOrExtent,
-            layer,
-          })
-        : Promise.reject(
-            new Error(
-              `An extent can not be used for ${layerId} as it is a WMS layer which only support coordinates for gfi requests.`
-            )
-          )
-    }
-    if (
-      rawLayerList.getLayerWhere({ id: layerId })?.typ === 'GeoJSON' &&
-      // NOTE: This is the case by design of @masterportal/masterportalapi but is added here for type safety
-      layer instanceof VectorLayer
-    ) {
-      return requestGfiGeoJson({ ...params, coordinateOrExtent, layer })
-    }
-    if (layer instanceof VectorLayer) {
-      return requestGfiWfs({ ...params, coordinateOrExtent, mode })
-    }
-    const notImplemented = `Layer ${layerId} was neither a Tile- nor a VectorLayer. GFI not implemented.`
-    return Promise.reject(new Error(notImplemented))
-  } catch (e) {
-    const error = `An error occurred while requesting features from layer with the id ${layerId}.`
-    return Promise.reject(new Error(error))
-  }
-}
diff --git a/vue2/packages/plugins/Gfi/src/utils/requestGfiGeoJson.ts b/vue2/packages/plugins/Gfi/src/utils/requestGfiGeoJson.ts
deleted file mode 100644
index 9088c7b2be..0000000000
--- a/vue2/packages/plugins/Gfi/src/utils/requestGfiGeoJson.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import { Feature as GeoJsonFeature } from 'geojson'
-import { Feature, Map } from 'ol'
-import { GeoJSON } from 'ol/format'
-import VectorLayer from 'ol/layer/Vector'
-import { FeatureLike } from 'ol/Feature'
-
-const writer = new GeoJSON()
-
-const getNestedFeatures = (
-  feature: Feature | FeatureLike
-): Feature | Feature[] | FeatureLike =>
-  feature instanceof Feature
-    ? feature.get('features')?.length
-      ? feature.get('features')
-      : feature
-    : feature
-
-/**
- * Returns features from GeoJSON layer as GeoJSON.
- */
-export default ({
-  map,
-  coordinateOrExtent,
-  layer,
-}: {
-  map: Map
-  coordinateOrExtent: [number, number] | [number, number, number, number]
-  layer: VectorLayer
-}): Promise<GeoJsonFeature[]> =>
-  Promise.resolve(
-    (coordinateOrExtent.length === 2
-      ? map.getFeaturesAtPixel(map.getPixelFromCoordinate(coordinateOrExtent), {
-          layerFilter: (candidate) => candidate === layer,
-        })
-      : // @ts-expect-error | Layers reaching this place have a source
-        layer
-          .getSource()
-          .getFeaturesInExtent(coordinateOrExtent)
-          .map(getNestedFeatures)
-          .flat(1)
-    )
-      .map((feature) =>
-        feature instanceof Feature
-          ? JSON.parse(writer.writeFeature(feature))
-          : false
-      )
-      // remove FeatureLikes
-      .filter((x) => x)
-  )
diff --git a/vue2/packages/plugins/Gfi/src/utils/requestGfiWfs.ts b/vue2/packages/plugins/Gfi/src/utils/requestGfiWfs.ts
deleted file mode 100644
index fec250ca5f..0000000000
--- a/vue2/packages/plugins/Gfi/src/utils/requestGfiWfs.ts
+++ /dev/null
@@ -1,112 +0,0 @@
-import { GeoJSON, WFS } from 'ol/format'
-import { Feature as GeoJsonFeature } from 'geojson'
-import { RequestGfiParameters } from '../types'
-
-/**
- * Parses WFS reply to jsonable objects.
- * NOTE This method may break on unexpected formats and require further
- * detection. For now, all WFS seem to "behave".
- * @param xmlString - Features as returned by WFS service
- * @param wfsVersion - Version of WFS service
- * @returns features as flat GeoJSON (NOT ol/GeoJSON)
- */
-const xml2GeoJson = (
-  xmlString: string,
-  wfsVersion: string
-): GeoJsonFeature[] => {
-  const parser = new WFS({ version: wfsVersion })
-  const writer = new GeoJSON()
-  const features = parser.readFeatures(xmlString)
-  const geoJsonFeatures = features.map((f) =>
-    JSON.parse(writer.writeFeature(f))
-  )
-
-  return geoJsonFeatures
-}
-
-/**
- * Executes gfi request on wfs layer and returns result as GeoJSON.
- * NOTE Optimization idea: For layers where features are regularly loaded,
- * no new request should be started. Instead, wait for any running load to
- * finish and use feature at layer source coordinate. (Not trivial.)
- */
-export default ({
-  map,
-  coordinateOrExtent,
-  layerConfiguration,
-  layerSpecification,
-  mode,
-}: Pick<
-  RequestGfiParameters,
-  | 'map'
-  | 'coordinateOrExtent'
-  | 'layerConfiguration'
-  | 'layerSpecification'
-  | 'mode'
->): Promise<GeoJsonFeature[]> => {
-  if (coordinateOrExtent.length === 4 && mode !== 'bboxDot') {
-    return Promise.reject(
-      new Error(
-        `Configuration error in requestGfiWfs.ts: mode must be "bboxDot" to be able to use an extent for gfi requests, but was "${mode}".`
-      )
-    )
-  }
-  const { featureType, url, version } = layerSpecification
-  const { geometryName } = layerConfiguration
-  const code = map.getView().getProjection().getCode()
-  const typeName = version === '2.0.0' ? 'typeNames' : 'typename'
-  let featureUrl = `${url}?service=WFS&version=${version}&request=GetFeature&${typeName}=${featureType}&srsName=${code}`
-
-  if (mode === 'bboxDot') {
-    const extent =
-      coordinateOrExtent.length === 2
-        ? /* The extended extent is necessary because an extent with the same
-           * coordinates could lead to an empty featureCollection. */
-          [
-            coordinateOrExtent[0] - 0.1,
-            coordinateOrExtent[1] - 0.1,
-            coordinateOrExtent[0] + 0.1,
-            coordinateOrExtent[1] + 0.1,
-          ]
-        : coordinateOrExtent
-
-    featureUrl += `&bbox=${extent},${code}`
-  } else if (mode === 'intersects') {
-    const point =
-      `<gml:Point srsName="${code}">` +
-      `<gml:coordinates>${coordinateOrExtent[0]},${coordinateOrExtent[1]}</gml:coordinates>` +
-      '</gml:Point>'
-    featureUrl +=
-      '&FILTER=' +
-      // NOTE: fes as a namespace and ValueReference for a property has been introduced in 2.0.0
-      (version === '2.0.0'
-        ? '<fes:Filter>' +
-          '<fes:Intersects>' +
-          `<fes:ValueReference>${geometryName}</fes:ValueReference>` +
-          point +
-          '</fes:Intersects>' +
-          '</fes:Filter>'
-        : '<ogc:Filter xmlns:ogc="http://www.opengis.net/ogc">' +
-          '<ogc:Intersects>' +
-          `<ogc:PropertyName>${geometryName}</ogc:PropertyName>` +
-          point +
-          '</fes:Intersects>' +
-          '</fes:Filter>')
-  } else {
-    return Promise.reject(
-      new Error(
-        `Type error in requestGfiWfs.ts: mode must be "intersects" or "bboxDot", but was "${mode}".`
-      )
-    )
-  }
-
-  return (
-    fetch(featureUrl, { method: 'GET' })
-      .then((response) => response.text())
-      // TODO: Type of layerSpecification needs an update to better reflect the possibilities of the services
-      //  and get rid of this @ts-ignore
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      .then((xmlText) => xml2GeoJson(xmlText, version))
-  )
-}
diff --git a/vue2/packages/plugins/Gfi/src/utils/requestGfiWms.ts b/vue2/packages/plugins/Gfi/src/utils/requestGfiWms.ts
deleted file mode 100644
index addad5ff85..0000000000
--- a/vue2/packages/plugins/Gfi/src/utils/requestGfiWms.ts
+++ /dev/null
@@ -1,204 +0,0 @@
-import WFS from 'ol/format/WFS'
-import GML32 from 'ol/format/GML32'
-import GML3 from 'ol/format/GML3'
-import GML2 from 'ol/format/GML2'
-import GML from 'ol/format/GML'
-import { GeoJSON } from 'ol/format'
-import { Feature } from 'ol'
-import { Feature as GeoJsonFeature } from 'geojson'
-import Geometry from 'ol/geom/Geometry'
-import { TileWMS } from 'ol/source'
-import { RequestGfiWmsParameters } from '../types'
-
-// list of supported reply formats that can be used from OL
-const formats = {
-  GML,
-  GML2,
-  GML3,
-  GML32,
-}
-
-/**
- * This is a custom text response reader working on an unspecified format that
- * commonly occurs in WMS GFI replies. It can be used by specifying "text" as
- * "format" on a GFI specification. Please mind that it's written from
- * experience, not from a clear definition, and may need attention whenever
- * new cases arise.
- * @param text - Custom text response, hopefully in the implemented format
- * @returns array of OpenLayers features
- */
-function readTextFeatures(text: string): Feature<Geometry>[] {
-  const lines = text.split('\n')
-  const features: Feature<Geometry>[] = []
-  let feature: Feature<Geometry> | undefined
-  /* TODO: Format supposedly looks like this – is this a standard or arbitrary?
-      GetFeatureInfo results:
-        LayerName:
-          FeatureId:
-            Horse: Yes
-            Speed: Fast
-            Horsepower: 4
-  */
-
-  for (const line of lines) {
-    if (
-      line === '' ||
-      line.startsWith('GetFeatureInfo results') ||
-      line.startsWith('Layer')
-    ) {
-      continue
-    }
-    if (line.startsWith('    ')) {
-      if (typeof feature !== 'undefined') {
-        const equalIndex = line.indexOf('=')
-        const [key, value] = [
-          line.substring(0, equalIndex),
-          line.substring(equalIndex + 3, line.length - 1),
-        ].map((s) => s.trim())
-        feature.set(key, value)
-      } else {
-        console.error(
-          '@polar/plugin-gfi: Found property before feature declaration in readTextFeatures.',
-          line,
-          'Skipping ...'
-        )
-      }
-      continue
-    }
-    if (line.startsWith('  ')) {
-      if (line.includes('Search returned no results')) {
-        break
-      }
-      const id = line.substring(0, line.length - 2).trim()
-      feature = new Feature()
-      feature.setId(id)
-      features.push(feature)
-    }
-  }
-  return features
-}
-
-/**
- * In case the layer configuration does not specify a parser, we're trying to
- * detect the returned XML format by searching for a GML namespace. Any return
- * format outside GML will currently not work with this automated parsing.
- * @param data - data as parsed from response body
- * @returns WFS capable of parsing data
- */
-function getParserFromData(data: string): WFS {
-  // NOTE: Tested for GML32 and GML, may break on GML2/GML3
-  const GMLFormat = data.includes('xmlns:gml="http://www.opengis.net/gml/3.2"')
-    ? GML32
-    : data.includes('xmlns:gml="http://www.opengis.net/gml"')
-    ? GML
-    : data.includes('xmlns:gml="http://www.opengis.net/gml/2')
-    ? GML2
-    : GML3
-
-  return new WFS({
-    gmlFormat: new GMLFormat(),
-  })
-}
-
-/**
- * A layer may have its parser specified in the configuration. In this case,
- * the specified parser is retrieved from a list of supported GML parsers, or a
- * custom text parser is used in case it fits.
- * @param format - format as specified by mapConfiguration
- * @returns object that supplies 'readTextFeatures' method
- */
-function getParserFromFormat(format: string): Pick<WFS, 'readFeatures'> {
-  if (formats[format]) {
-    return new WFS({
-      gmlFormat: new formats[format](),
-    })
-  }
-
-  if (format === 'text') {
-    return {
-      readFeatures: readTextFeatures,
-    }
-  }
-
-  throw new Error(`Format '${format}' not yet implemented in requestGfiWms.ts.`)
-}
-
-/**
- * @param parameters - map, layer, and coordinate to use for GFI request
- * @returns url to request for feature information
- */
-function getWmsGfiUrl(
-  { map, layer, coordinate }: RequestGfiWmsParameters,
-  { infoFormat }: Record<string, unknown>
-): string {
-  // Only layers with a valid source reach this point
-  const source = layer.getSource() as TileWMS
-  const view = map.getView()
-  const url = source.getFeatureInfoUrl(
-    coordinate,
-    // The view always has a resolution if this function is called
-    view.getResolution() as number,
-    view.getProjection(),
-    {
-      feature_count: 10,
-    }
-  )
-  const suffix = infoFormat ? `&info_format=${infoFormat}` : ''
-  return url + suffix
-}
-
-/**
- * Method fetches WMS feature information. Result will be filtered and modified
- * according to layerConfiguration.
- * @param parameters - parameter object
- * @returns promise of all features that hold relevant feature information
- */
-export default (
-  parameters: RequestGfiWmsParameters
-): Promise<GeoJsonFeature[]> => {
-  const { coordinate, layerConfiguration, layerSpecification } = parameters
-  const { filterBy, geometryName, format } = layerConfiguration
-
-  const url = getWmsGfiUrl(parameters, layerSpecification)
-
-  return fetch(url)
-    .then((response) => response.text())
-    .then((data) => {
-      /* NOTE: test block for WMS GFI
-      import WMSGetFeatureInfo from 'ol/format/WMSGetFeatureInfo'
-      try {
-        console.error('WMS GFI', url)
-        console.error(new WMSGetFeatureInfo().readFeatures(data))
-      } catch (e) {
-        console.error(e)
-      }
-      */
-
-      const parser =
-        layerSpecification.infoFormat === 'application/geojson'
-          ? new GeoJSON()
-          : format
-          ? getParserFromFormat(format)
-          : getParserFromData(data)
-
-      const parsedFeatures: Feature<Geometry>[] = parser.readFeatures(data)
-      const writer = new GeoJSON()
-
-      if (geometryName) {
-        parsedFeatures.forEach((f) => f.setGeometryName('geometry'))
-      }
-
-      const jsonFeatures = parsedFeatures
-        // WMS may return features nearby - filter to hit features
-        .filter((feature) =>
-          filterBy === 'clickPosition'
-            ? feature.getGeometry()?.intersectsCoordinate(coordinate)
-            : true
-        )
-        // transform to jsonable object representation
-        .map((f) => JSON.parse(writer.writeFeature(f)))
-
-      return jsonFeatures
-    })
-    .catch((e) => Promise.reject(e))
-}
diff --git a/vue2/packages/plugins/Gfi/src/utils/sortFeatures.ts b/vue2/packages/plugins/Gfi/src/utils/sortFeatures.ts
deleted file mode 100644
index 73f684d12a..0000000000
--- a/vue2/packages/plugins/Gfi/src/utils/sortFeatures.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import { Feature as GeoJsonFeature } from 'geojson'
-import GeoJSON from 'ol/format/GeoJSON'
-import { LineString, MultiLineString, MultiPolygon, Polygon } from 'ol/geom'
-
-/**
- * If multiple features are selected on a layer, it is necessary to order them by size.
- * This means that the order of the features in the array is largest to smallest,
- * as the first feature of the array is rendered first from OpenLayers.
- *
- * This function is used with Array.prototype.sort to order the given features its order.
- * The meaning of the return value can be read up on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#description}.
- */
-export default function (
-  featureA: GeoJsonFeature,
-  featureB: GeoJsonFeature,
-  srsName: string
-): number {
-  const parser = new GeoJSON({
-    dataProjection: srsName,
-    featureProjection: srsName,
-  })
-  const geometryA = parser.readGeometry(featureA.geometry)
-  const geometryB = parser.readGeometry(featureB.geometry)
-
-  const aIsPolygon =
-    geometryA instanceof Polygon || geometryA instanceof MultiPolygon
-  const bIsPolygon =
-    geometryB instanceof Polygon || geometryB instanceof MultiPolygon
-
-  if (aIsPolygon && bIsPolygon) {
-    return geometryB.getArea() - geometryA.getArea()
-  }
-  // If one of the geometries is not a polygon, Polygons are ordered to the front, then LineStrings, lastly Points
-  if (aIsPolygon) {
-    return -1
-  }
-  if (bIsPolygon) {
-    return 1
-  }
-  const aIsLineString =
-    geometryA instanceof LineString || geometryA instanceof MultiLineString
-  const bIsLineString =
-    geometryB instanceof LineString || geometryB instanceof MultiLineString
-
-  if (aIsLineString && bIsLineString) {
-    return 0
-  }
-  if (aIsLineString) {
-    return -1
-  }
-  if (bIsLineString) {
-    return 1
-  }
-  return 0
-}
diff --git a/vue2/packages/plugins/Gfi/tests/actions.spec.ts b/vue2/packages/plugins/Gfi/tests/actions.spec.ts
deleted file mode 100644
index 26d87a44ec..0000000000
--- a/vue2/packages/plugins/Gfi/tests/actions.spec.ts
+++ /dev/null
@@ -1,200 +0,0 @@
-// NOTE: action tests currently not type-supported, but working
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-import { makeActions } from '../src/store/actions'
-
-jest.mock('../src/utils/requestGfi', () => ({
-  requestGfi: jest.fn(() => Promise.resolve([])),
-}))
-
-jest.mock('../src/utils/displayFeatureLayer', () => ({
-  getFeatureDisplayLayer: jest.fn(),
-  addFeature: jest.fn(),
-  clear: jest.fn(),
-}))
-
-describe('GFI Actions', () => {
-  const actions = makeActions()
-  beforeEach(() => {
-    jest.clearAllMocks()
-    jest.useFakeTimers()
-  })
-  it('should call getFeatureInfo with the correct parameters', async () => {
-    const dispatch = jest.fn()
-    const coordinate = [0, 0]
-
-    const rootGetters = {
-      map: {
-        getLayers: () => ({
-          getArray: () => [],
-        }),
-        getView: () => ({
-          getProjection: () => ({
-            getCode: () => 'EPSG:4326',
-          }),
-        }),
-      },
-    }
-    const configuration = {
-      gfi: {
-        layers: {},
-        mode: 'bboxDot',
-        maxFeatures: 10,
-      },
-    }
-    const getters = {
-      layerKeys: ['layer1'],
-      geometryLayerKeys: [],
-      afterLoadFunction: null,
-      gfiConfiguration: configuration.gfi,
-    }
-
-    const context = {
-      commit: jest.fn(),
-      dispatch,
-      rootGetters,
-      configuration,
-      getters,
-    }
-
-    const getFeatureInfo = actions.getFeatureInfo
-    // @ts-ignore
-    await getFeatureInfo(context, coordinate)
-
-    expect(dispatch).toHaveBeenCalledTimes(1)
-    expect(dispatch).toHaveBeenCalledWith('debouncedGfiRequest', coordinate)
-  })
-  it('should fetch and process features', async () => {
-    const commit = jest.fn()
-    const configuration = {
-      gfi: {
-        layers: {
-          layer1: {
-            maxFeatures: 10,
-          },
-        },
-        mode: 'bboxDot',
-        maxFeatures: 10,
-      },
-    }
-    const rootGetters = {
-      map: {
-        getLayers: () => ({
-          getArray: () => [],
-        }),
-        getView: () => ({
-          getProjection: () => ({
-            getCode: () => 'EPSG:4326',
-          }),
-        }),
-      },
-      configuration,
-    }
-    const getters = {
-      layerKeys: ['layer1'],
-      geometryLayerKeys: ['layer1'],
-      afterLoadFunction: null,
-      gfiConfiguration: configuration.gfi,
-    }
-
-    const context = {
-      commit,
-      rootGetters,
-      getters,
-    }
-
-    const coordinate = [0, 0]
-    const layerResponse = []
-
-    const allSettledResult = [{ status: 'fulfilled', value: layerResponse }]
-    const allSettledMock = jest.spyOn(Promise, 'allSettled')
-    // @ts-ignore
-    allSettledMock.mockResolvedValue(allSettledResult)
-
-    const debounceMock = jest.fn((fn) => fn)
-    jest.mock('lodash', () => ({
-      debounce: debounceMock,
-    }))
-
-    const debouncedFunction = actions.debouncedGfiRequest
-    // @ts-ignore
-    const debouncedPromise = debouncedFunction(context, coordinate)
-    // @ts-ignore
-    jest.runAllTimers()
-
-    await debouncedPromise
-
-    expect(context.commit).toHaveBeenCalledTimes(1)
-    expect(context.commit).toHaveBeenCalledWith('setFeatureInformation', {
-      layer1: [],
-    })
-  })
-  it('should handle failed feature request', async () => {
-    const commit = jest.fn()
-    const configuration = {
-      gfi: {
-        layers: {
-          layer1: {
-            maxFeatures: 10,
-          },
-        },
-        mode: 'bboxDot',
-        maxFeatures: 10,
-      },
-    }
-    const rootGetters = {
-      map: {
-        getLayers: () => ({
-          getArray: () => [],
-        }),
-        getView: () => ({
-          getProjection: () => ({
-            getCode: () => 'EPSG:4326',
-          }),
-        }),
-      },
-      configuration,
-    }
-    const getters = {
-      layerKeys: ['layer1'],
-      geometryLayerKeys: ['layer1'],
-      afterLoadFunction: null,
-      gfiConfiguration: configuration.gfi,
-    }
-
-    const context = {
-      commit,
-      rootGetters,
-      getters,
-    }
-
-    const coordinate = [0, 0]
-
-    const allSettledResult = [
-      {
-        status: 'rejected',
-        reason: { message: 'Feature request failed' },
-      },
-    ]
-    const allSettledMock = jest.spyOn(Promise, 'allSettled')
-    // @ts-ignore
-    allSettledMock.mockResolvedValue(allSettledResult)
-
-    const debounceMock = jest.fn((fn) => fn)
-    jest.mock('lodash', () => ({
-      debounce: debounceMock,
-    }))
-
-    const debouncedFunction = actions.debouncedGfiRequest
-    // @ts-ignore
-    const debouncedPromise = debouncedFunction(context, coordinate)
-    // @ts-ignore
-    jest.runAllTimers()
-
-    await debouncedPromise
-
-    expect(context.commit).toHaveBeenCalledTimes(1)
-    expect(context.commit).toHaveBeenCalledWith('setFeatureInformation', {
-      layer1: expect.any(Symbol),
-    })
-  })
-})
diff --git a/vue2/packages/plugins/Gfi/tests/filterFeatures.spec.ts b/vue2/packages/plugins/Gfi/tests/filterFeatures.spec.ts
deleted file mode 100644
index 60cdfe5c85..0000000000
--- a/vue2/packages/plugins/Gfi/tests/filterFeatures.spec.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import { filterFeatures } from '../src/utils/filterFeatures'
-
-describe('filterFeatures', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-    jest.useFakeTimers()
-  })
-
-  it('should return an object with only GeoJsonFeature[] as its values if the values were already only GeoJsonFeature[]', () => {
-    expect(
-      Object.keys(
-        filterFeatures({
-          idOne: [
-            {
-              type: 'Feature',
-              geometry: { type: 'Point', coordinates: [0, 0] },
-              properties: { goodFeature: true },
-            },
-          ],
-          idTwo: [
-            {
-              type: 'Feature',
-              geometry: { type: 'Point', coordinates: [1, 1] },
-              properties: { goodFeature: true },
-            },
-            {
-              type: 'Feature',
-              geometry: { type: 'Point', coordinates: [0, 1] },
-              properties: { goodFeature: false },
-            },
-          ],
-        })
-      ).length
-    ).toBe(2)
-  })
-  it('should return an object with less keys if some values are symbols', () => {
-    expect(
-      Object.keys(
-        filterFeatures({
-          idOne: Symbol('failing'),
-          idTwo: [
-            {
-              type: 'Feature',
-              geometry: { type: 'Point', coordinates: [1, 1] },
-              properties: { goodFeature: true },
-            },
-            {
-              type: 'Feature',
-              geometry: { type: 'Point', coordinates: [0, 1] },
-              properties: { goodFeature: false },
-            },
-          ],
-        })
-      ).length
-    ).toBe(1)
-  })
-  it('should return an empty object if all values are symbols', () => {
-    expect(
-      Object.keys(
-        filterFeatures({
-          idOne: Symbol('failing'),
-          idTwo: Symbol('another fail'),
-        })
-      ).length
-    ).toBe(0)
-  })
-})
diff --git a/vue2/packages/plugins/Gfi/tests/sortFeatures.spec.ts b/vue2/packages/plugins/Gfi/tests/sortFeatures.spec.ts
deleted file mode 100644
index fd9d7a9e42..0000000000
--- a/vue2/packages/plugins/Gfi/tests/sortFeatures.spec.ts
+++ /dev/null
@@ -1,235 +0,0 @@
-import { Feature as GeoJsonFeature, LineString, Point, Polygon } from 'geojson'
-import sortFeatures from '../src/utils/sortFeatures'
-
-describe('sortFeatures', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-    jest.useFakeTimers()
-  })
-
-  describe('sorting two features', () => {
-    it('should sort the features by area (biggest first) if both are Polygons', () => {
-      const featureA: GeoJsonFeature<Polygon> = {
-        type: 'Feature',
-        geometry: {
-          type: 'Polygon',
-          coordinates: [
-            [
-              [10.5, 59],
-              [15, 59],
-              [15, 56],
-              [10, 56],
-              [10.5, 59],
-            ],
-          ],
-        },
-        properties: {},
-      }
-      const featureB: GeoJsonFeature<Polygon> = {
-        type: 'Feature',
-        geometry: {
-          type: 'Polygon',
-          coordinates: [
-            [
-              [-4.25, 62],
-              [27.5, 62],
-              [26.5, 45],
-              [-4.25, 50],
-              [-4.5, 62.25],
-            ],
-          ],
-        },
-        properties: {},
-      }
-      expect(
-        [featureA, featureB].sort((a, b) => sortFeatures(a, b, 'EPSG:4326'))
-      ).toEqual([featureB, featureA])
-    })
-    it('should put the Polygon feature first if the other feature is not a Polygon', () => {
-      const featureA: GeoJsonFeature<LineString> = {
-        type: 'Feature',
-        geometry: {
-          type: 'LineString',
-          coordinates: [
-            [1.5, 55],
-            [20, 55],
-          ],
-        },
-        properties: {},
-      }
-      const featureB: GeoJsonFeature<Polygon> = {
-        type: 'Feature',
-        geometry: {
-          type: 'Polygon',
-          coordinates: [
-            [
-              [10.5, 59],
-              [15, 59],
-              [15, 56],
-              [10, 56],
-              [10.5, 59],
-            ],
-          ],
-        },
-        properties: {},
-      }
-      expect(
-        [featureA, featureB].sort((a, b) => sortFeatures(a, b, 'EPSG:4326'))
-      ).toEqual([featureB, featureA])
-    })
-    it('should should keep the original order if both features are LineStrings', () => {
-      const featureA: GeoJsonFeature<LineString> = {
-        type: 'Feature',
-        geometry: {
-          type: 'LineString',
-          coordinates: [
-            [1.5, 55],
-            [20, 55],
-          ],
-        },
-        properties: {},
-      }
-      const featureB: GeoJsonFeature<LineString> = {
-        type: 'Feature',
-        geometry: {
-          type: 'LineString',
-          coordinates: [
-            [1.5, 55],
-            [20, 55],
-            [10, 56],
-          ],
-        },
-        properties: {},
-      }
-      expect(
-        [featureA, featureB].sort((a, b) => sortFeatures(a, b, 'EPSG:4326'))
-      ).toEqual([featureA, featureB])
-    })
-    it('should put the LineString feature first if the other feature is a Point Feature', () => {
-      const featureA: GeoJsonFeature<Point> = {
-        type: 'Feature',
-        geometry: {
-          type: 'Point',
-          coordinates: [1.5, 55],
-        },
-        properties: {},
-      }
-      const featureB: GeoJsonFeature<LineString> = {
-        type: 'Feature',
-        geometry: {
-          type: 'LineString',
-          coordinates: [
-            [1.5, 55],
-            [20, 55],
-            [10, 56],
-          ],
-        },
-        properties: {},
-      }
-      expect(
-        [featureA, featureB].sort((a, b) => sortFeatures(a, b, 'EPSG:4326'))
-      ).toEqual([featureB, featureA])
-    })
-    it('should should keep the original order if both features are Points', () => {
-      const featureA: GeoJsonFeature<Point> = {
-        type: 'Feature',
-        geometry: {
-          type: 'Point',
-          coordinates: [1.5, 55],
-        },
-        properties: {},
-      }
-      const featureB: GeoJsonFeature<Point> = {
-        type: 'Feature',
-        geometry: {
-          type: 'Point',
-          coordinates: [55, 1.5],
-        },
-        properties: {},
-      }
-      expect(
-        [featureA, featureB].sort((a, b) => sortFeatures(a, b, 'EPSG:4326'))
-      ).toEqual([featureA, featureB])
-    })
-  })
-  describe('sorting more than two features', () => {
-    it('should order the features by Polygons first, then LineStrings and lastly Points', () => {
-      const featureA: GeoJsonFeature<LineString> = {
-        type: 'Feature',
-        geometry: {
-          type: 'LineString',
-          coordinates: [
-            [1.5, 55],
-            [20, 55],
-          ],
-        },
-        properties: {},
-      }
-      const featureB: GeoJsonFeature<LineString> = {
-        type: 'Feature',
-        geometry: {
-          type: 'LineString',
-          coordinates: [
-            [1.5, 55],
-            [20, 55],
-            [10, 56],
-          ],
-        },
-        properties: {},
-      }
-      const featureC: GeoJsonFeature<Point> = {
-        type: 'Feature',
-        geometry: {
-          type: 'Point',
-          coordinates: [1.5, 55],
-        },
-        properties: {},
-      }
-      const featureD: GeoJsonFeature<Polygon> = {
-        type: 'Feature',
-        geometry: {
-          type: 'Polygon',
-          coordinates: [
-            [
-              [10.5, 59],
-              [15, 59],
-              [15, 56],
-              [10, 56],
-              [10.5, 59],
-            ],
-          ],
-        },
-        properties: {},
-      }
-      const featureE: GeoJsonFeature<Point> = {
-        type: 'Feature',
-        geometry: {
-          type: 'Point',
-          coordinates: [55, 1.5],
-        },
-        properties: {},
-      }
-      const featureF: GeoJsonFeature<Polygon> = {
-        type: 'Feature',
-        geometry: {
-          type: 'Polygon',
-          coordinates: [
-            [
-              [-4.25, 62],
-              [27.5, 62],
-              [26.5, 45],
-              [-4.25, 50],
-              [-4.5, 62.25],
-            ],
-          ],
-        },
-        properties: {},
-      }
-      expect(
-        [featureA, featureB, featureC, featureD, featureE, featureF].sort(
-          (a, b) => sortFeatures(a, b, 'EPSG:4326')
-        )
-      ).toEqual([featureF, featureD, featureA, featureB, featureC, featureE])
-    })
-  })
-})
diff --git a/vue2/packages/plugins/Gfi/vite.config.js b/vue2/packages/plugins/Gfi/vite.config.js
deleted file mode 100644
index 0d2ec38a15..0000000000
--- a/vue2/packages/plugins/Gfi/vite.config.js
+++ /dev/null
@@ -1,3 +0,0 @@
-import { getCodeConfig } from '../../../viteConfigs'
-
-export default getCodeConfig()
diff --git a/vue2/packages/types/custom/core.ts b/vue2/packages/types/custom/core.ts
index 36e4e3071d..5279405fc1 100644
--- a/vue2/packages/types/custom/core.ts
+++ b/vue2/packages/types/custom/core.ts
@@ -82,108 +82,3 @@ export interface DrawMetaService {
 	aggregationMode?: 'unequal' | 'all'
 	propertyNames?: string[]
 }
-
-/** Configuration of GFI feature regarding a specific layer */
-export interface GfiLayerConfiguration {
-	/**
-	 * Property of the features of a service having an url usable to trigger a
-	 * download of features as a document.
-	 */
-	exportProperty?: string
-	// filter method to apply on response features, only relevant for WMS services
-	filterBy?: 'clickPosition'
-	// format the response is known to come in (e.g. "GML"); only relevant for WMS services
-	format?: 'GML' | 'GML2' | 'GML3' | 'GML32' | 'text'
-	/**
-	 * Whether the found features' geometry, if available, is to be shown on the
-	 * map. It is simply printed to a helper layer.
-	 */
-	geometry?: boolean
-	// name of field to use for geometry, if not default field
-	geometryName?: string
-	isSelectable?: GfiIsSelectableFunction
-	maxFeatures?: number
-	/**
-	 * If window is true, the properties are either
-	 * 1. filtered by whether their key is in a string[]
-	 * 2. filtered by whether their key is in the given object's keys, and then
-	 *    translated to the object's value for that key
-	 * I.e., a feature \{ a: 0, b: 0, c: 0 \} with ['a', 'b'] will show key-value
-	 * pairs 'a':0 and 'b':0, and the same feature with object \{a: 'A'\} will
-	 * show key-value pair 'A':0, mind the uppercase A, which is the mapped key.
-	 *
-	 * This does not influence what information is available in the store,
-	 * only the UI is affected by these filters/mappings.
-	 */
-	properties?: string[] | Record<string, string>
-	showTooltip?: (feature: Feature, map: Map) => [string, string][]
-	/**
-	 * Whether the found features' properties are to be shown in the client's UI.
-	 * They are displayed as a table, one feature at a time, and if multiple
-	 * features are found, the user may step through all where the layer's window
-	 * value is true.
-	 */
-	window?: boolean
-}
-
-/** Object containing information for highlighting a gfi result */
-export interface HighlightStyle {
-	fill: Fill
-	stroke: Stroke
-}
-
-export type GfiIsSelectableFunction = (feature: GeoJsonFeature) => boolean
-
-/** configurable function to gather additional info */
-export type GfiAfterLoadFunction = (
-	featureInformation: Record<string, GeoJsonFeature[]>,
-	srsName: string // TODO: Might be interesting to overlap this with mapConfig.namedProjections for type safety in using only allowed epsg codes
-) =>
-	| Record<string, GeoJsonFeature[] | symbol>
-	| Promise<Record<string, GeoJsonFeature[] | symbol>>
-
-/** GFI Module Configuration */
-export interface FeatureList {
-	mode: 'visible' | 'loaded'
-	bindWithCoreHoverSelect?: boolean
-	pageLength?: number
-	text?: (string | ((f: Feature) => string))[]
-}
-
-export interface GfiConfiguration extends PluginOptions {
-	/**
-	 * Source paths through store to listen to for changes; it is assumed values
-	 * listened to are coordinates that can be used to request information from
-	 * the specified layers.
-	 */
-	coordinateSources: string[]
-	/**
-	 * The layers to request feature information from. Both WMS and WFS layers are
-	 * supported. Keys are layer IDs as specified in the services.json registry.
-	 */
-	layers: Record<string, GfiLayerConfiguration>
-	activeLayerPath?: string
-	afterLoadFunction?: GfiAfterLoadFunction
-	boxSelect?: boolean
-	/**
-	 * If required the stroke and fill of the highlighted feature can be configured.
-	 * Otherwise, a default style is applied.
-	 */
-	customHighlightStyle?: HighlightStyle
-	directSelect?: boolean
-	featureList?: FeatureList
-	/**
-	 * Optionally replace GfiContent component.
-	 * Usable to completely redesign content of GFI window.
-	 */
-	gfiContentComponent?: VueConstructor
-	/**
-	 * Limits the viewable GFIs per layer by this number. The first n elements
-	 * are chosen arbitrarily. Useful if you e.g. just want one result, or to
-	 * limit an endless stream of returns to maybe 10 or so. Infinite by default.
-	 */
-	maxFeatures?: number
-	mode?: 'bboxDot' | 'intersects'
-	multiSelect?: 'box' | 'circle'
-	renderType?: 'iconMenu' | 'independent'
-}