From 22e8594e45b679bc775f6545044d4ea88ae75e59 Mon Sep 17 00:00:00 2001
From: Robert Lemke <robert@flownative.com>
Date: Wed, 13 Mar 2024 11:10:51 +0100
Subject: [PATCH 1/2] Remove obsolete Proxy(false) annotations

Flow 9 can now handle read-only classes and value objects in general correctly and does not create proxy classes if not necessary.
---
 Neos.Flow/Classes/Session/Data/SessionIdentifier.php | 6 ++----
 Neos.Flow/Classes/Session/Data/SessionMetaData.php   | 7 +++----
 Neos.Flow/Classes/Session/Data/StorageIdentifier.php | 6 ++----
 3 files changed, 7 insertions(+), 12 deletions(-)

diff --git a/Neos.Flow/Classes/Session/Data/SessionIdentifier.php b/Neos.Flow/Classes/Session/Data/SessionIdentifier.php
index f3a0004fa9..76c59e3ba5 100644
--- a/Neos.Flow/Classes/Session/Data/SessionIdentifier.php
+++ b/Neos.Flow/Classes/Session/Data/SessionIdentifier.php
@@ -13,7 +13,6 @@
 
 namespace Neos\Flow\Session\Data;
 
-use Neos\Flow\Annotations as Flow;
 use Neos\Flow\Utility\Algorithms;
 
 /**
@@ -21,13 +20,12 @@
  * and identifies a SessionMetadata object from the SessionMetaDataStore that represents
  * a stored session without the key value store.
  *
- * @Flow\Proxy(false)
  * @internal
  */
