diff --git a/src/Directory.Packages.props b/src/Directory.Packages.props
index 5003ca7..dc0bc13 100644
--- a/src/Directory.Packages.props
+++ b/src/Directory.Packages.props
@@ -3,8 +3,8 @@
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
   </PropertyGroup>
   <ItemGroup>
-    <PackageVersion Include="IvAt.CommonFramework" Version="2.1.11" />
-    <PackageVersion Include="IvAt.CommonFramework.DependencyInjection" Version="2.1.11" />
+    <PackageVersion Include="IvAt.CommonFramework" Version="2.1.13" />
+    <PackageVersion Include="IvAt.CommonFramework.DependencyInjection" Version="2.1.13" />
     <PackageVersion Include="Microsoft.EntityFrameworkCore" Version="10.0.2" />
     <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.2" />
     <PackageVersion Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="10.0.2" />
diff --git a/src/GenericQueryable.EntityFramework/EfFetchService.cs b/src/GenericQueryable.EntityFramework/EfFetchService.cs
index 3787578..cbf435e 100644
--- a/src/GenericQueryable.EntityFramework/EfFetchService.cs
+++ b/src/GenericQueryable.EntityFramework/EfFetchService.cs
@@ -1,9 +1,8 @@
-using System.Collections.Concurrent;
-using System.Linq.Expressions;
+using System.Linq.Expressions;
 using System.Reflection;
 
 using CommonFramework;
-using CommonFramework.ExpressionEvaluate;
+
 using GenericQueryable.Fetching;
 
 using Microsoft.EntityFrameworkCore;
@@ -12,67 +11,28 @@
 
 namespace GenericQueryable.EntityFramework;
 
-public class EfFetchService([FromKeyedServices(RootFetchRuleExpander.Key)] IFetchRuleExpander fetchRuleExpander) : IFetchService
+public class EfFetchService([FromKeyedServices(RootFetchRuleExpander.Key)] IFetchRuleExpander fetchRuleExpander) : FetchService(fetchRuleExpander)
 {
-    private readonly ConcurrentDictionary<Type, ConcurrentDictionary<Type, object>> rootCache = [];
-
-    public virtual IQueryable<TSource> ApplyFetch<TSource>(IQueryable<TSource> source, FetchRule<TSource> fetchRule)
+    public override IQueryable<TSource> ApplyFetch<TSource>(IQueryable<TSource> source, FetchRule<TSource> fetchRule)
         where TSource : class
     {
-        return fetchRule switch
+        if (fetchRule is UntypedFetchRule<TSource> untypedFetchRule)
         {
-            UntypedFetchRule<TSource> untypedFetchRule => source.Include(untypedFetchRule.Path),
-
-            _ => this.GetApplyFetchFunc(fetchRule).Invoke(source)
-        };
-    }
-
-    private Func<IQueryable<TSource>, IQueryable<TSource>> GetApplyFetchFunc<TSource>(FetchRule<TSource> fetchRule)
-        where TSource : class
-    {
-        return this.rootCache
-            .GetOrAdd(typeof(TSource), _ => new ConcurrentDictionary<Type, object>())
-            .GetOrAdd(fetchRule.GetType(), _ => new ConcurrentDictionary<FetchRule<TSource>, Func<IQueryable<TSource>, IQueryable<TSource>>>())
-            .Pipe(v => (ConcurrentDictionary<FetchRule<TSource>, Func<IQueryable<TSource>, IQueryable<TSource>>>)v)
-            .GetOrAdd(fetchRule, _ =>
-            {
-                var fetchExpr = this.GetApplyFetchExpression(fetchRuleExpander.Expand(fetchRule));
-
-                return fetchExpr.Compile();
-            });
-    }
-
-    private Expression<Func<IQueryable<TSource>, IQueryable<TSource>>> GetApplyFetchExpression<TSource>(PropertyFetchRule<TSource> fetchRule)
-        where TSource : class
-    {
-        var startState = ExpressionHelper.GetIdentity<IQueryable<TSource>>();
-
-        return fetchRule.Paths.Aggregate(startState, (state, path) =>
+            return source.Include(untypedFetchRule.Path);
+        }
+        else
         {
-            var nextApplyFunc = GetApplyFetchExpression<TSource>(path);
-
-            return ExpressionEvaluateHelper.InlineEvaluate<Func<IQueryable<TSource>, IQueryable<TSource>>>(ee =>
-
-                q => ee.Evaluate(nextApplyFunc, ee.Evaluate(state, q)));
-        });
+            return base.ApplyFetch(source, fetchRule);
+        }
     }
 
