From 4513be6437dd27e36a03911325d150738dfc3059 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Fri, 28 Nov 2025 21:37:18 +0300
Subject: [PATCH 01/25] added SnapshotTypeMap and source generator for types
 registration

---
 .../Eventuous.Shared.Generators/Constants.cs  |   3 +
 .../Eventuous.Shared.Generators/Helpers.cs    |   8 +
 .../SnapshotMappingsGenerator.cs              | 197 ++++++++++++++++++
 .../TypeMappingsGenerator.cs                  |   3 +-
 .../SnapshotMap/SnapshotTypeMap.cs            |  33 +++
 5 files changed, 242 insertions(+), 2 deletions(-)
 create mode 100644 src/Core/gen/Eventuous.Shared.Generators/Helpers.cs
 create mode 100644 src/Core/gen/Eventuous.Shared.Generators/SnapshotMappingsGenerator.cs
 create mode 100644 src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotTypeMap.cs

diff --git a/src/Core/gen/Eventuous.Shared.Generators/Constants.cs b/src/Core/gen/Eventuous.Shared.Generators/Constants.cs
index 42b3fd4d..2dfac918 100644
--- a/src/Core/gen/Eventuous.Shared.Generators/Constants.cs
+++ b/src/Core/gen/Eventuous.Shared.Generators/Constants.cs
@@ -5,6 +5,9 @@ namespace Eventuous.Shared.Generators;
 
 internal static class Constants {
     public const string BaseNamespace      = "Eventuous";
+    public const string StateType          = "State";
     public const string EventTypeAttribute = "EventTypeAttribute";
     public const string EventTypeAttrFqcn  = $"{BaseNamespace}.{EventTypeAttribute}";
+    public const string SnapshotsAttribute  = "SnapshotsAttribute";
+    public const string SnapshotsAttrFqcn   = $"{BaseNamespace}.{SnapshotsAttribute}";
 }
diff --git a/src/Core/gen/Eventuous.Shared.Generators/Helpers.cs b/src/Core/gen/Eventuous.Shared.Generators/Helpers.cs
new file mode 100644
index 00000000..9a04cdfa
--- /dev/null
+++ b/src/Core/gen/Eventuous.Shared.Generators/Helpers.cs
@@ -0,0 +1,8 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+namespace Eventuous.Shared.Generators;
+
+internal static class Helpers {
+    public static string MakeGlobal(string typeName) => !typeName.StartsWith("global::") ? $"global::{typeName}" : typeName;
+}
diff --git a/src/Core/gen/Eventuous.Shared.Generators/SnapshotMappingsGenerator.cs b/src/Core/gen/Eventuous.Shared.Generators/SnapshotMappingsGenerator.cs
new file mode 100644
index 00000000..d529928f
--- /dev/null
+++ b/src/Core/gen/Eventuous.Shared.Generators/SnapshotMappingsGenerator.cs
@@ -0,0 +1,197 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System.Collections.Immutable;
+using System.Text;
+using static Eventuous.Shared.Generators.Constants;
+using static Eventuous.Shared.Generators.Helpers;
+
+namespace Eventuous.Shared.Generators;
+
+[Generator(LanguageNames.CSharp)]
+public sealed class SnapshotMappingsGenerator : IIncrementalGenerator {
+
+    static Map? GetMapFromSnapshotsAttribute(GeneratorSyntaxContext context) {
+        var classSyntax = (ClassDeclarationSyntax)context.Node;
+        var classSymbol = context.SemanticModel.GetDeclaredSymbol(classSyntax);
+        if (classSymbol == null || !IsState(classSymbol)) return null;
+
+        var snapshotsAttr = classSymbol.GetAttributes()
+            .FirstOrDefault(attr => attr.AttributeClass?.Name == "SnapshotsAttribute");
+
+        if (snapshotsAttr == null) return null;
+        
+        var snapshotTypes = new HashSet<string>();
+
+        foreach (var arg in snapshotsAttr.ConstructorArguments) {
+            if (arg.Kind == TypedConstantKind.Array) {
+                foreach (var typeConstant in arg.Values) {
+                    if (typeConstant.Value is ITypeSymbol typeSymbol) {
+                        snapshotTypes.Add(MakeGlobal(typeSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)));
+                    }
+                }
+            }
+            else if (arg.Kind == TypedConstantKind.Type && arg.Value is ITypeSymbol singleType) {
+                snapshotTypes.Add(MakeGlobal(singleType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)));
+            }
+        }
+
+        var stateType = classSymbol.BaseType?.TypeArguments[0];
+        if (stateType == null) return null;
+
+        return new Map {
+            SnapshotTypes = snapshotTypes,
+            StateType = MakeGlobal(classSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat))
+        };
+    }
+
+    static HashSet<string> GetTypesFromSnapshotsAttribute(AttributeData attributeData) {
+        var result = new HashSet<string>();
+
+        foreach (var arg in attributeData.ConstructorArguments) {
+            if (arg.Kind == TypedConstantKind.Array) {
+                foreach (var typeConstant in arg.Values) {
+                    if (typeConstant.Value is ITypeSymbol typeSymbol) {
+                        result.Add(typeSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat));
+                    }
+                }
+            }
+            else if (arg.Kind == TypedConstantKind.Type) {
+                if (arg.Value is ITypeSymbol typeSymbol) {
+                    result.Add(typeSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat));
+                }
+            }
+        }
+
+        foreach (var namedArg in attributeData.NamedArguments) {
+            if (namedArg.Value.Kind == TypedConstantKind.Array) {
+                foreach (var typeConstant in namedArg.Value.Values) {
+                    if (typeConstant.Value is ITypeSymbol typeSymbol) {
+                        result.Add(typeSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat));
+                    }
+                }
+            }
+            else if (namedArg.Value.Kind == TypedConstantKind.Type && namedArg.Value.Value is ITypeSymbol typeSymbol) {
+                result.Add(typeSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat));
+            }
+        }
+
+        return result;
+    }
+
+    static ImmutableArray<Map> GetMapFromSnapshotsAttribute(Compilation compilation) {
+        var builder = ImmutableArray.CreateBuilder<Map>();
+
+        // Current assembly
+        ProcessNamespace(compilation.Assembly.GlobalNamespace);
+
+        // Referenced assemblies
+        foreach (var ra in compilation.SourceModule.ReferencedAssemblySymbols) {
+            ProcessNamespace(ra.GlobalNamespace);
+        }
+
+        return builder.ToImmutable();
+
+        void ProcessType(INamedTypeSymbol type) {
+            var attr = GetSnapshotsAttribute(type);
+            if (attr is not null) {
+                var map = new Map {
+                    SnapshotTypes = GetTypesFromSnapshotsAttribute(attr),
+                    StateType = MakeGlobal(type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat))
+                };
+
+                builder.Add(map);
+            }
+
+            foreach (var nt in type.GetTypeMembers()) {
+                ProcessType(nt);
+            }
+        }
+
+        void ProcessNamespace(INamespaceSymbol ns) {
+            foreach (var member in ns.GetMembers()) {
+                switch (member) {
+                    case INamespaceSymbol cns:
+                        ProcessNamespace(cns); break;
+                    case INamedTypeSymbol type:
+                        ProcessType(type); break;
+                }
+            }
+        }
+    }
+
+    static void Output(SourceProductionContext context, ImmutableArray<Map> maps) {
+        var sb = new StringBuilder();
+        sb.AppendLine("// <auto-generated/>");
+        sb.AppendLine("#pragma warning disable CS8019");
+        sb.AppendLine("#nullable enable");
+        sb.AppendLine();
+        sb.AppendLine("using System;");
+        sb.AppendLine("using System.Runtime.CompilerServices;");
+        sb.AppendLine();
+        sb.AppendLine("namespace Eventuous;");
+        sb.AppendLine();
+        sb.AppendLine("internal static class SnapshotTypeMappings {");
+        sb.AppendLine("    [ModuleInitializer]");
+        sb.AppendLine("    internal static void Initialize() {");
+
+        foreach (var map in maps) {
+            foreach (var snapshotType in map.SnapshotTypes) {
+                sb.AppendLine($"        SnapshotTypeMap.Register(typeof({map.StateType}), typeof({snapshotType}));");
+            }
+        }
+
+        sb.AppendLine("    }");
+        sb.AppendLine("}");
+
+        context.AddSource("SnapshotTypeMappings.g.cs", sb.ToString());
+    }
+
+    public void Initialize(IncrementalGeneratorInitializationContext context) {
+        var maps = context.SyntaxProvider
+            .CreateSyntaxProvider(
+                predicate: static (s, _) => s is ClassDeclarationSyntax,
+                transform: static (c, _) => GetMapFromSnapshotsAttribute(c))
+            .Where(static m => m is not null)
+            .Collect();
+
+        var mapsFromReferencedAssmeblies = context.CompilationProvider
+            .Select(static (c, _) => GetMapFromSnapshotsAttribute(c));
+
+        var mergedMaps = maps
+            .Combine(mapsFromReferencedAssmeblies)
+            .Select(static (pair, _) => pair.Left.AddRange((IEnumerable<Map>)pair.Right));
+
+        context.RegisterSourceOutput(mergedMaps, Output!);
+
+    }
+
+    static bool IsState(INamedTypeSymbol type) {
+        var baseType = type.BaseType;
+
+        return baseType is not null
+            && baseType.Name == StateType
+            && baseType.ContainingNamespace.ToDisplayString() == BaseNamespace
+            && baseType.IsGenericType;
+    }
+
+    static AttributeData? GetSnapshotsAttribute(ISymbol symbol) {
+        foreach (var data in symbol.GetAttributes()) {
+            var attrClass = data.AttributeClass;
+            if (attrClass is null) continue;
+
+            var name = attrClass.ToDisplayString();
+            if (name == SnapshotsAttrFqcn || attrClass.Name is SnapshotsAttribute) return data;
+        }
+
+        return null;
+    }
+
+    sealed record Map {
+        public string StateType { get; set; } = null!;
+        public HashSet<string> SnapshotTypes { get; set; } = [];
+    }
+}
\ No newline at end of file
diff --git a/src/Core/gen/Eventuous.Shared.Generators/TypeMappingsGenerator.cs b/src/Core/gen/Eventuous.Shared.Generators/TypeMappingsGenerator.cs
index d68b13e8..1c1899fd 100644
--- a/src/Core/gen/Eventuous.Shared.Generators/TypeMappingsGenerator.cs
+++ b/src/Core/gen/Eventuous.Shared.Generators/TypeMappingsGenerator.cs
@@ -7,6 +7,7 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using static Eventuous.Shared.Generators.Constants;
+using static Eventuous.Shared.Generators.Helpers;
 
 namespace Eventuous.Shared.Generators;
 
@@ -202,6 +203,4 @@ static string SanitizeIdentifier(string name) {
 
         return sb.ToString();
     }
-
-    static string MakeGlobal(string typeName) => !typeName.StartsWith("global::") ? $"global::{typeName}" : typeName;
 }
diff --git a/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotTypeMap.cs b/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotTypeMap.cs
new file mode 100644
index 00000000..877d8f24
--- /dev/null
+++ b/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotTypeMap.cs
@@ -0,0 +1,33 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+namespace Eventuous;
+
+public static class SnapshotTypeMap {
+
+    static readonly Dictionary<Type, HashSet<Type>> StateToSnapshots = [];
+
+    public static void Register(Type stateType, Type eventType) {
+        if (StateToSnapshots.TryGetValue(stateType, out var value)) {
+            value.Add(eventType);
+        } else {
+            StateToSnapshots[stateType] = [eventType];
+        }
+    }
+
+    public static HashSet<Type> GetSnapshotTypes<TState>() {
+        var stateType = typeof(TState);
+
+        if (StateToSnapshots.TryGetValue(stateType, out var value)) {
+            return value;
+        }
+        else {
+            throw new InvalidOperationException();
+        }
+    }
+}
+
+[AttributeUsage(AttributeTargets.Class)]
+public class SnapshotsAttribute(params Type[] snapshotTypes) : Attribute {
+    public Type[] SnapshotTypes { get; } = snapshotTypes;
+}
\ No newline at end of file

From 82536dc972d57bbf5cb2f8ec72bd73db07c76197 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Fri, 28 Nov 2025 23:35:44 +0300
Subject: [PATCH 02/25] stream reading with snapshot support

---
 .../AggregatePersistenceExtensions.cs         | 10 +++-
 .../EventStore/StoreFunctions.cs              | 47 +++++++++++++++++++
 .../StateStore/StateStoreFunctions.cs         | 12 ++++-
 3 files changed, 66 insertions(+), 3 deletions(-)

diff --git a/src/Core/src/Eventuous.Persistence/AggregateStore/AggregatePersistenceExtensions.cs b/src/Core/src/Eventuous.Persistence/AggregateStore/AggregatePersistenceExtensions.cs
index 1907e364..30e264f8 100644
--- a/src/Core/src/Eventuous.Persistence/AggregateStore/AggregatePersistenceExtensions.cs
+++ b/src/Core/src/Eventuous.Persistence/AggregateStore/AggregatePersistenceExtensions.cs
@@ -127,7 +127,15 @@ public Task<AppendEventsResult> StoreAggregate<TAggregate, TState, TId>(
             var aggregate = (factoryRegistry ?? AggregateFactoryRegistry.Instance).CreateInstance<TAggregate, TState>();
 
             try {
-                var events = await eventReader.ReadStream(streamName, StreamReadPosition.Start, failIfNotFound, cancellationToken).NoContext();
+                StreamEvent[] events;
+
+                var snapshotTypes = SnapshotTypeMap.GetSnapshotTypes<TState>();
+                if (snapshotTypes.Count != 0) {
+                    events = await eventReader.ReadStreamAfterSnapshot(streamName, snapshotTypes, failIfNotFound, cancellationToken).NoContext();
+                } else {
+                    events = await eventReader.ReadStream(streamName, StreamReadPosition.Start, failIfNotFound, cancellationToken).NoContext();
+                }
+
                 if (events.Length == 0) return aggregate;
                 aggregate.Load(events[^1].Revision, events.Select(x => x.Payload));
             } catch (StreamNotFound) when (!failIfNotFound) {
diff --git a/src/Core/src/Eventuous.Persistence/EventStore/StoreFunctions.cs b/src/Core/src/Eventuous.Persistence/EventStore/StoreFunctions.cs
index 2234a3fb..00b462bf 100644
--- a/src/Core/src/Eventuous.Persistence/EventStore/StoreFunctions.cs
+++ b/src/Core/src/Eventuous.Persistence/EventStore/StoreFunctions.cs
@@ -93,4 +93,51 @@ public static async Task<StreamEvent[]> ReadStream(
 
         return streamEvents.ToArray();
     }
+
+    [RequiresDynamicCode(AttrConstants.DynamicSerializationMessage)]
+    [RequiresUnreferencedCode(AttrConstants.DynamicSerializationMessage)]
+    public static async Task<StreamEvent[]> ReadStreamAfterSnapshot(
+        this IEventReader eventReader,
+        StreamName        streamName,
+        HashSet<Type>     snapshotTypes,
+        bool              failIfNotFound = true,
+        CancellationToken cancellationToken = default
+    ) {
+        const int pageSize = 500;
+
+        var streamEvents = new List<StreamEvent>();
+
+        var position = StreamReadPosition.End;
+
+        try {
+            while (true) {
+                var events = await eventReader.ReadEventsBackwards(streamName, position, pageSize, failIfNotFound, cancellationToken).NoContext();
+
+                var indexOfSnapshot = events.Length;
+
+                while (--indexOfSnapshot >= 0) {
+                    var payload = events[indexOfSnapshot].Payload;
+                    if (payload is not null && snapshotTypes.Contains(payload.GetType())) {
+                        break;
+                    }
+                }
+
+                if (indexOfSnapshot == -1) {
+                    streamEvents.AddRange(events);
+                } else {
+                    streamEvents.AddRange(events[.. (indexOfSnapshot + 1)]);
+                    break;
+                }
+
+                if (events.Length < pageSize) break;
+
+                position = new(position.Value - events.Length);
+            }
+        } catch (StreamNotFound) when (!failIfNotFound) {
+            return [];
+        }
+
+        streamEvents.Reverse();
+        return [.. streamEvents];
+    }
 }
diff --git a/src/Core/src/Eventuous.Persistence/StateStore/StateStoreFunctions.cs b/src/Core/src/Eventuous.Persistence/StateStore/StateStoreFunctions.cs
index 75d4667f..39c74115 100644
--- a/src/Core/src/Eventuous.Persistence/StateStore/StateStoreFunctions.cs
+++ b/src/Core/src/Eventuous.Persistence/StateStore/StateStoreFunctions.cs
@@ -25,8 +25,16 @@ public async Task<FoldedEventStream<TState>> LoadState<TState>(
                 CancellationToken cancellationToken = default
             ) where TState : State<TState>, new() {
             try {
-                var streamEvents    = await reader.ReadStream(streamName, StreamReadPosition.Start, failIfNotFound, cancellationToken).NoContext();
-                var events          = streamEvents.Select(x => x.Payload!).ToArray();
+                StreamEvent[] streamEvents;
+
+                var snapshotTypes = SnapshotTypeMap.GetSnapshotTypes<TState>();
+                if (snapshotTypes.Count != 0) {
+                    streamEvents = await reader.ReadStreamAfterSnapshot(streamName, snapshotTypes, failIfNotFound, cancellationToken);
+                } else {
+                    streamEvents = await reader.ReadStream(streamName, StreamReadPosition.Start, failIfNotFound, cancellationToken).NoContext();
+                }
+
+                var events = streamEvents.Select(x => x.Payload!).ToArray();
                 var expectedVersion = events.Length == 0 ? ExpectedStreamVersion.NoStream : new(streamEvents.Last().Revision);
 
                 return (new(streamName, expectedVersion, events));

From 9c7a110827f58d9e05fc4c234bb0569cdc07ccf3 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Sat, 29 Nov 2025 23:00:20 +0300
Subject: [PATCH 03/25] fix ReadStreamAfterSnapshot

---
 .../EventStore/StoreFunctions.cs                  | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/Core/src/Eventuous.Persistence/EventStore/StoreFunctions.cs b/src/Core/src/Eventuous.Persistence/EventStore/StoreFunctions.cs
index 00b462bf..f13f0011 100644
--- a/src/Core/src/Eventuous.Persistence/EventStore/StoreFunctions.cs
+++ b/src/Core/src/Eventuous.Persistence/EventStore/StoreFunctions.cs
@@ -113,20 +113,21 @@ public static async Task<StreamEvent[]> ReadStreamAfterSnapshot(
             while (true) {
                 var events = await eventReader.ReadEventsBackwards(streamName, position, pageSize, failIfNotFound, cancellationToken).NoContext();
 
-                var indexOfSnapshot = events.Length;
+                var snapshotIndex = (int?) null;
 
-                while (--indexOfSnapshot >= 0) {
-                    var payload = events[indexOfSnapshot].Payload;
+                for (var i = 0; i < events.Length; i++) {
+                    var payload = events[i].Payload;
                     if (payload is not null && snapshotTypes.Contains(payload.GetType())) {
+                        snapshotIndex = i;
                         break;
                     }
                 }
 
-                if (indexOfSnapshot == -1) {
-                    streamEvents.AddRange(events);
-                } else {
-                    streamEvents.AddRange(events[.. (indexOfSnapshot + 1)]);
+                if (snapshotIndex.HasValue) {
+                    streamEvents.AddRange(events[..(snapshotIndex.Value + 1)]);
                     break;
+                } else {
+                    streamEvents.AddRange(events);
                 }
 
                 if (events.Length < pageSize) break;

From 153760252fb35fff33f733958431cde6aff8e984 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Sat, 29 Nov 2025 23:28:38 +0300
Subject: [PATCH 04/25] added sample to demonstrate the use of snapshots

---
 Directory.Packages.props                      |  2 +
 Eventuous.slnx                                |  5 ++
 .../banking/Banking.Api/Banking.Api.csproj    | 21 +++++++
 samples/banking/Banking.Api/Program.cs        | 29 ++++++++++
 .../Banking.Api/Services/AccountService.cs    | 56 +++++++++++++++++++
 .../Banking.Api/appsettings.Development.json  |  8 +++
 samples/banking/Banking.Api/appsettings.json  |  9 +++
 samples/banking/Banking.AppHost/AppHost.cs    | 13 +++++
 .../Banking.AppHost/Banking.AppHost.csproj    | 19 +++++++
 .../appsettings.Development.json              |  8 +++
 .../banking/Banking.AppHost/appsettings.json  |  9 +++
 .../Banking.Domain/Accounts/AccountEvents.cs  | 16 ++++++
 .../Banking.Domain/Accounts/AccountState.cs   | 26 +++++++++
 .../Banking.Domain/Banking.Domain.csproj      |  6 ++
 samples/banking/README.md                     | 13 +++++
 15 files changed, 240 insertions(+)
 create mode 100644 samples/banking/Banking.Api/Banking.Api.csproj
 create mode 100644 samples/banking/Banking.Api/Program.cs
 create mode 100644 samples/banking/Banking.Api/Services/AccountService.cs
 create mode 100644 samples/banking/Banking.Api/appsettings.Development.json
 create mode 100644 samples/banking/Banking.Api/appsettings.json
 create mode 100644 samples/banking/Banking.AppHost/AppHost.cs
 create mode 100644 samples/banking/Banking.AppHost/Banking.AppHost.csproj
 create mode 100644 samples/banking/Banking.AppHost/appsettings.Development.json
 create mode 100644 samples/banking/Banking.AppHost/appsettings.json
 create mode 100644 samples/banking/Banking.Domain/Accounts/AccountEvents.cs
 create mode 100644 samples/banking/Banking.Domain/Accounts/AccountState.cs
 create mode 100644 samples/banking/Banking.Domain/Banking.Domain.csproj
 create mode 100644 samples/banking/README.md

diff --git a/Directory.Packages.props b/Directory.Packages.props
index 26b5371b..66a54b38 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -23,6 +23,8 @@
   </PropertyGroup>
   <ItemGroup>
     <PackageVersion Include="BenchmarkDotNet" Version="0.14.0" />
+    <PackageVersion Include="CommunityToolkit.Aspire.Hosting.KurrentDB" Version="13.0.0" />
+    <PackageVersion Include="CommunityToolkit.Aspire.KurrentDB" Version="13.0.0" />
     <PackageVersion Include="FluentValidation" Version="12.0.0" />
     <PackageVersion Include="KurrentDB.Client" Version="1.2.0" />
     <PackageVersion Include="Microsoft.Extensions.Configuration" Version="$(MicrosoftExtensionsVer)" />
diff --git a/Eventuous.slnx b/Eventuous.slnx
index 9866ba98..688ee7a4 100644
--- a/Eventuous.slnx
+++ b/Eventuous.slnx
@@ -140,6 +140,11 @@
         <Project Path="src/SqlServer/test/Eventuous.Tests.SqlServer/Eventuous.Tests.SqlServer.csproj" />
     </Folder>
     <Folder Name="/Samples/" />
+    <Folder Name="/Samples/Banking/">
+        <Project Path="samples/banking/Banking.Api/Banking.Api.csproj" />
+        <Project Path="samples/banking/Banking.AppHost/Banking.AppHost.csproj" />
+        <Project Path="samples/banking/Banking.Domain/Banking.Domain.csproj" />
+    </Folder>
     <Folder Name="/Samples/Esdb/">
         <Project Path="samples/esdb/Bookings.Domain/Bookings.Domain.csproj" />
         <Project Path="samples/esdb/Bookings.Payments/Bookings.Payments.csproj" />
diff --git a/samples/banking/Banking.Api/Banking.Api.csproj b/samples/banking/Banking.Api/Banking.Api.csproj
new file mode 100644
index 00000000..1ec9411a
--- /dev/null
+++ b/samples/banking/Banking.Api/Banking.Api.csproj
@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="CommunityToolkit.Aspire.KurrentDB" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="$(SrcRoot)\Core\src\Eventuous.Application\Eventuous.Application.csproj" />
+    <ProjectReference Include="$(SrcRoot)\Core\gen\Eventuous.Shared.Generators\Eventuous.Shared.Generators.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
+    <ProjectReference Include="$(SrcRoot)\Extensions\src\Eventuous.Extensions.DependencyInjection\Eventuous.Extensions.DependencyInjection.csproj" />
+    <ProjectReference Include="$(SrcRoot)\KurrentDB\src\Eventuous.KurrentDB\Eventuous.KurrentDB.csproj" />   
+    <ProjectReference Include="..\Banking.Domain\Banking.Domain.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/samples/banking/Banking.Api/Program.cs b/samples/banking/Banking.Api/Program.cs
new file mode 100644
index 00000000..6ff26651
--- /dev/null
+++ b/samples/banking/Banking.Api/Program.cs
@@ -0,0 +1,29 @@
+using Banking.Api.Services;
+using Banking.Domain.Accounts;
+using Eventuous.KurrentDB;
+using Microsoft.AspNetCore.Mvc;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.AddKurrentDBClient("kurrentdb");
+
+builder.Services.AddEventStore<KurrentDBEventStore>();
+builder.Services.AddCommandService<AccountService, AccountState>();
+
+var app = builder.Build();
+
+app.MapGet("/accounts/{id}/deposit/{amount}", async ([FromRoute] string id, [FromRoute] decimal amount, [FromServices] AccountService accountService) => {
+    var cmd = new AccountService.Deposit(id, amount);
+    var res = await accountService.Handle(cmd, default);
+
+    return res.Match<object>(ok => ok, err => err);
+});
+
+app.MapGet("/accounts/{id}/withdraw/{amount}", async ([FromRoute] string id, [FromRoute] decimal amount, [FromServices] AccountService accountService) => {
+    var cmd = new AccountService.Deposit(id, amount);
+    var res = await accountService.Handle(cmd, default);
+
+    return res.Match<object>(ok => ok, err => err);
+});
+
+app.Run();
diff --git a/samples/banking/Banking.Api/Services/AccountService.cs b/samples/banking/Banking.Api/Services/AccountService.cs
new file mode 100644
index 00000000..9953d373
--- /dev/null
+++ b/samples/banking/Banking.Api/Services/AccountService.cs
@@ -0,0 +1,56 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+using Banking.Domain.Accounts;
+using Eventuous;
+
+namespace Banking.Api.Services;
+
+public class AccountService : CommandService<AccountState> {
+    public record Deposit(string AccountId, decimal Amount);
+    public record Withdraw(string AccountId, decimal Amount);
+
+    public AccountService(IEventStore store) : base(store) {
+        On<Deposit>()
+            .InState(ExpectedState.Any)
+            .GetStream(cmd => StreamName.ForState<AccountState>(cmd.AccountId))
+            .Act(ApplySnapshot<Deposit>(Handle));
+
+        On<Withdraw>()
+            .InState(ExpectedState.Any)
+            .GetStream(cmd => StreamName.ForState<AccountState>(cmd.AccountId))
+            .Act(ApplySnapshot<Withdraw>(Handle));
+    }
+
+    private IEnumerable<object> Handle(AccountState state, IEnumerable<object> _, Deposit cmd) {
+        return [
+            new AccountEvents.V1.Deposited(cmd.Amount)
+        ];
+    }
+
+    private IEnumerable<object> Handle(AccountState state, IEnumerable<object> _, Withdraw cmd) {
+        if (state.Balance < cmd.Amount) {
+            throw new InvalidOperationException();
+        }
+
+        return [
+            new AccountEvents.V1.Withdrawn(cmd.Amount)
+        ];
+    }
+
+    Func<AccountState, IEnumerable<object>, TCommand, IEnumerable<object>> ApplySnapshot<TCommand>(Func<AccountState, IEnumerable<object>, TCommand, IEnumerable<object>> handler) => (state, events, command) => {
+        var newEvents = handler(state, events, command);
+
+        if (newEvents.Count() + events.Count() >= 10) {
+            foreach (var @event in newEvents) {
+                state = state.When(@event);
+            }
+            return [
+                ..newEvents,
+                    new AccountEvents.V1.Snapshot(state.Balance)
+            ];
+        }
+
+        return newEvents;
+    };
+}
diff --git a/samples/banking/Banking.Api/appsettings.Development.json b/samples/banking/Banking.Api/appsettings.Development.json
new file mode 100644
index 00000000..0c208ae9
--- /dev/null
+++ b/samples/banking/Banking.Api/appsettings.Development.json
@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}
diff --git a/samples/banking/Banking.Api/appsettings.json b/samples/banking/Banking.Api/appsettings.json
new file mode 100644
index 00000000..10f68b8c
--- /dev/null
+++ b/samples/banking/Banking.Api/appsettings.json
@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}
diff --git a/samples/banking/Banking.AppHost/AppHost.cs b/samples/banking/Banking.AppHost/AppHost.cs
new file mode 100644
index 00000000..b8e34798
--- /dev/null
+++ b/samples/banking/Banking.AppHost/AppHost.cs
@@ -0,0 +1,13 @@
+var builder = DistributedApplication.CreateBuilder(args);
+
+var db = builder.AddKurrentDB("kurrentdb", 2113)
+    .WithEnvironment("EVENTSTORE_ENABLE_ATOM_PUB_OVER_HTTP", "true");
+
+builder
+    .AddProject<Projects.Banking_Api>("banking-api")
+    .WithReference(db, "kurrentdb")
+    .WaitFor(db);
+
+builder
+    .Build()
+    .Run();
diff --git a/samples/banking/Banking.AppHost/Banking.AppHost.csproj b/samples/banking/Banking.AppHost/Banking.AppHost.csproj
new file mode 100644
index 00000000..a2a54ee8
--- /dev/null
+++ b/samples/banking/Banking.AppHost/Banking.AppHost.csproj
@@ -0,0 +1,19 @@
+<Project Sdk="Aspire.AppHost.Sdk/13.0.1">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <UserSecretsId>3f5f156a-5139-482c-a37e-99163d5f39d7</UserSecretsId>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="CommunityToolkit.Aspire.Hosting.KurrentDB" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Banking.Api\Banking.Api.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/samples/banking/Banking.AppHost/appsettings.Development.json b/samples/banking/Banking.AppHost/appsettings.Development.json
new file mode 100644
index 00000000..0c208ae9
--- /dev/null
+++ b/samples/banking/Banking.AppHost/appsettings.Development.json
@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}
diff --git a/samples/banking/Banking.AppHost/appsettings.json b/samples/banking/Banking.AppHost/appsettings.json
new file mode 100644
index 00000000..31c092aa
--- /dev/null
+++ b/samples/banking/Banking.AppHost/appsettings.json
@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning",
+      "Aspire.Hosting.Dcp": "Warning"
+    }
+  }
+}
diff --git a/samples/banking/Banking.Domain/Accounts/AccountEvents.cs b/samples/banking/Banking.Domain/Accounts/AccountEvents.cs
new file mode 100644
index 00000000..304180c7
--- /dev/null
+++ b/samples/banking/Banking.Domain/Accounts/AccountEvents.cs
@@ -0,0 +1,16 @@
+using Eventuous;
+
+namespace Banking.Domain.Accounts;
+
+public static class AccountEvents {
+    public static class V1 {
+        [EventType("V1.Deposited")]
+        public record Deposited(decimal Amount);
+
+        [EventType("V1.Withdrawn")]
+        public record Withdrawn(decimal Amount);
+
+        [EventType("V1.Snapshot")]
+        public record Snapshot(decimal Balance);
+    }
+}
diff --git a/samples/banking/Banking.Domain/Accounts/AccountState.cs b/samples/banking/Banking.Domain/Accounts/AccountState.cs
new file mode 100644
index 00000000..aae82bf0
--- /dev/null
+++ b/samples/banking/Banking.Domain/Accounts/AccountState.cs
@@ -0,0 +1,26 @@
+using Eventuous;
+
+namespace Banking.Domain.Accounts;
+
+[Snapshots(typeof(AccountEvents.V1.Snapshot))]
+public record AccountState : State<AccountState> {
+    public decimal Balance { get; init; }
+
+    public AccountState() {
+        On<AccountEvents.V1.Snapshot>(When);
+        On<AccountEvents.V1.Deposited>(When);
+        On<AccountEvents.V1.Withdrawn>(When);
+    }
+
+    private AccountState When(AccountState state, AccountEvents.V1.Snapshot e) => state with {
+        Balance = e.Balance
+    };
+
+    private AccountState When(AccountState state, AccountEvents.V1.Deposited e) => state with {
+        Balance = state.Balance + e.Amount
+    };
+
+    private AccountState When(AccountState state, AccountEvents.V1.Withdrawn e) => state with {
+        Balance = state.Balance - e.Amount
+    };
+}
diff --git a/samples/banking/Banking.Domain/Banking.Domain.csproj b/samples/banking/Banking.Domain/Banking.Domain.csproj
new file mode 100644
index 00000000..d482b1e0
--- /dev/null
+++ b/samples/banking/Banking.Domain/Banking.Domain.csproj
@@ -0,0 +1,6 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <ItemGroup>
+    <ProjectReference Include="$(CoreRoot)\Eventuous.Domain\Eventuous.Domain.csproj"/>
+    <ProjectReference Include="$(CoreRoot)\Eventuous.Shared\Eventuous.Shared.csproj"/>
+  </ItemGroup>
+</Project>
diff --git a/samples/banking/README.md b/samples/banking/README.md
new file mode 100644
index 00000000..3addf873
--- /dev/null
+++ b/samples/banking/README.md
@@ -0,0 +1,13 @@
+### Project description
+
+A small example demonstrating the use of snapshots stored as an event in the aggregate stream
+
+### How to use snapshots?
+
+First, declare the type of event that represents a snapshot of the current state. In this example, see AccountEvents.V1.Snapshot. This name is chosen just for the example; ideally, it should correspond to something from your domain, for example, the closing of a shift
+
+Once we have a declared snapshot type, we need to link it to the state. Note the declaration of the AccountState type - it has the Snapshots attribute applied to it, which is given a list of types that are snapshot events. This attribute helps the EventReader understand that it needs to read the stream in reverse order up to the first encountered snapshot, and not load events prior to the snapshot
+
+You also need to define the logic according to which the snapshot event will occur. Since a snapshot is a regular event, you can create it at any moment during command processing, based on the available data to make the decision. An example can be seen in AccountService - the ApplySnapshot method.
+
+Essentially, this is all you need to start using snapshots (it is assumed that a package with source generators has been added to the project).
\ No newline at end of file

From abf7c3f9d5dd1a8ee907f5e67f0fde517a3732b9 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Sat, 29 Nov 2025 23:30:21 +0300
Subject: [PATCH 05/25] fix withdraw endpoint

---
 samples/banking/Banking.Api/Program.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/samples/banking/Banking.Api/Program.cs b/samples/banking/Banking.Api/Program.cs
index 6ff26651..5f55dc4a 100644
--- a/samples/banking/Banking.Api/Program.cs
+++ b/samples/banking/Banking.Api/Program.cs
@@ -20,7 +20,7 @@
 });
 
 app.MapGet("/accounts/{id}/withdraw/{amount}", async ([FromRoute] string id, [FromRoute] decimal amount, [FromServices] AccountService accountService) => {
-    var cmd = new AccountService.Deposit(id, amount);
+    var cmd = new AccountService.Withdraw(id, amount);
     var res = await accountService.Handle(cmd, default);
 
     return res.Match<object>(ok => ok, err => err);

From 8cfd46913f2c1fe121506308efc8572979c3aacd Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Sun, 30 Nov 2025 02:13:24 +0300
Subject: [PATCH 06/25] change get snapshot types method

---
 .../Eventuous.Shared/SnapshotMap/SnapshotTypeMap.cs   | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotTypeMap.cs b/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotTypeMap.cs
index 877d8f24..89878c58 100644
--- a/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotTypeMap.cs
+++ b/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotTypeMap.cs
@@ -15,16 +15,7 @@ public static void Register(Type stateType, Type eventType) {
         }
     }
 
-    public static HashSet<Type> GetSnapshotTypes<TState>() {
-        var stateType = typeof(TState);
-
-        if (StateToSnapshots.TryGetValue(stateType, out var value)) {
-            return value;
-        }
-        else {
-            throw new InvalidOperationException();
-        }
-    }
+    public static HashSet<Type> GetSnapshotTypes<TState>() => StateToSnapshots.GetValueOrDefault(typeof(TState), []);
 }
 
 [AttributeUsage(AttributeTargets.Class)]

