diff --git a/mycore-base/src/main/java/org/mycore/common/config/MCRConfiguration2.java b/mycore-base/src/main/java/org/mycore/common/config/MCRConfiguration2.java
index 4ee8bd1048..c2efb0d674 100644
--- a/mycore-base/src/main/java/org/mycore/common/config/MCRConfiguration2.java
+++ b/mycore-base/src/main/java/org/mycore/common/config/MCRConfiguration2.java
@@ -26,7 +26,6 @@
 import java.util.UUID;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutionException;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Function;
 import java.util.function.Predicate;
@@ -35,18 +34,15 @@
 import java.util.stream.Stream;
 
 import org.mycore.common.MCRClassTools;
-import org.mycore.common.MCRException;
+import org.mycore.common.config.instantiator.MCREmptyTree;
 import org.mycore.common.config.instantiator.MCRInstanceConfiguration;
 import org.mycore.common.config.instantiator.MCRInstanceConfiguration.Options;
 import org.mycore.common.config.instantiator.MCRInstanceName;
 import org.mycore.common.config.instantiator.MCRInstantiatorUtils;
+import org.mycore.common.config.instantiator.MCRProperTree;
+import org.mycore.common.config.instantiator.MCRPropertiesTree;
 import org.mycore.common.function.MCRTriConsumer;
 