-    private static Expression<Func<IQueryable<TSource>, IQueryable<TSource>>> GetApplyFetchExpression<TSource>(LambdaExpressionPath fetchPath)
+    protected override IEnumerable<MethodInfo> GetFetchMethods<TSource>(LambdaExpressionPath fetchPath)
         where TSource : class
     {
-        LambdaExpression startState = ExpressionHelper.GetIdentity<IQueryable<TSource>>();
-
-        var resultBody = fetchPath
+        return fetchPath
             .Properties
             .ZipStrong(new LambdaExpression?[] { null }.Concat(fetchPath.Properties.SkipLast(1)), (prop, prevProp) => new { prop, prevProp })
-            .Aggregate(startState.Body, (state, pair) =>
-            {
-                var fetchMethod = GetFetchMethod<TSource>(pair.prop, pair.prevProp);
-
-                return Expression.Call(fetchMethod, state, pair.prop);
-            });
-
-        return Expression.Lambda<Func<IQueryable<TSource>, IQueryable<TSource>>>(resultBody, startState.Parameters);
+            .Select(pair => GetFetchMethod<TSource>(pair.prop, pair.prevProp));
     }
 
     private static MethodInfo GetFetchMethod<TSource>(LambdaExpression prop, LambdaExpression? prevProp)