From 7f46c76935002ee8774341e4dccf01e1a989b62e Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Sun, 7 Dec 2025 13:23:51 +0300
Subject: [PATCH 07/25] added snapshot storage strategy

---
 .../SnapshotMap/SnapshotStorageStrategy.cs    | 24 +++++++++++++++++++
 .../SnapshotMap/SnapshotTypeMap.cs            |  5 ----
 .../SnapshotMap/SnapshotsAttribute.cs         | 18 ++++++++++++++
 3 files changed, 42 insertions(+), 5 deletions(-)
 create mode 100644 src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotStorageStrategy.cs
 create mode 100644 src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotsAttribute.cs

diff --git a/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotStorageStrategy.cs b/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotStorageStrategy.cs
new file mode 100644
index 00000000..11e31c66
--- /dev/null
+++ b/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotStorageStrategy.cs
@@ -0,0 +1,24 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+namespace Eventuous;
+
+/// <summary>
+/// Strategy for storing snapshot events
+/// </summary>
+public enum SnapshotStorageStrategy {
+    /// <summary>
+    /// Store snapshots in the same stream as other aggregate events
+    /// </summary>
+    SameStream,
+
+    /// <summary>
+    /// Store snapshots in a separate stream
+    /// </summary>
+    SeparateStream,
+
+    /// <summary>
+    /// Store snapshots in a separate storage (e.g., PostgreSQL, Redis, etc.)
+    /// </summary>
+    SeparateStore
+}
diff --git a/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotTypeMap.cs b/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotTypeMap.cs
index 89878c58..f88ae451 100644
--- a/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotTypeMap.cs
+++ b/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotTypeMap.cs
@@ -17,8 +17,3 @@ public static void Register(Type stateType, Type eventType) {
 
     public static HashSet<Type> GetSnapshotTypes<TState>() => StateToSnapshots.GetValueOrDefault(typeof(TState), []);
 }
-
-[AttributeUsage(AttributeTargets.Class)]
-public class SnapshotsAttribute(params Type[] snapshotTypes) : Attribute {
-    public Type[] SnapshotTypes { get; } = snapshotTypes;
-}
\ No newline at end of file
diff --git a/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotsAttribute.cs b/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotsAttribute.cs
new file mode 100644
index 00000000..619aa660
--- /dev/null
+++ b/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotsAttribute.cs
@@ -0,0 +1,18 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+namespace Eventuous;
+
+[AttributeUsage(AttributeTargets.Class)]
+public class SnapshotsAttribute : Attribute {
+    public Type[] SnapshotTypes { get; }
+
+    /// <summary>
+    /// Storage strategy for snapshot events
+    /// </summary>
+    public SnapshotStorageStrategy StorageStrategy { get; set; } = SnapshotStorageStrategy.SameStream;
+
+    public SnapshotsAttribute(params Type[] snapshotTypes) {
+        SnapshotTypes = snapshotTypes;
+    }
+}
\ No newline at end of file

From a3a060b0634da4073add7f7da5edb72fb59eec65 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Sun, 7 Dec 2025 13:46:34 +0300
Subject: [PATCH 08/25] enhance SnapshotMappingsGenerator and SnapshotTypeMap
 to support storage strategies. Added logic to retrieve and register storage
 strategies for snapshots, ensuring proper handling during snapshot type
 registration

---
 .../SnapshotMappingsGenerator.cs              | 54 +++++++++++++++++--
 .../SnapshotMap/SnapshotTypeMap.cs            | 19 ++++++-
 2 files changed, 69 insertions(+), 4 deletions(-)

diff --git a/src/Core/gen/Eventuous.Shared.Generators/SnapshotMappingsGenerator.cs b/src/Core/gen/Eventuous.Shared.Generators/SnapshotMappingsGenerator.cs
index d529928f..2cd2391b 100644
--- a/src/Core/gen/Eventuous.Shared.Generators/SnapshotMappingsGenerator.cs
+++ b/src/Core/gen/Eventuous.Shared.Generators/SnapshotMappingsGenerator.cs
@@ -39,12 +39,15 @@ public sealed class SnapshotMappingsGenerator : IIncrementalGenerator {
             }
         }
 
+        var storageStrategy = GetStorageStrategyFromAttribute(snapshotsAttr);
+
         var stateType = classSymbol.BaseType?.TypeArguments[0];
         if (stateType == null) return null;
 
         return new Map {
             SnapshotTypes = snapshotTypes,
-            StateType = MakeGlobal(classSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat))
+            StateType = MakeGlobal(classSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)),
+            StorageStrategy = storageStrategy
         };
     }
 
@@ -100,7 +103,8 @@ void ProcessType(INamedTypeSymbol type) {
             if (attr is not null) {
                 var map = new Map {
                     SnapshotTypes = GetTypesFromSnapshotsAttribute(attr),
-                    StateType = MakeGlobal(type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat))
+                    StateType = MakeGlobal(type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)),
+                    StorageStrategy = GetStorageStrategyFromAttribute(attr)
                 };
 
                 builder.Add(map);
@@ -139,8 +143,15 @@ static void Output(SourceProductionContext context, ImmutableArray<Map> maps) {
         sb.AppendLine("    internal static void Initialize() {");
 
         foreach (var map in maps) {
+            var strategyValue = map.StorageStrategy switch {
+                "SameStream" => "SnapshotStorageStrategy.SameStream",
+                "SeparateStream" => "SnapshotStorageStrategy.SeparateStream",
+                "SeparateStore" => "SnapshotStorageStrategy.SeparateStore",
+                _ => "SnapshotStorageStrategy.SameStream"
+            };
+
             foreach (var snapshotType in map.SnapshotTypes) {
-                sb.AppendLine($"        SnapshotTypeMap.Register(typeof({map.StateType}), typeof({snapshotType}));");
+                sb.AppendLine($"        SnapshotTypeMap.Register(typeof({map.StateType}), typeof({snapshotType}), {strategyValue});");
             }
         }
 
@@ -190,8 +201,45 @@ static bool IsState(INamedTypeSymbol type) {
         return null;
     }
 
+    static string GetStorageStrategyFromAttribute(AttributeData attributeData) {
+        foreach (var namedArg in attributeData.NamedArguments) {
+            if (namedArg.Key == "StorageStrategy" && namedArg.Value.Kind == TypedConstantKind.Enum) {
+                // Try to get the enum value name from the typed constant
+                var enumType = namedArg.Value.Type;
+                if (enumType != null) {
+                    // Get the enum value as a string representation
+                    var enumValue = namedArg.Value.Value;
+                    if (enumValue != null) {
+                        // Try to find the enum member with this value
+                        var enumMembers = enumType.GetMembers().OfType<IFieldSymbol>()
+                            .Where(f => f.IsStatic && f.IsDefinition && f.ConstantValue != null);
+                        
+                        foreach (var member in enumMembers) {
+                            if (Equals(member.ConstantValue, enumValue)) {
+                                return member.Name;
+                            }
+                        }
+                        
+                        // Fallback: map numeric values
+                        if (enumValue is int intValue) {
+                            return intValue switch {
+                                0 => "SameStream",
+                                1 => "SeparateStream",
+                                2 => "SeparateStore",
+                                _ => "SameStream"
+                            };
+                        }
+                    }
+                }
+            }
+        }
+
+        return "SameStream"; // Default value
+    }
+
     sealed record Map {
         public string StateType { get; set; } = null!;
         public HashSet<string> SnapshotTypes { get; set; } = [];
+        public string StorageStrategy { get; set; } = "SameStream";
     }
 }