-import com.google.common.base.Throwables;
-import com.google.common.cache.Cache;
-import com.google.common.cache.CacheBuilder;
-import com.google.common.util.concurrent.UncheckedExecutionException;
-
 import jakarta.inject.Singleton;
 
 /**
@@ -101,15 +97,10 @@ public class MCRConfiguration2 {
 
     private static final Map<UUID, EventListener> LISTENERS = new ConcurrentHashMap<>();
 
-    private static final int CONFIGURATIONS_CACHE_SIZE = 32;
-
-    private static final Cache<ConfigurationKey, MCRInstanceConfiguration<?>> CONFIGURATIONS = CacheBuilder.newBuilder()
-        .maximumSize(CONFIGURATIONS_CACHE_SIZE)
-        .softValues()
-        .build();
-
     private static final AtomicReference<Map<String, String>> PROPERTIES = new AtomicReference<>(Map.of());
 
+    private static final AtomicReference<MCRProperTree> PROPER_TREE = new AtomicReference<>(MCRPropertiesTree.EMPTY);
+
     static Map<SingletonKey, Object> instanceHolder = new MCRConcurrentHashMap<>();
 
     /**
@@ -139,6 +130,19 @@ public static Map<String, String> getAllPropertiesMap() {
         });
     }
 
+    /**
+     * Returns all configuration properties, excluding properties with blank values, i.e.
+     * only properties that are recognized by, for example, {@link #getString(String)} as a tree.
+     */
+    public static MCRProperTree getAllPropertiesTree() {
+        return PROPER_TREE.updateAndGet(existingValue -> {
+            if (existingValue instanceof MCREmptyTree) {
+                return MCRPropertiesTree.ofProperties(getAllPropertiesMap());
+            }
+            return existingValue;
+        });
+    }
+
     /**
      * @deprecated Use {@link MCRConfigurationBase#getSubpropertiesMap(String)} as one-to-one-replacement
      * or {@link #getSubpropertiesMap(String)} as an alternative version that is better aligned with
@@ -257,16 +261,8 @@ private static <S> Optional<S> createSingleInstanceOf(MCRInstanceConfiguration<S
         return Optional.ofNullable((S) instanceHolder.computeIfAbsent(key, _ -> configuration.instantiate()));
     }
 
-    @SuppressWarnings({ "unchecked", "PMD.PreserveStackTrace" })
     private static <S> MCRInstanceConfiguration<S> getConfiguration(Class<S> superClass, String name) {
-        try {
-            return ((MCRInstanceConfiguration<S>) CONFIGURATIONS.get(
-                new ConfigurationKey(superClass.getName(), name),
-                () -> MCRInstanceConfiguration.ofName(superClass, name, Options.IMPLICIT))).copy();
-        } catch (ExecutionException | UncheckedExecutionException e) {
-            Throwables.throwIfUnchecked(e.getCause());
-            throw new MCRException("Failed to create instance configuration for " + name, e.getCause());
-        }
+        return MCRInstanceConfiguration.ofName(superClass, name, getAllPropertiesTree(), Options.IMPLICIT);
     }
 
     /**
@@ -508,8 +504,8 @@ public static boolean removePropertyChangeEventListener(UUID uuid) {
     }
 
     public static <S> S instantiateClass(Class<S> superClass, String className) {
-        return MCRInstanceConfiguration.ofClassName(superClass, className, "MCR.AnonymousInstance." + className)
-            .instantiate();
+        return MCRInstanceConfiguration.ofClassName(superClass, className, "MCR.AnonymousInstance." + className,
+            getAllPropertiesTree()).instantiate();
     }
 
     public static <S> Stream<S> instantiateClasses(Class<S> superClass, String propertyName) {
@@ -528,10 +524,10 @@ private static <T> Class<? extends T> getClassObject(String classname) {
     }
 
     static void clearCaches() {
-        // BEWARE: do NOT replace with constant value, i.e. do NOT replace with PROPERTIES.set(Map.of());
+        // BEWARE: do NOT replace with constant values, i.e. do NOT replace with PROPERTIES.set(Map.of());
         // AtomicReference#updateAndGet only works as expected, when each update sets a distinct value
         PROPERTIES.set(new HashMap<>());
-        CONFIGURATIONS.invalidateAll();
+        PROPER_TREE.set(new MCREmptyTree());
     }
 
     private static class EventListener {
@@ -560,7 +556,4 @@ interface SingletonKey {
     record ConfigSingletonKey(String property, String classname) implements SingletonKey {
     }
 
-    record ConfigurationKey(String superclassName, String name) {
-    }
-
 }
diff --git a/mycore-base/src/main/java/org/mycore/common/config/instantiator/MCREmptyTree.java b/mycore-base/src/main/java/org/mycore/common/config/instantiator/MCREmptyTree.java
new file mode 100644
index 0000000000..31fad2f988
--- /dev/null
+++ b/mycore-base/src/main/java/org/mycore/common/config/instantiator/MCREmptyTree.java
@@ -0,0 +1,50 @@
+package org.mycore.common.config.instantiator;
+
+import java.util.Map;
+import java.util.stream.Stream;
+
+import org.mycore.common.log.MCRTreeMessage;
+
+public class MCREmptyTree implements MCRProperTree {
+
+    @Override
+    public String value() {
+        return "";
+    }
+
+    @Override
+    public Stream<String> keys() {
+        return Stream.empty();
+    }
+
+    @Override
+    public MCRProperTree nested(String key) {
+        return MCRPropertiesTree.EMPTY;
+    }
+
+    @Override
+    public MCRProperTree deeplyNested(String key) {
+        return MCRPropertiesTree.EMPTY;
+    }
+
+    @Override
+    public MCRProperTree excludeKey(String classKey) {
+        return this;
+    }
+
+    @Override
+    public Map<String, String> toProperties() {
+        return Map.of();
+    }
+
+    @Override
+    public MCRTreeMessage toTreeMessage() {
+        return new MCRTreeMessage();
+    }
+
+    @Override
+    public String toString() {
+        return "{ }";
+    }
+
+}
diff --git a/mycore-base/src/main/java/org/mycore/common/config/instantiator/MCRInstanceConfiguration.java b/mycore-base/src/main/java/org/mycore/common/config/instantiator/MCRInstanceConfiguration.java
index 2cd28b88b4..42d3edd823 100644
--- a/mycore-base/src/main/java/org/mycore/common/config/instantiator/MCRInstanceConfiguration.java
+++ b/mycore-base/src/main/java/org/mycore/common/config/instantiator/MCRInstanceConfiguration.java
@@ -19,8 +19,6 @@
 package org.mycore.common.config.instantiator;
 
 import java.lang.reflect.Modifier;
-import java.util.HashMap;
-import java.util.Map;
 import java.util.Set;
 
 import org.apache.logging.log4j.LogManager;
@@ -31,8 +29,8 @@
 import org.mycore.common.config.MCRConfigurationException;
 
 /**
- * Represents an extract of properties (obtained via {@link MCRConfiguration2#getAllPropertiesMap()}) used to
- * instantiate an object. Provides methods to extract nested configurations.
+ * Represents an extract of properties (typically {@link MCRConfiguration2#getAllPropertiesTree()}) used to
+ * instantiate an object.
  * <p>
  * Generally speaking, a configuration has a {@link MCRInstanceConfiguration#name()} that represents the
  * property key used to convey the {@link MCRInstanceConfiguration#valueClass()} of the class that should
@@ -60,18 +58,17 @@ public final class MCRInstanceConfiguration<S> {
 
     private final MCRInstanceName name;
 
-    private final Map<String, String> properties;
+    private final MCRProperTree properties;
 
-    private final Map<String, String> fullProperties;
+    private final MCRProperTree fullProperties;
 
     private MCRInstanceConfiguration(Class<S> superClass, Class<? extends S> valueClass, MCRInstanceName name,
-        Map<String, String> properties, Map<String, String> fullProperties) {
+        MCRProperTree properties, MCRProperTree fullProperties) {
         this.superClass = superClass;
         this.valueClass = valueClass;
         this.name = name;
-        this.properties = properties;
+        this.properties = properties.excludeKey(CLASS_KEY);
         this.fullProperties = fullProperties;
-        properties.remove(CLASS_KEY);
     }
 
     public boolean instantiatable() {
@@ -83,21 +80,30 @@ public S instantiate() {
     }
 
     /**
-     * Shorthand for {@link MCRInstanceConfiguration#ofClass(Class, Class, String)} that
+     * Shorthand for {@link MCRInstanceConfiguration#ofClass(Class, Class, String, MCRProperTree)} that
      * uses {@link MCRClassTools#forName(String)} to resolve the value class.
      */
     public static <S> MCRInstanceConfiguration<S> ofClassName(Class<S> superClass, String className,
-        String prefix) {
+        String prefix, MCRProperTree properties) {
         try {
             Class<? extends S> valueClass = MCRClassTools.forName(className);
-            return ofClass(superClass, valueClass, prefix);
+            return ofClass(superClass, valueClass, prefix, properties);
         } catch (ClassNotFoundException | LinkageError cause) {
             throw new MCRException("Failed to load class (" + className + ")", cause);
         }
     }
 
     /**
-     * Creates a new configuration for the given super class and value class.
+     * Shorthand for {@link MCRInstanceConfiguration#ofClass(Class, Class, String, MCRProperTree)} that
+     * uses {@link MCRConfiguration2#getAllPropertiesTree()} to obtain the properties.
+     */
+    public static <S> MCRInstanceConfiguration<S> ofClass(Class<S> superClass, Class<? extends S> valueClass,
+        String prefix) {
+        return ofClass(superClass, valueClass, prefix, MCRConfiguration2.getAllPropertiesTree());
+    }
+
+    /**
+     * Creates a new configuration for the given super class and value class based on the given properties.
      * <p>
      * Example: Given value class <code>Some.Instance.Name</code>,
      * prefix <code>Some.Instance.Name</code> and
@@ -114,34 +120,55 @@ public static <S> MCRInstanceConfiguration<S> ofClassName(Class<S> superClass, S
      *     <li><code>Key1=Value1</code></li>
      *     <li><code>Key2=Value2</code></li>
      * </ul>
+     * and {@link MCRInstanceConfiguration#fullProperties()} that are equal to the given properties.
      */
     public static <S> MCRInstanceConfiguration<S> ofClass(Class<S> superClass, Class<? extends S> valueClass,
-        String prefix) {
+        String prefix, MCRProperTree properties) {
         MCRInstanceName name = MCRInstanceName.of(prefix);
-        Map<String, String> properties = MCRConfiguration2.getAllPropertiesMap();
-        Map<String, String> reducedProperties = reduceProperties(prefix, properties);
-        return new MCRInstanceConfiguration<>(superClass, valueClass, name, reducedProperties, properties);
+        MCRProperTree nestedProperties = properties.deeplyNested(prefix);
+        return new MCRInstanceConfiguration<>(superClass, valueClass, name, nestedProperties, properties);
     }
 
     /**
-     * Shorthand for {@link MCRInstanceConfiguration#ofName(Class, MCRInstanceName, Set)} that
+     * Shorthand for {@link MCRInstanceConfiguration#ofName(Class, MCRInstanceName, MCRProperTree, Set)} that
      * creates the name with {@link MCRInstanceName#of(String)} and
+     * uses {@link MCRConfiguration2#getAllPropertiesTree()} to obtain the properties.
      * uses {@link Options#NONE} as the options.
      */
     public static <T> MCRInstanceConfiguration<T> ofName(Class<T> superClass, String name) {
-        return ofName(superClass, MCRInstanceName.of(name), Options.NONE);
+        return ofName(superClass, MCRInstanceName.of(name), MCRConfiguration2.getAllPropertiesTree(), Options.NONE);
     }
 
     /**
-     * Shorthand for {@link MCRInstanceConfiguration#ofName(Class, MCRInstanceName, Set)} that
-     * creates the name with {@link MCRInstanceName#of(String)}.
+     * Shorthand for {@link MCRInstanceConfiguration#ofName(Class, MCRInstanceName, MCRProperTree, Set)} that
+     * creates the name with {@link MCRInstanceName#of(String)} and
+     * uses {@link Options#NONE} as the options.
+     */
+    public static <T> MCRInstanceConfiguration<T> ofName(Class<T> superClass, String name,
+        MCRProperTree properties) {
+        return ofName(superClass, MCRInstanceName.of(name), properties, Options.NONE);
+    }
+
+    /**
+     * Shorthand for {@link MCRInstanceConfiguration#ofName(Class, MCRInstanceName, MCRProperTree, Set)} that
+     * creates the name with {@link MCRInstanceName#of(String)} and
+     * uses {@link MCRConfiguration2#getAllPropertiesTree()} to obtain the properties.
      */
     public static <T> MCRInstanceConfiguration<T> ofName(Class<T> superClass, String name, Set<Option> options) {
-        return ofName(superClass, MCRInstanceName.of(name), options);
+        return ofName(superClass, MCRInstanceName.of(name), MCRConfiguration2.getAllPropertiesTree(), options);
+    }
+
+    /**
+     * Shorthand for {@link MCRInstanceConfiguration#ofName(Class, MCRInstanceName, MCRProperTree, Set)} that
+     * creates the name with {@link MCRInstanceName#of(String)}.
+     */
+    public static <T> MCRInstanceConfiguration<T> ofName(Class<T> superClass, String name,
+        MCRProperTree properties, Set<Option> options) {
+        return ofName(superClass, MCRInstanceName.of(name), properties, options);
     }
 
     /**
-     * Creates a new configuration for the given super class and instance name.
+     * Creates a new configuration for the given super class and instance name based on the given properties.
      * <p>
      * Example: Given an {@link MCRInstanceName} <code>Some.Instance.Name</code> and
      * properties
@@ -161,17 +188,16 @@ public static <T> MCRInstanceConfiguration<T> ofName(Class<T> superClass, String
      * and {@link MCRInstanceConfiguration#fullProperties()} that are equal to the given properties.
      */
     public static <T> MCRInstanceConfiguration<T> ofName(Class<T> superClass, MCRInstanceName name,
-        Set<Option> options) {
-        Map<String, String> properties = MCRConfiguration2.getAllPropertiesMap();
-        Map<String, String> reducedProperties = reduceProperties(name.canonical(), properties);
-        Class<? extends T> valueClass = resolveValueClass(superClass, name, reducedProperties, options);
-        return new MCRInstanceConfiguration<>(superClass, valueClass, name, reducedProperties, properties);
+        MCRProperTree properties, Set<Option> options) {
+        MCRProperTree nestedProperties = properties.deeplyNested(name.canonical());
+        Class<? extends T> valueClass = resolveValueClass(superClass, name, nestedProperties, options);
+        return new MCRInstanceConfiguration<>(superClass, valueClass, name, nestedProperties, properties);
     }
 
     private static <S> Class<? extends S> resolveValueClass(Class<S> superClass, MCRInstanceName name,
-        Map<String, String> properties, Set<Option> options) {
+        MCRProperTree properties, Set<Option> options) {
 
-        String className = properties.get("Class");
+        String className = properties.nested(CLASS_KEY).value();
         if (className != null) {
             try {
                 return MCRClassTools.forName(className);
@@ -191,27 +217,6 @@ private static <S> Class<? extends S> resolveValueClass(Class<S> superClass, MCR
 
     }
 
-    private static Map<String, String> reduceProperties(String prefix, Map<String, String> properties) {
-
-        final String prefixWithDelimiter = prefix + '.';
-        final int prefixWithDelimiterLength = prefixWithDelimiter.length();
-
-        Map<String, String> reducedProperties = new HashMap<>();
-        for (Map.Entry<String, String> entry : properties.entrySet()) {
-            String key = entry.getKey();
-            if (!key.startsWith(prefixWithDelimiter)) {
-                continue;
-            }
-            String reducedKey = key.substring(prefixWithDelimiterLength);
-            reducedProperties.put(reducedKey, entry.getValue());
-        }
-        String directProperty = properties.get(prefix);
-        if (directProperty != null) {
-            reducedProperties.put("", directProperty);
-        }
-        return reducedProperties;
-    }
-
     public Class<S> superClass() {
         return superClass;
     }
@@ -224,16 +229,16 @@ public MCRInstanceName name() {
         return name;
     }
 
-    public Map<String, String> properties() {
+    public MCRProperTree properties() {
         return properties;
     }
 
-    public Map<String, String> fullProperties() {
+    public MCRProperTree fullProperties() {
         return fullProperties;
     }
 
     public MCRInstanceConfiguration<S> copy() {
-        return new MCRInstanceConfiguration<>(superClass, valueClass, name, new HashMap<>(properties), fullProperties);
+        return new MCRInstanceConfiguration<>(superClass, valueClass, name, properties, fullProperties);
     }
 
     @Override
@@ -242,12 +247,11 @@ public String toString() {
             "superClass=" + superClass.getName() + ", " +
             "valueClass=" + (valueClass == null ? "null" : valueClass.getName()) + ", " +
             "name=" + name + ", " +
-            "properties=" + properties + ", " +
-            "#fullProperties=" + fullProperties.size() + "}";
+            "properties=" + properties.toProperties() + "}";
     }
 
     public static <N> MCRInstanceConfiguration<N> ofComponents(Class<N> superClass, MCRInstanceName name,
-        Map<String, String> properties, Map<String, String> fullProperties) {
+        MCRProperTree properties, MCRProperTree fullProperties) {
         Class<? extends N> valueClass = resolveValueClass(superClass, name, properties, Options.IMPLICIT);
         return new MCRInstanceConfiguration<>(superClass, valueClass, name, properties, fullProperties);
     }
diff --git a/mycore-base/src/main/java/org/mycore/common/config/instantiator/MCRInstantiator.java b/mycore-base/src/main/java/org/mycore/common/config/instantiator/MCRInstantiator.java
index 6edea603b4..4ae616ca1c 100644
--- a/mycore-base/src/main/java/org/mycore/common/config/instantiator/MCRInstantiator.java
+++ b/mycore-base/src/main/java/org/mycore/common/config/instantiator/MCRInstantiator.java
@@ -84,7 +84,6 @@ private MCRInstantiator() {
     }
 
     static <S> S instantiate(MCRInstanceConfiguration<S> configuration) throws MCRConfigurationException {
-
         Class<S> superClass = configuration.superClass();
 
         if (configuration.valueClass() == null) {
@@ -99,7 +98,6 @@ static <S> S instantiate(MCRInstanceConfiguration<S> configuration) throws MCRCo
         }
 
         return superClass.cast(instance);
-
     }
 
     @SuppressWarnings("unchecked")
diff --git a/mycore-base/src/main/java/org/mycore/common/config/instantiator/MCRProperTree.java b/mycore-base/src/main/java/org/mycore/common/config/instantiator/MCRProperTree.java
new file mode 100644
index 0000000000..7e0c290c5f
--- /dev/null
+++ b/mycore-base/src/main/java/org/mycore/common/config/instantiator/MCRProperTree.java
@@ -0,0 +1,51 @@
+/*
+ * This file is part of ***  M y C o R e  ***
+ * See https://www.mycore.de/ for details.
+ *
+ * MyCoRe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * MyCoRe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with MyCoRe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.mycore.common.config.instantiator;
+
+import java.util.Map;
+import java.util.stream.Stream;
+
+import org.mycore.common.log.MCRTreeMessage;
+
+/**
+ * A {@link MCRProperTree} is an immutable tree of configuration properties with dot-separated keys
+ * that is used by {@link MCRInstantiator} during instantiation of configured classes.
+ * <p>
+ * The value of a tree node can be obtained with {@link MCRProperTree#value()}. Nested tree nodes
+ * can be obtained with {@link MCRProperTree#nested(String)} and {@link MCRProperTree#deeplyNested(String)}.
+ * The first method expects a single-level-key like <code>Foo</code>, while the latter method supports nested
+ * keys like <code>Foo.Bar.Baz</code>.
+ */
+public interface MCRProperTree {
+
+    String value();
+
+    Stream<String> keys();
+
+    MCRProperTree nested(String key);
+
+    MCRProperTree deeplyNested(String key);
+
+    MCRProperTree excludeKey(String classKey);
+
+    Map<String, String> toProperties();
+
+    MCRTreeMessage toTreeMessage();
+
+}
diff --git a/mycore-base/src/main/java/org/mycore/common/config/instantiator/MCRPropertiesTree.java b/mycore-base/src/main/java/org/mycore/common/config/instantiator/MCRPropertiesTree.java
new file mode 100644
index 0000000000..45a8b89544
--- /dev/null
+++ b/mycore-base/src/main/java/org/mycore/common/config/instantiator/MCRPropertiesTree.java
@@ -0,0 +1,197 @@
+/*
+ * This file is part of ***  M y C o R e  ***
+ * See https://www.mycore.de/ for details.
+ *
+ * MyCoRe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * MyCoRe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with MyCoRe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.mycore.common.config.instantiator;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import org.mycore.common.log.MCRTreeMessage;
+
+/**
+ * A {@link MCRPropertiesTree} is an immutable tree of configuration properties with dot-separated keys
+ * that is used by {@link MCRInstantiator} during instantiation of configured classes.
+ * <p>
+ * The value of a tree node can be obtained with {@link MCRPropertiesTree#value()}. Nested tree nodes
+ * can be obtained with {@link MCRPropertiesTree#nested(String)} and {@link MCRPropertiesTree#deeplyNested(String)}.
+ * The first method expects a single-level-key like <code>Foo</code>, while the latter method supports nested
+ * keys like <code>Foo.Bar.Baz</code>.
+ */
+public final class MCRPropertiesTree implements MCRProperTree {
+
+    public static final MCRPropertiesTree EMPTY = new MCRPropertiesTree(null, Map.of());
+
+    private static final Function<String, Object> HASH_MAP = _ -> new HashMap<>();
+
+    private final String value;
+
+    private final Map<String, MCRPropertiesTree> nested;
+
+    private MCRPropertiesTree(String value, Map<String, MCRPropertiesTree> nested) {
+        this.value = value;
+        this.nested = nested;
+    }
+
+    @Override
+    public String value() {
+        return value;
+    }
+
+    @Override
+    public Stream<String> keys() {
+        return nested.keySet().stream();
+    }
+
+    @Override
+    public MCRPropertiesTree nested(String key) {
+        return nested.getOrDefault(key, EMPTY);
+    }
+
+    @Override
+    public MCRPropertiesTree deeplyNested(String key) {
+        MCRPropertiesTree tree = this;
+        int startIndex = 0;
+        int nextDotIndex = key.indexOf('.', startIndex);
+        while (nextDotIndex != -1) {
+            tree = tree.nested(key.substring(startIndex, nextDotIndex));
+            startIndex = nextDotIndex + 1;
+            nextDotIndex = key.indexOf('.', startIndex);
+        }
+        return tree.nested(key.substring(startIndex));
+    }
+
+    @Override
+    public MCRProperTree excludeKey(String excludedKey) {
+        if (this.nested.containsKey(excludedKey)) {
+            Map<String, MCRPropertiesTree> nestedWithoutExcludedKey = new HashMap<>(this.nested);
+            nestedWithoutExcludedKey.remove(excludedKey);
+            return new MCRPropertiesTree(value, nestedWithoutExcludedKey);
+        } else {
+            return this;
+        }
+    }
+
+    @Override
+    public Map<String, String> toProperties() {
+        Map<String, String> properties = new HashMap<>();
+        if (value != null) {
+            properties.put("", value);
+        }
+        for (Map.Entry<String, MCRPropertiesTree> nestedEntry : nested.entrySet()) {
+            nestedEntry.getValue().putProperties(properties, nestedEntry.getKey());
+        }
+        return properties;
+    }
+
+    private void putProperties(Map<String, String> properties, String prefix) {
+        if (value != null) {
+            properties.put(prefix, value);
+        }
+        for (Map.Entry<String, MCRPropertiesTree> nestedEntry : nested.entrySet()) {
+            nestedEntry.getValue().putProperties(properties, prefix + "." + nestedEntry.getKey());
+        }
+    }
+
+    @Override
+    public MCRTreeMessage toTreeMessage() {
+        MCRTreeMessage treeMessage = new MCRTreeMessage();
+        sortedEntries().forEach(entry -> {
+            MCRPropertiesTree nestedTree = entry.getValue();
+            treeMessage.add(entry.getKey(), nestedTree.value, nestedTree.toTreeMessage());
+        });
+        return treeMessage;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder();
+        appendTo(builder);
+        return builder.toString();
+    }
+
+    private void appendTo(StringBuilder builder) {
+        builder.append('{');
+        if (value != null) {
+            builder.append(' ').append(value);
+        }
+        builder.append(' ');
+        if (!nested.isEmpty()) {
+            builder.append('|');
+            sortedEntries().forEach(entry -> {
+                builder.append(' ').append(entry.getKey()).append('=');
+                entry.getValue().appendTo(builder);
+            });
+            builder.append(' ');
+        }
+        builder.append('}');
+    }
+
+    private Stream<Map.Entry<String, MCRPropertiesTree>> sortedEntries() {
+        return nested.entrySet().stream().sorted(Map.Entry.comparingByKey());
+    }
+
+    public static MCRPropertiesTree of(String value) {
+        return new MCRPropertiesTree(value, Map.of());
+    }
+
+    public static MCRPropertiesTree ofProperties(Map<String, String> properties) {
+        return toTree(toNestedMap(properties));
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Map<String, Object> toNestedMap(Map<String, String> properties) {
+        Map<String, Object> root = new HashMap<>();
+        for (Map.Entry<String, String> entry : properties.entrySet()) {
+            String key = entry.getKey();
+            Map<String, Object> current = root;
+            String value = entry.getValue();
+            if (!value.isBlank()) {
+                String trimmedValue = value.trim();
+                if (key.isEmpty()) {
+                    root.put(null, trimmedValue);
+                } else {
+                    int startIndex = 0;
+                    int nextDotIndex = key.indexOf('.', startIndex);
+                    while (nextDotIndex != -1) {
+                        String keyPart = key.substring(startIndex, nextDotIndex);
+                        current = (Map<String, Object>) current.computeIfAbsent(keyPart, HASH_MAP);
+                        startIndex = nextDotIndex + 1;
+                        nextDotIndex = key.indexOf('.', startIndex);
+                    }
+                    String lastKeyPart = key.substring(startIndex);
+                    ((Map<String, Object>) current.computeIfAbsent(lastKeyPart, HASH_MAP)).put(null, trimmedValue);
+                }
+            }
+        }
+        return root;
+    }
+
+    @SuppressWarnings("unchecked")
+    private static MCRPropertiesTree toTree(Map<String, Object> map) {
+        Map<String, MCRPropertiesTree> nested = new HashMap<>();
+        map.forEach((key, value) -> {
+            if (key != null) {
+                nested.put(key, toTree((Map<String, Object>) value));
+            }
+        });
+        return new MCRPropertiesTree((String) map.get(null), nested);
+    }
+
+}
diff --git a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRClassPropertyExtractor.java b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRClassPropertyExtractor.java
index 6c1e8983ff..8c18244659 100644
--- a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRClassPropertyExtractor.java
+++ b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRClassPropertyExtractor.java
@@ -18,9 +18,8 @@
 
 package org.mycore.common.config.instantiator.source;
 
-import java.util.Map;
-
 import org.mycore.common.MCRClassTools;
+import org.mycore.common.config.instantiator.MCRProperTree;
 
 /**
  * A {@link MCRClassPropertyExtractor} is a {@link MCRValueExtractor} that uses
@@ -35,10 +34,9 @@ final class MCRClassPropertyExtractor implements MCRValueExtractor<Class<?>> {
     }
 
     @Override
-    public Class<?> toValue(MCRSourceContext context, Map<String, String> properties,
-        Map<String, String> fullProperties) {
+    public Class<?> toValue(MCRSourceContext context, MCRProperTree properties, MCRProperTree fullProperties) {
 
-        String className = properties.get("");
+        String className = properties.value();
 
         if (className == null) {
             return null;
diff --git a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRInstanceExtractor.java b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRInstanceExtractor.java
index 7dab3261d3..6067ecdab4 100644
--- a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRInstanceExtractor.java
+++ b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRInstanceExtractor.java
@@ -18,12 +18,11 @@
 
 package org.mycore.common.config.instantiator.source;
 
-import java.util.Map;
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.mycore.common.config.instantiator.MCRInstanceConfiguration;
 import org.mycore.common.config.instantiator.MCRInstanceName;
+import org.mycore.common.config.instantiator.MCRProperTree;
 
 /**
  * A {@link MCRInstanceExtractor} is a {@link MCRValueExtractor} that uses
@@ -40,8 +39,7 @@ final class MCRInstanceExtractor implements MCRValueExtractor<Object> {
     }
 
     @Override
-    public Object toValue(MCRSourceContext context, Map<String, String> properties,
-        Map<String, String> fullProperties) {
+    public Object toValue(MCRSourceContext context, MCRProperTree properties, MCRProperTree fullProperties) {
 
         MCRInstanceConfiguration<?> configuration = MCRInstanceConfiguration.ofComponents(
             superClass, MCRInstanceName.of(context.property()), properties, fullProperties);
diff --git a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRPropertyExtractor.java b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRPropertyExtractor.java
index bd68ed8584..df3bc8bf66 100644
--- a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRPropertyExtractor.java
+++ b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRPropertyExtractor.java
@@ -18,7 +18,7 @@
 
 package org.mycore.common.config.instantiator.source;
 
-import java.util.Map;
+import org.mycore.common.config.instantiator.MCRProperTree;
 
 /**
  * A {@link MCRPropertyExtractor} is a {@link MCRValueExtractor} that extracts
@@ -27,10 +27,9 @@
 final class MCRPropertyExtractor implements MCRValueExtractor<String> {
 
     @Override
-    public String toValue(MCRSourceContext context, Map<String, String> properties,
-        Map<String, String> fullProperties) {
+    public String toValue(MCRSourceContext context, MCRProperTree properties, MCRProperTree fullProperties) {
 
-        return properties.get("");
+        return properties.value();
 
     }
 
diff --git a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRRawPropertiesSource.java b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRRawPropertiesSource.java
index b57c8d6090..ef06bfbc26 100644
--- a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRRawPropertiesSource.java
+++ b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRRawPropertiesSource.java
@@ -18,7 +18,6 @@
 
 package org.mycore.common.config.instantiator.source;
 
-import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 
@@ -26,6 +25,7 @@
 import org.mycore.common.config.annotation.MCRRawProperties;
 import org.mycore.common.config.instantiator.MCRInstanceConfiguration;
 import org.mycore.common.config.instantiator.MCRInstantiatorUtils;
+import org.mycore.common.config.instantiator.MCRProperTree;
 import org.mycore.common.config.instantiator.target.MCRTarget;
 
 /**
@@ -35,17 +35,20 @@ final class MCRRawPropertiesSource implements MCRSource {
 
     private final MCRRawProperties annotation;
 
-    private final String prefix;
+    private final PatternHandler patternHandler;
 
     MCRRawPropertiesSource(MCRRawProperties annotation) {
         this.annotation = annotation;
-        String namePattern = annotation.namePattern();
+        this.patternHandler = toPatternHandler(annotation.namePattern());
+    }
+
+    private static PatternHandler toPatternHandler(String namePattern) {
         if (namePattern.equals("*")) {
-            this.prefix = "";
+            return new RootPatternHandler();
         } else if (namePattern.endsWith(".*")) {
-            this.prefix = namePattern.substring(0, namePattern.length() - 1);
+            return new NestedPatternHandler(namePattern);
         } else {
-            throw new MCRConfigurationException("Unsupported name pattern:" + annotation.namePattern());
+            throw new MCRConfigurationException("Unsupported name pattern:" + namePattern);
         }
     }
 
@@ -72,17 +75,11 @@ public Class<?> valueClass() {
     @Override
     public Map<String, String> get(MCRInstanceConfiguration<?> configuration, MCRTarget target) {
 
-        Map<String, String> properties =
-            annotation.absolute() ? configuration.fullProperties() : configuration.properties();
-
-        Map<String, String> filteredProperties = new HashMap<>();
-        properties.forEach((key, value) -> {
-            if (key.startsWith(prefix)) {
-                filteredProperties.put(key.substring(prefix.length()), value);
-            }
-        });
+        MCRProperTree properties = annotation.absolute() ? configuration.fullProperties() : configuration.properties();
+        Map<String, String> rawProperties = patternHandler.findTree(properties).toProperties();
+        patternHandler.prepareRawProperties(rawProperties);
 
-        if (filteredProperties.isEmpty() && annotation.required()) {
+        if (rawProperties.isEmpty() && annotation.required()) {
             String property;
             String description;
             if (annotation.absolute()) {
@@ -95,7 +92,48 @@ public Map<String, String> get(MCRInstanceConfiguration<?> configuration, MCRTar
             throw MCRInstantiatorUtils.emptyRawException(property, target, description);
         }
 
-        return filteredProperties;
+        return rawProperties;
+
+    }
+
+    private sealed interface PatternHandler permits RootPatternHandler, NestedPatternHandler {
+
+        MCRProperTree findTree(MCRProperTree properties);
+
+        void prepareRawProperties(Map<String, String> rawProperties);
+
+    }
+
+    private static final class RootPatternHandler implements PatternHandler {
+
+        @Override
+        public MCRProperTree findTree(MCRProperTree properties) {
+            return properties;
+        }
+
+        @Override
+        public void prepareRawProperties(Map<String, String> rawProperties) {
+            rawProperties.remove(MCRInstanceConfiguration.CLASS_KEY);
+        }
+
+    }
+
+    private static final class NestedPatternHandler implements PatternHandler {
+
+        private final String key;
+
+        private NestedPatternHandler(String namePattern) {
+            this.key = namePattern.substring(0, namePattern.length() - 2);
+        }
+
+        @Override
+        public MCRProperTree findTree(MCRProperTree properties) {
+            return properties.deeplyNested(key);
+        }
+
+        @Override
+        public void prepareRawProperties(Map<String, String> rawProperties) {
+        }
 
     }
 
diff --git a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRSourceBase.java b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRSourceBase.java
index cf15dd2ab5..4ad8d046ed 100644
--- a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRSourceBase.java
+++ b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRSourceBase.java
@@ -18,17 +18,13 @@
 
 package org.mycore.common.config.instantiator.source;
 
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.mycore.common.config.MCRConfigurationException;
 import org.mycore.common.config.annotation.MCRSentinel;
 import org.mycore.common.config.instantiator.MCRInstanceConfiguration;
 import org.mycore.common.config.instantiator.MCRInstantiatorUtils;
+import org.mycore.common.config.instantiator.MCRProperTree;
 import org.mycore.common.config.instantiator.target.MCRTarget;
 
 /**
@@ -59,7 +55,7 @@ abstract sealed class MCRSourceBase<Result> implements MCRSource permits MCRValu
     public final Result get(MCRInstanceConfiguration<?> configuration, MCRTarget target) {
 
         String name = name();
-        Map<String, String> fullProperties = configuration.fullProperties();
+        MCRProperTree fullProperties = configuration.fullProperties();
 
         MCRSourceContext context;
         Result result;
@@ -70,13 +66,13 @@ public final Result get(MCRInstanceConfiguration<?> configuration, MCRTarget tar
 
         if (absoluteName()) {
             context = new MCRSourceContext(target, name, "absolute " + description());
-            result = getResult(context, reduceProperties(fullProperties, name), fullProperties);
+            result = getResult(context, fullProperties.deeplyNested(name), fullProperties);
         } else if (name.isEmpty()) {
             context = new MCRSourceContext(target, configuration.name().canonical(), description());
             result = getResult(context, configuration.properties(), fullProperties);
         } else {
             context = new MCRSourceContext(target, configuration.name().canonical() + "." + name, description());
-            result = getResult(context, reduceProperties(configuration.properties(), name), fullProperties);
+            result = getResult(context, configuration.properties().deeplyNested(name), fullProperties);
         }
         if (logger.isDebugEnabled() && isMissingResult(result)) {
             logger.debug(context.missingValueMessage(target));
@@ -85,7 +81,7 @@ public final Result get(MCRInstanceConfiguration<?> configuration, MCRTarget tar
         String defaultName = defaultName();
         if (isMissingResult(result) && !defaultName.isEmpty()) {
             context = new MCRSourceContext(target, defaultName, "default " + description());
-            result = getResult(context, reduceProperties(fullProperties, defaultName), fullProperties);
+            result = getResult(context, fullProperties.deeplyNested(defaultName), fullProperties);
             if (logger.isDebugEnabled() && isMissingResult(result)) {
                 logger.debug(context.missingValueMessage(target));
             }
@@ -99,42 +95,6 @@ public final Result get(MCRInstanceConfiguration<?> configuration, MCRTarget tar
 
     }
 
-    protected static Map<String, String> reduceProperties(Map<String, String> properties, String prefix) {
-
-        final String prefixWithDelimiter = prefix + '.';
-        final int prefixWithDelimiterLength = prefixWithDelimiter.length();
-
-        Map<String, String> reducedProperties = new HashMap<>();
-        for (Map.Entry<String, String> entry : properties.entrySet()) {
-            String key = entry.getKey();
-            if (!key.startsWith(prefixWithDelimiter)) {
-                continue;
-            }
-            String reducedKey = key.substring(prefixWithDelimiterLength);
-            reducedProperties.put(reducedKey, entry.getValue());
-        }
-        String directProperty = properties.get(prefix);
-        if (directProperty != null) {
-            reducedProperties.put("", directProperty);
-        }
-        return reducedProperties;
-    }
-
-    protected static Set<String> nextNestedKeys(Map<String, String> properties) {
-        Set<String> keys = new HashSet<>();
-        properties.keySet().forEach((key) -> {
-            if (!key.isEmpty()) {
-                int index = key.indexOf('.');
-                if (index == -1) {
-                    keys.add(key);
-                } else {
-                    keys.add(key.substring(0, index));
-                }
-            }
-        });
-        return keys;
-    }
-
     protected abstract String description();
 
     protected abstract String name();
@@ -145,8 +105,8 @@ protected static Set<String> nextNestedKeys(Map<String, String> properties) {
 
     protected abstract boolean absoluteName();
 
-    protected abstract Result getResult(MCRSourceContext context, Map<String, String> properties,
-        Map<String, String> fullProperties);
+    protected abstract Result getResult(MCRSourceContext context, MCRProperTree properties,
+        MCRProperTree fullProperties);
 
     protected abstract boolean required();
 
@@ -156,12 +116,11 @@ protected abstract Result getResult(MCRSourceContext context, Map<String, String
 
     protected abstract Result missingResultReplacement();
 
-    protected final boolean rejectedBySentinel(MCRSourceContext context,
-        Map<String, String> properties) {
+    protected final boolean rejectedBySentinel(MCRSourceContext context, MCRProperTree properties) {
 
         if (sentinel != null) {
             boolean sentinelValue = sentinel.defaultValue();
-            String configuredSentinelValue = properties.get(sentinel.name());
+            String configuredSentinelValue = properties.nested(sentinel.name()).value();
             if (configuredSentinelValue != null) {
                 sentinelValue = Boolean.parseBoolean(configuredSentinelValue);
             }
@@ -180,4 +139,8 @@ protected final boolean rejectedBySentinel(MCRSourceContext context,
 
     }
 
+    protected final MCRProperTree filterProperties(MCRProperTree properties) {
+        return sentinel != null ? properties.excludeKey(sentinel.name()) : properties;
+    }
+
 }
diff --git a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRSourceContext.java b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRSourceContext.java
index 13d72c728b..3c093bafbe 100644
--- a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRSourceContext.java
+++ b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRSourceContext.java
@@ -19,11 +19,8 @@
 package org.mycore.common.config.instantiator.source;
 
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.List;
 import java.util.Locale;
-import java.util.SortedMap;
-import java.util.TreeMap;
 
 import org.mycore.common.config.MCRConfigurationException;
 import org.mycore.common.config.instantiator.MCRInstantiatorUtils;
@@ -76,25 +73,6 @@ public MCRSourceContext withHint(String hint) {
         return new MCRSourceContext(target, property, description, hints);
     }
 
-    public List<String> orderedIntegerKeys(Collection<String> keys) {
-
-        SortedMap<Integer, String> keyMap = new TreeMap<>();
-        for (String key : keys) {
-            try {
-                Integer integerValue = Integer.parseInt(key);
-                String alreadyMappedKey = keyMap.put(integerValue, key);
-                if (alreadyMappedKey != null && !alreadyMappedKey.equals(key)) {
-                    throw inconsistentIntegerKeysException(key, alreadyMappedKey);
-                }
-            } catch (NumberFormatException exception) {
-                throw nonIntegerKeyException(key, exception);
-            }
-        }
-
-        return new ArrayList<>(keyMap.values());
-
-    }
-
     public MCRConfigurationException configurationException(String exceptionMessage) {
         return new MCRConfigurationException(exceptionMessage(exceptionMessage));
     }
diff --git a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRValueExtractor.java b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRValueExtractor.java
index bbbf843ab9..9130bf6283 100644
--- a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRValueExtractor.java
+++ b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRValueExtractor.java
@@ -18,7 +18,7 @@
 
 package org.mycore.common.config.instantiator.source;
 
-import java.util.Map;
+import org.mycore.common.config.instantiator.MCRProperTree;
 
 /**
  * A {@link MCRValueExtractor} extracts a value (of a specific type) from a configured string value.
@@ -28,6 +28,6 @@
 sealed interface MCRValueExtractor<Value> permits MCRClassPropertyExtractor, MCRInstanceExtractor,
     MCRPropertyExtractor {
 
-    Value toValue(MCRSourceContext context, Map<String, String> properties, Map<String, String> fullProperties);
+    Value toValue(MCRSourceContext context, MCRProperTree properties, MCRProperTree fullProperties);
 
 }
diff --git a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRValueListSourceBase.java b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRValueListSourceBase.java
index 98876b4132..8bdf196228 100644
--- a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRValueListSourceBase.java
+++ b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRValueListSourceBase.java
@@ -20,11 +20,15 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
+import java.util.SortedMap;
+import java.util.TreeMap;
+import java.util.stream.Stream;
 
 import org.mycore.common.config.MCRConfiguration2;
 import org.mycore.common.config.MCRConfigurationException;
 import org.mycore.common.config.annotation.MCRSentinel;
+import org.mycore.common.config.instantiator.MCRProperTree;
+import org.mycore.common.config.instantiator.MCRPropertiesTree;
 
 /**
  * A {@link MCRValueListSourceBase} is a base implementation of {@link MCRSource} that
@@ -45,18 +49,18 @@ abstract sealed class MCRValueListSourceBase<Value> extends MCRSourceBase<List<V
     }
 
     @Override
-    protected final List<Value> getResult(MCRSourceContext context, Map<String, String> properties,
-        Map<String, String> fullProperties) {
+    protected final List<Value> getResult(MCRSourceContext context, MCRProperTree properties,
+        MCRProperTree fullProperties) {
 
         List<Value> list = new ArrayList<>();
 
         int negativeKeyCount = 0;
         String elementDescription = context.description() + " element";
-        for (String key : context.orderedIntegerKeys(nextNestedKeys(properties))) {
+        for (String key : orderedKeys(context, properties.keys())) {
             MCRSourceContext nestedContext = context.nested(key, elementDescription);
-            Map<String, String> nestedProperties = reduceProperties(properties, key);
+            MCRProperTree nestedProperties = properties.nested(key);
             if (!rejectedBySentinel(nestedContext, nestedProperties)) {
-                Value value = extractor.toValue(nestedContext, nestedProperties, fullProperties);
+                Value value = extractor.toValue(nestedContext, filterProperties(nestedProperties), fullProperties);
                 if (value != null) {
                     if (key.charAt(0) == '-') {
                         negativeKeyCount++;
@@ -66,13 +70,13 @@ protected final List<Value> getResult(MCRSourceContext context, Map<String, Stri
             }
         }
 
-        String shortFormProperty = properties.get("");
+        String shortFormProperty = properties.value();
         if (supportsShortForm() && shortFormProperty != null) {
             List<Value> shortFormList = new ArrayList<>();
             int shortFormIndex = 0;
             for (String shortFormValue : parseShortFormList(shortFormProperty)) {
                 MCRSourceContext indexContext = context.withHint("at index " + shortFormIndex);
-                Value value = extractor.toValue(indexContext, Map.of("", shortFormValue), fullProperties);
+                Value value = extractor.toValue(indexContext, MCRPropertiesTree.of(shortFormValue), fullProperties);
                 if (value != null) {
                     shortFormList.add(value);
                 }
@@ -85,6 +89,25 @@ protected final List<Value> getResult(MCRSourceContext context, Map<String, Stri
 
     }
 
+    private static List<String> orderedKeys(MCRSourceContext context, Stream<String> keys) {
+
+        SortedMap<Integer, String> keyMap = new TreeMap<>();
+        keys.forEach(key -> {
+            try {
+                Integer integerValue = Integer.parseInt(key);
+                String alreadyMappedKey = keyMap.put(integerValue, key);
+                if (alreadyMappedKey != null && !alreadyMappedKey.equals(key)) {
+                    throw context.inconsistentIntegerKeysException(key, alreadyMappedKey);
+                }
+            } catch (NumberFormatException exception) {
+                throw context.nonIntegerKeyException(key, exception);
+            }
+        });
+
+        return new ArrayList<>(keyMap.values());
+
+    }
+
     protected abstract boolean supportsShortForm();
 
     private List<String> parseShortFormList(String value) {
diff --git a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRValueMapSourceBase.java b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRValueMapSourceBase.java
index 8501af3e67..fc9c113efa 100644
--- a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRValueMapSourceBase.java
+++ b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRValueMapSourceBase.java
@@ -25,6 +25,8 @@
 import org.mycore.common.config.MCRConfiguration2;
 import org.mycore.common.config.MCRConfigurationException;
 import org.mycore.common.config.annotation.MCRSentinel;
+import org.mycore.common.config.instantiator.MCRProperTree;
+import org.mycore.common.config.instantiator.MCRPropertiesTree;
 
 /**
  * A {@link MCRValueMapSourceBase} is a base implementation of {@link MCRSource} that
@@ -45,16 +47,16 @@ abstract sealed class MCRValueMapSourceBase<Value> extends MCRSourceBase<Map<Str
     }
 
     @Override
-    protected final Map<String, Value> getResult(MCRSourceContext context, Map<String, String> properties,
-        Map<String, String> fullProperties) {
+    protected final Map<String, Value> getResult(MCRSourceContext context, MCRProperTree properties,
+        MCRProperTree fullProperties) {
 
         Map<String, Value> map = new HashMap<>();
 
-        String shortFormProperty = properties.get("");
+        String shortFormProperty = properties.value();
         if (supportsShortForm() && shortFormProperty != null) {
             parseShortFormMap(shortFormProperty).forEach((key, shortFormValue) -> {
                 MCRSourceContext keyContext = context.withHint("for key " + key);
-                Value value = extractor.toValue(keyContext, Map.of("", shortFormValue), fullProperties);
+                Value value = extractor.toValue(keyContext, MCRPropertiesTree.of(shortFormValue), fullProperties);
                 if (value != null) {
                     map.put(key, value);
                 }
@@ -62,16 +64,16 @@ protected final Map<String, Value> getResult(MCRSourceContext context, Map<Strin
         }
 
         String entryDescription = context.description() + " entry";
-        for (String key : nextNestedKeys(properties)) {
+        properties.keys().forEach(key -> {
             MCRSourceContext nestedContext = context.nested(key, entryDescription);
-            Map<String, String> nestedProperties = reduceProperties(properties, key);
+            MCRProperTree nestedProperties = properties.nested(key);
             if (!rejectedBySentinel(nestedContext, nestedProperties)) {
-                Value value = extractor.toValue(nestedContext, nestedProperties, fullProperties);
+                Value value = extractor.toValue(nestedContext, filterProperties(nestedProperties), fullProperties);
                 if (value != null) {
                     map.put(key, value);
                 }
             }
-        }
+        });
 
         return map;
 
diff --git a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRValueSourceBase.java b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRValueSourceBase.java
index b6a39bcb3c..5422057c3d 100644
--- a/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRValueSourceBase.java
+++ b/mycore-base/src/main/java/org/mycore/common/config/instantiator/source/MCRValueSourceBase.java
@@ -18,10 +18,9 @@
 
 package org.mycore.common.config.instantiator.source;
 
-import java.util.Map;
-
 import org.mycore.common.config.MCRConfigurationException;
 import org.mycore.common.config.annotation.MCRSentinel;
+import org.mycore.common.config.instantiator.MCRProperTree;
 
 /**
  * A {@link MCRValueSourceBase} is a base implementation of {@link MCRSource} that
@@ -42,14 +41,14 @@ abstract sealed class MCRValueSourceBase<Value> extends MCRSourceBase<Value> per
     }
 
     @Override
-    protected final Value getResult(MCRSourceContext context, Map<String, String> properties,
-        Map<String, String> fullProperties) {
+    protected final Value getResult(MCRSourceContext context, MCRProperTree properties,
+        MCRProperTree fullProperties) {
 
         if (rejectedBySentinel(context, properties)) {
             return null;
         }
 
-        return extractor.toValue(context, properties, fullProperties);
+        return extractor.toValue(context, filterProperties(properties), fullProperties);
 
     }
 
diff --git a/mycore-base/src/main/java/org/mycore/common/log/MCRTreeMessage.java b/mycore-base/src/main/java/org/mycore/common/log/MCRTreeMessage.java
index d2adfeea7f..7561bb903e 100644
--- a/mycore-base/src/main/java/org/mycore/common/log/MCRTreeMessage.java
+++ b/mycore-base/src/main/java/org/mycore/common/log/MCRTreeMessage.java
@@ -54,7 +54,11 @@ public void add(String key, String value) {
     }
 
     public void add(String key, MCRTreeMessage message) {
-        entries.add(new NestedEntry(key, message));
+        entries.add(new NestedEntry(key, null, message));
+    }
+
+    public void add(String key, String value, MCRTreeMessage message) {
+        entries.add(new NestedEntry(key, value, message));
     }
 
     public String logMessage(String introduction) {
@@ -140,16 +144,19 @@ private static final class NestedEntry extends Entry {
 
         private final String key;
 
+        private final String value;
+
         private final MCRTreeMessage description;
 
-        private NestedEntry(String key, MCRTreeMessage description) {
+        private NestedEntry(String key, String value, MCRTreeMessage description) {
             this.key = Objects.requireNonNull(key);
+            this.value = value;
             this.description = Objects.requireNonNull(description);
         }
 
         @Override
         public void treeLines(List<Indent> prefix, List<String> lines) {
-            lines.add(prefixString(prefix) + key + ":");
+            lines.add(prefixString(prefix) + key + ":" + (value == null ? "" : " " + value));
             description.treeLines(prefix, lines);
         }
     }
diff --git a/mycore-base/src/main/java/org/mycore/frontend/cli/MCRDeveloperCommands.java b/mycore-base/src/main/java/org/mycore/frontend/cli/MCRDeveloperCommands.java
index 0735acb08e..bbfb166c78 100644
--- a/mycore-base/src/main/java/org/mycore/frontend/cli/MCRDeveloperCommands.java
+++ b/mycore-base/src/main/java/org/mycore/frontend/cli/MCRDeveloperCommands.java
@@ -42,6 +42,7 @@
 import org.mycore.common.MCRUserInformation;
 import org.mycore.common.MCRUserInformationResolver;
 import org.mycore.common.config.MCRConfiguration2;
+import org.mycore.common.config.instantiator.MCRProperTree;
 import org.mycore.common.xsl.uriresolver.MCRURIResolver;
 import org.mycore.datamodel.metadata.MCRDerivate;
 import org.mycore.datamodel.metadata.MCRMetadataManager;
@@ -119,9 +120,9 @@ public static void showProperty(String key) {
     }
 
     @MCRCommand(
-        syntax = "show properties {0}",
+        syntax = "show properties with prefix {0}",
         help = "Show configuration properties starting with key prefix {0}",
-        order = 50)
+        order = 41)
     public static void showProperties(String keyPrefix) {
         Map<String, String> values = MCRConfiguration2.getSubpropertiesMap(keyPrefix);
         if (values.isEmpty()) {
@@ -131,6 +132,28 @@ public static void showProperties(String keyPrefix) {
         }
     }
 
+    @MCRCommand(
+        syntax = "show properties tree",
+        help = "Show configuration properties as tree",
+        order = 50)
+    public static void showPropertiesTree() {
+        MCRProperTree values = MCRConfiguration2.getAllPropertiesTree();
+        if (LOGGER.isInfoEnabled()) {
+            LOGGER.info(values.toTreeMessage().logMessage("Properties tree"));
+        }
+    }
+
+    @MCRCommand(
+        syntax = "show properties tree for prefix {0}",
+        help = "Show configuration properties starting with key prefix {0} as tree",
+        order = 51)
+    public static void showPropertiesTree(String keyPrefix) {
+        MCRProperTree values = MCRConfiguration2.getAllPropertiesTree().deeplyNested(keyPrefix);
+        if (LOGGER.isInfoEnabled()) {
+            LOGGER.info(values.toTreeMessage().logMessage("Properties tree"));
+        }
+    }
+
     @MCRCommand(
         syntax = "show all properties",
         help = "Show all configuration properties",
diff --git a/mycore-base/src/test/java/org/mycore/common/config/MCRConfigurationTest.java b/mycore-base/src/test/java/org/mycore/common/config/MCRConfigurationTest.java
index 63942d8e15..c5da3779da 100644
--- a/mycore-base/src/test/java/org/mycore/common/config/MCRConfigurationTest.java
+++ b/mycore-base/src/test/java/org/mycore/common/config/MCRConfigurationTest.java
@@ -156,7 +156,7 @@ private Pair<String, String> createConflictConfiguration() {
 
         propertyA = propertyA + ".Class";
         propertyB = propertyB + ".Class";
-        
+
         LogManager.getLogger().info("Colliding Strings:");
         LogManager.getLogger().info(classNameA + " " + propertyA + " => " + a);
         LogManager.getLogger().info(classNameB + " " + propertyB + " => " + b);
diff --git a/mycore-base/src/test/java/org/mycore/common/config/MCRInstanceConfigurationTest.java b/mycore-base/src/test/java/org/mycore/common/config/MCRInstanceConfigurationTest.java
index 1450ad87dc..8151ff26b4 100644
--- a/mycore-base/src/test/java/org/mycore/common/config/MCRInstanceConfigurationTest.java
+++ b/mycore-base/src/test/java/org/mycore/common/config/MCRInstanceConfigurationTest.java
@@ -23,7 +23,8 @@
 import static org.mycore.common.config.instantiator.MCRInstanceConfiguration.ofClass;
 import static org.mycore.common.config.instantiator.MCRInstanceConfiguration.ofName;
 
-import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 import org.junit.jupiter.api.Test;
 import org.mycore.common.MCRTestConfiguration;
@@ -34,8 +35,6 @@
 @MyCoReTest
 public class MCRInstanceConfigurationTest {
 
-    private static final String TEST_CLASS = TestClass.class.getName();
-
     @Test
     @MCRTestConfiguration(properties = {
         @MCRTestProperty(key = "Foo.Bar.Class", classNameOf = TestClass.class)
@@ -60,9 +59,10 @@ public void configurationMovesEntries() {
 
         MCRInstanceConfiguration<?> configuration = ofName(Object.class, "Foo.Bar");
 
-        assertEquals("Value1", configuration.properties().get("Key1"));
-        assertEquals("Value2", configuration.properties().get("Key2"));
-        assertEquals(2, configuration.properties().size());
+        Set<String> keySet = configuration.properties().keys().collect(Collectors.toSet());
+        assertEquals("Value1", configuration.properties().nested("Key1").value());
+        assertEquals("Value2", configuration.properties().nested("Key2").value());
+        assertEquals(2, keySet.size());
 
     }
 
@@ -85,13 +85,13 @@ public void directConfiguration() {
     })
     public void directConfigurationRemovesClassEntry() {
 
-        MCRInstanceConfiguration<?> configuration =
-            ofClass(Object.class, TestClass.class, "Instance");
+        MCRInstanceConfiguration<?> configuration = ofClass(Object.class, TestClass.class, "Instance");
 
-        assertFalse(configuration.properties().containsKey("Class"));
-        assertEquals("ClassValue", configuration.properties().get("class"));
-        assertEquals("ClassValue", configuration.properties().get(""));
-        assertEquals(2, configuration.properties().size());
+        Set<String> keySet = configuration.properties().keys().collect(Collectors.toSet());
+        assertFalse(keySet.contains("Class"));
+        assertEquals("ClassValue", configuration.properties().nested("class").value());
+        assertEquals("ClassValue", configuration.properties().value());
+        assertEquals(1, keySet.size());
 
     }
 
diff --git a/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorBasicTest.java b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorBasicTest.java
index 9b5f6cdb35..28d2261aab 100644
--- a/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorBasicTest.java
+++ b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorBasicTest.java
@@ -20,7 +20,6 @@
 
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.mycore.common.config.instantiator.MCRInstanceConfiguration.ofName;
 
 import java.util.function.Supplier;
 
@@ -30,6 +29,7 @@
 import org.mycore.common.config.annotation.MCRConfigurationProxy;
 import org.mycore.common.config.annotation.MCRFactory;
 import org.mycore.common.config.instantiator.MCRInstanceConfiguration;
+import org.mycore.common.config.instantiator.MCRInstanceConfiguration.Options;
 import org.mycore.test.MyCoReTest;
 
 @MyCoReTest
@@ -42,7 +42,7 @@ public class MCRInstantiatorBasicTest {
         })
     public void singletonFactory() {
 
-        TestClassWithSingletonFactory instance = ofName(TestClassWithSingletonFactory.class, "Foo").instantiate();
+        TestClassWithSingletonFactory instance = ofName(TestClassWithSingletonFactory.class);
 
         assertNotNull(instance);
 
@@ -55,7 +55,7 @@ public void singletonFactory() {
         })
     public void annotatedFactory() {
 
-        TestClassWitAnnotatedFactory instance = ofName(TestClassWitAnnotatedFactory.class, "Foo").instantiate();
+        TestClassWitAnnotatedFactory instance = ofName(TestClassWitAnnotatedFactory.class);
 
         assertNotNull(instance);
 
@@ -69,7 +69,7 @@ public void annotatedFactory() {
     public void annotatedFactories() {
 
         assertThrows(MCRConfigurationException.class,
-            () -> ofName(TestClassWitAnnotatedFactories.class, "Foo").instantiate());
+            () -> ofName(TestClassWitAnnotatedFactories.class));
 
     }
 
@@ -80,7 +80,7 @@ public void annotatedFactories() {
         })
     public void constructorFactory() {
 
-        TestClassWithConstructor instance = ofName(TestClassWithConstructor.class, "Foo").instantiate();
+        TestClassWithConstructor instance = ofName(TestClassWithConstructor.class);
 
         assertNotNull(instance);
 
@@ -94,7 +94,7 @@ public void constructorFactory() {
     public void noConstructorOrFactory() {
 
         assertThrows(MCRConfigurationException.class,
-            () -> ofName(TestClassWithoutConstructorOrFactory.class, "Foo").instantiate());
+            () -> ofName(TestClassWithoutConstructorOrFactory.class));
 
     }
 
@@ -106,7 +106,7 @@ public void noConstructorOrFactory() {
     public void multipleFactories() {
 
         assertThrows(MCRConfigurationException.class,
-            () -> ofName(TestClassWithMultipleFactories.class, "Foo").instantiate());
+            () -> ofName(TestClassWithMultipleFactories.class));
 
     }
 
@@ -117,8 +117,7 @@ public void multipleFactories() {
         })
     public void configurationImplicit() {
 
-        ImplicitTestClass instance = ofName(ImplicitTestClass.class, "Foo",
-            MCRInstanceConfiguration.Options.IMPLICIT).instantiate();
+        ImplicitTestClass instance = ofImplicitName(ImplicitTestClass.class);
 
         assertNotNull(instance);
 
@@ -132,12 +131,20 @@ public void configurationImplicit() {
         })
     public void configurationProxy() {
 
-        TestClassWithConfigurationProxy instance = ofName(TestClassWithConfigurationProxy.class, "Foo").instantiate();
+        TestClassWithConfigurationProxy instance = ofName(TestClassWithConfigurationProxy.class);
 
         assertNotNull(instance);
 
     }
 
+    private <S> S ofName(Class<S> superClass) {
+        return MCRInstanceConfiguration.ofName(superClass, "Foo").instantiate();
+    }
+
+    private <S> S ofImplicitName(Class<S> superClass) {
+        return MCRInstanceConfiguration.ofName(superClass, "Foo", Options.IMPLICIT).instantiate();
+    }
+
     @SuppressWarnings("InstantiationOfUtilityClass")
     public static class TestClassWithSingletonFactory {
 
diff --git a/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorClassPropertyBasicTest.java b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorClassPropertyBasicTest.java
index 762ed0ba4d..df5f293e3e 100644
--- a/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorClassPropertyBasicTest.java
+++ b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorClassPropertyBasicTest.java
@@ -21,7 +21,6 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.mycore.common.config.instantiator.MCRInstanceConfiguration.ofName;
 
 import java.util.List;
 import java.util.Map;
@@ -48,7 +47,7 @@ public class MCRInstantiatorClassPropertyBasicTest {
         })
     public void classValue() {
 
-        TestClass instance = ofName(TestClass.class, "Foo").instantiate();
+        TestClass instance = ofName(TestClass.class);
 
         assertNotNull(instance);
         assertEquals(FooValue.class, instance.value);
@@ -64,7 +63,7 @@ public void classValue() {
     public void incompatibleClassValue() {
 
         MCRConfigurationException exception = assertThrows(MCRConfigurationException.class,
-            () -> MCRInstanceConfiguration.ofName(TestClass.class, "Foo").instantiate());
+            () -> ofName(TestClass.class));
 
         assertEquals("Class, configured in Foo.Value (and sub-properties thereof),"
             + " for target field 'value' in configured class " + TestClass.class.getName()
@@ -82,7 +81,7 @@ public void incompatibleClassValue() {
     public void missingClassValue() {
 
         MCRConfigurationException exception = assertThrows(MCRConfigurationException.class,
-            () -> MCRInstanceConfiguration.ofName(TestClass.class, "Foo").instantiate());
+            () -> ofName(TestClass.class));
 
         assertEquals("Class, configured in Foo.Value (and sub-properties thereof),"
             + " for target field 'value' in configured class " + TestClass.class.getName()
@@ -101,7 +100,7 @@ public void missingClassValue() {
         })
     public void classValueMap() {
 
-        TestClassWithMap instance = ofName(TestClassWithMap.class, "Foo").instantiate();
+        TestClassWithMap instance = ofName(TestClassWithMap.class);
 
         assertNotNull(instance);
         assertEquals(FooValue.class, instance.values.get("foo"));
@@ -119,7 +118,7 @@ public void classValueMap() {
     public void incompatibleClassValueInMap() {
 
         MCRConfigurationException exception = assertThrows(MCRConfigurationException.class,
-            () -> MCRInstanceConfiguration.ofName(TestClass.class, "Foo").instantiate());
+            () -> ofName(TestClass.class));
 
         assertEquals("Class map entry, configured in Foo.Values.bar (and sub-properties thereof),"
             + " for target field 'values' in configured class " + TestClassWithMap.class.getName()
@@ -138,7 +137,7 @@ public void incompatibleClassValueInMap() {
     public void missingClassValueInMap() {
 
         MCRConfigurationException exception = assertThrows(MCRConfigurationException.class,
-            () -> MCRInstanceConfiguration.ofName(TestClass.class, "Foo").instantiate());
+            () -> ofName(TestClass.class));
 
         assertEquals("Class map entry, configured in Foo.Values.bar (and sub-properties thereof),"
             + " for target field 'values' in configured class " + TestClassWithMap.class.getName()
@@ -156,7 +155,7 @@ public void missingClassValueInShortMap() {
         MCRConfiguration2.set("Foo.Values", "foo:" + FooValue.class.getName() + ",bar:" + MISSING_CLASS);
 
         MCRConfigurationException exception = assertThrows(MCRConfigurationException.class,
-            () -> MCRInstanceConfiguration.ofName(TestClass.class, "Foo").instantiate());
+            () -> ofName(TestClass.class));
 
         assertEquals("Class map (for key bar), configured in Foo.Values (and sub-properties thereof),"
             + " for target field 'values' in configured class " + TestClassWithMap.class.getName()
@@ -175,7 +174,7 @@ public void missingClassValueInShortMap() {
         })
     public void classValueList() {
 
-        TestClassWithList instance = ofName(TestClassWithList.class, "Foo").instantiate();
+        TestClassWithList instance = ofName(TestClassWithList.class);
 
         assertNotNull(instance);
         assertEquals(FooValue.class, instance.values.getFirst());
@@ -193,7 +192,7 @@ public void classValueList() {
     public void incompatibleClassValueInList() {
 
         MCRConfigurationException exception = assertThrows(MCRConfigurationException.class,
-            () -> MCRInstanceConfiguration.ofName(TestClass.class, "Foo").instantiate());
+            () -> ofName(TestClass.class));
 
         assertEquals("Class list element, configured in Foo.Values.20 (and sub-properties thereof),"
             + " for target field 'values' in configured class " + TestClassWithList.class.getName()
@@ -212,7 +211,7 @@ public void incompatibleClassValueInList() {
     public void missingClassValueInList() {
 
         MCRConfigurationException exception = assertThrows(MCRConfigurationException.class,
-            () -> MCRInstanceConfiguration.ofName(TestClass.class, "Foo").instantiate());
+            () -> ofName(TestClass.class));
 
         assertEquals("Class list element, configured in Foo.Values.20 (and sub-properties thereof),"
             + " for target field 'values' in configured class " + TestClassWithList.class.getName()
@@ -230,7 +229,7 @@ public void missingClassValueInShortList() {
         MCRConfiguration2.set("Foo.Values", FooValue.class.getName() + "," + MISSING_CLASS);
 
         MCRConfigurationException exception = assertThrows(MCRConfigurationException.class,
-            () -> MCRInstanceConfiguration.ofName(TestClass.class, "Foo").instantiate());
+            () -> ofName(TestClass.class));
 
         assertEquals("Class list (at index 1), configured in Foo.Values (and sub-properties thereof),"
             + " for target field 'values' in configured class " + TestClassWithList.class.getName()
@@ -238,6 +237,10 @@ public void missingClassValueInShortList() {
 
     }
 
+    private <S> S ofName(Class<S> superClass) {
+        return MCRInstanceConfiguration.ofName(superClass, "Foo").instantiate();
+    }
+
     public static class TestClass {
 
         @MCRClassProperty(name = "Value", superClass = Value.class)
diff --git a/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorCollectionTest.java b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorCollectionTest.java
index 272bf51335..01e709ac18 100644
--- a/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorCollectionTest.java
+++ b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorCollectionTest.java
@@ -22,7 +22,6 @@
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.mycore.common.config.instantiator.MCRInstanceConfiguration.ofName;
 
 import java.util.List;
 import java.util.Map;
@@ -49,8 +48,7 @@ public class MCRInstantiatorCollectionTest {
         })
     public void map() {
 
-        TestClassWithMap instance = ofName(TestClassWithMap.class,
-            "Foo").instantiate();
+        TestClassWithMap instance = ofName(TestClassWithMap.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map);
@@ -73,8 +71,7 @@ public void map() {
         })
     public void mapNotPresent() {
 
-        assertThrows(MCRConfigurationException.class,
-            () -> MCRInstanceConfiguration.ofName(Object.class, "Foo").instantiate());
+        assertThrows(MCRConfigurationException.class, () -> ofName(Object.class));
 
     }
 
@@ -87,8 +84,7 @@ public void mapNotPresent() {
         })
     public void optionalMap() {
 
-        TestClassWithOptionalMap instance = ofName(TestClassWithOptionalMap.class,
-            "Foo").instantiate();
+        TestClassWithOptionalMap instance = ofName(TestClassWithOptionalMap.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map);
@@ -111,8 +107,7 @@ public void optionalMap() {
         })
     public void optionalMapNotPresent() {
 
-        TestClassWithOptionalMap instance = ofName(TestClassWithOptionalMap.class,
-            "Foo").instantiate();
+        TestClassWithOptionalMap instance = ofName(TestClassWithOptionalMap.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map);
@@ -132,8 +127,7 @@ public void optionalMapNotPresent() {
         })
     public void mapWithSentinel() {
 
-        TestClassWithMapWithSentinel instance = ofName(TestClassWithMapWithSentinel.class,
-            "Foo").instantiate();
+        TestClassWithMapWithSentinel instance = ofName(TestClassWithMapWithSentinel.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map);
@@ -156,8 +150,7 @@ public void mapWithSentinel() {
         })
     public void mapWithPrefix() {
 
-        TestClassWithMapsWithPrefix instance = ofName(TestClassWithMapsWithPrefix.class,
-            "Foo").instantiate();
+        TestClassWithMapsWithPrefix instance = ofName(TestClassWithMapsWithPrefix.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map1);
@@ -183,8 +176,7 @@ public void mapWithPrefix() {
         })
     public void shortFormMapWithPrefix() {
 
-        TestClassWithMapWithPrefix instance = ofName(TestClassWithMapWithPrefix.class,
-            "Foo").instantiate();
+        TestClassWithMapWithPrefix instance = ofName(TestClassWithMapWithPrefix.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map);
@@ -210,8 +202,7 @@ public void shortFormMapWithPrefix() {
         })
     public void mixedFormMapWithPrefix() {
 
-        TestClassWithMapWithPrefix instance = ofName(TestClassWithMapWithPrefix.class,
-            "Foo").instantiate();
+        TestClassWithMapWithPrefix instance = ofName(TestClassWithMapWithPrefix.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map);
@@ -242,8 +233,7 @@ public void mixedFormMapWithPrefix() {
         })
     public void shortFormMapWithoutPrefix() {
 
-        TestClassWithMapWithoutPrefix instance = ofName(TestClassWithMapWithoutPrefix.class, "Foo.Class",
-            Options.IMPLICIT).instantiate();
+        TestClassWithMapWithoutPrefix instance = ofClassName(TestClassWithMapWithoutPrefix.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map);
@@ -269,8 +259,7 @@ public void shortFormMapWithoutPrefix() {
         })
     public void mapWithEmptyMapValues() {
 
-        TestClassWithMapWithPrefix instance = ofName(TestClassWithMapWithPrefix.class,
-            "Foo").instantiate();
+        TestClassWithMapWithPrefix instance = ofName(TestClassWithMapWithPrefix.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map);
@@ -298,8 +287,7 @@ public void mapWithEmptyMapValues() {
         })
     public void mapWithPrefixAndSentinel() {
 
-        TestClassWithMapWithPrefixAndSentinel instance = ofName(TestClassWithMapWithPrefixAndSentinel.class,
-            "Foo").instantiate();
+        TestClassWithMapWithPrefixAndSentinel instance = ofName(TestClassWithMapWithPrefixAndSentinel.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map);
@@ -322,8 +310,7 @@ public void mapWithPrefixAndSentinel() {
         })
     public void list() {
 
-        TestClassWithList instance = ofName(TestClassWithList.class,
-            "Foo").instantiate();
+        TestClassWithList instance = ofName(TestClassWithList.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list);
@@ -346,8 +333,7 @@ public void list() {
         })
     public void listNotPresent() {
 
-        assertThrows(MCRConfigurationException.class,
-            () -> MCRInstanceConfiguration.ofName(Object.class, "Foo").instantiate());
+        assertThrows(MCRConfigurationException.class, () -> ofName(Object.class));
 
     }
 
@@ -360,8 +346,7 @@ public void listNotPresent() {
         })
     public void optionalList() {
 
-        TestClassWithOptionalList instance = ofName(TestClassWithOptionalList.class,
-            "Foo").instantiate();
+        TestClassWithOptionalList instance = ofName(TestClassWithOptionalList.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list);
@@ -384,8 +369,7 @@ public void optionalList() {
         })
     public void optionalListNotPresent() {
 
-        TestClassWithOptionalList instance = ofName(TestClassWithOptionalList.class,
-            "Foo").instantiate();
+        TestClassWithOptionalList instance = ofName(TestClassWithOptionalList.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list);
@@ -406,8 +390,7 @@ public void optionalListNotPresent() {
         })
     public void listWithSentinel() {
 
-        TestClassWithListAndSentinel instance = ofName(TestClassWithListAndSentinel.class,
-            "Foo").instantiate();
+        TestClassWithListAndSentinel instance = ofName(TestClassWithListAndSentinel.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list);
@@ -427,8 +410,7 @@ public void listWithSentinel() {
         })
     public void listWithPrefix() {
 
-        TestClassWithListsWithPrefix instance = ofName(TestClassWithListsWithPrefix.class,
-            "Foo").instantiate();
+        TestClassWithListsWithPrefix instance = ofName(TestClassWithListsWithPrefix.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list1);
@@ -454,8 +436,7 @@ public void listWithPrefix() {
         })
     public void shortFormListWithPrefix() {
 
-        TestClassWithListWithPrefix instance = ofName(TestClassWithListWithPrefix.class,
-            "Foo").instantiate();
+        TestClassWithListWithPrefix instance = ofName(TestClassWithListWithPrefix.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list);
@@ -481,8 +462,7 @@ public void shortFormListWithPrefix() {
         })
     public void mixedFormListWithPrefix() {
 
-        TestClassWithListWithPrefix instance = ofName(TestClassWithListWithPrefix.class,
-            "Foo").instantiate();
+        TestClassWithListWithPrefix instance = ofName(TestClassWithListWithPrefix.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list);
@@ -513,8 +493,7 @@ public void mixedFormListWithPrefix() {
         })
     public void shortFormListWithoutPrefix() {
 
-        TestClassWithListWithoutPrefix instance = ofName(TestClassWithListWithoutPrefix.class, "Foo.Class",
-            Options.IMPLICIT).instantiate();
+        TestClassWithListWithoutPrefix instance = ofClassName(TestClassWithListWithoutPrefix.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list);
@@ -540,8 +519,7 @@ public void shortFormListWithoutPrefix() {
         })
     public void listWithEmptyValues() {
 
-        TestClassWithListWithPrefix instance = ofName(TestClassWithListWithPrefix.class,
-            "Foo").instantiate();
+        TestClassWithListWithPrefix instance = ofName(TestClassWithListWithPrefix.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list);
@@ -569,8 +547,7 @@ public void listWithEmptyValues() {
         })
     public void listWithPrefixAndSentinel() {
 
-        TestClassWithListWithPrefixAndSentinel instance = ofName(TestClassWithListWithPrefixAndSentinel.class,
-            "Foo").instantiate();
+        TestClassWithListWithPrefixAndSentinel instance = ofName(TestClassWithListWithPrefixAndSentinel.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list);
@@ -581,6 +558,14 @@ public void listWithPrefixAndSentinel() {
 
     }
 
+    private <S> S ofName(Class<S> superClass) {
+        return MCRInstanceConfiguration.ofName(superClass, "Foo").instantiate();
+    }
+
+    private <S> S ofClassName(Class<S> superClass) {
+        return MCRInstanceConfiguration.ofName(superClass, "Foo.Class", Options.IMPLICIT).instantiate();
+    }
+
     public static class TestClassWithMap {
 
         @MCRPropertyMap
diff --git a/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorConfigTest.java b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorConfigTest.java
index 9683697960..01720b8595 100644
--- a/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorConfigTest.java
+++ b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorConfigTest.java
@@ -167,6 +167,7 @@ private void testInstance(String instanceName) {
         assertTrue(fullInstanceValue.isPresent(), "Properties should contain " + instanceName);
 
         ConfigurableTestInstance instance = ofName(ConfigurableTestInstance.class, fullInstanceName).instantiate();
+
         assertNotNull(instance, "Test " + fullInstanceName + " should be present");
 
         validateFields(instance);
diff --git a/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorDefaultTest.java b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorDefaultTest.java
index bac6cd3769..9affee906e 100644
--- a/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorDefaultTest.java
+++ b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorDefaultTest.java
@@ -20,7 +20,6 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.mycore.common.config.instantiator.MCRInstanceConfiguration.ofName;
 
 import java.util.List;
 import java.util.Map;
@@ -32,6 +31,7 @@
 import org.mycore.common.config.annotation.MCRInstanceList;
 import org.mycore.common.config.annotation.MCRInstanceMap;
 import org.mycore.common.config.annotation.MCRProperty;
+import org.mycore.common.config.instantiator.MCRInstanceConfiguration;
 import org.mycore.test.MyCoReTest;
 
 @MyCoReTest
@@ -52,8 +52,7 @@ public class MCRInstantiatorDefaultTest {
         })
     public void nested() {
 
-        TestClassWithNestedClass instance = ofName(TestClassWithNestedClass.class,
-            "Foo").instantiate();
+        TestClassWithNestedClass instance = ofName(TestClassWithNestedClass.class);
 
         assertNotNull(instance);
         assertNotNull(instance.nested);
@@ -69,8 +68,7 @@ public void nested() {
         })
     public void nestedImplicit() {
 
-        TestClassWithImplicitNestedClass instance = ofName(TestClassWithImplicitNestedClass.class,
-            "Foo").instantiate();
+        TestClassWithImplicitNestedClass instance = ofName(TestClassWithImplicitNestedClass.class);
 
         assertNotNull(instance);
         assertNotNull(instance.nested);
@@ -88,8 +86,7 @@ public void nestedImplicit() {
         })
     public void nestedNested() {
 
-        TestClassWithNestedNestedClass instance = ofName(TestClassWithNestedNestedClass.class,
-            "Foo").instantiate();
+        TestClassWithNestedNestedClass instance = ofName(TestClassWithNestedNestedClass.class);
 
         assertNotNull(instance);
         assertNotNull(instance.nested);
@@ -108,8 +105,7 @@ public void nestedNested() {
         })
     public void nestedMap() {
 
-        TestClassWithNestedMap instance = ofName(TestClassWithNestedMap.class,
-            "Foo").instantiate();
+        TestClassWithNestedMap instance = ofName(TestClassWithNestedMap.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map);
@@ -136,8 +132,7 @@ public void nestedMap() {
         })
     public void nestedMapImplicit() {
 
-        TestClassWithNestedMapOfImplicitEntries instance = ofName(TestClassWithNestedMapOfImplicitEntries.class,
-            "Foo").instantiate();
+        TestClassWithNestedMapOfImplicitEntries instance = ofName(TestClassWithNestedMapOfImplicitEntries.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map);
@@ -166,8 +161,7 @@ public void nestedMapImplicit() {
         })
     public void nestedList() {
 
-        TestClassWithNestedList instance = ofName(TestClassWithNestedList.class,
-            "Foo").instantiate();
+        TestClassWithNestedList instance = ofName(TestClassWithNestedList.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list);
@@ -194,8 +188,7 @@ public void nestedList() {
         })
     public void nestedListImplicit() {
 
-        TestClassWithNestedListOfImplicitEntries instance = ofName(TestClassWithNestedListOfImplicitEntries.class,
-            "Foo").instantiate();
+        TestClassWithNestedListOfImplicitEntries instance = ofName(TestClassWithNestedListOfImplicitEntries.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list);
@@ -215,6 +208,10 @@ public void nestedListImplicit() {
 
     }
 
+    private <S> S ofName(Class<S> superClass) {
+        return MCRInstanceConfiguration.ofName(superClass, "Foo").instantiate();
+    }
+
     public static class NestedClass {
 
         @MCRProperty(name = "Property1", defaultName = "Default.Property1")
diff --git a/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorInstanceBasicTest.java b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorInstanceBasicTest.java
index 6105a63d7e..4a0bf811de 100644
--- a/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorInstanceBasicTest.java
+++ b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorInstanceBasicTest.java
@@ -21,7 +21,6 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.mycore.common.config.instantiator.MCRInstanceConfiguration.ofName;
 
 import java.util.List;
 import java.util.Map;
@@ -46,7 +45,7 @@ public class MCRInstantiatorInstanceBasicTest {
         })
     public void instanceValue() {
 
-        TestClass instance = ofName(TestClass.class, "Foo").instantiate();
+        TestClass instance = ofName(TestClass.class);
 
         assertNotNull(instance);
         assertEquals(FooValue.class, instance.value.getClass());
@@ -62,7 +61,7 @@ public void instanceValue() {
     public void incompatibleInstanceValue() {
 
         MCRConfigurationException exception = assertThrows(MCRConfigurationException.class,
-            () -> MCRInstanceConfiguration.ofName(TestClass.class, "Foo").instantiate());
+            () -> ofName(TestClass.class));
 
         assertEquals("Instance, configured in Foo.Value (and sub-properties thereof),"
             + " for target field 'value' in configured class " + TestClass.class.getName()
@@ -82,7 +81,7 @@ public void incompatibleInstanceValue() {
         })
     public void instanceValueMap() {
 
-        TestClassWithMap instance = ofName(TestClassWithMap.class, "Foo").instantiate();
+        TestClassWithMap instance = ofName(TestClassWithMap.class);
 
         assertNotNull(instance);
         assertEquals(FooValue.class, instance.values.get("foo").getClass());
@@ -101,7 +100,7 @@ public void instanceValueMap() {
         })
     public void instanceValueList() {
 
-        TestClassWithList instance = ofName(TestClassWithList.class, "Foo").instantiate();
+        TestClassWithList instance = ofName(TestClassWithList.class);
 
         assertNotNull(instance);
         assertEquals(FooValue.class, instance.values.getFirst().getClass());
@@ -109,6 +108,10 @@ public void instanceValueList() {
 
     }
 
+    private <S> S ofName(Class<S> superClass) {
+        return MCRInstanceConfiguration.ofName(superClass, "Foo").instantiate();
+    }
+
     public static class TestClass {
 
         @MCRInstance(name = "Value", valueClass = Value.class)
diff --git a/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorNestedTest.java b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorNestedTest.java
index e284871923..09c4058152 100644
--- a/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorNestedTest.java
+++ b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorNestedTest.java
@@ -22,7 +22,6 @@
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.mycore.common.config.instantiator.MCRInstanceConfiguration.ofName;
 
 import java.util.List;
 import java.util.Map;
@@ -51,8 +50,7 @@ public class MCRInstantiatorNestedTest {
         })
     public void nested() {
 
-        TestClassWithNestedClass instance = ofName(TestClassWithNestedClass.class,
-            "Foo").instantiate();
+        TestClassWithNestedClass instance = ofName(TestClassWithNestedClass.class);
 
         assertNotNull(instance);
         assertNotNull(instance.nested);
@@ -68,8 +66,7 @@ public void nested() {
         })
     public void nestedNotPresent() {
 
-        assertThrows(MCRConfigurationException.class,
-            () -> MCRInstanceConfiguration.ofName(Object.class, "Foo").instantiate());
+        assertThrows(MCRConfigurationException.class, () -> ofName(Object.class));
 
     }
 
@@ -82,8 +79,7 @@ public void nestedNotPresent() {
         })
     public void nestedImplicit() {
 
-        TestClassWithImplicitNestedClass instance = ofName(TestClassWithImplicitNestedClass.class,
-            "Foo").instantiate();
+        TestClassWithImplicitNestedClass instance = ofName(TestClassWithImplicitNestedClass.class);
 
         assertNotNull(instance);
         assertNotNull(instance.nested);
@@ -102,8 +98,7 @@ public void nestedImplicit() {
         })
     public void nestedOptional() {
 
-        TestClassWithOptionalNestedClass instance = ofName(TestClassWithOptionalNestedClass.class,
-            "Foo").instantiate();
+        TestClassWithOptionalNestedClass instance = ofName(TestClassWithOptionalNestedClass.class);
 
         assertNotNull(instance);
         assertNotNull(instance.nested);
@@ -119,8 +114,7 @@ public void nestedOptional() {
         })
     public void nestedOptionalNotPresent() {
 
-        TestClassWithOptionalNestedClass instance = ofName(TestClassWithOptionalNestedClass.class,
-            "Foo").instantiate();
+        TestClassWithOptionalNestedClass instance = ofName(TestClassWithOptionalNestedClass.class);
 
         assertNotNull(instance);
         assertNull(instance.nested);
@@ -138,8 +132,7 @@ public void nestedOptionalNotPresent() {
         })
     public void nestedNested() {
 
-        TestClassWithNestedNestedClass instance = ofName(TestClassWithNestedNestedClass.class,
-            "Foo").instantiate();
+        TestClassWithNestedNestedClass instance = ofName(TestClassWithNestedNestedClass.class);
 
         assertNotNull(instance);
         assertNotNull(instance.nested);
@@ -160,8 +153,8 @@ public void nestedNested() {
         })
     public void nestedOptionalAndSentinel() {
 
-        TestClassWithOptionalNestedClassAndSentinel instance = ofName(TestClassWithOptionalNestedClassAndSentinel.class,
-            "Foo").instantiate();
+        TestClassWithOptionalNestedClassAndSentinel instance =
+            ofName(TestClassWithOptionalNestedClassAndSentinel.class);
 
         assertNotNull(instance);
         assertNotNull(instance.nested);
@@ -181,8 +174,8 @@ public void nestedOptionalAndSentinel() {
         })
     public void nestedOptionalAndSentinelNotPresent() {
 
-        TestClassWithOptionalNestedClassAndSentinel instance = ofName(TestClassWithOptionalNestedClassAndSentinel.class,
-            "Foo").instantiate();
+        TestClassWithOptionalNestedClassAndSentinel instance =
+            ofName(TestClassWithOptionalNestedClassAndSentinel.class);
 
         assertNotNull(instance);
         assertNull(instance.nested);
@@ -200,8 +193,7 @@ public void nestedOptionalAndSentinelNotPresent() {
         })
     public void nestedMap() {
 
-        TestClassWithNestedMap instance = ofName(TestClassWithNestedMap.class,
-            "Foo").instantiate();
+        TestClassWithNestedMap instance = ofName(TestClassWithNestedMap.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map);
@@ -226,8 +218,7 @@ public void nestedMap() {
         })
     public void nestedMapNotPresent() {
 
-        assertThrows(MCRConfigurationException.class,
-            () -> MCRInstanceConfiguration.ofName(Object.class, "Foo").instantiate());
+        assertThrows(MCRConfigurationException.class, () -> ofName(Object.class));
 
     }
 
@@ -240,8 +231,7 @@ public void nestedMapNotPresent() {
         })
     public void nestedMapImplicit() {
 
-        TestClassWithNestedMapOfImplicitEntries instance = ofName(TestClassWithNestedMapOfImplicitEntries.class,
-            "Foo").instantiate();
+        TestClassWithNestedMapOfImplicitEntries instance = ofName(TestClassWithNestedMapOfImplicitEntries.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map);
@@ -270,8 +260,7 @@ public void nestedMapImplicit() {
         })
     public void nestedOptionalMap() {
 
-        TestClassWithOptionalNestedMap instance = ofName(TestClassWithOptionalNestedMap.class,
-            "Foo").instantiate();
+        TestClassWithOptionalNestedMap instance = ofName(TestClassWithOptionalNestedMap.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map);
@@ -296,8 +285,7 @@ public void nestedOptionalMap() {
         })
     public void nestedOptionalMapNotPresent() {
 
-        TestClassWithOptionalNestedMap instance = ofName(TestClassWithOptionalNestedMap.class,
-            "Foo").instantiate();
+        TestClassWithOptionalNestedMap instance = ofName(TestClassWithOptionalNestedMap.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map);
@@ -321,8 +309,7 @@ public void nestedOptionalMapNotPresent() {
         })
     public void nestedMapWithSentinel() {
 
-        TestClassWithNestedMapWithSentinel instance = ofName(TestClassWithNestedMapWithSentinel.class,
-            "Foo").instantiate();
+        TestClassWithNestedMapWithSentinel instance = ofName(TestClassWithNestedMapWithSentinel.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map);
@@ -347,8 +334,7 @@ public void nestedMapWithSentinel() {
         })
     public void nestedMapWithPrefix() {
 
-        TestClassWithNestedMapsWithPrefix instance = ofName(TestClassWithNestedMapsWithPrefix.class,
-            "Foo").instantiate();
+        TestClassWithNestedMapsWithPrefix instance = ofName(TestClassWithNestedMapsWithPrefix.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map1);
@@ -384,8 +370,8 @@ public void nestedMapWithPrefix() {
         })
     public void nestedMapWithPrefixAndSentinel() {
 
-        TestClassWithNestedMapWithPrefixAndSentinel instance = ofName(TestClassWithNestedMapWithPrefixAndSentinel.class,
-            "Foo").instantiate();
+        TestClassWithNestedMapWithPrefixAndSentinel instance =
+            ofName(TestClassWithNestedMapWithPrefixAndSentinel.class);
 
         assertNotNull(instance);
         assertNotNull(instance.map);
@@ -410,8 +396,7 @@ public void nestedMapWithPrefixAndSentinel() {
         })
     public void nestedList() {
 
-        TestClassWithNestedList instance = ofName(TestClassWithNestedList.class,
-            "Foo").instantiate();
+        TestClassWithNestedList instance = ofName(TestClassWithNestedList.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list);
@@ -436,8 +421,7 @@ public void nestedList() {
         })
     public void nestedListNotPresent() {
 
-        assertThrows(MCRConfigurationException.class,
-            () -> MCRInstanceConfiguration.ofName(Object.class, "Foo").instantiate());
+        assertThrows(MCRConfigurationException.class, () -> ofName(Object.class));
 
     }
 
@@ -450,8 +434,7 @@ public void nestedListNotPresent() {
         })
     public void nestedListImplicit() {
 
-        TestClassWithNestedListOfImplicitEntries instance = ofName(TestClassWithNestedListOfImplicitEntries.class,
-            "Foo").instantiate();
+        TestClassWithNestedListOfImplicitEntries instance = ofName(TestClassWithNestedListOfImplicitEntries.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list);
@@ -480,8 +463,7 @@ public void nestedListImplicit() {
         })
     public void nestedOptionalList() {
 
-        TestClassWithOptionalNestedList instance = ofName(TestClassWithOptionalNestedList.class,
-            "Foo").instantiate();
+        TestClassWithOptionalNestedList instance = ofName(TestClassWithOptionalNestedList.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list);
@@ -506,8 +488,7 @@ public void nestedOptionalList() {
         })
     public void nestedOptionalListNotPresent() {
 
-        TestClassWithOptionalNestedList instance = ofName(TestClassWithOptionalNestedList.class,
-            "Foo").instantiate();
+        TestClassWithOptionalNestedList instance = ofName(TestClassWithOptionalNestedList.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list);
@@ -531,8 +512,7 @@ public void nestedOptionalListNotPresent() {
         })
     public void nestedListWithSentinel() {
 
-        TestClassWithNestedListAndSentinel instance = ofName(TestClassWithNestedListAndSentinel.class,
-            "Foo").instantiate();
+        TestClassWithNestedListAndSentinel instance = ofName(TestClassWithNestedListAndSentinel.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list);
@@ -554,8 +534,7 @@ public void nestedListWithSentinel() {
         })
     public void nestedListWithPrefix() {
 
-        TestClassWithNestedListsWithPrefix instance = ofName(TestClassWithNestedListsWithPrefix.class,
-            "Foo").instantiate();
+        TestClassWithNestedListsWithPrefix instance = ofName(TestClassWithNestedListsWithPrefix.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list1);
@@ -591,8 +570,7 @@ public void nestedListWithPrefix() {
     public void nestedListWithPrefixAndSentinel() {
 
         TestClassWithNestedListWithPrefixAndSentinel instance =
-            ofName(TestClassWithNestedListWithPrefixAndSentinel.class,
-                "Foo").instantiate();
+            ofName(TestClassWithNestedListWithPrefixAndSentinel.class);
 
         assertNotNull(instance);
         assertNotNull(instance.list);
@@ -603,6 +581,10 @@ public void nestedListWithPrefixAndSentinel() {
 
     }
 
+    private <S> S ofName(Class<S> superClass) {
+        return MCRInstanceConfiguration.ofName(superClass, "Foo").instantiate();
+    }
+
     public static class NestedClass {
 
         @MCRProperty(name = "PropertyA")
diff --git a/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorProxyTest.java b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorProxyTest.java
index ab70b63c43..f5dd4c8796 100644
--- a/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorProxyTest.java
+++ b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorProxyTest.java
@@ -20,7 +20,6 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.mycore.common.config.instantiator.MCRInstanceConfiguration.ofName;
 
 import java.util.function.Supplier;
 
@@ -29,6 +28,7 @@
 import org.mycore.common.MCRTestProperty;
 import org.mycore.common.config.annotation.MCRConfigurationProxy;
 import org.mycore.common.config.annotation.MCRProperty;
+import org.mycore.common.config.instantiator.MCRInstanceConfiguration;
 import org.mycore.test.MyCoReTest;
 
 @MyCoReTest
@@ -37,26 +37,29 @@ public class MCRInstantiatorProxyTest {
     @Test
     @MCRTestConfiguration(
         properties = {
-            @MCRTestProperty(key = "Foo.Class", classNameOf = TestClassWithConfigurationProxy.class),
+            @MCRTestProperty(key = "Foo.Class", classNameOf = TestClass.class),
             @MCRTestProperty(key = "Foo.Property1", string = "Value1"),
             @MCRTestProperty(key = "Foo.Property2", string = "Value2")
         })
     public void annotated() {
 
-        TestClassWithConfigurationProxy instance = ofName(TestClassWithConfigurationProxy.class,
-            "Foo").instantiate();
+        TestClass instance = ofName(TestClass.class);
 
         assertNotNull(instance);
         assertEquals("Value1-Value2", instance.value());
 
     }
 
-    @MCRConfigurationProxy(proxyClass = TestClassWithConfigurationProxy.Factory.class)
-    public static class TestClassWithConfigurationProxy {
+    private <S> S ofName(Class<S> superClass) {
+        return MCRInstanceConfiguration.ofName(superClass, "Foo").instantiate();
+    }
+
+    @MCRConfigurationProxy(proxyClass = TestClass.Factory.class)
+    public static class TestClass {
 
         private final String value;
 
-        public TestClassWithConfigurationProxy(String value) {
+        public TestClass(String value) {
             this.value = value;
         }
 
@@ -64,7 +67,7 @@ public String value() {
             return value;
         }
 
-        public static class Factory implements Supplier<TestClassWithConfigurationProxy> {
+        public static class Factory implements Supplier<TestClass> {
 
             @MCRProperty(name = "Property1")
             public String value1;
@@ -73,8 +76,8 @@ public static class Factory implements Supplier<TestClassWithConfigurationProxy>
             public String value2;
 
             @Override
-            public TestClassWithConfigurationProxy get() {
-                return new TestClassWithConfigurationProxy(value1 + "-" + value2);
+            public TestClass get() {
+                return new TestClass(value1 + "-" + value2);
             }
 
         }
diff --git a/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorRawPropertiesBasicTest.java b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorRawPropertiesBasicTest.java
new file mode 100644
index 0000000000..767a3d2f48
--- /dev/null
+++ b/mycore-base/src/test/java/org/mycore/common/config/MCRInstantiatorRawPropertiesBasicTest.java
@@ -0,0 +1,123 @@
+/*
+ * This file is part of ***  M y C o R e  ***
+ * See https://www.mycore.de/ for details.
+ *
+ * MyCoRe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * MyCoRe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with MyCoRe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.mycore.common.config;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Map;
+
+import org.junit.jupiter.api.Test;
+import org.mycore.common.MCRTestConfiguration;
+import org.mycore.common.MCRTestProperty;
+import org.mycore.common.config.annotation.MCRRawProperties;
+import org.mycore.common.config.instantiator.MCRInstanceConfiguration;
+import org.mycore.test.MyCoReTest;
+
+@MyCoReTest
+public class MCRInstantiatorRawPropertiesBasicTest {
+
+    @Test
+    @MCRTestConfiguration(
+        properties = {
+            @MCRTestProperty(key = "Foo.Class", classNameOf = TestClass.class),
+            @MCRTestProperty(key = "Foo.1", string = "1"),
+            @MCRTestProperty(key = "Foo.2", string = "2"),
+            @MCRTestProperty(key = "Foo.Values.1", string = "Value-1"),
+            @MCRTestProperty(key = "Foo.Values.2", string = "Value-2"),
+            @MCRTestProperty(key = "MCR.Values.1", string = "MCR-Value-1"),
+            @MCRTestProperty(key = "MCR.Values.2", string = "MCR-Value-2")
+        })
+    public void testRawProperties() {
+
+        TestClass instance = ofName(TestClass.class);
+
+        assertEquals(Map.of(
+            "1", "1",
+            "2", "2",
+            "Values.1",
+            "Value-1",
+            "Values.2",
+            "Value-2"),
+            instance.values);
+
+        assertEquals(Map.of(
+            "1", "Value-1",
+            "2", "Value-2"),
+            instance.nestedValues);
+
+        assertEquals(Map.of(
+            "1", "MCR-Value-1",
+            "2", "MCR-Value-2"),
+            instance.absoluteValues);
+
+    }
+
+    @Test
+    @MCRTestConfiguration(
+        properties = {
+            @MCRTestProperty(key = "Foo.Class", classNameOf = TestClass.class),
+            @MCRTestProperty(key = "Foo", string = "Empty"),
+            @MCRTestProperty(key = "Foo.Values.Class", string = "Value-Class"),
+            @MCRTestProperty(key = "Foo.Values.", string = "Value-Cursed"),
+            @MCRTestProperty(key = "Foo.Values", string = "Value-Empty"),
+            @MCRTestProperty(key = "MCR.Values.Class", string = "MCR-Value-Class"),
+            @MCRTestProperty(key = "MCR.Values.", string = "MCR-Value-Cursed"),
+            @MCRTestProperty(key = "MCR.Values", string = "MCR-Value-Empty")
+        })
+    public void testRawPropertiesUncommonValues() {
+
+        TestClass instance = ofName(TestClass.class);
+
+        assertEquals(Map.of(
+            "", "Empty",
+            "Values.Class", "Value-Class",
+            "Values.", "Value-Cursed",
+            "Values", "Value-Empty"),
+            instance.values);
+
+        assertEquals(Map.of(
+            "Class", "Value-Class",
+            "", "Value-Cursed"),
+            instance.nestedValues);
+
+        assertEquals(Map.of(
+            "Class", "MCR-Value-Class",
+            "", "MCR-Value-Cursed"),
+            instance.absoluteValues);
+
+    }
+
+    private <S> S ofName(Class<S> superClass) {
+        return MCRInstanceConfiguration.ofName(superClass, "Foo").instantiate();
+    }
+
+    public static class TestClass {
+
+        @MCRRawProperties(namePattern = "*")
+        public Map<String, String> values;
+
+        @MCRRawProperties(namePattern = "Values.*")
+        public Map<String, String> nestedValues;
+
+        @MCRRawProperties(namePattern = "MCR.Values.*", absolute = true)
+        public Map<String, String> absoluteValues;
+
+    }
+
+}