diff --git a/README.md b/README.md
index 5f69d3d66..43bd4d627 100644
--- a/README.md
+++ b/README.md
@@ -114,7 +114,7 @@ Explore how to use MetaConfigurator with real-world examples:
 
 *   **[External References](./documentation_user/examples/external_references)** – Learn how to handle external references in MetaConfigurator.
 
-*   **[RDF Panel](./documentation_user/examples/rdf)** – Learn how to use MetaConfigurator to explore Semantic data.
+*   **[RDF Panel](./documentation_user/examples/rdf)** – Learn how to use MetaConfigurator to create, explore and edit Semantic RDF data.
 
 📚 Read the full [User Documentation](./documentation_user).
 
diff --git a/meta_configurator/e2e/csvImport.spec.ts b/meta_configurator/e2e/csvImport.spec.ts
new file mode 100644
index 000000000..73e50184e
--- /dev/null
+++ b/meta_configurator/e2e/csvImport.spec.ts
@@ -0,0 +1,70 @@
+import {test, expect} from '@playwright/test';
+import {openApp} from './utils';
+import {tpGetData} from './utilsTestPanel';
+import {
+    expandImportOptions,
+    openCsvImportDialog,
+    setColumnPath,
+    setCsvTablePath,
+    submitCsvImport,
+    uploadCsvFile,
+    uploadCsvFileAndCheckProgress,
+} from './utilsCsvImport';
+import {SessionMode} from '../src/store/sessionMode';
+
+test('Import CSV as standalone table with default paths', async ({page}) => {
+    await openApp(page, 'settings_testpanel.json');
+
+    await openCsvImportDialog(page);
+    await uploadCsvFile(page, 'data_people.csv');
+
+    // submit without changing any options — default table path comes from the filename
+    await submitCsvImport(page);
+
+    // filename "data_people.csv" → stringToIdentifier strips underscores → key is "datapeople"
+    const data = await tpGetData(page, SessionMode.DataEditor);
+    expect(data).toHaveProperty('datapeople');
+    expect(data.datapeople).toHaveLength(2);
+    expect(data.datapeople[0]).toMatchObject({name: 'Alice', city: 'Berlin', role: 'Engineer'});
+    expect(data.datapeople[1]).toMatchObject({name: 'Bob', city: 'Munich', role: 'Designer'});
+});
+
+test('Import CSV with custom table path and renamed column', async ({page}) => {
+    await openApp(page, 'settings_testpanel.json');
+
+    await openCsvImportDialog(page);
+    await uploadCsvFile(page, 'data_people.csv');
+
+    await expandImportOptions(page);
+    await setCsvTablePath(page, 'people');
+    await setColumnPath(page, 'city', 'location');
+
+    await submitCsvImport(page);
+
+    const data = await tpGetData(page, SessionMode.DataEditor);
+    expect(data).toEqual({
+        people: [
+            {name: 'Alice', location: 'Berlin', role: 'Engineer'},
+            {name: 'Bob', location: 'Munich', role: 'Designer'},
+        ],
+    });
+});
+
+test('CSV file upload progresses reliably for 15 consecutive attempts in the same session without reload', async ({page}) => {
+    test.setTimeout(60000);
+    await openApp(page, 'settings_testpanel.json');
+
+    for (let attempt = 1; attempt <= 15; attempt++) {
+        await test.step(`csv upload attempt ${attempt}`, async () => {
+            await openCsvImportDialog(page);
+            try {
+                await uploadCsvFileAndCheckProgress(page, 'data_people.csv', 4000);
+            } catch (error) {
+                throw new Error(`CSV upload attempt ${attempt} got stuck before parsing completed`, {
+                    cause: error instanceof Error ? error : undefined,
+                });
+            }
+            await submitCsvImport(page);
+        });
+    }
+});
diff --git a/meta_configurator/e2e/panelGuiEditor.spec.ts b/meta_configurator/e2e/panelGuiEditor.spec.ts
index 2093e58c1..88151f423 100644
--- a/meta_configurator/e2e/panelGuiEditor.spec.ts
+++ b/meta_configurator/e2e/panelGuiEditor.spec.ts
@@ -32,6 +32,9 @@ test('Edit the feature testing example schema using the GUI Editor, testing basi
 
     // Set the heightInMeter property to the value 10
     await editNumberOrIntProperty(page, ['heightInMeter'], 10)
+    await expect
+        .poll(async () => (await tpGetData(page, SessionMode.DataEditor)).heightInMeter)
+        .toBe(10)
 
     // Expect a Schema Violation Symbol because the height value is invalid
     await checkPropertySchemaViolation(page, ['heightInMeter'], true)
@@ -142,4 +145,4 @@ test('Change the GUI editor content and check if the internal data is updated pr
     // Validate that the internal data is updated correctly
     const dataAfterNameEnter = await tpGetData(page, SessionMode.DataEditor);
     expect(dataAfterNameEnter).toEqual({ name: 'Alex', address: { city: 'Berlin' } });
-});
\ No newline at end of file
+});
diff --git a/meta_configurator/e2e/test-fixtures/data_people.csv b/meta_configurator/e2e/test-fixtures/data_people.csv
new file mode 100644
index 000000000..d9cf33143
--- /dev/null
+++ b/meta_configurator/e2e/test-fixtures/data_people.csv
@@ -0,0 +1,3 @@
+name,city,role
+Alice,Berlin,Engineer
+Bob,Munich,Designer
diff --git a/meta_configurator/e2e/utilsCsvImport.ts b/meta_configurator/e2e/utilsCsvImport.ts
new file mode 100644
index 000000000..aae13678b
--- /dev/null
+++ b/meta_configurator/e2e/utilsCsvImport.ts
@@ -0,0 +1,53 @@
+import {Page} from 'playwright';
+import {expect} from '@playwright/test';
+import path from 'node:path';
+
+const fixturesDir = path.resolve(process.cwd(), 'e2e/test-fixtures');
+
+export async function openCsvImportDialog(page: Page) {
+    await page.locator('#import-data').click();
+    await page.getByRole('menuitem', {name: 'Import CSV Data'}).click();
+    await expect(page.getByRole('dialog', {name: 'Import CSV'})).toBeVisible();
+}
+
+export async function uploadCsvFile(page: Page, filename: string) {
+    const fileChooserPromise = page.waitForEvent('filechooser');
+    await page.getByTestId('csv-select-file').click();
+    const fileChooser = await fileChooserPromise;
+    await fileChooser.setFiles(path.join(fixturesDir, filename));
+    // wait for the Import button to appear, confirming the CSV was parsed
+    await expect(page.getByTestId('csv-submit-import')).toBeVisible();
+}
+
+export async function uploadCsvFileAndCheckProgress(page: Page, filename: string, timeoutMs: number = 5000) {
+    const [fileChooser] = await Promise.all([
+        page.waitForEvent('filechooser', {timeout: timeoutMs}),
+        page.getByTestId('csv-select-file').click({timeout: timeoutMs}),
+    ]);
+    await fileChooser.setFiles(path.join(fixturesDir, filename));
+    await expect(
+        page.getByTestId('csv-submit-import'),
+        'CSV import dialog did not progress past file selection'
+    ).toBeVisible({timeout: timeoutMs});
+}
+
+export async function expandImportOptions(page: Page) {
+    await page.getByTestId('csv-import-options-toggle').click();
+}
+
+export async function setCsvTablePath(page: Page, tablePath: string) {
+    const input = page.getByTestId('csv-table-path-input');
+    await input.clear();
+    await input.fill(tablePath);
+}
+
+export async function setColumnPath(page: Page, columnName: string, newPath: string) {
+    const input = page.getByTestId(`csv-column-path-${columnName}`);
+    await input.clear();
+    await input.fill(newPath);
+}
+
+export async function submitCsvImport(page: Page) {
+    await page.getByTestId('csv-submit-import').click();
+    await expect(page.getByRole('dialog', {name: 'Import CSV'})).not.toBeVisible();
+}
diff --git a/meta_configurator/e2e/utilsGuiEditor.ts b/meta_configurator/e2e/utilsGuiEditor.ts
index 677e6928f..545c15432 100644
--- a/meta_configurator/e2e/utilsGuiEditor.ts
+++ b/meta_configurator/e2e/utilsGuiEditor.ts
@@ -2,7 +2,6 @@ import {Page} from "playwright";
 import {expect} from "@playwright/test";
 import {Path, PathElement} from "../src/utility/path";
 import {pathToString} from "../src/utility/pathUtils";