diff --git a/src/GenericQueryable.Runtime/Fetching/FetchService.cs b/src/GenericQueryable.Runtime/Fetching/FetchService.cs
new file mode 100644
index 0000000..38d1be3
--- /dev/null
+++ b/src/GenericQueryable.Runtime/Fetching/FetchService.cs
@@ -0,0 +1,63 @@
+using System.Collections.Concurrent;
+using System.Linq.Expressions;
+using System.Reflection;
+
+using CommonFramework;
+using CommonFramework.ExpressionEvaluate;
+
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GenericQueryable.Fetching;
+
+public abstract class FetchService([FromKeyedServices(RootFetchRuleExpander.Key)] IFetchRuleExpander fetchRuleExpander) : IFetchService
+{
+    private readonly ConcurrentDictionary<Type, ConcurrentDictionary<Type, object>> rootCache = [];
+
+    public virtual IQueryable<TSource> ApplyFetch<TSource>(IQueryable<TSource> source, FetchRule<TSource> fetchRule)
+        where TSource : class => this.GetApplyFetchFunc(fetchRule).Invoke(source);
+
+    private Func<IQueryable<TSource>, IQueryable<TSource>> GetApplyFetchFunc<TSource>(FetchRule<TSource> fetchRule)
+        where TSource : class
+    {
+        return this.rootCache
+            .GetOrAdd(typeof(TSource), _ => new ConcurrentDictionary<Type, object>())
+            .GetOrAdd(fetchRule.GetType(), _ => new ConcurrentDictionary<FetchRule<TSource>, Func<IQueryable<TSource>, IQueryable<TSource>>>())
+            .Pipe(v => (ConcurrentDictionary<FetchRule<TSource>, Func<IQueryable<TSource>, IQueryable<TSource>>>)v)
+            .GetOrAdd(fetchRule, _ =>
+            {
+                var fetchExpr = this.GetApplyFetchExpression(fetchRuleExpander.Expand(fetchRule));
+
+                return fetchExpr.Compile();
+            });
+    }
+
+    private Expression<Func<IQueryable<TSource>, IQueryable<TSource>>> GetApplyFetchExpression<TSource>(PropertyFetchRule<TSource> fetchRule)
+        where TSource : class
+    {
+        var startState = ExpressionHelper.GetIdentity<IQueryable<TSource>>();
+
+        return fetchRule.Paths.Aggregate(startState, (state, path) =>
+        {
+            var nextApplyFunc = this.GetApplyFetchExpression<TSource>(path);
+
+            return ExpressionEvaluateHelper.InlineEvaluate<Func<IQueryable<TSource>, IQueryable<TSource>>>(ee =>
+
+                q => ee.Evaluate(nextApplyFunc, ee.Evaluate(state, q)));
+        });
+    }
+
+    private Expression<Func<IQueryable<TSource>, IQueryable<TSource>>> GetApplyFetchExpression<TSource>(LambdaExpressionPath fetchPath)
+        where TSource : class
+    {
+        LambdaExpression startState = ExpressionHelper.GetIdentity<IQueryable<TSource>>();
+
+        var resultBody = this
+            .GetFetchMethods<TSource>(fetchPath).ZipStrong(fetchPath.Properties, (method, prop) => new { method, prop })
+            .Aggregate(startState.Body, (state, pair) => Expression.Call(pair.method, state, pair.prop));
+
+        return Expression.Lambda<Func<IQueryable<TSource>, IQueryable<TSource>>>(resultBody, startState.Parameters);
+    }
+
+    protected abstract IEnumerable<MethodInfo> GetFetchMethods<TSource>(LambdaExpressionPath fetchPath)
+        where TSource : class;
+}
\ No newline at end of file
diff --git a/src/GenericQueryable.Runtime/Fetching/UntypedFetchExpander.cs b/src/GenericQueryable.Runtime/Fetching/UntypedFetchExpander.cs
new file mode 100644
index 0000000..8320e81
--- /dev/null
+++ b/src/GenericQueryable.Runtime/Fetching/UntypedFetchExpander.cs
@@ -0,0 +1,29 @@
+using System.Collections.Concurrent;
+
+using CommonFramework;
+
+namespace GenericQueryable.Fetching;
+
+public class UntypedFetchExpander : IFetchRuleExpander
+{
+    private readonly ConcurrentDictionary<Type, object> cache = new();
+
+    public PropertyFetchRule<TSource>? TryExpand<TSource>(FetchRule<TSource> fetchRule)
+    {
+        if (fetchRule is UntypedFetchRule<TSource> untypedFetchRule)
+        {
+            return this.cache.GetOrAdd(typeof(TSource), _ => new ConcurrentDictionary<UntypedFetchRule<TSource>, PropertyFetchRule<TSource>>())
+                .Pipe(innerCache => (ConcurrentDictionary<UntypedFetchRule<TSource>, PropertyFetchRule<TSource>>)innerCache)
+                .Pipe(innerCache => innerCache.GetOrAdd(
+                    untypedFetchRule,
+                    _ =>
+                    {
+                        var fetchPath = LambdaExpressionPath.Create(typeof(TSource), untypedFetchRule.Path.Split('.'));
+
+                        return new PropertyFetchRule<TSource>([fetchPath]);
+                    }));
+        }
+
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/src/GenericQueryable.Runtime/GenericQueryable.Runtime.csproj b/src/GenericQueryable.Runtime/GenericQueryable.Runtime.csproj
index 6b15324..3ee59ac 100644
--- a/src/GenericQueryable.Runtime/GenericQueryable.Runtime.csproj
+++ b/src/GenericQueryable.Runtime/GenericQueryable.Runtime.csproj
@@ -5,6 +5,10 @@
     <RootNamespace>GenericQueryable</RootNamespace>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\GenericQueryable.Abstractions\GenericQueryable.Abstractions.csproj" />
   </ItemGroup>
diff --git a/src/GenericQueryable/DependencyInjection/GenericQueryableSetup.cs b/src/GenericQueryable/DependencyInjection/GenericQueryableSetup.cs
index dc00a54..a0373e3 100644
--- a/src/GenericQueryable/DependencyInjection/GenericQueryableSetup.cs
+++ b/src/GenericQueryable/DependencyInjection/GenericQueryableSetup.cs
@@ -26,6 +26,8 @@ public void Initialize(IServiceCollection services)
             services.TryAddSingleton<IMethodRedirector, MethodRedirector>();
 
             services.AddSingleton<IFetchRuleExpander, FetchRuleHeaderExpander>();
+            services.AddSingleton<IFetchRuleExpander, UntypedFetchExpander>();
+
             services.AddKeyedSingleton<IFetchRuleExpander, RootFetchRuleExpander>(RootFetchRuleExpander.Key);
         }
 
diff --git a/src/__SolutionItems/CommonAssemblyInfo.cs b/src/__SolutionItems/CommonAssemblyInfo.cs
index 1df93de..4fdb881 100644
--- a/src/__SolutionItems/CommonAssemblyInfo.cs
+++ b/src/__SolutionItems/CommonAssemblyInfo.cs
@@ -3,7 +3,7 @@
 [assembly: AssemblyProduct("GenericQueryable")]
 [assembly: AssemblyCompany("IvAt")]
 
-[assembly: AssemblyVersion("2.1.11.0")]
+[assembly: AssemblyVersion("2.1.13.0")]
 [assembly: AssemblyInformationalVersion("changes at build")]
 
 #if DEBUG