-class SessionIdentifier
+readonly class SessionIdentifier
 {
     private function __construct(
-        public readonly string $value
+        public string $value
     ) {
     }
 
diff --git a/Neos.Flow/Classes/Session/Data/SessionMetaData.php b/Neos.Flow/Classes/Session/Data/SessionMetaData.php
index 2ca5403d01..e6944503a8 100644
--- a/Neos.Flow/Classes/Session/Data/SessionMetaData.php
+++ b/Neos.Flow/Classes/Session/Data/SessionMetaData.php
@@ -15,9 +15,6 @@
 
 use Neos\Flow\Annotations as Flow;
 
-/**
- * @Flow\Proxy(false)
- */
 class SessionMetaData
 {
     /**
@@ -26,6 +23,7 @@ class SessionMetaData
      * @param int $lastActivityTimestamp
      * @param string[] $tags
      */
+    #[Flow\Autowiring(false)]
     public function __construct(
         public readonly SessionIdentifier $sessionIdentifier,
         public readonly StorageIdentifier $storageIdentifier,
@@ -48,7 +46,8 @@ public static function createWithTimestamp(int $timestamp): self
      * Create session metadata from classic cache format for backwards compatibility
      * @param string $sessionIdentifier
      * @param array{'storageIdentifier': string, 'lastActivityTimestamp': int, 'tags': string[]} $data
-     * @deprecated this will be removed with flow 10
+     * @return self
+     * @deprecated this will be removed with Flow 10
      */
     public static function createFromSessionIdentifierStringAndOldArrayCacheFormat(string $sessionIdentifier, array $data): self
     {
diff --git a/Neos.Flow/Classes/Session/Data/StorageIdentifier.php b/Neos.Flow/Classes/Session/Data/StorageIdentifier.php
index 9e2774c358..def64a1743 100644
--- a/Neos.Flow/Classes/Session/Data/StorageIdentifier.php
+++ b/Neos.Flow/Classes/Session/Data/StorageIdentifier.php
@@ -13,7 +13,6 @@
 
 namespace Neos\Flow\Session\Data;
 
-use Neos\Flow\Annotations as Flow;
 use Neos\Flow\Utility\Algorithms;
 
 /**
@@ -22,13 +21,12 @@
  * and  is never exposed to the outside. The StorageIdentifier stays the same if a
  * Session gets a new SessionIdentifier (renewId).
  *
- * @Flow\Proxy(false)
  * @internal
  */
-class StorageIdentifier
+readonly class StorageIdentifier
 {
     private function __construct(
-        public readonly string $value
+        public string $value
     ) {
     }
 

From 7cd4be686d30fdd6b264a4e29610bcf707bced2d Mon Sep 17 00:00:00 2001
From: Robert Lemke <robert@flownative.com>
Date: Wed, 13 Mar 2024 15:46:13 +0100
Subject: [PATCH 2/2] TASK: Modernize and clean up session-related code

The session-related code in Flow was updated to use modern PHP features and attributes. Classes are also declared as strict and a few minor bugs which surfaced due to type strictness were fixed along the way.
---
 .../Session/Aspect/LazyLoadingAspect.php      |  80 ++----
 .../Aspect/LazyLoadingProxyInterface.php      |   1 +
 .../Classes/Session/Aspect/LoggingAspect.php  | 106 +++-----
 .../SessionObjectMethodsPointcutFilter.php    |  38 +--
 .../Session/CookieEnabledInterface.php        |  16 +-
 .../Session/Data/SessionIdentifier.php        |   3 +
 .../Session/Data/SessionKeyValueStore.php     |  14 +-
 .../Classes/Session/Data/SessionMetaData.php  |   8 +-
 .../Session/Data/SessionMetaDataStore.php     |  52 ++--
 .../Session/Data/StorageIdentifier.php        |   3 +
 Neos.Flow/Classes/Session/Exception.php       |   1 +
 .../DataNotSerializableException.php          |   1 +
 ...InvalidDataInSessionDataStoreException.php |   1 +
 .../InvalidRequestHandlerException.php        |   1 +
 .../InvalidRequestResponseException.php       |   1 +
 .../OperationNotSupportedException.php        |   1 +
 .../SessionAutostartIsEnabledException.php    |   1 +
 .../Exception/SessionNotStartedException.php  |   1 +
 Neos.Flow/Classes/Session/Session.php         | 244 +++++-------------
 .../Classes/Session/SessionInterface.php      |  55 ++--
 Neos.Flow/Classes/Session/SessionManager.php  | 142 ++++------
 .../Session/SessionManagerInterface.php       |  20 +-
 .../Classes/Session/TransientSession.php      | 131 +++-------
 Neos.Flow/Configuration/Objects.yaml          |   3 -
 .../Http/Middleware/SessionMiddlewareTest.php |  25 +-
 .../AuthenticationProviderManagerTest.php     |   2 +-
 .../Tests/Unit/Session/SessionManagerTest.php |  86 +++---
 Neos.Flow/Tests/Unit/Session/SessionTest.php  | 109 +++++---
 28 files changed, 442 insertions(+), 704 deletions(-)

diff --git a/Neos.Flow/Classes/Session/Aspect/LazyLoadingAspect.php b/Neos.Flow/Classes/Session/Aspect/LazyLoadingAspect.php
index 12311364e5..6254dd84a7 100644
--- a/Neos.Flow/Classes/Session/Aspect/LazyLoadingAspect.php
+++ b/Neos.Flow/Classes/Session/Aspect/LazyLoadingAspect.php
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace Neos\Flow\Session\Aspect;
 
 /*
@@ -19,55 +20,29 @@
 
 /**
  * Adds the aspect of lazy loading to objects with scope session.
- *
- * @Flow\Aspect
- * @Flow\Introduce("filter(Neos\Flow\Session\Aspect\SessionObjectMethodsPointcutFilter)", interfaceName = "Neos\Flow\Session\Aspect\LazyLoadingProxyInterface")
- * @Flow\Scope("singleton")
  */
+#[Flow\Aspect]
+#[Flow\Introduce(pointcutExpression: "filter(Neos\Flow\Session\Aspect\SessionObjectMethodsPointcutFilter)", interfaceName: LazyLoadingProxyInterface::class)]
+#[Flow\Scope("singleton")]
 class LazyLoadingAspect
 {
-    /**
-     * @Flow\Inject
-     * @var ObjectManagerInterface
-     */
-    protected $objectManager;
-
-    /**
-     * @Flow\Inject
-     * @var SessionManagerInterface
-     */
-    protected $sessionManager;
+    #[Flow\Inject]
+    protected ?LoggerInterface $logger = null;
 
-    /**
-     * @var LoggerInterface
-     */
-    protected $logger;
-
-    /**
-     * @var array
-     */
-    protected $sessionOriginalInstances = [];
+    protected array $sessionOriginalInstances = [];
 
-    /**
-     * Injects the (system) logger based on PSR-3.
-     *
-     * @param LoggerInterface $logger
-     * @return void
-     */
-    public function injectLogger(LoggerInterface $logger)
-    {
-        $this->logger = $logger;
+    public function __construct(
+        readonly protected ObjectManagerInterface $objectManager,
+        readonly protected SessionManagerInterface $sessionManager,
+    ) {
     }
 
     /**
      * Registers an object of scope session.
      *
-     * @param string $objectName
-     * @param object $object
-     * @return void
      * @see \Neos\Flow\ObjectManagement\ObjectManager
      */
-    public function registerSessionInstance($objectName, $object)
+    public function registerSessionInstance(string $objectName, object $object): void
     {
         $this->sessionOriginalInstances[$objectName] = $object;
     }
@@ -77,12 +52,10 @@ public function registerSessionInstance($objectName, $object)
      * Those methods will trigger a session initialization if a session does not exist
      * yet.
      *
-     * @param JoinPointInterface $joinPoint The current join point
-     * @return void
-     * @fixme The pointcut expression below does not consider the options of the session annotation – needs adjustments in the AOP framework
-     * @Flow\Before("methodAnnotatedWith(Neos\Flow\Annotations\Session)")
+     * @fixme The pointcut expression below does not consider the options of the session annotation and needs adjustments in the AOP framework
      */
-    public function initializeSession(JoinPointInterface $joinPoint)
+    #[Flow\Before("methodAnnotatedWith(Neos\Flow\Annotations\Session)")]
+    public function initializeSession(JoinPointInterface $joinPoint): void
     {
         $session = $this->sessionManager->getCurrentSession();
 
@@ -90,23 +63,20 @@ public function initializeSession(JoinPointInterface $joinPoint)
             return;
         }
 
-        /** @var string $objectName */
-        $objectName = $this->objectManager->getObjectNameByClassName(get_class($joinPoint->getProxy()));
-        $methodName = $joinPoint->getMethodName();
-
-        $this->logger->debug(sprintf('Session initialization triggered by %s->%s.', $objectName, $methodName));
+        if ($this->logger) {
+            $objectName = $this->objectManager->getObjectNameByClassName(get_class($joinPoint->getProxy()));
+            $methodName = $joinPoint->getMethodName();
+            $this->logger->debug(sprintf('Session initialization triggered by %s->%s.', $objectName, $methodName));
+        }
         $session->start();
     }
 
     /**
      * Around advice, wrapping every method of a scope session object. It redirects
      * all method calls to the session object once there is one.
-     *
-     * @param JoinPointInterface $joinPoint The current join point
-     * @return mixed
-     * @Flow\Around("filter(Neos\Flow\Session\Aspect\SessionObjectMethodsPointcutFilter)")
      */
-    public function callMethodOnOriginalSessionObject(JoinPointInterface $joinPoint)
+    #[Flow\Around("filter(Neos\Flow\Session\Aspect\SessionObjectMethodsPointcutFilter)")]
+    public function callMethodOnOriginalSessionObject(JoinPointInterface $joinPoint): mixed
     {
         $objectName = $this->objectManager->getObjectNameByClassName(get_class($joinPoint->getProxy()));
         $methodName = $joinPoint->getMethodName();
@@ -118,9 +88,9 @@ public function callMethodOnOriginalSessionObject(JoinPointInterface $joinPoint)
 
         if ($this->sessionOriginalInstances[$objectName] === $proxy) {
             return $joinPoint->getAdviceChain()->proceed($joinPoint);
-        } else {
-            $arguments = array_values($joinPoint->getMethodArguments());
-            return $this->sessionOriginalInstances[$objectName]->$methodName(...$arguments);
         }
+
+        $arguments = array_values($joinPoint->getMethodArguments());
+        return $this->sessionOriginalInstances[$objectName]->$methodName(...$arguments);
     }
 }
diff --git a/Neos.Flow/Classes/Session/Aspect/LazyLoadingProxyInterface.php b/Neos.Flow/Classes/Session/Aspect/LazyLoadingProxyInterface.php
index 0001892b11..4990332bce 100644
--- a/Neos.Flow/Classes/Session/Aspect/LazyLoadingProxyInterface.php
+++ b/Neos.Flow/Classes/Session/Aspect/LazyLoadingProxyInterface.php
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace Neos\Flow\Session\Aspect;
 
 /*
diff --git a/Neos.Flow/Classes/Session/Aspect/LoggingAspect.php b/Neos.Flow/Classes/Session/Aspect/LoggingAspect.php
index ea60e463e0..5c70e11af0 100644
--- a/Neos.Flow/Classes/Session/Aspect/LoggingAspect.php
+++ b/Neos.Flow/Classes/Session/Aspect/LoggingAspect.php
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace Neos\Flow\Session\Aspect;
 
 /*
@@ -13,62 +14,38 @@
 
 use Neos\Flow\Annotations as Flow;
 use Neos\Flow\Aop\JoinPointInterface;
+use Neos\Flow\Session\Exception\SessionNotStartedException;
 use Neos\Flow\Session\SessionInterface;
 use Psr\Log\LoggerInterface;
 
 /**
  * An aspect which centralizes the logging of important session actions.
- *
- * @Flow\Aspect
- * @Flow\Scope("singleton")
  */
+#[Flow\Aspect]
+#[Flow\Scope("singleton")]
 class LoggingAspect
 {
-    /**
-     * @Flow\Inject(name="Neos.Flow:SecurityLogger")
-     * @var LoggerInterface
-     */
-    protected $logger;
-
-    /**
-     * Injects the (security) logger based on PSR-3.
-     *
-     * @param LoggerInterface $logger
-     * @return void
-     */
-    public function injectLogger(LoggerInterface $logger)
-    {
-        $this->logger = $logger;
-    }
+    #[Flow\Inject]
+    protected ?LoggerInterface $logger = null;
 
     /**
-     * Logs calls of start()
-     *
-     * @Flow\After("within(Neos\Flow\Session\SessionInterface) && method(.*->start())")
-     * @param JoinPointInterface $joinPoint The current joinpoint
-     * @return void
+     * @throws SessionNotStartedException
      */
-    public function logStart(JoinPointInterface $joinPoint)
+    #[Flow\After("within(Neos\Flow\Session\SessionInterface) && method(.*->start())")]
+    public function logStart(JoinPointInterface $joinPoint): void
     {
         /** @var SessionInterface $session */
         $session = $joinPoint->getProxy();
         if ($session->isStarted()) {
-            $this->logger->info(sprintf('%s: Started session with id %s.', $this->getClassName($joinPoint), $session->getId()));
+            $this->logger?->info(sprintf('%s: Started session with id %s.', $this->getSessionImplementationClassName($joinPoint), $session->getId()));
         }
     }
 
-    /**
-     * Logs calls of resume()
-     *
-     * @Flow\After("within(Neos\Flow\Session\SessionInterface) && method(.*->resume())")
-     * @param JoinPointInterface $joinPoint The current joinpoint
-     * @return void
-     */
-    public function logResume(JoinPointInterface $joinPoint)
+    #[Flow\After("within(Neos\Flow\Session\SessionInterface) && method(.*->resume())")]
+    public function logResume(JoinPointInterface $joinPoint): void
     {
-        /** @var SessionInterface $session */
         $session = $joinPoint->getProxy();
-        if ($session->isStarted()) {
+        if ($session instanceof SessionInterface && $session->isStarted()) {
             $inactivityInSeconds = $joinPoint->getResult();
             if ($inactivityInSeconds === 1) {
                 $inactivityMessage = '1 second';
@@ -81,76 +58,55 @@ public function logResume(JoinPointInterface $joinPoint)
             } else {
                 $inactivityMessage = sprintf('more than %s hours', (int)($inactivityInSeconds / 3600));
             }
-            $this->logger->debug(sprintf('%s: Resumed session with id %s which was inactive for %s. (%ss)', $this->getClassName($joinPoint), $session->getId(), $inactivityMessage, $inactivityInSeconds));
+            $this->logger?->debug(sprintf('%s: Resumed session with id %s which was inactive for %s. (%ss)', $this->getSessionImplementationClassName($joinPoint), $session->getId(), $inactivityMessage, $inactivityInSeconds));
         }
     }
 
     /**
-     * Logs calls of destroy()
-     *
-     * @Flow\Before("within(Neos\Flow\Session\SessionInterface) && method(.*->destroy())")
-     * @param JoinPointInterface $joinPoint The current joinpoint
-     * @return void
+     * @throws SessionNotStartedException
      */
-    public function logDestroy(JoinPointInterface $joinPoint)
+    #[Flow\Before("within(Neos\Flow\Session\SessionInterface) && method(.*->destroy())")]
+    public function logDestroy(JoinPointInterface $joinPoint): void
     {
-        /** @var SessionInterface $session */
         $session = $joinPoint->getProxy();
-        if ($session->isStarted()) {
+        if ($session instanceof SessionInterface && $session->isStarted()) {
             $reason = $joinPoint->isMethodArgument('reason') ? $joinPoint->getMethodArgument('reason') : 'no reason given';
-            $this->logger->debug(sprintf('%s: Destroyed session with id %s: %s', $this->getClassName($joinPoint), $session->getId(), $reason));
+            $this->logger?->debug(sprintf('%s: Destroyed session with id %s: %s', $this->getSessionImplementationClassName($joinPoint), $session->getId(), $reason));
         }
     }
 
     /**
-     * Logs calls of renewId()
-     *
-     * @Flow\Around("within(Neos\Flow\Session\SessionInterface) && method(.*->renewId())")
-     * @param JoinPointInterface $joinPoint The current joinpoint
-     * @return mixed The result of the target method if it has not been intercepted
+     * @throws SessionNotStartedException
      */
-    public function logRenewId(JoinPointInterface $joinPoint)
+    #[Flow\Around("within(Neos\Flow\Session\SessionInterface) && method(.*->renewId())")]
+    public function logRenewId(JoinPointInterface $joinPoint): mixed
     {
-        /** @var SessionInterface $session */
         $session = $joinPoint->getProxy();
-        $oldId = $session->getId();
         $newId = $joinPoint->getAdviceChain()->proceed($joinPoint);
-        if ($session->isStarted()) {
-            $this->logger->info(sprintf('%s: Changed session id from %s to %s', $this->getClassName($joinPoint), $oldId, $newId));
+        if (($session instanceof SessionInterface) && $session->isStarted()) {
+            $this->logger?->info(sprintf('%s: Changed session id from %s to %s', $this->getSessionImplementationClassName($joinPoint), $session->getId(), $newId));
         }
         return $newId;
     }
 
-    /**
-     * Logs calls of collectGarbage()
-     *
-     * @Flow\AfterReturning("within(Neos\Flow\Session\SessionInterface) && method(.*->collectGarbage())")
-     * @param JoinPointInterface $joinPoint The current joinpoint
-     * @return void
-     */
-    public function logCollectGarbage(JoinPointInterface $joinPoint)
+    #[Flow\AfterReturning("within(Neos\Flow\Session\SessionInterface) && method(.*->collectGarbage())")]
+    public function logCollectGarbage(JoinPointInterface $joinPoint): void
     {
         $sessionRemovalCount = $joinPoint->getResult();
         if ($sessionRemovalCount > 0) {
-            $this->logger->info(sprintf('%s: Triggered garbage collection and removed %s expired sessions.', $this->getClassName($joinPoint), $sessionRemovalCount));
+            $this->logger?->info(sprintf('%s: Triggered garbage collection and removed %s expired sessions.', $this->getSessionImplementationClassName($joinPoint), $sessionRemovalCount));
         } elseif ($sessionRemovalCount === 0) {
-            $this->logger->info(sprintf('%s: Triggered garbage collection but no sessions needed to be removed.', $this->getClassName($joinPoint)));
+            $this->logger?->info(sprintf('%s: Triggered garbage collection but no sessions needed to be removed.', $this->getSessionImplementationClassName($joinPoint)));
         } elseif ($sessionRemovalCount === false) {
-            $this->logger->warning(sprintf('%s: Ommitting garbage collection because another process is already running. Consider lowering the GC propability if these messages appear a lot.', $this->getClassName($joinPoint)));
+            $this->logger?->warning(sprintf('%s: Ommitting garbage collection because another process is already running. Consider lowering the GC probability if these messages appear a lot.', $this->getSessionImplementationClassName($joinPoint)));
         }
     }
 
-    /**
-     * Determines the short or full class name of the session implementation
-     *
-     * @param JoinPointInterface $joinPoint
-     * @return string
-     */
-    protected function getClassName(JoinPointInterface $joinPoint)
+    protected function getSessionImplementationClassName(JoinPointInterface $joinPoint): string
     {
         $className = $joinPoint->getClassName();
         $sessionNamespace = substr(SessionInterface::class, 0, -strrpos(SessionInterface::class, '\\') + 1);
-        if (strpos($className, $sessionNamespace) === 0) {
+        if (str_starts_with($className, $sessionNamespace)) {
             $className = substr($className, strlen($sessionNamespace));
         }
         return $className;
diff --git a/Neos.Flow/Classes/Session/Aspect/SessionObjectMethodsPointcutFilter.php b/Neos.Flow/Classes/Session/Aspect/SessionObjectMethodsPointcutFilter.php
index 132f7ea0c3..1f89a3be0b 100644
--- a/Neos.Flow/Classes/Session/Aspect/SessionObjectMethodsPointcutFilter.php
+++ b/Neos.Flow/Classes/Session/Aspect/SessionObjectMethodsPointcutFilter.php
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace Neos\Flow\Session\Aspect;
 
 /*
@@ -17,24 +18,17 @@
 use Neos\Flow\ObjectManagement\Configuration\Configuration as ObjectConfiguration;
 use Neos\Flow\Annotations as Flow;
 use Neos\Flow\Reflection\ClassReflection;
+use Neos\Flow\Reflection\Exception\ClassLoadingForReflectionFailedException;
 
 /**
  * Pointcut filter matching proxyable methods in objects of scope session
- *
- * @Flow\Scope("singleton")
  */
+#[Flow\Scope("singleton")]
 class SessionObjectMethodsPointcutFilter implements PointcutFilterInterface
 {
-    /**
-     * @var CompileTimeObjectManager
-     */
-    protected $objectManager;
+    protected CompileTimeObjectManager $objectManager;
 
-    /**
-     * @param CompileTimeObjectManager $objectManager
-     * @return void
-     */
-    public function injectObjectManager(CompileTimeObjectManager $objectManager)
+    public function injectObjectManager(CompileTimeObjectManager $objectManager): void
     {
         $this->objectManager = $objectManager;
     }
@@ -46,9 +40,10 @@ public function injectObjectManager(CompileTimeObjectManager $objectManager)
      * @param string $methodName Name of the method to check against
      * @param string $methodDeclaringClassName Name of the class the method was originally declared in
      * @param mixed $pointcutQueryIdentifier Some identifier for this query - must at least differ from a previous identifier. Used for circular reference detection.
-     * @return boolean true if the class / method match, otherwise false
+     * @return bool true if the class / method match, otherwise false
+     * @throws ClassLoadingForReflectionFailedException
      */
-    public function matches($className, $methodName, $methodDeclaringClassName, $pointcutQueryIdentifier)
+    public function matches($className, $methodName, $methodDeclaringClassName, $pointcutQueryIdentifier): bool
     {
         if ($methodName === null) {
             return false;
@@ -68,19 +63,15 @@ public function matches($className, $methodName, $methodDeclaringClassName, $poi
         }
 
         $classReflection = new ClassReflection($className);
-        if ($classReflection->hasMethod($methodName) && $classReflection->getMethod($methodName)->isPrivate()) {
-            return false;
-        }
-
-        return true;
+        return !($classReflection->hasMethod($methodName) && $classReflection->getMethod($methodName)->isPrivate());
     }
 
     /**
      * Returns true if this filter holds runtime evaluations for a previously matched pointcut
      *
-     * @return boolean true if this filter has runtime evaluations
+     * @return bool true if this filter has runtime evaluations
      */
-    public function hasRuntimeEvaluationsDefinition()
+    public function hasRuntimeEvaluationsDefinition(): bool
     {
         return false;
     }
@@ -90,18 +81,15 @@ public function hasRuntimeEvaluationsDefinition()
      *
      * @return array Runtime evaluations
      */
-    public function getRuntimeEvaluationsDefinition()
+    public function getRuntimeEvaluationsDefinition(): array
     {
         return [];
     }
 
     /**
      * This method is used to optimize the matching process.
-     *
-     * @param ClassNameIndex $classNameIndex
-     * @return ClassNameIndex
      */
-    public function reduceTargetClassNames(ClassNameIndex $classNameIndex)
+    public function reduceTargetClassNames(ClassNameIndex $classNameIndex): ClassNameIndex
     {
         $sessionClasses = new ClassNameIndex();
         $sessionClasses->setClassNames($this->objectManager->getClassNamesByScope(ObjectConfiguration::SCOPE_SESSION));
diff --git a/Neos.Flow/Classes/Session/CookieEnabledInterface.php b/Neos.Flow/Classes/Session/CookieEnabledInterface.php
index a86ae7a856..522f07079c 100644
--- a/Neos.Flow/Classes/Session/CookieEnabledInterface.php
+++ b/Neos.Flow/Classes/Session/CookieEnabledInterface.php
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace Neos\Flow\Session;
 
 /*
@@ -13,22 +14,9 @@
 
 use Neos\Flow\Http\Cookie;
 
-/**
- * Interface for Sessions that are related to a cookie.
- */
 interface CookieEnabledInterface extends SessionInterface
 {
-    /**
-     * @return Cookie
-     */
     public function getSessionCookie(): Cookie;
 
-    /**
-     * @param Cookie $sessionCookie
-     * @param string $storageIdentifier
-     * @param int $lastActivityTimestamp
-     * @param array $tags
-     * @return CookieEnabledInterface|SessionInterface
-     */
-    public static function createFromCookieAndSessionInformation(Cookie $sessionCookie, string $storageIdentifier, int $lastActivityTimestamp, array $tags = []);
+    public static function createFromCookieAndSessionInformation(Cookie $sessionCookie, string $storageIdentifier, int $lastActivityTimestamp, array $tags = []): SessionInterface|CookieEnabledInterface;
 }
diff --git a/Neos.Flow/Classes/Session/Data/SessionIdentifier.php b/Neos.Flow/Classes/Session/Data/SessionIdentifier.php
index 76c59e3ba5..11f97761f4 100644
--- a/Neos.Flow/Classes/Session/Data/SessionIdentifier.php
+++ b/Neos.Flow/Classes/Session/Data/SessionIdentifier.php
@@ -34,6 +34,9 @@ public static function createFromString(string $value): self
         return new self($value);
     }
 
+    /**
+     * @throws \Exception
+     */
     public static function createRandom(): self
     {
         return new self(Algorithms::generateRandomString(32));
diff --git a/Neos.Flow/Classes/Session/Data/SessionKeyValueStore.php b/Neos.Flow/Classes/Session/Data/SessionKeyValueStore.php
index a6434d0027..18793fcaf5 100644
--- a/Neos.Flow/Classes/Session/Data/SessionKeyValueStore.php
+++ b/Neos.Flow/Classes/Session/Data/SessionKeyValueStore.php
@@ -1,6 +1,5 @@
 <?php
 declare(strict_types=1);
-
 namespace Neos\Flow\Session\Data;
 
 /*
@@ -14,7 +13,9 @@
  */
 
 use Neos\Cache\Backend\IterableBackendInterface;
+use Neos\Cache\Exception;
 use Neos\Cache\Exception\InvalidBackendException;
+use Neos\Cache\Exception\InvalidDataException;
 use Neos\Cache\Frontend\StringFrontend;
 
 /**
@@ -23,7 +24,6 @@
 class SessionKeyValueStore
 {
     protected StringFrontend $cache;
-
     protected bool $useIgBinary = false;
 
     /**
@@ -36,6 +36,9 @@ public function injectCache(StringFrontend $cache): void
         $this->cache = $cache;
     }
 
+    /**
+     * @throws InvalidBackendException
+     */
     public function initializeObject(): void
     {
         if (!$this->cache->getBackend() instanceof IterableBackendInterface) {
@@ -54,10 +57,17 @@ public function retrieve(StorageIdentifier $storageIdentifier, string $key): mix
     {
         $entryIdentifier = $this->createEntryIdentifier($storageIdentifier, $key);
         $serializedResult = $this->cache->get($entryIdentifier);
+        if (!is_string($serializedResult)) {
+            return null;
+        }
         $this->writeDebounceHashes[$storageIdentifier->value][$key] = md5($serializedResult);
         return ($this->useIgBinary === true) ? igbinary_unserialize($serializedResult) : unserialize($serializedResult);
     }
 
+    /**
+     * @throws Exception
+     * @throws InvalidDataException
+     */
     public function store(StorageIdentifier $storageIdentifier, string $key, mixed $value): void
     {
         $entryIdentifier = $this->createEntryIdentifier($storageIdentifier, $key);
diff --git a/Neos.Flow/Classes/Session/Data/SessionMetaData.php b/Neos.Flow/Classes/Session/Data/SessionMetaData.php
index e6944503a8..50fee91a2c 100644
--- a/Neos.Flow/Classes/Session/Data/SessionMetaData.php
+++ b/Neos.Flow/Classes/Session/Data/SessionMetaData.php
@@ -1,5 +1,6 @@
 <?php
 declare(strict_types=1);
+namespace Neos\Flow\Session\Data;
 
 /*
  * This file is part of the Neos.Flow package.
@@ -11,8 +12,6 @@
  * source code.
  */
 
-namespace Neos\Flow\Session\Data;
-
 use Neos\Flow\Annotations as Flow;
 
 class SessionMetaData
@@ -32,6 +31,9 @@ public function __construct(
     ) {
     }
 
+    /**
+     * @throws \Exception
+     */
     public static function createWithTimestamp(int $timestamp): self
     {
         return new self(
@@ -82,7 +84,7 @@ public function withNewSessionIdentifier(): self
     public function withAddedTag(string $tag): self
     {
         $tags = $this->tags;
-        if (!in_array($tag, $this->tags)) {
+        if (!in_array($tag, $this->tags, true)) {
             $tags[] = $tag;
         }
         return new self(
diff --git a/Neos.Flow/Classes/Session/Data/SessionMetaDataStore.php b/Neos.Flow/Classes/Session/Data/SessionMetaDataStore.php
index 285631b6ed..a61eec9bff 100644
--- a/Neos.Flow/Classes/Session/Data/SessionMetaDataStore.php
+++ b/Neos.Flow/Classes/Session/Data/SessionMetaDataStore.php
@@ -14,9 +14,11 @@
  */
 
 use Neos\Cache\Backend\IterableBackendInterface;
+use Neos\Cache\Exception;
 use Neos\Cache\Exception\InvalidBackendException;
+use Neos\Cache\Exception\NotSupportedByBackendException;
 use Neos\Cache\Frontend\VariableFrontend;
-use Neos\FLow\Annotations as Flow;
+use Neos\Flow\Annotations\InjectConfiguration;
 use Neos\Flow\Session\Exception\InvalidDataInSessionDataStoreException;
 
 /**
@@ -24,17 +26,13 @@
  */
 class SessionMetaDataStore
 {
-    protected VariableFrontend $cache;
-
     protected const TAG_PREFIX = 'customtag-';
+    protected const GARBAGE_COLLECTION_CACHE_IDENTIFIER = '_garbage-collection-running';
 
-    protected const GARBAGE_COLLECTION_CACHEIDENTIFIER = '_garbage-collection-running';
+    #[InjectConfiguration(path: "session.updateMetadataThreshold")]
+    protected ?int $updateMetadataThreshold = null;
 
-    /**
-     * @var int|null
-     * @Flow\InjectConfiguration(path="session.updateMetadataThreshold")
-     */
-    protected $updateMetadataThreshold = null;
+    protected VariableFrontend $cache;
 
     /**
      * @var array<string, SessionMetaData>
@@ -46,7 +44,7 @@ public function injectCache(VariableFrontend $cache): void
         $this->cache = $cache;
     }
 
-    public function initializeObject()
+    public function initializeObject(): void
     {
         if (!$this->cache->getBackend() instanceof IterableBackendInterface) {
             throw new InvalidBackendException(sprintf('The session storage cache must provide a backend implementing the IterableBackendInterface, but the given backend "%s" does not implement it.', get_class($this->cache->getBackend())), 1370964558);
@@ -68,18 +66,22 @@ public function has(SessionIdentifier $sessionIdentifier): bool
         return $this->cache->has($sessionIdentifier->value);
     }
 
+    /**
+     * @throws InvalidDataInSessionDataStoreException
+     */
     public function retrieve(SessionIdentifier $sessionIdentifier): ?SessionMetaData
     {
-        /**
-         * @var false|array|SessionMetaData $metaDataFromCache
-         */
         $metaDataFromCache = $this->cache->get($sessionIdentifier->value);
         if ($metaDataFromCache === false) {
             return null;
-        } elseif ($metaDataFromCache instanceof SessionMetaData) {
+        }
+
+        if ($metaDataFromCache instanceof SessionMetaData) {
             $this->writeDebounceCache[$metaDataFromCache->sessionIdentifier->value] = $metaDataFromCache;
             return $metaDataFromCache;
-        } elseif (is_array($metaDataFromCache)) {
+        }
+
+        if (is_array($metaDataFromCache)) {
             $metaDataFromCache = SessionMetaData::createFromSessionIdentifierStringAndOldArrayCacheFormat($sessionIdentifier->value, $metaDataFromCache);
             $this->writeDebounceCache[$metaDataFromCache->sessionIdentifier->value] = $metaDataFromCache;
             return $metaDataFromCache;
@@ -90,11 +92,12 @@ public function retrieve(SessionIdentifier $sessionIdentifier): ?SessionMetaData
     /**
      * @param string $tag
      * @return \Generator<string, SessionMetaData> Session metadata indexed by sessionIdentifier
+     * @throws NotSupportedByBackendException
      */
     public function retrieveByTag(string $tag): \Generator
     {
         foreach ($this->cache->getByTag(self::TAG_PREFIX . $tag) as $sessionIdentifier => $sessionMetaData) {
-            if ($sessionIdentifier === self::GARBAGE_COLLECTION_CACHEIDENTIFIER) {
+            if ($sessionIdentifier === self::GARBAGE_COLLECTION_CACHE_IDENTIFIER) {
                 continue;
             }
             if ($sessionMetaData instanceof SessionMetaData) {
@@ -110,11 +113,12 @@ public function retrieveByTag(string $tag): \Generator
 
     /**
      * @return \Generator<string, SessionMetaData> Session metadata indexed by sessionIdentifier
+     * @throws NotSupportedByBackendException
      */
     public function retrieveAll(): \Generator
     {
         foreach ($this->cache->getIterator() as $sessionIdentifier => $sessionMetaData) {
-            if ($sessionIdentifier === self::GARBAGE_COLLECTION_CACHEIDENTIFIER) {
+            if ($sessionIdentifier === self::GARBAGE_COLLECTION_CACHE_IDENTIFIER) {
                 continue;
             }
             if ($sessionMetaData instanceof SessionMetaData) {
@@ -128,6 +132,9 @@ public function retrieveAll(): \Generator
         }
     }
 
+    /**
+     * @throws Exception
+     */
     public function store(SessionMetaData $sessionMetaData): void
     {
         $tagsForCacheEntry = array_map(function ($tag) {
@@ -147,24 +154,27 @@ public function store(SessionMetaData $sessionMetaData): void
         $this->cache->set($sessionMetaData->sessionIdentifier->value, $sessionMetaData, $tagsForCacheEntry, 0);
     }
 
-    public function remove(SessionMetaData $sessionMetaData): mixed
+    public function remove(SessionMetaData $sessionMetaData): bool
     {
         unset($this->writeDebounceCache[$sessionMetaData->sessionIdentifier->value]);
         return $this->cache->remove($sessionMetaData->sessionIdentifier->value);
     }
 
+    /**
+     * @throws Exception
+     */
     public function startGarbageCollection(): void
     {
-        $this->cache->set(self::GARBAGE_COLLECTION_CACHEIDENTIFIER, true, [], 120);
+        $this->cache->set(self::GARBAGE_COLLECTION_CACHE_IDENTIFIER, true, [], 120);
     }
 
     public function isGarbageCollectionRunning(): bool
     {
-        return $this->cache->has(self::GARBAGE_COLLECTION_CACHEIDENTIFIER);
+        return $this->cache->has(self::GARBAGE_COLLECTION_CACHE_IDENTIFIER);
     }
 
     public function endGarbageCollection(): void
     {
-        $this->cache->remove(self::GARBAGE_COLLECTION_CACHEIDENTIFIER);
+        $this->cache->remove(self::GARBAGE_COLLECTION_CACHE_IDENTIFIER);
     }
 }
diff --git a/Neos.Flow/Classes/Session/Data/StorageIdentifier.php b/Neos.Flow/Classes/Session/Data/StorageIdentifier.php
index def64a1743..042b495728 100644
--- a/Neos.Flow/Classes/Session/Data/StorageIdentifier.php
+++ b/Neos.Flow/Classes/Session/Data/StorageIdentifier.php
@@ -35,6 +35,9 @@ public static function createFromString(string $value): self
         return new self($value);
     }
 
+    /**
+     * @throws \Exception
+     */
     public static function createRandom(): self
     {
         return new self(Algorithms::generateUUID());
diff --git a/Neos.Flow/Classes/Session/Exception.php b/Neos.Flow/Classes/Session/Exception.php
index f85449f576..b93c97cd7c 100644
--- a/Neos.Flow/Classes/Session/Exception.php
+++ b/Neos.Flow/Classes/Session/Exception.php
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace Neos\Flow\Session;
 
 /*
diff --git a/Neos.Flow/Classes/Session/Exception/DataNotSerializableException.php b/Neos.Flow/Classes/Session/Exception/DataNotSerializableException.php
index 46b4069674..9238ef1c6f 100644
--- a/Neos.Flow/Classes/Session/Exception/DataNotSerializableException.php
+++ b/Neos.Flow/Classes/Session/Exception/DataNotSerializableException.php
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace Neos\Flow\Session\Exception;
 
 /*
diff --git a/Neos.Flow/Classes/Session/Exception/InvalidDataInSessionDataStoreException.php b/Neos.Flow/Classes/Session/Exception/InvalidDataInSessionDataStoreException.php
index bc5ee148a4..81fd9e6c91 100644
--- a/Neos.Flow/Classes/Session/Exception/InvalidDataInSessionDataStoreException.php
+++ b/Neos.Flow/Classes/Session/Exception/InvalidDataInSessionDataStoreException.php
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace Neos\Flow\Session\Exception;
 
 /*
diff --git a/Neos.Flow/Classes/Session/Exception/InvalidRequestHandlerException.php b/Neos.Flow/Classes/Session/Exception/InvalidRequestHandlerException.php
index 02afdb27ca..ece830858b 100644
--- a/Neos.Flow/Classes/Session/Exception/InvalidRequestHandlerException.php
+++ b/Neos.Flow/Classes/Session/Exception/InvalidRequestHandlerException.php
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace Neos\Flow\Session\Exception;
 
 /*
diff --git a/Neos.Flow/Classes/Session/Exception/InvalidRequestResponseException.php b/Neos.Flow/Classes/Session/Exception/InvalidRequestResponseException.php
index de4a2bc690..750c60eae8 100644
--- a/Neos.Flow/Classes/Session/Exception/InvalidRequestResponseException.php
+++ b/Neos.Flow/Classes/Session/Exception/InvalidRequestResponseException.php
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace Neos\Flow\Session\Exception;
 
 /*
diff --git a/Neos.Flow/Classes/Session/Exception/OperationNotSupportedException.php b/Neos.Flow/Classes/Session/Exception/OperationNotSupportedException.php
index 28499910ab..c9b929079a 100644
--- a/Neos.Flow/Classes/Session/Exception/OperationNotSupportedException.php
+++ b/Neos.Flow/Classes/Session/Exception/OperationNotSupportedException.php
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace Neos\Flow\Session\Exception;
 
 /*
diff --git a/Neos.Flow/Classes/Session/Exception/SessionAutostartIsEnabledException.php b/Neos.Flow/Classes/Session/Exception/SessionAutostartIsEnabledException.php
index 806a186ef4..bc8b29ecb2 100644
--- a/Neos.Flow/Classes/Session/Exception/SessionAutostartIsEnabledException.php
+++ b/Neos.Flow/Classes/Session/Exception/SessionAutostartIsEnabledException.php
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace Neos\Flow\Session\Exception;
 
 /*
diff --git a/Neos.Flow/Classes/Session/Exception/SessionNotStartedException.php b/Neos.Flow/Classes/Session/Exception/SessionNotStartedException.php
index 6b4ea69a50..c3f9bb152c 100644
--- a/Neos.Flow/Classes/Session/Exception/SessionNotStartedException.php
+++ b/Neos.Flow/Classes/Session/Exception/SessionNotStartedException.php
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace Neos\Flow\Session\Exception;
 
 /*
diff --git a/Neos.Flow/Classes/Session/Session.php b/Neos.Flow/Classes/Session/Session.php
index 4268fcb078..8d4ab055ad 100644
--- a/Neos.Flow/Classes/Session/Session.php
+++ b/Neos.Flow/Classes/Session/Session.php
@@ -11,25 +11,27 @@
  * source code.
  */
 
+use Neos\Cache\Exception as CacheException;
+use Neos\Cache\Exception\InvalidDataException;
 use Neos\Cache\Exception\NotSupportedByBackendException;
+use Neos\Cache\Frontend\FrontendInterface;
+use Neos\Flow\Annotations as Flow;
+use Neos\Flow\Http\Cookie;
 use Neos\Flow\Log\Utility\LogEnvironment;
 use Neos\Flow\ObjectManagement\Configuration\Configuration as ObjectConfiguration;
 use Neos\Flow\ObjectManagement\ObjectManagerInterface;
 use Neos\Flow\ObjectManagement\Proxy\ProxyInterface;
-use Neos\Flow\Annotations as Flow;
 use Neos\Flow\Session\Data\SessionIdentifier;
 use Neos\Flow\Session\Data\SessionKeyValueStore;
 use Neos\Flow\Session\Data\SessionMetaData;
 use Neos\Flow\Session\Data\SessionMetaDataStore;
-use Neos\Flow\Http\Cookie;
-use Neos\Cache\Frontend\FrontendInterface;
 use Neos\Flow\Session\Data\StorageIdentifier;
 use Psr\Log\LoggerInterface;
 
 /**
  * A modular session implementation based on the caching framework.
  *
- * You may access the currently active session in userland code. In order to do this,
+ * You may access the currently active session in user land code. In order to do this,
  * inject SessionInterface and NOT just the Session object.
  * The former will be a unique instance (singleton) representing the current session
  * while the latter would be a completely new session instance!
@@ -48,109 +50,34 @@ class Session implements CookieEnabledInterface
 {
     private const FLOW_OBJECT_STORAGE_KEY = 'Neos_Flow_Object_ObjectManager';
 
-    /**
-     * @Flow\Inject
-     * @var ObjectManagerInterface
-     */
-    protected $objectManager;
+    #[Flow\Inject(lazy: false)]
+    protected ObjectManagerInterface $objectManager;
 
-    /**
-     * @Flow\Inject(name="Neos.Flow:SystemLogger")
-     * @var LoggerInterface
-     */
-    protected $logger;
+    #[Flow\Inject]
+    protected ?LoggerInterface $logger = null;
 
-    /**
-     * Meta data cache for this session
-     *
-     * @Flow\Inject
-     * @var SessionMetaDataStore
-     */
-    protected $sessionMetaDataStore;
+    #[Flow\Inject(lazy: false)]
+    protected SessionMetaDataStore $sessionMetaDataStore;
 
-    /**
-     * Storage cache for this session
-     *
-     * @Flow\Inject
-     * @var SessionKeyValueStore
-     */
-    protected $sessionKeyValueStore;
+    #[Flow\Inject(lazy: false)]
+    protected SessionKeyValueStore $sessionKeyValueStore;
 
-    /**
-     * @var string
-     */
-    protected $sessionCookieName;
+    protected string $sessionCookieName;
+    protected int $sessionCookieLifetime = 0;
+    protected ?string $sessionCookieDomain = null;
+    protected ?string $sessionCookiePath = null;
+    protected bool $sessionCookieSecure = true;
+    protected bool $sessionCookieHttpOnly = true;
+    protected ?string $sessionCookieSameSite = null;
+    protected ?Cookie $sessionCookie = null;
+    protected int $inactivityTimeout;
+    protected array $tags = [];
+    protected int $now = 0;
+    protected ?SessionMetaData $sessionMetaData = null;
+    protected bool $started = false;
+    protected bool $remote = false;
 
     /**
-     * @var integer
-     */
-    protected $sessionCookieLifetime = 0;
-
-    /**
-     * @var string
-     */
-    protected $sessionCookieDomain;
-
-    /**
-     * @var string
-     */
-    protected $sessionCookiePath;
-
-    /**
-     * @var boolean
-     */
-    protected $sessionCookieSecure = true;
-
-    /**
-     * @var boolean
-     */
-    protected $sessionCookieHttpOnly = true;
-
-    /**
-     * @var string
-     */
-    protected $sessionCookieSameSite;
-
-    /**
-     * @var Cookie
-     */
-    protected $sessionCookie;
-
-    /**
-     * @var integer
-     */
-    protected $inactivityTimeout;
-
-
-    /**
-     * @var array
-     */
-    protected $tags = [];
-
-    /**
-     * @var integer
-     */
-    protected $now;
-
-    protected SessionMetaData|null $sessionMetaData = null;
-
-    /**
-     * If this session has been started
-     *
-     * @var boolean
-     */
-    protected $started = false;
-
-    /**
-     * If this session is remote or the "current" session
-     *
-     * @var boolean
-     */
-    protected $remote = false;
-
-    /**
-     * Constructs this session
-     *
      * Session instances MUST NOT be created manually! They should be retrieved via
      * the Session Manager or through dependency injection (use SessionInterface!).
      */
@@ -178,10 +105,6 @@ public static function createRemote(string $sessionIdentifier, string $storageId
         return $session;
     }
 
-    /**
-     * @param SessionMetaData $sessionMetaData
-     * @return Session
-     */
     public static function createRemoteFromSessionMetaData(SessionMetaData $sessionMetaData): self
     {
         $session = new static();
@@ -191,14 +114,7 @@ public static function createRemoteFromSessionMetaData(SessionMetaData $sessionM
         return $session;
     }
 
-    /**
-     * @param Cookie $sessionCookie
-     * @param string $storageIdentifier
-     * @param int $lastActivityTimestamp
-     * @param array $tags
-     * @return Session
-     */
-    public static function createFromCookieAndSessionInformation(Cookie $sessionCookie, string $storageIdentifier, int $lastActivityTimestamp, array $tags = [])
+    public static function createFromCookieAndSessionInformation(Cookie $sessionCookie, string $storageIdentifier, int $lastActivityTimestamp, array $tags = []): SessionInterface|CookieEnabledInterface
     {
         $session = new static();
         $session->sessionMetaData = new SessionMetaData(
@@ -211,13 +127,7 @@ public static function createFromCookieAndSessionInformation(Cookie $sessionCook
         return $session;
     }
 
-    /**
-     * Injects the Flow settings
-     *
-     * @param array $settings Settings of the Flow package
-     * @return void
-     */
-    public function injectSettings(array $settings)
+    public function injectSettings(array $settings): void
     {
         $this->sessionCookieName = $settings['session']['name'];
         $this->sessionCookieLifetime = (integer)$settings['session']['cookie']['lifetime'];
@@ -229,32 +139,12 @@ public function injectSettings(array $settings)
         $this->inactivityTimeout = (integer)$settings['session']['inactivityTimeout'];
     }
 
-    /**
-     * Injects the (system) logger based on PSR-3.
-     *
-     * @param LoggerInterface $logger
-     * @return void
-     */
-    public function injectLogger(LoggerInterface $logger)
-    {
-        $this->logger = $logger;
-    }
-
-    /**
-     * @return Cookie
-     */
     public function getSessionCookie(): Cookie
     {
         return $this->sessionCookie;
     }
 
-    /**
-     * Tells if the session has been started already.
-     *
-     * @return boolean
-     * @api
-     */
-    public function isStarted()
+    public function isStarted(): bool
     {
         return $this->started;
     }
@@ -263,10 +153,9 @@ public function isStarted()
      * Tells if the session is local (the current session bound to the current HTTP
      * request) or remote (retrieved through the Session Manager).
      *
-     * @return boolean true if the session is remote, false if this is the current session
      * @api
      */
-    public function isRemote()
+    public function isRemote(): bool
     {
         return $this->remote;
     }
@@ -279,7 +168,7 @@ public function isRemote()
      * @see CookieEnabledInterface
      * @api
      */
-    public function start()
+    public function start(): void
     {
         if ($this->started === false) {
             $this->sessionMetaData = SessionMetaData::createWithTimestamp($this->now);
@@ -297,20 +186,20 @@ public function start()
      * trigger the expiration of that session. An expired session cannot be resumed.
      *
      * NOTE that this method does a bit more than the name implies: Because the
-     * session info data needs to be loaded, this method stores this data already
+     * session info data needs to be loaded, this method stores this data already,
      * so it doesn't have to be loaded again once the session is being used.
      *
-     * @return boolean
+     * @return bool
      * @api
      */
-    public function canBeResumed()
+    public function canBeResumed(): bool
     {
         if ($this->sessionCookie === null || $this->started === true) {
             return false;
         }
         $sessionIdentifier = $this->sessionCookie->getValue();
         if ($this->sessionMetaDataStore->isValidSessionIdentifier($sessionIdentifier) === false) {
-            $this->logger->warning('SESSION IDENTIFIER INVALID: ' . $sessionIdentifier, LogEnvironment::fromMethodName(__METHOD__));
+            $this->logger?->warning('SESSION IDENTIFIER INVALID: ' . $sessionIdentifier, LogEnvironment::fromMethodName(__METHOD__));
             return false;
         }
         $sessionMetaData = $this->sessionMetaDataStore->retrieve(SessionIdentifier::createFromString($sessionIdentifier));
@@ -324,10 +213,12 @@ public function canBeResumed()
     /**
      * Resumes an existing session, if any.
      *
-     * @return null|integer If a session was resumed, the inactivity of this session since the last request is returned
+     * @return null|int If a session was resumed, the inactivity of this session since the last request is returned
+     * @throws InvalidDataException
+     * @throws CacheException
      * @api
      */
-    public function resume()
+    public function resume(): ?int
     {
         if ($this->started === false && $this->canBeResumed()) {
             $this->started = true;
@@ -363,7 +254,7 @@ public function resume()
      * @throws Exception\SessionNotStartedException
      * @api
      */
-    public function getId()
+    public function getId(): string
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('Tried to retrieve the session identifier, but the session has not been started yet.)', 1351171517);
@@ -380,7 +271,7 @@ public function getId()
      * @throws Exception\OperationNotSupportedException
      * @api
      */
-    public function renewId()
+    public function renewId(): string
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('Tried to renew the session identifier, but the session has not been started yet.', 1351182429);
@@ -404,7 +295,7 @@ public function renewId()
      * @return mixed The contents associated with the given key
      * @throws Exception\SessionNotStartedException
      */
-    public function getData($key)
+    public function getData(string $key): mixed
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('Tried to get session data, but the session has not been started yet.', 1351162255);
@@ -416,10 +307,10 @@ public function getData($key)
      * Returns true if a session data entry $key is available.
      *
      * @param string $key Entry identifier of the session data
-     * @return boolean
+     * @return bool
      * @throws Exception\SessionNotStartedException
      */
-    public function hasKey($key)
+    public function hasKey(string $key): bool
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('Tried to check a session data entry, but the session has not been started yet.', 1352488661);
@@ -435,9 +326,11 @@ public function hasKey($key)
      * @return void
      * @throws Exception\DataNotSerializableException
      * @throws Exception\SessionNotStartedException
+     * @throws CacheException
+     * @throws InvalidDataException
      * @api
      */
-    public function putData($key, $data)
+    public function putData(string $key, mixed $data): void
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('Tried to create a session data entry, but the session has not been started yet.', 1351162259);
@@ -455,11 +348,11 @@ public function putData($key, $data)
      * For the current (local) session, this method will always return the current
      * time. For a remote session, the unix timestamp will be returned.
      *
-     * @return integer unix timestamp
+     * @return int unix timestamp
      * @throws Exception\SessionNotStartedException
      * @api
      */
-    public function getLastActivityTimestamp()
+    public function getLastActivityTimestamp(): int
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('Tried to retrieve the last activity timestamp of a session which has not been started yet.', 1354290378);
@@ -479,7 +372,7 @@ public function getLastActivityTimestamp()
      * @throws \InvalidArgumentException
      * @api
      */
-    public function addTag($tag)
+    public function addTag(string $tag): void
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('Tried to tag a session which has not been started yet.', 1355143533);
@@ -498,7 +391,7 @@ public function addTag($tag)
      * @throws Exception\SessionNotStartedException
      * @api
      */
-    public function removeTag($tag)
+    public function removeTag(string $tag): void
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('Tried to tag a session which has not been started yet.', 1355150140);
@@ -514,7 +407,7 @@ public function removeTag($tag)
      * @throws Exception\SessionNotStartedException
      * @api
      */
-    public function getTags()
+    public function getTags(): array
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('Tried to retrieve tags from a session which has not been started yet.', 1355141501);
@@ -525,10 +418,9 @@ public function getTags()
     /**
      * Updates the last activity time to "now".
      *
-     * @return void
      * @throws Exception\SessionNotStartedException
      */
-    public function touch()
+    public function touch(): void
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('Tried to touch a session, but the session has not been started yet.', 1354284318);
@@ -544,11 +436,12 @@ public function touch()
 
     /**
      * Explicitly writes and closes the session
-     *
-     * @return void
+     * @throws NotSupportedByBackendException
+     * @throws CacheException
      * @api
+     *
      */
-    public function close()
+    public function close(): void
     {
         $this->shutdownObject();
     }
@@ -556,12 +449,12 @@ public function close()
     /**
      * Explicitly destroys all session data
      *
-     * @param string $reason A reason for destroying the session – used by the LoggingAspect
+     * @param string|null $reason A reason for destroying the session – used by the LoggingAspect
      * @return void
      * @throws Exception\SessionNotStartedException
      * @api
      */
-    public function destroy($reason = null)
+    public function destroy(?string $reason = null): void
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('Tried to destroy a session which has not been started yet.', 1351162668);
@@ -583,13 +476,10 @@ public function destroy($reason = null)
      * This method must not be called manually – it is invoked by Flow's object
      * management.
      *
-     * @return void
-     * @throws Exception\DataNotSerializableException
-     * @throws Exception\SessionNotStartedException
      * @throws NotSupportedByBackendException
-     * @throws \Neos\Cache\Exception
+     * @throws CacheException
      */
-    public function shutdownObject()
+    public function shutdownObject(): void
     {
         if ($this->started === true && $this->remote === false) {
             if ($this->sessionMetaDataStore->has($this->sessionMetaData->sessionIdentifier)) {
@@ -603,9 +493,9 @@ public function shutdownObject()
     /**
      * Automatically expires the session if the user has been inactive for too long.
      *
-     * @return boolean true if the session expired, false if not
+     * @return bool true if the session expired, false if not
      */
-    protected function autoExpire()
+    protected function autoExpire(): bool
     {
         $lastActivitySecondsAgo = $this->now - $this->sessionMetaData->lastActivityTimestamp;
         $expired = false;
@@ -627,9 +517,9 @@ protected function autoExpire()
      * The session cache entry is also tagged with "session", the session identifier
      * and any custom tags of this session, prefixed with TAG_PREFIX.
      *
-     * @return void
+     * @throws CacheException
      */
-    protected function writeSessionMetaDataCacheEntry()
+    protected function writeSessionMetaDataCacheEntry(): void
     {
         $this->sessionMetaDataStore->store($this->sessionMetaData);
     }
diff --git a/Neos.Flow/Classes/Session/SessionInterface.php b/Neos.Flow/Classes/Session/SessionInterface.php
index e1cfafd104..791f21debf 100644
--- a/Neos.Flow/Classes/Session/SessionInterface.php
+++ b/Neos.Flow/Classes/Session/SessionInterface.php
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace Neos\Flow\Session;
 
 /*
@@ -11,46 +12,36 @@
  * source code.
  */
 
-/**
- * Contract for a session.
- */
 interface SessionInterface
 {
     /**
      * Tells if the session has been started already.
-     *
-     * @return boolean
      */
-    public function isStarted();
+    public function isStarted(): bool;
 
     /**
-     * Starts the session, if is has not been already started
-     *
-     * @return void
+     * Starts the session, if it has not been already started
      */
-    public function start();
+    public function start(): void;
 
     /**
      * Returns true if there is a session that can be resumed. false otherwise
-     *
-     * @return boolean
      */
-    public function canBeResumed();
+    public function canBeResumed(): bool;
 
     /**
      * Resumes an existing session, if any.
      *
-     * @return void
+     * @return null|int If a session was resumed, the inactivity of this session since the last request is returned
      */
-    public function resume();
+    public function resume(): ?int;
 
     /**
      * Returns the current session ID.
      *
-     * @return string The current session ID
      * @throws Exception\SessionNotStartedException
      */
-    public function getId();
+    public function getId(): string;
 
     /**
      * Generates and propagates a new session ID and transfers all existing data
@@ -60,7 +51,7 @@ public function getId();
      *
      * @return string The new session ID
      */
-    public function renewId();
+    public function renewId(): string;
 
     /**
      * Returns the content (mixed) associated with the given key.
@@ -69,15 +60,15 @@ public function renewId();
      * @return mixed The contents associated with the given key
      * @throws Exception\SessionNotStartedException
      */
-    public function getData($key);
+    public function getData(string $key): mixed;
 
     /**
      * Returns true if $key is available.
      *
      * @param string $key
-     * @return boolean
+     * @return bool
      */
-    public function hasKey($key);
+    public function hasKey(string $key): bool;
 
     /**
      * Stores the given data under the given key in the session
@@ -87,7 +78,7 @@ public function hasKey($key);
      * @return void
      * @throws Exception\SessionNotStartedException
      */
-    public function putData($key, $data);
+    public function putData(string $key, mixed $data): void;
 
     /**
      * Tags this session with the given tag.
@@ -101,7 +92,7 @@ public function putData($key, $data);
      * @throws \InvalidArgumentException
      * @api
      */
-    public function addTag($tag);
+    public function addTag(string $tag): void;
 
     /**
      * Removes the specified tag from this session.
@@ -111,7 +102,7 @@ public function addTag($tag);
      * @throws Exception\SessionNotStartedException
      * @api
      */
-    public function removeTag($tag);
+    public function removeTag(string $tag): void;
 
     /**
      * Returns the tags this session has been tagged with.
@@ -120,15 +111,14 @@ public function removeTag($tag);
      * @throws Exception\SessionNotStartedException
      * @api
      */
-    public function getTags();
+    public function getTags(): array;
 
     /**
      * Updates the last activity time to "now".
      *
-     * @return void
      * @api
      */
-    public function touch();
+    public function touch(): void;
 
     /**
      * Returns the unix time stamp marking the last point in time this session has
@@ -137,25 +127,24 @@ public function touch();
      * For the current (local) session, this method will always return the current
      * time. For a remote session, the unix timestamp will be returned.
      *
-     * @return integer unix timestamp
+     * @return int unix timestamp
      * @api
      */
-    public function getLastActivityTimestamp();
+    public function getLastActivityTimestamp(): int;
 
     /**
      * Explicitly writes (persists) and closes the session
      *
-     * @return void
      * @throws Exception\SessionNotStartedException
      */
-    public function close();
+    public function close(): void;
 
     /**
      * Explicitly destroys all session data
      *
-     * @param string $reason A reason for destroying the session – used by the LoggingAspect
+     * @param string|null $reason A reason for destroying the session – used by the LoggingAspect
      * @return void
      * @throws Exception\SessionNotStartedException
      */
-    public function destroy($reason = null);
+    public function destroy(?string $reason = null): void;
 }
diff --git a/Neos.Flow/Classes/Session/SessionManager.php b/Neos.Flow/Classes/Session/SessionManager.php
index f9d69b4d19..cdf8d89a90 100644
--- a/Neos.Flow/Classes/Session/SessionManager.php
+++ b/Neos.Flow/Classes/Session/SessionManager.php
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace Neos\Flow\Session;
 
 /*
@@ -11,80 +12,42 @@
  * source code.
  */
 
+use Neos\Cache\Exception as CacheException;
 use Neos\Cache\Exception\NotSupportedByBackendException;
 use Neos\Flow\Annotations as Flow;
 use Neos\Flow\Http\Cookie;
 use Neos\Flow\Session\Data\SessionIdentifier;
 use Neos\Flow\Session\Data\SessionKeyValueStore;
 use Neos\Flow\Session\Data\SessionMetaDataStore;
+use Neos\Flow\Session\Exception\InvalidDataInSessionDataStoreException;
+use Neos\Flow\Session\Exception\SessionNotStartedException;
 use Neos\Flow\Utility\Algorithms;
-use Psr\Log\LoggerInterface;
 
-/**
- * Session Manager
- *
- * @Flow\Scope("singleton")
- */
+#[Flow\Scope("singleton")]
 class SessionManager implements SessionManagerInterface
 {
-    /**
-     * @var SessionInterface
-     */
-    protected $currentSession;
-
-    /**
-     * @var array
-     */
-    protected $remoteSessions;
-
-    /**
-     * Meta data storage for sessions
-     *
-     * @Flow\Inject
-     * @var SessionMetaDataStore
-     */
-    protected $sessionMetaDataStore;
-
-    /**
-     * Storage for sessions data
-     *
-     * @Flow\Inject
-     * @var SessionKeyValueStore
-     */
-    protected $sessionKeyValueStore;
-
-    /**
-     * @var float
-     * @Flow\InjectConfiguration(path="session.garbageCollection.probability")
-     */
-    protected $garbageCollectionProbability;
-
-    /**
-     * @Flow\InjectConfiguration(path="session.garbageCollection.maximumPerRun")
-     * @var integer
-     */
-    protected $garbageCollectionMaximumPerRun;
-
-    /**
-     * @Flow\InjectConfiguration(path="session.inactivityTimeout")
-     * @var integer
-     */
-    protected $inactivityTimeout;
-
-    /**
-     * @Flow\Inject(name="Neos.Flow:SystemLogger")
-     * @var LoggerInterface
-     */
-    protected $logger;
+    protected ?SessionInterface $currentSession = null;
+    protected array $remoteSessions = [];
+
+    public function __construct(
+        readonly protected SessionMetaDataStore $sessionMetaDataStore,
+        readonly protected SessionKeyValueStore $sessionKeyValueStore,
+        #[Flow\InjectConfiguration(path: "session.garbageCollection.probability")]
+        readonly protected float $garbageCollectionProbability,
+        #[Flow\InjectConfiguration(path: "session.garbageCollection.maximumPerRun")]
+        readonly protected int $garbageCollectionMaximumPerRun,
+        #[Flow\InjectConfiguration(path: "session.inactivityTimeout")]
+        readonly protected int $inactivityTimeout,
+    ) {
+    }
 
     /**
      * Returns the currently active session which stores session data for the
      * current HTTP request on this local system.
      *
-     * @return SessionInterface
      * @api
      */
-    public function getCurrentSession()
+    public function getCurrentSession(): SessionInterface
     {
         if ($this->currentSession === null) {
             $this->currentSession = Session::create();
@@ -93,10 +56,9 @@ public function getCurrentSession()
     }
 
     /**
-     * @param Cookie $cookie
-     * @return bool
+     * @throws InvalidDataInSessionDataStoreException
      */
-    public function initializeCurrentSessionFromCookie(Cookie $cookie)
+    public function initializeCurrentSessionFromCookie(Cookie $cookie): bool
     {
         if ($this->currentSession !== null && $this->currentSession->isStarted()) {
             return false;
@@ -115,10 +77,9 @@ public function initializeCurrentSessionFromCookie(Cookie $cookie)
     }
 
     /**
-     * @param Cookie $cookie
-     * @return bool
+     * @throws \Exception
      */
-    public function createCurrentSessionFromCookie(Cookie $cookie)
+    public function createCurrentSessionFromCookie(Cookie $cookie): bool
     {
         if ($this->currentSession !== null && $this->currentSession->isStarted()) {
             return false;
@@ -133,11 +94,11 @@ public function createCurrentSessionFromCookie(Cookie $cookie)
      * Returns the specified session. If no session with the given identifier exists,
      * NULL is returned.
      *
-     * @param string $sessionIdentifier The session identifier
-     * @return SessionInterface|null
+     * @throws InvalidDataInSessionDataStoreException
+     * @throws SessionNotStartedException
      * @api
      */
-    public function getSession($sessionIdentifier)
+    public function getSession(string $sessionIdentifier): ?SessionInterface
     {
         if ($this->currentSession !== null && $this->currentSession->isStarted() && $this->currentSession->getId() === $sessionIdentifier) {
             return $this->currentSession;
@@ -146,24 +107,28 @@ public function getSession($sessionIdentifier)
             return $this->remoteSessions[$sessionIdentifier];
         }
         $sessionIdentifierObject = SessionIdentifier::createFromString($sessionIdentifier);
-        if ($this->sessionMetaDataStore->has($sessionIdentifierObject)) {
-            $sessionMetaData = $this->sessionMetaDataStore->retrieve($sessionIdentifierObject);
-            $this->remoteSessions[$sessionIdentifierObject->value] = Session::createRemoteFromSessionMetaData($sessionMetaData);
-            return $this->remoteSessions[$sessionIdentifierObject->value];
+        if (!$this->sessionMetaDataStore->has($sessionIdentifierObject)) {
+            return null;
+        }
+        $sessionMetaData = $this->sessionMetaDataStore->retrieve($sessionIdentifierObject);
+        if ($sessionMetaData === null) {
+            return null;
         }
-        return null;
+        $this->remoteSessions[$sessionIdentifierObject->value] = Session::createRemoteFromSessionMetaData($sessionMetaData);
+        return $this->remoteSessions[$sessionIdentifierObject->value];
     }
 
     /**
      * Returns all active sessions, even remote ones.
      *
      * @return array<SessionInterface>
+     * @throws NotSupportedByBackendException
      * @api
      */
-    public function getActiveSessions()
+    public function getActiveSessions(): array
     {
         $activeSessions = [];
-        foreach ($this->sessionMetaDataStore->retrieveAll() as $sessionIdentifier => $sessionMetaData) {
+        foreach ($this->sessionMetaDataStore->retrieveAll() as $sessionMetaData) {
             $session = Session::createRemoteFromSessionMetaData($sessionMetaData);
             $activeSessions[] = $session;
         }
@@ -175,12 +140,13 @@ public function getActiveSessions()
      *
      * @param string $tag A valid Cache Frontend tag
      * @return array A collection of Session objects or an empty array if tag did not match
+     * @throws NotSupportedByBackendException
      * @api
      */
-    public function getSessionsByTag($tag)
+    public function getSessionsByTag(string $tag): array
     {
         $taggedSessions = [];
-        foreach ($this->sessionMetaDataStore->retrieveByTag($tag) as $sessionIdentifier => $sessionMetaData) {
+        foreach ($this->sessionMetaDataStore->retrieveByTag($tag) as $sessionMetaData) {
             $session = Session::createRemoteFromSessionMetaData($sessionMetaData);
             $taggedSessions[] = $session;
         }
@@ -192,13 +158,14 @@ public function getSessionsByTag($tag)
      *
      * @param string $tag A valid Cache Frontend tag
      * @param string $reason A reason to mention in log output for why the sessions have been destroyed. For example: "The corresponding account was deleted"
-     * @return integer Number of sessions which have been destroyed
+     * @return int Number of sessions which have been destroyed
+     * @throws SessionNotStartedException
+     * @throws NotSupportedByBackendException
      */
-    public function destroySessionsByTag($tag, $reason = '')
+    public function destroySessionsByTag(string $tag, string $reason = ''): int
     {
         $sessions = $this->getSessionsByTag($tag);
         foreach ($sessions as $session) {
-            /** @var SessionInterface $session */
             $session->destroy($reason);
         }
         return count($sessions);
@@ -208,7 +175,8 @@ public function destroySessionsByTag($tag, $reason = '')
      * Iterates over all existing sessions and removes their data if the inactivity
      * timeout was reached.
      *
-     * @return integer|null The number of outdated entries removed, null in case the garbage-collection was already running
+     * @return int|null The number of outdated entries removed, null in case the garbage-collection was already running
+     * @throws CacheException
      * @api
      */
     public function collectGarbage(): ?int
@@ -224,7 +192,7 @@ public function collectGarbage(): ?int
         $sessionRemovalCount = 0;
         $this->sessionMetaDataStore->startGarbageCollection();
 
-        foreach ($this->sessionMetaDataStore->retrieveAll() as $sessionIdentifier => $sessionMetadata) {
+        foreach ($this->sessionMetaDataStore->retrieveAll() as $sessionMetadata) {
             $lastActivitySecondsAgo = $now - $sessionMetadata->lastActivityTimestamp;
             if ($lastActivitySecondsAgo > $this->inactivityTimeout) {
                 if ($sessionMetadata->lastActivityTimestamp !== null) {
@@ -249,15 +217,17 @@ public function collectGarbage(): ?int
      * management.
      *
      * @return void
-     * @throws Exception\DataNotSerializableException
-     * @throws Exception\SessionNotStartedException
      * @throws NotSupportedByBackendException
-     * @throws \Neos\Cache\Exception
+     * @throws CacheException
      */
-    public function shutdownObject()
+    public function shutdownObject(): void
     {
-        $decimals = strlen(strrchr((string)$this->garbageCollectionProbability, '.')) - 1;
-        $factor = ($decimals > -1) ? $decimals * 10 : 1;
+        if (str_contains((string)$this->garbageCollectionProbability, '.')) {
+            $decimals = strlen(strrchr((string)$this->garbageCollectionProbability, '.')) - 1;
+            $factor = $decimals * 10;
+        } else {
+            $factor = 1;
+        }
         if (rand(1, 100 * $factor) <= ($this->garbageCollectionProbability * $factor)) {
             $this->collectGarbage();
         }
diff --git a/Neos.Flow/Classes/Session/SessionManagerInterface.php b/Neos.Flow/Classes/Session/SessionManagerInterface.php
index f9956b2178..de71da87fd 100644
--- a/Neos.Flow/Classes/Session/SessionManagerInterface.php
+++ b/Neos.Flow/Classes/Session/SessionManagerInterface.php
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace Neos\Flow\Session;
 
 /*
@@ -11,8 +12,6 @@
  * source code.
  */
 
-use Neos\Flow\Annotations as Flow;
-
 /**
  * Interface for a session manager
  *
@@ -28,20 +27,17 @@ interface SessionManagerInterface
      * Returns the currently active session which stores session data for the
      * current HTTP request on this local system.
      *
-     * @return SessionInterface
      * @api
      */
-    public function getCurrentSession();
+    public function getCurrentSession(): SessionInterface;
 
     /**
      * Returns the specified session. If no session with the given identifier exists,
      * NULL is returned.
      *
-     * @param string $sessionIdentifier The session identifier
-     * @return SessionInterface|null
      * @api
      */
-    public function getSession($sessionIdentifier);
+    public function getSession(string $sessionIdentifier): ?SessionInterface;
 
     /**
      * Returns all active sessions, even remote ones.
@@ -49,7 +45,7 @@ public function getSession($sessionIdentifier);
      * @return array<Session>
      * @api
      */
-    public function getActiveSessions();
+    public function getActiveSessions(): array;
 
     /**
      * Returns all sessions which are tagged by the specified tag.
@@ -58,22 +54,22 @@ public function getActiveSessions();
      * @return array A collection of Session objects or an empty array if tag did not match
      * @api
      */
-    public function getSessionsByTag($tag);
+    public function getSessionsByTag(string $tag): array;
 
     /**
      * Destroys all sessions which are tagged with the specified tag.
      *
      * @param string $tag A valid Cache Frontend tag
      * @param string $reason A reason to mention in log output for why the sessions have been destroyed. For example: "The corresponding account was deleted"
-     * @return integer Number of sessions which have been destroyed
+     * @return int Number of sessions which have been destroyed
      * @api
      */
-    public function destroySessionsByTag($tag, $reason = '');
+    public function destroySessionsByTag(string $tag, string $reason = ''): int;
 
     /**
      * Remove data of all sessions which are considered to be expired.
      *
-     * @return integer|null The number of outdated entries removed or NULL if no such information could be determined
+     * @return ?int The number of outdated entries removed or NULL if no such information could be determined
      */
     public function collectGarbage(): ?int;
 }
diff --git a/Neos.Flow/Classes/Session/TransientSession.php b/Neos.Flow/Classes/Session/TransientSession.php
index 6905e61199..0e15bb8231 100644
--- a/Neos.Flow/Classes/Session/TransientSession.php
+++ b/Neos.Flow/Classes/Session/TransientSession.php
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace Neos\Flow\Session;
 
 /*
@@ -12,7 +13,6 @@
  */
 
 use Neos\Flow\Annotations as Flow;
-use Neos\Flow\Core\Bootstrap;
 use Neos\Flow\Utility\Algorithms;
 
 /**
@@ -20,83 +20,46 @@
  *
  * This session behaves like any other session except that it only stores the
  * data during one request.
- *
- * @Flow\Scope("singleton")
  */
+#[Flow\Scope("singleton")]
 class TransientSession implements SessionInterface
 {
-    /**
-     * The session Id
-     *
-     * @var string
-     */
-    protected $sessionId;
-
-    /**
-     * If this session has been started
-     *
-     * @var boolean
-     */
-    protected $started = false;
-
-    /**
-     * The session data
-     *
-     * @var array
-     */
-    protected $data = [];
+    protected string $sessionId;
+    protected bool $started = false;
+    protected array $data = [];
+    protected ?int $lastActivityTimestamp = null;
+    protected array $tags;
 
-    /**
-     * @var integer
-     */
-    protected $lastActivityTimestamp;
-
-    /**
-     * @var array
-     */
-    protected $tags;
-
-    /**
-     * Tells if the session has been started already.
-     *
-     * @return boolean
-     */
-    public function isStarted()
+    public function isStarted(): bool
     {
         return $this->started;
     }
 
     /**
-     * Starts the session, if it has not been already started
-     *
-     * @return void
+     * @throws \Exception
      */
-    public function start()
+    public function start(): void
     {
         $this->sessionId = Algorithms::generateRandomString(13);
         $this->started = true;
     }
 
-    /**
-     * Returns true if there is a session that can be resumed. false otherwise
-     *
-     * @return boolean
-     */
-    public function canBeResumed()
+    public function canBeResumed(): bool
     {
         return true;
     }
 
     /**
-     * Resumes an existing session, if any.
-     *
-     * @return void
+     * @throws \Exception
      */
-    public function resume()
+    public function resume(): ?int
     {
+        $lastActivitySecondsAgo = null;
         if ($this->started === false) {
             $this->start();
+            $lastActivitySecondsAgo = (time() - $this->lastActivityTimestamp);
         }
+        return $lastActivitySecondsAgo;
     }
 
     /**
@@ -104,8 +67,9 @@ public function resume()
      * to the new session.
      *
      * @return string The new session ID
+     * @throws \Exception
      */
-    public function renewId()
+    public function renewId(): string
     {
         $this->sessionId = Algorithms::generateRandomString(13);
         return $this->sessionId;
@@ -117,7 +81,7 @@ public function renewId()
      * @return string The current session ID
      * @throws Exception\SessionNotStartedException
      */
-    public function getId()
+    public function getId(): string
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('The session has not been started yet.', 1218034659);
@@ -132,21 +96,15 @@ public function getId()
      * @return mixed The data associated with the given key or NULL
      * @throws Exception\SessionNotStartedException
      */
-    public function getData($key)
+    public function getData(string $key): mixed
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('The session has not been started yet.', 1218034660);
         }
-        return (array_key_exists($key, $this->data)) ? $this->data[$key] : null;
+        return $this->data[$key] ?? null;
     }
 
-    /**
-     * Returns true if $key is available.
-     *
-     * @param string $key
-     * @return boolean
-     */
-    public function hasKey($key)
+    public function hasKey(string $key): bool
     {
         return array_key_exists($key, $this->data);
     }
@@ -155,11 +113,11 @@ public function hasKey($key)
      * Stores the given data under the given key in the session
      *
      * @param string $key The key under which the data should be stored
-     * @param object $data The data to be stored
+     * @param mixed $data The data to be stored
      * @return void
      * @throws Exception\SessionNotStartedException
      */
-    public function putData($key, $data)
+    public function putData(string $key, mixed $data): void
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('The session has not been started yet.', 1218034661);
@@ -170,10 +128,9 @@ public function putData($key, $data)
     /**
      * Closes the session
      *
-     * @return void
      * @throws Exception\SessionNotStartedException
      */
-    public function close()
+    public function close(): void
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('The session has not been started yet.', 1218034662);
@@ -184,11 +141,11 @@ public function close()
     /**
      * Explicitly destroys all session data
      *
-     * @param string $reason A reason for destroying the session – used by the LoggingAspect
+     * @param string|null $reason A reason for destroying the session – used by the LoggingAspect
      * @return void
      * @throws Exception\SessionNotStartedException
      */
-    public function destroy($reason = null)
+    public function destroy(?string $reason = null): void
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('The session has not been started yet.', 1218034663);
@@ -197,33 +154,13 @@ public function destroy($reason = null)
         $this->started = false;
     }
 
-    /**
-     * No operation for transient session.
-     *
-     * @param Bootstrap $bootstrap
-     * @return void
-     */
-    public static function destroyAll(Bootstrap $bootstrap)
-    {
-    }
-
-    /**
-     * No operation for transient session.
-     *
-     * @return null
-     */
-    public function collectGarbage()
-    {
-        return null;
-    }
-
     /**
      * Returns the unix time stamp marking the last point in time this session has
      * been in use.
      *
-     * @return integer unix timestamp
+     * @return int unix timestamp
      */
-    public function getLastActivityTimestamp()
+    public function getLastActivityTimestamp(): int
     {
         if ($this->lastActivityTimestamp === null) {
             $this->touch();
@@ -233,10 +170,8 @@ public function getLastActivityTimestamp()
 
     /**
      * Updates the last activity time to "now".
-     *
-     * @return void
      */
-    public function touch()
+    public function touch(): void
     {
         $this->lastActivityTimestamp = time();
     }
@@ -253,7 +188,7 @@ public function touch()
      * @throws \InvalidArgumentException
      * @api
      */
-    public function addTag($tag)
+    public function addTag(string $tag): void
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('The session has not been started yet.', 1422551048);
@@ -269,7 +204,7 @@ public function addTag($tag)
      * @throws Exception\SessionNotStartedException
      * @api
      */
-    public function removeTag($tag)
+    public function removeTag(string $tag): void
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('The session has not been started yet.', 1422551049);
@@ -286,7 +221,7 @@ public function removeTag($tag)
      * @throws Exception\SessionNotStartedException
      * @api
      */
-    public function getTags()
+    public function getTags(): array
     {
         if ($this->started !== true) {
             throw new Exception\SessionNotStartedException('The session has not been started yet.', 1422551050);
diff --git a/Neos.Flow/Configuration/Objects.yaml b/Neos.Flow/Configuration/Objects.yaml
index 405a8756a3..daae5adee2 100644
--- a/Neos.Flow/Configuration/Objects.yaml
+++ b/Neos.Flow/Configuration/Objects.yaml
@@ -486,9 +486,6 @@ Neos\Flow\Session\Data\SessionMetaDataStore:
           1:
             value: Flow_Session_MetaData
 
-Neos\Flow\Session\SessionManagerInterface:
-  className: Neos\Flow\Session\SessionManager
-
 #
 # Utility
 #
diff --git a/Neos.Flow/Tests/Unit/Http/Middleware/SessionMiddlewareTest.php b/Neos.Flow/Tests/Unit/Http/Middleware/SessionMiddlewareTest.php
index d7f1849816..9543f41881 100644
--- a/Neos.Flow/Tests/Unit/Http/Middleware/SessionMiddlewareTest.php
+++ b/Neos.Flow/Tests/Unit/Http/Middleware/SessionMiddlewareTest.php
@@ -80,10 +80,7 @@ public function setUp(): void
     public function handleCreatesSessionIfNoCookiesAreSet(): void
     {
         $this->mockHttpRequest->method('getCookieParams')->willReturn([]);
-
-        $this->mockSessionManager->expects($this->once())->method('createCurrentSessionFromCookie')->willReturnCallback(static function (Cookie $cookie) {
-            self::assertSame('session_cookie_name', $cookie->getName());
-        });
+        $this->mockSessionManager->expects($this->once())->method('createCurrentSessionFromCookie');
 
         $this->sessionMiddleware->process($this->mockHttpRequest, $this->mockHttpRequestHandler);
     }
@@ -98,9 +95,7 @@ public function handleCreatesSessionIfNoSessionCookieIsSet(): void
             'some_other_cookie' => 'some other value',
         ]);
 
-        $this->mockSessionManager->expects($this->once())->method('createCurrentSessionFromCookie')->willReturnCallback(static function (Cookie $cookie) {
-            self::assertSame('session_cookie_name', $cookie->getName());
-        });
+        $this->mockSessionManager->expects($this->once())->method('createCurrentSessionFromCookie');
 
         $this->sessionMiddleware->process($this->mockHttpRequest, $this->mockHttpRequestHandler);
     }
@@ -114,9 +109,7 @@ public function handleCreatesSessionIfSessionCookieIsNull(): void
             'session_cookie_name' => null,
         ]);
 
-        $this->mockSessionManager->expects($this->once())->method('createCurrentSessionFromCookie')->willReturnCallback(static function (Cookie $cookie) {
-            self::assertSame('session_cookie_name', $cookie->getName());
-        });
+        $this->mockSessionManager->expects($this->once())->method('createCurrentSessionFromCookie');
 
         $this->sessionMiddleware->process($this->mockHttpRequest, $this->mockHttpRequestHandler);
     }
@@ -130,9 +123,7 @@ public function handleInitializesSessionFromSessionCookieIfItExists(): void
             'session_cookie_name' => 'some_value',
         ]);
 
-        $this->mockSessionManager->expects($this->once())->method('initializeCurrentSessionFromCookie')->willReturnCallback(static function (Cookie $cookie) {
-            self::assertSame('session_cookie_name', $cookie->getName());
-        });
+        $this->mockSessionManager->expects($this->once())->method('initializeCurrentSessionFromCookie');
 
         $this->sessionMiddleware->process($this->mockHttpRequest, $this->mockHttpRequestHandler);
     }
@@ -165,9 +156,7 @@ public function newSessionCookiesTakeSessionCookieSettingsIntoAccount(array $ses
             'cookie' => array_merge($this->defaultSessionCookieSettings, $sessionCookieSettings),
         ]);
 
-        $this->mockSessionManager->expects($this->once())->method('initializeCurrentSessionFromCookie')->willReturnCallback(static function (Cookie $cookie) use ($expectedCookie) {
-            self::assertSame($expectedCookie, (string)$cookie);
-        });
+        $this->mockSessionManager->expects($this->once())->method('initializeCurrentSessionFromCookie');
 
         $this->sessionMiddleware->process($this->mockHttpRequest, $this->mockHttpRequestHandler);
     }
@@ -203,9 +192,7 @@ public function valueFromSessionCookieIsCleanedBeforeANewCookieIsCreated($sessio
             'session_cookie_name' => $sessionCookieValue,
         ]);
 
-        $this->mockSessionManager->expects($this->once())->method('initializeCurrentSessionFromCookie')->willReturnCallback(static function (Cookie $cookie) use ($expectedNewCookieValue) {
-            self::assertSame($expectedNewCookieValue, $cookie->getValue());
-        });
+        $this->mockSessionManager->expects($this->once())->method('initializeCurrentSessionFromCookie');
 
         $this->sessionMiddleware->process($this->mockHttpRequest, $this->mockHttpRequestHandler);
     }
diff --git a/Neos.Flow/Tests/Unit/Security/Authentication/AuthenticationProviderManagerTest.php b/Neos.Flow/Tests/Unit/Security/Authentication/AuthenticationProviderManagerTest.php
index 2f48cd638f..58ac8b69e7 100644
--- a/Neos.Flow/Tests/Unit/Security/Authentication/AuthenticationProviderManagerTest.php
+++ b/Neos.Flow/Tests/Unit/Security/Authentication/AuthenticationProviderManagerTest.php
@@ -62,7 +62,7 @@ protected function setUp(): void
         $this->mockSession = $this->getMockBuilder(SessionInterface::class)->getMock();
         $this->mockSecurityContext = $this->getMockBuilder(Context::class)->disableOriginalConstructor()->getMock();
 
-        $this->mockSessionManager = $this->getMockBuilder(SessionManager::class)->getMock();
+        $this->mockSessionManager = $this->getMockBuilder(SessionManager::class)->disableOriginalConstructor()->getMock();
         $this->mockSessionManager->expects(self::any())->method('getCurrentSession')->willReturn($this->mockSession);
 
         $this->inject($this->authenticationProviderManager, 'sessionManager', $this->mockSessionManager);
diff --git a/Neos.Flow/Tests/Unit/Session/SessionManagerTest.php b/Neos.Flow/Tests/Unit/Session/SessionManagerTest.php
index 8e894c0d12..5b94585044 100644
--- a/Neos.Flow/Tests/Unit/Session/SessionManagerTest.php
+++ b/Neos.Flow/Tests/Unit/Session/SessionManagerTest.php
@@ -13,27 +13,26 @@
 
 use GuzzleHttp\Psr7\Response;
 use GuzzleHttp\Psr7\Uri;
-use Neos\Cache\Frontend\StringFrontend;
-use Neos\Flow\Http\RequestHandler;
-use Neos\Flow\Session\Data\SessionIdentifier;
-use Neos\Flow\Session\Data\SessionKeyValueStore;
-use Neos\Flow\Session\Data\SessionMetaDataStore;
-use Neos\Http\Factories\ServerRequestFactory;
-use Neos\Http\Factories\UriFactory;
-use org\bovigo\vfs\vfsStream;
 use Neos\Cache\Backend\FileBackend;
 use Neos\Cache\EnvironmentConfiguration;
+use Neos\Cache\Frontend\StringFrontend;
+use Neos\Cache\Frontend\VariableFrontend;
 use Neos\Flow\Core\Bootstrap;
+use Neos\Flow\Http\Cookie;
+use Neos\Flow\Http\RequestHandler;
 use Neos\Flow\ObjectManagement\ObjectManagerInterface;
 use Neos\Flow\Security\Context;
+use Neos\Flow\Session\Data\SessionIdentifier;
+use Neos\Flow\Session\Data\SessionKeyValueStore;
+use Neos\Flow\Session\Data\SessionMetaDataStore;
 use Neos\Flow\Session\Session;
 use Neos\Flow\Session\SessionManager;
-use Neos\Cache\Frontend\VariableFrontend;
-use Neos\Flow\Http\Cookie;
 use Neos\Flow\Tests\UnitTestCase;
+use Neos\Http\Factories\ServerRequestFactory;
+use Neos\Http\Factories\UriFactory;
+use org\bovigo\vfs\vfsStream;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
-use Psr\Log\LoggerInterface;
 
 /**
  * Unit tests for the Flow Session implementation
@@ -115,8 +114,9 @@ protected function setUp(): void
 
     /**
      * @test for #1674
+     * @throws
      */
-    public function garbageCollectionWorksCorrectlyWithInvalidMetadataEntry()
+    public function garbageCollectionWorksCorrectlyWithInvalidMetadataEntry(): void
     {
         $cache = $this->createCache('Meta');
         $cache->set('foo', null);
@@ -125,43 +125,53 @@ public function garbageCollectionWorksCorrectlyWithInvalidMetadataEntry()
         $sessionMetaDataStore->injectCache($cache);
         $sessionKeyValueStore = $this->createSessionKeyValueStore();
 
-        $sessionManager = new SessionManager();
-        $this->inject($sessionManager, 'sessionMetaDataStore', $sessionMetaDataStore);
-        $this->inject($sessionManager, 'sessionKeyValueStore', $sessionKeyValueStore);
-        $this->inject($sessionManager, 'logger', $this->createMock(LoggerInterface::class));
+        $sessionManager = new SessionManager(
+            $sessionMetaDataStore,
+            $sessionKeyValueStore,
+            1.0,
+            100,
+            500
+        );
 
         $this->assertSame(0, $sessionManager->collectGarbage());
     }
 
     /**
      * @test
+     * @throws
      */
-    public function garbageCollectionIsOmittedIfInactivityTimeoutIsSetToZero()
+    public function garbageCollectionIsOmittedIfInactivityTimeoutIsSetToZero(): void
     {
         $sessionMetaDataStore = $this->createSessionMetaDataStore();
         $sessionKeyValueStore = $this->createSessionKeyValueStore();
 
-        $sessionManager = new SessionManager();
-        $this->inject($sessionManager, 'sessionMetaDataStore', $sessionMetaDataStore);
-        $this->inject($sessionManager, 'sessionKeyValueStore', $sessionKeyValueStore);
-        $this->inject($sessionManager, 'inactivityTimeout', 0);
+        $sessionManager = new SessionManager(
+            $sessionMetaDataStore,
+            $sessionKeyValueStore,
+            1.0,
+            100,
+            0
+        );
 
         self::assertSame(0, $sessionManager->collectGarbage());
     }
 
     /**
      * @test
+     * @throws
      */
-    public function garbageCollectionIsOmittedIfAnotherProcessIsAlreadyRunning()
+    public function garbageCollectionIsOmittedIfAnotherProcessIsAlreadyRunning(): void
     {
         $sessionMetaDataStore = $this->createSessionMetaDataStore();
         $sessionKeyValueStore = $this->createSessionKeyValueStore();
 
-        $sessionManager = new SessionManager();
-        $this->inject($sessionManager, 'sessionMetaDataStore', $sessionMetaDataStore);
-        $this->inject($sessionManager, 'sessionKeyValueStore', $sessionKeyValueStore);
-        $this->inject($sessionManager, 'inactivityTimeout', 5000);
-        $this->inject($sessionManager, 'garbageCollectionProbability', 100);
+        $sessionManager = new SessionManager(
+            $sessionMetaDataStore,
+            $sessionKeyValueStore,
+            100.0,
+            100,
+            5000
+        );
 
         // No sessions need to be removed:
         self::assertSame(0, $sessionManager->collectGarbage());
@@ -174,20 +184,21 @@ public function garbageCollectionIsOmittedIfAnotherProcessIsAlreadyRunning()
 
     /**
      * @test
+     * @throws
      */
-    public function garbageCollectionOnlyRemovesTheDefinedMaximumNumberOfSessions()
+    public function garbageCollectionOnlyRemovesTheDefinedMaximumNumberOfSessions(): void
     {
         $sessionMetaDataStore = $this->createSessionMetaDataStore();
         $sessionKeyValueStore = $this->createSessionKeyValueStore();
 
         for ($i = 0; $i < 9; $i++) {
-            $sessionManager = new SessionManager();
-            $this->inject($sessionManager, 'sessionMetaDataStore', $sessionMetaDataStore);
-            $this->inject($sessionManager, 'sessionKeyValueStore', $sessionKeyValueStore);
-            $this->inject($sessionManager, 'inactivityTimeout', 1000);
-            $this->inject($sessionManager, 'garbageCollectionProbability', 0);
-            $this->inject($sessionManager, 'garbageCollectionMaximumPerRun', 5);
-            $this->inject($sessionManager, 'logger', $this->createMock(LoggerInterface::class));
+            $sessionManager = new SessionManager(
+                $sessionMetaDataStore,
+                $sessionKeyValueStore,
+                0,
+                5,
+                1000
+            );
 
             $session = Session::create();
             $this->inject($session, 'sessionMetaDataStore', $sessionMetaDataStore);
@@ -220,7 +231,7 @@ protected function createSessionKeyValueStore(): SessionKeyValueStore
         return $store;
     }
 
-    protected function createSessionMetaDataStore():SessionMetaDataStore
+    protected function createSessionMetaDataStore(): SessionMetaDataStore
     {
         $backend = new FileBackend(new EnvironmentConfiguration('Session Testing', 'vfs://Foo/', PHP_MAXPATHLEN));
         $cache = new VariableFrontend('Meta', $backend);
@@ -237,8 +248,9 @@ protected function createSessionMetaDataStore():SessionMetaDataStore
      *
      * @param string $name
      * @return VariableFrontend
+     * @throws
      */
-    protected function createCache($name)
+    protected function createCache(string $name): VariableFrontend
     {
         $backend = new FileBackend(new EnvironmentConfiguration('Session Testing', 'vfs://Foo/', PHP_MAXPATHLEN));
         $cache = new VariableFrontend($name, $backend);
diff --git a/Neos.Flow/Tests/Unit/Session/SessionTest.php b/Neos.Flow/Tests/Unit/Session/SessionTest.php
index 34dabfe8b8..177dfe174e 100644
--- a/Neos.Flow/Tests/Unit/Session/SessionTest.php
+++ b/Neos.Flow/Tests/Unit/Session/SessionTest.php
@@ -13,29 +13,29 @@
 
 use GuzzleHttp\Psr7\Response;
 use GuzzleHttp\Psr7\Uri;
+use Neos\Cache\Backend\FileBackend;
+use Neos\Cache\EnvironmentConfiguration;
 use Neos\Cache\Frontend\StringFrontend;
+use Neos\Cache\Frontend\VariableFrontend;
+use Neos\Flow\Core\Bootstrap;
+use Neos\Flow\Http\Cookie;
 use Neos\Flow\Http\RequestHandler;
+use Neos\Flow\ObjectManagement\ObjectManagerInterface;
+use Neos\Flow\Security\Context;
 use Neos\Flow\Session\Data\SessionIdentifier;
 use Neos\Flow\Session\Data\SessionKeyValueStore;
 use Neos\Flow\Session\Data\SessionMetaData;
 use Neos\Flow\Session\Data\SessionMetaDataStore;
 use Neos\Flow\Session\Data\StorageIdentifier;
-use Neos\Http\Factories\ServerRequestFactory;
-use Neos\Http\Factories\UriFactory;
 use Neos\Flow\Session\Exception\DataNotSerializableException;
 use Neos\Flow\Session\Exception\OperationNotSupportedException;
-use org\bovigo\vfs\vfsStream;
-use Neos\Cache\Backend\FileBackend;
-use Neos\Cache\EnvironmentConfiguration;
-use Neos\Flow\Core\Bootstrap;
-use Neos\Flow\ObjectManagement\ObjectManagerInterface;
-use Neos\Flow\Security\Context;
 use Neos\Flow\Session\Exception\SessionNotStartedException;
 use Neos\Flow\Session\Session;
 use Neos\Flow\Session\SessionManager;
-use Neos\Cache\Frontend\VariableFrontend;
-use Neos\Flow\Http\Cookie;
 use Neos\Flow\Tests\UnitTestCase;
+use Neos\Http\Factories\ServerRequestFactory;
+use Neos\Http\Factories\UriFactory;
+use org\bovigo\vfs\vfsStream;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 
@@ -360,7 +360,7 @@ public function renewIdThrowsExceptionIfCalledOnRemoteSession()
     public function sessionDataCanBeRetrievedEvenAfterSessionIdHasBeenRenewed()
     {
         $sessionMetaDataStore = $this->createSessionMetaDataStore();
-        $sessionKeyValueStore =$this->createSessionKeyValueStore();
+        $sessionKeyValueStore = $this->createSessionKeyValueStore();
 
         $session = Session::create();
         $this->inject($session, 'objectManager', $this->mockObjectManager);
@@ -408,8 +408,9 @@ public function putDataThrowsExceptionIfSessionIsNotStarted()
 
     /**
      * @test
+     * @throws
      */
-    public function putDataThrowsExceptionIfTryingToPersistAResource()
+    public function putDataThrowsExceptionIfTryingToPersistAResource(): void
     {
         $this->expectException(DataNotSerializableException::class);
         $session = Session::create();
@@ -425,7 +426,7 @@ public function putDataThrowsExceptionIfTryingToPersistAResource()
     /**
      * @test
      */
-    public function getDataReturnsDataPreviouslySetWithPutData()
+    public function getDataReturnsDataPreviouslySetWithPutData(): void
     {
         $session = Session::create();
         $this->inject($session, 'settings', $this->settings);
@@ -443,7 +444,7 @@ public function getDataReturnsDataPreviouslySetWithPutData()
     /**
      * @test
      */
-    public function hasKeyThrowsExceptionIfCalledOnNonStartedSession()
+    public function hasKeyThrowsExceptionIfCalledOnNonStartedSession(): void
     {
         $this->expectException(SessionNotStartedException::class);
         $session = Session::create();
@@ -452,8 +453,9 @@ public function hasKeyThrowsExceptionIfCalledOnNonStartedSession()
 
     /**
      * @test
+     * @throws
      */
-    public function twoSessionsDontConflictIfUsingSameEntryIdentifiers()
+    public function twoSessionsDontConflictIfUsingSameEntryIdentifiers(): void
     {
         $sessionMetaDataStore = $this->createSessionMetaDataStore();
         $sessionKeyValueStore = $this->createSessionKeyValueStore();
@@ -480,7 +482,7 @@ public function twoSessionsDontConflictIfUsingSameEntryIdentifiers()
     /**
      * @test
      */
-    public function getLastActivityTimestampThrowsExceptionIfCalledOnNonStartedSession()
+    public function getLastActivityTimestampThrowsExceptionIfCalledOnNonStartedSession(): void
     {
         $this->expectException(SessionNotStartedException::class);
         $session = Session::create();
@@ -489,8 +491,9 @@ public function getLastActivityTimestampThrowsExceptionIfCalledOnNonStartedSessi
 
     /**
      * @test
+     * @throws
      */
-    public function lastActivityTimestampOfNewSessionIsSetAndStoredCorrectlyAndCanBeRetrieved()
+    public function lastActivityTimestampOfNewSessionIsSetAndStoredCorrectlyAndCanBeRetrieved(): void
     {
         $sessionMetaDataStore = $this->createSessionMetaDataStore();
         $sessionKeyValueStore = $this->createSessionKeyValueStore();
@@ -518,7 +521,7 @@ public function lastActivityTimestampOfNewSessionIsSetAndStoredCorrectlyAndCanBe
     /**
      * @test
      */
-    public function addTagThrowsExceptionIfCalledOnNonStartedSession()
+    public function addTagThrowsExceptionIfCalledOnNonStartedSession(): void
     {
         $this->expectException(SessionNotStartedException::class);
         $session = Session::create();
@@ -527,8 +530,9 @@ public function addTagThrowsExceptionIfCalledOnNonStartedSession()
 
     /**
      * @test
+     * @throws
      */
-    public function addTagThrowsExceptionIfTagIsNotValid()
+    public function addTagThrowsExceptionIfTagIsNotValid(): void
     {
         $this->expectException(\InvalidArgumentException::class);
         $taggedSession = Session::create();
@@ -543,8 +547,9 @@ public function addTagThrowsExceptionIfTagIsNotValid()
 
     /**
      * @test
+     * @throws
      */
-    public function aSessionCanBeTaggedAndBeRetrievedAgainByTheseTags()
+    public function aSessionCanBeTaggedAndBeRetrievedAgainByTheseTags(): void
     {
         $sessionMetaDataStore = $this->createSessionMetaDataStore();
         $sessionKeyValueStore = $this->createSessionKeyValueStore();
@@ -573,8 +578,13 @@ public function aSessionCanBeTaggedAndBeRetrievedAgainByTheseTags()
         $otherSession->close();
         $taggedSession->close();
 
-        $sessionManager = new SessionManager();
-        $this->inject($sessionManager, 'sessionMetaDataStore', $sessionMetaDataStore);
+        $sessionManager = new SessionManager(
+            $sessionMetaDataStore,
+            $sessionKeyValueStore,
+            0.2,
+            5,
+            1000
+        );
 
         $retrievedSessions = $sessionManager->getSessionsByTag('SampleTag');
         self::assertSame($taggedSessionId, $retrievedSessions[0]->getId());
@@ -583,13 +593,13 @@ public function aSessionCanBeTaggedAndBeRetrievedAgainByTheseTags()
 
     /**
      * @test
+     * @throws
      */
-    public function getActiveSessionsReturnsAllActiveSessions()
+    public function getActiveSessionsReturnsAllActiveSessions(): void
     {
         $sessionMetaDataStore = $this->createSessionMetaDataStore();
         $sessionKeyValueStore = $this->createSessionKeyValueStore();
 
-        $sessions = [];
         $sessionIDs = [];
         for ($i = 0; $i < 5; $i++) {
             $session = Session::create();
@@ -598,13 +608,17 @@ public function getActiveSessionsReturnsAllActiveSessions()
             $this->inject($session, 'sessionKeyValueStore', $sessionKeyValueStore);
             $this->inject($session, 'objectManager', $this->mockObjectManager);
             $session->start();
-            $sessions[] = $session;
             $sessionIDs[] = $session->getId();
             $session->close();
         }
 
-        $sessionManager = new SessionManager();
-        $this->inject($sessionManager, 'sessionMetaDataStore', $sessionMetaDataStore);
+        $sessionManager = new SessionManager(
+            $sessionMetaDataStore,
+            $sessionKeyValueStore,
+            0.5,
+            5,
+            1000
+        );
 
         $activeSessions = $sessionManager->getActiveSessions();
 
@@ -619,8 +633,9 @@ public function getActiveSessionsReturnsAllActiveSessions()
 
     /**
      * @test
+     * @throws
      */
-    public function getTagsOnAResumedSessionReturnsTheTagsSetWithAddTag()
+    public function getTagsOnAResumedSessionReturnsTheTagsSetWithAddTag(): void
     {
         $sessionMetaDataStore = $this->createSessionMetaDataStore();
         $sessionKeyValueStore = $this->createSessionKeyValueStore();
@@ -653,7 +668,7 @@ public function getTagsOnAResumedSessionReturnsTheTagsSetWithAddTag()
     /**
      * @test
      */
-    public function getTagsThrowsExceptionIfCalledOnNonStartedSession()
+    public function getTagsThrowsExceptionIfCalledOnNonStartedSession(): void
     {
         $this->expectException(SessionNotStartedException::class);
         $session = Session::create();
@@ -663,7 +678,7 @@ public function getTagsThrowsExceptionIfCalledOnNonStartedSession()
     /**
      * @test
      */
-    public function removeTagThrowsExceptionIfCalledOnNonStartedSession()
+    public function removeTagThrowsExceptionIfCalledOnNonStartedSession(): void
     {
         $this->expectException(SessionNotStartedException::class);
         $session = Session::create();
@@ -672,8 +687,9 @@ public function removeTagThrowsExceptionIfCalledOnNonStartedSession()
 
     /**
      * @test
+     * @throws
      */
-    public function removeTagRemovesAPreviouslySetTag()
+    public function removeTagRemovesAPreviouslySetTag(): void
     {
         $taggedSession = Session::create();
         $this->inject($taggedSession, 'settings', $this->settings);
@@ -696,7 +712,7 @@ public function removeTagRemovesAPreviouslySetTag()
     /**
      * @test
      */
-    public function touchThrowsExceptionIfCalledOnNonStartedSession()
+    public function touchThrowsExceptionIfCalledOnNonStartedSession(): void
     {
         $this->expectException(SessionNotStartedException::class);
         $session = Session::create();
@@ -705,8 +721,9 @@ public function touchThrowsExceptionIfCalledOnNonStartedSession()
 
     /**
      * @test
+     * @throws
      */
-    public function touchUpdatesLastActivityTimestampOfRemoteSession()
+    public function touchUpdatesLastActivityTimestampOfRemoteSession(): void
     {
         $storageIdentifier = '6e988eaa-7010-4ee8-bfb8-96ea4b40ec16';
         $sessionMetaDataStore = $this->createSessionMetaDataStore();
@@ -729,8 +746,9 @@ public function touchUpdatesLastActivityTimestampOfRemoteSession()
 
     /**
      * @test
+     * @throws
      */
-    public function closeFlagsTheSessionAsClosed()
+    public function closeFlagsTheSessionAsClosed(): void
     {
         $session = Session::create();
         $this->inject($session, 'objectManager', $this->mockObjectManager);
@@ -747,8 +765,9 @@ public function closeFlagsTheSessionAsClosed()
 
     /**
      * @test
+     * @throws
      */
-    public function closeAndShutdownObjectDoNotCloseARemoteSession()
+    public function closeAndShutdownObjectDoNotCloseARemoteSession(): void
     {
         $storageIdentifier = '6e988eaa-7010-4ee8-bfb8-96ea4b40ec16';
         $session = Session::createRemote('ZPjPj3A0Opd7JeDoe7rzUQYCoDMcxscb', $storageIdentifier, 1354293259, []);
@@ -766,8 +785,9 @@ public function closeAndShutdownObjectDoNotCloseARemoteSession()
 
     /**
      * @test
+     * @throws
      */
-    public function shutdownChecksIfSessionStillExistsInStorageCacheBeforeWritingData()
+    public function shutdownChecksIfSessionStillExistsInStorageCacheBeforeWritingData(): void
     {
         $sessionMetaDataStore = $this->createSessionMetaDataStore();
         $sessionKeyValueStore = $this->createSessionKeyValueStore();
@@ -811,7 +831,7 @@ public function shutdownChecksIfSessionStillExistsInStorageCacheBeforeWritingDat
     /**
      * @test
      */
-    public function destroyThrowsExceptionIfSessionIsNotStarted()
+    public function destroyThrowsExceptionIfSessionIsNotStarted(): void
     {
         $this->expectException(SessionNotStartedException::class);
         $session = Session::create();
@@ -820,8 +840,9 @@ public function destroyThrowsExceptionIfSessionIsNotStarted()
 
     /**
      * @test
+     * @throws
      */
-    public function destroyRemovesAllSessionDataFromTheCurrentSessionButNotFromOtherSessions()
+    public function destroyRemovesAllSessionDataFromTheCurrentSessionButNotFromOtherSessions(): void
     {
         $session1 = Session::create();
         $session2 = Session::create();
@@ -863,8 +884,9 @@ public function destroyRemovesAllSessionDataFromTheCurrentSessionButNotFromOther
 
     /**
      * @test
+     * @throws
      */
-    public function destroyRemovesAllSessionDataFromARemoteSession()
+    public function destroyRemovesAllSessionDataFromARemoteSession(): void
     {
         $sessionMetaData = new SessionMetaData(
             SessionIdentifier::createFromString('ZPjPj3A0Opd7JeDoe7rzUQYCoDMcxscb'),
@@ -894,8 +916,9 @@ public function destroyRemovesAllSessionDataFromARemoteSession()
 
     /**
      * @test
+     * @throws
      */
-    public function autoExpireRemovesAllSessionDataOfTheExpiredSession()
+    public function autoExpireRemovesAllSessionDataOfTheExpiredSession(): void
     {
         $session = $this->getAccessibleMock(Session::class, ['dummy']);
         $this->inject($session, 'objectManager', $this->mockObjectManager);
@@ -923,7 +946,7 @@ public function autoExpireRemovesAllSessionDataOfTheExpiredSession()
         $session->close();
 
         $sessionInfo = $sessionMetaDataStore->retrieve($sessionIdentifier);
-        $sessionInfo  = $sessionInfo->withLastActivityTimestamp(time() - 4000);
+        $sessionInfo = $sessionInfo->withLastActivityTimestamp(time() - 4000);
         $sessionMetaDataStore->store($sessionInfo);
 
         // canBeResumed implicitly calls autoExpire():
@@ -936,7 +959,7 @@ public function autoExpireRemovesAllSessionDataOfTheExpiredSession()
     /**
      * @test
      */
-    public function autoExpireTriggersGarbageCollectionForExpiredSessions()
+    public function autoExpireTriggersGarbageCollectionForExpiredSessions(): void
     {
         $settings = $this->settings;
         $settings['session']['inactivityTimeout'] = 5000;
@@ -1013,7 +1036,7 @@ protected function createSessionKeyValueStore(): SessionKeyValueStore
         return $store;
     }
 
-    protected function createSessionMetaDataStore():SessionMetaDataStore
+    protected function createSessionMetaDataStore(): SessionMetaDataStore
     {
         $backend = new FileBackend(new EnvironmentConfiguration('Session Testing', 'vfs://Foo/', PHP_MAXPATHLEN));
         $cache = new VariableFrontend('Meta', $backend);