-import {selectAll} from "./utils";
 
 
 export async function checkPropertyExistence(page: Page, propertyPath: Path, shouldBeVisible: boolean) {
@@ -40,21 +39,24 @@ export async function editNumberOrIntProperty(page: Page, propertyPath: Path, va
     const pathAsString = pathToString(propertyPath);
     const spinButton = page.getByTestId(`property-data-${pathAsString}`).getByRole('spinbutton')
     await spinButton.click();
-    await selectAll(page);
-    await spinButton.press('Backspace');
-
-    // Simulate real typing
-    for (const char of value.toString()) {
-        await page.keyboard.press(char);
-    }
-
-    await spinButton.press('Enter');
+    await spinButton.evaluate((input, newValue) => {
+        const nativeValueSetter = Object.getOwnPropertyDescriptor(
+            window.HTMLInputElement.prototype,
+            'value'
+        )?.set;
+        nativeValueSetter?.call(input, String(newValue));
+        input.dispatchEvent(new Event('input', {bubbles: true}));
+        input.setAttribute('aria-valuenow', String(newValue));
+    }, value);
+    await spinButton.blur();
 }
 
 export async function checkNumberOrIntProperty(page: Page, propertyPath: Path, value: number) {
     const pathAsString = pathToString(propertyPath);
     const textField = page.getByTestId(`property-data-${pathAsString}`).getByRole('spinbutton')
-    await expect(textField).toHaveValue(value.toString());
+    await expect
+        .poll(async () => await textField.getAttribute('aria-valuenow'))
+        .toBe(value.toString());
 }
 
 export async function removeOptionalPropertyValue(page: Page, propertyPath: Path) {
@@ -77,9 +79,11 @@ export async function addArrayItem(page: Page, propertyPath: Path) {
 
 export async function checkPropertySchemaViolation(page: Page, propertyPath: Path, shouldBeVisible: boolean) {
     const pathAsString = pathToString(propertyPath);
-    const validationErrorIcon = page.getByTestId(`property-metadata-${pathAsString}`).getByTestId("validation-error-icon");
+    const propertyMetadata = page.getByTestId(`property-metadata-${pathAsString}`);
+    const validationErrorIcon = propertyMetadata.getByTestId("validation-error-icon");
     if (shouldBeVisible) {
-        await expect(validationErrorIcon).toBeVisible();
+        await expect(propertyMetadata).toBeVisible();
+        await expect(validationErrorIcon).toBeVisible({timeout: 8000});
     } else {
         await expect(validationErrorIcon).not.toBeVisible();
     }
@@ -101,4 +105,4 @@ export async function expandOrCollapseProperty(page: Page, propertyPathElement:
     // do check if the name starts with the propertyName, but ignore the other part of the name, as it can differ always depending on the children count
     const expansionButton = page.getByRole('cell', { name: new RegExp(`^${propertyPathElement} :`) }).getByRole('button');
     await expansionButton.click();
-}
\ No newline at end of file
+}
diff --git a/meta_configurator/src/components/CombinedEditorComponent.vue b/meta_configurator/src/components/CombinedEditorComponent.vue
index 18234f0e1..f5770fa3e 100644
--- a/meta_configurator/src/components/CombinedEditorComponent.vue
+++ b/meta_configurator/src/components/CombinedEditorComponent.vue
@@ -3,7 +3,7 @@ Main component of the application.
 Combines the code editor and the gui editor.
 -->
 <script lang="ts" setup>
-import {computed, onMounted, onUnmounted, type Ref, ref, watch} from 'vue';
+import {computed, onMounted, onUnmounted, ref, watch} from 'vue';
 import 'primeicons/primeicons.css';
 import SplitterPanel from 'primevue/splitterpanel';
 import Splitter from 'primevue/splitter';
@@ -15,13 +15,13 @@ import {useConfirm} from 'primevue/useconfirm';
 import {confirmationService} from '@/utility/confirmationService';
 import {toastService} from '@/utility/toastService';
 import {useAppRouter} from '@/router/router';
-import {useDropZone, useWindowSize, watchImmediate} from '@vueuse/core/index';
+import {useDropZone, useWindowSize, watchImmediate} from '@vueuse/core';
 import {readFileContentToDataLink} from '@/utility/readFileContent';
 import {getDataForMode} from '@/data/useDataLink';
 import {useSettings} from '@/settings/useSettings';
 import {modeToRoute, SessionMode} from '@/store/sessionMode';
 import {useSessionStore} from '@/store/sessionStore';
-import type {SettingsInterfacePanels, SettingsInterfaceRoot} from '@/settings/settingsTypes';
+import type {SettingsInterfacePanels} from '@/settings/settingsTypes';
 import {SETTINGS_DATA_DEFAULT} from '@/settings/defaultSettingsData';
 import {updateSettingsWithDefaults} from '@/settings/settingsUpdater';
 import {panelTypeRegistry} from '@/components/panels/panelTypeRegistry';
@@ -38,15 +38,17 @@ let panelsDefinition: SettingsInterfacePanels = settings.value.panels;
 // Ace Editor
 watchImmediate(
   () => settings,
-  (settings: Ref<SettingsInterfaceRoot>) => {
-    let panels = settings.value.panels;
+  settings => {
+    const panels = settings.value.panels;
     if (JSON.stringify(panels) !== JSON.stringify(panelsDefinition)) {
       panelsDefinition = panels;
     }
     // fix panels if they are not defined
     for (let mode of Object.values(SessionMode)) {
       if (!panels[mode]) {
-        panels[mode] = structuredClone(SETTINGS_DATA_DEFAULT.panels[mode]);
+        panels[mode] = structuredClone(
+          SETTINGS_DATA_DEFAULT.panels[mode]
+        ) as SettingsInterfacePanels[typeof mode];
       }
     }
   }
@@ -61,6 +63,7 @@ const panels = computed(() => {
     };
   });
 });
+const panelsKey = computed(() => JSON.stringify(panels.value));
 
 let {width} = useWindowSize();
 
@@ -164,10 +167,10 @@ onUnmounted(() => {
           class="h-full"
           style="min-width: 0"
           :layout="width < 600 ? 'vertical' : 'horizontal'"
-          :key="panels">
+          :key="panelsKey">
           <SplitterPanel
             v-for="(panel, index) in panels"
-            :key="index + panel"
+            :key="`${panel.sessionMode}-${index}`"
             :min-size="10"
             :size="panel.size"
             :resizable="true">
diff --git a/meta_configurator/src/components/panels/ai-prompts/AiPromptsTemplate.vue b/meta_configurator/src/components/panels/ai-prompts/AiPromptsTemplate.vue
index a0a2e987a..d072283de 100644
--- a/meta_configurator/src/components/panels/ai-prompts/AiPromptsTemplate.vue
+++ b/meta_configurator/src/components/panels/ai-prompts/AiPromptsTemplate.vue
@@ -261,7 +261,10 @@ async function submitPromptExportDocument() {
   // if the schema defines export formats, the user prompt is ignored and the selected export format is used
   if (documentExportFormatNames.value.length > 0) {
     const exportFormatName = selectedExportFormat.value;
-    const exportFormatDef = documentExportFormats.value![exportFormatName];
+    const exportFormatDef = documentExportFormats.value?.[exportFormatName];
+    if (!exportFormatDef) {
+      throw new Error(`Unknown export format "${exportFormatName}".`);
+    }
     // if export format is just a string, it is the URL
     if (typeof exportFormatDef === 'string') {
       userPrompt = await fetchExternalContentText(exportFormatDef);
diff --git a/meta_configurator/src/components/panels/code-editor/setupAnnotations.ts b/meta_configurator/src/components/panels/code-editor/setupAnnotations.ts
index 129aa4330..af5416ebd 100644
--- a/meta_configurator/src/components/panels/code-editor/setupAnnotations.ts
+++ b/meta_configurator/src/components/panels/code-editor/setupAnnotations.ts
@@ -77,9 +77,12 @@ function validationErrorsToAnnotations(editor: Editor, errors: ErrorObject[]): A
     }
 
     const index = positions[instancePathKey];
-    let position;
+    if (index === undefined) {
+      continue;
+    }
+    let position: {row: number; column: number};
     if (index in cachedPositionsForIndices) {
-      position = cachedPositionsForIndices[index];
+      position = cachedPositionsForIndices[index]!;
     } else {
       position = editor.session.doc.indexToPosition(index, 0);
       cachedPositionsForIndices[index] = position;
diff --git a/meta_configurator/src/components/panels/code-editor/setupLinkToSelectionAndData.ts b/meta_configurator/src/components/panels/code-editor/setupLinkToSelectionAndData.ts
index 34d154e39..2713b2279 100644
--- a/meta_configurator/src/components/panels/code-editor/setupLinkToSelectionAndData.ts
+++ b/meta_configurator/src/components/panels/code-editor/setupLinkToSelectionAndData.ts
@@ -9,7 +9,7 @@ import {
 } from '@/components/panels/code-editor/aceUtility';
 import type {SessionMode} from '@/store/sessionMode';
 import {getDataForMode, getSessionForMode} from '@/data/useDataLink';
-import {watchImmediate} from '@vueuse/core/index';
+import {watchImmediate} from '@vueuse/core';
 import {useSettings} from '@/settings/useSettings';
 import {sizeOf} from '@/utility/sizeOf';
 
diff --git a/meta_configurator/src/components/panels/gui-editor/PropertiesPanel.vue b/meta_configurator/src/components/panels/gui-editor/PropertiesPanel.vue
index 11fdd0514..2999836d0 100644
--- a/meta_configurator/src/components/panels/gui-editor/PropertiesPanel.vue
+++ b/meta_configurator/src/components/panels/gui-editor/PropertiesPanel.vue
@@ -507,19 +507,18 @@ const schemaInfoOverlay = ref<InstanceType<typeof SchemaInfoOverlay> | undefined
 const allowShowOverlay = ref(true);
 const overlayShowScheduled = ref(false);
 
-const showInfoOverlayPanelInstantly = (nodeData: ConfigTreeNodeData, event: MouseEvent) => {
+const showInfoOverlayPanelInstantly = (nodeData: ConfigTreeNodeData, event: Event) => {
   const relevantErrors = getValidationResults(nodeData.absolutePath).errors;
-  // @ts-ignore
   schemaInfoOverlay.value?.showPanel(
     nodeData.schema,
-    nodeData.name,
+    String(nodeData.name),
     nodeData.parentSchema,
     relevantErrors,
     event
   );
 };
 const showInfoOverlayPanelDebounced = useDebounceFn(
-  (nodeData: ConfigTreeNodeData, event: MouseEvent) => {
+  (nodeData: ConfigTreeNodeData, event: Event) => {
     if (allowShowOverlay.value && overlayShowScheduled.value) {
       showInfoOverlayPanelInstantly(nodeData, event);
     }
@@ -527,7 +526,7 @@ const showInfoOverlayPanelDebounced = useDebounceFn(
   1000
 );
 
-function showInfoOverlayPanel(nodeData: ConfigTreeNodeData, event: MouseEvent) {
+function showInfoOverlayPanel(nodeData: ConfigTreeNodeData, event: Event) {
   overlayShowScheduled.value = true;
   showInfoOverlayPanelDebounced(nodeData, event);
 }
@@ -608,7 +607,9 @@ function zoomIntoPath(path: Path) {
             @update_tree="updateTree"
             @click="() => clickedPropertyData(slotProps.node.data)"
             bodyClass="w-full"
-            @keydown.ctrl.i="event => showInfoOverlayPanelInstantly(slotProps.node.data, event)"
+            @keydown.ctrl.i="
+              (event: KeyboardEvent) => showInfoOverlayPanelInstantly(slotProps.node.data, event)
+            "
             :data-testid="'property-data-' + pathToString(slotProps.node.data.absolutePath)" />
         </span>
 
diff --git a/meta_configurator/src/components/panels/gui-editor/PropertyMetadata.vue b/meta_configurator/src/components/panels/gui-editor/PropertyMetadata.vue
index 7c5c85f6f..32d62277f 100644
--- a/meta_configurator/src/components/panels/gui-editor/PropertyMetadata.vue
+++ b/meta_configurator/src/components/panels/gui-editor/PropertyMetadata.vue
@@ -93,7 +93,7 @@ function zoomIntoPath() {
   }
 }
 
-function updatePropertyName(event) {
+function updatePropertyName(event: KeyboardEvent | FocusEvent) {
   const target = event.target as HTMLElement;
   let text = target.innerText;
 
@@ -103,12 +103,12 @@ function updatePropertyName(event) {
   if (isPropertyNameEditable(props.type)) {
     emit('update_property_name', props.node.data.name as string, text);
   } else {
-    event.target.innerText = props.node.data.name;
+    target.innerText = String(props.node.data.name);
   }
 
   isEditingPropertyName.value = false;
   emit('stop_editing_property_name');
-  event.target.contenteditable = false;
+  target.contentEditable = 'false';
   showPencil.value = true;
 }
 
diff --git a/meta_configurator/src/components/panels/gui-editor/SchemaInfoOverlay.vue b/meta_configurator/src/components/panels/gui-editor/SchemaInfoOverlay.vue
index 33b494def..92f274527 100644
--- a/meta_configurator/src/components/panels/gui-editor/SchemaInfoOverlay.vue
+++ b/meta_configurator/src/components/panels/gui-editor/SchemaInfoOverlay.vue
@@ -18,7 +18,7 @@ import type {ErrorObject} from 'ajv';
 import {useSessionStore} from '@/store/sessionStore';
 
 const schemaRef: Ref<JsonSchemaWrapper | undefined> = ref();
-const propertyNameRef: Ref<String> = ref('');
+const propertyNameRef: Ref<string> = ref('');
 const parentSchemaRef: Ref<JsonSchemaWrapper | undefined> = ref();
 const validationErrorsRef: Ref<ErrorObject[]> = ref([]);
 
@@ -44,9 +44,9 @@ const keepOpen = ref(false);
 const showPanel = (
   schema: JsonSchemaWrapper,
   propertyName: string,
-  parentSchema: JsonSchemaWrapper,
+  parentSchema: JsonSchemaWrapper | undefined,
   validationErrors: ErrorObject[],
-  event
+  event: Event
 ) => {
   schemaRef.value = schema;
   propertyNameRef.value = propertyName;
diff --git a/meta_configurator/src/components/panels/gui-editor/configTreeNodeResolver.ts b/meta_configurator/src/components/panels/gui-editor/configTreeNodeResolver.ts
index 62ddb6325..8974fbd5c 100644
--- a/meta_configurator/src/components/panels/gui-editor/configTreeNodeResolver.ts
+++ b/meta_configurator/src/components/panels/gui-editor/configTreeNodeResolver.ts
@@ -1,6 +1,7 @@
 import {JsonSchemaWrapper} from '@/schema/jsonSchemaWrapper';
 import type {
   AddPropertyTreeNode,
+  ConfigDataTreeNode,
   ConfigDataTreeNodeType,
   GuiEditorTreeNode,
 } from '@/components/panels/gui-editor/configDataTreeNode';
@@ -247,7 +248,7 @@ export class ConfigTreeNodeResolver {
     mode: SessionMode,
     {absolutePath, relativePath, schema, depth}: TreeNodeResolvingParameters
   ): GuiEditorTreeNode | undefined {
-    const advanced = {
+    const advanced: ConfigDataTreeNode = {
       data: {
         name: schema.title ?? '',
         schema: schema,
@@ -272,7 +273,7 @@ export class ConfigTreeNodeResolver {
       ),
     };
 
-    if (advanced.children.length > 0) {
+    if ((advanced.children?.length ?? 0) > 0) {
       return advanced;
     }
 
@@ -297,7 +298,7 @@ export class ConfigTreeNodeResolver {
     const optionalProperties = this.createSchemaPropertiesChildNodes(
       mode,
       parameters,
-      key => !parameters.schema.isRequired(key) && !parameters.schema.properties[key].deprecated
+      key => !parameters.schema.isRequired(key) && !parameters.schema.properties[key]?.deprecated
     );
     const additionalProperties = this.createDataPropertiesChildNodes(
       mode,
@@ -307,7 +308,7 @@ export class ConfigTreeNodeResolver {
     const deprecatedProperties = this.createSchemaPropertiesChildNodes(
       mode,
       parameters,
-      key => parameters.schema.properties[key].deprecated && !parameters.schema.isRequired(key)
+      key => !!parameters.schema.properties[key]?.deprecated && !parameters.schema.isRequired(key)
     );
     return requiredProperties.concat(
       optionalProperties,
@@ -532,7 +533,11 @@ export class ConfigTreeNodeResolver {
     if (userSelectionOneOf !== undefined) {
       const baseSchema = {...schema.jsonSchema};
       delete baseSchema.type;
-      const newTypeSchema = typeSchema(schema.type[userSelectionOneOf.index], mode);
+      const selectedType = schema.type[userSelectionOneOf.index];
+      if (!selectedType) {
+        return [];
+      }
+      const newTypeSchema = typeSchema(selectedType, mode);
       const mergedSchema = new JsonSchemaWrapper(
         {
           allOf: [baseSchema, newTypeSchema.jsonSchema ?? {}],
@@ -563,6 +568,9 @@ export class ConfigTreeNodeResolver {
       const baseSchema = {...schema.jsonSchema};
       delete baseSchema.oneOf;
       const subSchemaOneOf = schema.oneOf[userSelectionOneOf.index];
+      if (!subSchemaOneOf) {
+        return [];
+      }
       const mergedSchema = new JsonSchemaWrapper(
         {
           allOf: [baseSchema, subSchemaOneOf.jsonSchema ?? {}],
@@ -593,7 +601,7 @@ export class ConfigTreeNodeResolver {
       const baseSchema = {...schema.jsonSchema};
       delete baseSchema.anyOf;
       const subSchemasAnyOf = userSelectionAnyOf.map(userSelectionEntry => {
-        return schema.anyOf[userSelectionEntry.index].jsonSchema ?? {};
+        return schema.anyOf[userSelectionEntry.index]?.jsonSchema ?? {};
       });
       const mergedSchema = safeMergeSchemas(baseSchema, ...subSchemasAnyOf);
       if (!mergedSchema) {
diff --git a/meta_configurator/src/components/panels/gui-editor/isStructuralChangeInInstance.ts b/meta_configurator/src/components/panels/gui-editor/isStructuralChangeInInstance.ts
index 63a13107c..0971a64dc 100644
--- a/meta_configurator/src/components/panels/gui-editor/isStructuralChangeInInstance.ts
+++ b/meta_configurator/src/components/panels/gui-editor/isStructuralChangeInInstance.ts
@@ -1,5 +1,3 @@
-import type {GuiEditorTreeNode} from '@/components/panels/gui-editor/configDataTreeNode.ts';
-
 export function isStructuralChangeInInstance(oldObject: any, newObject: any): boolean {
   // algorithm to determine whether any key or structure has changed between oldObject and newObject
   // changes in values of existing keys are not considered structural changes
diff --git a/meta_configurator/src/components/panels/gui-editor/properties/BooleanProperty.vue b/meta_configurator/src/components/panels/gui-editor/properties/BooleanProperty.vue
index 9755308ea..a3f541db7 100644
--- a/meta_configurator/src/components/panels/gui-editor/properties/BooleanProperty.vue
+++ b/meta_configurator/src/components/panels/gui-editor/properties/BooleanProperty.vue
@@ -6,7 +6,7 @@ They are represented as a select button with two options: true and false.
 import SelectButton from 'primevue/selectbutton';
 import {computed, ref} from 'vue';
 import type {PathElement} from '@/utility/path';
-import type {ValidationResult} from '@/schema/validationService';
+import type {ValidationResult} from '@/schema/validationUtils';
 import {JsonSchemaWrapper} from '@/schema/jsonSchemaWrapper';
 import {isReadOnly} from '@/components/panels/gui-editor/configTreeNodeReadingUtils';
 
diff --git a/meta_configurator/src/components/panels/gui-editor/properties/EnumProperty.vue b/meta_configurator/src/components/panels/gui-editor/properties/EnumProperty.vue
index 98ccd234a..cb081ffe3 100644
--- a/meta_configurator/src/components/panels/gui-editor/properties/EnumProperty.vue
+++ b/meta_configurator/src/components/panels/gui-editor/properties/EnumProperty.vue
@@ -7,7 +7,7 @@ import Select from 'primevue/select';
 import _ from 'lodash';
 import {dataToString} from '@/utility/dataToString';
 import type {PathElement} from '@/utility/path';
-import type {ValidationResult} from '@/schema/validationService';
+import type {ValidationResult} from '@/schema/validationUtils';
 import {JsonSchemaWrapper} from '@/schema/jsonSchemaWrapper';
 import {isReadOnly} from '@/components/panels/gui-editor/configTreeNodeReadingUtils';
 import {useSettings} from '@/settings/useSettings';
diff --git a/meta_configurator/src/components/panels/gui-editor/properties/NumberProperty.vue b/meta_configurator/src/components/panels/gui-editor/properties/NumberProperty.vue
index 81953a183..bf5461d8f 100644
--- a/meta_configurator/src/components/panels/gui-editor/properties/NumberProperty.vue
+++ b/meta_configurator/src/components/panels/gui-editor/properties/NumberProperty.vue
@@ -5,7 +5,7 @@ import {computed} from 'vue';
 import {JsonSchemaWrapper} from '@/schema/jsonSchemaWrapper';
 import {generatePlaceholderText} from '@/utility/propertyPlaceholderGenerator';
 import {GuiConstants} from '@/constants';
-import type {ValidationResult} from '@/schema/validationService';
+import type {ValidationResult} from '@/schema/validationUtils';
 import type {PathElement} from '@/utility/path';
 import {isReadOnly} from '@/components/panels/gui-editor/configTreeNodeReadingUtils';
 import {useSettings} from '@/settings/useSettings';
diff --git a/meta_configurator/src/components/panels/gui-editor/properties/OneOfSelectionProperty.vue b/meta_configurator/src/components/panels/gui-editor/properties/OneOfSelectionProperty.vue
index 80a1188dc..e890ba2ab 100644
--- a/meta_configurator/src/components/panels/gui-editor/properties/OneOfSelectionProperty.vue
+++ b/meta_configurator/src/components/panels/gui-editor/properties/OneOfSelectionProperty.vue
@@ -174,7 +174,9 @@ function applySchemaConstantsOnData(schema: JsonSchemaType, data: any): any {
         data = {};
       }
       if (key in data) {
-        applySchemaConstantsOnData(propertySchema, data[key]);
+        if (propertySchema !== undefined) {
+          applySchemaConstantsOnData(propertySchema, data[key]);
+        }
       }
     }
   }
diff --git a/meta_configurator/src/components/panels/gui-editor/properties/OntologyUriProperty.vue b/meta_configurator/src/components/panels/gui-editor/properties/OntologyUriProperty.vue
index 9cf0a7bdb..faf4fab5c 100644
--- a/meta_configurator/src/components/panels/gui-editor/properties/OntologyUriProperty.vue
+++ b/meta_configurator/src/components/panels/gui-editor/properties/OntologyUriProperty.vue
@@ -7,7 +7,7 @@ import AutoComplete from 'primevue/autocomplete';
 import _ from 'lodash';
 import {dataToString} from '@/utility/dataToString';
 import type {PathElement} from '@/utility/path';
-import type {ValidationResult} from '@/schema/validationService';
+import type {ValidationResult} from '@/schema/validationUtils';
 import {JsonSchemaWrapper} from '@/schema/jsonSchemaWrapper';
 import {isReadOnly} from '@/components/panels/gui-editor/configTreeNodeReadingUtils';
 import {findSuggestionsForSearchTerm} from '@/utility/rdf/findSuggestionsForSearchTerm';
diff --git a/meta_configurator/src/components/panels/gui-editor/properties/StringProperty.vue b/meta_configurator/src/components/panels/gui-editor/properties/StringProperty.vue
index b66d00344..9d8ea4ef8 100644
--- a/meta_configurator/src/components/panels/gui-editor/properties/StringProperty.vue
+++ b/meta_configurator/src/components/panels/gui-editor/properties/StringProperty.vue
@@ -5,7 +5,7 @@ import InputText from 'primevue/inputtext';
 import {generatePlaceholderText} from '@/utility/propertyPlaceholderGenerator';
 import type {JsonSchemaWrapper} from '@/schema/jsonSchemaWrapper';
 import type {PathElement} from '@/utility/path';
-import type {ValidationResult} from '@/schema/validationService';
+import type {ValidationResult} from '@/schema/validationUtils';
 import {isReadOnly} from '@/components/panels/gui-editor/configTreeNodeReadingUtils';
 import {useSettings} from '@/settings/useSettings';
 
diff --git a/meta_configurator/src/components/panels/list-analysis/ListAnalysisPanel.vue b/meta_configurator/src/components/panels/list-analysis/ListAnalysisPanel.vue
index 69810dee8..a63f12a9a 100644
--- a/meta_configurator/src/components/panels/list-analysis/ListAnalysisPanel.vue
+++ b/meta_configurator/src/components/panels/list-analysis/ListAnalysisPanel.vue
@@ -34,7 +34,7 @@ watch(possibleArrays, (newPossibleArrays: string[]) => {
   if (newPossibleArrays.length == 0) {
     selectedArrayPointer.value = null;
   } else if (newPossibleArrays.length == 1) {
-    selectedArrayPointer.value = possibleArrays.value[0];
+    selectedArrayPointer.value = possibleArrays.value[0] ?? null;
   } else {
     // if there are multiple arrays, we do not change the selection
   }
diff --git a/meta_configurator/src/components/panels/rdf/__tests__/rdfPanel.test.ts b/meta_configurator/src/components/panels/rdf/__tests__/rdfPanel.test.ts
index cd43eab76..9837e46ae 100644
--- a/meta_configurator/src/components/panels/rdf/__tests__/rdfPanel.test.ts
+++ b/meta_configurator/src/components/panels/rdf/__tests__/rdfPanel.test.ts
@@ -121,7 +121,8 @@ describe('RdfPanel', () => {
       predicateType: target!.predicate.termType,
       object: UPDATED_LABEL,
       objectType: RdfTermType.Literal,
-      objectDatatype: target!.object.datatype?.value ?? '',
+      objectDatatype:
+        target!.object.termType === RdfTermType.Literal ? target!.object.datatype?.value ?? '' : '',
       statement: target,
     });
 
@@ -172,7 +173,10 @@ describe('RdfPanel', () => {
       predicateType: editedStatement!.predicate.termType,
       object: ORIGINAL_LABEL,
       objectType: RdfTermType.Literal,
-      objectDatatype: editedStatement!.object.datatype?.value ?? '',
+      objectDatatype:
+        editedStatement!.object.termType === RdfTermType.Literal
+          ? editedStatement!.object.datatype?.value ?? ''
+          : '',
     });
     expect(addResult.success).toBe(true);
 
@@ -189,5 +193,5 @@ describe('RdfPanel', () => {
       () => JSON.stringify(getExportedJsonLd()) === JSON.stringify(expectedAddedJsonLd)
     );
     expect(getExportedJsonLd()).toEqual(expectedAddedJsonLd);
-  });
+  }, 8000);
 });
diff --git a/meta_configurator/src/components/panels/rdf/__tests__/rmlMappingServiceStandard.test.ts b/meta_configurator/src/components/panels/rdf/__tests__/rmlMappingServiceStandard.test.ts
index 9e20fc9e2..6c948d49f 100644
--- a/meta_configurator/src/components/panels/rdf/__tests__/rmlMappingServiceStandard.test.ts
+++ b/meta_configurator/src/components/panels/rdf/__tests__/rmlMappingServiceStandard.test.ts
@@ -23,4 +23,32 @@ describe('RmlMappingServiceStandard.performRmlMapping', () => {
     expect(result.success).toBe(true);
     expect(result.resultData).toEqual(expectedResult);
   });
+
+  it('excludes rr/rml/ql prefixes from the JSON-LD @context', async () => {
+    const input = JSON.parse(readFixture('input.json'));
+    const mappingConfig = readFixture('mapping.ttl');
+
+    const service = new RmlMappingServiceStandard();
+    const result = await service.performRmlMapping(input, mappingConfig);
+
+    expect(result.success).toBe(true);
+    const context = result.resultData['@context'];
+    expect(context).not.toHaveProperty('rr');
+    expect(context).not.toHaveProperty('rml');
+    expect(context).not.toHaveProperty('ql');
+  });
+
+  it('includes non-ignored prefixes in the JSON-LD @context', async () => {
+    const input = JSON.parse(readFixture('input.json'));
+    const mappingConfig = readFixture('mapping.ttl');
+
+    const service = new RmlMappingServiceStandard();
+    const result = await service.performRmlMapping(input, mappingConfig);
+
+    expect(result.success).toBe(true);
+    const context = result.resultData['@context'];
+    expect(context).toHaveProperty('m4i', 'http://w3id.org/nfdi4ing/metadata4ing#');
+    expect(context).toHaveProperty('schema', 'https://schema.org/');
+    expect(context).toHaveProperty('rdfs', 'http://www.w3.org/2000/01/rdf-schema#');
+  });
 });
diff --git a/meta_configurator/src/components/panels/rdf/rdf-authoring/RdfTripleToolbar.vue b/meta_configurator/src/components/panels/rdf/rdf-authoring/RdfTripleToolbar.vue
index b296d3876..e51217c4a 100644
--- a/meta_configurator/src/components/panels/rdf/rdf-authoring/RdfTripleToolbar.vue
+++ b/meta_configurator/src/components/panels/rdf/rdf-authoring/RdfTripleToolbar.vue
@@ -90,7 +90,7 @@ function toggleExportPopover(event: Event) {
   exportPopover.value?.toggle?.(event);
 }
 
-function onGlobalFilterChange(value: string | null) {
-  emit('update:globalFilterValue', value);
+function onGlobalFilterChange(value: string | undefined) {
+  emit('update:globalFilterValue', value ?? null);
 }
 </script>
diff --git a/meta_configurator/src/components/panels/rdf/sparql-editor/SparqlQueryTab.vue b/meta_configurator/src/components/panels/rdf/sparql-editor/SparqlQueryTab.vue
index 9b586b2d9..bdcd3c211 100644
--- a/meta_configurator/src/components/panels/rdf/sparql-editor/SparqlQueryTab.vue
+++ b/meta_configurator/src/components/panels/rdf/sparql-editor/SparqlQueryTab.vue
@@ -9,7 +9,7 @@
         },
       }">
       <div class="space-y-4 mb-2">
-        <Accordion :value="activeAccordion" @update:value="emit('update:activeAccordion', $event)">
+        <Accordion :value="activeAccordion" @update:value="updateActiveAccordion">
           <AccordionPanel value="aiPanel">
             <AccordionHeader>Use AI assistance to generate SPARQL queries</AccordionHeader>
             <AccordionContent>
@@ -119,6 +119,10 @@ const emit = defineEmits<{
   (e: 'run-query'): void;
   (e: 'open-visualization-help'): void;
 }>();
+
+function updateActiveAccordion(value: string | string[] | null | undefined) {
+  emit('update:activeAccordion', Array.isArray(value) ? value[0] ?? null : value ?? null);
+}
 </script>
 
 <style scoped>
diff --git a/meta_configurator/src/components/panels/rdf/sparql-editor/SparqlResultTab.vue b/meta_configurator/src/components/panels/rdf/sparql-editor/SparqlResultTab.vue
index 1a269eb9e..fbb878c55 100644
--- a/meta_configurator/src/components/panels/rdf/sparql-editor/SparqlResultTab.vue
+++ b/meta_configurator/src/components/panels/rdf/sparql-editor/SparqlResultTab.vue
@@ -93,12 +93,12 @@ const emit = defineEmits<{
 
 const exportPopover = ref<any>(null);
 
-function updateGlobalFilter(value: string | null) {
+function updateGlobalFilter(value: string | undefined) {
   const nextFilters = {
     ...props.filters,
     global: {
       ...(props.filters.global ?? {}),
-      value,
+      value: value ?? null,
     },
   };
   emit('update:filters', nextFilters);
diff --git a/meta_configurator/src/components/panels/rdf/visualizer/RdfVisualizerGraphPanel.vue b/meta_configurator/src/components/panels/rdf/visualizer/RdfVisualizerGraphPanel.vue
index 651bbd3a8..4d4a041ee 100644
--- a/meta_configurator/src/components/panels/rdf/visualizer/RdfVisualizerGraphPanel.vue
+++ b/meta_configurator/src/components/panels/rdf/visualizer/RdfVisualizerGraphPanel.vue
@@ -13,7 +13,7 @@
             raised
             :disabled="hasGraphError"
             v-tooltip.left="item.label"
-            @click="item.command" />
+            @click="event => item.command?.({originalEvent: event, item})" />
         </template>
       </Dock>
       <Dock v-if="!readOnly" :model="bottomDockItems" position="bottom" class="graph-dock-bottom">
@@ -23,7 +23,7 @@
             rounded
             raised
             v-tooltip.top="item.label"
-            @click="item.command" />
+            @click="event => item.command?.({originalEvent: event, item})" />
         </template>
       </Dock>
       <Transition name="fade">
diff --git a/meta_configurator/src/components/panels/rdf/visualizer/useRdfVisualizerGraph.ts b/meta_configurator/src/components/panels/rdf/visualizer/useRdfVisualizerGraph.ts
index f1d2c4016..2841cc282 100644
--- a/meta_configurator/src/components/panels/rdf/visualizer/useRdfVisualizerGraph.ts
+++ b/meta_configurator/src/components/panels/rdf/visualizer/useRdfVisualizerGraph.ts
@@ -77,7 +77,7 @@ export function useRdfVisualizerGraph(options: {
     const node = selectedNode ?? cy.value.nodes(':selected').first();
     if (!node || node.length === 0) return;
 
-    animateFit(node, 80, 400);
+    animateFit(node as any, 80, 400);
   }
 
   function focusNodeById(nodeId: string) {
@@ -189,14 +189,14 @@ export function useRdfVisualizerGraph(options: {
     const randomInRange = (min: number, max: number) => min + Math.random() * (max - min);
     return cy.value.layout({
       name: 'cose-bilkent',
-      animate: true,
+      animate: 'end',
       animationDuration: 1000,
       randomize: true,
       idealEdgeLength: randomInRange(160, 280),
       edgeElasticity: randomInRange(70, 140),
       gravity: randomInRange(70, 130),
       numIter: 15000,
-    });
+    } as any);
   }
 
   function enableGraphInteractions(graph: cytoscape.Core) {
diff --git a/meta_configurator/src/components/panels/schema-diagram/SchemaExternalReferenceNode.vue b/meta_configurator/src/components/panels/schema-diagram/SchemaExternalReferenceNode.vue
index 2d28c4173..6c8010285 100644
--- a/meta_configurator/src/components/panels/schema-diagram/SchemaExternalReferenceNode.vue
+++ b/meta_configurator/src/components/panels/schema-diagram/SchemaExternalReferenceNode.vue
@@ -57,7 +57,7 @@ function updateReferenceValue() {
       'External reference value is not defined. This should not happen. Please report this issue.'
     );
   }
-  emit('update_external_reference_value', props.data, props.data.reference, newName);
+  emit('update_external_reference_value', props.data, newName);
 }
 
 function deleteExternalReference() {
diff --git a/meta_configurator/src/components/panels/schema-diagram/schemaDiagramTypes.ts b/meta_configurator/src/components/panels/schema-diagram/schemaDiagramTypes.ts
index 35e5fd471..20f4be30b 100644
--- a/meta_configurator/src/components/panels/schema-diagram/schemaDiagramTypes.ts
+++ b/meta_configurator/src/components/panels/schema-diagram/schemaDiagramTypes.ts
@@ -17,7 +17,7 @@ export function schemaGraphToVueFlowNodes(graph: SchemaGraph): Node[] {
     return {
       id: pathToNodeId(data.absolutePath),
       position: {x: Math.random() * 500, y: Math.random() * 500},
-      label: data.name,
+      label: data.name ?? '',
       type: data.getNodeType(),
       data: data,
     };
diff --git a/meta_configurator/src/components/toolbar/ModeSelector.vue b/meta_configurator/src/components/toolbar/ModeSelector.vue
index 0f97768f4..c5db81c16 100644
--- a/meta_configurator/src/components/toolbar/ModeSelector.vue
+++ b/meta_configurator/src/components/toolbar/ModeSelector.vue
@@ -4,6 +4,7 @@ import type {MenuItem} from 'primevue/menuitem';
 import TabMenu from 'primevue/tabmenu';
 import {modeToMenuTitle, SessionMode} from '@/store/sessionMode';
 import {useSettings} from '@/settings/useSettings';
+import type {SettingsInterfaceRoot} from '@/settings/settingsTypes';
 
 const props = defineProps<{
   currentMode: SessionMode;
@@ -15,7 +16,7 @@ const emit = defineEmits<{
 
 const settings = useSettings();
 
-function getTabs(settings): MenuItem[] {
+function getTabs(settings: SettingsInterfaceRoot): MenuItem[] {
   const items: MenuItem[] = [];
 
   items.push({
@@ -56,18 +57,18 @@ watch(
   () => props.currentMode,
   mode => {
     const idx = tabs.value.findIndex(
-      (t, i) => t.command && tabs.value[i].label === modeToMenuTitle(mode)
+      (t, i) => t.command && tabs.value[i]?.label === modeToMenuTitle(mode)
     );
     if (idx >= 0) activeIndex.value = idx;
   },
   {immediate: true}
 );
 
-function onTabChange(event) {
+function onTabChange(event: {index: number}) {
   const idx = event.index;
   const item = tabs.value[idx];
   if (item?.command) {
-    item.command(event);
+    (item.command as () => void)();
   }
 }
 </script>
diff --git a/meta_configurator/src/components/toolbar/SearchBar.vue b/meta_configurator/src/components/toolbar/SearchBar.vue
index 4d4b07e38..0aa59784e 100644
--- a/meta_configurator/src/components/toolbar/SearchBar.vue
+++ b/meta_configurator/src/components/toolbar/SearchBar.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import {type Ref, ref} from 'vue';
+import {computed, type Ref, ref} from 'vue';
 import type {MenuItem} from 'primevue/menuitem';
 import Menu from 'primevue/menu';
 import {useSessionStore} from '@/store/sessionStore';
@@ -47,7 +47,7 @@ watchDebounced(
     searchInDataAndSchema(searchTerm.value)
       .then(searchResults => {
         if (searchResults.length > 0) {
-          session.currentSelectedElement.value = searchResults[0].path;
+          session.currentSelectedElement.value = searchResults[0]!.path;
         }
         session.currentSearchResults.value = searchResults;
         searchResultItems.value = searchResults
@@ -61,11 +61,10 @@ watchDebounced(
   {debounce: 500}
 );
 
-const showSearchResultsMenu = event => {
+const showSearchResultsMenu = (event: FocusEvent) => {
   searchResultMenu.value?.show(event, event.target);
   focus('searchBar');
 };
-import {computed} from 'vue';
 let mode = useSessionStore().currentMode;
 let session = getSessionForMode(mode);
 const currentIndex = computed(() => {
@@ -85,7 +84,7 @@ function goNext() {
 
   const idx = results.findIndex(r => r.path === session.currentSelectedElement.value);
   const nextIdx = (idx + 1) % results.length;
-  session.currentSelectedElement.value = results[nextIdx].path;
+  session.currentSelectedElement.value = results[nextIdx]!.path;
 }
 function goPrev() {
   const results = session.currentSearchResults.value;
@@ -93,7 +92,7 @@ function goPrev() {
 
   const idx = results.findIndex(r => r.path === session.currentSelectedElement.value);
   const prevIdx = (idx - 1 + results.length) % results.length;
-  session.currentSelectedElement.value = results[prevIdx].path;
+  session.currentSelectedElement.value = results[prevIdx]!.path;
 }
 </script>
 
diff --git a/meta_configurator/src/components/toolbar/TopToolbarMenuButtons.vue b/meta_configurator/src/components/toolbar/TopToolbarMenuButtons.vue
index dfbf6a88c..5cc7cd1f0 100644
--- a/meta_configurator/src/components/toolbar/TopToolbarMenuButtons.vue
+++ b/meta_configurator/src/components/toolbar/TopToolbarMenuButtons.vue
@@ -110,20 +110,26 @@ function getMenuItems(settings: SettingsInterfaceRoot, positionBottom: boolean):
 // computed property function to get menu items to allow for updating of the menu items
 const menuItems = computed(() => getMenuItems(settings.value, props.showBottomMenu));
 
-const itemMenuRefs = ref(new Map<string, typeof Menu>());
+const itemMenuRefs = ref(new Map<string, {toggle?: (event: Event) => void}>());
 
-function setItemMenuRef(item: MenuItem, menu: typeof Menu) {
-  itemMenuRefs.value.set(getLabelOfItem(item), menu);
+function setItemMenuRef(item: MenuItem, menu: {toggle?: (event: Event) => void} | null) {
+  const label = getLabelOfItem(item);
+  if (!label || !menu) {
+    return;
+  }
+  itemMenuRefs.value.set(label, menu);
 }
 function handleItemButtonClick(item: MenuItem, event: Event) {
   if (item.items) {
     const label = getLabelOfItem(item);
     if (label !== undefined) {
       const menu = itemMenuRefs.value.get(label);
-      menu.toggle(event);
+      if (menu?.toggle) {
+        menu.toggle(event);
+      }
     }
   } else if (item.command) {
-    item.command({item, originalEvent: event});
+    item.command?.({item, originalEvent: event} as any);
   }
 }
 function getLabelOfItem(item: MenuItem): string | undefined {
@@ -158,7 +164,7 @@ function isHighlighted(item: MenuItem) {
 
 <template>
   <!-- menu items -->
-  <div v-for="item in menuItems" :key="item.label">
+  <div v-for="item in menuItems" :key="getLabelOfItem(item) ?? item.key ?? ''">
     <span v-if="item.separator" class="text-lg p-2 text-gray-300">|</span>
     <Button
       v-else
@@ -177,7 +183,7 @@ function isHighlighted(item: MenuItem) {
       v-if="item.items"
       :model="item.items"
       :popup="true"
-      :ref="itemMenu => setItemMenuRef(item, itemMenu)">
+      :ref="itemMenu => setItemMenuRef(item, itemMenu as any)">
       <template #itemicon="slotProps">
         <div v-if="slotProps.item.icon !== undefined">
           <FontAwesomeIcon
diff --git a/meta_configurator/src/components/toolbar/dialogs/csvimport/ImportCsvDialog.vue b/meta_configurator/src/components/toolbar/dialogs/csvimport/ImportCsvDialog.vue
index 52b8717d6..c3dfa125d 100644
--- a/meta_configurator/src/components/toolbar/dialogs/csvimport/ImportCsvDialog.vue
+++ b/meta_configurator/src/components/toolbar/dialogs/csvimport/ImportCsvDialog.vue
@@ -82,7 +82,7 @@ function requestUploadFile() {
   requestUploadFileToRef(currentUserDataString, pathBeforeRowIndex);
 }
 
-watch(currentUserDataString, newValue => {
+watch(currentUserDataString, () => {
   const {delimiterSuggestion, decimalSeparatorSuggestion} =
     computeMostUsedDelimiterAndDecimalSeparator(currentUserDataString.value);
   delimiter.value = delimiterSuggestion;
@@ -90,7 +90,7 @@ watch(currentUserDataString, newValue => {
   // isInferSchema.value = isSchemaEmpty(useCurrentSchema().schemaRaw.value);
   loadCsvFromInput();
 });
-watch([decimalSeparator, delimiter], newValue => {
+watch([decimalSeparator, delimiter], () => {
   loadCsvFromInput();
 });
 
@@ -109,10 +109,15 @@ function loadCsvFromInput() {
 }
 
 // Watch for changes in currentUserCsv and update fields shown to user accordingly
-watch(currentUserCsv, newValue => {
+watch(currentUserCsv, () => {
   if (currentUserCsv.value.length > 0) {
     // Get the first row of the CSV file and use it as the column names
-    const columns = Object.keys(currentUserCsv.value[0]);
+    const firstRow = currentUserCsv.value[0];
+    if (!firstRow) {
+      currentColumnMapping.value = [];
+      return;
+    }
+    const columns = Object.keys(firstRow);
     currentColumnMapping.value = columns.map((column, index) => {
       return new CsvImportColumnMappingData(index, column, pathBeforeRowIndex);
     });
@@ -131,7 +136,7 @@ watch(currentUserCsv, newValue => {
 
   // by default, select the first table to expand
   if (possiblePreviousTables.value.length > 0) {
-    tableToExpand.value = possiblePreviousTables.value[0];
+    tableToExpand.value = possiblePreviousTables.value[0]!;
   }
 
   possiblePrimaryKeyProps.value = currentColumnMapping.value.map(column => {
@@ -141,7 +146,7 @@ watch(currentUserCsv, newValue => {
     };
   });
   if (possiblePrimaryKeyProps.value.length > 0) {
-    primaryKeyProp.value = possiblePrimaryKeyProps.value[0];
+    primaryKeyProp.value = possiblePrimaryKeyProps.value[0]!;
   }
 });
 
@@ -159,16 +164,19 @@ watch(tableToExpand, newValue => {
   // select the best matching foreign key property
   if (possibleForeignKeyProps.value.length > 0 && currentColumnMapping.value.length > 0) {
     const arrayPath = jsonPointerToPathTyped('/' + tableToExpand.value.value);
-    const bestMatchingForeignKey = findBestMatchingForeignKeyAttribute(
-      arrayPath,
-      currentUserCsv.value,
-      possibleForeignKeyProps.value.map(prop => prop.value),
-      primaryKeyProp.value.value
-    );
-    foreignKey.value = {
-      label: bestMatchingForeignKey,
-      value: bestMatchingForeignKey,
-    };
+    const bestMatchingForeignKey =
+      findBestMatchingForeignKeyAttribute(
+        arrayPath,
+        currentUserCsv.value,
+        possibleForeignKeyProps.value.map(prop => prop.value),
+        primaryKeyProp.value.value
+      ) ?? possibleForeignKeyProps.value[0]?.value;
+    if (bestMatchingForeignKey) {
+      foreignKey.value = {
+        label: bestMatchingForeignKey,
+        value: bestMatchingForeignKey,
+      };
+    }
   }
   // update pathBeforeRowIndex to the table path
   pathBeforeRowIndex.value = pathToJsonPointer(newValue.value).slice(1);
@@ -227,6 +235,7 @@ defineExpose({show: openDialog, close: hideDialog});
       <div class="flex align-items-center">
         <Button
           label="Select CSV Document"
+          data-testid="csv-select-file"
           @click="requestUploadFile"
           class="p-button-raised p-button-rounded"></Button>
         <FontAwesomeIcon
@@ -239,7 +248,8 @@ defineExpose({show: openDialog, close: hideDialog});
         v-if="currentUserDataString.length > 0"
         header="Import Options"
         toggleable
-        :collapsed="true">
+        :collapsed="true"
+        :pt="{pcToggleButton: {root: {'data-testid': 'csv-import-options-toggle'}}}">
         <div>
           <div class="flex align-items-center vertical-center">
             <label for="delimiter" class="mr-2"><b>Delimiter in the CSV document:</b></label>
@@ -300,7 +310,10 @@ defineExpose({show: openDialog, close: hideDialog});
               <label for="delimiter" class="mr-2">
                 <b>Path for the resulting array in the document:</b>
               </label>
-              <InputText v-model="pathBeforeRowIndex" class="fixed-width" />
+              <InputText
+                v-model="pathBeforeRowIndex"
+                data-testid="csv-table-path-input"
+                class="fixed-width" />
             </div>
           </div>
           <div v-else>
@@ -368,14 +381,17 @@ defineExpose({show: openDialog, close: hideDialog});
               </tr>
             </thead>
             <tbody>
-              <tr v-for="column in currentColumnMapping">
+              <tr v-for="column in currentColumnMapping" :key="column.index">
                 <td>{{ column.name }}</td>
                 <td>
                   <span class="text-xs">/{{ column.pathBeforeRowIndex }}/ROW_INDEX/</span>
                   <span class="text-xs" v-if="isExpandWithLookupTables"
                     >{{ foreignKey.value }}/</span
                   >
-                  <InputText v-model="column.pathAfterRowIndex" class="fixed-width" />
+                  <InputText
+                    v-model="column.pathAfterRowIndex"
+                    :data-testid="'csv-column-path-' + column.name"
+                    class="fixed-width" />
                 </td>
                 <!--td v-if="isInferSchema">
                 <InputText v-model="column.titleInSchema" class="fixed-width" />
@@ -389,6 +405,7 @@ defineExpose({show: openDialog, close: hideDialog});
       <Button
         v-if="currentUserCsv.length > 0"
         @click="submitImport"
+        data-testid="csv-submit-import"
         class="p-button-raised p-button-rounded"
         label="Import"></Button>
     </div>
diff --git a/meta_configurator/src/components/toolbar/dialogs/csvimport/__tests__/csvImportTypes.test.ts b/meta_configurator/src/components/toolbar/dialogs/csvimport/__tests__/csvImportTypes.test.ts
new file mode 100644
index 000000000..903f797c1
--- /dev/null
+++ b/meta_configurator/src/components/toolbar/dialogs/csvimport/__tests__/csvImportTypes.test.ts
@@ -0,0 +1,44 @@
+import {describe, expect, it} from 'vitest';
+import {ref} from 'vue';
+import {CsvImportColumnMappingData} from '@/components/toolbar/dialogs/csvimport/csvImportTypes';
+
+describe('CsvImportColumnMappingData', () => {
+  it('getPathForJsonDocument produces a typed path with correct segments', () => {
+    const pathBeforeRowIndex = ref('items');
+    const column = new CsvImportColumnMappingData(0, 'First Name', pathBeforeRowIndex);
+    // pathAfterRowIndex is initialised from stringToIdentifier(name) → 'first_name'
+
+    const path = column.getPathForJsonDocument(3);
+
+    expect(path).toEqual(['items', 3, 'first_name']);
+  });
+
+  it('getTablePathForJsonDocument produces a typed path with the correct table segment', () => {
+    const pathBeforeRowIndex = ref('measurements');
+    const column = new CsvImportColumnMappingData(0, 'value', pathBeforeRowIndex);
+
+    const path = column.getTablePathForJsonDocument();
+
+    expect(path).toEqual(['measurements']);
+  });
+
+  it('getTablePathForJsonDocument reflects changes to the shared pathBeforeRowIndex ref', () => {
+    const pathBeforeRowIndex = ref('first');
+    const column = new CsvImportColumnMappingData(0, 'col', pathBeforeRowIndex);
+
+    pathBeforeRowIndex.value = 'updated';
+    const path = column.getTablePathForJsonDocument();
+
+    expect(path).toEqual(['updated']);
+  });
+
+  it('getPathForJsonDocument reflects changes to the pathAfterRowIndex string', () => {
+    const pathBeforeRowIndex = ref('root');
+    const column = new CsvImportColumnMappingData(0, 'col', pathBeforeRowIndex);
+
+    column.pathAfterRowIndex = 'custom_field';
+    const path = column.getPathForJsonDocument(0);
+
+    expect(path).toEqual(['root', 0, 'custom_field']);
+  });
+});
diff --git a/meta_configurator/src/components/toolbar/dialogs/csvimport/csvImportTypes.ts b/meta_configurator/src/components/toolbar/dialogs/csvimport/csvImportTypes.ts
index 5771c903a..fae9ccab9 100644
--- a/meta_configurator/src/components/toolbar/dialogs/csvimport/csvImportTypes.ts
+++ b/meta_configurator/src/components/toolbar/dialogs/csvimport/csvImportTypes.ts
@@ -1,4 +1,4 @@
-import {ref, type Ref} from 'vue';
+import {type Ref, unref} from 'vue';
 import {jsonPointerToPathTyped} from '@/utility/pathUtils';
 import type {Path} from '@/utility/path';
 import {stringToIdentifier} from '@/utility/stringToIdentifier';
@@ -6,21 +6,21 @@ import {stringToIdentifier} from '@/utility/stringToIdentifier';
 export class CsvImportColumnMappingData {
   constructor(public index: number, public name: string, pathBeforeRowIndex: Ref<string>) {
     this.pathBeforeRowIndex = pathBeforeRowIndex;
-    this.pathAfterRowIndex = ref(stringToIdentifier(this.name, false));
-    this.titleInSchema = ref(this.name);
+    this.pathAfterRowIndex = stringToIdentifier(this.name, false);
+    this.titleInSchema = this.name;
   }
 
   public pathBeforeRowIndex: Ref<string>;
-  public pathAfterRowIndex: Ref<string>;
-  public titleInSchema: Ref<string>;
+  public pathAfterRowIndex: string;
+  public titleInSchema: string;
 
   public getPathForJsonDocument(rowIndex: number): Path {
     return jsonPointerToPathTyped(
-      '/' + this.pathBeforeRowIndex + '/' + rowIndex + '/' + this.pathAfterRowIndex
+      '/' + unref(this.pathBeforeRowIndex) + '/' + rowIndex + '/' + this.pathAfterRowIndex
     );
   }
 
   public getTablePathForJsonDocument(): Path {
-    return jsonPointerToPathTyped('/' + this.pathBeforeRowIndex);
+    return jsonPointerToPathTyped('/' + unref(this.pathBeforeRowIndex));
   }
 }
diff --git a/meta_configurator/src/components/toolbar/dialogs/csvimport/delimiterSeparatorUtils.ts b/meta_configurator/src/components/toolbar/dialogs/csvimport/delimiterSeparatorUtils.ts
index 65b440815..2cc6c8f1d 100644
--- a/meta_configurator/src/components/toolbar/dialogs/csvimport/delimiterSeparatorUtils.ts
+++ b/meta_configurator/src/components/toolbar/dialogs/csvimport/delimiterSeparatorUtils.ts
@@ -17,7 +17,7 @@ function getMostUsedDelimiter(csv: string, delimiters: LabelledValue[]): Labelle
   const delimiterCount = delimiters.map(delimiter => {
     return csv.split(delimiter.value).length;
   });
-  return delimiters[delimiterCount.indexOf(Math.max(...delimiterCount))];
+  return delimiters[delimiterCount.indexOf(Math.max(...delimiterCount))] ?? delimiters[0]!;
 }
 
 // we check for the occurrence count of the separator, but only for separators that are surrounded by integers
@@ -29,7 +29,7 @@ function getMostUsedDecimalSeparator(
   const separatorCount = separators.map(separator => {
     return csv.split(generateFloatRegexFull(delimiterValue, separator.value)).length;
   });
-  return separators[separatorCount.indexOf(Math.max(...separatorCount))];
+  return separators[separatorCount.indexOf(Math.max(...separatorCount))] ?? separators[0]!;
 }
 
 export function computeMostUsedDelimiterAndDecimalSeparator(csv: string): {
@@ -44,7 +44,7 @@ export function computeMostUsedDelimiterAndDecimalSeparator(csv: string): {
   if (availableDecimalSeparators.length === 1) {
     return {
       delimiterSuggestion: delimiter,
-      decimalSeparatorSuggestion: availableDecimalSeparators[0],
+      decimalSeparatorSuggestion: availableDecimalSeparators[0]!,
     };
   }
 
diff --git a/meta_configurator/src/components/toolbar/dialogs/csvimport/importCsvUtils.ts b/meta_configurator/src/components/toolbar/dialogs/csvimport/importCsvUtils.ts
index 08f8bfe86..5d1c95306 100644
--- a/meta_configurator/src/components/toolbar/dialogs/csvimport/importCsvUtils.ts
+++ b/meta_configurator/src/components/toolbar/dialogs/csvimport/importCsvUtils.ts
@@ -1,4 +1,3 @@
-import {useFileDialog} from '@vueuse/core';
 import {readFileContentToStringRef} from '@/utility/readFileContent';
 import type {Ref} from 'vue';
 import {getDataForMode, getSchemaForMode} from '@/data/useDataLink';
@@ -18,26 +17,18 @@ import type {JsonSchemaType} from '@/schema/jsonSchemaType';
 import {identifyArraysInJson} from '@/utility/arrayPathUtils';
 import {stringToIdentifier} from '@/utility/stringToIdentifier';
 import {useErrorService} from '@/utility/errorServiceInstance';
+import {createLazySingleFileDialog} from '@/utility/fileDialogUtils';
 
-export function requestUploadFileToRef(resultString: Ref<string>, resultTableName: Ref<string>) {
-  const {open, onChange, reset} = useFileDialog({
-    // accept only json, schema.json, yaml, yml, xml and xsd files
-    accept: '.csv',
-    multiple: false,
-  });
+const csvFileDialog = createLazySingleFileDialog('.csv');
 
-  onChange((files: FileList | null) => {
-    if (files && files.length > 0) {
-      resultTableName.value = stringToIdentifier(files[0].name, true); // Get the name of the first file
+export function requestUploadFileToRef(resultString: Ref<string>, resultTableName: Ref<string>) {
+  csvFileDialog.openForSelection(files => {
+    const firstFile = files?.[0];
+    if (firstFile) {
+      resultTableName.value = stringToIdentifier(firstFile.name, true); // Get the name of the first file
       readFileContentToStringRef(files, resultString);
     }
-    reset(); // Reset the file dialog after selection
   });
-
-  // opening it with a small delay might fix the issue of the dialog opening but onChange never triggering
-  setTimeout(() => {
-    open();
-  }, 3);
 }
 
 export function inferSchemaForNewDataAndMergeIntoCurrentSchema(
@@ -149,7 +140,7 @@ export function detectPropertiesOfTableInJson(json: any, tablePath: Path): strin
   const table = _.get(json, pathToString(tablePath));
   if (Array.isArray(table)) {
     if (table.length > 0) {
-      return Object.keys(table[0]);
+      return Object.keys(table[0] ?? {});
     }
   }
   return [];
@@ -186,7 +177,7 @@ function countKeyMatches(
     arrayIndex++
   ) {
     const arrayElement = arrayData[arrayIndex];
-    const primaryKeyValue = arrayElement[foreignKeyAttribute];
+    const primaryKeyValue = arrayElement?.[foreignKeyAttribute];
     const matchingLookupRow = lookupValuesInCsv(lookupCsv, primaryKeyColumn, primaryKeyValue);
     if (matchingLookupRow) {
       result += 1;
diff --git a/meta_configurator/src/components/toolbar/dialogs/csvimport/writeCsvToData.ts b/meta_configurator/src/components/toolbar/dialogs/csvimport/writeCsvToData.ts
index 12a5b4b7f..eb4d3c14a 100644
--- a/meta_configurator/src/components/toolbar/dialogs/csvimport/writeCsvToData.ts
+++ b/meta_configurator/src/components/toolbar/dialogs/csvimport/writeCsvToData.ts
@@ -6,9 +6,13 @@ import {lookupValuesInCsv} from '@/components/toolbar/dialogs/csvimport/importCs
 
 export function writeCsvToData(csv: any[], columnMapping: CsvImportColumnMappingData[]) {
   const currentData = getDataForMode(SessionMode.DataEditor);
+  const firstColumn = columnMapping[0];
+  if (!firstColumn) {
+    return;
+  }
 
   let rowIndexOffset = 0;
-  const arrayPath = columnMapping[0].getTablePathForJsonDocument();
+  const arrayPath = firstColumn.getTablePathForJsonDocument();
   // if there already exists an array at the path, append the new data to it, by setting the rowIndexOffset
   const dataAtPath = currentData.dataAt(arrayPath);
   if (Array.isArray(dataAtPath)) {
@@ -34,9 +38,13 @@ export function expandCsvDataIntoTable(
   columnMapping: CsvImportColumnMappingData[]
 ) {
   const currentData = getDataForMode(SessionMode.DataEditor);
+  const firstColumn = columnMapping[0];
+  if (!firstColumn) {
+    return;
+  }
 
-  const arrayPath = columnMapping[0].getTablePathForJsonDocument();
-  const arrayData: any[] = currentData.dataAt(arrayPath);
+  const arrayPath = firstColumn.getTablePathForJsonDocument();
+  const arrayData: any[] = currentData.dataAt(arrayPath) ?? [];
   for (let arrayIndex = 0; arrayIndex < arrayData.length; arrayIndex++) {
     const arrayElement = arrayData[arrayIndex];
     const primaryKeyValue = arrayElement[foreignKeyAttribute];
diff --git a/meta_configurator/src/components/toolbar/dialogs/data-mapping/DataMappingDialog.vue b/meta_configurator/src/components/toolbar/dialogs/data-mapping/DataMappingDialog.vue
index 0953c8d04..20271b04a 100644
--- a/meta_configurator/src/components/toolbar/dialogs/data-mapping/DataMappingDialog.vue
+++ b/meta_configurator/src/components/toolbar/dialogs/data-mapping/DataMappingDialog.vue
@@ -40,9 +40,9 @@ const mappingServiceWarnings = [
   'The JSONata mapping service is very expressive flexible, but may generate invalid mappings for complex inputs, which have to manually be corrected.',
 ];
 
-const selectedMappingServiceType: Ref<string> = ref(mappingServiceTypes[0]);
+const selectedMappingServiceType: Ref<string> = ref(mappingServiceTypes[0]!);
 
-const mappingService: Ref<DataMappingService> = computed(() => {
+const mappingService = computed<DataMappingService>(() => {
   if (selectedMappingServiceType.value === 'Advanced (JSONata)') {
     return new DataMappingServiceJsonata();
   }
@@ -50,7 +50,7 @@ const mappingService: Ref<DataMappingService> = computed(() => {
   throw new Error('Invalid mapping service type');
 });
 
-const mappingServiceWarning: Ref<string> = computed(() => {
+const mappingServiceWarning = computed<string>(() => {
   const index = mappingServiceTypes.indexOf(selectedMappingServiceType.value);
   return mappingServiceWarnings[index] || '';
 });
diff --git a/meta_configurator/src/components/toolbar/dialogs/turtle-import/importTurtleUtils.ts b/meta_configurator/src/components/toolbar/dialogs/turtle-import/importTurtleUtils.ts
index 5633a9559..97b85d066 100644
--- a/meta_configurator/src/components/toolbar/dialogs/turtle-import/importTurtleUtils.ts
+++ b/meta_configurator/src/components/toolbar/dialogs/turtle-import/importTurtleUtils.ts
@@ -1,26 +1,17 @@
-import {useFileDialog} from '@vueuse/core';
 import {readFileContentToStringRef} from '@/utility/readFileContent';
 import {RdfMediaType} from '@/components/panels/rdf/rdfEnums';
 import {useSettings} from '@/settings/useSettings';
 import type {Ref} from 'vue';
 import * as $rdf from 'rdflib';
+import {createLazySingleFileDialog} from '@/utility/fileDialogUtils';
 
 const settings = useSettings();
+const turtleFileDialog = createLazySingleFileDialog('.ttl');
 
 export function requestUploadFileToRef(resultString: Ref<string>): void {
-  const {open, onChange, reset} = useFileDialog({
-    accept: '.ttl',
-    multiple: false,
+  turtleFileDialog.openForSelection(files => {
+    readFileContentToStringRef(files, resultString);
   });
-
-  onChange((files: FileList | null) => {
-    if (files && files.length > 0) {
-      readFileContentToStringRef(files, resultString);
-    }
-    reset();
-  });
-
-  setTimeout(open, 3);
 }
 
 /**
diff --git a/meta_configurator/src/components/toolbar/fetchExampleSchemas.ts b/meta_configurator/src/components/toolbar/fetchExampleSchemas.ts
deleted file mode 100644
index 773b1ed85..000000000
--- a/meta_configurator/src/components/toolbar/fetchExampleSchemas.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import {openClearDataEditorDialog} from '@/components/toolbar/clearFile';
-import {toastService} from '@/utility/toastService';
-import {useDataSource} from '@/data/dataSource';
-import {schemaCollection} from '@/packaged-schemas/schemaCollection';
-import {adaptComplexitySettingsToLoadedSchema} from '@/settings/settingsUpdater';
-import {getDataForMode} from '@/data/useDataLink';
-import {SessionMode} from '@/store/sessionMode';
-import {useErrorService} from '@/utility/errorServiceInstance';
-
-/**
- * Loads the example schema with the given key.
- * @param schemaKey The key of the example schema to load
- */
-export function loadExampleSchema(schemaKey: string): void {
-  try {
-    let selectedSchema: any = schemaCollection.find(schema => schema.key === schemaKey);
-    selectedSchema = structuredClone(selectedSchema);
-    const schemaName = selectedSchema.label || 'Unknown Schema';
-    useDataSource().userSchemaData.value = selectedSchema?.schema;
-    useDataSource().newSchemaWasFetched.value = true;
-    // this will adapt the meta schema settings to enable/disable multiple types, boolean schema support, etc.
-    const userSettings = getDataForMode(SessionMode.Settings).data.value;
-    adaptComplexitySettingsToLoadedSchema(userSettings, selectedSchema?.schema);
-
-    openClearDataEditorDialog();
-
-    const toast = toastService;
-    if (toast) {
-      toast.add({
-        severity: 'info',
-        summary: 'Info',
-        detail: `"${schemaName}" fetched successfully!`,
-        life: 3000,
-      });
-    }
-  } catch (error) {
-    useErrorService().onError(error);
-  }
-}
diff --git a/meta_configurator/src/components/toolbar/importFile.ts b/meta_configurator/src/components/toolbar/importFile.ts
index 5f3694838..80e8111ef 100644
--- a/meta_configurator/src/components/toolbar/importFile.ts
+++ b/meta_configurator/src/components/toolbar/importFile.ts
@@ -1,29 +1,22 @@
-import {useFileDialog} from '@vueuse/core';
 import {readFileContentForFunction} from '@/utility/readFileContent';
 import {getDataForMode} from '@/data/useDataLink';
 import {SessionMode} from '@/store/sessionMode';
 import type {ManagedData} from '@/data/managedData';
 import {findAvailableSchemaId} from '@/schema/schemaReadingUtils';
+import {createLazySingleFileDialog} from '@/utility/fileDialogUtils';
+
+const importSchemaFileDialog = createLazySingleFileDialog(
+  '.json, .yaml, .yml, .xml, .schema.json',
+  5
+);
 
 /**
  * Opens a file dialog to select a JSON schema to import.
  */
 export function openImportSchemaDialog(): void {
-  const {open, onChange, reset} = useFileDialog({
-    // accept only json, schema.json, yaml, yml, xml and xsd files
-    accept: '.json, .yaml, .yml, .xml, .schema.json',
-    multiple: false,
-  });
-
-  onChange((files: FileList | null) => {
+  importSchemaFileDialog.openForSelection(files => {
     readFileContentForFunction(files, importSchema);
-    reset(); // Reset the file dialog after selection
   });
-
-  // opening it with a small delay might fix the issue of the dialog opening but onChange never triggering
-  setTimeout(() => {
-    open();
-  }, 5);
 }
 
 function importSchema(importedSchema: any) {
diff --git a/meta_configurator/src/components/toolbar/menuItems.ts b/meta_configurator/src/components/toolbar/menuItems.ts
index afe998ac0..78dc5bd32 100644
--- a/meta_configurator/src/components/toolbar/menuItems.ts
+++ b/meta_configurator/src/components/toolbar/menuItems.ts
@@ -78,6 +78,7 @@ export class MenuItems {
       },
       {
         label: 'Import Data...',
+        key: 'import-data',
         icon: 'fa-solid fa-file-import',
         items: [
           {
diff --git a/meta_configurator/src/components/toolbar/resolveSchemaReferences.ts b/meta_configurator/src/components/toolbar/resolveSchemaReferences.ts
index 9563e9e51..96848a9a7 100644
--- a/meta_configurator/src/components/toolbar/resolveSchemaReferences.ts
+++ b/meta_configurator/src/components/toolbar/resolveSchemaReferences.ts
@@ -3,6 +3,7 @@ import {getDataForMode} from '@/data/useDataLink';
 import {SessionMode} from '@/store/sessionMode';
 import $RefParser from '@apidevtools/json-schema-ref-parser';
 import {useErrorService} from '@/utility/errorServiceInstance.ts';
+import type {TopLevelSchema} from '@/schema/jsonSchemaType';
 
 /**
  * Goes through the schema and resolves all references.
@@ -10,17 +11,22 @@ import {useErrorService} from '@/utility/errorServiceInstance.ts';
  */
 export async function resolveSchemaReferences(): Promise<void> {
   const managedSchemaData = getDataForMode(SessionMode.SchemaEditor);
-  const schemaData = managedSchemaData.data.value;
+  const schemaData = managedSchemaData.data.value as TopLevelSchema;
   try {
     // count definitions for info message
+    const schemaObject = schemaData as TopLevelSchema & {
+      $defs?: Record<string, unknown>;
+      definitions?: Record<string, unknown>;
+    };
     const definitionCount =
-      Object.keys(schemaData.$defs || {}).length + Object.keys(schemaData.definitions || {}).length;
+      Object.keys(schemaObject.$defs || {}).length +
+      Object.keys(schemaObject.definitions || {}).length;
 
     let resolvedSchema = await $RefParser.dereference(schemaData, {mutateInputSchema: false});
 
     // remove definitions, as they should not be needed anymore
-    delete resolvedSchema.$defs;
-    delete resolvedSchema.definitions;
+    delete (resolvedSchema as any).$defs;
+    delete (resolvedSchema as any).definitions;
 
     // serialize and deserialize the schema, in case of circular reference, this will fail. Good to catch early
     resolvedSchema = JSON.parse(JSON.stringify(resolvedSchema));
diff --git a/meta_configurator/src/components/toolbar/uploadFile.ts b/meta_configurator/src/components/toolbar/uploadFile.ts
index bd4f88bf4..2cce11c64 100644
--- a/meta_configurator/src/components/toolbar/uploadFile.ts
+++ b/meta_configurator/src/components/toolbar/uploadFile.ts
@@ -1,8 +1,10 @@
-import {useFileDialog} from '@vueuse/core';
 import {readFileContentToDataLink} from '@/utility/readFileContent';
 import {getDataForMode} from '@/data/useDataLink';
 import type {ManagedData} from '@/data/managedData';
 import {SessionMode} from '@/store/sessionMode';
+import {createLazySingleFileDialog} from '@/utility/fileDialogUtils';
+
+const uploadDataFileDialog = createLazySingleFileDialog('.json, .yaml, .yml, .xml, .schema.json');
 
 /**
  * Opens a file dialog to select a file to upload.
@@ -10,21 +12,9 @@ import {SessionMode} from '@/store/sessionMode';
  * @param resultDataLink The DataLink to which the file content should be written
  */
 export function openUploadFileDialog(resultDataLink: ManagedData): void {
-  const {open, onChange, reset} = useFileDialog({
-    // accept only json, schema.json, yaml, yml, xml and xsd files
-    accept: '.json, .yaml, .yml, .xml, .schema.json',
-    multiple: false,
-  });
-
-  onChange((files: FileList | null) => {
+  uploadDataFileDialog.openForSelection(files => {
     readFileContentToDataLink(files, resultDataLink);
-    reset(); // Reset the file dialog after selection
   });
-
-  // opening it with a small delay might fix the issue of the dialog opening but onChange never triggering
-  setTimeout(() => {
-    open();
-  }, 3);
 }
 
 /**
diff --git a/meta_configurator/src/data-mapping/dataMappingService.ts b/meta_configurator/src/data-mapping/dataMappingService.ts
index 14bf2a80b..528bdad54 100644
--- a/meta_configurator/src/data-mapping/dataMappingService.ts
+++ b/meta_configurator/src/data-mapping/dataMappingService.ts
@@ -1,5 +1,4 @@
 import type {TopLevelSchema} from '@/schema/jsonSchemaType';
-import type {Ref} from 'vue';
 
 export interface DataMappingService {
   sanitizeMappingConfig(config: string, input: any): string;
diff --git a/meta_configurator/src/data-mapping/jsonata/dataMappingServiceJsonata.ts b/meta_configurator/src/data-mapping/jsonata/dataMappingServiceJsonata.ts
index c10fea486..1282993bf 100644
--- a/meta_configurator/src/data-mapping/jsonata/dataMappingServiceJsonata.ts
+++ b/meta_configurator/src/data-mapping/jsonata/dataMappingServiceJsonata.ts
@@ -82,11 +82,12 @@ export class DataMappingServiceJsonata implements DataMappingService {
         message: 'Data mapping performed successfully.',
       };
     } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
       console.error('Error performing data mapping: ', e);
       return {
         resultData: {},
         success: false,
-        message: `Data mapping failed. Please check the mapping configuration. Use <a href="https://try.jsonata.org/" target="_blank">https://try.jsonata.org/</a> to validate and fix your JSONata expression. Reason: ${e.message}.`,
+        message: `Data mapping failed. Please check the mapping configuration. Use <a href="https://try.jsonata.org/" target="_blank">https://try.jsonata.org/</a> to validate and fix your JSONata expression. Reason: ${message}.`,
       };
     }
   }
@@ -155,11 +156,12 @@ export class DataMappingServiceJsonata implements DataMappingService {
     let column = position;
 
     for (let i = 0; i < lines.length; i++) {
-      if (column < lines[i].length) {
+      const line = lines[i]!;
+      if (column < line.length) {
         row = i;
         break;
       }
-      column -= lines[i].length + 1; // +1 for the newline character
+      column -= line.length + 1; // +1 for the newline character
     }
 
     return {row, column};
diff --git a/meta_configurator/src/dataformats/__tests__/formatRegistry.test.ts b/meta_configurator/src/dataformats/__tests__/formatRegistry.test.ts
index 0a4484ec6..95a5d8cea 100644
--- a/meta_configurator/src/dataformats/__tests__/formatRegistry.test.ts
+++ b/meta_configurator/src/dataformats/__tests__/formatRegistry.test.ts
@@ -8,7 +8,7 @@ import {PathIndexLinkJson} from '../pathIndexLinkJson';
 import {PathIndexLinkYaml} from '../pathIndexLinkYaml';
 
 function setDataFormat(format: string | undefined) {
-  useDataSource().settingsData.value.dataFormat = format;
+  useDataSource().settingsData.value.dataFormat = format as any;
   triggerRef(useDataSource().settingsData);
 }
 
diff --git a/meta_configurator/src/dataformats/pathIndexLinkYaml.ts b/meta_configurator/src/dataformats/pathIndexLinkYaml.ts
index 10da2bb64..7abac4464 100644
--- a/meta_configurator/src/dataformats/pathIndexLinkYaml.ts
+++ b/meta_configurator/src/dataformats/pathIndexLinkYaml.ts
@@ -45,8 +45,8 @@ export class PathIndexLinkYaml implements PathIndexLink {
 
     visit(document, {
       Pair(_, pair) {
-        const pairKey: Node | null = pair.key;
-        const pairValue: Node | null = pair.value;
+        const pairKey = pair.key as Node | null;
+        const pairValue = pair.value as Node | null;
         if (pairKey && pairValue) {
           if (
             (pairKey.range &&
@@ -63,7 +63,7 @@ export class PathIndexLinkYaml implements PathIndexLink {
       },
       Seq: (key, seq: YAMLSeq) => {
         seq.items.forEach((item, index) => {
-          const itemNode: Node = item;
+          const itemNode = item as Node;
           if (
             itemNode &&
             itemNode.range &&
diff --git a/meta_configurator/src/rml-mapping/standard/rmlMappingServiceStandard.ts b/meta_configurator/src/rml-mapping/standard/rmlMappingServiceStandard.ts
index e2d80a8ae..8d73f6dcd 100644
--- a/meta_configurator/src/rml-mapping/standard/rmlMappingServiceStandard.ts
+++ b/meta_configurator/src/rml-mapping/standard/rmlMappingServiceStandard.ts
@@ -60,18 +60,14 @@ function isErrorWithLine(error: unknown): error is {message: string; context: {l
 async function extractPrefixes(config: string): Promise<Record<string, string>> {
   let prefixes: Record<string, string> = {};
 
-  await new N3Parser().parse(
-    config,
-    (_error: any, _quad: any, prefixMap: Record<string, string>) => {
-      if (prefixMap) {
-        prefixes = Object.fromEntries(
-          Object.entries(prefixMap).filter(
-            ([name, iri]) => !IGNORED_PREFIX_NAMES.has(name) && !IGNORED_IRIS.has(iri)
-          )
-        );
+  await new N3Parser().parse(config, {
+    onQuad: () => {},
+    onPrefix: (prefix, iri) => {
+      if (!IGNORED_PREFIX_NAMES.has(prefix) && !IGNORED_IRIS.has(iri.value)) {
+        prefixes[prefix] = iri.value;
       }
-    }
-  );
+    },
+  });
 
   return prefixes;
 }
diff --git a/meta_configurator/src/router/router.ts b/meta_configurator/src/router/router.ts
index 10cb305d6..1d41d86e9 100644
--- a/meta_configurator/src/router/router.ts
+++ b/meta_configurator/src/router/router.ts
@@ -1,4 +1,4 @@
-import {createRouter, createWebHashHistory, createWebHistory} from 'vue-router';
+import {createRouter, createWebHistory} from 'vue-router';
 import {useSessionStore} from '@/store/sessionStore';
 import {SessionMode} from '@/store/sessionMode';
 import SchemaEditorView from '@/views/SchemaEditorView.vue';
diff --git a/meta_configurator/src/schema/__tests__/cleanupSchemaByType.test.ts b/meta_configurator/src/schema/__tests__/cleanupSchemaByType.test.ts
index 115ec9410..a36b66cd7 100644
--- a/meta_configurator/src/schema/__tests__/cleanupSchemaByType.test.ts
+++ b/meta_configurator/src/schema/__tests__/cleanupSchemaByType.test.ts
@@ -1,4 +1,4 @@
-import {describe, expect, it, vi} from 'vitest';
+import {describe, expect, it} from 'vitest';
 import {type JsonSchemaType} from '../jsonSchemaType';
 import {cleanupSchemaByType} from '@/schema/cleanupSchemaByType.ts';
 
diff --git a/meta_configurator/src/schema/__tests__/jsonSchemaVisitor.test.ts b/meta_configurator/src/schema/__tests__/jsonSchemaVisitor.test.ts
index be775e5fb..862b49da9 100644
--- a/meta_configurator/src/schema/__tests__/jsonSchemaVisitor.test.ts
+++ b/meta_configurator/src/schema/__tests__/jsonSchemaVisitor.test.ts
@@ -66,17 +66,21 @@ class RecordingVisitor extends JsonSchemaVisitor {
   }
 }
 
+function asSchema(schema: JsonSchemaType): JsonSchemaType {
+  return schema;
+}
+
 describe('JsonSchemaVisitor', () => {
   it('visits a simple object schema', () => {
     const visitor = new RecordingVisitor();
-    const schema = {type: 'object', title: 'Root'};
+    const schema = asSchema({type: 'object', title: 'Root'});
     visitor.traverse(schema);
 
     expect(visitor.schemas).toHaveLength(1);
-    expect(visitor.schemas[0].schema).toBe(schema);
-    expect(visitor.schemas[0].ctx.depth).toBe(0);
-    expect(visitor.schemas[0].ctx.path).toEqual([]);
-    expect(visitor.schemas[0].ctx.parentKind).toBeNull();
+    expect(visitor.schemas[0]!.schema).toBe(schema);
+    expect(visitor.schemas[0]!.ctx.depth).toBe(0);
+    expect(visitor.schemas[0]!.ctx.path).toEqual([]);
+    expect(visitor.schemas[0]!.ctx.parentKind).toBeNull();
   });
 
   it('visits a boolean schema', () => {
@@ -84,42 +88,42 @@ describe('JsonSchemaVisitor', () => {
     visitor.traverse(true);
 
     expect(visitor.booleans).toHaveLength(1);
-    expect(visitor.booleans[0].value).toBe(true);
+    expect(visitor.booleans[0]!.value).toBe(true);
   });
 
   it('visits properties with correct context', () => {
     const visitor = new RecordingVisitor();
-    const schema = {
+    const schema = asSchema({
       type: 'object',
       properties: {
         name: {type: 'string'},
         age: {type: 'number'},
       },
-    };
+    });
     visitor.traverse(schema);
 
     expect(visitor.properties).toHaveLength(2);
-    expect(visitor.properties[0].name).toBe('name');
-    expect(visitor.properties[0].ctx.path).toEqual(['properties', 'name']);
-    expect(visitor.properties[0].ctx.parentKind).toBe('property');
-    expect(visitor.properties[1].name).toBe('age');
-    expect(visitor.properties[1].ctx.path).toEqual(['properties', 'age']);
+    expect(visitor.properties[0]!.name).toBe('name');
+    expect(visitor.properties[0]!.ctx.path).toEqual(['properties', 'name']);
+    expect(visitor.properties[0]!.ctx.parentKind).toBe('property');
+    expect(visitor.properties[1]!.name).toBe('age');
+    expect(visitor.properties[1]!.ctx.path).toEqual(['properties', 'age']);
   });
 
   it('visits patternProperties', () => {
     const visitor = new RecordingVisitor();
-    const schema = {
+    const schema = asSchema({
       type: 'object',
       patternProperties: {
         '^S_': {type: 'string'},
       },
-    };
+    });
     visitor.traverse(schema);
 
     expect(visitor.patternProperties).toHaveLength(1);
-    expect(visitor.patternProperties[0].pattern).toBe('^S_');
-    expect(visitor.patternProperties[0].ctx.parentKind).toBe('pattern');
-    expect(visitor.patternProperties[0].ctx.path).toEqual(['patternProperties', '^S_']);
+    expect(visitor.patternProperties[0]!.pattern).toBe('^S_');
+    expect(visitor.patternProperties[0]!.ctx.parentKind).toBe('pattern');
+    expect(visitor.patternProperties[0]!.ctx.path).toEqual(['patternProperties', '^S_']);
   });
 
   it('visits $ref', () => {
@@ -127,16 +131,16 @@ describe('JsonSchemaVisitor', () => {
     visitor.traverse({$ref: '#/$defs/foo'});
 
     expect(visitor.refs).toHaveLength(1);
-    expect(visitor.refs[0].ref).toBe('#/$defs/foo');
+    expect(visitor.refs[0]!.ref).toBe('#/$defs/foo');
   });
 
   it('visits allOf, anyOf, oneOf', () => {
     const visitor = new RecordingVisitor();
-    const schema = {
+    const schema = asSchema({
       allOf: [{type: 'object'}],
       anyOf: [{type: 'string'}, {type: 'number'}],
       oneOf: [{type: 'boolean'}],
-    };
+    });
     visitor.traverse(schema);
 
     const keywords = visitor.compositionals.map(c => c.keyword);
@@ -150,7 +154,7 @@ describe('JsonSchemaVisitor', () => {
     visitor.traverse({not: {type: 'string'}});
 
     expect(visitor.compositionals).toHaveLength(1);
-    expect(visitor.compositionals[0].keyword).toBe('not');
+    expect(visitor.compositionals[0]!.keyword).toBe('not');
   });
 
   it('visits if/then/else', () => {
@@ -165,7 +169,7 @@ describe('JsonSchemaVisitor', () => {
     expect(conditionalKeywords).toContain('if');
     expect(conditionalKeywords).toContain('then');
     expect(conditionalKeywords).toContain('else');
-    expect(visitor.conditionals[2].schema).toBe(true);
+    expect(visitor.conditionals[2]!.schema).toBe(true);
   });
 
   it('visits $defs', () => {
@@ -181,8 +185,8 @@ describe('JsonSchemaVisitor', () => {
     const names = visitor.definitions.map(d => d.name);
     expect(names).toContain('foo');
     expect(names).toContain('bar');
-    expect(visitor.definitions[0].ctx.parentKind).toBe('definition');
-    expect(visitor.definitions[0].ctx.path).toEqual(['$defs', 'foo']);
+    expect(visitor.definitions[0]!.ctx.parentKind).toBe('definition');
+    expect(visitor.definitions[0]!.ctx.path).toEqual(['$defs', 'foo']);
   });
 
   it('visits legacy definitions keyword', () => {
@@ -190,8 +194,8 @@ describe('JsonSchemaVisitor', () => {
     visitor.traverse({definitions: {myDef: {type: 'object'}}});
 
     expect(visitor.definitions).toHaveLength(1);
-    expect(visitor.definitions[0].name).toBe('myDef');
-    expect(visitor.definitions[0].ctx.path).toEqual(['definitions', 'myDef']);
+    expect(visitor.definitions[0]!.name).toBe('myDef');
+    expect(visitor.definitions[0]!.ctx.path).toEqual(['definitions', 'myDef']);
   });
 
   it('visits items as single schema', () => {
@@ -199,8 +203,8 @@ describe('JsonSchemaVisitor', () => {
     visitor.traverse({type: 'array', items: {type: 'string'}});
 
     expect(visitor.subSchemaKeywords).toHaveLength(1);
-    expect(visitor.subSchemaKeywords[0].keyword).toBe('items');
-    expect(visitor.subSchemaKeywords[0].ctx.path).toEqual(['items']);
+    expect(visitor.subSchemaKeywords[0]!.keyword).toBe('items');
+    expect(visitor.subSchemaKeywords[0]!.ctx.path).toEqual(['items']);
   });
 
   it('visits items as array (tuple)', () => {
@@ -208,8 +212,8 @@ describe('JsonSchemaVisitor', () => {
     visitor.traverse({type: 'array', items: [{type: 'string'}, {type: 'number'}]});
 
     expect(visitor.subSchemaKeywords).toHaveLength(2);
-    expect(visitor.subSchemaKeywords[0].ctx.path).toEqual(['items', 0]);
-    expect(visitor.subSchemaKeywords[1].ctx.path).toEqual(['items', 1]);
+    expect(visitor.subSchemaKeywords[0]!.ctx.path).toEqual(['items', 0]);
+    expect(visitor.subSchemaKeywords[1]!.ctx.path).toEqual(['items', 1]);
   });
 
   it('visits additionalProperties', () => {
@@ -284,8 +288,8 @@ describe('JsonSchemaVisitor', () => {
     });
 
     expect(visitor.definitions).toHaveLength(1);
-    expect(visitor.definitions[0].name).toBe('credit_card');
-    expect(visitor.definitions[0].ctx.path).toEqual(['dependentSchemas', 'credit_card']);
+    expect(visitor.definitions[0]!.name).toBe('credit_card');
+    expect(visitor.definitions[0]!.ctx.path).toEqual(['dependentSchemas', 'credit_card']);
   });
 
   it('skips array-valued dependencies, visits schema-valued ones', () => {
@@ -298,19 +302,19 @@ describe('JsonSchemaVisitor', () => {
     } as any);
 
     expect(visitor.definitions).toHaveLength(1);
-    expect(visitor.definitions[0].name).toBe('address');
+    expect(visitor.definitions[0]!.name).toBe('address');
   });
 
   it('visits $dynamicRef and $recursiveRef', () => {
     const visitor = new RecordingVisitor();
     visitor.traverse({$dynamicRef: '#myAnchor'} as any);
     expect(visitor.refs).toHaveLength(1);
-    expect(visitor.refs[0].ref).toBe('#myAnchor');
+    expect(visitor.refs[0]!.ref).toBe('#myAnchor');
 
     const visitor2 = new RecordingVisitor();
     visitor2.traverse({$recursiveRef: '#'} as any);
     expect(visitor2.refs).toHaveLength(1);
-    expect(visitor2.refs[0].ref).toBe('#');
+    expect(visitor2.refs[0]!.ref).toBe('#');
   });
 
   it('handles prefixItems', () => {
@@ -319,7 +323,7 @@ describe('JsonSchemaVisitor', () => {
 
     const prefixItemKeywords = visitor.subSchemaKeywords.filter(k => k.keyword === 'prefixItems');
     expect(prefixItemKeywords).toHaveLength(2);
-    expect(prefixItemKeywords[0].ctx.path).toEqual(['prefixItems', 0]);
-    expect(prefixItemKeywords[1].ctx.path).toEqual(['prefixItems', 1]);
+    expect(prefixItemKeywords[0]!.ctx.path).toEqual(['prefixItems', 0]);
+    expect(prefixItemKeywords[1]!.ctx.path).toEqual(['prefixItems', 1]);
   });
 });
diff --git a/meta_configurator/src/schema/__tests__/metaSchemaBuilder.test.ts b/meta_configurator/src/schema/__tests__/metaSchemaBuilder.test.ts
index f1010107e..eb7a40c7c 100644
--- a/meta_configurator/src/schema/__tests__/metaSchemaBuilder.test.ts
+++ b/meta_configurator/src/schema/__tests__/metaSchemaBuilder.test.ts
@@ -3,7 +3,6 @@ import {buildMetaSchema} from '@/schema/metaSchemaBuilder';
 import {ValidationService} from '@/schema/validationService';
 import {SETTINGS_DATA_DEFAULT} from '@/settings/defaultSettingsData';
 import type {SettingsInterfaceMetaSchema} from '@/settings/settingsTypes';
-import type {TopLevelSchema} from '@/schema/jsonSchemaType';
 
 function buildSettings(overrides: Partial<SettingsInterfaceMetaSchema> = {}) {
   return {
@@ -14,7 +13,7 @@ function buildSettings(overrides: Partial<SettingsInterfaceMetaSchema> = {}) {
 
 function validateSchemaCandidate(
   settings: Partial<SettingsInterfaceMetaSchema>,
-  schemaCandidate: TopLevelSchema
+  schemaCandidate: any
 ) {
   const metaSchema = buildMetaSchema(buildSettings(settings));
   const validationService = new ValidationService(metaSchema);
@@ -24,7 +23,15 @@ function validateSchemaCandidate(
 describe('metaSchemaBuilder', () => {
   describe('type validation with allowMultipleTypes disabled', () => {
     it('accepts all individual simple types', () => {
-      const simpleTypes = ['array', 'boolean', 'integer', 'null', 'number', 'object', 'string'];
+      const simpleTypes = [
+        'array',
+        'boolean',
+        'integer',
+        'null',
+        'number',
+        'object',
+        'string',
+      ] as const;
 
       for (const type of simpleTypes) {
         const result = validateSchemaCandidate(
@@ -41,7 +48,7 @@ describe('metaSchemaBuilder', () => {
     });
 
     it('accepts nullable unions with exactly one non-null type', () => {
-      const nullableTypes = ['array', 'boolean', 'integer', 'number', 'object', 'string'];
+      const nullableTypes = ['array', 'boolean', 'integer', 'number', 'object', 'string'] as const;
 
       for (const type of nullableTypes) {
         const schemaCandidate =
@@ -93,10 +100,7 @@ describe('metaSchemaBuilder', () => {
     });
 
     it('still rejects empty type arrays', () => {
-      const result = validateSchemaCandidate(
-        {allowMultipleTypes: false},
-        {type: [] as unknown as TopLevelSchema['type']}
-      );
+      const result = validateSchemaCandidate({allowMultipleTypes: false}, {type: []});
 
       expect(result.errors.length).toBeGreaterThan(0);
     });
diff --git a/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorArrays.test.ts b/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorArrays.test.ts
index 17ee72e49..6749bb3f4 100644
--- a/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorArrays.test.ts
+++ b/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorArrays.test.ts
@@ -124,47 +124,53 @@ describe('test schema graph constructor with objects and attributes, without adv
     rootNode.attributes = generateObjectAttributes(rootNode.absolutePath, rootNode.schema, defs);
     expect(rootNode.attributes.length).toEqual(6);
 
-    expect(rootNode.attributes[0].name).toEqual('propertyArrayToSimple');
-    expect(rootNode.attributes[0].title).toEqual(undefined);
-    expect(rootNode.attributes[0].absolutePath).toEqual(['properties', 'propertyArrayToSimple']);
-    expect(rootNode.attributes[0].deprecated).toBeFalsy();
-    expect(rootNode.attributes[0].required).toBeFalsy();
-
-    expect(rootNode.attributes[1].name).toEqual('propertyArrayToComplex');
-    expect(rootNode.attributes[1].title).toEqual(undefined);
-    expect(rootNode.attributes[1].absolutePath).toEqual(['properties', 'propertyArrayToComplex']);
-    expect(rootNode.attributes[1].deprecated).toBeFalsy();
-    expect(rootNode.attributes[1].required).toBeFalsy();
-
-    expect(rootNode.attributes[2].name).toEqual('propertyArrayToRefSimple');
-    expect(rootNode.attributes[2].title).toEqual(undefined);
-    expect(rootNode.attributes[2].absolutePath).toEqual(['properties', 'propertyArrayToRefSimple']);
-    expect(rootNode.attributes[2].deprecated).toBeFalsy();
-    expect(rootNode.attributes[2].required).toBeFalsy();
-
-    expect(rootNode.attributes[3].name).toEqual('propertyArrayToRefComplexWithTitle');
-    expect(rootNode.attributes[3].title).toEqual(undefined);
-    expect(rootNode.attributes[3].absolutePath).toEqual([
+    expect(rootNode.attributes[0]!.name).toEqual('propertyArrayToSimple');
+    expect(rootNode.attributes[0]!.title).toEqual(undefined);
+    expect(rootNode.attributes[0]!.absolutePath).toEqual(['properties', 'propertyArrayToSimple']);
+    expect(rootNode.attributes[0]!.deprecated).toBeFalsy();
+    expect(rootNode.attributes[0]!.required).toBeFalsy();
+
+    expect(rootNode.attributes[1]!.name).toEqual('propertyArrayToComplex');
+    expect(rootNode.attributes[1]!.title).toEqual(undefined);
+    expect(rootNode.attributes[1]!.absolutePath).toEqual(['properties', 'propertyArrayToComplex']);
+    expect(rootNode.attributes[1]!.deprecated).toBeFalsy();
+    expect(rootNode.attributes[1]!.required).toBeFalsy();
+
+    expect(rootNode.attributes[2]!.name).toEqual('propertyArrayToRefSimple');
+    expect(rootNode.attributes[2]!.title).toEqual(undefined);
+    expect(rootNode.attributes[2]!.absolutePath).toEqual([
+      'properties',
+      'propertyArrayToRefSimple',
+    ]);
+    expect(rootNode.attributes[2]!.deprecated).toBeFalsy();
+    expect(rootNode.attributes[2]!.required).toBeFalsy();
+
+    expect(rootNode.attributes[3]!.name).toEqual('propertyArrayToRefComplexWithTitle');
+    expect(rootNode.attributes[3]!.title).toEqual(undefined);
+    expect(rootNode.attributes[3]!.absolutePath).toEqual([
       'properties',
       'propertyArrayToRefComplexWithTitle',
     ]);
-    expect(rootNode.attributes[3].deprecated).toBeFalsy();
-    expect(rootNode.attributes[3].required).toBeFalsy();
-
-    expect(rootNode.attributes[4].name).toEqual('propertyRefToArraySimple');
-    expect(rootNode.attributes[4].title).toEqual(undefined);
-    expect(rootNode.attributes[4].absolutePath).toEqual(['properties', 'propertyRefToArraySimple']);
-    expect(rootNode.attributes[4].deprecated).toBeFalsy();
-    expect(rootNode.attributes[4].required).toBeFalsy();
-
-    expect(rootNode.attributes[5].name).toEqual('propertyRefToArrayComplex');
-    expect(rootNode.attributes[5].title).toEqual(undefined);
-    expect(rootNode.attributes[5].absolutePath).toEqual([
+    expect(rootNode.attributes[3]!.deprecated).toBeFalsy();
+    expect(rootNode.attributes[3]!.required).toBeFalsy();
+
+    expect(rootNode.attributes[4]!.name).toEqual('propertyRefToArraySimple');
+    expect(rootNode.attributes[4]!.title).toEqual(undefined);
+    expect(rootNode.attributes[4]!.absolutePath).toEqual([
+      'properties',
+      'propertyRefToArraySimple',
+    ]);
+    expect(rootNode.attributes[4]!.deprecated).toBeFalsy();
+    expect(rootNode.attributes[4]!.required).toBeFalsy();
+
+    expect(rootNode.attributes[5]!.name).toEqual('propertyRefToArrayComplex');
+    expect(rootNode.attributes[5]!.title).toEqual(undefined);
+    expect(rootNode.attributes[5]!.absolutePath).toEqual([
       'properties',
       'propertyRefToArrayComplex',
     ]);
-    expect(rootNode.attributes[5].deprecated).toBeFalsy();
-    expect(rootNode.attributes[5].required).toBeFalsy();
+    expect(rootNode.attributes[5]!.deprecated).toBeFalsy();
+    expect(rootNode.attributes[5]!.required).toBeFalsy();
   });
 
   it('generate attribute type description', () => {
@@ -174,27 +180,27 @@ describe('test schema graph constructor with objects and attributes, without adv
 
     const attrPropArraySimple = rootNode.attributes[0];
     // array of booleans
-    expect(attrPropArraySimple.typeDescription).toEqual('boolean[]');
+    expect(attrPropArraySimple!.typeDescription).toEqual('boolean[]');
 
     const attrPropArrayComplex = rootNode.attributes[1];
     // array to inlined object.
-    expect(attrPropArrayComplex.typeDescription).toEqual('propertyArrayToComplex entry[]');
+    expect(attrPropArrayComplex!.typeDescription).toEqual('propertyArrayToComplex entry[]');
 
     const attrPropArrayRefSimple = rootNode.attributes[2];
     // array to ref of simple type
-    expect(attrPropArrayRefSimple.typeDescription).toEqual('string[]');
+    expect(attrPropArrayRefSimple!.typeDescription).toEqual('string[]');
 
     const attrPropArrayRefComplexWithTitle = rootNode.attributes[3];
     // array to ref of complex type
-    expect(attrPropArrayRefComplexWithTitle.typeDescription).toEqual('PersonTitle[]');
+    expect(attrPropArrayRefComplexWithTitle!.typeDescription).toEqual('PersonTitle[]');
 
     const attrPropRefToArraySimple = rootNode.attributes[4];
     // reference to array of booleans
-    expect(attrPropRefToArraySimple.typeDescription).toEqual('arrayProperty');
+    expect(attrPropRefToArraySimple!.typeDescription).toEqual('arrayProperty');
 
     const attrPropRefToArrayComplex = rootNode.attributes[5];
     // reference to array of objects. We take the name of the object as the type description
-    expect(attrPropRefToArrayComplex.typeDescription).toEqual('arrayObjectProperty');
+    expect(attrPropRefToArrayComplex!.typeDescription).toEqual('arrayObjectProperty');
   });
 
   it('generate object fallback display name', () => {
@@ -310,26 +316,26 @@ describe('test schema graph constructor with objects and attributes, without adv
     }
 
     // for this array, because the object is inlined, the edge is to the inlined object
-    expect(graph.edges[0].end.absolutePath).toEqual([
+    expect(graph.edges[0]!.end.absolutePath).toEqual([
       'properties',
       'propertyArrayToComplex',
       'items',
     ]);
-    expect(graph.edges[0].edgeType).toEqual(EdgeType.ATTRIBUTE);
-    expect(graph.edges[0].isArray).toEqual(true);
-    expect(graph.edges[0].label).toEqual('propertyArrayToComplex');
+    expect(graph.edges[0]!.edgeType).toEqual(EdgeType.ATTRIBUTE);
+    expect(graph.edges[0]!.isArray).toEqual(true);
+    expect(graph.edges[0]!.label).toEqual('propertyArrayToComplex');
 
     // for this array, because the object is not inlined, the edge is to the object node
-    expect(graph.edges[1].end.absolutePath).toEqual(['$defs', 'person']);
-    expect(graph.edges[1].edgeType).toEqual(EdgeType.ATTRIBUTE);
-    expect(graph.edges[1].isArray).toEqual(true);
-    expect(graph.edges[1].label).toEqual('propertyArrayToRefComplexWithTitle');
+    expect(graph.edges[1]!.end.absolutePath).toEqual(['$defs', 'person']);
+    expect(graph.edges[1]!.edgeType).toEqual(EdgeType.ATTRIBUTE);
+    expect(graph.edges[1]!.isArray).toEqual(true);
+    expect(graph.edges[1]!.label).toEqual('propertyArrayToRefComplexWithTitle');
 
     // this is a very tricky one: it needs resolving of the reference to the array and then the object behind the array
-    expect(graph.edges[2].end.absolutePath).toEqual(['$defs', 'arrayObjectProperty', 'items']);
-    expect(graph.edges[2].edgeType).toEqual(EdgeType.ATTRIBUTE);
-    expect(graph.edges[2].isArray).toEqual(true);
-    expect(graph.edges[2].label).toEqual('propertyRefToArrayComplex');
+    expect(graph.edges[2]!.end.absolutePath).toEqual(['$defs', 'arrayObjectProperty', 'items']);
+    expect(graph.edges[2]!.edgeType).toEqual(EdgeType.ATTRIBUTE);
+    expect(graph.edges[2]!.isArray).toEqual(true);
+    expect(graph.edges[2]!.label).toEqual('propertyRefToArrayComplex');
 
     graph.edges = [];
     const propArrayComplexItem = defs.get('properties.propertyArrayToComplex.items')!;
diff --git a/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorBasicFeatures.test.ts b/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorBasicFeatures.test.ts
index 2fe3424c3..a2174c2fe 100644
--- a/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorBasicFeatures.test.ts
+++ b/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorBasicFeatures.test.ts
@@ -17,8 +17,7 @@ vi.mock('@/dataformats/formatRegistry', () => ({
 }));
 
 describe('test schema graph constructor with objects and attributes, without advanced keywords such as oneOf', () => {
-  let currentPath: Path;
-  let schema: TopLevelSchema = {
+  const schema: TopLevelSchema = {
     type: 'object',
     required: ['propertyObject'],
     $defs: {
@@ -88,44 +87,44 @@ describe('test schema graph constructor with objects and attributes, without adv
     expect(rootNode).toBeDefined();
     rootNode.attributes = generateObjectAttributes(rootNode.absolutePath, rootNode.schema, defs);
     expect(rootNode.attributes.length).toEqual(6);
-    expect(rootNode.attributes[0].name).toEqual('propertySimple');
-    expect(rootNode.attributes[0].title).toEqual(undefined);
-    expect(rootNode.attributes[0].absolutePath).toEqual(['properties', 'propertySimple']);
-    expect(rootNode.attributes[0].deprecated).toBeTruthy();
-    expect(rootNode.attributes[0].required).toBeFalsy();
-
-    expect(rootNode.attributes[1].name).toEqual('propertyObject');
-    expect(rootNode.attributes[1].title).toEqual(undefined);
-    expect(rootNode.attributes[1].absolutePath).toEqual(['properties', 'propertyObject']);
-    expect(rootNode.attributes[1].deprecated).toBeFalsy();
-    expect(rootNode.attributes[1].required).toBeTruthy();
-
-    expect(rootNode.attributes[2].name).toEqual('propertyObjectWithTitle');
-    expect(rootNode.attributes[2].title).toEqual(undefined);
-    expect(rootNode.attributes[2].absolutePath).toEqual(['properties', 'propertyObjectWithTitle']);
-    expect(rootNode.attributes[2].deprecated).toBeFalsy();
-    expect(rootNode.attributes[2].required).toBeFalsy();
-
-    expect(rootNode.attributes[3].name).toEqual('propertyRefToSimple');
-    expect(rootNode.attributes[3].title).toEqual(undefined);
-    expect(rootNode.attributes[3].absolutePath).toEqual(['properties', 'propertyRefToSimple']);
-    expect(rootNode.attributes[3].deprecated).toBeFalsy();
-    expect(rootNode.attributes[3].required).toBeFalsy();
-
-    expect(rootNode.attributes[4].name).toEqual('propertyRefToComplex');
-    expect(rootNode.attributes[4].title).toEqual(undefined);
-    expect(rootNode.attributes[4].absolutePath).toEqual(['properties', 'propertyRefToComplex']);
-    expect(rootNode.attributes[4].deprecated).toBeFalsy();
-    expect(rootNode.attributes[4].required).toBeFalsy();
-
-    expect(rootNode.attributes[5].name).toEqual('propertyRefToNestedObject');
-    expect(rootNode.attributes[5].title).toEqual(undefined);
-    expect(rootNode.attributes[5].absolutePath).toEqual([
+    expect(rootNode.attributes[0]!.name).toEqual('propertySimple');
+    expect(rootNode.attributes[0]!.title).toEqual(undefined);
+    expect(rootNode.attributes[0]!.absolutePath).toEqual(['properties', 'propertySimple']);
+    expect(rootNode.attributes[0]!.deprecated).toBeTruthy();
+    expect(rootNode.attributes[0]!.required).toBeFalsy();
+
+    expect(rootNode.attributes[1]!.name).toEqual('propertyObject');
+    expect(rootNode.attributes[1]!.title).toEqual(undefined);
+    expect(rootNode.attributes[1]!.absolutePath).toEqual(['properties', 'propertyObject']);
+    expect(rootNode.attributes[1]!.deprecated).toBeFalsy();
+    expect(rootNode.attributes[1]!.required).toBeTruthy();
+
+    expect(rootNode.attributes[2]!.name).toEqual('propertyObjectWithTitle');
+    expect(rootNode.attributes[2]!.title).toEqual(undefined);
+    expect(rootNode.attributes[2]!.absolutePath).toEqual(['properties', 'propertyObjectWithTitle']);
+    expect(rootNode.attributes[2]!.deprecated).toBeFalsy();
+    expect(rootNode.attributes[2]!.required).toBeFalsy();
+
+    expect(rootNode.attributes[3]!.name).toEqual('propertyRefToSimple');
+    expect(rootNode.attributes[3]!.title).toEqual(undefined);
+    expect(rootNode.attributes[3]!.absolutePath).toEqual(['properties', 'propertyRefToSimple']);
+    expect(rootNode.attributes[3]!.deprecated).toBeFalsy();
+    expect(rootNode.attributes[3]!.required).toBeFalsy();
+
+    expect(rootNode.attributes[4]!.name).toEqual('propertyRefToComplex');
+    expect(rootNode.attributes[4]!.title).toEqual(undefined);
+    expect(rootNode.attributes[4]!.absolutePath).toEqual(['properties', 'propertyRefToComplex']);
+    expect(rootNode.attributes[4]!.deprecated).toBeFalsy();
+    expect(rootNode.attributes[4]!.required).toBeFalsy();
+
+    expect(rootNode.attributes[5]!.name).toEqual('propertyRefToNestedObject');
+    expect(rootNode.attributes[5]!.title).toEqual(undefined);
+    expect(rootNode.attributes[5]!.absolutePath).toEqual([
       'properties',
       'propertyRefToNestedObject',
     ]);
-    expect(rootNode.attributes[5].deprecated).toBeFalsy();
-    expect(rootNode.attributes[5].required).toBeFalsy();
+    expect(rootNode.attributes[5]!.deprecated).toBeFalsy();
+    expect(rootNode.attributes[5]!.required).toBeFalsy();
   });
 
   it('generate attribute type description', () => {
@@ -134,25 +133,25 @@ describe('test schema graph constructor with objects and attributes, without adv
     rootNode.attributes = generateObjectAttributes(rootNode.absolutePath, rootNode.schema, defs);
 
     const attrPropSimple = rootNode.attributes[0];
-    expect(attrPropSimple.typeDescription).toEqual('string');
+    expect(attrPropSimple!.typeDescription).toEqual('string');
 
     const attrPropComplex = rootNode.attributes[1];
-    expect(attrPropComplex.typeDescription).toEqual('propertyObject');
+    expect(attrPropComplex!.typeDescription).toEqual('propertyObject');
 
     const attrPropComplexWithTitle = rootNode.attributes[2];
-    expect(attrPropComplexWithTitle.typeDescription).toEqual('propertyObjectWithTitle');
+    expect(attrPropComplexWithTitle!.typeDescription).toEqual('propertyObjectWithTitle');
 
     const attrPropRefSimple = rootNode.attributes[3];
     // if there is a ref to a simple type, we use the name of the simple type
-    expect(attrPropRefSimple.typeDescription).toEqual('propertySimple');
+    expect(attrPropRefSimple!.typeDescription).toEqual('propertySimple');
 
     const attrPropRefComplex = rootNode.attributes[4];
     // reference to object --> use name of object
-    expect(attrPropRefComplex.typeDescription).toEqual('propertyObject');
+    expect(attrPropRefComplex!.typeDescription).toEqual('propertyObject');
 
     const attrPropRefNestedObject = rootNode.attributes[5];
     // reference to nested object
-    expect(attrPropRefNestedObject.typeDescription).toEqual('person');
+    expect(attrPropRefNestedObject!.typeDescription).toEqual('person');
   });
 
   it('generate object title', () => {
@@ -226,28 +225,28 @@ describe('test schema graph constructor with objects and attributes, without adv
     for (const edge of graph.edges) {
       expect(edge.start.absolutePath).toEqual([]);
     }
-    expect(graph.edges[0].end.absolutePath).toEqual(['properties', 'propertyObject']);
-    expect(graph.edges[0].edgeType).toEqual(EdgeType.ATTRIBUTE);
-    expect(graph.edges[0].label).toEqual('propertyObject');
-    expect(graph.edges[0].end.getNodeType() == 'schemaobject').toBeTruthy();
+    expect(graph.edges[0]!.end.absolutePath).toEqual(['properties', 'propertyObject']);
+    expect(graph.edges[0]!.edgeType).toEqual(EdgeType.ATTRIBUTE);
+    expect(graph.edges[0]!.label).toEqual('propertyObject');
+    expect(graph.edges[0]!.end.getNodeType() == 'schemaobject').toBeTruthy();
 
-    expect(graph.edges[1].end.absolutePath).toEqual(['properties', 'propertyObjectWithTitle']);
-    expect(graph.edges[1].edgeType).toEqual(EdgeType.ATTRIBUTE);
-    expect(graph.edges[1].label).toEqual('propertyObjectWithTitle');
-    expect(graph.edges[1].end.getNodeType() == 'schemaobject').toBeTruthy();
+    expect(graph.edges[1]!.end.absolutePath).toEqual(['properties', 'propertyObjectWithTitle']);
+    expect(graph.edges[1]!.edgeType).toEqual(EdgeType.ATTRIBUTE);
+    expect(graph.edges[1]!.label).toEqual('propertyObjectWithTitle');
+    expect(graph.edges[1]!.end.getNodeType() == 'schemaobject').toBeTruthy();
 
     // the edge is not to the ref definition but to the resolved object
-    expect(graph.edges[2].end.absolutePath).toEqual(['properties', 'propertyObject']);
-    expect(graph.edges[2].edgeType).toEqual(EdgeType.ATTRIBUTE);
+    expect(graph.edges[2]!.end.absolutePath).toEqual(['properties', 'propertyObject']);
+    expect(graph.edges[2]!.edgeType).toEqual(EdgeType.ATTRIBUTE);
     // the label of the edge is the actual attribute name, not the resolved data type
-    expect(graph.edges[2].label).toEqual('propertyRefToComplex');
-    expect(graph.edges[2].end.getNodeType() == 'schemaobject').toBeTruthy();
+    expect(graph.edges[2]!.label).toEqual('propertyRefToComplex');
+    expect(graph.edges[2]!.end.getNodeType() == 'schemaobject').toBeTruthy();
 
     // this edge is not to the ref definition but to the resolved object
-    expect(graph.edges[3].end.absolutePath).toEqual(['$defs', 'person']);
-    expect(graph.edges[3].edgeType).toEqual(EdgeType.ATTRIBUTE);
-    expect(graph.edges[3].label).toEqual('propertyRefToNestedObject');
-    expect(graph.edges[3].end.getNodeType() == 'schemaobject').toBeTruthy();
+    expect(graph.edges[3]!.end.absolutePath).toEqual(['$defs', 'person']);
+    expect(graph.edges[3]!.edgeType).toEqual(EdgeType.ATTRIBUTE);
+    expect(graph.edges[3]!.label).toEqual('propertyRefToNestedObject');
+    expect(graph.edges[3]!.end.getNodeType() == 'schemaobject').toBeTruthy();
 
     graph.edges = [];
     const propComplex = defs.get('properties.propertyObject')!;
@@ -266,10 +265,10 @@ describe('test schema graph constructor with objects and attributes, without adv
     generateAttributeEdges(person, defs, graph);
     // one attribute edge from person to address
     expect(graph.edges.length).toEqual(1);
-    expect(graph.edges[0].start.absolutePath).toEqual(['$defs', 'person']);
-    expect(graph.edges[0].end.absolutePath).toEqual(['$defs', 'person', 'properties', 'address']);
-    expect(graph.edges[0].edgeType).toEqual(EdgeType.ATTRIBUTE);
-    expect(graph.edges[0].label).toEqual('address');
-    expect(graph.edges[0].end.getNodeType() == 'schemaobject').toBeTruthy();
+    expect(graph.edges[0]!.start.absolutePath).toEqual(['$defs', 'person']);
+    expect(graph.edges[0]!.end.absolutePath).toEqual(['$defs', 'person', 'properties', 'address']);
+    expect(graph.edges[0]!.edgeType).toEqual(EdgeType.ATTRIBUTE);
+    expect(graph.edges[0]!.label).toEqual('address');
+    expect(graph.edges[0]!.end.getNodeType() == 'schemaobject').toBeTruthy();
   });
 });
diff --git a/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorComposition.test.ts b/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorComposition.test.ts
index 6101a2849..3c4a4fdc4 100644
--- a/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorComposition.test.ts
+++ b/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorComposition.test.ts
@@ -155,27 +155,27 @@ describe('test schema graph constructor with objects and compositional keywords'
     rootNode.attributes = generateObjectAttributes(rootNode.absolutePath, rootNode.schema, defs);
 
     expect(rootNode.attributes.length).toEqual(4);
-    expect(rootNode.attributes[0].name).toEqual('propertySimple');
-    expect(rootNode.attributes[0].title).toEqual(undefined);
-    expect(rootNode.attributes[0].absolutePath).toEqual(['properties', 'propertySimple']);
+    expect(rootNode.attributes[0]!.name).toEqual('propertySimple');
+    expect(rootNode.attributes[0]!.title).toEqual(undefined);
+    expect(rootNode.attributes[0]!.absolutePath).toEqual(['properties', 'propertySimple']);
 
-    expect(rootNode.attributes[1].name).toEqual('propertyRefToCompositional');
-    expect(rootNode.attributes[1].title).toEqual(undefined);
-    expect(rootNode.attributes[1].absolutePath).toEqual([
+    expect(rootNode.attributes[1]!.name).toEqual('propertyRefToCompositional');
+    expect(rootNode.attributes[1]!.title).toEqual(undefined);
+    expect(rootNode.attributes[1]!.absolutePath).toEqual([
       'properties',
       'propertyRefToCompositional',
     ]);
 
-    expect(rootNode.attributes[2].name).toEqual('propertyArrayToCompositional');
-    expect(rootNode.attributes[2].title).toEqual(undefined);
-    expect(rootNode.attributes[2].absolutePath).toEqual([
+    expect(rootNode.attributes[2]!.name).toEqual('propertyArrayToCompositional');
+    expect(rootNode.attributes[2]!.title).toEqual(undefined);
+    expect(rootNode.attributes[2]!.absolutePath).toEqual([
       'properties',
       'propertyArrayToCompositional',
     ]);
 
-    expect(rootNode.attributes[3].name).toEqual('propertyArrayInlineCompositional');
-    expect(rootNode.attributes[3].title).toEqual(undefined);
-    expect(rootNode.attributes[3].absolutePath).toEqual([
+    expect(rootNode.attributes[3]!.name).toEqual('propertyArrayInlineCompositional');
+    expect(rootNode.attributes[3]!.title).toEqual(undefined);
+    expect(rootNode.attributes[3]!.absolutePath).toEqual([
       'properties',
       'propertyArrayInlineCompositional',
     ]);
@@ -298,85 +298,91 @@ describe('test schema graph constructor with objects and compositional keywords'
 
     expect(graph.edges.length).toEqual(13);
 
-    expect(graph.edges[0].start.absolutePath).toEqual([]);
-    expect(graph.edges[0].end.absolutePath).toEqual(['$defs', 'compositionalWithoutObjectType']);
-    expect(graph.edges[0].edgeType).toEqual(EdgeType.ATTRIBUTE);
-    expect(graph.edges[0].isArray).toEqual(false);
-    expect(graph.edges[0].label).toEqual('propertyRefToCompositional');
+    expect(graph.edges[0]!.start.absolutePath).toEqual([]);
+    expect(graph.edges[0]!.end.absolutePath).toEqual(['$defs', 'compositionalWithoutObjectType']);
+    expect(graph.edges[0]!.edgeType).toEqual(EdgeType.ATTRIBUTE);
+    expect(graph.edges[0]!.isArray).toEqual(false);
+    expect(graph.edges[0]!.label).toEqual('propertyRefToCompositional');
 
-    expect(graph.edges[1].start.absolutePath).toEqual([]);
-    expect(graph.edges[1].end.absolutePath).toEqual(['$defs', 'compositionalWithoutObjectType']);
-    expect(graph.edges[1].edgeType).toEqual(EdgeType.ATTRIBUTE);
-    expect(graph.edges[1].isArray).toEqual(true);
-    expect(graph.edges[1].label).toEqual('propertyArrayToCompositional');
+    expect(graph.edges[1]!.start.absolutePath).toEqual([]);
+    expect(graph.edges[1]!.end.absolutePath).toEqual(['$defs', 'compositionalWithoutObjectType']);
+    expect(graph.edges[1]!.edgeType).toEqual(EdgeType.ATTRIBUTE);
+    expect(graph.edges[1]!.isArray).toEqual(true);
+    expect(graph.edges[1]!.label).toEqual('propertyArrayToCompositional');
 
-    expect(graph.edges[2].start.absolutePath).toEqual([]);
-    expect(graph.edges[2].end.absolutePath).toEqual([
+    expect(graph.edges[2]!.start.absolutePath).toEqual([]);
+    expect(graph.edges[2]!.end.absolutePath).toEqual([
       'properties',
       'propertyArrayInlineCompositional',
       'items',
     ]);
-    expect(graph.edges[2].edgeType).toEqual(EdgeType.ATTRIBUTE);
-    expect(graph.edges[2].isArray).toEqual(true);
+    expect(graph.edges[2]!.edgeType).toEqual(EdgeType.ATTRIBUTE);
+    expect(graph.edges[2]!.isArray).toEqual(true);
 
     // note that the order of the edges as in the same order as in the generation function: oneOf, anyOf, allOf, if, then, else
-    expect(graph.edges[3].start.absolutePath).toEqual([]);
-    expect(graph.edges[3].end.absolutePath).toEqual(['$defs', 'researcher']);
-    expect(graph.edges[3].edgeType).toEqual(EdgeType.ONE_OF);
-    expect(graph.edges[3].label).toEqual(EdgeType.ONE_OF);
-    expect(graph.edges[3].isArray).toEqual(false);
-
-    expect(graph.edges[4].start.absolutePath).toEqual([]);
-    expect(graph.edges[4].end.absolutePath).toEqual(['oneOf', 1]);
-    expect(graph.edges[4].edgeType).toEqual(EdgeType.ONE_OF);
-    expect(graph.edges[4].label).toEqual(EdgeType.ONE_OF);
-
-    expect(graph.edges[5].start.absolutePath).toEqual([]);
-    expect(graph.edges[5].end.absolutePath).toEqual(['$defs', 'person']);
-    expect(graph.edges[5].edgeType).toEqual(EdgeType.ANY_OF);
-    expect(graph.edges[5].label).toEqual(EdgeType.ANY_OF);
-
-    expect(graph.edges[6].start.absolutePath).toEqual([]);
-    expect(graph.edges[6].end.absolutePath).toEqual(['$defs', 'animal']);
-    expect(graph.edges[6].edgeType).toEqual(EdgeType.ANY_OF);
-    expect(graph.edges[6].label).toEqual(EdgeType.ANY_OF);
-
-    expect(graph.edges[7].start.absolutePath).toEqual([]);
-    expect(graph.edges[7].end.absolutePath).toEqual(['$defs', 'livingBeing']);
-    expect(graph.edges[7].edgeType).toEqual(EdgeType.ALL_OF);
-    expect(graph.edges[7].label).toEqual(EdgeType.ALL_OF);
-
-    expect(graph.edges[8].start.absolutePath).toEqual([]);
-    expect(graph.edges[8].end.absolutePath).toEqual(['allOf', 1]);
-    expect(graph.edges[8].edgeType).toEqual(EdgeType.ALL_OF);
-    expect(graph.edges[8].label).toEqual(EdgeType.ALL_OF);
-
-    expect(graph.edges[9].start.absolutePath).toEqual([
+    expect(graph.edges[3]!.start.absolutePath).toEqual([]);
+    expect(graph.edges[3]!.end.absolutePath).toEqual(['$defs', 'researcher']);
+    expect(graph.edges[3]!.edgeType).toEqual(EdgeType.ONE_OF);
+    expect(graph.edges[3]!.label).toEqual(EdgeType.ONE_OF);
+    expect(graph.edges[3]!.isArray).toEqual(false);
+
+    expect(graph.edges[4]!.start.absolutePath).toEqual([]);
+    expect(graph.edges[4]!.end.absolutePath).toEqual(['oneOf', 1]);
+    expect(graph.edges[4]!.edgeType).toEqual(EdgeType.ONE_OF);
+    expect(graph.edges[4]!.label).toEqual(EdgeType.ONE_OF);
+
+    expect(graph.edges[5]!.start.absolutePath).toEqual([]);
+    expect(graph.edges[5]!.end.absolutePath).toEqual(['$defs', 'person']);
+    expect(graph.edges[5]!.edgeType).toEqual(EdgeType.ANY_OF);
+    expect(graph.edges[5]!.label).toEqual(EdgeType.ANY_OF);
+
+    expect(graph.edges[6]!.start.absolutePath).toEqual([]);
+    expect(graph.edges[6]!.end.absolutePath).toEqual(['$defs', 'animal']);
+    expect(graph.edges[6]!.edgeType).toEqual(EdgeType.ANY_OF);
+    expect(graph.edges[6]!.label).toEqual(EdgeType.ANY_OF);
+
+    expect(graph.edges[7]!.start.absolutePath).toEqual([]);
+    expect(graph.edges[7]!.end.absolutePath).toEqual(['$defs', 'livingBeing']);
+    expect(graph.edges[7]!.edgeType).toEqual(EdgeType.ALL_OF);
+    expect(graph.edges[7]!.label).toEqual(EdgeType.ALL_OF);
+
+    expect(graph.edges[8]!.start.absolutePath).toEqual([]);
+    expect(graph.edges[8]!.end.absolutePath).toEqual(['allOf', 1]);
+    expect(graph.edges[8]!.edgeType).toEqual(EdgeType.ALL_OF);
+    expect(graph.edges[8]!.label).toEqual(EdgeType.ALL_OF);
+
+    expect(graph.edges[9]!.start.absolutePath).toEqual([
       'properties',
       'propertyArrayInlineCompositional',
       'items',
     ]);
-    expect(graph.edges[9].end.absolutePath).toEqual(['$defs', 'person']);
-    expect(graph.edges[9].edgeType).toEqual(EdgeType.ALL_OF);
-    expect(graph.edges[9].label).toEqual(EdgeType.ALL_OF);
+    expect(graph.edges[9]!.end.absolutePath).toEqual(['$defs', 'person']);
+    expect(graph.edges[9]!.edgeType).toEqual(EdgeType.ALL_OF);
+    expect(graph.edges[9]!.label).toEqual(EdgeType.ALL_OF);
 
-    expect(graph.edges[10].start.absolutePath).toEqual([
+    expect(graph.edges[10]!.start.absolutePath).toEqual([
       'properties',
       'propertyArrayInlineCompositional',
       'items',
     ]);
-    expect(graph.edges[10].end.absolutePath).toEqual(['$defs', 'animal']);
-    expect(graph.edges[10].edgeType).toEqual(EdgeType.ALL_OF);
-    expect(graph.edges[10].label).toEqual(EdgeType.ALL_OF);
-
-    expect(graph.edges[11].start.absolutePath).toEqual(['$defs', 'compositionalWithoutObjectType']);
-    expect(graph.edges[11].end.absolutePath).toEqual(['$defs', 'person']);
-    expect(graph.edges[11].edgeType).toEqual(EdgeType.ONE_OF);
-    expect(graph.edges[11].label).toEqual(EdgeType.ONE_OF);
-
-    expect(graph.edges[12].start.absolutePath).toEqual(['$defs', 'compositionalWithoutObjectType']);
-    expect(graph.edges[12].end.absolutePath).toEqual(['$defs', 'animal']);
-    expect(graph.edges[12].edgeType).toEqual(EdgeType.ONE_OF);
-    expect(graph.edges[12].label).toEqual(EdgeType.ONE_OF);
+    expect(graph.edges[10]!.end.absolutePath).toEqual(['$defs', 'animal']);
+    expect(graph.edges[10]!.edgeType).toEqual(EdgeType.ALL_OF);
+    expect(graph.edges[10]!.label).toEqual(EdgeType.ALL_OF);
+
+    expect(graph.edges[11]!.start.absolutePath).toEqual([
+      '$defs',
+      'compositionalWithoutObjectType',
+    ]);
+    expect(graph.edges[11]!.end.absolutePath).toEqual(['$defs', 'person']);
+    expect(graph.edges[11]!.edgeType).toEqual(EdgeType.ONE_OF);
+    expect(graph.edges[11]!.label).toEqual(EdgeType.ONE_OF);
+
+    expect(graph.edges[12]!.start.absolutePath).toEqual([
+      '$defs',
+      'compositionalWithoutObjectType',
+    ]);
+    expect(graph.edges[12]!.end.absolutePath).toEqual(['$defs', 'animal']);
+    expect(graph.edges[12]!.edgeType).toEqual(EdgeType.ONE_OF);
+    expect(graph.edges[12]!.label).toEqual(EdgeType.ONE_OF);
   });
 });
diff --git a/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorConditionals.test.ts b/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorConditionals.test.ts
index 580dc1ff4..f2aca6e2f 100644
--- a/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorConditionals.test.ts
+++ b/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorConditionals.test.ts
@@ -89,13 +89,13 @@ describe('test schema graph constructor with conditionals', () => {
     rootNode.attributes = generateObjectAttributes(rootNode.absolutePath, rootNode.schema, defs);
 
     expect(rootNode.attributes.length).toEqual(2);
-    expect(rootNode.attributes[0].name).toEqual('propertySimple');
-    expect(rootNode.attributes[0].title).toEqual(undefined);
-    expect(rootNode.attributes[0].absolutePath).toEqual(['properties', 'propertySimple']);
+    expect(rootNode.attributes[0]!.name).toEqual('propertySimple');
+    expect(rootNode.attributes[0]!.title).toEqual(undefined);
+    expect(rootNode.attributes[0]!.absolutePath).toEqual(['properties', 'propertySimple']);
 
-    expect(rootNode.attributes[1].name).toEqual('propertyObject');
-    expect(rootNode.attributes[1].title).toEqual(undefined);
-    expect(rootNode.attributes[1].absolutePath).toEqual(['properties', 'propertyObject']);
+    expect(rootNode.attributes[1]!.name).toEqual('propertyObject');
+    expect(rootNode.attributes[1]!.title).toEqual(undefined);
+    expect(rootNode.attributes[1]!.absolutePath).toEqual(['properties', 'propertyObject']);
   });
 
   it('deal with "then" that only implicitly has object type', () => {
@@ -104,9 +104,9 @@ describe('test schema graph constructor with conditionals', () => {
     thenNode.attributes = generateObjectAttributes(thenNode.absolutePath, thenNode.schema, defs);
 
     expect(thenNode.attributes.length).toEqual(1);
-    expect(thenNode.attributes[0].name).toEqual('propertyObject');
-    expect(thenNode.attributes[0].title).toEqual(undefined);
-    expect(thenNode.attributes[0].absolutePath).toEqual(['then', 'properties', 'propertyObject']);
+    expect(thenNode.attributes[0]!.name).toEqual('propertyObject');
+    expect(thenNode.attributes[0]!.title).toEqual(undefined);
+    expect(thenNode.attributes[0]!.absolutePath).toEqual(['then', 'properties', 'propertyObject']);
   });
 
   it('generate object title', () => {
@@ -183,13 +183,13 @@ describe('test schema graph constructor with conditionals', () => {
     }
 
     // note that the order of the edges as in the same order as in the generation function: if, then, else
-    expect(graph.edges[0].end.absolutePath).toEqual(['$defs', 'researcher']);
-    expect(graph.edges[0].edgeType).toEqual(EdgeType.IF);
-    expect(graph.edges[0].label).toEqual(EdgeType.IF);
+    expect(graph.edges[0]!.end.absolutePath).toEqual(['$defs', 'researcher']);
+    expect(graph.edges[0]!.edgeType).toEqual(EdgeType.IF);
+    expect(graph.edges[0]!.label).toEqual(EdgeType.IF);
 
-    expect(graph.edges[1].end.absolutePath).toEqual(['then']);
-    expect(graph.edges[1].edgeType).toEqual(EdgeType.THEN);
-    expect(graph.edges[1].label).toEqual(EdgeType.THEN);
+    expect(graph.edges[1]!.end.absolutePath).toEqual(['then']);
+    expect(graph.edges[1]!.edgeType).toEqual(EdgeType.THEN);
+    expect(graph.edges[1]!.label).toEqual(EdgeType.THEN);
   });
 
   it('trim graph', () => {
diff --git a/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorEnum.test.ts b/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorEnum.test.ts
index 8160b5ad5..672b5ee5b 100644
--- a/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorEnum.test.ts
+++ b/meta_configurator/src/schema/graph-representation/__tests__/schemaGraphConstructorEnum.test.ts
@@ -82,21 +82,21 @@ describe('test schema graph constructor with objects and attributes with enums',
     rootNode.attributes = generateObjectAttributes(rootNode.absolutePath, rootNode.schema, defs);
 
     expect(rootNode.attributes.length).toEqual(4);
-    expect(rootNode.attributes[0].name).toEqual('propertyEnum');
-    expect(rootNode.attributes[0].title).toEqual(undefined);
-    expect(rootNode.attributes[0].absolutePath).toEqual(['properties', 'propertyEnum']);
+    expect(rootNode.attributes[0]!.name).toEqual('propertyEnum');
+    expect(rootNode.attributes[0]!.title).toEqual(undefined);
+    expect(rootNode.attributes[0]!.absolutePath).toEqual(['properties', 'propertyEnum']);
 
-    expect(rootNode.attributes[1].name).toEqual('propertyEnumMixed');
-    expect(rootNode.attributes[1].title).toEqual(undefined);
-    expect(rootNode.attributes[1].absolutePath).toEqual(['properties', 'propertyEnumMixed']);
+    expect(rootNode.attributes[1]!.name).toEqual('propertyEnumMixed');
+    expect(rootNode.attributes[1]!.title).toEqual(undefined);
+    expect(rootNode.attributes[1]!.absolutePath).toEqual(['properties', 'propertyEnumMixed']);
 
-    expect(rootNode.attributes[2].name).toEqual('propertyEnumRef1');
-    expect(rootNode.attributes[2].title).toEqual(undefined);
-    expect(rootNode.attributes[2].absolutePath).toEqual(['properties', 'propertyEnumRef1']);
+    expect(rootNode.attributes[2]!.name).toEqual('propertyEnumRef1');
+    expect(rootNode.attributes[2]!.title).toEqual(undefined);
+    expect(rootNode.attributes[2]!.absolutePath).toEqual(['properties', 'propertyEnumRef1']);
 
-    expect(rootNode.attributes[3].name).toEqual('propertyEnumRef2');
-    expect(rootNode.attributes[3].title).toEqual(undefined);
-    expect(rootNode.attributes[3].absolutePath).toEqual(['properties', 'propertyEnumRef2']);
+    expect(rootNode.attributes[3]!.name).toEqual('propertyEnumRef2');
+    expect(rootNode.attributes[3]!.title).toEqual(undefined);
+    expect(rootNode.attributes[3]!.absolutePath).toEqual(['properties', 'propertyEnumRef2']);
   });
 
   it('generate attribute edges', () => {
@@ -112,25 +112,25 @@ describe('test schema graph constructor with objects and attributes with enums',
     for (const edge of graph.edges) {
       expect(edge.start.absolutePath).toEqual([]);
     }
-    expect(graph.edges[0].end.absolutePath).toEqual(['properties', 'propertyEnum']);
-    expect(graph.edges[0].edgeType).toEqual(EdgeType.ATTRIBUTE);
-    expect(graph.edges[0].label).toEqual('propertyEnum');
-    expect(graph.edges[0].end.getNodeType() == 'schemaenum').toBeTruthy();
-
-    expect(graph.edges[1].end.absolutePath).toEqual(['properties', 'propertyEnumMixed']);
-    expect(graph.edges[1].edgeType).toEqual(EdgeType.ATTRIBUTE);
-    expect(graph.edges[1].label).toEqual('propertyEnumMixed');
-    expect(graph.edges[1].end.getNodeType() == 'schemaenum').toBeTruthy();
-
-    expect(graph.edges[2].end.absolutePath).toEqual(['$defs', 'enumString']);
-    expect(graph.edges[2].edgeType).toEqual(EdgeType.ATTRIBUTE);
-    expect(graph.edges[2].label).toEqual('propertyEnumRef1');
-    expect(graph.edges[2].end.getNodeType() == 'schemaenum').toBeTruthy();
-
-    expect(graph.edges[3].end.absolutePath).toEqual(['$defs', 'enumInt']);
-    expect(graph.edges[3].edgeType).toEqual(EdgeType.ATTRIBUTE);
-    expect(graph.edges[3].label).toEqual('propertyEnumRef2');
-    expect(graph.edges[3].end.getNodeType() == 'schemaenum').toBeTruthy();
+    expect(graph.edges[0]!.end.absolutePath).toEqual(['properties', 'propertyEnum']);
+    expect(graph.edges[0]!.edgeType).toEqual(EdgeType.ATTRIBUTE);
+    expect(graph.edges[0]!.label).toEqual('propertyEnum');
+    expect(graph.edges[0]!.end.getNodeType() == 'schemaenum').toBeTruthy();
+
+    expect(graph.edges[1]!.end.absolutePath).toEqual(['properties', 'propertyEnumMixed']);
+    expect(graph.edges[1]!.edgeType).toEqual(EdgeType.ATTRIBUTE);
+    expect(graph.edges[1]!.label).toEqual('propertyEnumMixed');
+    expect(graph.edges[1]!.end.getNodeType() == 'schemaenum').toBeTruthy();
+
+    expect(graph.edges[2]!.end.absolutePath).toEqual(['$defs', 'enumString']);
+    expect(graph.edges[2]!.edgeType).toEqual(EdgeType.ATTRIBUTE);
+    expect(graph.edges[2]!.label).toEqual('propertyEnumRef1');
+    expect(graph.edges[2]!.end.getNodeType() == 'schemaenum').toBeTruthy();
+
+    expect(graph.edges[3]!.end.absolutePath).toEqual(['$defs', 'enumInt']);
+    expect(graph.edges[3]!.edgeType).toEqual(EdgeType.ATTRIBUTE);
+    expect(graph.edges[3]!.label).toEqual('propertyEnumRef2');
+    expect(graph.edges[3]!.end.getNodeType() == 'schemaenum').toBeTruthy();
   });
 
   it('trim enum values', () => {
diff --git a/meta_configurator/src/schema/graph-representation/graphRepresentationToHierarchy.ts b/meta_configurator/src/schema/graph-representation/graphRepresentationToHierarchy.ts
index 051068dc2..0bc407444 100644
--- a/meta_configurator/src/schema/graph-representation/graphRepresentationToHierarchy.ts
+++ b/meta_configurator/src/schema/graph-representation/graphRepresentationToHierarchy.ts
@@ -1,12 +1,9 @@
 import {
   EdgeType,
-  SchemaElementData,
   type SchemaGraph,
   SchemaNodeData,
-  SchemaObjectNodeData,
 } from '@/schema/graph-representation/schemaGraphTypes';
 import {pathToString} from '@/utility/pathUtils';
-import type {Path} from '@/utility/path';
 
 export interface HierarchyNode {
   graphNode: SchemaNodeData;
diff --git a/meta_configurator/src/schema/graph-representation/typeUtils.ts b/meta_configurator/src/schema/graph-representation/typeUtils.ts
index fc9ebed41..e2665bfb2 100644
--- a/meta_configurator/src/schema/graph-representation/typeUtils.ts
+++ b/meta_configurator/src/schema/graph-representation/typeUtils.ts
@@ -7,7 +7,6 @@ import {pathToJsonPointer} from '@/utility/pathUtils';
 import {SchemaNodeData} from '@/schema/graph-representation/schemaGraphTypes';
 import type {Path} from '@/utility/path';
 import {cleanupSchemaByType} from '../cleanupSchemaByType';
-import {doesSchemaAllowNull} from '@/schema/schemaReadingUtils';
 
 export type AttributeTypeChoice = {label: string; schema: JsonSchemaObjectType};
 
@@ -45,7 +44,7 @@ export function collectTypeChoices(nodesData: SchemaNodeData[]): AttributeTypeCh
   const objectDefs = collectObjectAndEnumDefinitionPathsFromNodes(nodesData);
 
   objectDefs.forEach(def => {
-    const objectName: string = def[def.length - 1].toString();
+    const objectName: string = def[def.length - 1]!.toString();
     const pathAsJsonPointer = pathToJsonPointer(def);
     result.push({
       label: objectName,
@@ -122,7 +121,7 @@ export function applyNewType(
 ) {
   if (typeSchema.type !== undefined) {
     currentSchema.type = typeSchema.type;
-    cleanupSchemaByType(currentSchema, typeSchema.type);
+    cleanupSchemaByType(currentSchema, typeSchema.type as SchemaPropertyType);
     if (typeSchema.type === 'array') {
       if (
         currentSchema.items === undefined ||
diff --git a/meta_configurator/src/schema/graph-representation/updateGraph.ts b/meta_configurator/src/schema/graph-representation/updateGraph.ts
index 0a0653d50..e004bbbba 100644
--- a/meta_configurator/src/schema/graph-representation/updateGraph.ts
+++ b/meta_configurator/src/schema/graph-representation/updateGraph.ts
@@ -34,10 +34,15 @@ export function wasNodeAddedOrEdgesChanged(oldNodes: Node[], newNodes: Node[]):
       }
       // edges changed only if an attribute type changed and the new or old value was a schema object instead of a simple type
       for (let i = 0; i < newAttributes.length; i++) {
-        if (newAttributes[i].typeDescription !== oldAttributes[i].typeDescription) {
+        const newAttribute = newAttributes[i];
+        const oldAttribute = oldAttributes[i];
+        if (!newAttribute || !oldAttribute) {
+          return true;
+        }
+        if (newAttribute.typeDescription !== oldAttribute.typeDescription) {
           if (
-            !isSimpleType(newAttributes[i].typeDescription) ||
-            !isSimpleType(oldAttributes[i].typeDescription)
+            !isSimpleType(newAttribute.typeDescription) ||
+            !isSimpleType(oldAttribute.typeDescription)
           ) {
             return true;
           }
diff --git a/meta_configurator/src/schema/jsonSchemaWrapper.ts b/meta_configurator/src/schema/jsonSchemaWrapper.ts
index 3fb26e1df..8d8df005f 100644
--- a/meta_configurator/src/schema/jsonSchemaWrapper.ts
+++ b/meta_configurator/src/schema/jsonSchemaWrapper.ts
@@ -65,7 +65,7 @@ export class JsonSchemaWrapper {
       const requiredProperties = this.required ?? [];
       for (const key of Object.keys(this.properties)) {
         if (requiredProperties.includes(key)) {
-          result[key] = this.properties[key].initialValue();
+          result[key] = this.properties[key]!.initialValue();
         }
       }
       return result;
@@ -73,8 +73,8 @@ export class JsonSchemaWrapper {
     if (this.hasType('array')) {
       const result = [];
 
-      if (this.items && this.minLength > 0) {
-        for (let i = 0; i < this.minLength; i++) {
+      if (this.items && this.minItems > 0) {
+        for (let i = 0; i < this.minItems; i++) {
           result.push(this.items.initialValue());
         }
       }
diff --git a/meta_configurator/src/schema/mergeAllOfs.ts b/meta_configurator/src/schema/mergeAllOfs.ts
index bd71bd945..412066d16 100644
--- a/meta_configurator/src/schema/mergeAllOfs.ts
+++ b/meta_configurator/src/schema/mergeAllOfs.ts
@@ -7,31 +7,34 @@ export function mergeAllOfs(schema: JsonSchemaType, deep: boolean = true): JsonS
     return schema;
   }
 
-  return mergeAllOf(schema, {
-    deep: deep,
-    resolvers: {
-      defaultResolver: mergeAllOf.options.resolvers.title,
-      // add additional resolvers here, most of the keywords are NOT supported by default
-      conditions: function (values: any[][]) {
-        return values.flat(); // just merge all conditions
-      },
-      metaConfigurator: function (values: any[][]) {
-        let result = {
-          advanced: false,
-          hideAddPropertyButton: false,
-        };
-        for (const value of values) {
-          if ('advanced' in value && value.advanced) {
-            result.advanced = true;
-          }
-          if ('hideAddPropertyButton' in value && value.hideAddPropertyButton) {
-            result.hideAddPropertyButton = true;
+  return mergeAllOf(
+    schema as any,
+    {
+      deep: deep,
+      resolvers: {
+        defaultResolver: mergeAllOf.options.resolvers.title,
+        // add additional resolvers here, most of the keywords are NOT supported by default
+        conditions: function (values: any[][]) {
+          return values.flat(); // just merge all conditions
+        },
+        metaConfigurator: function (values: any[][]) {
+          let result = {
+            advanced: false,
+            hideAddPropertyButton: false,
+          };
+          for (const value of values) {
+            if ('advanced' in value && value.advanced) {
+              result.advanced = true;
+            }
+            if ('hideAddPropertyButton' in value && value.hideAddPropertyButton) {
+              result.hideAddPropertyButton = true;
+            }
           }
-        }
-        return result;
+          return result;
+        },
       },
-    },
-  });
+    } as any
+  );
 }
 export function safeMergeAllOfs(schema: JsonSchemaType): JsonSchemaType {
   try {
diff --git a/meta_configurator/src/schema/metaSchemaBuilder.ts b/meta_configurator/src/schema/metaSchemaBuilder.ts
index af89dc05d..539e287e7 100644
--- a/meta_configurator/src/schema/metaSchemaBuilder.ts
+++ b/meta_configurator/src/schema/metaSchemaBuilder.ts
@@ -1,11 +1,11 @@
 import type {SettingsInterfaceMetaSchema} from '@/settings/settingsTypes';
-import type {TopLevelSchema} from '@/schema/jsonSchemaType';
+import type {JsonSchemaObjectType, TopLevelSchema} from '@/schema/jsonSchemaType';
 import {META_SCHEMA_SIMPLIFIED} from '@/packaged-schemas/metaSchemaSimplified';
-import {updateSettingsWithDefaults} from '@/settings/settingsUpdater';
 import {SETTINGS_DATA_DEFAULT} from '@/settings/defaultSettingsData';
 
 export function buildMetaSchema(metaSchemaSettings: SettingsInterfaceMetaSchema): TopLevelSchema {
   let metaSchema = structuredClone(META_SCHEMA_SIMPLIFIED);
+  const defs = metaSchema.$defs as Record<string, any>;
 
   if (!metaSchemaSettings) {
     // if no settings are provided, use the default settings
@@ -13,76 +13,75 @@ export function buildMetaSchema(metaSchemaSettings: SettingsInterfaceMetaSchema)
   }
 
   if (!metaSchemaSettings.allowBooleanSchema) {
-    metaSchema.$defs!.jsonSchema = DEF_JSON_SCHEMA_WITHOUT_BOOLEAN_SCHEMA;
+    defs.jsonSchema = DEF_JSON_SCHEMA_WITHOUT_BOOLEAN_SCHEMA;
   }
   if (!metaSchemaSettings.allowMultipleTypes) {
-    metaSchema.$defs!.typeDefinition = DEF_TYPE_DEFINITION_WITHOUT_MULTIPLE_TYPES_EXCEPT_NULLABLE;
+    defs.typeDefinition = DEF_TYPE_DEFINITION_WITHOUT_MULTIPLE_TYPES_EXCEPT_NULLABLE;
   }
   if (!metaSchemaSettings.showAdditionalPropertiesButton) {
-    metaSchema.$defs!.objectSubSchema!.metaConfigurator = {
+    defs.objectSubSchema!.metaConfigurator = {
       hideAddPropertyButton: true,
     };
   }
 
   if (metaSchemaSettings.markMoreFieldsAsAdvanced) {
-    metaSchema.$defs!.constProperty!.properties!.const.metaConfigurator = {
+    defs.constProperty.properties.const.metaConfigurator = {
       advanced: true,
     };
-    metaSchema.$defs!.enumProperty!.properties!.enum.metaConfigurator = {
+    defs.enumProperty.properties.enum.metaConfigurator = {
       advanced: true,
     };
-    metaSchema.$defs!.objectProperty!.properties!.additionalProperties.metaConfigurator = {
+    defs.objectProperty.properties.additionalProperties.metaConfigurator = {
       advanced: true,
     };
-    metaSchema.$defs!.stringProperty!.properties!.maxLength.metaConfigurator = {
+    defs.stringProperty.properties.maxLength.metaConfigurator = {
       advanced: true,
     };
-    metaSchema.$defs!.stringProperty!.properties!.minLength.metaConfigurator = {
+    defs.stringProperty.properties.minLength.metaConfigurator = {
       advanced: true,
     };
-    metaSchema.$defs!.stringProperty!.properties!.pattern.metaConfigurator = {
+    defs.stringProperty.properties.pattern.metaConfigurator = {
       advanced: true,
     };
-    metaSchema.$defs!.arrayProperty!.properties!.minItems.metaConfigurator = {
+    defs.arrayProperty.properties.minItems.metaConfigurator = {
       advanced: true,
     };
-    metaSchema.$defs!.arrayProperty!.properties!.maxItems.metaConfigurator = {
+    defs.arrayProperty.properties.maxItems.metaConfigurator = {
       advanced: true,
     };
-    metaSchema.$defs!.arrayProperty!.properties!.uniqueItems.metaConfigurator = {
+    defs.arrayProperty.properties.uniqueItems.metaConfigurator = {
       advanced: true,
     };
-    metaSchema.$defs!['meta-data']!.properties!.examples.metaConfigurator = {
+    defs['meta-data'].properties.examples.metaConfigurator = {
       advanced: true,
     };
-    metaSchema.$defs!['meta-data']!.properties!.default.metaConfigurator = {
+    defs['meta-data'].properties.default.metaConfigurator = {
       advanced: true,
     };
   }
 
   if (metaSchemaSettings.objectTypesComfort) {
-    metaSchema.$defs.enumProperty.allOf = ALL_OF_ENUM_PROPERTY;
-    metaSchema.$defs.constProperty.allOf = ALL_OF_CONST_PROPERTY;
-    metaSchema.$defs['meta-data'].allOf = ALL_OF_META_DATA;
+    defs.enumProperty.allOf = ALL_OF_ENUM_PROPERTY;
+    defs.constProperty.allOf = ALL_OF_CONST_PROPERTY;
+    defs['meta-data'].allOf = ALL_OF_META_DATA;
   }
 
   if (metaSchemaSettings.showJsonLdFields) {
-    for (const key in JSON_LD_DEFS) {
-      const value: any = JSON_LD_DEFS[key];
-      metaSchema.$defs[key] = value;
+    for (const [key, value] of Object.entries(JSON_LD_DEFS)) {
+      defs[key] = value as JsonSchemaObjectType;
     }
-    metaSchema.$defs.rootObjectSubSchema!.allOf! = [
+    defs.rootObjectSubSchema.allOf = [
       {
         $ref: '#/$defs/jsonLdContextHaving',
       },
-      ...metaSchema.$defs.rootObjectSubSchema!.allOf!,
+      ...defs.rootObjectSubSchema.allOf,
     ];
 
-    metaSchema.$defs.objectSubSchema!.allOf! = [
+    defs.objectSubSchema.allOf = [
       {
         $ref: '#/$defs/jsonLdCommon',
       },
-      ...metaSchema.$defs.objectSubSchema!.allOf!,
+      ...defs.objectSubSchema.allOf,
     ];
   }
 
@@ -91,20 +90,20 @@ export function buildMetaSchema(metaSchemaSettings: SettingsInterfaceMetaSchema)
     !metaSchemaSettings.allowMultipleTypes ||
     metaSchemaSettings.objectTypesComfort;
   if (simplified) {
-    metaSchema.$defs.jsonMetaSchema.title = 'Simplified JSON Schema Meta Schema';
+    defs.jsonMetaSchema.title = 'Simplified JSON Schema Meta Schema';
   }
 
   return metaSchema;
 }
 
-const DEF_JSON_SCHEMA_WITHOUT_BOOLEAN_SCHEMA = {
+const DEF_JSON_SCHEMA_WITHOUT_BOOLEAN_SCHEMA: JsonSchemaObjectType = {
   title: 'Json schema',
   $ref: '#/$defs/objectSubSchema',
   $comment:
     'This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.',
 };
 
-const DEF_TYPE_DEFINITION_WITHOUT_MULTIPLE_TYPES_EXCEPT_NULLABLE = {
+const DEF_TYPE_DEFINITION_WITHOUT_MULTIPLE_TYPES_EXCEPT_NULLABLE: JsonSchemaObjectType = {
   properties: {
     type: {
       oneOf: [
@@ -135,7 +134,7 @@ const DEF_TYPE_DEFINITION_WITHOUT_MULTIPLE_TYPES_EXCEPT_NULLABLE = {
   },
 };
 
-const ALL_OF_ENUM_PROPERTY = [
+const ALL_OF_ENUM_PROPERTY: JsonSchemaObjectType[] = [
   {
     if: {
       $ref: '#/$defs/hasTypeArray',
@@ -208,7 +207,7 @@ const ALL_OF_ENUM_PROPERTY = [
   },
 ];
 
-const ALL_OF_CONST_PROPERTY = [
+const ALL_OF_CONST_PROPERTY: JsonSchemaObjectType[] = [
   {
     if: {
       $ref: '#/$defs/hasTypeArray',
@@ -271,7 +270,7 @@ const ALL_OF_CONST_PROPERTY = [
   },
 ];
 
-const ALL_OF_META_DATA = [
+const ALL_OF_META_DATA: JsonSchemaObjectType[] = [
   {
     if: {
       $ref: '#/$defs/hasTypeArray',
diff --git a/meta_configurator/src/schema/schemaLazyResolver.ts b/meta_configurator/src/schema/schemaLazyResolver.ts
index 6b9ea8759..b3a98d652 100644
--- a/meta_configurator/src/schema/schemaLazyResolver.ts
+++ b/meta_configurator/src/schema/schemaLazyResolver.ts
@@ -127,7 +127,7 @@ function attemptMergeOneOfsIntoAnyOfs(schema: JsonSchemaType) {
     let someAnyOfHasMultipleOneOfOptions = false;
 
     for (let i = 0; i < schema.anyOf.length; i++) {
-      const subSchemaAnyOf = schema.anyOf[i];
+      const subSchemaAnyOf = schema.anyOf[i]!;
 
       const mergedOneOfs: JsonSchemaType[] = [];
 
@@ -140,7 +140,7 @@ function attemptMergeOneOfsIntoAnyOfs(schema: JsonSchemaType) {
 
       if (mergedOneOfs.length == 1) {
         // if anyOf has just one compatible oneOf: merge it
-        schema.anyOf[i] = mergedOneOfs[0];
+        schema.anyOf[i] = mergedOneOfs[0]!;
       } else if (mergedOneOfs.length > 1) {
         someAnyOfHasMultipleOneOfOptions = true;
       }
@@ -223,7 +223,7 @@ function mergeSingularOneOf(schema: JsonSchemaType, mode: SessionMode): JsonSche
       const copiedSchema: JsonSchemaObjectType = {...schema};
       delete copiedSchema.oneOf;
       return safeMergeSchemas(
-        resolveAndTransform(schema.oneOf![0], mode),
+        resolveAndTransform(schema.oneOf[0]!, mode),
         resolveAndTransform(copiedSchema, mode)
       );
     } else if (schema.oneOf!!.length == 0) {
@@ -245,7 +245,7 @@ function mergeSingularAnyOf(schema: JsonSchemaType, mode: SessionMode): JsonSche
       const copiedSchema: JsonSchemaObjectType = {...schema};
       delete copiedSchema.anyOf;
       return safeMergeSchemas(
-        resolveAndTransform(schema.anyOf!![0], mode),
+        resolveAndTransform(schema.anyOf[0]!, mode),
         resolveAndTransform(copiedSchema, mode)
       );
     } else if (schema.anyOf!!.length == 0) {
@@ -266,7 +266,7 @@ function resolveReference(
   let preprocessedRefSchemas = preprocessedRefSchemasMap.get(mode)!;
   let refSchema: any;
   if (preprocessedRefSchemas.has(refString)) {
-    refSchema = preprocessedRefSchemas.get(refString);
+    refSchema = preprocessedRefSchemas.get(refString)!;
   } else {
     let rootSchema = getSchemaForMode(mode).schemaPreprocessed.value;
     try {
diff --git a/meta_configurator/src/schema/schemaReadingUtils.ts b/meta_configurator/src/schema/schemaReadingUtils.ts
index b2146927e..53f07e3cf 100644
--- a/meta_configurator/src/schema/schemaReadingUtils.ts
+++ b/meta_configurator/src/schema/schemaReadingUtils.ts
@@ -140,7 +140,7 @@ export function setSchemaNullable(
       type => type !== 'null'
     );
     const nextTypes = [...new Set([...nonNullableTypes, 'null'])];
-    schema.type = nextTypes.length === 1 ? nextTypes[0] : nextTypes;
+    schema.type = (nextTypes.length === 1 ? nextTypes[0]! : nextTypes) as SchemaPropertyTypes;
     return;
   }
 
@@ -148,7 +148,7 @@ export function setSchemaNullable(
   if (nextTypes.length === 0) {
     delete schema.type;
   } else {
-    schema.type = nextTypes.length === 1 ? nextTypes[0] : nextTypes;
+    schema.type = (nextTypes.length === 1 ? nextTypes[0]! : nextTypes) as SchemaPropertyTypes;
   }
 }
 
diff --git a/meta_configurator/src/schema/validationService.ts b/meta_configurator/src/schema/validationService.ts
index 035206c45..f13ad5786 100644
--- a/meta_configurator/src/schema/validationService.ts
+++ b/meta_configurator/src/schema/validationService.ts
@@ -172,23 +172,31 @@ export class ValidationService {
     }
     if (result.properties) {
       for (const key of Object.keys(result.properties)) {
-        result.properties[key] = this.updateReferencesAndReplaceCustomKeywords(
-          result.properties[key]
-        );
+        const propertySchema = result.properties[key];
+        if (propertySchema === undefined) {
+          continue;
+        }
+        result.properties[key] = this.updateReferencesAndReplaceCustomKeywords(propertySchema);
       }
     }
     if (result.patternProperties) {
       for (const key of Object.keys(result.patternProperties)) {
-        result.patternProperties[key] = this.updateReferencesAndReplaceCustomKeywords(
-          result.patternProperties[key]
-        );
+        const patternPropertySchema = result.patternProperties[key];
+        if (patternPropertySchema === undefined) {
+          continue;
+        }
+        result.patternProperties[key] =
+          this.updateReferencesAndReplaceCustomKeywords(patternPropertySchema);
       }
     }
     if (result.dependentSchemas) {
       for (const key of Object.keys(result.dependentSchemas)) {
-        result.dependentSchemas[key] = this.updateReferencesAndReplaceCustomKeywords(
-          result.dependentSchemas[key]
-        );
+        const dependentSchema = result.dependentSchemas[key];
+        if (dependentSchema === undefined) {
+          continue;
+        }
+        result.dependentSchemas[key] =
+          this.updateReferencesAndReplaceCustomKeywords(dependentSchema);
       }
     }
 
diff --git a/meta_configurator/src/schema/writeDefaultsToData.ts b/meta_configurator/src/schema/writeDefaultsToData.ts
index 4beb5fe06..be562a962 100644
--- a/meta_configurator/src/schema/writeDefaultsToData.ts
+++ b/meta_configurator/src/schema/writeDefaultsToData.ts
@@ -23,6 +23,9 @@ export function writeSchemaRequiredDefaultsToData(
   if (schemaProperties) {
     for (const propertyName in schemaProperties) {
       const property = schemaProperties[propertyName];
+      if (!property) {
+        continue;
+      }
       if (requiredProperties.includes(propertyName)) {
         if (!document[propertyName]) {
           if (property.default) {
@@ -40,7 +43,7 @@ export function writeSchemaRequiredDefaultsToData(
                 writeSchemaRequiredDefaultsToData(
                   data,
                   path.concat(propertyName, '0'),
-                  property.items,
+                  property.items!,
                   updateDataFct
                 );
               }
diff --git a/meta_configurator/src/settings/useSettings.ts b/meta_configurator/src/settings/useSettings.ts
index a3b7ef5a7..95458817c 100644
--- a/meta_configurator/src/settings/useSettings.ts
+++ b/meta_configurator/src/settings/useSettings.ts
@@ -6,5 +6,5 @@ import type {RemovableRef} from '@vueuse/core';
  * Use this hook to access the settings data for reading.
  */
 export function useSettings(): RemovableRef<SettingsInterfaceRoot> {
-  return useDataSource().settingsData;
+  return useDataSource().settingsData as RemovableRef<SettingsInterfaceRoot>;
 }
diff --git a/meta_configurator/src/types/cytoscape-cose-bilkent.d.ts b/meta_configurator/src/types/cytoscape-cose-bilkent.d.ts
new file mode 100644
index 000000000..c97ae54ba
--- /dev/null
+++ b/meta_configurator/src/types/cytoscape-cose-bilkent.d.ts
@@ -0,0 +1 @@
+declare module 'cytoscape-cose-bilkent';
diff --git a/meta_configurator/src/utility/__tests__/fileDialogUtils.test.ts b/meta_configurator/src/utility/__tests__/fileDialogUtils.test.ts
new file mode 100644
index 000000000..9cd5a2c00
--- /dev/null
+++ b/meta_configurator/src/utility/__tests__/fileDialogUtils.test.ts
@@ -0,0 +1,49 @@
+import {beforeEach, describe, expect, it, vi} from 'vitest';
+
+const openMock = vi.fn();
+const onChangeRegistrations: Array<(files: FileList | null) => void> = [];
+const resetMock = vi.fn();
+
+vi.mock('@vueuse/core', () => ({
+  useFileDialog: vi.fn(() => ({
+    open: openMock,
+    onChange: (handler: (files: FileList | null) => void) => {
+      onChangeRegistrations.push(handler);
+    },
+    reset: resetMock,
+  })),
+}));
+
+describe('createLazySingleFileDialog', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+    onChangeRegistrations.length = 0;
+    vi.useFakeTimers();
+  });
+
+  it('reuses one dialog registration and routes selection to the latest handler', async () => {
+    const {createLazySingleFileDialog} = await import('@/utility/fileDialogUtils.ts');
+
+    const dialog = createLazySingleFileDialog('.csv');
+    const firstHandler = vi.fn();
+    const secondHandler = vi.fn();
+
+    dialog.openForSelection(firstHandler);
+    dialog.openForSelection(secondHandler);
+
+    expect(onChangeRegistrations).toHaveLength(1);
+    expect(openMock).not.toHaveBeenCalled();
+
+    vi.runAllTimers();
+
+    expect(openMock).toHaveBeenCalledTimes(2);
+
+    const files = {0: new File(['a'], 'test.csv'), length: 1} as unknown as FileList;
+    onChangeRegistrations[0]!(files);
+
+    expect(firstHandler).not.toHaveBeenCalled();
+    expect(secondHandler).toHaveBeenCalledWith(files);
+    expect(resetMock).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/meta_configurator/src/utility/__tests__/pathUtils.test.ts b/meta_configurator/src/utility/__tests__/pathUtils.test.ts
index a3a064803..78280afdc 100644
--- a/meta_configurator/src/utility/__tests__/pathUtils.test.ts
+++ b/meta_configurator/src/utility/__tests__/pathUtils.test.ts
@@ -11,7 +11,6 @@ import {
   pathToJsonPointer,
   pathToString,
 } from '../pathUtils';
-import {dataAt} from '../resolveDataAtPath';
 
 // avoid constructing useDataLink store through imports, it is not required for this component
 vi.mock('@/data/useDataLink', () => ({
diff --git a/meta_configurator/src/utility/__tests__/renameUtils.test.ts b/meta_configurator/src/utility/__tests__/renameUtils.test.ts
index d899be13a..377390c0b 100644
--- a/meta_configurator/src/utility/__tests__/renameUtils.test.ts
+++ b/meta_configurator/src/utility/__tests__/renameUtils.test.ts
@@ -1,5 +1,5 @@
 import {describe, expect, it, vi} from 'vitest';
-import {replacePropertyNameUtils, updateReferences} from '../renameUtils';
+import {replacePropertyNameUtils} from '../renameUtils';
 import {META_SCHEMA_SIMPLIFIED} from '../../packaged-schemas/metaSchemaSimplified';
 import {type Path} from '../path';
 import _ from 'lodash';
diff --git a/meta_configurator/src/utility/codeGenerationUtils.ts b/meta_configurator/src/utility/codeGenerationUtils.ts
index 5e873d8d7..c2dca0849 100644
--- a/meta_configurator/src/utility/codeGenerationUtils.ts
+++ b/meta_configurator/src/utility/codeGenerationUtils.ts
@@ -28,7 +28,7 @@ export const SUPPORTED_LANGUAGES = [
 ].sort((a, b) => a.localeCompare(b));
 
 export async function quicktypeJSON(targetLanguage: string, typeName: string, jsonString: string) {
-  const jsonInput = jsonInputForTargetLanguage(targetLanguage);
+  const jsonInput = jsonInputForTargetLanguage(targetLanguage as any);
 
   // We could add multiple samples for the same desired
   // type, or many sources for other types. Here we're
@@ -43,7 +43,7 @@ export async function quicktypeJSON(targetLanguage: string, typeName: string, js
 
   return await quicktype({
     inputData,
-    lang: targetLanguage,
+    lang: targetLanguage as any,
   });
 }
 
@@ -63,7 +63,7 @@ export async function quicktypeJSONSchema(
 
   return await quicktype({
     inputData,
-    lang: removeParametersFromLanguage(targetLanguage),
+    lang: removeParametersFromLanguage(targetLanguage) as any,
     rendererOptions: getRendererOptions(targetLanguage),
   });
 }
diff --git a/meta_configurator/src/utility/data-export/dataExportService.ts b/meta_configurator/src/utility/data-export/dataExportService.ts
index bc466fb40..c6747c24a 100644
--- a/meta_configurator/src/utility/data-export/dataExportService.ts
+++ b/meta_configurator/src/utility/data-export/dataExportService.ts
@@ -1,5 +1,4 @@
 import type {TopLevelSchema} from '@/schema/jsonSchemaType';
-import type {Ref} from 'vue';
 
 export interface DataExportService {
   generateMappingSuggestion(
diff --git a/meta_configurator/src/utility/data-export/dataExportServiceHandlebars.ts b/meta_configurator/src/utility/data-export/dataExportServiceHandlebars.ts
index 24cd757ef..33771059e 100644
--- a/meta_configurator/src/utility/data-export/dataExportServiceHandlebars.ts
+++ b/meta_configurator/src/utility/data-export/dataExportServiceHandlebars.ts
@@ -15,7 +15,7 @@ Handlebars.registerHelper('default', (value: any, defaultValue: any) =>
   value !== undefined && value !== null && value !== '' ? value : defaultValue
 );
 
-Handlebars.registerHelper('exists', function (value: any, options: any) {
+Handlebars.registerHelper('exists', function (this: any, value: any, options: any) {
   const currentContext: any = this;
   return value !== undefined && value !== null && value !== ''
     ? options.fn(currentContext)
@@ -24,7 +24,7 @@ Handlebars.registerHelper('exists', function (value: any, options: any) {
 
 Handlebars.registerHelper(
   'compare',
-  function (left: any, operator: string, right: any, options: any) {
+  function (this: any, left: any, operator: string, right: any, options: any) {
     const currentContext: any = this;
     let result = false;
     switch (operator) {
diff --git a/meta_configurator/src/utility/documentation/__tests__/schemaToMarkdown.test.ts b/meta_configurator/src/utility/documentation/__tests__/schemaToMarkdown.test.ts
index f655ad0db..6165c40d8 100644
--- a/meta_configurator/src/utility/documentation/__tests__/schemaToMarkdown.test.ts
+++ b/meta_configurator/src/utility/documentation/__tests__/schemaToMarkdown.test.ts
@@ -64,7 +64,10 @@ describe('schemaToMarkdown samples coverage', async () => {
 
       const schema: TopLevelSchema = JSON.parse(schemaJson);
       const schemaPreprocessed = preprocessOneTime(schema);
-      const title = schemaPreprocessed.title ?? 'Untitled schema';
+      const title =
+        typeof schemaPreprocessed === 'object' && schemaPreprocessed !== null
+          ? schemaPreprocessed.title ?? 'Untitled schema'
+          : 'Untitled schema';
       const schemaGraph = constructSchemaGraph(
         schemaPreprocessed,
         useSettings().value.documentation.mergeAllOfs
diff --git a/meta_configurator/src/utility/fileDialogUtils.ts b/meta_configurator/src/utility/fileDialogUtils.ts
new file mode 100644
index 000000000..4d266b277
--- /dev/null
+++ b/meta_configurator/src/utility/fileDialogUtils.ts
@@ -0,0 +1,43 @@
+import {useFileDialog} from '@vueuse/core';
+
+type FileSelectionHandler = (files: FileList) => void;
+
+export function createLazySingleFileDialog(accept: string, openDelayMs: number = 3) {
+  let currentHandler: FileSelectionHandler | undefined;
+  let dialog:
+    | {
+        open: () => void;
+        onChange: (handler: (files: FileList | null) => void) => void;
+        reset: () => void;
+      }
+    | undefined;
+
+  function ensureDialog() {
+    if (!dialog) {
+      const {open, onChange, reset} = useFileDialog({
+        accept,
+        multiple: false,
+      });
+
+      onChange((files: FileList | null) => {
+        if (files && files.length > 0) {
+          currentHandler?.(files);
+        }
+        reset();
+      });
+
+      dialog = {open, onChange, reset};
+    }
+    return dialog;
+  }
+
+  return {
+    openForSelection(handler: FileSelectionHandler) {
+      currentHandler = handler;
+      const {open} = ensureDialog();
+      setTimeout(() => {
+        open();
+      }, openDelayMs);
+    },
+  };
+}
diff --git a/meta_configurator/src/utility/readFileContent.ts b/meta_configurator/src/utility/readFileContent.ts
index 677159533..653d2e544 100644
--- a/meta_configurator/src/utility/readFileContent.ts
+++ b/meta_configurator/src/utility/readFileContent.ts
@@ -35,6 +35,9 @@ async function readFileContentFromFileList(
     return Promise.reject(new Error('Please select exactly one file'));
   }
   const file = files[0];
+  if (!file) {
+    return Promise.reject(new Error('Please select exactly one file'));
+  }
   const fileContentAsString = readFileContent(file);
 
   if (parseInput) {
@@ -99,6 +102,6 @@ export function readFileContentForFunction(
       }
     })
     .catch(error => {
-      errorService.onError(error);
+      useErrorService().onError(error);
     });
 }
diff --git a/meta_configurator/src/utility/toastService.ts b/meta_configurator/src/utility/toastService.ts
index 25e0a2b54..34a1b4caf 100644
--- a/meta_configurator/src/utility/toastService.ts
+++ b/meta_configurator/src/utility/toastService.ts
@@ -18,6 +18,10 @@ export class ToastService implements ToastServiceMethods {
   removeGroup(group: string): void {
     this.toast?.removeGroup(group);
   }
+
+  remove(message: ToastMessageOptions): void {
+    this.toast?.remove(message);
+  }
 }
 
 export const toastService = new ToastService();
diff --git a/meta_configurator/src/utility/trimData.ts b/meta_configurator/src/utility/trimData.ts
index fa30fda6b..0ad86abbe 100644
--- a/meta_configurator/src/utility/trimData.ts
+++ b/meta_configurator/src/utility/trimData.ts
@@ -73,6 +73,9 @@ function trimDataToNPropertiesPerObject(data: any, n: number): any {
     const keys = Object.keys(data);
     for (let i = 0; i < Math.min(n, keys.length); i++) {
       const key = keys[i];
+      if (key === undefined) {
+        continue;
+      }
       newObject[key] = trimDataToNPropertiesPerObject(data[key], n);
     }
     return newObject;
diff --git a/meta_configurator/src/vue-shim.d.ts b/meta_configurator/src/vue-shim.d.ts
new file mode 100644
index 000000000..939fef480
--- /dev/null
+++ b/meta_configurator/src/vue-shim.d.ts
@@ -0,0 +1,4 @@
+declare module '*.vue' {
+  const component: any;
+  export default component;
+}
diff --git a/meta_configurator/src/vue-shim.ts b/meta_configurator/src/vue-shim.ts
deleted file mode 100644
index 8f6f41026..000000000
--- a/meta_configurator/src/vue-shim.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-declare module '*.vue' {
-  import Vue from 'vue';
-  export default Vue;
-}
diff --git a/meta_configurator/src/workers/validationWorker.ts b/meta_configurator/src/workers/validationWorker.ts
index 64d292b51..8f13d183b 100644
--- a/meta_configurator/src/workers/validationWorker.ts
+++ b/meta_configurator/src/workers/validationWorker.ts
@@ -17,7 +17,6 @@ interface ValidationWorkerResponse {
   taskId: string;
 }
 
-import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
 import {ValidationResult} from '@/schema/validationUtils';