\ No newline at end of file
diff --git a/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotTypeMap.cs b/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotTypeMap.cs
index f88ae451..6e842b58 100644
--- a/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotTypeMap.cs
+++ b/src/Core/src/Eventuous.Shared/SnapshotMap/SnapshotTypeMap.cs
@@ -6,14 +6,31 @@ namespace Eventuous;
 public static class SnapshotTypeMap {
 
     static readonly Dictionary<Type, HashSet<Type>> StateToSnapshots = [];
+    static readonly Dictionary<Type, SnapshotStorageStrategy> StateToStorageStrategy = [];
 
-    public static void Register(Type stateType, Type eventType) {
+    public static void Register(Type stateType, Type eventType, SnapshotStorageStrategy storageStrategy = SnapshotStorageStrategy.SameStream) {
         if (StateToSnapshots.TryGetValue(stateType, out var value)) {
             value.Add(eventType);
         } else {
             StateToSnapshots[stateType] = [eventType];
+            // Store strategy for the state type when first registering snapshots for this state
+            StateToStorageStrategy[stateType] = storageStrategy;
         }
     }
 
     public static HashSet<Type> GetSnapshotTypes<TState>() => StateToSnapshots.GetValueOrDefault(typeof(TState), []);
+
+    /// <summary>
+    /// Gets the storage strategy for the specified state type
+    /// </summary>
+    /// <typeparam name="TState">The state type</typeparam>
+    /// <returns>The storage strategy, or <see cref="SnapshotStorageStrategy.SameStream"/> if not specified</returns>
+    public static SnapshotStorageStrategy GetStorageStrategy<TState>() => GetStorageStrategy(typeof(TState));
+
+    /// <summary>
+    /// Gets the storage strategy for the specified state type
+    /// </summary>
+    /// <param name="stateType">The state type</param>
+    /// <returns>The storage strategy, or <see cref="SnapshotStorageStrategy.SameStream"/> if not specified</returns>
+    public static SnapshotStorageStrategy GetStorageStrategy(Type stateType) => StateToStorageStrategy.GetValueOrDefault(stateType, SnapshotStorageStrategy.SameStream);
 }

From 430b8d952bd22bec5dc397a32d3b520485dadf8e Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Sun, 7 Dec 2025 15:31:30 +0300
Subject: [PATCH 09/25] add ISnapshotStore interface and Snapshot record for
 snapshot management

---
 .../SnapshotStore/ISnapshotStore.cs           | 41 +++++++++++++++++++
 .../SnapshotStore/Snapshot.cs                 | 20 +++++++++
 2 files changed, 61 insertions(+)
 create mode 100644 src/Core/src/Eventuous.Persistence/SnapshotStore/ISnapshotStore.cs
 create mode 100644 src/Core/src/Eventuous.Persistence/SnapshotStore/Snapshot.cs

diff --git a/src/Core/src/Eventuous.Persistence/SnapshotStore/ISnapshotStore.cs b/src/Core/src/Eventuous.Persistence/SnapshotStore/ISnapshotStore.cs
new file mode 100644
index 00000000..3b2ccd99
--- /dev/null
+++ b/src/Core/src/Eventuous.Persistence/SnapshotStore/ISnapshotStore.cs
@@ -0,0 +1,41 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+namespace Eventuous;
+
+/// <summary>
+/// Snapshot store for storing and retrieving snapshot events separately from the main event stream.
+/// Used when <see cref="SnapshotStorageStrategy.SeparateStore"/> is configured.
+/// </summary>
+[PublicAPI]
+public interface ISnapshotStore {
+    /// <summary>
+    /// Reads the latest snapshot for the specified stream
+    /// </summary>
+    /// <param name="streamName">Stream name to read snapshot for</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    /// <returns>Snapshot data if found, null otherwise</returns>
+    [RequiresDynamicCode(AttrConstants.DynamicSerializationMessage)]
+    [RequiresUnreferencedCode(AttrConstants.DynamicSerializationMessage)]
+    Task<Snapshot?> Read(StreamName streamName, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Writes a snapshot to the store
+    /// </summary>
+    /// <param name="streamName">Stream name to write snapshot for</param>
+    /// <param name="snapshot">Snapshot data to write</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    /// <returns>Task representing the write operation</returns>
+    [RequiresDynamicCode(AttrConstants.DynamicSerializationMessage)]
+    [RequiresUnreferencedCode(AttrConstants.DynamicSerializationMessage)]
+    Task Write(StreamName streamName, Snapshot snapshot, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Deletes a snapshot for the specified stream
+    /// </summary>
+    /// <param name="streamName">Stream name to delete snapshot for</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    /// <returns>Task representing the delete operation</returns>
+    Task Delete(StreamName streamName, CancellationToken cancellationToken = default);
+}
+
diff --git a/src/Core/src/Eventuous.Persistence/SnapshotStore/Snapshot.cs b/src/Core/src/Eventuous.Persistence/SnapshotStore/Snapshot.cs
new file mode 100644
index 00000000..0673ddf3
--- /dev/null
+++ b/src/Core/src/Eventuous.Persistence/SnapshotStore/Snapshot.cs
@@ -0,0 +1,20 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+namespace Eventuous;
+
+/// <summary>
+/// Represents a snapshot event with its metadata
+/// </summary>
+public record Snapshot {
+    /// <summary>
+    /// Stream revision at the time of snapshot creation
+    /// </summary>
+    public long Revision { get; init; }
+
+    /// <summary>
+    /// The snapshot event payload
+    /// </summary>
+    public object? Payload { get; init; }
+}
+

From fa96de61c307cf07488aab5454a5433c247f50e0 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Sun, 7 Dec 2025 16:08:26 +0300
Subject: [PATCH 10/25] implement ISnapshotStore support in LoadAggregate and
 LoadState functions

---
 .../FunctionalService/CommandService.cs       |  4 +-
 .../AggregatePersistenceExtensions.cs         | 65 ++++++++++++++++++-
 .../AggregateStore/AggregateStore.cs          |  4 +-
 .../AggregateStoreWithArchive.cs              |  4 +-
 .../StateStore/StateStoreFunctions.cs         | 65 ++++++++++++++++++-
 .../src/Eventuous.Shared/Store/StreamName.cs  | 11 ++++
 6 files changed, 141 insertions(+), 12 deletions(-)

diff --git a/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs b/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
index 5563b2f2..393f215a 100644
--- a/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
+++ b/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
@@ -82,8 +82,8 @@ public async Task<Result<TState>> Handle<TCommand>(TCommand command, Cancellatio
 
         try {
             var loadedState = registeredHandler.ExpectedState switch {
-                ExpectedState.Any      => await resolvedReader.LoadState<TState>(streamName, false, cancellationToken).NoContext(),
-                ExpectedState.Existing => await resolvedReader.LoadState<TState>(streamName, true, cancellationToken).NoContext(),
+                ExpectedState.Any      => await resolvedReader.LoadState<TState>(streamName, false, null, cancellationToken).NoContext(),
+                ExpectedState.Existing => await resolvedReader.LoadState<TState>(streamName, true, null, cancellationToken).NoContext(),
                 ExpectedState.New      => new(streamName, ExpectedStreamVersion.NoStream, []),
                 _                      => throw new ArgumentOutOfRangeException(null, "Unknown expected state")
             };
diff --git a/src/Core/src/Eventuous.Persistence/AggregateStore/AggregatePersistenceExtensions.cs b/src/Core/src/Eventuous.Persistence/AggregateStore/AggregatePersistenceExtensions.cs
index 30e264f8..c66fb76d 100644
--- a/src/Core/src/Eventuous.Persistence/AggregateStore/AggregatePersistenceExtensions.cs
+++ b/src/Core/src/Eventuous.Persistence/AggregateStore/AggregatePersistenceExtensions.cs
@@ -109,6 +109,7 @@ public Task<AppendEventsResult> StoreAggregate<TAggregate, TState, TId>(
         /// <param name="streamName">Name of the aggregate stream</param>
         /// <param name="failIfNotFound">Either fail if the stream is not found, default is false</param>
         /// <param name="factoryRegistry">Optional: aggregate factory registry. Default instance will be used if the argument isn't provided.</param>
+        /// <param name="snapshotStore">Optional snapshot store for SeparateStore strategy</param>
         /// <param name="cancellationToken">Cancellation token</param>
         /// <typeparam name="TAggregate">Aggregate type</typeparam>
         /// <typeparam name="TState">Aggregate state type</typeparam>
@@ -121,6 +122,7 @@ public Task<AppendEventsResult> StoreAggregate<TAggregate, TState, TId>(
                 StreamName                streamName,
                 bool                      failIfNotFound    = true,
                 AggregateFactoryRegistry? factoryRegistry   = null,
+                ISnapshotStore?           snapshotStore     = null,
                 CancellationToken         cancellationToken = default
             )
             where TAggregate : Aggregate<TState> where TState : State<TState>, new() {
@@ -128,10 +130,65 @@ public Task<AppendEventsResult> StoreAggregate<TAggregate, TState, TId>(
 
             try {
                 StreamEvent[] events;
-
                 var snapshotTypes = SnapshotTypeMap.GetSnapshotTypes<TState>();
+                var storageStrategy = SnapshotTypeMap.GetStorageStrategy<TState>();
+
                 if (snapshotTypes.Count != 0) {
-                    events = await eventReader.ReadStreamAfterSnapshot(streamName, snapshotTypes, failIfNotFound, cancellationToken).NoContext();
+                    switch (storageStrategy) {
+                        case SnapshotStorageStrategy.SameStream:
+                            events = await eventReader.ReadStreamAfterSnapshot(streamName, snapshotTypes, failIfNotFound, cancellationToken).NoContext();
+                            break;
+
+                        case SnapshotStorageStrategy.SeparateStream: {
+                            var snapshotStreamName = StreamName.ForSnapshot(streamName);
+                            var snapshotEvents = await eventReader.ReadEventsBackwards(snapshotStreamName, StreamReadPosition.End, 1, false, cancellationToken).NoContext();
+                            
+                            StreamEvent? snapshotEvent = null;
+
+                            if (snapshotEvents.Length > 0) {
+                                var candidate = snapshotEvents[0];
+                                if (candidate.Payload != null && snapshotTypes.Contains(candidate.Payload.GetType())) {
+                                    snapshotEvent = candidate;
+                                }
+                            }
+                            
+                            if (snapshotEvent.HasValue) {
+                                var snapshotRevision = snapshotEvent.Value.Revision;
+                                var eventsAfterSnapshot = await eventReader.ReadStream(streamName, new(snapshotRevision + 1), failIfNotFound, cancellationToken).NoContext();
+                                events = [snapshotEvent.Value, ..eventsAfterSnapshot];
+                            } else {
+                                events = await eventReader.ReadStream(streamName, StreamReadPosition.Start, failIfNotFound, cancellationToken).NoContext();
+                            }
+                            break;
+                        }
+
+                        case SnapshotStorageStrategy.SeparateStore: {
+                            if (snapshotStore == null) {
+                                throw new InvalidOperationException($"Snapshot store is required for {nameof(SnapshotStorageStrategy.SeparateStore)} strategy");
+                            }
+
+                            var snapshot = await snapshotStore.Read(streamName, cancellationToken).NoContext();
+                            
+                            if (snapshot != null) {
+                                var snapshotEvent = new StreamEvent(
+                                    Guid.Empty,
+                                    snapshot.Payload,
+                                    [],
+                                    string.Empty,
+                                    snapshot.Revision
+                                );
+                                var eventsAfterSnapshot = await eventReader.ReadStream(streamName, new(snapshot.Revision + 1), failIfNotFound, cancellationToken).NoContext();
+                                events = [snapshotEvent, ..eventsAfterSnapshot];
+                            } else {
+                                events = await eventReader.ReadStream(streamName, StreamReadPosition.Start, failIfNotFound, cancellationToken).NoContext();
+                            }
+                            break;
+                        }
+
+                        default:
+                            events = await eventReader.ReadStream(streamName, StreamReadPosition.Start, failIfNotFound, cancellationToken).NoContext();
+                            break;
+                    }
                 } else {
                     events = await eventReader.ReadStream(streamName, StreamReadPosition.Start, failIfNotFound, cancellationToken).NoContext();
                 }
@@ -156,6 +213,7 @@ public Task<AppendEventsResult> StoreAggregate<TAggregate, TState, TId>(
         /// <param name="streamNameMap">Optional: stream name map. Default instance is used when argument isn't provided.</param>
         /// <param name="failIfNotFound">Either fail if the stream is not found, default is false</param>
         /// <param name="factoryRegistry">Optional: aggregate factory registry. Default instance will be used if the argument isn't provided.</param>
+        /// <param name="snapshotStore">Optional snapshot store for SeparateStore strategy</param>
         /// <param name="cancellationToken">Cancellation token</param>
         /// <typeparam name="TAggregate">Aggregate type</typeparam>
         /// <typeparam name="TState">Aggregate state type</typeparam>
@@ -170,12 +228,13 @@ public Task<AppendEventsResult> StoreAggregate<TAggregate, TState, TId>(
                 StreamNameMap?            streamNameMap     = null,
                 bool                      failIfNotFound    = true,
                 AggregateFactoryRegistry? factoryRegistry   = null,
+                ISnapshotStore?           snapshotStore     = null,
                 CancellationToken         cancellationToken = default
             )
             where TAggregate : Aggregate<TState> where TState : State<TState>, new() where TId : Id {
             var streamName = streamNameMap?.GetStreamName<TAggregate, TState, TId>(aggregateId)
              ?? StreamNameFactory.For<TAggregate, TState, TId>(aggregateId);
-            var aggregate = await eventReader.LoadAggregate<TAggregate, TState>(streamName, failIfNotFound, factoryRegistry, cancellationToken).NoContext();
+            var aggregate = await eventReader.LoadAggregate<TAggregate, TState>(streamName, failIfNotFound, factoryRegistry, snapshotStore, cancellationToken).NoContext();
 
             return aggregate.WithId<TAggregate, TState, TId>(aggregateId);
         }
diff --git a/src/Core/src/Eventuous.Persistence/AggregateStore/AggregateStore.cs b/src/Core/src/Eventuous.Persistence/AggregateStore/AggregateStore.cs
index aeda1b03..a91a75bd 100644
--- a/src/Core/src/Eventuous.Persistence/AggregateStore/AggregateStore.cs
+++ b/src/Core/src/Eventuous.Persistence/AggregateStore/AggregateStore.cs
@@ -43,7 +43,7 @@ public Task<AppendEventsResult> Store<TAggregate, TState>(StreamName streamName,
     [RequiresDynamicCode(AttrConstants.DynamicSerializationMessage)]
     [RequiresUnreferencedCode(AttrConstants.DynamicSerializationMessage)]
     public Task<T> Load<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T, TState>(StreamName streamName, CancellationToken cancellationToken) where T : Aggregate<TState> where TState : State<TState>, new()
-        => _eventReader.LoadAggregate<T, TState>(streamName, true, _factoryRegistry, cancellationToken);
+        => _eventReader.LoadAggregate<T, TState>(streamName, true, _factoryRegistry, null, cancellationToken);
 
     /// <inheritdoc/>
     [Obsolete("Use IEventReader.LoadAggregate<TAggregate, TState> instead.")]
@@ -51,5 +51,5 @@ public Task<AppendEventsResult> Store<TAggregate, TState>(StreamName streamName,
     [RequiresUnreferencedCode(AttrConstants.DynamicSerializationMessage)]
     public Task<T> LoadOrNew<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T, TState>(StreamName streamName, CancellationToken cancellationToken)
         where T : Aggregate<TState> where TState : State<TState>, new()
-        => _eventReader.LoadAggregate<T, TState>(streamName, false, _factoryRegistry, cancellationToken);
+        => _eventReader.LoadAggregate<T, TState>(streamName, false, _factoryRegistry, null, cancellationToken);
 }
diff --git a/src/Core/src/Eventuous.Persistence/AggregateStore/AggregateStoreWithArchive.cs b/src/Core/src/Eventuous.Persistence/AggregateStore/AggregateStoreWithArchive.cs
index 52ae93be..11e7ad7d 100644
--- a/src/Core/src/Eventuous.Persistence/AggregateStore/AggregateStoreWithArchive.cs
+++ b/src/Core/src/Eventuous.Persistence/AggregateStore/AggregateStoreWithArchive.cs
@@ -26,12 +26,12 @@ public Task<AppendEventsResult> Store<TAggregate, TState>(StreamName streamName,
     [RequiresUnreferencedCode(AttrConstants.DynamicSerializationMessage)]
     public Task<TAggregate> Load<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] TAggregate, TState>(StreamName streamName, CancellationToken cancellationToken)
         where TAggregate : Aggregate<TState> where TState : State<TState>, new()
-        => _tieredEventStore.LoadAggregate<TAggregate, TState>(streamName, true, _factoryRegistry, cancellationToken);
+        => _tieredEventStore.LoadAggregate<TAggregate, TState>(streamName, true, _factoryRegistry, null, cancellationToken);
 
     /// <inheritdoc/>
     [RequiresDynamicCode(AttrConstants.DynamicSerializationMessage)]
     [RequiresUnreferencedCode(AttrConstants.DynamicSerializationMessage)]
     public Task<TAggregate> LoadOrNew<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] TAggregate, TState>(StreamName streamName, CancellationToken cancellationToken)
         where TAggregate : Aggregate<TState> where TState : State<TState>, new()
-        => _tieredEventStore.LoadAggregate<TAggregate, TState>(streamName, false, _factoryRegistry, cancellationToken);
+        => _tieredEventStore.LoadAggregate<TAggregate, TState>(streamName, false, _factoryRegistry, null, cancellationToken);
 }
diff --git a/src/Core/src/Eventuous.Persistence/StateStore/StateStoreFunctions.cs b/src/Core/src/Eventuous.Persistence/StateStore/StateStoreFunctions.cs
index 39c74115..f8cbcc9e 100644
--- a/src/Core/src/Eventuous.Persistence/StateStore/StateStoreFunctions.cs
+++ b/src/Core/src/Eventuous.Persistence/StateStore/StateStoreFunctions.cs
@@ -13,6 +13,7 @@ public static class StateStoreFunctions {
         /// </summary>
         /// <param name="streamName">Name of the stream to read from</param>
         /// <param name="failIfNotFound">When set to false and there's no stream, the function will return an empty instance.</param>
+        /// <param name="snapshotStore">Optional snapshot store for SeparateStore strategy</param>
         /// <param name="cancellationToken">Cancellation token</param>
         /// <typeparam name="TState">State object type</typeparam>
         /// <returns>Instance of <seealso cref="FoldedEventStream{T}"/> containing events and folded state</returns>
@@ -22,14 +23,70 @@ public static class StateStoreFunctions {
         public async Task<FoldedEventStream<TState>> LoadState<TState>(
                 StreamName        streamName,
                 bool              failIfNotFound    = true,
+                ISnapshotStore?   snapshotStore     = null,
                 CancellationToken cancellationToken = default
             ) where TState : State<TState>, new() {
             try {
                 StreamEvent[] streamEvents;
-
                 var snapshotTypes = SnapshotTypeMap.GetSnapshotTypes<TState>();
+                var storageStrategy = SnapshotTypeMap.GetStorageStrategy<TState>();
+
                 if (snapshotTypes.Count != 0) {
-                    streamEvents = await reader.ReadStreamAfterSnapshot(streamName, snapshotTypes, failIfNotFound, cancellationToken);
+                    switch (storageStrategy) {
+                        case SnapshotStorageStrategy.SameStream:
+                            streamEvents = await reader.ReadStreamAfterSnapshot(streamName, snapshotTypes, failIfNotFound, cancellationToken);
+                            break;
+
+                        case SnapshotStorageStrategy.SeparateStream: {
+                            var snapshotStreamName = StreamName.ForSnapshot(streamName);
+                            var snapshotEvents = await reader.ReadEventsBackwards(snapshotStreamName, StreamReadPosition.End, 1, false, cancellationToken).NoContext();
+
+                            StreamEvent? snapshotEvent = null;
+
+                            if (snapshotEvents.Length > 0) {
+                                var candidate = snapshotEvents[0];
+                                if (candidate.Payload != null && snapshotTypes.Contains(candidate.Payload.GetType())) {
+                                    snapshotEvent = candidate;
+                                }
+                            }
+
+                            if (snapshotEvent.HasValue) {
+                                var snapshotRevision = snapshotEvent.Value.Revision;
+                                var eventsAfterSnapshot = await reader.ReadStream(streamName, new(snapshotRevision + 1), failIfNotFound, cancellationToken).NoContext();
+                                streamEvents = [snapshotEvent.Value, ..eventsAfterSnapshot];
+                            } else {
+                                streamEvents = await reader.ReadStream(streamName, StreamReadPosition.Start, failIfNotFound, cancellationToken).NoContext();
+                            }
+                            break;
+                        }
+
+                        case SnapshotStorageStrategy.SeparateStore: {
+                            if (snapshotStore == null) {
+                                throw new InvalidOperationException($"Snapshot store is required for {nameof(SnapshotStorageStrategy.SeparateStore)} strategy");
+                            }
+
+                            var snapshot = await snapshotStore.Read(streamName, cancellationToken).NoContext();
+
+                            if (snapshot != null) {
+                                var snapshotEvent = new StreamEvent(
+                                    Guid.Empty,
+                                    snapshot.Payload,
+                                    [],
+                                    string.Empty,
+                                    snapshot.Revision
+                                );
+                                var eventsAfterSnapshot = await reader.ReadStream(streamName, new(snapshot.Revision + 1), failIfNotFound, cancellationToken).NoContext();
+                                streamEvents = [snapshotEvent, ..eventsAfterSnapshot];
+                            } else {
+                                streamEvents = await reader.ReadStream(streamName, StreamReadPosition.Start, failIfNotFound, cancellationToken).NoContext();
+                            }
+                            break;
+                        }
+
+                        default:
+                            streamEvents = await reader.ReadStream(streamName, StreamReadPosition.Start, failIfNotFound, cancellationToken).NoContext();
+                            break;
+                    }
                 } else {
                     streamEvents = await reader.ReadStream(streamName, StreamReadPosition.Start, failIfNotFound, cancellationToken).NoContext();
                 }
@@ -52,6 +109,7 @@ public async Task<FoldedEventStream<TState>> LoadState<TState>(
         /// </summary>
         /// <param name="id">State identity value</param>
         /// <param name="failIfNotFound">When set to false and there's no stream, the function will return an empty instance.</param>
+        /// <param name="snapshotStore">Optional snapshot store for SeparateStore strategy</param>
         /// <param name="cancellationToken">Cancellation token</param>
         /// <param name="streamNameMap">Mapper between identity and stream name</param>
         /// <typeparam name="TState">State object type</typeparam>
@@ -63,10 +121,11 @@ public async Task<FoldedEventStream<TState>> LoadState<TState, TId>(
                 StreamNameMap     streamNameMap,
                 TId               id,
                 bool              failIfNotFound    = true,
+                ISnapshotStore?   snapshotStore    = null,
                 CancellationToken cancellationToken = default
             )
             where TState : State<TState>, new() where TId : Id {
-            var foldedStream = await reader.LoadState<TState>(streamNameMap.GetStreamName(id), failIfNotFound, cancellationToken).NoContext();
+            var foldedStream = await reader.LoadState<TState>(streamNameMap.GetStreamName(id), failIfNotFound, snapshotStore, cancellationToken).NoContext();
 
             return foldedStream with { State = foldedStream.State.WithId(id) };
         }
diff --git a/src/Core/src/Eventuous.Shared/Store/StreamName.cs b/src/Core/src/Eventuous.Shared/Store/StreamName.cs
index 2f02d9be..6efc9b48 100644
--- a/src/Core/src/Eventuous.Shared/Store/StreamName.cs
+++ b/src/Core/src/Eventuous.Shared/Store/StreamName.cs
@@ -30,6 +30,17 @@ public static StreamName ForState<TState>(string entityId) {
     public readonly string GetId() => Value[(Value.IndexOf('-') + 1)..];
     public readonly string GetCategory() => Value[..Value.IndexOf('-')];
 
+    /// <summary>
+    /// Creates a snapshot stream name by adding "Snapshot" suffix after the category
+    /// </summary>
+    /// <param name="originalStream">Original stream name</param>
+    /// <returns>Snapshot stream name in format: {Category}Snapshot-{Id}</returns>
+    public static StreamName ForSnapshot(StreamName originalStream) {
+        var category = originalStream.GetCategory();
+        var id = originalStream.GetId();
+        return new($"{category}Snapshot-{id}");
+    }
+
     public static implicit operator string(StreamName streamName) => streamName.Value;
 
     public override readonly string ToString() => Value;

From f9bd21b69736dce64474c60cf165dc71e05df4b2 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Sun, 7 Dec 2025 16:17:10 +0300
Subject: [PATCH 11/25] fix build

---
 .../Eventuous.Application/AggregateService/CommandService.cs  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs b/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
index 45111b4d..110515d7 100644
--- a/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
+++ b/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
@@ -76,10 +76,10 @@ public async Task<Result<TState>> Handle<TCommand>(TCommand command, Cancellatio
         try {
             var aggregate = registeredHandler.ExpectedState switch {
                 ExpectedState.Any => await reader
-                    .LoadAggregate<TAggregate, TState, TId>(aggregateId, _streamNameMap, false, _factoryRegistry, cancellationToken)
+                    .LoadAggregate<TAggregate, TState, TId>(aggregateId, _streamNameMap, false, _factoryRegistry, null, cancellationToken)
                     .NoContext(),
                 ExpectedState.Existing => await reader
-                    .LoadAggregate<TAggregate, TState, TId>(aggregateId, _streamNameMap, true, _factoryRegistry, cancellationToken)
+                    .LoadAggregate<TAggregate, TState, TId>(aggregateId, _streamNameMap, true, _factoryRegistry, null,cancellationToken)
                     .NoContext(),
                 ExpectedState.New     => Create(aggregateId),
                 ExpectedState.Unknown => null,

From 5771bb94b5757412d12650d3674a1e62e03a0d40 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Sun, 7 Dec 2025 19:37:17 +0300
Subject: [PATCH 12/25] add ISnapshotStore support to CommandService and
 FunctionalCommandService; implement snapshot handling logic for
 SeparateStream and SeparateStore strategies

---
 .../AggregateService/CommandService.cs        | 104 +++++++++++++++-
 .../FunctionalService/CommandService.cs       | 112 ++++++++++++++++--
 2 files changed, 202 insertions(+), 14 deletions(-)

diff --git a/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs b/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
index 110515d7..9a3f6844 100644
--- a/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
+++ b/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
@@ -20,7 +20,8 @@ public abstract partial class CommandService<[DynamicallyAccessedMembers(Dynamic
         AggregateFactoryRegistry? factoryRegistry = null,
         StreamNameMap?            streamNameMap   = null,
         ITypeMapper?              typeMap         = null,
-        AmendEvent?               amendEvent      = null
+        AmendEvent?               amendEvent      = null,
+        ISnapshotStore?           snapshotStore   = null
     )
     : ICommandService<TAggregate, TState, TId>
     where TAggregate : Aggregate<TState>
@@ -31,8 +32,9 @@ protected CommandService(
             AggregateFactoryRegistry? factoryRegistry = null,
             StreamNameMap?            streamNameMap   = null,
             ITypeMapper?              typeMap         = null,
-            AmendEvent?               amendEvent      = null
-        ) : this(store, store, factoryRegistry, streamNameMap, typeMap, amendEvent) { }
+            AmendEvent?               amendEvent      = null,
+            ISnapshotStore?           snapshotStore   = null
+        ) : this(store, store, factoryRegistry, streamNameMap, typeMap, amendEvent, snapshotStore) { }
 
     [PublicAPI]
     protected IEventReader? Reader { get; } = reader;
@@ -43,6 +45,7 @@ protected CommandService(
     readonly AggregateFactoryRegistry             _factoryRegistry = factoryRegistry ?? AggregateFactoryRegistry.Instance;
     readonly StreamNameMap                        _streamNameMap   = streamNameMap   ?? new StreamNameMap();
     readonly ITypeMapper                          _typeMap         = typeMap         ?? TypeMap.Instance;
+    readonly ISnapshotStore?                      _snapshotStore   = snapshotStore;
 
     /// <summary>
     /// Returns the command handler builder for the specified command type.
@@ -91,11 +94,24 @@ public async Task<Result<TState>> Handle<TCommand>(TCommand command, Cancellatio
             // Zero in the global position would mean nothing, so the receiver needs to check the Changes.Length
             if (result.Changes.Count == 0) return Result<TState>.FromSuccess(result.State, [], 0);
 
-            var proposed    = new ProposedAppend(stream, new(result.OriginalVersion), result.Changes.Select(x => new ProposedEvent(x, new())).ToArray());
+            // Separate snapshots from regular events based on storage strategy
+            var snapshotTypes = SnapshotTypeMap.GetSnapshotTypes<TState>();
+            var storageStrategy = SnapshotTypeMap.GetStorageStrategy<TState>();
+            var allEvents = result.Changes.Select(x => new ProposedEvent(x, new())).ToArray();
+            var (regularEvents, snapshotEvents) = SeparateSnapshots(allEvents, snapshotTypes, storageStrategy);
+
+            // Store regular events first
+            var proposed    = new ProposedAppend(stream, new(result.OriginalVersion), regularEvents);
             var final       = registeredHandler.AmendAppend?.Invoke(proposed, command) ?? proposed;
             var writer      = registeredHandler.ResolveWriter(command);
             var storeResult = await writer.Store(final, Amend, cancellationToken).NoContext();
-            var changes     = result.Changes.Select(x => Change.FromEvent(x, _typeMap));
+
+            // Handle snapshots based on strategy
+            if (snapshotEvents.Length > 0 && storageStrategy != SnapshotStorageStrategy.SameStream) {
+                await HandleSnapshots(stream, snapshotEvents, storeResult.NextExpectedVersion, storageStrategy, writer, cancellationToken).NoContext();
+            }
+
+            var changes = result.Changes.Select(x => Change.FromEvent(x, _typeMap));
             Log.CommandHandled<TCommand>();
 
             return Result<TState>.FromSuccess(result.State, changes, storeResult.GlobalPosition);
@@ -116,4 +132,82 @@ NewStreamEvent Amend(NewStreamEvent streamEvent) {
 
     internal void AddHandler<TCommand>(RegisteredHandler<TAggregate, TState, TId> handler) where TCommand : class
         => _handlers.AddHandler<TCommand>(handler);
+
+    static (ProposedEvent[] RegularEvents, ProposedEvent[] SnapshotEvents) SeparateSnapshots(
+        ProposedEvent[] events,
+        HashSet<Type> snapshotTypes,
+        SnapshotStorageStrategy strategy
+    ) {
+        if (strategy == SnapshotStorageStrategy.SameStream || snapshotTypes.Count == 0) {
+            return (events, []);
+        }
+
+        var regularEvents = new List<ProposedEvent>();
+        var snapshotEvents = new List<ProposedEvent>();
+
+        foreach (var evt in events) {
+            if (evt.Data != null && snapshotTypes.Contains(evt.Data.GetType())) {
+                snapshotEvents.Add(evt);
+            } else {
+                regularEvents.Add(evt);
+            }
+        }
+
+        return (regularEvents.ToArray(), snapshotEvents.ToArray());
+    }
+
+    [RequiresDynamicCode(AttrConstants.DynamicSerializationMessage)]
+    [RequiresUnreferencedCode(AttrConstants.DynamicSerializationMessage)]
+    async Task HandleSnapshots(
+        StreamName streamName,
+        ProposedEvent[] snapshotEvents,
+        long streamRevision,
+        SnapshotStorageStrategy strategy,
+        IEventWriter writer,
+        CancellationToken cancellationToken
+    ) {
+        if (snapshotEvents.Length == 0) return;
+
+        // Take the last snapshot if multiple
+        var snapshotEvent = snapshotEvents[^1];
+
+        switch (strategy) {
+            case SnapshotStorageStrategy.SeparateStream: {
+                var snapshotStreamName = StreamName.ForSnapshot(streamName);
+                var store = writer as IEventStore;                
+                if (store == null) {
+                    throw new InvalidOperationException($"IEventStore is required for {nameof(SnapshotStorageStrategy.SeparateStream)} strategy. IEventWriter must implement IEventStore.");
+                }
+
+                var snapshotAppend = new ProposedAppend(
+                    snapshotStreamName,
+                    ExpectedStreamVersion.Any,
+                    [snapshotEvent]
+                );
+
+                var result = await writer.Store(snapshotAppend, null, cancellationToken).NoContext();
+
+                await store.TruncateStream(
+                    snapshotStreamName,
+                    new StreamTruncatePosition(result.NextExpectedVersion),
+                    new ExpectedStreamVersion(result.NextExpectedVersion),
+                    cancellationToken);
+
+                break;
+            }
+
+            case SnapshotStorageStrategy.SeparateStore: {
+                if (_snapshotStore == null) {
+                    throw new InvalidOperationException($"Snapshot store is required for {nameof(SnapshotStorageStrategy.SeparateStore)} strategy");
+                }
+
+                var snapshot = new Snapshot {
+                    Revision = streamRevision,
+                    Payload = snapshotEvent.Data
+                };
+                await _snapshotStore.Write(streamName, snapshot, cancellationToken).NoContext();
+                break;
+            }
+        }
+    }
 }
diff --git a/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs b/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
index 393f215a..e8d35e02 100644
--- a/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
+++ b/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
@@ -8,10 +8,10 @@ namespace Eventuous;
 using static Diagnostics.ApplicationEventSource;
 
 [Obsolete("Use CommandService<TState>")]
-public abstract class FunctionalCommandService<TState>(IEventReader reader, IEventWriter writer, ITypeMapper? typeMap = null, AmendEvent? amendEvent = null)
-    : CommandService<TState>(reader, writer, typeMap, amendEvent) where TState : State<TState>, new() {
-    protected FunctionalCommandService(IEventStore store, ITypeMapper? typeMap = null, AmendEvent? amendEvent = null)
-        : this(store, store, typeMap, amendEvent) { }
+public abstract class FunctionalCommandService<TState>(IEventReader reader, IEventWriter writer, ITypeMapper? typeMap = null, AmendEvent? amendEvent = null, ISnapshotStore? snapshotStore = null)
+    : CommandService<TState>(reader, writer, typeMap, amendEvent, snapshotStore) where TState : State<TState>, new() {
+    protected FunctionalCommandService(IEventStore store, ITypeMapper? typeMap = null, AmendEvent? amendEvent = null, ISnapshotStore? snapshotStore = null)
+        : this(store, store, typeMap, amendEvent, snapshotStore) { }
 
     [Obsolete("Use On<TCommand>().InState(ExpectedState.New).GetStream(...).Act(...) instead")]
     protected void OnNew<TCommand>(Func<TCommand, StreamName> getStreamName, Func<TCommand, NewEvents> action) where TCommand : class
@@ -36,11 +36,13 @@ protected void OnAny<TCommand>(Func<TCommand, StreamName> getStreamName, Func<TS
 /// <param name="writer">Event writer or event store</param>
 /// <param name="typeMap"><seealso cref="ITypeMapper"/> instance or null to use the default type mapper</param>
 /// <param name="amendEvent">Optional function to add extra information to the event before it gets stored</param>
+/// <param name="snapshotStore">Optional snapshot store for SeparateStore strategy</param>
 /// <typeparam name="TState">State object type</typeparam>
-public abstract class CommandService<TState>(IEventReader reader, IEventWriter writer, ITypeMapper? typeMap = null, AmendEvent? amendEvent = null)
+public abstract class CommandService<TState>(IEventReader reader, IEventWriter writer, ITypeMapper? typeMap = null, AmendEvent? amendEvent = null, ISnapshotStore? snapshotStore = null)
     : ICommandService<TState> where TState : State<TState>, new() {
     readonly ITypeMapper         _typeMap  = typeMap ?? TypeMap.Instance;
-    readonly HandlersMap<TState> _handlers = new();
+    readonly HandlersMap<TState>  _handlers = new();
+    readonly ISnapshotStore?     _snapshotStore = snapshotStore;
 
     /// <summary>
     /// Alternative constructor for the functional command service, which uses an <seealso cref="IEventStore"/> instance for both reading and writing.
@@ -48,8 +50,9 @@ public abstract class CommandService<TState>(IEventReader reader, IEventWriter w
     /// <param name="store">Event store</param>
     /// <param name="typeMap"><seealso cref="ITypeMapper"/> instance or null to use the default type mapper</param>
     /// <param name="amendEvent">Optional function to add extra information to the event before it gets stored</param>
+    /// <param name="snapshotStore">Optional snapshot store for SeparateStore strategy</param>
     // ReSharper disable once UnusedMember.Global
-    protected CommandService(IEventStore store, ITypeMapper? typeMap = null, AmendEvent? amendEvent = null) : this(store, store, typeMap, amendEvent) { }
+    protected CommandService(IEventStore store, ITypeMapper? typeMap = null, AmendEvent? amendEvent = null, ISnapshotStore? snapshotStore = null) : this(store, store, typeMap, amendEvent, snapshotStore) { }
 
     /// <summary>
     /// Returns the command handler builder for the specified command type.
@@ -96,10 +99,22 @@ public async Task<Result<TState>> Handle<TCommand>(TCommand command, Cancellatio
             // Zero in the global position would mean nothing, so the receiver needs to check the Changes.Length
             if (newEvents.Length == 0) return Result<TState>.FromSuccess(newState, [], 0);
 
-            var proposed    = new ProposedAppend(streamName, loadedState.StreamVersion, newEvents);
+            // Separate snapshots from regular events based on storage strategy
+            var snapshotTypes = SnapshotTypeMap.GetSnapshotTypes<TState>();
+            var storageStrategy = SnapshotTypeMap.GetStorageStrategy<TState>();
+            var (regularEvents, snapshotEvents) = SeparateSnapshots(newEvents, snapshotTypes, storageStrategy);
+
+            // Store regular events first
+            var proposed    = new ProposedAppend(streamName, loadedState.StreamVersion, regularEvents);
             var final       = registeredHandler.AmendAppend?.Invoke(proposed, command) ?? proposed;
             var storeResult = await resolvedWriter.Store(final, Amend, cancellationToken).NoContext();
-            var changes     = result.Select(x => Change.FromEvent(x, _typeMap));
+
+            // Handle snapshots based on strategy
+            if (snapshotEvents.Length > 0 && storageStrategy != SnapshotStorageStrategy.SameStream) {
+                await HandleSnapshots(streamName, snapshotEvents, storeResult.NextExpectedVersion, storageStrategy, resolvedWriter, cancellationToken).NoContext();
+            }
+
+            var changes = result.Select(x => Change.FromEvent(x, _typeMap));
             Log.CommandHandled<TCommand>();
 
             return Result<TState>.FromSuccess(newState, changes, storeResult.GlobalPosition);
@@ -119,4 +134,83 @@ NewStreamEvent Amend(NewStreamEvent streamEvent) {
     protected static StreamName GetStream(string id) => StreamName.ForState<TState>(id);
 
     internal void AddHandler<TCommand>(RegisteredHandler<TState> handler) where TCommand : class => _handlers.AddHandler<TCommand>(handler);
+
+    static (ProposedEvent[] RegularEvents, ProposedEvent[] SnapshotEvents) SeparateSnapshots(
+        ProposedEvent[] events,
+        HashSet<Type> snapshotTypes,
+        SnapshotStorageStrategy strategy
+    ) {
+        if (strategy == SnapshotStorageStrategy.SameStream || snapshotTypes.Count == 0) {
+            return (events, []);
+        }
+
+        var regularEvents = new List<ProposedEvent>();
+        var snapshotEvents = new List<ProposedEvent>();
+
+        foreach (var evt in events) {
+            if (evt.Data != null && snapshotTypes.Contains(evt.Data.GetType())) {
+                snapshotEvents.Add(evt);
+            } else {
+                regularEvents.Add(evt);
+            }
+        }
+
+        return (regularEvents.ToArray(), snapshotEvents.ToArray());
+    }
+
+    [RequiresDynamicCode(AttrConstants.DynamicSerializationMessage)]
+    [RequiresUnreferencedCode(AttrConstants.DynamicSerializationMessage)]
+    async Task HandleSnapshots(
+        StreamName streamName,
+        ProposedEvent[] snapshotEvents,
+        long streamRevision,
+        SnapshotStorageStrategy strategy,
+        IEventWriter writer,
+        CancellationToken cancellationToken
+    ) {
+        if (snapshotEvents.Length == 0) return;
+
+        // Take the last snapshot if multiple
+        var snapshotEvent = snapshotEvents[^1];
+
+        switch (strategy) {
+            case SnapshotStorageStrategy.SeparateStream: {
+                var snapshotStreamName = StreamName.ForSnapshot(streamName);
+                var store = writer as IEventStore;
+                
+                if (store == null) {
+                    throw new InvalidOperationException($"IEventStore is required for {nameof(SnapshotStorageStrategy.SeparateStream)} strategy. IEventWriter must implement IEventStore.");
+                }
+
+                var snapshotAppend = new ProposedAppend(
+                    snapshotStreamName,
+                    ExpectedStreamVersion.NoStream,
+                    [snapshotEvent]
+                );
+
+                var result = await writer.Store(snapshotAppend, null, cancellationToken).NoContext();
+
+                await store.TruncateStream(
+                    snapshotStreamName,
+                    new StreamTruncatePosition(result.NextExpectedVersion),
+                    new ExpectedStreamVersion(result.NextExpectedVersion),
+                    cancellationToken);
+
+                    break;
+            }
+
+            case SnapshotStorageStrategy.SeparateStore: {
+                if (_snapshotStore == null) {
+                    throw new InvalidOperationException($"Snapshot store is required for {nameof(SnapshotStorageStrategy.SeparateStore)} strategy");
+                }
+
+                var snapshot = new Snapshot {
+                    Revision = streamRevision,
+                    Payload = snapshotEvent.Data
+                };
+                await _snapshotStore.Write(streamName, snapshot, cancellationToken).NoContext();
+                break;
+            }
+        }
+    }
 }

From 1c614d71850af33859403ab0c28758195d5b2bc5 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Sun, 7 Dec 2025 21:15:44 +0300
Subject: [PATCH 13/25] bug fixes for the SeparateStream storage strategy

---
 .../banking/Banking.Domain/Accounts/AccountState.cs |  2 +-
 .../AggregateService/CommandService.cs              | 11 +++++++++--
 .../FunctionalService/CommandService.cs             | 13 ++++++++++---
 .../AggregatePersistenceExtensions.cs               |  7 ++++---
 .../StateStore/StateStoreFunctions.cs               |  7 ++++---
 5 files changed, 28 insertions(+), 12 deletions(-)

diff --git a/samples/banking/Banking.Domain/Accounts/AccountState.cs b/samples/banking/Banking.Domain/Accounts/AccountState.cs
index aae82bf0..92209f2f 100644
--- a/samples/banking/Banking.Domain/Accounts/AccountState.cs
+++ b/samples/banking/Banking.Domain/Accounts/AccountState.cs
@@ -2,7 +2,7 @@
 
 namespace Banking.Domain.Accounts;
 
-[Snapshots(typeof(AccountEvents.V1.Snapshot))]
+[Snapshots(typeof(AccountEvents.V1.Snapshot), StorageStrategy = SnapshotStorageStrategy.SeparateStream)]
 public record AccountState : State<AccountState> {
     public decimal Balance { get; init; }
 
diff --git a/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs b/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
index 9a3f6844..6ffe04fc 100644
--- a/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
+++ b/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
@@ -185,12 +185,19 @@ CancellationToken cancellationToken
                     [snapshotEvent]
                 );
 
-                var result = await writer.Store(snapshotAppend, null, cancellationToken).NoContext();
+                var result = await writer.Store(
+                    snapshotAppend,
+                    (@event) => {
+                        @event.Metadata.With("revision", streamRevision.ToString());
+                        return @event;
+                    },
+                    cancellationToken)
+                    .NoContext();
 
                 await store.TruncateStream(
                     snapshotStreamName,
                     new StreamTruncatePosition(result.NextExpectedVersion),
-                    new ExpectedStreamVersion(result.NextExpectedVersion),
+                    ExpectedStreamVersion.Any,
                     cancellationToken);
 
                 break;
diff --git a/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs b/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
index e8d35e02..ce037b5e 100644
--- a/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
+++ b/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
@@ -184,16 +184,23 @@ CancellationToken cancellationToken
 
                 var snapshotAppend = new ProposedAppend(
                     snapshotStreamName,
-                    ExpectedStreamVersion.NoStream,
+                    ExpectedStreamVersion.Any,
                     [snapshotEvent]
                 );
 
-                var result = await writer.Store(snapshotAppend, null, cancellationToken).NoContext();
+                var result = await writer.Store(
+                    snapshotAppend,
+                    (@event) => {
+                        @event.Metadata.With("revision", streamRevision.ToString());
+                        return @event;
+                    },
+                    cancellationToken)
+                    .NoContext();
 
                 await store.TruncateStream(
                     snapshotStreamName,
                     new StreamTruncatePosition(result.NextExpectedVersion),
-                    new ExpectedStreamVersion(result.NextExpectedVersion),
+                    ExpectedStreamVersion.Any,
                     cancellationToken);
 
                     break;
diff --git a/src/Core/src/Eventuous.Persistence/AggregateStore/AggregatePersistenceExtensions.cs b/src/Core/src/Eventuous.Persistence/AggregateStore/AggregatePersistenceExtensions.cs
index c66fb76d..c58af799 100644
--- a/src/Core/src/Eventuous.Persistence/AggregateStore/AggregatePersistenceExtensions.cs
+++ b/src/Core/src/Eventuous.Persistence/AggregateStore/AggregatePersistenceExtensions.cs
@@ -148,13 +148,14 @@ public Task<AppendEventsResult> StoreAggregate<TAggregate, TState, TId>(
                             if (snapshotEvents.Length > 0) {
                                 var candidate = snapshotEvents[0];
                                 if (candidate.Payload != null && snapshotTypes.Contains(candidate.Payload.GetType())) {
-                                    snapshotEvent = candidate;
+                                    snapshotEvent = candidate with {
+                                        Revision = long.Parse(candidate.Metadata.GetString("revision")!)
+                                    };
                                 }
                             }
                             
                             if (snapshotEvent.HasValue) {
-                                var snapshotRevision = snapshotEvent.Value.Revision;
-                                var eventsAfterSnapshot = await eventReader.ReadStream(streamName, new(snapshotRevision + 1), failIfNotFound, cancellationToken).NoContext();
+                                var eventsAfterSnapshot = await eventReader.ReadStream(streamName, new(snapshotEvent.Value.Revision + 1), failIfNotFound, cancellationToken).NoContext();
                                 events = [snapshotEvent.Value, ..eventsAfterSnapshot];
                             } else {
                                 events = await eventReader.ReadStream(streamName, StreamReadPosition.Start, failIfNotFound, cancellationToken).NoContext();
diff --git a/src/Core/src/Eventuous.Persistence/StateStore/StateStoreFunctions.cs b/src/Core/src/Eventuous.Persistence/StateStore/StateStoreFunctions.cs
index f8cbcc9e..6fba0d46 100644
--- a/src/Core/src/Eventuous.Persistence/StateStore/StateStoreFunctions.cs
+++ b/src/Core/src/Eventuous.Persistence/StateStore/StateStoreFunctions.cs
@@ -46,13 +46,14 @@ public async Task<FoldedEventStream<TState>> LoadState<TState>(
                             if (snapshotEvents.Length > 0) {
                                 var candidate = snapshotEvents[0];
                                 if (candidate.Payload != null && snapshotTypes.Contains(candidate.Payload.GetType())) {
-                                    snapshotEvent = candidate;
+                                    snapshotEvent = candidate with {
+                                        Revision = long.Parse(candidate.Metadata.GetString("revision")!)
+                                    };
                                 }
                             }
 
                             if (snapshotEvent.HasValue) {
-                                var snapshotRevision = snapshotEvent.Value.Revision;
-                                var eventsAfterSnapshot = await reader.ReadStream(streamName, new(snapshotRevision + 1), failIfNotFound, cancellationToken).NoContext();
+                                var eventsAfterSnapshot = await reader.ReadStream(streamName, new(snapshotEvent.Value.Revision + 1), failIfNotFound, cancellationToken).NoContext();
                                 streamEvents = [snapshotEvent.Value, ..eventsAfterSnapshot];
                             } else {
                                 streamEvents = await reader.ReadStream(streamName, StreamReadPosition.Start, failIfNotFound, cancellationToken).NoContext();

From dbba34a38d7d2e8f0f5f7985f581dd791be3a884 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Mon, 8 Dec 2025 12:01:30 +0300
Subject: [PATCH 14/25] added postgres snapshot store

---
 .../Eventuous.Postgresql.csproj               |   1 +
 .../Extensions/RegistrationExtensions.cs      | 104 ++++++++++++++++++
 .../PostgresSnapshotStore.cs                  |  95 ++++++++++++++++
 .../PostgresSnapshotStoreOptions.cs           |  26 +++++
 .../Scripts/1_SnapshotSchema.sql              |  14 +++
 .../Eventuous.Postgresql/SnapshotSchema.cs    |  62 +++++++++++
 .../SnapshotSchemaInitializer.cs              |  19 ++++
 7 files changed, 321 insertions(+)
 create mode 100644 src/Postgres/src/Eventuous.Postgresql/PostgresSnapshotStore.cs
 create mode 100644 src/Postgres/src/Eventuous.Postgresql/PostgresSnapshotStoreOptions.cs
 create mode 100644 src/Postgres/src/Eventuous.Postgresql/Scripts/1_SnapshotSchema.sql
 create mode 100644 src/Postgres/src/Eventuous.Postgresql/SnapshotSchema.cs
 create mode 100644 src/Postgres/src/Eventuous.Postgresql/SnapshotSchemaInitializer.cs

diff --git a/src/Postgres/src/Eventuous.Postgresql/Eventuous.Postgresql.csproj b/src/Postgres/src/Eventuous.Postgresql/Eventuous.Postgresql.csproj
index 7d3ed25c..376320de 100644
--- a/src/Postgres/src/Eventuous.Postgresql/Eventuous.Postgresql.csproj
+++ b/src/Postgres/src/Eventuous.Postgresql/Eventuous.Postgresql.csproj
@@ -20,6 +20,7 @@
         <EmbeddedResource Include="Scripts\7_ReadStreamSub.sql"/>
         <EmbeddedResource Include="Scripts\8_TruncateStream.sql"/>
         <EmbeddedResource Include="Scripts\9_TryInsertTombstone.sql"/>
+        <EmbeddedResource Include="Scripts\1_SnapshotSchema.sql"/>
     </ItemGroup>
     <ItemGroup>
         <Compile Include="$(CoreRoot)\Eventuous.Shared\Tools\TaskExtensions.cs">
diff --git a/src/Postgres/src/Eventuous.Postgresql/Extensions/RegistrationExtensions.cs b/src/Postgres/src/Eventuous.Postgresql/Extensions/RegistrationExtensions.cs
index 7909e50f..432396c3 100644
--- a/src/Postgres/src/Eventuous.Postgresql/Extensions/RegistrationExtensions.cs
+++ b/src/Postgres/src/Eventuous.Postgresql/Extensions/RegistrationExtensions.cs
@@ -135,5 +135,109 @@ public IServiceCollection AddPostgresCheckpointStore() {
                 }
             );
         }
+
+        /// <summary>
+        /// Adds PostgreSQL snapshot store and the necessary schema to the DI container.
+        /// </summary>
+        /// <param name="connectionString">Connection string</param>
+        /// <param name="schema">Schema name</param>
+        /// <param name="initializeDatabase">Set to true if you want the schema to be created on startup</param>
+        /// <param name="configureBuilder">Optional: function to configure the data source builder</param>
+        /// <param name="connectionLifetime">Optional: lifetime of the connection, default is transient</param>
+        /// <param name="dataSourceLifetime">Optional: lifetime of the data source, default is singleton</param>
+        /// <returns>Services collection</returns>
+        // ReSharper disable once UnusedMethodReturnValue.Global
+        public IServiceCollection AddPostgresSnapshotStore(
+                string                                             connectionString,
+                string                                             schema             = SnapshotSchema.DefaultSchema,
+                bool                                               initializeDatabase = false,
+                Action<IServiceProvider, NpgsqlDataSourceBuilder>? configureBuilder   = null,
+                ServiceLifetime                                    connectionLifetime = ServiceLifetime.Transient,
+                ServiceLifetime                                    dataSourceLifetime = ServiceLifetime.Singleton
+            ) {
+            var options = new PostgresSnapshotStoreOptions {
+                Schema             = schema,
+                ConnectionString   = connectionString,
+                InitializeDatabase = initializeDatabase
+            };
+
+            services.AddNpgsqlSnapshotDataSourceCore(
+                _ => connectionString,
+                configureBuilder,
+                connectionLifetime,
+                dataSourceLifetime
+            );
+            services.AddSingleton(options);
+            services.AddSingleton<PostgresSnapshotStore>(sp => {
+                var snapshotDataSource = sp.GetRequiredService<PostgresSnapshotDataSource>();
+                return new PostgresSnapshotStore(snapshotDataSource.DataSource, options, sp.GetService<IEventSerializer>());
+            });
+            services.AddSingleton<ISnapshotStore>(sp => sp.GetRequiredService<PostgresSnapshotStore>());
+            services.AddHostedService<SnapshotSchemaInitializer>();
+
+            return services;
+        }
+
+        /// <summary>
+        /// Adds PostgreSQL snapshot store and the necessary schema to the DI container.
+        /// </summary>
+        /// <param name="config">Configuration section for PostgreSQL snapshot store options</param>
+        /// <param name="configureBuilder">Optional: function to configure the data source builder</param>
+        /// <param name="connectionLifetime">Optional: lifetime of the connection, default is transient</param>
+        /// <param name="dataSourceLifetime">Optional: lifetime of the data source, default is singleton</param>
+        /// <returns>Services collection</returns>
+        // ReSharper disable once UnusedMethodReturnValue.Global
+        public IServiceCollection AddPostgresSnapshotStore(
+                IConfiguration                                     config,
+                Action<IServiceProvider, NpgsqlDataSourceBuilder>? configureBuilder   = null,
+                ServiceLifetime                                    connectionLifetime = ServiceLifetime.Transient,
+                ServiceLifetime                                    dataSourceLifetime = ServiceLifetime.Singleton
+            ) {
+            services.Configure<PostgresSnapshotStoreOptions>(config);
+            services.AddSingleton<PostgresSnapshotStoreOptions>(sp => sp.GetRequiredService<IOptions<PostgresSnapshotStoreOptions>>().Value);
+
+            services.AddNpgsqlSnapshotDataSourceCore(
+                sp => Ensure.NotEmptyString(sp.GetRequiredService<PostgresSnapshotStoreOptions>().ConnectionString),
+                configureBuilder,
+                connectionLifetime,
+                dataSourceLifetime
+            );
+
+            services.AddSingleton<PostgresSnapshotStore>(sp => {
+                var options = sp.GetRequiredService<PostgresSnapshotStoreOptions>();
+                var snapshotDataSource = sp.GetRequiredService<PostgresSnapshotDataSource>();
+                return new PostgresSnapshotStore(snapshotDataSource.DataSource, options, sp.GetService<IEventSerializer>());
+            });
+            services.AddSingleton<ISnapshotStore>(sp => sp.GetRequiredService<PostgresSnapshotStore>());
+            services.AddHostedService<SnapshotSchemaInitializer>();
+
+            return services;
+        }
+
+        void AddNpgsqlSnapshotDataSourceCore(
+                Func<IServiceProvider, string>                     getConnectionString,
+                Action<IServiceProvider, NpgsqlDataSourceBuilder>? configureDataSource,
+                ServiceLifetime                                    connectionLifetime,
+                ServiceLifetime                                    dataSourceLifetime
+            ) {
+            // Register snapshot-specific data source as singleton
+            services.TryAdd(
+                new ServiceDescriptor(
+                    typeof(PostgresSnapshotDataSource),
+                    sp => {
+                        var dataSourceBuilder = new NpgsqlDataSourceBuilder(getConnectionString(sp));
+                        dataSourceBuilder.UseLoggerFactory(sp.GetService<ILoggerFactory>());
+                        configureDataSource?.Invoke(sp, dataSourceBuilder);
+                        return new PostgresSnapshotDataSource(dataSourceBuilder.Build());
+                    },
+                    dataSourceLifetime
+                )
+            );
+        }
+    }
+
+    // Wrapper to distinguish snapshot data source from event store data source
+    internal class PostgresSnapshotDataSource(NpgsqlDataSource dataSource) {
+        public NpgsqlDataSource DataSource { get; } = dataSource;
     }
 }
diff --git a/src/Postgres/src/Eventuous.Postgresql/PostgresSnapshotStore.cs b/src/Postgres/src/Eventuous.Postgresql/PostgresSnapshotStore.cs
new file mode 100644
index 00000000..4eaff6c3
--- /dev/null
+++ b/src/Postgres/src/Eventuous.Postgresql/PostgresSnapshotStore.cs
@@ -0,0 +1,95 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+using System.Runtime.Serialization;
+using System.Text;
+using Eventuous.Postgresql.Extensions;
+using static Eventuous.DeserializationResult;
+
+namespace Eventuous.Postgresql;
+
+/// <summary>
+/// PostgreSQL snapshot store implementation for storing snapshots separately from event streams.
+/// </summary>
+public class PostgresSnapshotStore : ISnapshotStore {
+    readonly NpgsqlDataSource      _dataSource;
+    readonly SnapshotSchema         _schema;
+    readonly IEventSerializer       _serializer;
+    const    string                 ContentType = "application/json";
+
+    public PostgresSnapshotStore(
+            NpgsqlDataSource           dataSource,
+            PostgresSnapshotStoreOptions? options,
+            IEventSerializer?           serializer = null
+        ) {
+        var pgOptions = options ?? new PostgresSnapshotStoreOptions();
+        _schema     = new SnapshotSchema(pgOptions.Schema);
+        _dataSource = Ensure.NotNull(dataSource, "Data Source");
+        _serializer = serializer ?? DefaultEventSerializer.Instance;
+    }
+
+    /// <inheritdoc />
+    [RequiresDynamicCode("Only works with AOT when using DefaultStaticEventSerializer")]
+    [RequiresUnreferencedCode("Only works with AOT when using DefaultStaticEventSerializer")]
+    public async Task<Snapshot?> Read(StreamName streamName, CancellationToken cancellationToken = default) {
+        await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken).NoContext();
+        await using var cmd        = connection.GetCommand(_schema.ReadSnapshot)
+            .Add("stream_name", NpgsqlDbType.Varchar, streamName.ToString());
+
+        await using var reader = await cmd.ExecuteReaderAsync(cancellationToken).NoContext();
+
+        if (!await reader.ReadAsync(cancellationToken).NoContext()) {
+            return null;
+        }
+
+        var revision   = reader.GetInt64(0);
+        var eventType  = reader.GetString(1);
+        var jsonData   = reader.GetString(2);
+
+        var deserialized = _serializer.DeserializeEvent(
+            Encoding.UTF8.GetBytes(jsonData),
+            eventType,
+            ContentType
+        );
+
+        return deserialized switch {
+            SuccessfullyDeserialized success => new Snapshot {
+                Revision = revision,
+                Payload  = success.Payload
+            },
+            FailedToDeserialize failed => throw new SerializationException($"Can't deserialize snapshot {eventType}: {failed.Error}"),
+            _                          => throw new("Unknown deserialization result")
+        };
+    }
+
+    /// <inheritdoc />
+    [RequiresDynamicCode("Only works with AOT when using DefaultStaticEventSerializer")]
+    [RequiresUnreferencedCode("Only works with AOT when using DefaultStaticEventSerializer")]
+    public async Task Write(StreamName streamName, Snapshot snapshot, CancellationToken cancellationToken = default) {
+        if (snapshot.Payload == null) {
+            throw new ArgumentException("Snapshot payload cannot be null", nameof(snapshot));
+        }
+
+        var serialized = _serializer.SerializeEvent(snapshot.Payload);
+        var jsonData   = Encoding.UTF8.GetString(serialized.Payload);
+
+        await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken).NoContext();
+        await using var cmd        = connection.GetCommand(_schema.WriteSnapshot)
+            .Add("stream_name", NpgsqlDbType.Varchar, streamName.ToString())
+            .Add("revision", NpgsqlDbType.Bigint, snapshot.Revision)
+            .Add("event_type", NpgsqlDbType.Varchar, serialized.EventType)
+            .Add("json_data", NpgsqlDbType.Jsonb, jsonData);
+
+        await cmd.ExecuteNonQueryAsync(cancellationToken).NoContext();
+    }
+
+    /// <inheritdoc />
+    public async Task Delete(StreamName streamName, CancellationToken cancellationToken = default) {
+        await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken).NoContext();
+        await using var cmd        = connection.GetCommand(_schema.DeleteSnapshot)
+            .Add("stream_name", NpgsqlDbType.Varchar, streamName.ToString());
+
+        await cmd.ExecuteNonQueryAsync(cancellationToken).NoContext();
+    }
+}
+
diff --git a/src/Postgres/src/Eventuous.Postgresql/PostgresSnapshotStoreOptions.cs b/src/Postgres/src/Eventuous.Postgresql/PostgresSnapshotStoreOptions.cs
new file mode 100644
index 00000000..6635e59e
--- /dev/null
+++ b/src/Postgres/src/Eventuous.Postgresql/PostgresSnapshotStoreOptions.cs
@@ -0,0 +1,26 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+// ReSharper disable PropertyCanBeMadeInitOnly.Global
+
+namespace Eventuous.Postgresql;
+
+public class PostgresSnapshotStoreOptions(string schema) {
+    public PostgresSnapshotStoreOptions() : this(SnapshotSchema.DefaultSchema) { }
+
+    /// <summary>
+    /// Override the default schema name.
+    /// </summary>
+    public string Schema { get; set; } = schema;
+
+    /// <summary>
+    /// PostgreSQL connection string.
+    /// </summary>
+    public string ConnectionString { get; set; } = null!;
+
+    /// <summary>
+    /// Set to true to initialize the database schema on startup. Default is false.
+    /// </summary>
+    public bool InitializeDatabase { get; set; }
+}
+
diff --git a/src/Postgres/src/Eventuous.Postgresql/Scripts/1_SnapshotSchema.sql b/src/Postgres/src/Eventuous.Postgresql/Scripts/1_SnapshotSchema.sql
new file mode 100644
index 00000000..18b21da5
--- /dev/null
+++ b/src/Postgres/src/Eventuous.Postgresql/Scripts/1_SnapshotSchema.sql
@@ -0,0 +1,14 @@
+create schema if not exists __schema__;
+
+create table if not exists __schema__.snapshots (
+    stream_name varchar(1000) not null,
+    revision    bigint not null,
+    event_type  varchar(128) not null,
+    json_data   jsonb not null,
+    created     timestamp not null default (now() at time zone 'utc'),
+    constraint pk_snapshots primary key (stream_name),
+    constraint ck_revision_gte_zero check (revision >= 0)
+);
+
+create index if not exists snapshots_stream_name_idx on __schema__.snapshots (stream_name);
+
diff --git a/src/Postgres/src/Eventuous.Postgresql/SnapshotSchema.cs b/src/Postgres/src/Eventuous.Postgresql/SnapshotSchema.cs
new file mode 100644
index 00000000..85a5cdb1
--- /dev/null
+++ b/src/Postgres/src/Eventuous.Postgresql/SnapshotSchema.cs
@@ -0,0 +1,62 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+using System.Reflection;
+using Microsoft.Extensions.Logging;
+
+namespace Eventuous.Postgresql;
+
+/// <summary>
+/// Instantiate a new SnapshotSchema object with the specified schema name. The default schema name is "eventuous"
+/// </summary>
+/// <param name="schema"></param>
+public class SnapshotSchema(string schema = SnapshotSchema.DefaultSchema) {
+    public const string DefaultSchema = "eventuous";
+
+    public string Name => schema;
+
+    public string ReadSnapshot  => $"SELECT revision, event_type, json_data FROM {schema}.snapshots WHERE stream_name = @stream_name";
+    public string WriteSnapshot  => $"INSERT INTO {schema}.snapshots (stream_name, revision, event_type, json_data) VALUES (@stream_name, @revision, @event_type, @json_data) ON CONFLICT (stream_name) DO UPDATE SET revision = @revision, event_type = @event_type, json_data = @json_data, created = now() at time zone 'utc'";
+    public string DeleteSnapshot => $"DELETE FROM {schema}.snapshots WHERE stream_name = @stream_name";
+
+    static readonly Assembly Assembly = typeof(SnapshotSchema).Assembly;
+
+    public async Task CreateSchema(NpgsqlDataSource dataSource, ILogger<SnapshotSchema>? log, CancellationToken cancellationToken = default) {
+        log?.LogInformation("Creating snapshot schema {Schema}", schema);
+        const string scriptName = "Eventuous.Postgresql.Scripts.1_SnapshotSchema.sql";
+
+        await using var connection = await dataSource.OpenConnectionAsync(cancellationToken).NoContext();
+
+        var transaction = await connection.BeginTransactionAsync(cancellationToken).NoContext();
+
+        try {
+            log?.LogInformation("Executing {Script}", scriptName);
+            await using var stream = Assembly.GetManifestResourceStream(scriptName);
+            if (stream == null) {
+                throw new InvalidOperationException($"Embedded resource {scriptName} not found");
+            }
+
+            using var reader = new StreamReader(stream);
+
+#if NET7_0_OR_GREATER
+            var script = await reader.ReadToEndAsync(cancellationToken).NoContext();
+#else
+            var script = await reader.ReadToEndAsync().NoContext();
+#endif
+            var cmdScript = script.Replace("__schema__", schema);
+
+            await using var cmd = new NpgsqlCommand(cmdScript, connection, transaction);
+
+            await cmd.ExecuteNonQueryAsync(cancellationToken).NoContext();
+        } catch (Exception e) {
+            log?.LogCritical(e, "Unable to initialize the snapshot database schema");
+            await transaction.RollbackAsync(cancellationToken);
+
+            throw;
+        }
+
+        await transaction.CommitAsync(cancellationToken).NoContext();
+        log?.LogInformation("Snapshot database schema initialized");
+    }
+}
+
diff --git a/src/Postgres/src/Eventuous.Postgresql/SnapshotSchemaInitializer.cs b/src/Postgres/src/Eventuous.Postgresql/SnapshotSchemaInitializer.cs
new file mode 100644
index 00000000..3921e8a0
--- /dev/null
+++ b/src/Postgres/src/Eventuous.Postgresql/SnapshotSchemaInitializer.cs
@@ -0,0 +1,19 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace Eventuous.Postgresql;
+
+public class SnapshotSchemaInitializer(PostgresSnapshotStoreOptions options, ILoggerFactory? loggerFactory = null) : IHostedService {
+    public Task StartAsync(CancellationToken cancellationToken) {
+        if (!options.InitializeDatabase) return Task.CompletedTask;
+        var dataSource = new NpgsqlDataSourceBuilder(options.ConnectionString).Build();
+        var schema = new SnapshotSchema(options.Schema);
+        return schema.CreateSchema(dataSource, loggerFactory?.CreateLogger<SnapshotSchema>(), cancellationToken);
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+}
+

From 4a6bec3ab2f0a0b5b5429c2708057bad68201894 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Mon, 8 Dec 2025 12:08:03 +0300
Subject: [PATCH 15/25] moved snapshot scripts to separate folder

---
 .../src/Eventuous.Postgresql/Eventuous.Postgresql.csproj      | 2 +-
 src/Postgres/src/Eventuous.Postgresql/Schema.cs               | 4 +++-
 src/Postgres/src/Eventuous.Postgresql/SnapshotSchema.cs       | 2 +-
 .../{Scripts => SnapshotScripts}/1_SnapshotSchema.sql         | 0
 4 files changed, 5 insertions(+), 3 deletions(-)
 rename src/Postgres/src/Eventuous.Postgresql/{Scripts => SnapshotScripts}/1_SnapshotSchema.sql (100%)

diff --git a/src/Postgres/src/Eventuous.Postgresql/Eventuous.Postgresql.csproj b/src/Postgres/src/Eventuous.Postgresql/Eventuous.Postgresql.csproj
index 376320de..8d484d89 100644
--- a/src/Postgres/src/Eventuous.Postgresql/Eventuous.Postgresql.csproj
+++ b/src/Postgres/src/Eventuous.Postgresql/Eventuous.Postgresql.csproj
@@ -20,7 +20,7 @@
         <EmbeddedResource Include="Scripts\7_ReadStreamSub.sql"/>
         <EmbeddedResource Include="Scripts\8_TruncateStream.sql"/>
         <EmbeddedResource Include="Scripts\9_TryInsertTombstone.sql"/>
-        <EmbeddedResource Include="Scripts\1_SnapshotSchema.sql"/>
+        <EmbeddedResource Include="SnapshotScripts\1_SnapshotSchema.sql"/>
     </ItemGroup>
     <ItemGroup>
         <Compile Include="$(CoreRoot)\Eventuous.Shared\Tools\TaskExtensions.cs">
diff --git a/src/Postgres/src/Eventuous.Postgresql/Schema.cs b/src/Postgres/src/Eventuous.Postgresql/Schema.cs
index bed75ac0..34f588fe 100644
--- a/src/Postgres/src/Eventuous.Postgresql/Schema.cs
+++ b/src/Postgres/src/Eventuous.Postgresql/Schema.cs
@@ -35,7 +35,9 @@ public class Schema(string schema = Schema.DefaultSchema) {
 
     public async Task CreateSchema(NpgsqlDataSource dataSource, ILogger<Schema>? log, CancellationToken cancellationToken = default) {
         log?.LogInformation("Creating schema {Schema}", schema);
-        var names = Assembly.GetManifestResourceNames().Where(x => x.EndsWith(".sql")).OrderBy(x => x);
+        var names = Assembly.GetManifestResourceNames()
+            .Where(x => x.EndsWith(".sql") && !x.Contains("SnapshotScripts"))
+            .OrderBy(x => x);
 
         await using var connection = await dataSource.OpenConnectionAsync(cancellationToken).NoContext();
 
diff --git a/src/Postgres/src/Eventuous.Postgresql/SnapshotSchema.cs b/src/Postgres/src/Eventuous.Postgresql/SnapshotSchema.cs
index 85a5cdb1..e2c8c32f 100644
--- a/src/Postgres/src/Eventuous.Postgresql/SnapshotSchema.cs
+++ b/src/Postgres/src/Eventuous.Postgresql/SnapshotSchema.cs
@@ -23,7 +23,7 @@ public class SnapshotSchema(string schema = SnapshotSchema.DefaultSchema) {
 
     public async Task CreateSchema(NpgsqlDataSource dataSource, ILogger<SnapshotSchema>? log, CancellationToken cancellationToken = default) {
         log?.LogInformation("Creating snapshot schema {Schema}", schema);
-        const string scriptName = "Eventuous.Postgresql.Scripts.1_SnapshotSchema.sql";
+        const string scriptName = "Eventuous.Postgresql.SnapshotScripts.1_SnapshotSchema.sql";
 
         await using var connection = await dataSource.OpenConnectionAsync(cancellationToken).NoContext();
 
diff --git a/src/Postgres/src/Eventuous.Postgresql/Scripts/1_SnapshotSchema.sql b/src/Postgres/src/Eventuous.Postgresql/SnapshotScripts/1_SnapshotSchema.sql
similarity index 100%
rename from src/Postgres/src/Eventuous.Postgresql/Scripts/1_SnapshotSchema.sql
rename to src/Postgres/src/Eventuous.Postgresql/SnapshotScripts/1_SnapshotSchema.sql

From 0c6ce31551e691e0bea53c7fe0ad9c8e08aefc3f Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Mon, 8 Dec 2025 12:53:29 +0300
Subject: [PATCH 16/25] fix snapshot store drilling

---
 .../Eventuous.Application/AggregateService/CommandService.cs  | 4 ++--
 .../Eventuous.Application/FunctionalService/CommandService.cs | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs b/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
index 6ffe04fc..2c7bf5e2 100644
--- a/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
+++ b/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
@@ -79,10 +79,10 @@ public async Task<Result<TState>> Handle<TCommand>(TCommand command, Cancellatio
         try {
             var aggregate = registeredHandler.ExpectedState switch {
                 ExpectedState.Any => await reader
-                    .LoadAggregate<TAggregate, TState, TId>(aggregateId, _streamNameMap, false, _factoryRegistry, null, cancellationToken)
+                    .LoadAggregate<TAggregate, TState, TId>(aggregateId, _streamNameMap, false, _factoryRegistry, snapshotStore, cancellationToken)
                     .NoContext(),
                 ExpectedState.Existing => await reader
-                    .LoadAggregate<TAggregate, TState, TId>(aggregateId, _streamNameMap, true, _factoryRegistry, null,cancellationToken)
+                    .LoadAggregate<TAggregate, TState, TId>(aggregateId, _streamNameMap, true, _factoryRegistry, snapshotStore, cancellationToken)
                     .NoContext(),
                 ExpectedState.New     => Create(aggregateId),
                 ExpectedState.Unknown => null,
diff --git a/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs b/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
index ce037b5e..3448f4e8 100644
--- a/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
+++ b/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
@@ -85,8 +85,8 @@ public async Task<Result<TState>> Handle<TCommand>(TCommand command, Cancellatio
 
         try {
             var loadedState = registeredHandler.ExpectedState switch {
-                ExpectedState.Any      => await resolvedReader.LoadState<TState>(streamName, false, null, cancellationToken).NoContext(),
-                ExpectedState.Existing => await resolvedReader.LoadState<TState>(streamName, true, null, cancellationToken).NoContext(),
+                ExpectedState.Any      => await resolvedReader.LoadState<TState>(streamName, false, snapshotStore, cancellationToken).NoContext(),
+                ExpectedState.Existing => await resolvedReader.LoadState<TState>(streamName, true, snapshotStore, cancellationToken).NoContext(),
                 ExpectedState.New      => new(streamName, ExpectedStreamVersion.NoStream, []),
                 _                      => throw new ArgumentOutOfRangeException(null, "Unknown expected state")
             };

From 13d1248f622bfda6e90a846e85d094dd336cd6ee Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Mon, 8 Dec 2025 12:54:32 +0300
Subject: [PATCH 17/25] added code demonstrating the use of snapshots in a
 separate storage (Postgres)

---
 Directory.Packages.props                            |  1 +
 samples/banking/Banking.Api/Banking.Api.csproj      |  3 ++-
 samples/banking/Banking.Api/Program.cs              |  7 +++++++
 .../banking/Banking.Api/Services/AccountService.cs  |  2 +-
 samples/banking/Banking.AppHost/AppHost.cs          | 13 ++++++++++---
 .../banking/Banking.AppHost/Banking.AppHost.csproj  |  1 +
 .../banking/Banking.Domain/Accounts/AccountState.cs |  2 +-
 7 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/Directory.Packages.props b/Directory.Packages.props
index 66a54b38..573e78d4 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -22,6 +22,7 @@
     <TUnitVersion>0.77.3</TUnitVersion>
   </PropertyGroup>
   <ItemGroup>
+    <PackageVersion Include="Aspire.Hosting.PostgreSQL" Version="13.0.2" />
     <PackageVersion Include="BenchmarkDotNet" Version="0.14.0" />
     <PackageVersion Include="CommunityToolkit.Aspire.Hosting.KurrentDB" Version="13.0.0" />
     <PackageVersion Include="CommunityToolkit.Aspire.KurrentDB" Version="13.0.0" />
diff --git a/samples/banking/Banking.Api/Banking.Api.csproj b/samples/banking/Banking.Api/Banking.Api.csproj
index 1ec9411a..3f48f1d9 100644
--- a/samples/banking/Banking.Api/Banking.Api.csproj
+++ b/samples/banking/Banking.Api/Banking.Api.csproj
@@ -14,7 +14,8 @@
     <ProjectReference Include="$(SrcRoot)\Core\src\Eventuous.Application\Eventuous.Application.csproj" />
     <ProjectReference Include="$(SrcRoot)\Core\gen\Eventuous.Shared.Generators\Eventuous.Shared.Generators.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
     <ProjectReference Include="$(SrcRoot)\Extensions\src\Eventuous.Extensions.DependencyInjection\Eventuous.Extensions.DependencyInjection.csproj" />
-    <ProjectReference Include="$(SrcRoot)\KurrentDB\src\Eventuous.KurrentDB\Eventuous.KurrentDB.csproj" />   
+    <ProjectReference Include="$(SrcRoot)\KurrentDB\src\Eventuous.KurrentDB\Eventuous.KurrentDB.csproj" />
+    <ProjectReference Include="$(SrcRoot)\Postgres\src\Eventuous.Postgresql\Eventuous.Postgresql.csproj" />   
     <ProjectReference Include="..\Banking.Domain\Banking.Domain.csproj" />
   </ItemGroup>
 
diff --git a/samples/banking/Banking.Api/Program.cs b/samples/banking/Banking.Api/Program.cs
index 5f55dc4a..6d5cc254 100644
--- a/samples/banking/Banking.Api/Program.cs
+++ b/samples/banking/Banking.Api/Program.cs
@@ -5,6 +5,13 @@
 
 var builder = WebApplication.CreateBuilder(args);
 
+var postgresSnapshotDbConnectionString = builder.Configuration.GetConnectionString("postgresSnapshotsDb");
+if (postgresSnapshotDbConnectionString == null) {
+    throw new InvalidOperationException("postgres snapshots db conenction string should be not null");
+}
+
+builder.Services.AddPostgresSnapshotStore(postgresSnapshotDbConnectionString, initializeDatabase: true);
+
 builder.AddKurrentDBClient("kurrentdb");
 
 builder.Services.AddEventStore<KurrentDBEventStore>();
diff --git a/samples/banking/Banking.Api/Services/AccountService.cs b/samples/banking/Banking.Api/Services/AccountService.cs
index 9953d373..bb6a7e2e 100644
--- a/samples/banking/Banking.Api/Services/AccountService.cs
+++ b/samples/banking/Banking.Api/Services/AccountService.cs
@@ -10,7 +10,7 @@ public class AccountService : CommandService<AccountState> {
     public record Deposit(string AccountId, decimal Amount);
     public record Withdraw(string AccountId, decimal Amount);
 
-    public AccountService(IEventStore store) : base(store) {
+    public AccountService(IEventStore store, ISnapshotStore snapshotStore) : base(store, snapshotStore: snapshotStore) {
         On<Deposit>()
             .InState(ExpectedState.Any)
             .GetStream(cmd => StreamName.ForState<AccountState>(cmd.AccountId))
diff --git a/samples/banking/Banking.AppHost/AppHost.cs b/samples/banking/Banking.AppHost/AppHost.cs
index b8e34798..30a067b5 100644
--- a/samples/banking/Banking.AppHost/AppHost.cs
+++ b/samples/banking/Banking.AppHost/AppHost.cs
@@ -1,12 +1,19 @@
 var builder = DistributedApplication.CreateBuilder(args);
 
-var db = builder.AddKurrentDB("kurrentdb", 2113)
+var kurrentdb = builder.AddKurrentDB("eventuous-kurrentdb", 2113)
     .WithEnvironment("EVENTSTORE_ENABLE_ATOM_PUB_OVER_HTTP", "true");
 
+var postgres = builder.AddPostgres("eventuous-postgres")
+    .WithPgWeb();
+
+var postgresSnapshotsDb = postgres.AddDatabase("snapshots");
+
 builder
     .AddProject<Projects.Banking_Api>("banking-api")
-    .WithReference(db, "kurrentdb")
-    .WaitFor(db);
+    .WithReference(kurrentdb, "kurrentdb")
+    .WaitFor(kurrentdb)
+    .WithReference(postgresSnapshotsDb, "postgresSnapshotsDb")
+    .WaitFor(postgresSnapshotsDb);
 
 builder
     .Build()
diff --git a/samples/banking/Banking.AppHost/Banking.AppHost.csproj b/samples/banking/Banking.AppHost/Banking.AppHost.csproj
index a2a54ee8..389f7e53 100644
--- a/samples/banking/Banking.AppHost/Banking.AppHost.csproj
+++ b/samples/banking/Banking.AppHost/Banking.AppHost.csproj
@@ -9,6 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Aspire.Hosting.PostgreSQL" />
     <PackageReference Include="CommunityToolkit.Aspire.Hosting.KurrentDB" />
   </ItemGroup>
 
diff --git a/samples/banking/Banking.Domain/Accounts/AccountState.cs b/samples/banking/Banking.Domain/Accounts/AccountState.cs
index 92209f2f..86c6cc58 100644
--- a/samples/banking/Banking.Domain/Accounts/AccountState.cs
+++ b/samples/banking/Banking.Domain/Accounts/AccountState.cs
@@ -2,7 +2,7 @@
 
 namespace Banking.Domain.Accounts;
 
-[Snapshots(typeof(AccountEvents.V1.Snapshot), StorageStrategy = SnapshotStorageStrategy.SeparateStream)]
+[Snapshots(typeof(AccountEvents.V1.Snapshot), StorageStrategy = SnapshotStorageStrategy.SeparateStore)]
 public record AccountState : State<AccountState> {
     public decimal Balance { get; init; }
 

From 1b177a9e8e86284ae714d4cee569cc8711370e6d Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Mon, 8 Dec 2025 14:30:31 +0300
Subject: [PATCH 18/25] moved code related to snapshots to appropriate folder

---
 .../Eventuous.Postgresql.csproj               | 42 +++++++++----------
 .../Extensions/RegistrationExtensions.cs      |  1 +
 .../src/Eventuous.Postgresql/Schema.cs        |  2 +-
 .../{ => Snapshots}/PostgresSnapshotStore.cs  |  2 +-
 .../PostgresSnapshotStoreOptions.cs           |  2 +-
 .../Scripts}/1_SnapshotSchema.sql             |  0
 .../{ => Snapshots}/SnapshotSchema.cs         |  4 +-
 .../SnapshotSchemaInitializer.cs              |  2 +-
 8 files changed, 28 insertions(+), 27 deletions(-)
 rename src/Postgres/src/Eventuous.Postgresql/{ => Snapshots}/PostgresSnapshotStore.cs (99%)
 rename src/Postgres/src/Eventuous.Postgresql/{ => Snapshots}/PostgresSnapshotStoreOptions.cs (94%)
 rename src/Postgres/src/Eventuous.Postgresql/{SnapshotScripts => Snapshots/Scripts}/1_SnapshotSchema.sql (100%)
 rename src/Postgres/src/Eventuous.Postgresql/{ => Snapshots}/SnapshotSchema.cs (97%)
 rename src/Postgres/src/Eventuous.Postgresql/{ => Snapshots}/SnapshotSchemaInitializer.cs (95%)

diff --git a/src/Postgres/src/Eventuous.Postgresql/Eventuous.Postgresql.csproj b/src/Postgres/src/Eventuous.Postgresql/Eventuous.Postgresql.csproj
index 8d484d89..f4e99a06 100644
--- a/src/Postgres/src/Eventuous.Postgresql/Eventuous.Postgresql.csproj
+++ b/src/Postgres/src/Eventuous.Postgresql/Eventuous.Postgresql.csproj
@@ -1,26 +1,26 @@
 <Project Sdk="Microsoft.NET.Sdk">
     <ItemGroup>
-        <ProjectReference Include="$(CoreRoot)\Eventuous.Subscriptions\Eventuous.Subscriptions.csproj"/>
-        <ProjectReference Include="$(CoreRoot)\Eventuous.Persistence\Eventuous.Persistence.csproj"/>
-        <ProjectReference Include="$(SrcRoot)\Relational\src\Eventuous.Sql.Base\Eventuous.Sql.Base.csproj"/>
-        <ProjectReference Include="$(CoreRoot)\Eventuous.Producers\Eventuous.Producers.csproj"/>
+        <ProjectReference Include="$(CoreRoot)\Eventuous.Subscriptions\Eventuous.Subscriptions.csproj" />
+        <ProjectReference Include="$(CoreRoot)\Eventuous.Persistence\Eventuous.Persistence.csproj" />
+        <ProjectReference Include="$(SrcRoot)\Relational\src\Eventuous.Sql.Base\Eventuous.Sql.Base.csproj" />
+        <ProjectReference Include="$(CoreRoot)\Eventuous.Producers\Eventuous.Producers.csproj" />
     </ItemGroup>
     <ItemGroup>
-        <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions"/>
-        <PackageReference Include="Npgsql"/>
-        <PackageReference Include="Npgsql.DependencyInjection"/>
+        <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" />
+        <PackageReference Include="Npgsql" />
+        <PackageReference Include="Npgsql.DependencyInjection" />
     </ItemGroup>
     <ItemGroup>
-        <EmbeddedResource Include="Scripts\1_Schema.sql"/>
-        <EmbeddedResource Include="Scripts\2_AppendEvents.sql"/>
-        <EmbeddedResource Include="Scripts\3_CheckStream.sql"/>
-        <EmbeddedResource Include="Scripts\4_ReadAllForwards.sql"/>
-        <EmbeddedResource Include="Scripts\5_ReadStreamBackwards.sql"/>
-        <EmbeddedResource Include="Scripts\6_ReadStreamForwards.sql"/>
-        <EmbeddedResource Include="Scripts\7_ReadStreamSub.sql"/>
-        <EmbeddedResource Include="Scripts\8_TruncateStream.sql"/>
-        <EmbeddedResource Include="Scripts\9_TryInsertTombstone.sql"/>
-        <EmbeddedResource Include="SnapshotScripts\1_SnapshotSchema.sql"/>
+        <EmbeddedResource Include="Scripts\1_Schema.sql" />
+        <EmbeddedResource Include="Scripts\2_AppendEvents.sql" />
+        <EmbeddedResource Include="Scripts\3_CheckStream.sql" />
+        <EmbeddedResource Include="Scripts\4_ReadAllForwards.sql" />
+        <EmbeddedResource Include="Scripts\5_ReadStreamBackwards.sql" />
+        <EmbeddedResource Include="Scripts\6_ReadStreamForwards.sql" />
+        <EmbeddedResource Include="Scripts\7_ReadStreamSub.sql" />
+        <EmbeddedResource Include="Scripts\8_TruncateStream.sql" />
+        <EmbeddedResource Include="Scripts\9_TryInsertTombstone.sql" />
+        <EmbeddedResource Include="Snapshots\Scripts\1_SnapshotSchema.sql" />
     </ItemGroup>
     <ItemGroup>
         <Compile Include="$(CoreRoot)\Eventuous.Shared\Tools\TaskExtensions.cs">
@@ -31,11 +31,11 @@
         </Compile>
     </ItemGroup>
     <ItemGroup>
-        <InternalsVisibleTo Include="Eventuous.Tests.Postgres"/>
+        <InternalsVisibleTo Include="Eventuous.Tests.Postgres" />
     </ItemGroup>
     <ItemGroup>
-        <Using Include="Npgsql"/>
-        <Using Include="NpgsqlTypes"/>
-        <Using Include="Eventuous.Tools"/>
+        <Using Include="Npgsql" />
+        <Using Include="NpgsqlTypes" />
+        <Using Include="Eventuous.Tools" />
     </ItemGroup>
 </Project>
diff --git a/src/Postgres/src/Eventuous.Postgresql/Extensions/RegistrationExtensions.cs b/src/Postgres/src/Eventuous.Postgresql/Extensions/RegistrationExtensions.cs
index 432396c3..afdbf3ee 100644
--- a/src/Postgres/src/Eventuous.Postgresql/Extensions/RegistrationExtensions.cs
+++ b/src/Postgres/src/Eventuous.Postgresql/Extensions/RegistrationExtensions.cs
@@ -3,6 +3,7 @@
 
 using System.Data.Common;
 using Eventuous.Postgresql;
+using Eventuous.Postgresql.Snapshots;
 using Eventuous.Postgresql.Subscriptions;
 using Eventuous.Sql.Base;
 using Microsoft.Extensions.Configuration;
diff --git a/src/Postgres/src/Eventuous.Postgresql/Schema.cs b/src/Postgres/src/Eventuous.Postgresql/Schema.cs
index 34f588fe..44c04f3b 100644
--- a/src/Postgres/src/Eventuous.Postgresql/Schema.cs
+++ b/src/Postgres/src/Eventuous.Postgresql/Schema.cs
@@ -36,7 +36,7 @@ public class Schema(string schema = Schema.DefaultSchema) {
     public async Task CreateSchema(NpgsqlDataSource dataSource, ILogger<Schema>? log, CancellationToken cancellationToken = default) {
         log?.LogInformation("Creating schema {Schema}", schema);
         var names = Assembly.GetManifestResourceNames()
-            .Where(x => x.EndsWith(".sql") && !x.Contains("SnapshotScripts"))
+            .Where(x => x.EndsWith(".sql") && !x.Contains("Snapshots.Scripts"))
             .OrderBy(x => x);
 
         await using var connection = await dataSource.OpenConnectionAsync(cancellationToken).NoContext();
diff --git a/src/Postgres/src/Eventuous.Postgresql/PostgresSnapshotStore.cs b/src/Postgres/src/Eventuous.Postgresql/Snapshots/PostgresSnapshotStore.cs
similarity index 99%
rename from src/Postgres/src/Eventuous.Postgresql/PostgresSnapshotStore.cs
rename to src/Postgres/src/Eventuous.Postgresql/Snapshots/PostgresSnapshotStore.cs
index 4eaff6c3..2bcc75cf 100644
--- a/src/Postgres/src/Eventuous.Postgresql/PostgresSnapshotStore.cs
+++ b/src/Postgres/src/Eventuous.Postgresql/Snapshots/PostgresSnapshotStore.cs
@@ -6,7 +6,7 @@
 using Eventuous.Postgresql.Extensions;
 using static Eventuous.DeserializationResult;
 
-namespace Eventuous.Postgresql;
+namespace Eventuous.Postgresql.Snapshots;
 
 /// <summary>
 /// PostgreSQL snapshot store implementation for storing snapshots separately from event streams.
diff --git a/src/Postgres/src/Eventuous.Postgresql/PostgresSnapshotStoreOptions.cs b/src/Postgres/src/Eventuous.Postgresql/Snapshots/PostgresSnapshotStoreOptions.cs
similarity index 94%
rename from src/Postgres/src/Eventuous.Postgresql/PostgresSnapshotStoreOptions.cs
rename to src/Postgres/src/Eventuous.Postgresql/Snapshots/PostgresSnapshotStoreOptions.cs
index 6635e59e..55eee872 100644
--- a/src/Postgres/src/Eventuous.Postgresql/PostgresSnapshotStoreOptions.cs
+++ b/src/Postgres/src/Eventuous.Postgresql/Snapshots/PostgresSnapshotStoreOptions.cs
@@ -3,7 +3,7 @@
 
 // ReSharper disable PropertyCanBeMadeInitOnly.Global
 
-namespace Eventuous.Postgresql;
+namespace Eventuous.Postgresql.Snapshots;
 
 public class PostgresSnapshotStoreOptions(string schema) {
     public PostgresSnapshotStoreOptions() : this(SnapshotSchema.DefaultSchema) { }
diff --git a/src/Postgres/src/Eventuous.Postgresql/SnapshotScripts/1_SnapshotSchema.sql b/src/Postgres/src/Eventuous.Postgresql/Snapshots/Scripts/1_SnapshotSchema.sql
similarity index 100%
rename from src/Postgres/src/Eventuous.Postgresql/SnapshotScripts/1_SnapshotSchema.sql
rename to src/Postgres/src/Eventuous.Postgresql/Snapshots/Scripts/1_SnapshotSchema.sql
diff --git a/src/Postgres/src/Eventuous.Postgresql/SnapshotSchema.cs b/src/Postgres/src/Eventuous.Postgresql/Snapshots/SnapshotSchema.cs
similarity index 97%
rename from src/Postgres/src/Eventuous.Postgresql/SnapshotSchema.cs
rename to src/Postgres/src/Eventuous.Postgresql/Snapshots/SnapshotSchema.cs
index e2c8c32f..58affba5 100644
--- a/src/Postgres/src/Eventuous.Postgresql/SnapshotSchema.cs
+++ b/src/Postgres/src/Eventuous.Postgresql/Snapshots/SnapshotSchema.cs
@@ -4,7 +4,7 @@
 using System.Reflection;
 using Microsoft.Extensions.Logging;
 
-namespace Eventuous.Postgresql;
+namespace Eventuous.Postgresql.Snapshots;
 
 /// <summary>
 /// Instantiate a new SnapshotSchema object with the specified schema name. The default schema name is "eventuous"
@@ -23,7 +23,7 @@ public class SnapshotSchema(string schema = SnapshotSchema.DefaultSchema) {
 
     public async Task CreateSchema(NpgsqlDataSource dataSource, ILogger<SnapshotSchema>? log, CancellationToken cancellationToken = default) {
         log?.LogInformation("Creating snapshot schema {Schema}", schema);
-        const string scriptName = "Eventuous.Postgresql.SnapshotScripts.1_SnapshotSchema.sql";
+        const string scriptName = "Eventuous.Postgresql.Snapshots.Scripts.1_SnapshotSchema.sql";
 
         await using var connection = await dataSource.OpenConnectionAsync(cancellationToken).NoContext();
 
diff --git a/src/Postgres/src/Eventuous.Postgresql/SnapshotSchemaInitializer.cs b/src/Postgres/src/Eventuous.Postgresql/Snapshots/SnapshotSchemaInitializer.cs
similarity index 95%
rename from src/Postgres/src/Eventuous.Postgresql/SnapshotSchemaInitializer.cs
rename to src/Postgres/src/Eventuous.Postgresql/Snapshots/SnapshotSchemaInitializer.cs
index 3921e8a0..ee8c9689 100644
--- a/src/Postgres/src/Eventuous.Postgresql/SnapshotSchemaInitializer.cs
+++ b/src/Postgres/src/Eventuous.Postgresql/Snapshots/SnapshotSchemaInitializer.cs
@@ -4,7 +4,7 @@
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 
-namespace Eventuous.Postgresql;
+namespace Eventuous.Postgresql.Snapshots;
 
 public class SnapshotSchemaInitializer(PostgresSnapshotStoreOptions options, ILoggerFactory? loggerFactory = null) : IHostedService {
     public Task StartAsync(CancellationToken cancellationToken) {

From 241b86a633b0a6e0bc5d691c12b5847226bc500c Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Mon, 8 Dec 2025 17:53:19 +0300
Subject: [PATCH 19/25] added `UseSnapshotStrategy` to command services

---
 .../Banking.Api/Services/AccountService.cs    | 45 +++++--------------
 .../AggregateService/CommandService.cs        | 36 ++++++++++++---
 .../FunctionalService/CommandService.cs       | 27 ++++++++++-
 .../Eventuous.Application/SnapshotStrategy.cs | 17 +++++++
 4 files changed, 86 insertions(+), 39 deletions(-)
 create mode 100644 src/Core/src/Eventuous.Application/SnapshotStrategy.cs

diff --git a/samples/banking/Banking.Api/Services/AccountService.cs b/samples/banking/Banking.Api/Services/AccountService.cs
index bb6a7e2e..3445be5d 100644
--- a/samples/banking/Banking.Api/Services/AccountService.cs
+++ b/samples/banking/Banking.Api/Services/AccountService.cs
@@ -11,46 +11,25 @@ public record Deposit(string AccountId, decimal Amount);
     public record Withdraw(string AccountId, decimal Amount);
 
     public AccountService(IEventStore store, ISnapshotStore snapshotStore) : base(store, snapshotStore: snapshotStore) {
+
+        UseSnapshotStrategy(
+            predicate: (events, _) => events.Count() >= 5,
+            produce: (_, state) => new AccountEvents.V1.Snapshot(state.Balance));
+
         On<Deposit>()
             .InState(ExpectedState.Any)
             .GetStream(cmd => StreamName.ForState<AccountState>(cmd.AccountId))
-            .Act(ApplySnapshot<Deposit>(Handle));
+            .Act((_, __, cmd) => [new AccountEvents.V1.Deposited(cmd.Amount)]);
 
         On<Withdraw>()
             .InState(ExpectedState.Any)
             .GetStream(cmd => StreamName.ForState<AccountState>(cmd.AccountId))
-            .Act(ApplySnapshot<Withdraw>(Handle));
-    }
+            .Act(static (state, __, cmd) => {
+                if (state.Balance < cmd.Amount) {
+                    throw new InvalidOperationException();
+                }
 
-    private IEnumerable<object> Handle(AccountState state, IEnumerable<object> _, Deposit cmd) {
-        return [
-            new AccountEvents.V1.Deposited(cmd.Amount)
-        ];
+                return [new AccountEvents.V1.Withdrawn(cmd.Amount)];
+            });
     }
-
-    private IEnumerable<object> Handle(AccountState state, IEnumerable<object> _, Withdraw cmd) {
-        if (state.Balance < cmd.Amount) {
-            throw new InvalidOperationException();
-        }
-
-        return [
-            new AccountEvents.V1.Withdrawn(cmd.Amount)
-        ];
-    }
-
-    Func<AccountState, IEnumerable<object>, TCommand, IEnumerable<object>> ApplySnapshot<TCommand>(Func<AccountState, IEnumerable<object>, TCommand, IEnumerable<object>> handler) => (state, events, command) => {
-        var newEvents = handler(state, events, command);
-
-        if (newEvents.Count() + events.Count() >= 10) {
-            foreach (var @event in newEvents) {
-                state = state.When(@event);
-            }
-            return [
-                ..newEvents,
-                    new AccountEvents.V1.Snapshot(state.Balance)
-            ];
-        }
-
-        return newEvents;
-    };
 }
diff --git a/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs b/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
index 2c7bf5e2..d1f6b1d3 100644
--- a/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
+++ b/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
@@ -46,6 +46,7 @@ protected CommandService(
     readonly StreamNameMap                        _streamNameMap   = streamNameMap   ?? new StreamNameMap();
     readonly ITypeMapper                          _typeMap         = typeMap         ?? TypeMap.Instance;
     readonly ISnapshotStore?                      _snapshotStore   = snapshotStore;
+    SnapshotStrategy<TState>?                    _snapshotStrategy;
 
     /// <summary>
     /// Returns the command handler builder for the specified command type.
@@ -55,6 +56,19 @@ protected CommandService(
     protected IDefineExpectedState<TCommand, TAggregate, TState, TId> On<TCommand>() where TCommand : class
         => new CommandHandlerBuilder<TCommand, TAggregate, TState, TId>(this, Reader, Writer);
 
+    /// <summary>
+    /// Configures a snapshot strategy that determines when and how to create snapshot events.
+    /// The snapshot event type must be registered in <see cref="SnapshotTypeMap"/> for the state type.
+    /// </summary>
+    /// <param name="predicate">Function that takes all events (original + new) and state, returns true if snapshot should be created</param>
+    /// <param name="produce">Function that takes all events and state, returns the snapshot event object</param>
+    protected void UseSnapshotStrategy(
+        Func<NewEvents, TState, bool> predicate,
+        Func<NewEvents, TState, object> produce
+    ) {
+        _snapshotStrategy = new SnapshotStrategy<TState>(predicate, produce);
+    }
+
     /// <summary>
     /// The command handler. Call this function from your edge (API).
     /// </summary>
@@ -73,8 +87,9 @@ public async Task<Result<TState>> Handle<TCommand>(TCommand command, Cancellatio
         }
 
         var aggregateId = await registeredHandler.GetId(command, cancellationToken).NoContext();
-        var reader      = registeredHandler.ResolveReader(command);
         var stream      = _streamNameMap.GetStreamName<TAggregate, TState, TId>(aggregateId);
+        var reader      = registeredHandler.ResolveReader(command);
+        var writer      = registeredHandler.ResolveWriter(command);
 
         try {
             var aggregate = registeredHandler.ExpectedState switch {
@@ -91,19 +106,30 @@ public async Task<Result<TState>> Handle<TCommand>(TCommand command, Cancellatio
 
             var result = await registeredHandler.Handler(aggregate!, command, cancellationToken).NoContext();
 
+            var newEvents = result.Changes.Select(x => new ProposedEvent(x, [])).ToArray();
+            var newState  = result.State;
+
+            // Apply snapshot strategy if configured
+            if (_snapshotStrategy != null) {
+                var allEvents = result.Current;
+                if (_snapshotStrategy.Predicate(allEvents, result.State)) {
+                    var snapshotEvent = _snapshotStrategy.Produce(allEvents, result.State);
+                    newState = newState.When(snapshotEvent);
+                    newEvents = [.. newEvents, new(snapshotEvent, [])];
+                }
+            }
+
             // Zero in the global position would mean nothing, so the receiver needs to check the Changes.Length
-            if (result.Changes.Count == 0) return Result<TState>.FromSuccess(result.State, [], 0);
+            if (newEvents.Length == 0) return Result<TState>.FromSuccess(newState, [], 0);
 
             // Separate snapshots from regular events based on storage strategy
             var snapshotTypes = SnapshotTypeMap.GetSnapshotTypes<TState>();
             var storageStrategy = SnapshotTypeMap.GetStorageStrategy<TState>();
-            var allEvents = result.Changes.Select(x => new ProposedEvent(x, new())).ToArray();
-            var (regularEvents, snapshotEvents) = SeparateSnapshots(allEvents, snapshotTypes, storageStrategy);
+            var (regularEvents, snapshotEvents) = SeparateSnapshots(newEvents, snapshotTypes, storageStrategy);
 
             // Store regular events first
             var proposed    = new ProposedAppend(stream, new(result.OriginalVersion), regularEvents);
             var final       = registeredHandler.AmendAppend?.Invoke(proposed, command) ?? proposed;
-            var writer      = registeredHandler.ResolveWriter(command);
             var storeResult = await writer.Store(final, Amend, cancellationToken).NoContext();
 
             // Handle snapshots based on strategy
diff --git a/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs b/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
index 3448f4e8..90c4e34a 100644
--- a/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
+++ b/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
@@ -43,6 +43,7 @@ public abstract class CommandService<TState>(IEventReader reader, IEventWriter w
     readonly ITypeMapper         _typeMap  = typeMap ?? TypeMap.Instance;
     readonly HandlersMap<TState>  _handlers = new();
     readonly ISnapshotStore?     _snapshotStore = snapshotStore;
+    SnapshotStrategy<TState>?    _snapshotStrategy;
 
     /// <summary>
     /// Alternative constructor for the functional command service, which uses an <seealso cref="IEventStore"/> instance for both reading and writing.
@@ -61,6 +62,19 @@ protected CommandService(IEventStore store, ITypeMapper? typeMap = null, AmendEv
     /// <returns></returns>
     protected IDefineExpectedState<TCommand, TState> On<TCommand>() where TCommand : class => new CommandHandlerBuilder<TCommand, TState>(this, reader, writer);
 
+    /// <summary>
+    /// Configures a snapshot strategy that determines when and how to create snapshot events.
+    /// The snapshot event type must be registered in <see cref="SnapshotTypeMap"/> for the state type.
+    /// </summary>
+    /// <param name="predicate">Function that takes all events (original + new) and state, returns true if snapshot should be created</param>
+    /// <param name="produce">Function that takes all events and state, returns the snapshot event object</param>
+    protected void UseSnapshotStrategy(
+        Func<IEnumerable<object>, TState, bool> predicate,
+        Func<IEnumerable<object>, TState, object> produce
+    ) {
+        _snapshotStrategy = new SnapshotStrategy<TState>(predicate, produce);
+    }
+
     /// <summary>
     /// Function to handle a command and return the resulting state and changes.
     /// </summary>
@@ -93,9 +107,20 @@ public async Task<Result<TState>> Handle<TCommand>(TCommand command, Cancellatio
 
             var result = (await registeredHandler.Handler(loadedState.State, loadedState.Events, command, cancellationToken).NoContext()).ToArray();
 
-            var newEvents = result.Select(x => new ProposedEvent(x, new())).ToArray();
+            var newEvents = result.Select(x => new ProposedEvent(x, [])).ToArray();
             var newState  = newEvents.Aggregate(loadedState.State, (current, evt) => current.When(evt.Data));
 
+            // Apply snapshot strategy if configured
+            if (_snapshotStrategy != null) {
+                var allEvents = loadedState.Events.Concat(result);
+                if (_snapshotStrategy.Predicate(allEvents, newState)) {
+                    var snapshotEvent = _snapshotStrategy.Produce(allEvents, newState);
+                    newState = newState.When(snapshotEvent);
+                    result = [.. result, snapshotEvent];
+                    newEvents = [.. newEvents, new ProposedEvent(snapshotEvent, [])];
+                }
+            }
+
             // Zero in the global position would mean nothing, so the receiver needs to check the Changes.Length
             if (newEvents.Length == 0) return Result<TState>.FromSuccess(newState, [], 0);
 
diff --git a/src/Core/src/Eventuous.Application/SnapshotStrategy.cs b/src/Core/src/Eventuous.Application/SnapshotStrategy.cs
new file mode 100644
index 00000000..d4bfdf46
--- /dev/null
+++ b/src/Core/src/Eventuous.Application/SnapshotStrategy.cs
@@ -0,0 +1,17 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+namespace Eventuous;
+
+/// <summary>
+/// Represents a snapshot strategy that determines when and how to create snapshot events.
+/// </summary>
+/// <typeparam name="TState">The state type</typeparam>
+sealed class SnapshotStrategy<TState>(
+    Func<NewEvents, TState, bool> predicate,
+    Func<NewEvents, TState, object> produce
+) where TState : State<TState>, new() {
+    public Func<NewEvents, TState, bool> Predicate { get; } = predicate;
+    public Func<NewEvents, TState, object> Produce { get; } = produce;
+}
+

From 0a24b03898845f6a6883f74124897d192fe43507 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Tue, 9 Dec 2025 13:23:49 +0300
Subject: [PATCH 20/25] added sqlserver snapshot store

---
 Directory.Packages.props                      |  1 +
 .../banking/Banking.Api/Banking.Api.csproj    |  3 +-
 samples/banking/Banking.Api/Program.cs        | 19 +++-
 samples/banking/Banking.AppHost/AppHost.cs    |  7 +-
 .../Banking.AppHost/Banking.AppHost.csproj    |  1 +
 .../Eventuous.SqlServer.csproj                |  1 +
 .../Extensions/RegistrationExtensions.cs      | 51 ++++++++++
 .../Snapshots/Scripts/1_SnapshotSchema.sql    | 22 +++++
 .../Snapshots/SnapshotSchema.cs               | 62 ++++++++++++
 .../Snapshots/SnapshotSchemaInitializer.cs    | 38 ++++++++
 .../Snapshots/SqlServerSnapshotStore.cs       | 97 +++++++++++++++++++
 .../SqlServerSnapshotStoreOptions.cs          | 26 +++++
 12 files changed, 324 insertions(+), 4 deletions(-)
 create mode 100644 src/SqlServer/src/Eventuous.SqlServer/Snapshots/Scripts/1_SnapshotSchema.sql
 create mode 100644 src/SqlServer/src/Eventuous.SqlServer/Snapshots/SnapshotSchema.cs
 create mode 100644 src/SqlServer/src/Eventuous.SqlServer/Snapshots/SnapshotSchemaInitializer.cs
 create mode 100644 src/SqlServer/src/Eventuous.SqlServer/Snapshots/SqlServerSnapshotStore.cs
 create mode 100644 src/SqlServer/src/Eventuous.SqlServer/Snapshots/SqlServerSnapshotStoreOptions.cs

diff --git a/Directory.Packages.props b/Directory.Packages.props
index 573e78d4..9d9ab868 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -23,6 +23,7 @@
   </PropertyGroup>
   <ItemGroup>
     <PackageVersion Include="Aspire.Hosting.PostgreSQL" Version="13.0.2" />
+    <PackageVersion Include="Aspire.Hosting.SqlServer" Version="13.0.2" />
     <PackageVersion Include="BenchmarkDotNet" Version="0.14.0" />
     <PackageVersion Include="CommunityToolkit.Aspire.Hosting.KurrentDB" Version="13.0.0" />
     <PackageVersion Include="CommunityToolkit.Aspire.KurrentDB" Version="13.0.0" />
diff --git a/samples/banking/Banking.Api/Banking.Api.csproj b/samples/banking/Banking.Api/Banking.Api.csproj
index 3f48f1d9..51c417ee 100644
--- a/samples/banking/Banking.Api/Banking.Api.csproj
+++ b/samples/banking/Banking.Api/Banking.Api.csproj
@@ -15,7 +15,8 @@
     <ProjectReference Include="$(SrcRoot)\Core\gen\Eventuous.Shared.Generators\Eventuous.Shared.Generators.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
     <ProjectReference Include="$(SrcRoot)\Extensions\src\Eventuous.Extensions.DependencyInjection\Eventuous.Extensions.DependencyInjection.csproj" />
     <ProjectReference Include="$(SrcRoot)\KurrentDB\src\Eventuous.KurrentDB\Eventuous.KurrentDB.csproj" />
-    <ProjectReference Include="$(SrcRoot)\Postgres\src\Eventuous.Postgresql\Eventuous.Postgresql.csproj" />   
+    <ProjectReference Include="$(SrcRoot)\Postgres\src\Eventuous.Postgresql\Eventuous.Postgresql.csproj" />
+    <ProjectReference Include="$(SrcRoot)\SqlServer\src\Eventuous.SqlServer\Eventuous.SqlServer.csproj" />
     <ProjectReference Include="..\Banking.Domain\Banking.Domain.csproj" />
   </ItemGroup>
 
diff --git a/samples/banking/Banking.Api/Program.cs b/samples/banking/Banking.Api/Program.cs
index 6d5cc254..75128a8d 100644
--- a/samples/banking/Banking.Api/Program.cs
+++ b/samples/banking/Banking.Api/Program.cs
@@ -5,16 +5,31 @@
 
 var builder = WebApplication.CreateBuilder(args);
 
+//----------------------------------------------------------------
+// Snapshot store registration
+
 var postgresSnapshotDbConnectionString = builder.Configuration.GetConnectionString("postgresSnapshotsDb");
 if (postgresSnapshotDbConnectionString == null) {
     throw new InvalidOperationException("postgres snapshots db conenction string should be not null");
 }
 
-builder.Services.AddPostgresSnapshotStore(postgresSnapshotDbConnectionString, initializeDatabase: true);
+//builder.Services.AddPostgresSnapshotStore(postgresSnapshotDbConnectionString, initializeDatabase: true);
 
-builder.AddKurrentDBClient("kurrentdb");
+var sqlServerSnapshotsDbConnectionString = builder.Configuration.GetConnectionString("sqlServerSnapshotsDb");
+if (sqlServerSnapshotsDbConnectionString == null) {
+    throw new InvalidOperationException("sqlServer snapshots db connection string should be not null");
+}
+
+builder.Services.AddSqlServerSnapshotStore(sqlServerSnapshotsDbConnectionString, initializeDatabase: true);
 
+//----------------------------------------------------------------
+// Event store registration
+
+builder.AddKurrentDBClient("kurrentdb");
 builder.Services.AddEventStore<KurrentDBEventStore>();
+
+//----------------------------------------------------------------
+
 builder.Services.AddCommandService<AccountService, AccountState>();
 
 var app = builder.Build();
diff --git a/samples/banking/Banking.AppHost/AppHost.cs b/samples/banking/Banking.AppHost/AppHost.cs
index 30a067b5..170e5256 100644
--- a/samples/banking/Banking.AppHost/AppHost.cs
+++ b/samples/banking/Banking.AppHost/AppHost.cs
@@ -8,12 +8,17 @@
 
 var postgresSnapshotsDb = postgres.AddDatabase("snapshots");
 
+var sqlServer = builder.AddSqlServer("eventuous-sqlserver");
+var sqlServerSnapshotsDb = sqlServer.AddDatabase("eventuous-sqlserver-snapshotsdb", "snapshots");
+
 builder
     .AddProject<Projects.Banking_Api>("banking-api")
     .WithReference(kurrentdb, "kurrentdb")
     .WaitFor(kurrentdb)
     .WithReference(postgresSnapshotsDb, "postgresSnapshotsDb")
-    .WaitFor(postgresSnapshotsDb);
+    .WaitFor(postgresSnapshotsDb)
+    .WithReference(sqlServerSnapshotsDb, "sqlServerSnapshotsDb")
+    .WaitFor(sqlServerSnapshotsDb);
 
 builder
     .Build()
diff --git a/samples/banking/Banking.AppHost/Banking.AppHost.csproj b/samples/banking/Banking.AppHost/Banking.AppHost.csproj
index 389f7e53..0a9e247a 100644
--- a/samples/banking/Banking.AppHost/Banking.AppHost.csproj
+++ b/samples/banking/Banking.AppHost/Banking.AppHost.csproj
@@ -10,6 +10,7 @@
 
   <ItemGroup>
     <PackageReference Include="Aspire.Hosting.PostgreSQL" />
+    <PackageReference Include="Aspire.Hosting.SqlServer" />
     <PackageReference Include="CommunityToolkit.Aspire.Hosting.KurrentDB" />
   </ItemGroup>
 
diff --git a/src/SqlServer/src/Eventuous.SqlServer/Eventuous.SqlServer.csproj b/src/SqlServer/src/Eventuous.SqlServer/Eventuous.SqlServer.csproj
index 8ba83d74..92bbc07c 100644
--- a/src/SqlServer/src/Eventuous.SqlServer/Eventuous.SqlServer.csproj
+++ b/src/SqlServer/src/Eventuous.SqlServer/Eventuous.SqlServer.csproj
@@ -19,6 +19,7 @@
         <EmbeddedResource Include="Scripts\6_ReadStreamForwards.sql"/>
         <EmbeddedResource Include="Scripts\7_ReadStreamSub.sql"/>
         <EmbeddedResource Include="Scripts\8_TruncateStream.sql" />
+        <EmbeddedResource Include="Snapshots\Scripts\1_SnapshotSchema.sql"/>
     </ItemGroup>
     <ItemGroup>
         <Compile Include="$(CoreRoot)\Eventuous.Shared\Tools\TaskExtensions.cs">
diff --git a/src/SqlServer/src/Eventuous.SqlServer/Extensions/RegistrationExtensions.cs b/src/SqlServer/src/Eventuous.SqlServer/Extensions/RegistrationExtensions.cs
index f65f0420..2b989be4 100644
--- a/src/SqlServer/src/Eventuous.SqlServer/Extensions/RegistrationExtensions.cs
+++ b/src/SqlServer/src/Eventuous.SqlServer/Extensions/RegistrationExtensions.cs
@@ -3,6 +3,7 @@
 
 using Eventuous.SqlServer;
 using Eventuous.SqlServer.Projections;
+using Eventuous.SqlServer.Snapshots;
 using Eventuous.SqlServer.Subscriptions;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection.Extensions;
@@ -84,5 +85,55 @@ public IServiceCollection AddSqlServerCheckpointStore()
                     return new(Ensure.NotNull(connectionString), schema, loggerFactory);
                 }
             );
+
+        /// <summary>
+        /// Adds SQL Server snapshot store and the necessary schema to the DI container.
+        /// </summary>
+        /// <param name="connectionString">Connection string</param>
+        /// <param name="schema">Schema name</param>
+        /// <param name="initializeDatabase">Set to true if you want the schema to be created on startup</param>
+        /// <returns>Services collection</returns>
+        // ReSharper disable once UnusedMethodReturnValue.Global
+        public IServiceCollection AddSqlServerSnapshotStore(
+                string connectionString,
+                string schema             = SnapshotSchema.DefaultSchema,
+                bool   initializeDatabase = false
+            ) {
+            var options = new SqlServerSnapshotStoreOptions {
+                Schema             = schema,
+                ConnectionString   = connectionString,
+                InitializeDatabase = initializeDatabase
+            };
+
+            services.AddSingleton(options);
+            services.AddSingleton<SqlServerSnapshotStore>(sp => {
+                var snapshotOptions = sp.GetRequiredService<SqlServerSnapshotStoreOptions>();
+                return new SqlServerSnapshotStore(snapshotOptions.ConnectionString, snapshotOptions, sp.GetService<IEventSerializer>());
+            });
+            services.AddSingleton<ISnapshotStore>(sp => sp.GetRequiredService<SqlServerSnapshotStore>());
+            services.AddHostedService<SnapshotSchemaInitializer>();
+
+            return services;
+        }
+
+        /// <summary>
+        /// Adds SQL Server snapshot store and the necessary schema to the DI container using the configuration.
+        /// </summary>
+        /// <param name="config">Configuration section for SQL Server snapshot store options</param>
+        /// <returns>Services collection</returns>
+        // ReSharper disable once UnusedMethodReturnValue.Global
+        public IServiceCollection AddSqlServerSnapshotStore(IConfiguration config) {
+            services.Configure<SqlServerSnapshotStoreOptions>(config);
+            services.AddSingleton<SqlServerSnapshotStoreOptions>(sp => sp.GetRequiredService<IOptions<SqlServerSnapshotStoreOptions>>().Value);
+
+            services.AddSingleton<SqlServerSnapshotStore>(sp => {
+                var options = sp.GetRequiredService<SqlServerSnapshotStoreOptions>();
+                return new SqlServerSnapshotStore(options.ConnectionString, options, sp.GetService<IEventSerializer>());
+            });
+            services.AddSingleton<ISnapshotStore>(sp => sp.GetRequiredService<SqlServerSnapshotStore>());
+            services.AddHostedService<SnapshotSchemaInitializer>();
+
+            return services;
+        }
     }
 }
diff --git a/src/SqlServer/src/Eventuous.SqlServer/Snapshots/Scripts/1_SnapshotSchema.sql b/src/SqlServer/src/Eventuous.SqlServer/Snapshots/Scripts/1_SnapshotSchema.sql
new file mode 100644
index 00000000..1a4b7e2a
--- /dev/null
+++ b/src/SqlServer/src/Eventuous.SqlServer/Snapshots/Scripts/1_SnapshotSchema.sql
@@ -0,0 +1,22 @@
+IF (SCHEMA_ID(N'__schema__') IS NULL)
+    BEGIN
+        EXEC ('CREATE SCHEMA [__schema__] AUTHORIZATION [dbo]')
+    END
+
+IF OBJECT_ID('__schema__.snapshots', 'U') IS NULL
+    BEGIN
+        CREATE TABLE __schema__.snapshots
+        (
+            stream_name NVARCHAR(1000) NOT NULL,
+            revision    BIGINT         NOT NULL,
+            event_type  NVARCHAR(128)  NOT NULL,
+            json_data   NVARCHAR(MAX)  NOT NULL,
+            created     DATETIME2(7)   NOT NULL DEFAULT GETUTCDATE(),
+            CONSTRAINT PK_Snapshots PRIMARY KEY CLUSTERED (stream_name),
+            CONSTRAINT CK_RevisionGteZero CHECK (revision >= 0),
+            CONSTRAINT CK_JsonDataIsJson CHECK (ISJSON(json_data) = 1)
+        );
+
+        CREATE INDEX IDX_SnapshotsStreamName ON __schema__.snapshots (stream_name);
+    END
+
diff --git a/src/SqlServer/src/Eventuous.SqlServer/Snapshots/SnapshotSchema.cs b/src/SqlServer/src/Eventuous.SqlServer/Snapshots/SnapshotSchema.cs
new file mode 100644
index 00000000..4b901a36
--- /dev/null
+++ b/src/SqlServer/src/Eventuous.SqlServer/Snapshots/SnapshotSchema.cs
@@ -0,0 +1,62 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+using System.Reflection;
+using Eventuous.SqlServer;
+using Microsoft.Extensions.Logging;
+
+namespace Eventuous.SqlServer.Snapshots;
+
+/// <summary>
+/// Instantiate a new SnapshotSchema object with the specified schema name. The default schema name is "eventuous"
+/// </summary>
+/// <param name="schema"></param>
+public class SnapshotSchema(string schema = SnapshotSchema.DefaultSchema) {
+    public const string DefaultSchema = "eventuous";
+
+    public string Name => schema;
+
+    public string ReadSnapshot  => $"SELECT revision, event_type, json_data FROM {schema}.snapshots WHERE stream_name = @stream_name";
+    public string WriteSnapshot  => $"MERGE {schema}.snapshots AS target USING (VALUES (@stream_name, @revision, @event_type, @json_data)) AS source (stream_name, revision, event_type, json_data) ON target.stream_name = source.stream_name WHEN MATCHED THEN UPDATE SET revision = source.revision, event_type = source.event_type, json_data = source.json_data, created = GETUTCDATE() WHEN NOT MATCHED THEN INSERT (stream_name, revision, event_type, json_data, created) VALUES (source.stream_name, source.revision, source.event_type, source.json_data, GETUTCDATE());";
+    public string DeleteSnapshot => $"DELETE FROM {schema}.snapshots WHERE stream_name = @stream_name";
+
+    static readonly Assembly Assembly = typeof(SnapshotSchema).Assembly;
+
+    public async Task CreateSchema(string connectionString, ILogger<SnapshotSchema>? log, CancellationToken cancellationToken = default) {
+        log?.LogInformation("Creating snapshot schema {Schema}", schema);
+        const string scriptName = "Eventuous.SqlServer.Snapshots.Scripts.1_SnapshotSchema.sql";
+
+        await using var connection = await ConnectionFactory.GetConnection(connectionString, cancellationToken).NoContext();
+        await using var transaction = (SqlTransaction)await connection.BeginTransactionAsync(cancellationToken).NoContext();
+
+        try {
+            log?.LogInformation("Executing {Script}", scriptName);
+            await using var stream = Assembly.GetManifestResourceStream(scriptName);
+            if (stream == null) {
+                throw new InvalidOperationException($"Embedded resource {scriptName} not found");
+            }
+
+            using var reader = new StreamReader(stream);
+
+#if NET7_0_OR_GREATER
+            var script = await reader.ReadToEndAsync(cancellationToken).NoContext();
+#else
+            var script = await reader.ReadToEndAsync().NoContext();
+#endif
+            var cmdScript = script.Replace("__schema__", schema);
+
+            await using var cmd = new SqlCommand(cmdScript, connection, transaction);
+
+            await cmd.ExecuteNonQueryAsync(cancellationToken).NoContext();
+        } catch (Exception e) {
+            log?.LogCritical(e, "Unable to initialize the snapshot database schema");
+            await transaction.RollbackAsync(cancellationToken);
+
+            throw;
+        }
+
+        await transaction.CommitAsync(cancellationToken).NoContext();
+        log?.LogInformation("Snapshot database schema initialized");
+    }
+}
+
diff --git a/src/SqlServer/src/Eventuous.SqlServer/Snapshots/SnapshotSchemaInitializer.cs b/src/SqlServer/src/Eventuous.SqlServer/Snapshots/SnapshotSchemaInitializer.cs
new file mode 100644
index 00000000..33e1bfb7
--- /dev/null
+++ b/src/SqlServer/src/Eventuous.SqlServer/Snapshots/SnapshotSchemaInitializer.cs
@@ -0,0 +1,38 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace Eventuous.SqlServer.Snapshots;
+
+public class SnapshotSchemaInitializer(SqlServerSnapshotStoreOptions options, ILoggerFactory? loggerFactory = null) : IHostedService {
+    readonly ILogger<SnapshotSchema>? _log = loggerFactory?.CreateLogger<SnapshotSchema>();
+
+    public async Task StartAsync(CancellationToken cancellationToken) {
+        if (!options.InitializeDatabase) return;
+
+        var schema           = new SnapshotSchema(options.Schema);
+        var connectionString = Ensure.NotEmptyString(options.ConnectionString);
+
+        Exception? ex = null;
+
+        for (var i = 0; i < 10; i++) {
+            try {
+                await schema.CreateSchema(connectionString, _log, cancellationToken);
+
+                return;
+            } catch (SqlException e) {
+                _log?.LogError("Unable to initialize the snapshot database schema: {Message}", e.Message);
+                ex = e;
+            }
+
+            await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken);
+        }
+
+        throw ex!;
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+}
+
diff --git a/src/SqlServer/src/Eventuous.SqlServer/Snapshots/SqlServerSnapshotStore.cs b/src/SqlServer/src/Eventuous.SqlServer/Snapshots/SqlServerSnapshotStore.cs
new file mode 100644
index 00000000..e9142ba5
--- /dev/null
+++ b/src/SqlServer/src/Eventuous.SqlServer/Snapshots/SqlServerSnapshotStore.cs
@@ -0,0 +1,97 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+using System.Runtime.Serialization;
+using System.Text;
+using Eventuous;
+using Eventuous.SqlServer;
+using Eventuous.SqlServer.Extensions;
+using static Eventuous.DeserializationResult;
+
+namespace Eventuous.SqlServer.Snapshots;
+
+/// <summary>
+/// SQL Server snapshot store implementation for storing snapshots separately from event streams.
+/// </summary>
+public class SqlServerSnapshotStore : ISnapshotStore {
+    readonly string              _connectionString;
+    readonly SnapshotSchema      _schema;
+    readonly IEventSerializer    _serializer;
+    const    string              ContentType = "application/json";
+
+    public SqlServerSnapshotStore(
+            string                  connectionString,
+            SqlServerSnapshotStoreOptions? options,
+            IEventSerializer?       serializer = null
+        ) {
+        var sqlOptions = options ?? new SqlServerSnapshotStoreOptions();
+        _schema          = new SnapshotSchema(sqlOptions.Schema);
+        _connectionString = Ensure.NotEmptyString(connectionString);
+        _serializer      = serializer ?? DefaultEventSerializer.Instance;
+    }
+
+    /// <inheritdoc />
+    [RequiresDynamicCode("Only works with AOT when using DefaultStaticEventSerializer")]
+    [RequiresUnreferencedCode("Only works with AOT when using DefaultStaticEventSerializer")]
+    public async Task<Snapshot?> Read(StreamName streamName, CancellationToken cancellationToken = default) {
+        await using var connection = await ConnectionFactory.GetConnection(_connectionString, cancellationToken).NoContext();
+        await using var cmd        = connection.GetTextCommand(_schema.ReadSnapshot)
+            .Add("@stream_name", SqlDbType.NVarChar, streamName.ToString());
+
+        await using var reader = await cmd.ExecuteReaderAsync(cancellationToken).NoContext();
+
+        if (!await reader.ReadAsync(cancellationToken).NoContext()) {
+            return null;
+        }
+
+        var revision   = reader.GetInt64(0);
+        var eventType  = reader.GetString(1);
+        var jsonData   = reader.GetString(2);
+
+        var deserialized = _serializer.DeserializeEvent(
+            Encoding.UTF8.GetBytes(jsonData),
+            eventType,
+            ContentType
+        );
+
+        return deserialized switch {
+            SuccessfullyDeserialized success => new Snapshot {
+                Revision = revision,
+                Payload  = success.Payload
+            },
+            FailedToDeserialize failed => throw new SerializationException($"Can't deserialize snapshot {eventType}: {failed.Error}"),
+            _                          => throw new("Unknown deserialization result")
+        };
+    }
+
+    /// <inheritdoc />
+    [RequiresDynamicCode("Only works with AOT when using DefaultStaticEventSerializer")]
+    [RequiresUnreferencedCode("Only works with AOT when using DefaultStaticEventSerializer")]
+    public async Task Write(StreamName streamName, Snapshot snapshot, CancellationToken cancellationToken = default) {
+        if (snapshot.Payload == null) {
+            throw new ArgumentException("Snapshot payload cannot be null", nameof(snapshot));
+        }
+
+        var serialized = _serializer.SerializeEvent(snapshot.Payload);
+        var jsonData   = Encoding.UTF8.GetString(serialized.Payload);
+
+        await using var connection = await ConnectionFactory.GetConnection(_connectionString, cancellationToken).NoContext();
+        await using var cmd        = connection.GetTextCommand(_schema.WriteSnapshot)
+            .Add("@stream_name", SqlDbType.NVarChar, streamName.ToString())
+            .Add("@revision", SqlDbType.BigInt, snapshot.Revision)
+            .Add("@event_type", SqlDbType.NVarChar, serialized.EventType)
+            .Add("@json_data", SqlDbType.NVarChar, jsonData);
+
+        await cmd.ExecuteNonQueryAsync(cancellationToken).NoContext();
+    }
+
+    /// <inheritdoc />
+    public async Task Delete(StreamName streamName, CancellationToken cancellationToken = default) {
+        await using var connection = await ConnectionFactory.GetConnection(_connectionString, cancellationToken).NoContext();
+        await using var cmd        = connection.GetTextCommand(_schema.DeleteSnapshot)
+            .Add("@stream_name", SqlDbType.NVarChar, streamName.ToString());
+
+        await cmd.ExecuteNonQueryAsync(cancellationToken).NoContext();
+    }
+}
+
diff --git a/src/SqlServer/src/Eventuous.SqlServer/Snapshots/SqlServerSnapshotStoreOptions.cs b/src/SqlServer/src/Eventuous.SqlServer/Snapshots/SqlServerSnapshotStoreOptions.cs
new file mode 100644
index 00000000..3cfb886e
--- /dev/null
+++ b/src/SqlServer/src/Eventuous.SqlServer/Snapshots/SqlServerSnapshotStoreOptions.cs
@@ -0,0 +1,26 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+// ReSharper disable PropertyCanBeMadeInitOnly.Global
+
+namespace Eventuous.SqlServer.Snapshots;
+
+public class SqlServerSnapshotStoreOptions(string schema) {
+    public SqlServerSnapshotStoreOptions() : this(SnapshotSchema.DefaultSchema) { }
+
+    /// <summary>
+    /// Override the default schema name.
+    /// </summary>
+    public string Schema { get; set; } = schema;
+
+    /// <summary>
+    /// SQL Server connection string.
+    /// </summary>
+    public string ConnectionString { get; set; } = null!;
+
+    /// <summary>
+    /// Set to true to initialize the database schema on startup. Default is false.
+    /// </summary>
+    public bool InitializeDatabase { get; set; }
+}
+

From e0db97ce93d9b55deff56f790f163b1f61d97c18 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Tue, 9 Dec 2025 14:50:42 +0300
Subject: [PATCH 21/25] added mongodb snapshot store

---
 Directory.Packages.props                      |  1 +
 Eventuous.slnx                                |  1 +
 .../banking/Banking.Api/Banking.Api.csproj    |  1 +
 samples/banking/Banking.Api/Program.cs        |  9 +-
 samples/banking/Banking.AppHost/AppHost.cs    |  9 +-
 .../Banking.AppHost/Banking.AppHost.csproj    |  1 +
 .../Eventuous.MongoDB.csproj                  | 21 ++++
 .../Extensions/RegistrationExtensions.cs      | 99 +++++++++++++++++++
 .../Snapshots/MongoSnapshotStore.cs           | 94 ++++++++++++++++++
 .../Snapshots/MongoSnapshotStoreOptions.cs    | 33 +++++++
 .../Snapshots/SnapshotDocument.cs             | 16 +++
 .../Snapshots/SnapshotIndexInitializer.cs     | 62 ++++++++++++
 12 files changed, 345 insertions(+), 2 deletions(-)
 create mode 100644 src/Mongo/src/Eventuous.MongoDB/Eventuous.MongoDB.csproj
 create mode 100644 src/Mongo/src/Eventuous.MongoDB/Extensions/RegistrationExtensions.cs
 create mode 100644 src/Mongo/src/Eventuous.MongoDB/Snapshots/MongoSnapshotStore.cs
 create mode 100644 src/Mongo/src/Eventuous.MongoDB/Snapshots/MongoSnapshotStoreOptions.cs
 create mode 100644 src/Mongo/src/Eventuous.MongoDB/Snapshots/SnapshotDocument.cs
 create mode 100644 src/Mongo/src/Eventuous.MongoDB/Snapshots/SnapshotIndexInitializer.cs

diff --git a/Directory.Packages.props b/Directory.Packages.props
index 9d9ab868..57602e75 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -22,6 +22,7 @@
     <TUnitVersion>0.77.3</TUnitVersion>
   </PropertyGroup>
   <ItemGroup>
+    <PackageVersion Include="Aspire.Hosting.MongoDB" Version="13.0.2" />
     <PackageVersion Include="Aspire.Hosting.PostgreSQL" Version="13.0.2" />
     <PackageVersion Include="Aspire.Hosting.SqlServer" Version="13.0.2" />
     <PackageVersion Include="BenchmarkDotNet" Version="0.14.0" />
diff --git a/Eventuous.slnx b/Eventuous.slnx
index 688ee7a4..a4215337 100644
--- a/Eventuous.slnx
+++ b/Eventuous.slnx
@@ -114,6 +114,7 @@
     </Folder>
     <Folder Name="/Mongo/" />
     <Folder Name="/Mongo/src/">
+        <Project Path="src/Mongo/src/Eventuous.MongoDB/Eventuous.MongoDB.csproj" />
         <Project Path="src/Mongo/src/Eventuous.Projections.MongoDB/Eventuous.Projections.MongoDB.csproj" />
     </Folder>
     <Folder Name="/Mongo/test/">
diff --git a/samples/banking/Banking.Api/Banking.Api.csproj b/samples/banking/Banking.Api/Banking.Api.csproj
index 51c417ee..77e97dfb 100644
--- a/samples/banking/Banking.Api/Banking.Api.csproj
+++ b/samples/banking/Banking.Api/Banking.Api.csproj
@@ -17,6 +17,7 @@
     <ProjectReference Include="$(SrcRoot)\KurrentDB\src\Eventuous.KurrentDB\Eventuous.KurrentDB.csproj" />
     <ProjectReference Include="$(SrcRoot)\Postgres\src\Eventuous.Postgresql\Eventuous.Postgresql.csproj" />
     <ProjectReference Include="$(SrcRoot)\SqlServer\src\Eventuous.SqlServer\Eventuous.SqlServer.csproj" />
+    <ProjectReference Include="$(SrcRoot)\Mongo\src\Eventuous.MongoDB\Eventuous.MongoDB.csproj" />
     <ProjectReference Include="..\Banking.Domain\Banking.Domain.csproj" />
   </ItemGroup>
 
diff --git a/samples/banking/Banking.Api/Program.cs b/samples/banking/Banking.Api/Program.cs
index 75128a8d..42ae4108 100644
--- a/samples/banking/Banking.Api/Program.cs
+++ b/samples/banking/Banking.Api/Program.cs
@@ -20,7 +20,14 @@
     throw new InvalidOperationException("sqlServer snapshots db connection string should be not null");
 }
 
-builder.Services.AddSqlServerSnapshotStore(sqlServerSnapshotsDbConnectionString, initializeDatabase: true);
+//builder.Services.AddSqlServerSnapshotStore(sqlServerSnapshotsDbConnectionString, initializeDatabase: true);
+
+var mongoDbSnapshotsDbConnectionString = builder.Configuration.GetConnectionString("mongoDbSnapshotsDb");
+if (mongoDbSnapshotsDbConnectionString == null) {
+    throw new InvalidOperationException("mongodb snapshots db connection string should be not null");
+}
+
+builder.Services.AddMongoSnapshotStore(mongoDbSnapshotsDbConnectionString, initializeIndexes: true);
 
 //----------------------------------------------------------------
 // Event store registration
diff --git a/samples/banking/Banking.AppHost/AppHost.cs b/samples/banking/Banking.AppHost/AppHost.cs
index 170e5256..f1190b8d 100644
--- a/samples/banking/Banking.AppHost/AppHost.cs
+++ b/samples/banking/Banking.AppHost/AppHost.cs
@@ -11,6 +11,11 @@
 var sqlServer = builder.AddSqlServer("eventuous-sqlserver");
 var sqlServerSnapshotsDb = sqlServer.AddDatabase("eventuous-sqlserver-snapshotsdb", "snapshots");
 
+var mongodb = builder.AddMongoDB("eventuous-mongodb")
+    .WithMongoExpress();
+
+var mongodbSnapshotsDb = mongodb.AddDatabase("eventuous-mongodb-snapshotsdb", "snapshots");
+
 builder
     .AddProject<Projects.Banking_Api>("banking-api")
     .WithReference(kurrentdb, "kurrentdb")
@@ -18,7 +23,9 @@
     .WithReference(postgresSnapshotsDb, "postgresSnapshotsDb")
     .WaitFor(postgresSnapshotsDb)
     .WithReference(sqlServerSnapshotsDb, "sqlServerSnapshotsDb")
-    .WaitFor(sqlServerSnapshotsDb);
+    .WaitFor(sqlServerSnapshotsDb)
+    .WithReference(mongodbSnapshotsDb, "mongoDbSnapshotsDb")
+    .WaitFor(mongodbSnapshotsDb);
 
 builder
     .Build()
diff --git a/samples/banking/Banking.AppHost/Banking.AppHost.csproj b/samples/banking/Banking.AppHost/Banking.AppHost.csproj
index 0a9e247a..18d1164e 100644
--- a/samples/banking/Banking.AppHost/Banking.AppHost.csproj
+++ b/samples/banking/Banking.AppHost/Banking.AppHost.csproj
@@ -9,6 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Aspire.Hosting.MongoDB" />
     <PackageReference Include="Aspire.Hosting.PostgreSQL" />
     <PackageReference Include="Aspire.Hosting.SqlServer" />
     <PackageReference Include="CommunityToolkit.Aspire.Hosting.KurrentDB" />
diff --git a/src/Mongo/src/Eventuous.MongoDB/Eventuous.MongoDB.csproj b/src/Mongo/src/Eventuous.MongoDB/Eventuous.MongoDB.csproj
new file mode 100644
index 00000000..ee3f296b
--- /dev/null
+++ b/src/Mongo/src/Eventuous.MongoDB/Eventuous.MongoDB.csproj
@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <ItemGroup>
+        <ProjectReference Include="$(CoreRoot)\Eventuous.Persistence\Eventuous.Persistence.csproj" />
+    </ItemGroup>
+    <ItemGroup>
+        <PackageReference Include="MongoDB.Driver" />
+        <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" />
+        <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" />
+    </ItemGroup>
+    <ItemGroup>
+        <Compile Include="$(CoreRoot)\Eventuous.Shared\Tools\TaskExtensions.cs">
+            <Link>Tools\TaskExtensions.cs</Link>
+        </Compile>
+        <Compile Include="$(CoreRoot)\Eventuous.Shared\Tools\Ensure.cs">
+            <Link>Tools\Ensure.cs</Link>
+        </Compile>
+        <Using Include="Eventuous.Tools" />
+        <Using Include="MongoDB.Driver" />
+    </ItemGroup>
+</Project>
+
diff --git a/src/Mongo/src/Eventuous.MongoDB/Extensions/RegistrationExtensions.cs b/src/Mongo/src/Eventuous.MongoDB/Extensions/RegistrationExtensions.cs
new file mode 100644
index 00000000..dbac37d8
--- /dev/null
+++ b/src/Mongo/src/Eventuous.MongoDB/Extensions/RegistrationExtensions.cs
@@ -0,0 +1,99 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+using Eventuous.MongoDB.Snapshots;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+// ReSharper disable once CheckNamespace
+namespace Microsoft.Extensions.DependencyInjection;
+
+/// <summary>
+/// Extension methods for registering MongoDB snapshot store.
+/// </summary>
+public static class ServiceCollectionExtensions {
+    /// <param name="services">Service collection</param>
+    extension(IServiceCollection services) {
+        /// <summary>
+        /// Adds MongoDB snapshot store to the DI container.
+        /// </summary>
+        /// <param name="connectionString">MongoDB connection string</param>
+        /// <param name="databaseName">Database name. Default is "eventuous"</param>
+        /// <param name="collectionName">Collection name. Default is "snapshots"</param>
+        /// <param name="initializeIndexes">Set to true to initialize indexes on startup. Default is false</param>
+        /// <returns>Services collection</returns>
+        // ReSharper disable once UnusedMethodReturnValue.Global
+        public IServiceCollection AddMongoSnapshotStore(
+                string connectionString,
+                string databaseName        = "eventuous",
+                string collectionName      = "snapshots",
+                bool   initializeIndexes    = false
+            ) {
+            var options = new MongoSnapshotStoreOptions {
+                ConnectionString   = Ensure.NotEmptyString(connectionString),
+                DatabaseName       = databaseName,
+                CollectionName     = collectionName,
+                InitializeIndexes  = initializeIndexes
+            };
+
+            services.AddSingleton(options);
+            services.AddSingleton<MongoSnapshotStore>(sp => {
+                var opts = sp.GetRequiredService<MongoSnapshotStoreOptions>();
+                var mongoSettings = MongoClientSettings.FromConnectionString(opts.ConnectionString);
+                var client        = new MongoClient(mongoSettings);
+                var database      = client.GetDatabase(opts.DatabaseName);
+                return new MongoSnapshotStore(database, opts, sp.GetService<IEventSerializer>());
+            });
+            services.AddSingleton<ISnapshotStore>(sp => sp.GetRequiredService<MongoSnapshotStore>());
+
+            if (options.InitializeIndexes) {
+                services.AddHostedService<SnapshotIndexInitializer>(sp => {
+                    var opts = sp.GetRequiredService<MongoSnapshotStoreOptions>();
+                    var mongoSettings = MongoClientSettings.FromConnectionString(opts.ConnectionString);
+                    var client        = new MongoClient(mongoSettings);
+                    var database      = client.GetDatabase(opts.DatabaseName);
+                    var loggerFactory = sp.GetService<ILoggerFactory>();
+                    return new SnapshotIndexInitializer(database, opts, loggerFactory);
+                });
+            }
+
+            return services;
+        }
+
+        /// <summary>
+        /// Adds MongoDB snapshot store to the DI container using configuration.
+        /// </summary>
+        /// <param name="config">Configuration section for MongoDB snapshot store options</param>
+        /// <returns>Services collection</returns>
+        // ReSharper disable once UnusedMethodReturnValue.Global
+        public IServiceCollection AddMongoSnapshotStore(IConfiguration config) {
+            services.Configure<MongoSnapshotStoreOptions>(config);
+            services.AddSingleton<MongoSnapshotStoreOptions>(sp => sp.GetRequiredService<IOptions<MongoSnapshotStoreOptions>>().Value);
+
+            services.AddSingleton<MongoSnapshotStore>(sp => {
+                var opts = sp.GetRequiredService<MongoSnapshotStoreOptions>();
+                var mongoSettings = MongoClientSettings.FromConnectionString(Ensure.NotEmptyString(opts.ConnectionString));
+                var client        = new MongoClient(mongoSettings);
+                var database      = client.GetDatabase(opts.DatabaseName);
+                return new MongoSnapshotStore(database, opts, sp.GetService<IEventSerializer>());
+            });
+            services.AddSingleton<ISnapshotStore>(sp => sp.GetRequiredService<MongoSnapshotStore>());
+
+            // Register index initializer only if InitializeIndexes is enabled
+            // The initializer will check the option and skip if false
+            services.AddHostedService<SnapshotIndexInitializer>(sp => {
+                var opts = sp.GetRequiredService<MongoSnapshotStoreOptions>();
+                var mongoSettings = MongoClientSettings.FromConnectionString(Ensure.NotEmptyString(opts.ConnectionString));
+                var client        = new MongoClient(mongoSettings);
+                var database      = client.GetDatabase(opts.DatabaseName);
+                var loggerFactory = sp.GetService<ILoggerFactory>();
+                return new SnapshotIndexInitializer(database, opts, loggerFactory);
+            });
+
+            return services;
+        }
+    }
+}
+
diff --git a/src/Mongo/src/Eventuous.MongoDB/Snapshots/MongoSnapshotStore.cs b/src/Mongo/src/Eventuous.MongoDB/Snapshots/MongoSnapshotStore.cs
new file mode 100644
index 00000000..7c3f91d7
--- /dev/null
+++ b/src/Mongo/src/Eventuous.MongoDB/Snapshots/MongoSnapshotStore.cs
@@ -0,0 +1,94 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+using System.Runtime.Serialization;
+using System.Text;
+using static Eventuous.DeserializationResult;
+
+namespace Eventuous.MongoDB.Snapshots;
+
+/// <summary>
+/// MongoDB snapshot store implementation for storing snapshots separately from event streams.
+/// </summary>
+public class MongoSnapshotStore : ISnapshotStore {
+    readonly IMongoCollection<SnapshotDocument> _collection;
+    readonly IEventSerializer                   _serializer;
+    const    string                             ContentType = "application/json";
+
+    public MongoSnapshotStore(
+            IMongoDatabase              database,
+            MongoSnapshotStoreOptions?  options,
+            IEventSerializer?           serializer = null
+        ) {
+        var mongoOptions = options ?? new MongoSnapshotStoreOptions();
+        _collection = Ensure.NotNull(database).GetCollection<SnapshotDocument>(mongoOptions.CollectionName);
+        _serializer = serializer ?? DefaultEventSerializer.Instance;
+    }
+
+    /// <inheritdoc />
+    [RequiresDynamicCode("Only works with AOT when using DefaultStaticEventSerializer")]
+    [RequiresUnreferencedCode("Only works with AOT when using DefaultStaticEventSerializer")]
+    public async Task<Snapshot?> Read(StreamName streamName, CancellationToken cancellationToken = default) {
+        var document = await _collection
+            .Find(x => x.StreamName == streamName.ToString())
+            .SingleOrDefaultAsync(cancellationToken)
+            .NoContext();
+
+        if (document == null) {
+            return null;
+        }
+
+        var deserialized = _serializer.DeserializeEvent(
+            Encoding.UTF8.GetBytes(document.JsonData),
+            document.EventType,
+            ContentType
+        );
+
+        return deserialized switch {
+            SuccessfullyDeserialized success => new Snapshot {
+                Revision = document.Revision,
+                Payload  = success.Payload
+            },
+            FailedToDeserialize failed => throw new SerializationException($"Can't deserialize snapshot {document.EventType}: {failed.Error}"),
+            _                          => throw new("Unknown deserialization result")
+        };
+    }
+
+    /// <inheritdoc />
+    [RequiresDynamicCode("Only works with AOT when using DefaultStaticEventSerializer")]
+    [RequiresUnreferencedCode("Only works with AOT when using DefaultStaticEventSerializer")]
+    public async Task Write(StreamName streamName, Snapshot snapshot, CancellationToken cancellationToken = default) {
+        if (snapshot.Payload == null) {
+            throw new ArgumentException("Snapshot payload cannot be null", nameof(snapshot));
+        }
+
+        var serialized = _serializer.SerializeEvent(snapshot.Payload);
+        var jsonData   = Encoding.UTF8.GetString(serialized.Payload);
+
+        var document = new SnapshotDocument {
+            StreamName = streamName.ToString(),
+            Revision   = snapshot.Revision,
+            EventType  = serialized.EventType,
+            JsonData   = jsonData,
+            Created    = DateTime.UtcNow
+        };
+
+        await _collection.ReplaceOneAsync(
+                x => x.StreamName == streamName.ToString(),
+                document,
+                new ReplaceOptions { IsUpsert = true },
+                cancellationToken
+            )
+            .NoContext();
+    }
+
+    /// <inheritdoc />
+    public async Task Delete(StreamName streamName, CancellationToken cancellationToken = default) {
+        await _collection.DeleteOneAsync(
+                x => x.StreamName == streamName.ToString(),
+                cancellationToken
+            )
+            .NoContext();
+    }
+}
+
diff --git a/src/Mongo/src/Eventuous.MongoDB/Snapshots/MongoSnapshotStoreOptions.cs b/src/Mongo/src/Eventuous.MongoDB/Snapshots/MongoSnapshotStoreOptions.cs
new file mode 100644
index 00000000..fe48ccc5
--- /dev/null
+++ b/src/Mongo/src/Eventuous.MongoDB/Snapshots/MongoSnapshotStoreOptions.cs
@@ -0,0 +1,33 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+// ReSharper disable PropertyCanBeMadeInitOnly.Global
+
+namespace Eventuous.MongoDB.Snapshots;
+
+/// <summary>
+/// MongoDB snapshot store options.
+/// </summary>
+[PublicAPI]
+public class MongoSnapshotStoreOptions {
+    /// <summary>
+    /// MongoDB connection string.
+    /// </summary>
+    public string ConnectionString { get; set; } = null!;
+
+    /// <summary>
+    /// Database name. Default is "eventuous".
+    /// </summary>
+    public string DatabaseName { get; set; } = "eventuous";
+
+    /// <summary>
+    /// Collection name for snapshots. Default is "snapshots".
+    /// </summary>
+    public string CollectionName { get; set; } = "snapshots";
+
+    /// <summary>
+    /// Set to true to initialize indexes on startup. Default is false.
+    /// </summary>
+    public bool InitializeIndexes { get; set; }
+}
+
diff --git a/src/Mongo/src/Eventuous.MongoDB/Snapshots/SnapshotDocument.cs b/src/Mongo/src/Eventuous.MongoDB/Snapshots/SnapshotDocument.cs
new file mode 100644
index 00000000..512bbd14
--- /dev/null
+++ b/src/Mongo/src/Eventuous.MongoDB/Snapshots/SnapshotDocument.cs
@@ -0,0 +1,16 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+namespace Eventuous.MongoDB.Snapshots;
+
+/// <summary>
+/// MongoDB document representation of a snapshot.
+/// </summary>
+record SnapshotDocument {
+    public string   StreamName { get; init; } = null!;
+    public long     Revision   { get; init; }
+    public string   EventType  { get; init; } = null!;
+    public string   JsonData   { get; init; } = null!;
+    public DateTime Created    { get; init; }
+}
+
diff --git a/src/Mongo/src/Eventuous.MongoDB/Snapshots/SnapshotIndexInitializer.cs b/src/Mongo/src/Eventuous.MongoDB/Snapshots/SnapshotIndexInitializer.cs
new file mode 100644
index 00000000..c9d27efc
--- /dev/null
+++ b/src/Mongo/src/Eventuous.MongoDB/Snapshots/SnapshotIndexInitializer.cs
@@ -0,0 +1,62 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace Eventuous.MongoDB.Snapshots;
+
+/// <summary>
+/// Initializes MongoDB indexes for snapshot collection on startup.
+/// </summary>
+public class SnapshotIndexInitializer : IHostedService {
+    readonly IMongoDatabase            _database;
+    readonly MongoSnapshotStoreOptions _options;
+    readonly ILogger<SnapshotIndexInitializer>? _logger;
+
+    public SnapshotIndexInitializer(
+            IMongoDatabase              database,
+            MongoSnapshotStoreOptions   options,
+            ILoggerFactory?             loggerFactory = null
+        ) {
+        _database = Ensure.NotNull(database);
+        _options  = Ensure.NotNull(options);
+        _logger   = loggerFactory?.CreateLogger<SnapshotIndexInitializer>();
+    }
+
+    public async Task StartAsync(CancellationToken cancellationToken) {
+        if (!_options.InitializeIndexes) return;
+
+        _logger?.LogInformation("Initializing snapshot indexes for collection {CollectionName}", _options.CollectionName);
+
+        var collection = _database.GetCollection<SnapshotDocument>(_options.CollectionName);
+
+        try {
+            // Create unique index on StreamName (equivalent to primary key in SQL)
+            var streamNameIndex = new CreateIndexModel<SnapshotDocument>(
+                Builders<SnapshotDocument>.IndexKeys.Ascending(x => x.StreamName),
+                new CreateIndexOptions { Unique = true, Name = "IX_Snapshots_StreamName" }
+            );
+
+            await collection.Indexes.CreateOneAsync(streamNameIndex, cancellationToken: cancellationToken).NoContext();
+
+            // Create index on Created for potential queries/filtering
+            var createdIndex = new CreateIndexModel<SnapshotDocument>(
+                Builders<SnapshotDocument>.IndexKeys.Ascending(x => x.Created),
+                new CreateIndexOptions { Name = "IX_Snapshots_Created" }
+            );
+
+            await collection.Indexes.CreateOneAsync(createdIndex, cancellationToken: cancellationToken).NoContext();
+
+            _logger?.LogInformation("Snapshot indexes initialized successfully");
+        } catch (MongoCommandException ex) when (ex.CodeName == "IndexOptionsConflict" || ex.Message.Contains("already exists")) {
+            _logger?.LogWarning("Index already exists, skipping creation");
+        } catch (Exception ex) {
+            _logger?.LogError(ex, "Failed to initialize snapshot indexes");
+            throw;
+        }
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+}
+

From 5286bb84b0c10d7577f3ee97196ec215119ef8b5 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Tue, 9 Dec 2025 15:00:23 +0300
Subject: [PATCH 22/25] fixed snapshot reading from mongodb

---
 .../Eventuous.MongoDB/Snapshots/MongoSnapshotStore.cs |  6 +++---
 .../Eventuous.MongoDB/Snapshots/SnapshotDocument.cs   |  3 +++
 .../Snapshots/SnapshotIndexInitializer.cs             | 11 +++--------
 3 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/src/Mongo/src/Eventuous.MongoDB/Snapshots/MongoSnapshotStore.cs b/src/Mongo/src/Eventuous.MongoDB/Snapshots/MongoSnapshotStore.cs
index 7c3f91d7..d819811b 100644
--- a/src/Mongo/src/Eventuous.MongoDB/Snapshots/MongoSnapshotStore.cs
+++ b/src/Mongo/src/Eventuous.MongoDB/Snapshots/MongoSnapshotStore.cs
@@ -30,7 +30,7 @@ public MongoSnapshotStore(
     [RequiresUnreferencedCode("Only works with AOT when using DefaultStaticEventSerializer")]
     public async Task<Snapshot?> Read(StreamName streamName, CancellationToken cancellationToken = default) {
         var document = await _collection
-            .Find(x => x.StreamName == streamName.ToString())
+            .Find(Builders<SnapshotDocument>.Filter.Eq(x => x.StreamName, streamName.ToString()))
             .SingleOrDefaultAsync(cancellationToken)
             .NoContext();
 
@@ -74,7 +74,7 @@ public async Task Write(StreamName streamName, Snapshot snapshot, CancellationTo
         };
 
         await _collection.ReplaceOneAsync(
-                x => x.StreamName == streamName.ToString(),
+                Builders<SnapshotDocument>.Filter.Eq(x => x.StreamName, streamName.ToString()),
                 document,
                 new ReplaceOptions { IsUpsert = true },
                 cancellationToken
@@ -85,7 +85,7 @@ await _collection.ReplaceOneAsync(
     /// <inheritdoc />
     public async Task Delete(StreamName streamName, CancellationToken cancellationToken = default) {
         await _collection.DeleteOneAsync(
-                x => x.StreamName == streamName.ToString(),
+                Builders<SnapshotDocument>.Filter.Eq(x => x.StreamName, streamName.ToString()),
                 cancellationToken
             )
             .NoContext();
diff --git a/src/Mongo/src/Eventuous.MongoDB/Snapshots/SnapshotDocument.cs b/src/Mongo/src/Eventuous.MongoDB/Snapshots/SnapshotDocument.cs
index 512bbd14..efcd38f7 100644
--- a/src/Mongo/src/Eventuous.MongoDB/Snapshots/SnapshotDocument.cs
+++ b/src/Mongo/src/Eventuous.MongoDB/Snapshots/SnapshotDocument.cs
@@ -1,12 +1,15 @@
 // Copyright (C) Eventuous HQ OÜ. All rights reserved
 // Licensed under the Apache License, Version 2.0.
 
+using MongoDB.Bson.Serialization.Attributes;
+
 namespace Eventuous.MongoDB.Snapshots;
 
 /// <summary>
 /// MongoDB document representation of a snapshot.
 /// </summary>
 record SnapshotDocument {
+    [BsonId]
     public string   StreamName { get; init; } = null!;
     public long     Revision   { get; init; }
     public string   EventType  { get; init; } = null!;
diff --git a/src/Mongo/src/Eventuous.MongoDB/Snapshots/SnapshotIndexInitializer.cs b/src/Mongo/src/Eventuous.MongoDB/Snapshots/SnapshotIndexInitializer.cs
index c9d27efc..d1d64fd7 100644
--- a/src/Mongo/src/Eventuous.MongoDB/Snapshots/SnapshotIndexInitializer.cs
+++ b/src/Mongo/src/Eventuous.MongoDB/Snapshots/SnapshotIndexInitializer.cs
@@ -32,14 +32,9 @@ public async Task StartAsync(CancellationToken cancellationToken) {
         var collection = _database.GetCollection<SnapshotDocument>(_options.CollectionName);
 
         try {
-            // Create unique index on StreamName (equivalent to primary key in SQL)
-            var streamNameIndex = new CreateIndexModel<SnapshotDocument>(
-                Builders<SnapshotDocument>.IndexKeys.Ascending(x => x.StreamName),
-                new CreateIndexOptions { Unique = true, Name = "IX_Snapshots_StreamName" }
-            );
-
-            await collection.Indexes.CreateOneAsync(streamNameIndex, cancellationToken: cancellationToken).NoContext();
-
+            // Note: StreamName is marked as [BsonId], so it's automatically indexed as _id
+            // No need to create a separate index on StreamName
+            
             // Create index on Created for potential queries/filtering
             var createdIndex = new CreateIndexModel<SnapshotDocument>(
                 Builders<SnapshotDocument>.IndexKeys.Ascending(x => x.Created),

From 4a1720e79ded0118afa420845391eb46de103c63 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Tue, 9 Dec 2025 15:45:09 +0300
Subject: [PATCH 23/25] fixed sqlserver duplicate constraint name

---
 .../Snapshots/Scripts/1_SnapshotSchema.sql                    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/SqlServer/src/Eventuous.SqlServer/Snapshots/Scripts/1_SnapshotSchema.sql b/src/SqlServer/src/Eventuous.SqlServer/Snapshots/Scripts/1_SnapshotSchema.sql
index 1a4b7e2a..d118344e 100644
--- a/src/SqlServer/src/Eventuous.SqlServer/Snapshots/Scripts/1_SnapshotSchema.sql
+++ b/src/SqlServer/src/Eventuous.SqlServer/Snapshots/Scripts/1_SnapshotSchema.sql
@@ -13,8 +13,8 @@ IF OBJECT_ID('__schema__.snapshots', 'U') IS NULL
             json_data   NVARCHAR(MAX)  NOT NULL,
             created     DATETIME2(7)   NOT NULL DEFAULT GETUTCDATE(),
             CONSTRAINT PK_Snapshots PRIMARY KEY CLUSTERED (stream_name),
-            CONSTRAINT CK_RevisionGteZero CHECK (revision >= 0),
-            CONSTRAINT CK_JsonDataIsJson CHECK (ISJSON(json_data) = 1)
+            CONSTRAINT CK_Snapshots_RevisionGteZero CHECK (revision >= 0),
+            CONSTRAINT CK_Snapshots_JsonDataIsJson CHECK (ISJSON(json_data) = 1)
         );
 
         CREATE INDEX IDX_SnapshotsStreamName ON __schema__.snapshots (stream_name);

From 9a48a0c04f3f43e7c1d4c0a79258ac5f4cc552e2 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Tue, 9 Dec 2025 17:29:23 +0300
Subject: [PATCH 24/25] added redis snapshot store

---
 Directory.Packages.props                      |   1 +
 .../banking/Banking.Api/Banking.Api.csproj    |   1 +
 samples/banking/Banking.Api/Program.cs        |   9 +-
 samples/banking/Banking.AppHost/AppHost.cs    |   7 +-
 .../Banking.AppHost/Banking.AppHost.csproj    |   1 +
 .../Extensions/RegistrationExtensions.cs      | 212 ++++++++++++++++++
 src/Redis/src/Eventuous.Redis/RedisKeys.cs    |   4 +
 .../Snapshots/RedisSnapshotStore.cs           | 105 +++++++++
 .../Snapshots/RedisSnapshotStoreOptions.cs    |  14 ++
 9 files changed, 352 insertions(+), 2 deletions(-)
 create mode 100644 src/Redis/src/Eventuous.Redis/Extensions/RegistrationExtensions.cs
 create mode 100644 src/Redis/src/Eventuous.Redis/Snapshots/RedisSnapshotStore.cs
 create mode 100644 src/Redis/src/Eventuous.Redis/Snapshots/RedisSnapshotStoreOptions.cs

diff --git a/Directory.Packages.props b/Directory.Packages.props
index 57602e75..7a38340c 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -24,6 +24,7 @@
   <ItemGroup>
     <PackageVersion Include="Aspire.Hosting.MongoDB" Version="13.0.2" />
     <PackageVersion Include="Aspire.Hosting.PostgreSQL" Version="13.0.2" />
+    <PackageVersion Include="Aspire.Hosting.Redis" Version="13.0.2" />
     <PackageVersion Include="Aspire.Hosting.SqlServer" Version="13.0.2" />
     <PackageVersion Include="BenchmarkDotNet" Version="0.14.0" />
     <PackageVersion Include="CommunityToolkit.Aspire.Hosting.KurrentDB" Version="13.0.0" />
diff --git a/samples/banking/Banking.Api/Banking.Api.csproj b/samples/banking/Banking.Api/Banking.Api.csproj
index 77e97dfb..53090d69 100644
--- a/samples/banking/Banking.Api/Banking.Api.csproj
+++ b/samples/banking/Banking.Api/Banking.Api.csproj
@@ -18,6 +18,7 @@
     <ProjectReference Include="$(SrcRoot)\Postgres\src\Eventuous.Postgresql\Eventuous.Postgresql.csproj" />
     <ProjectReference Include="$(SrcRoot)\SqlServer\src\Eventuous.SqlServer\Eventuous.SqlServer.csproj" />
     <ProjectReference Include="$(SrcRoot)\Mongo\src\Eventuous.MongoDB\Eventuous.MongoDB.csproj" />
+    <ProjectReference Include="$(SrcRoot)\Redis\src\Eventuous.Redis\Eventuous.Redis.csproj" />
     <ProjectReference Include="..\Banking.Domain\Banking.Domain.csproj" />
   </ItemGroup>
 
diff --git a/samples/banking/Banking.Api/Program.cs b/samples/banking/Banking.Api/Program.cs
index 42ae4108..bf985e32 100644
--- a/samples/banking/Banking.Api/Program.cs
+++ b/samples/banking/Banking.Api/Program.cs
@@ -27,7 +27,14 @@
     throw new InvalidOperationException("mongodb snapshots db connection string should be not null");
 }
 
-builder.Services.AddMongoSnapshotStore(mongoDbSnapshotsDbConnectionString, initializeIndexes: true);
+//builder.Services.AddMongoSnapshotStore(mongoDbSnapshotsDbConnectionString, initializeIndexes: true);
+
+var redisConnectionString = builder.Configuration.GetConnectionString("redis");
+if (redisConnectionString == null) {
+    throw new InvalidOperationException("redis connection string should be not null");
+}
+
+builder.Services.AddRedisSnapshotStore(redisConnectionString, database: 0);
 
 //----------------------------------------------------------------
 // Event store registration
diff --git a/samples/banking/Banking.AppHost/AppHost.cs b/samples/banking/Banking.AppHost/AppHost.cs
index f1190b8d..f6101a37 100644
--- a/samples/banking/Banking.AppHost/AppHost.cs
+++ b/samples/banking/Banking.AppHost/AppHost.cs
@@ -16,6 +16,9 @@
 
 var mongodbSnapshotsDb = mongodb.AddDatabase("eventuous-mongodb-snapshotsdb", "snapshots");
 
+var redis = builder.AddRedis("eventuous-redis")
+    .WithRedisInsight();
+
 builder
     .AddProject<Projects.Banking_Api>("banking-api")
     .WithReference(kurrentdb, "kurrentdb")
@@ -25,7 +28,9 @@
     .WithReference(sqlServerSnapshotsDb, "sqlServerSnapshotsDb")
     .WaitFor(sqlServerSnapshotsDb)
     .WithReference(mongodbSnapshotsDb, "mongoDbSnapshotsDb")
-    .WaitFor(mongodbSnapshotsDb);
+    .WaitFor(mongodbSnapshotsDb)
+    .WithReference(redis, "redis")
+    .WaitFor(redis);
 
 builder
     .Build()
diff --git a/samples/banking/Banking.AppHost/Banking.AppHost.csproj b/samples/banking/Banking.AppHost/Banking.AppHost.csproj
index 18d1164e..a728b1a0 100644
--- a/samples/banking/Banking.AppHost/Banking.AppHost.csproj
+++ b/samples/banking/Banking.AppHost/Banking.AppHost.csproj
@@ -11,6 +11,7 @@
   <ItemGroup>
     <PackageReference Include="Aspire.Hosting.MongoDB" />
     <PackageReference Include="Aspire.Hosting.PostgreSQL" />
+    <PackageReference Include="Aspire.Hosting.Redis" />
     <PackageReference Include="Aspire.Hosting.SqlServer" />
     <PackageReference Include="CommunityToolkit.Aspire.Hosting.KurrentDB" />
   </ItemGroup>
diff --git a/src/Redis/src/Eventuous.Redis/Extensions/RegistrationExtensions.cs b/src/Redis/src/Eventuous.Redis/Extensions/RegistrationExtensions.cs
new file mode 100644
index 00000000..df0cdbc5
--- /dev/null
+++ b/src/Redis/src/Eventuous.Redis/Extensions/RegistrationExtensions.cs
@@ -0,0 +1,212 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+using Eventuous.Redis;
+using Eventuous.Redis.Snapshots;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Options;
+using StackExchange.Redis;
+
+// ReSharper disable UnusedMethodReturnValue.Global
+// ReSharper disable once CheckNamespace
+namespace Microsoft.Extensions.DependencyInjection;
+
+public static class ServiceCollectionExtensions {
+    /// <param name="services">Service collection</param>
+    extension(IServiceCollection services) {
+        /// <summary>
+        /// Adds Redis snapshot store to the DI container.
+        /// </summary>
+        /// <param name="getDatabase">Function to get Redis database instance</param>
+        /// <param name="options">Snapshot store options</param>
+        /// <returns>Services collection</returns>
+        // ReSharper disable once UnusedMethodReturnValue.Global
+        public IServiceCollection AddRedisSnapshotStore(
+                GetRedisDatabase              getDatabase,
+                RedisSnapshotStoreOptions?    options
+            ) {
+            var snapshotOptions = options ?? new RedisSnapshotStoreOptions();
+            services.AddSingleton(snapshotOptions);
+            services.AddSingleton<RedisSnapshotStore>(sp => {
+                var snapshotOptions = sp.GetRequiredService<RedisSnapshotStoreOptions>();
+                return new RedisSnapshotStore(getDatabase, snapshotOptions, sp.GetService<IEventSerializer>());
+            });
+            services.AddSingleton<ISnapshotStore>(sp => sp.GetRequiredService<RedisSnapshotStore>());
+
+            return services;
+        }
+
+        /// <summary>
+        /// Adds Redis snapshot store to the DI container with default options.
+        /// </summary>
+        /// <param name="getDatabase">Function to get Redis database instance</param>
+        /// <returns>Services collection</returns>
+        // ReSharper disable once UnusedMethodReturnValue.Global
+        public IServiceCollection AddRedisSnapshotStore(GetRedisDatabase getDatabase) {
+            return services.AddRedisSnapshotStore(getDatabase, (RedisSnapshotStoreOptions?)null);
+        }
+
+        /// <summary>
+        /// Adds Redis snapshot store to the DI container using connection multiplexer.
+        /// </summary>
+        /// <param name="connectionMultiplexer">Redis connection multiplexer</param>
+        /// <param name="database">Database number (default: 0)</param>
+        /// <param name="options">Snapshot store options</param>
+        /// <returns>Services collection</returns>
+        // ReSharper disable once UnusedMethodReturnValue.Global
+        public IServiceCollection AddRedisSnapshotStore(
+                IConnectionMultiplexer         connectionMultiplexer,
+                int                           database,
+                RedisSnapshotStoreOptions?    options
+            ) {
+            GetRedisDatabase getDatabase = () => connectionMultiplexer.GetDatabase(database);
+            return services.AddRedisSnapshotStore(getDatabase, options);
+        }
+
+        /// <summary>
+        /// Adds Redis snapshot store to the DI container using connection multiplexer with default options.
+        /// </summary>
+        /// <param name="connectionMultiplexer">Redis connection multiplexer</param>
+        /// <param name="database">Database number (default: 0)</param>
+        /// <returns>Services collection</returns>
+        // ReSharper disable once UnusedMethodReturnValue.Global
+        public IServiceCollection AddRedisSnapshotStore(
+                IConnectionMultiplexer         connectionMultiplexer,
+                int                           database = 0
+            ) {
+            return services.AddRedisSnapshotStore(connectionMultiplexer, database, null);
+        }
+
+        /// <summary>
+        /// Adds Redis snapshot store to the DI container using configuration.
+        /// </summary>
+        /// <param name="getDatabase">Function to get Redis database instance</param>
+        /// <param name="config">Configuration section for Redis snapshot store options</param>
+        /// <returns>Services collection</returns>
+        // ReSharper disable once UnusedMethodReturnValue.Global
+        public IServiceCollection AddRedisSnapshotStore(
+                GetRedisDatabase              getDatabase,
+                IConfiguration                config
+            ) {
+            var options = new RedisSnapshotStoreOptions();
+            if (config["KeyPrefix"] != null) {
+                options.KeyPrefix = config["KeyPrefix"];
+            }
+            services.AddSingleton(options);
+
+            services.AddSingleton<RedisSnapshotStore>(sp => {
+                var snapshotOptions = sp.GetRequiredService<RedisSnapshotStoreOptions>();
+                return new RedisSnapshotStore(getDatabase, snapshotOptions, sp.GetService<IEventSerializer>());
+            });
+            services.AddSingleton<ISnapshotStore>(sp => sp.GetRequiredService<RedisSnapshotStore>());
+
+            return services;
+        }
+
+        /// <summary>
+        /// Adds Redis snapshot store to the DI container using connection multiplexer and configuration.
+        /// </summary>
+        /// <param name="connectionMultiplexer">Redis connection multiplexer</param>
+        /// <param name="config">Configuration section for Redis snapshot store options</param>
+        /// <param name="database">Database number (default: 0)</param>
+        /// <returns>Services collection</returns>
+        // ReSharper disable once UnusedMethodReturnValue.Global
+        public IServiceCollection AddRedisSnapshotStore(
+                IConnectionMultiplexer         connectionMultiplexer,
+                IConfiguration                 config,
+                int                            database = 0
+            ) {
+            var options = new RedisSnapshotStoreOptions();
+            if (config["KeyPrefix"] != null) {
+                options.KeyPrefix = config["KeyPrefix"];
+            }
+            services.AddSingleton(options);
+
+            GetRedisDatabase getDatabase = () => connectionMultiplexer.GetDatabase(database);
+            services.AddSingleton<RedisSnapshotStore>(sp => {
+                var snapshotOptions = sp.GetRequiredService<RedisSnapshotStoreOptions>();
+                return new RedisSnapshotStore(getDatabase, snapshotOptions, sp.GetService<IEventSerializer>());
+            });
+            services.AddSingleton<ISnapshotStore>(sp => sp.GetRequiredService<RedisSnapshotStore>());
+
+            return services;
+        }
+
+        /// <summary>
+        /// Adds Redis snapshot store to the DI container using connection string.
+        /// </summary>
+        /// <param name="connectionString">Redis connection string</param>
+        /// <param name="database">Database number (default: 0)</param>
+        /// <param name="options">Snapshot store options</param>
+        /// <returns>Services collection</returns>
+        // ReSharper disable once UnusedMethodReturnValue.Global
+        public IServiceCollection AddRedisSnapshotStore(
+                string                         connectionString,
+                int                            database,
+                RedisSnapshotStoreOptions?     options
+            ) {
+            services.AddSingleton<IConnectionMultiplexer>(_ => ConnectionMultiplexer.Connect(connectionString));
+            
+            var snapshotOptions = options ?? new RedisSnapshotStoreOptions();
+            services.AddSingleton(snapshotOptions);
+            
+            services.AddSingleton<RedisSnapshotStore>(sp => {
+                var snapshotOptions = sp.GetRequiredService<RedisSnapshotStoreOptions>();
+                var muxer = sp.GetRequiredService<IConnectionMultiplexer>();
+                GetRedisDatabase getDatabase = () => muxer.GetDatabase(database);
+                return new RedisSnapshotStore(getDatabase, snapshotOptions, sp.GetService<IEventSerializer>());
+            });
+            services.AddSingleton<ISnapshotStore>(sp => sp.GetRequiredService<RedisSnapshotStore>());
+
+            return services;
+        }
+
+        /// <summary>
+        /// Adds Redis snapshot store to the DI container using connection string with default options.
+        /// </summary>
+        /// <param name="connectionString">Redis connection string</param>
+        /// <param name="database">Database number (default: 0)</param>
+        /// <returns>Services collection</returns>
+        // ReSharper disable once UnusedMethodReturnValue.Global
+        public IServiceCollection AddRedisSnapshotStore(
+                string                         connectionString,
+                int                            database = 0
+            ) {
+            return services.AddRedisSnapshotStore(connectionString, database, null);
+        }
+
+        /// <summary>
+        /// Adds Redis snapshot store to the DI container using connection string and configuration.
+        /// </summary>
+        /// <param name="connectionString">Redis connection string</param>
+        /// <param name="config">Configuration section for Redis snapshot store options</param>
+        /// <param name="database">Database number (default: 0)</param>
+        /// <returns>Services collection</returns>
+        // ReSharper disable once UnusedMethodReturnValue.Global
+        public IServiceCollection AddRedisSnapshotStore(
+                string                         connectionString,
+                IConfiguration                 config,
+                int                            database = 0
+            ) {
+            services.AddSingleton<IConnectionMultiplexer>(_ => ConnectionMultiplexer.Connect(connectionString));
+            
+            var options = new RedisSnapshotStoreOptions();
+            if (config["KeyPrefix"] != null) {
+                options.KeyPrefix = config["KeyPrefix"];
+            }
+            services.AddSingleton(options);
+
+            services.AddSingleton<RedisSnapshotStore>(sp => {
+                var snapshotOptions = sp.GetRequiredService<RedisSnapshotStoreOptions>();
+                var muxer = sp.GetRequiredService<IConnectionMultiplexer>();
+                GetRedisDatabase getDatabase = () => muxer.GetDatabase(database);
+                return new RedisSnapshotStore(getDatabase, snapshotOptions, sp.GetService<IEventSerializer>());
+            });
+            services.AddSingleton<ISnapshotStore>(sp => sp.GetRequiredService<RedisSnapshotStore>());
+
+            return services;
+        }
+    }
+}
+
diff --git a/src/Redis/src/Eventuous.Redis/RedisKeys.cs b/src/Redis/src/Eventuous.Redis/RedisKeys.cs
index 9ffec171..291c394b 100644
--- a/src/Redis/src/Eventuous.Redis/RedisKeys.cs
+++ b/src/Redis/src/Eventuous.Redis/RedisKeys.cs
@@ -11,4 +11,8 @@ public static class EventuousRedisKeys {
     public const string Position = "position";
     public const string MessageId = "message_id";
     public const string MessageType = "message_type";
+    
+    // Snapshot keys
+    public const string Revision = "revision";
+    public const string EventType = "event_type";
 }
diff --git a/src/Redis/src/Eventuous.Redis/Snapshots/RedisSnapshotStore.cs b/src/Redis/src/Eventuous.Redis/Snapshots/RedisSnapshotStore.cs
new file mode 100644
index 00000000..7cfc7b3d
--- /dev/null
+++ b/src/Redis/src/Eventuous.Redis/Snapshots/RedisSnapshotStore.cs
@@ -0,0 +1,105 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+using System.Runtime.Serialization;
+using System.Text;
+using Eventuous;
+using static Eventuous.DeserializationResult;
+using static Eventuous.Redis.EventuousRedisKeys;
+
+namespace Eventuous.Redis.Snapshots;
+
+using Tools;
+
+/// <summary>
+/// Redis snapshot store implementation for storing snapshots separately from event streams.
+/// </summary>
+public class RedisSnapshotStore : ISnapshotStore {
+    readonly GetRedisDatabase           _getDatabase;
+    readonly RedisSnapshotStoreOptions  _options;
+    readonly IEventSerializer           _serializer;
+    const    string                     ContentType = "application/json";
+
+    public RedisSnapshotStore(
+            GetRedisDatabase              getDatabase,
+            RedisSnapshotStoreOptions?    options = null,
+            IEventSerializer?             serializer = null
+        ) {
+        _getDatabase = Ensure.NotNull(getDatabase, "Connection factory");
+        _options     = options ?? new RedisSnapshotStoreOptions();
+        _serializer  = serializer ?? DefaultEventSerializer.Instance;
+    }
+
+    string GetSnapshotKey(StreamName streamName) => $"{_options.KeyPrefix}:{streamName}";
+
+    /// <inheritdoc />
+    [RequiresDynamicCode("Only works with AOT when using DefaultStaticEventSerializer")]
+    [RequiresUnreferencedCode("Only works with AOT when using DefaultStaticEventSerializer")]
+    public async Task<Snapshot?> Read(StreamName streamName, CancellationToken cancellationToken = default) {
+        var database = _getDatabase();
+        var key      = GetSnapshotKey(streamName);
+        
+        var revisionValue  = await database.HashGetAsync(key, Revision).NoContext();
+        var eventTypeValue = await database.HashGetAsync(key, EventType).NoContext();
+        var jsonDataValue  = await database.HashGetAsync(key, JsonData).NoContext();
+
+        if (revisionValue.IsNull || eventTypeValue.IsNull || jsonDataValue.IsNull) {
+            return null;
+        }
+
+        var revision   = revisionValue.ToString();
+        var eventType  = eventTypeValue.ToString();
+        var jsonData   = jsonDataValue.ToString();
+
+        if (string.IsNullOrEmpty(revision) || string.IsNullOrEmpty(eventType) || string.IsNullOrEmpty(jsonData)) {
+            return null;
+        }
+
+        var deserialized = _serializer.DeserializeEvent(
+            Encoding.UTF8.GetBytes(jsonData),
+            eventType,
+            ContentType
+        );
+
+        return deserialized switch {
+            SuccessfullyDeserialized success => new Snapshot {
+                Revision = long.Parse(revision),
+                Payload  = success.Payload
+            },
+            FailedToDeserialize failed => throw new SerializationException($"Can't deserialize snapshot {eventType}: {failed.Error}"),
+            _                          => throw new("Unknown deserialization result")
+        };
+    }
+
+    /// <inheritdoc />
+    [RequiresDynamicCode("Only works with AOT when using DefaultStaticEventSerializer")]
+    [RequiresUnreferencedCode("Only works with AOT when using DefaultStaticEventSerializer")]
+    public async Task Write(StreamName streamName, Snapshot snapshot, CancellationToken cancellationToken = default) {
+        if (snapshot.Payload == null) {
+            throw new ArgumentException("Snapshot payload cannot be null", nameof(snapshot));
+        }
+
+        var serialized = _serializer.SerializeEvent(snapshot.Payload);
+        var jsonData   = Encoding.UTF8.GetString(serialized.Payload);
+        var key        = GetSnapshotKey(streamName);
+        var database   = _getDatabase();
+
+        var hashFields = new HashEntry[] {
+            new(Revision, snapshot.Revision.ToString()),
+            new(EventType, serialized.EventType),
+            new(JsonData, jsonData),
+            new(Created, DateTime.UtcNow.ToString("O"))
+        };
+
+        await database.HashSetAsync(key, hashFields).NoContext();
+    }
+
+    /// <inheritdoc />
+    public async Task Delete(StreamName streamName, CancellationToken cancellationToken = default) {
+        var database = _getDatabase();
+        var key      = GetSnapshotKey(streamName);
+
+        await database.KeyDeleteAsync(key).NoContext();
+    }
+}
+
diff --git a/src/Redis/src/Eventuous.Redis/Snapshots/RedisSnapshotStoreOptions.cs b/src/Redis/src/Eventuous.Redis/Snapshots/RedisSnapshotStoreOptions.cs
new file mode 100644
index 00000000..18bbd3df
--- /dev/null
+++ b/src/Redis/src/Eventuous.Redis/Snapshots/RedisSnapshotStoreOptions.cs
@@ -0,0 +1,14 @@
+// Copyright (C) Eventuous HQ OÜ. All rights reserved
+// Licensed under the Apache License, Version 2.0.
+
+// ReSharper disable PropertyCanBeMadeInitOnly.Global
+
+namespace Eventuous.Redis.Snapshots;
+
+public class RedisSnapshotStoreOptions {
+    /// <summary>
+    /// Redis key prefix for snapshots. Default is "snapshot".
+    /// </summary>
+    public string KeyPrefix { get; set; } = "snapshot";
+}
+

From cdac7750de40fcb733051b90dd0fa98b1674b121 Mon Sep 17 00:00:00 2001
From: AlexTroshkin <alextroshkin@outlook.com>
Date: Tue, 9 Dec 2025 17:41:08 +0300
Subject: [PATCH 25/25] fixed snapshotstore capture

---
 .../AggregateService/CommandService.cs                    | 6 +++---
 .../FunctionalService/CommandService.cs                   | 8 ++++----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs b/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
index d1f6b1d3..c08cae41 100644
--- a/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
+++ b/src/Core/src/Eventuous.Application/AggregateService/CommandService.cs
@@ -46,7 +46,7 @@ protected CommandService(
     readonly StreamNameMap                        _streamNameMap   = streamNameMap   ?? new StreamNameMap();
     readonly ITypeMapper                          _typeMap         = typeMap         ?? TypeMap.Instance;
     readonly ISnapshotStore?                      _snapshotStore   = snapshotStore;
-    SnapshotStrategy<TState>?                    _snapshotStrategy;
+    SnapshotStrategy<TState>?                     _snapshotStrategy;
 
     /// <summary>
     /// Returns the command handler builder for the specified command type.
@@ -94,10 +94,10 @@ public async Task<Result<TState>> Handle<TCommand>(TCommand command, Cancellatio
         try {
             var aggregate = registeredHandler.ExpectedState switch {
                 ExpectedState.Any => await reader
-                    .LoadAggregate<TAggregate, TState, TId>(aggregateId, _streamNameMap, false, _factoryRegistry, snapshotStore, cancellationToken)
+                    .LoadAggregate<TAggregate, TState, TId>(aggregateId, _streamNameMap, false, _factoryRegistry, _snapshotStore, cancellationToken)
                     .NoContext(),
                 ExpectedState.Existing => await reader
-                    .LoadAggregate<TAggregate, TState, TId>(aggregateId, _streamNameMap, true, _factoryRegistry, snapshotStore, cancellationToken)
+                    .LoadAggregate<TAggregate, TState, TId>(aggregateId, _streamNameMap, true, _factoryRegistry, _snapshotStore, cancellationToken)
                     .NoContext(),
                 ExpectedState.New     => Create(aggregateId),
                 ExpectedState.Unknown => null,
diff --git a/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs b/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
index 90c4e34a..cf7efd5b 100644
--- a/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
+++ b/src/Core/src/Eventuous.Application/FunctionalService/CommandService.cs
@@ -40,8 +40,8 @@ protected void OnAny<TCommand>(Func<TCommand, StreamName> getStreamName, Func<TS
 /// <typeparam name="TState">State object type</typeparam>
 public abstract class CommandService<TState>(IEventReader reader, IEventWriter writer, ITypeMapper? typeMap = null, AmendEvent? amendEvent = null, ISnapshotStore? snapshotStore = null)
     : ICommandService<TState> where TState : State<TState>, new() {
-    readonly ITypeMapper         _typeMap  = typeMap ?? TypeMap.Instance;
-    readonly HandlersMap<TState>  _handlers = new();
+    readonly ITypeMapper         _typeMap       = typeMap ?? TypeMap.Instance;
+    readonly HandlersMap<TState> _handlers      = new();
     readonly ISnapshotStore?     _snapshotStore = snapshotStore;
     SnapshotStrategy<TState>?    _snapshotStrategy;
 
@@ -99,8 +99,8 @@ public async Task<Result<TState>> Handle<TCommand>(TCommand command, Cancellatio
 
         try {
             var loadedState = registeredHandler.ExpectedState switch {
-                ExpectedState.Any      => await resolvedReader.LoadState<TState>(streamName, false, snapshotStore, cancellationToken).NoContext(),
-                ExpectedState.Existing => await resolvedReader.LoadState<TState>(streamName, true, snapshotStore, cancellationToken).NoContext(),
+                ExpectedState.Any      => await resolvedReader.LoadState<TState>(streamName, false, _snapshotStore, cancellationToken).NoContext(),
+                ExpectedState.Existing => await resolvedReader.LoadState<TState>(streamName, true, _snapshotStore, cancellationToken).NoContext(),
                 ExpectedState.New      => new(streamName, ExpectedStreamVersion.NoStream, []),
                 _                      => throw new ArgumentOutOfRangeException(null, "Unknown expected state")
             };