diff --git a/Neos.Flow/Classes/Aop/Builder/ProxyClassBuilder.php b/Neos.Flow/Classes/Aop/Builder/ProxyClassBuilder.php
index b1052792f7..a175e0cf8d 100644
--- a/Neos.Flow/Classes/Aop/Builder/ProxyClassBuilder.php
+++ b/Neos.Flow/Classes/Aop/Builder/ProxyClassBuilder.php
@@ -441,10 +441,8 @@ public function buildProxyClass(string $targetClassName, array $aspectContainers
      * @param ClassNameIndex $targetClassNameCandidates target class names for advices
      * @param ClassNameIndex $treatedSubClasses Already treated (sub) classes to avoid duplication
      * @return ClassNameIndex The new collection of already treated classes
-     * @throws ClassLoadingForReflectionFailedException
-     * @throws \ReflectionException
-     * @throws InvalidClassException
      * @throws CannotBuildObjectException
+     * @throws \ReflectionException
      */
     protected function proxySubClassesOfClassToEnsureAdvices(string $className, ClassNameIndex $targetClassNameCandidates, ClassNameIndex $treatedSubClasses): ClassNameIndex
     {
diff --git a/Neos.Flow/Classes/Cache/CacheManager.php b/Neos.Flow/Classes/Cache/CacheManager.php
index 404b699205..b4e6b4c6d6 100644
--- a/Neos.Flow/Classes/Cache/CacheManager.php
+++ b/Neos.Flow/Classes/Cache/CacheManager.php
@@ -375,9 +375,10 @@ protected function flushClassCachesByChangedFiles(array $changedFiles): void
         $flushDoctrineProxyCache = false;
         $flushPolicyCache = false;
         if (count($modifiedClassNamesWithUnderscores) > 0) {
-            $reflectionStatusCache = $this->getCache('Flow_Reflection_Status');
+            $reflectionDataRuntimeCache = $this->getCache('Flow_Reflection_RuntimeData');
             foreach (array_keys($modifiedClassNamesWithUnderscores) as $classNameWithUnderscores) {
-                $reflectionStatusCache->remove($classNameWithUnderscores);
+                $this->logger->debug('File change detected, removing reflection for ' . $classNameWithUnderscores);
+                $reflectionDataRuntimeCache->remove($classNameWithUnderscores);
                 if ($flushDoctrineProxyCache === false && preg_match('/_Domain_Model_(.+)/', $classNameWithUnderscores) === 1) {
                     $flushDoctrineProxyCache = true;
                 }
diff --git a/Neos.Flow/Classes/Command/CacheCommandController.php b/Neos.Flow/Classes/Command/CacheCommandController.php
index 9999ac98d5..2f79738aa2 100644
--- a/Neos.Flow/Classes/Command/CacheCommandController.php
+++ b/Neos.Flow/Classes/Command/CacheCommandController.php
@@ -134,9 +134,6 @@ public function injectEnvironment(Environment $environment)
      * from running, the removal of any temporary data can be forced by specifying
      * the option <b>--force</b>.
      *
-     * This command does not remove the precompiled data provided by frozen
-     * packages unless the <b>--force</b> option is used.
-     *
      * @param boolean $force Force flushing of any temporary data
      * @return void
      * @see neos.flow:cache:warmup
@@ -156,23 +153,6 @@ public function flushCommand(bool $force = false)
             $this->lockManager->unlockSite();
         }
 
-        $frozenPackages = [];
-        foreach (array_keys($this->packageManager->getAvailablePackages()) as $packageKey) {
-            if ($this->packageManager->isPackageFrozen($packageKey)) {
-                $frozenPackages[] = $packageKey;
-            }
-        }
-        if ($frozenPackages !== []) {
-            $this->outputFormatted(PHP_EOL . 'Please note that the following package' . (count($frozenPackages) === 1 ? ' is' : 's are') . ' currently frozen: ' . PHP_EOL);
-            $this->outputFormatted(implode(PHP_EOL, $frozenPackages) . PHP_EOL, [], 2);
-
-            $message = 'As code and configuration changes in these packages are not detected, the application may respond ';
-            $message .= 'unexpectedly if modifications were done anyway or the remaining code relies on these changes.' . PHP_EOL . PHP_EOL;
-            $message .= 'You may call <b>package:refreeze all</b> in order to refresh frozen packages or use the <b>--force</b> ';
-            $message .= 'option of this <b>cache:flush</b> command to flush caches if Flow becomes unresponsive.' . PHP_EOL;
-            $this->outputFormatted($message, [$frozenPackages]);
-        }
-
         $this->sendAndExit(0);
     }
 
diff --git a/Neos.Flow/Classes/Command/PackageCommandController.php b/Neos.Flow/Classes/Command/PackageCommandController.php
index 25e6616f5a..79649b5d0c 100644
--- a/Neos.Flow/Classes/Command/PackageCommandController.php
+++ b/Neos.Flow/Classes/Command/PackageCommandController.php
@@ -14,8 +14,6 @@
 use Neos\Flow\Annotations as Flow;
 use Neos\Flow\Cli\CommandController;
 use Neos\Flow\Composer\ComposerUtility;
-use Neos\Flow\Core\Booting\Scripts;
-use Neos\Flow\Core\Bootstrap;
 use Neos\Flow\Package\PackageInterface;
 use Neos\Flow\Package\PackageKeyAwareInterface;
 use Neos\Flow\Package\PackageManager;
@@ -32,25 +30,6 @@ class PackageCommandController extends CommandController
      */
     protected $packageManager;
 
-    /**
-     * @var array
-     */
-    protected $settings;
-
-    /**
-     * @var Bootstrap
-     */
-    protected $bootstrap;
-
-    /**
-     * @param array $settings The Flow settings
-     * @return void
-     */
-    public function injectSettings(array $settings)
-    {
-        $this->settings = $settings;
-    }
-
     /**
      * @param PackageManager $packageManager
      * @return void
@@ -60,15 +39,6 @@ public function injectPackageManager(PackageManager $packageManager)
         $this->packageManager = $packageManager;
     }
 
-    /**
-     * @param Bootstrap $bootstrap
-     * @return void
-     */
-    public function injectBootstrap(Bootstrap $bootstrap)
-    {
-        $this->bootstrap = $bootstrap;
-    }
-
     /**
      * Create a new package
      *
@@ -112,9 +82,7 @@ public function createCommand(string $packageKey, string $packageType = PackageI
     public function listCommand(bool $loadingOrder = false)
     {
         $availablePackages = [];
-        $frozenPackages = [];
         $longestPackageKey = 0;
-        $freezeSupported = $this->bootstrap->getContext()->isDevelopment();
 
         foreach ($this->packageManager->getAvailablePackages() as $packageKey => $package) {
             if (strlen($packageKey) > $longestPackageKey) {
@@ -122,10 +90,6 @@ public function listCommand(bool $loadingOrder = false)
             }
 
             $availablePackages[$packageKey] = $package;
-
-            if ($this->packageManager->isPackageFrozen($packageKey)) {
-                $frozenPackages[$packageKey] = $package;
-            }
         }
 
         if ($loadingOrder === false) {
@@ -135,13 +99,7 @@ public function listCommand(bool $loadingOrder = false)
         $this->outputLine('PACKAGES:');
         /** @var PackageInterface|PackageKeyAwareInterface $package */
         foreach ($availablePackages as $package) {
-            $frozenState = ($freezeSupported && isset($frozenPackages[$package->getPackageKey()]) ? '* ' : '  ');
-            $this->outputLine(' ' . str_pad($package->getPackageKey(), $longestPackageKey + 3) . $frozenState . str_pad($package->getInstalledVersion(), 15));
-        }
-
-        if (count($frozenPackages) > 0 && $freezeSupported) {
-            $this->outputLine();
-            $this->outputLine(' * frozen package');
+            $this->outputLine(' ' . str_pad($package->getPackageKey(), $longestPackageKey + 3) . str_pad($package->getInstalledVersion(), 15));
         }
     }
 
@@ -165,47 +123,11 @@ public function listCommand(bool $loadingOrder = false)
      * @return void
      * @see neos.flow:package:unfreeze
      * @see neos.flow:package:refreeze
+     * @deprecated since 8.4
      */
     public function freezeCommand(string $packageKey = 'all')
     {
-        if (!$this->bootstrap->getContext()->isDevelopment()) {
-            $this->outputLine('Package freezing is only supported in Development context.');
-            $this->quit(3);
-        }
-
-        $packagesToFreeze = [];
-
-        if ($packageKey === 'all') {
-            foreach (array_keys($this->packageManager->getAvailablePackages()) as $packageKey) {
-                if (!$this->packageManager->isPackageFrozen($packageKey)) {
-                    $packagesToFreeze[] = $packageKey;
-                }
-            }
-            if ($packagesToFreeze === []) {
-                $this->outputLine('Nothing to do, all packages were already frozen.');
-                $this->quit(0);
-            }
-        } elseif ($packageKey === 'blackberry') {
-            $this->outputLine('http://bit.ly/freeze-blackberry');
-            $this->quit(42);
-        } else {
-            if (!$this->packageManager->isPackageAvailable($packageKey)) {
-                $this->outputLine('Package "%s" is not available.', [$packageKey]);
-                $this->quit(2);
-            }
-
-            if ($this->packageManager->isPackageFrozen($packageKey)) {
-                $this->outputLine('Package "%s" was already frozen.', [$packageKey]);
-                $this->quit(0);
-            }
-
-            $packagesToFreeze = [$packageKey];
-        }
-
-        foreach ($packagesToFreeze as $packageKey) {
-            $this->packageManager->freezePackage($packageKey);
-            $this->outputLine('Froze package "%s".', [$packageKey]);
-        }
+        $this->outputLine('Package freezing is no longer supported, this command is deprecated and will be removed with 9.0.');
     }
 
     /**
@@ -222,47 +144,11 @@ public function freezeCommand(string $packageKey = 'all')
      * @return void
      * @see neos.flow:package:freeze
      * @see neos.flow:cache:flush
+     * @deprecated since 8.4
      */
     public function unfreezeCommand(string $packageKey = 'all')
     {
-        if (!$this->bootstrap->getContext()->isDevelopment()) {
-            $this->outputLine('Package freezing is only supported in Development context.');
-            $this->quit(3);
-        }
-
-        $packagesToUnfreeze = [];
-
-        if ($packageKey === 'all') {
-            foreach (array_keys($this->packageManager->getAvailablePackages()) as $packageKey) {
-                if ($this->packageManager->isPackageFrozen($packageKey)) {
-                    $packagesToUnfreeze[] = $packageKey;
-                }
-            }
-            if ($packagesToUnfreeze === []) {
-                $this->outputLine('Nothing to do, no packages were frozen.');
-                $this->quit(0);
-            }
-        } else {
-            if ($packageKey === null) {
-                $this->outputLine('You must specify a package to unfreeze.');
-                $this->quit(1);
-            }
-
-            if (!$this->packageManager->isPackageAvailable($packageKey)) {
-                $this->outputLine('Package "%s" is not available.', [$packageKey]);
-                $this->quit(2);
-            }
-            if (!$this->packageManager->isPackageFrozen($packageKey)) {
-                $this->outputLine('Package "%s" was not frozen.', [$packageKey]);
-                $this->quit(0);
-            }
-            $packagesToUnfreeze = [$packageKey];
-        }
-
-        foreach ($packagesToUnfreeze as $packageKey) {
-            $this->packageManager->unfreezePackage($packageKey);
-            $this->outputLine('Unfroze package "%s".', [$packageKey]);
-        }
+        $this->outputLine('Package freezing is no longer supported, this command is deprecated and will be removed with 9.0.');
     }
 
     /**
@@ -280,50 +166,11 @@ public function unfreezeCommand(string $packageKey = 'all')
      * @return void
      * @see neos.flow:package:freeze
      * @see neos.flow:cache:flush
+     * @deprecated since 8.4
      */
     public function refreezeCommand(string $packageKey = 'all')
     {
-        if (!$this->bootstrap->getContext()->isDevelopment()) {
-            $this->outputLine('Package freezing is only supported in Development context.');
-            $this->quit(3);
-        }
-
-        $packagesToRefreeze = [];
-
-        if ($packageKey === 'all') {
-            foreach (array_keys($this->packageManager->getAvailablePackages()) as $packageKey) {
-                if ($this->packageManager->isPackageFrozen($packageKey)) {
-                    $packagesToRefreeze[] = $packageKey;
-                }
-            }
-            if ($packagesToRefreeze === []) {
-                $this->outputLine('Nothing to do, no packages were frozen.');
-                $this->quit(0);
-            }
-        } else {
-            if ($packageKey === null) {
-                $this->outputLine('You must specify a package to refreeze.');
-                $this->quit(1);
-            }
-
-            if (!$this->packageManager->isPackageAvailable($packageKey)) {
-                $this->outputLine('Package "%s" is not available.', [$packageKey]);
-                $this->quit(2);
-            }
-            if (!$this->packageManager->isPackageFrozen($packageKey)) {
-                $this->outputLine('Package "%s" was not frozen.', [$packageKey]);
-                $this->quit(0);
-            }
-            $packagesToRefreeze = [$packageKey];
-        }
-
-        foreach ($packagesToRefreeze as $packageKey) {
-            $this->packageManager->refreezePackage($packageKey);
-            $this->outputLine('Refroze package "%s".', [$packageKey]);
-        }
-
-        Scripts::executeCommand('neos.flow:cache:flush', $this->settings, false);
-        $this->sendAndExit(0);
+        $this->outputLine('Package freezing is no longer supported, this command is deprecated and will be removed with 9.0.');
     }
 
     /**
diff --git a/Neos.Flow/Classes/Core/Booting/Scripts.php b/Neos.Flow/Classes/Core/Booting/Scripts.php
index 7614aedf75..74edfed2e0 100644
--- a/Neos.Flow/Classes/Core/Booting/Scripts.php
+++ b/Neos.Flow/Classes/Core/Booting/Scripts.php
@@ -247,7 +247,7 @@ public static function initializeSystemLogger(Bootstrap $bootstrap): void
         $throwableStorage = self::initializeExceptionStorage($bootstrap, $settings);
         $bootstrap->setEarlyInstance(ThrowableStorageInterface::class, $throwableStorage);
 
-        /** @var PsrLoggerFactoryInterface $psrLoggerFactoryName */
+        /** @var class-string $psrLoggerFactoryName */
         $psrLoggerFactoryName = $settings['log']['psr3']['loggerFactory'];
         $psrLogConfigurations = $settings['log']['psr3'][$psrLoggerFactoryName] ?? [];
         $psrLogFactory = $psrLoggerFactoryName::create($psrLogConfigurations);
@@ -578,10 +578,6 @@ public static function initializeSystemFileMonitor(Bootstrap $bootstrap)
 
         /** @var FlowPackageInterface $package */
         foreach ($packageManager->getFlowPackages() as $packageKey => $package) {
-            if ($packageManager->isPackageFrozen($packageKey)) {
-                continue;
-            }
-
             self::monitorDirectoryIfItExists($fileMonitors['Flow_ConfigurationFiles'], $package->getConfigurationPath(), '\.y(a)?ml$');
             self::monitorDirectoryIfItExists($fileMonitors['Flow_TranslationFiles'], $package->getResourcesPath() . 'Private/Translations/', '\.xlf');
 
diff --git a/Neos.Flow/Classes/Package.php b/Neos.Flow/Classes/Package.php
index 7aedd92240..f6ad59cbfb 100644
--- a/Neos.Flow/Classes/Package.php
+++ b/Neos.Flow/Classes/Package.php
@@ -21,6 +21,7 @@
 use Neos\Flow\ObjectManagement\Proxy;
 use Neos\Flow\Package\Package as BasePackage;
 use Neos\Flow\Package\PackageManager;
+use Neos\Flow\Reflection\ReflectionService;
 use Neos\Flow\ResourceManagement\ResourceManager;
 use Neos\Flow\ResourceManagement\ResourceRepository;
 use Neos\Flow\Security\Authentication\AuthenticationProviderManager;
@@ -105,10 +106,6 @@ public function boot(Core\Bootstrap $bootstrap)
                     /** @var PackageManager $packageManager */
                     $packageManager = $bootstrap->getEarlyInstance(Package\PackageManager::class);
                     foreach ($packageManager->getFlowPackages() as $packageKey => $package) {
-                        if ($packageManager->isPackageFrozen($packageKey)) {
-                            continue;
-                        }
-
                         $publicResourcesPath = $package->getResourcesPath() . 'Public/';
                         if (is_dir($publicResourcesPath)) {
                             $publicResourcesFileMonitor->monitorDirectory($publicResourcesPath);
@@ -139,6 +136,7 @@ public function boot(Core\Bootstrap $bootstrap)
         $dispatcher->connect(Core\Bootstrap::class, 'bootstrapShuttingDown', ObjectManagement\ObjectManagerInterface::class, 'shutdown');
         $dispatcher->connect(Core\Bootstrap::class, 'bootstrapShuttingDown', Configuration\ConfigurationManager::class, 'shutdown');
 
+        /** @see ReflectionService::saveToCache() */
         $dispatcher->connect(Core\Bootstrap::class, 'bootstrapShuttingDown', Reflection\ReflectionService::class, 'saveToCache');
 
         $dispatcher->connect(Command\CoreCommandController::class, 'finishedCompilationRun', Security\Authorization\Privilege\Method\MethodPrivilegePointcutFilter::class, 'savePolicyCache');
diff --git a/Neos.Flow/Classes/Package/PackageManager.php b/Neos.Flow/Classes/Package/PackageManager.php
index 41d6f2ce7d..8b0e8e9432 100644
--- a/Neos.Flow/Classes/Package/PackageManager.php
+++ b/Neos.Flow/Classes/Package/PackageManager.php
@@ -15,7 +15,6 @@
 use Neos\Flow\Composer\Exception\InvalidConfigurationException;
 use Neos\Flow\Composer\ComposerUtility;
 use Neos\Flow\Core\Bootstrap;
-use Neos\Flow\Reflection\ReflectionService;
 use Neos\Flow\SignalSlot\Dispatcher;
 use Neos\Flow\SignalSlot\Exception\InvalidSlotException;
 use Neos\Utility\Exception\FilesException;
@@ -229,22 +228,11 @@ public function getAvailablePackages(): array
      * precompiled reflection data in order to improve performance.
      *
      * @return array<PackageInterface>
+     * @deprecated since 8.4
      */
     public function getFrozenPackages(): array
     {
-        $frozenPackages = [];
-        if ($this->bootstrap->getContext()->isDevelopment()) {
-            /** @var PackageInterface $package */
-            foreach ($this->packages as $packageKey => $package) {
-                if (isset($this->packageStatesConfiguration['packages'][$package->getComposerName()]['frozen']) &&
-                    $this->packageStatesConfiguration['packages'][$package->getComposerName()]['frozen'] === true
-                ) {
-                    $frozenPackages[$packageKey] = $package;
-                }
-            }
-        }
-
-        return $frozenPackages;
+        return [];
     }
 
     /**
@@ -401,6 +389,7 @@ public function createPackage($packageKey, array $manifest = [], $packagesPath =
      * @param string $toAbsolutePath
      * @return void
      * @throws FilesException
+     * @deprecated since 8.4
      */
     protected function movePackage($fromAbsolutePath, $toAbsolutePath): void
     {
@@ -409,95 +398,16 @@ protected function movePackage($fromAbsolutePath, $toAbsolutePath): void
         Files::removeDirectoryRecursively($fromAbsolutePath);
     }
 
-    /**
-     * Freezes a package
-     *
-     * @param string $packageKey The package to freeze
-     * @return void
-     * @throws Exception\PackageStatesFileNotWritableException
-     * @throws Exception\UnknownPackageException
-     * @throws \Neos\Flow\Exception
-     * @throws FilesException
-     */
-    public function freezePackage($packageKey): void
-    {
-        if (!$this->bootstrap->getContext()->isDevelopment()) {
-            throw new \LogicException('Package freezing is only supported in Development context.', 1338810870);
-        }
-
-        if (!$this->isPackageAvailable($packageKey)) {
-            throw new Exception\UnknownPackageException('Package "' . $packageKey . '" is not available.', 1331715956);
-        }
-        if ($this->isPackageFrozen($packageKey)) {
-            return;
-        }
-
-        $package = $this->packages[$packageKey];
-        $this->bootstrap->getObjectManager()->get(ReflectionService::class)->freezePackageReflection($packageKey);
-
-        $this->packageStatesConfiguration['packages'][$package->getComposerName()]['frozen'] = true;
-        $this->savePackageStates($this->packageStatesConfiguration);
-    }
-
     /**
      * Tells if a package is frozen
      *
      * @param string $packageKey The package to check
      * @return boolean
+     * @deprecated since 8.4
      */
     public function isPackageFrozen($packageKey): bool
     {
-        if (!isset($this->packages[$packageKey])) {
-            return false;
-        }
-        $composerName = $this->packages[$packageKey]->getComposerName();
-
-        return (
-            $this->bootstrap->getContext()->isDevelopment()
-            && isset($this->packageStatesConfiguration['packages'][$composerName]['frozen'])
-            && $this->packageStatesConfiguration['packages'][$composerName]['frozen'] === true
-        );
-    }
-
-    /**
-     * Unfreezes a package
-     *
-     * @param string $packageKey The package to unfreeze
-     * @return void
-     * @throws Exception\PackageStatesFileNotWritableException
-     * @throws \Neos\Flow\Exception
-     * @throws FilesException
-     */
-    public function unfreezePackage($packageKey): void
-    {
-        if (!$this->isPackageFrozen($packageKey)) {
-            return;
-        }
-        if (!isset($this->packages[$packageKey])) {
-            return;
-        }
-        $composerName = $this->packages[$packageKey]->getComposerName();
-
-        $this->bootstrap->getObjectManager()->get(ReflectionService::class)->unfreezePackageReflection($packageKey);
-
-        unset($this->packageStatesConfiguration['packages'][$composerName]['frozen']);
-        $this->savePackageStates($this->packageStatesConfiguration);
-    }
-
-    /**
-     * Refreezes a package
-     *
-     * @param string $packageKey The package to refreeze
-     * @return void
-     * @throws \Neos\Flow\Exception
-     */
-    public function refreezePackage($packageKey): void
-    {
-        if (!$this->isPackageFrozen($packageKey)) {
-            return;
-        }
-
-        $this->bootstrap->getObjectManager()->get(ReflectionService::class)->unfreezePackageReflection($packageKey);
+        return false;
     }
 
     /**
diff --git a/Neos.Flow/Classes/Reflection/ReflectionService.php b/Neos.Flow/Classes/Reflection/ReflectionService.php
index 835f4a2414..4f5707daf2 100644
--- a/Neos.Flow/Classes/Reflection/ReflectionService.php
+++ b/Neos.Flow/Classes/Reflection/ReflectionService.php
@@ -19,10 +19,8 @@
 use Doctrine\Persistence\Proxy as DoctrineProxy;
 use Neos\Cache\Backend\FreezableBackendInterface;
 use Neos\Cache\Exception;
-use Neos\Cache\Frontend\StringFrontend;
 use Neos\Cache\Frontend\VariableFrontend;
 use Neos\Flow\Annotations as Flow;
-use Neos\Flow\Core\ApplicationContext;
 use Neos\Flow\Log\Utility\LogEnvironment;
 use Neos\Flow\ObjectManagement\Proxy\ProxyInterface;
 use Neos\Flow\Package\PackageManager;
@@ -32,14 +30,9 @@
 use Neos\Flow\Reflection\Exception\InvalidClassException;
 use Neos\Flow\Reflection\Exception\InvalidPropertyTypeException;
 use Neos\Flow\Reflection\Exception\InvalidValueObjectException;
-use Neos\Flow\Utility\Environment;
-use Neos\Utility\Arrays;
-use Neos\Utility\Exception\FilesException;
-use Neos\Utility\Files;
 use Neos\Utility\TypeHandling;
 use Psr\Log\LoggerInterface;
 use Psr\Log\LogLevel;
-use ReflectionException;
 
 /**
  * A service for acquiring reflection based information in a performant way. This
@@ -74,15 +67,9 @@ class ReflectionService
     // Implementations of an interface
     protected const DATA_INTERFACE_IMPLEMENTATIONS = 1;
 
-    // Implemented interfaces of a class
-    protected const DATA_CLASS_INTERFACES = 2;
-
     // Subclasses of a class
     protected const DATA_CLASS_SUBCLASSES = 3;
 
-    // Class tag values
-    protected const DATA_CLASS_TAGS_VALUES = 4;
-
     // Class annotations
     protected const DATA_CLASS_ANNOTATIONS = 5;
     protected const DATA_CLASS_ABSTRACT = 6;
@@ -113,14 +100,9 @@ class ReflectionService
 
     protected Reader $annotationReader;
     protected array $availableClassNames = [];
-    protected StringFrontend $statusCache;
-    protected VariableFrontend $reflectionDataCompiletimeCache;
     protected VariableFrontend $reflectionDataRuntimeCache;
     protected VariableFrontend $classSchemataRuntimeCache;
     protected ?LoggerInterface $logger = null;
-    protected PackageManager $packageManager;
-    protected Environment $environment;
-    protected ApplicationContext $context;
 
     /**
      * The doctrine PHP parser which can parse "use" statements. Is initialized
@@ -135,11 +117,6 @@ class ReflectionService
      */
     protected array $useStatementsForClassCache;
 
-    /**
-     * In Production context, with frozen caches, this flag will be true
-     */
-    protected bool $loadFromClassSchemaRuntimeCache = false;
-
     protected array $settings = [];
 
     /**
@@ -181,24 +158,6 @@ class ReflectionService
      */
     protected array $methodAnnotationsRuntimeCache = [];
 
-    /**
-     * Sets the status cache
-     *
-     * The cache must be set before initializing the Reflection Service
-     */
-    public function setStatusCache(StringFrontend $cache): void
-    {
-        $this->statusCache = $cache;
-        $backend = $this->statusCache->getBackend();
-        if (is_callable([$backend, 'initializeObject'])) {
-            $backend->initializeObject();
-        }
-    }
-
-    public function setReflectionDataCompiletimeCache(VariableFrontend $cache): void
-    {
-        $this->reflectionDataCompiletimeCache = $cache;
-    }
 
     public function setReflectionDataRuntimeCache(VariableFrontend $cache): void
     {
@@ -220,16 +179,6 @@ public function injectLogger(LoggerInterface $logger): void
         $this->logger = $logger;
     }
 
-    public function injectPackageManager(PackageManager $packageManager): void
-    {
-        $this->packageManager = $packageManager;
-    }
-
-    public function injectEnvironment(Environment $environment): void
-    {
-        $this->environment = $environment;
-    }
-
     protected function getDoctrinePhpParser(): PhpParser
     {
         if ($this->doctrinePhpParser === null) {
@@ -243,20 +192,14 @@ protected function getDoctrinePhpParser(): PhpParser
      * Initialize the reflection service lazily
      *
      * This method must be run only after all dependencies have been injected.
-     *
-     * @throws FilesException
-     * @throws \Neos\Flow\Utility\Exception
      */
     protected function initialize(): void
     {
-        $this->context = $this->environment->getContext();
-
-        if ($this->hasFrozenCacheInProduction()) {
-            $this->classReflectionData = $this->reflectionDataRuntimeCache->get('__classNames');
+        $classNames = $this->reflectionDataRuntimeCache->get('__classNames');
+        if (is_array($classNames)) {
+            $this->classReflectionData = $classNames;
             $this->annotatedClasses = $this->reflectionDataRuntimeCache->get('__annotatedClasses');
-            $this->loadFromClassSchemaRuntimeCache = true;
-        } else {
-            $this->loadClassReflectionCompiletimeCache();
+            $this->classesByMethodAnnotations = $this->reflectionDataRuntimeCache->get('__classesByMethodAnnotations');
         }
 
         $this->annotationReader = new AnnotationReader();
@@ -275,13 +218,14 @@ protected function initialize(): void
      * This method is called by the Compile Time Object Manager which also determines
      * the list of classes to consider for reflection.
      *
+     * @param array $availableClassNames
      * @throws ClassLoadingForReflectionFailedException
      * @throws ClassSchemaConstraintViolationException
      * @throws Exception
-     * @throws FilesException
      * @throws InvalidClassException
-     * @throws ReflectionException
-     * @throws \Neos\Flow\Utility\Exception
+     * @throws InvalidPropertyTypeException
+     * @throws InvalidValueObjectException
+     * @throws \ReflectionException
      */
     public function buildReflectionData(array $availableClassNames): void
     {
@@ -297,6 +241,8 @@ public function buildReflectionData(array $availableClassNames): void
      * Tells if the specified class is known to this reflection service and
      * reflection information is available.
      *
+     * @param class-string $className
+     *
      * @api
      */
     public function isClassReflected(string $className): bool
@@ -306,7 +252,7 @@ public function isClassReflected(string $className): bool
         }
         $className = $this->cleanClassName($className);
 
-        return isset($this->classReflectionData[$className]);
+        return isset($this->classReflectionData[$className]) && is_array($this->classReflectionData[$className]);
     }
 
     /**
@@ -328,19 +274,19 @@ public function getAllClassNames(): array
      * interface name. If no class implementing the interface was found or more than one
      * implementation was found in the package defining the interface, false is returned.
      *
+     * @param class-string $interfaceName
+     * @return string|bool
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function getDefaultImplementationClassNameForInterface(string $interfaceName): string|bool
     {
-        if (!$this->initialized) {
-            $this->initialize();
-        }
-        $interfaceName = $this->cleanClassName($interfaceName);
-
         if (interface_exists($interfaceName) === false) {
             throw new \InvalidArgumentException('"' . $interfaceName . '" does not exist or is not the name of an interface.', 1238769559);
         }
-        $this->loadOrReflectClassIfNecessary($interfaceName);
+        $interfaceName = $this->prepareClassReflectionForUsage($interfaceName);
 
         $classNamesFound = isset($this->classReflectionData[$interfaceName][self::DATA_INTERFACE_IMPLEMENTATIONS]) ? array_keys($this->classReflectionData[$interfaceName][self::DATA_INTERFACE_IMPLEMENTATIONS]) : [];
         if (count($classNamesFound) === 1) {
@@ -369,19 +315,15 @@ public function getDefaultImplementationClassNameForInterface(string $interfaceN
      * @return list<class-string<T>>
      * @throws ClassLoadingForReflectionFailedException
      * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function getAllImplementationClassNamesForInterface(string $interfaceName): array
     {
-        if (!$this->initialized) {
-            $this->initialize();
-        }
-        $interfaceName = $this->cleanClassName($interfaceName);
-
         if (interface_exists($interfaceName) === false) {
             throw new \InvalidArgumentException('"' . $interfaceName . '" does not exist or is not the name of an interface.', 1238769560);
         }
-        $this->loadOrReflectClassIfNecessary($interfaceName);
+        $interfaceName = $this->prepareClassReflectionForUsage($interfaceName);
 
         return (isset($this->classReflectionData[$interfaceName][self::DATA_INTERFACE_IMPLEMENTATIONS])) ? array_keys($this->classReflectionData[$interfaceName][self::DATA_INTERFACE_IMPLEMENTATIONS]) : [];
     }
@@ -394,20 +336,15 @@ public function getAllImplementationClassNamesForInterface(string $interfaceName
      * @return array<class-string>
      * @throws ClassLoadingForReflectionFailedException
      * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function getAllSubClassNamesForClass(string $className): array
     {
-        if (!$this->initialized) {
-            $this->initialize();
-        }
-        $className = $this->cleanClassName($className);
-
         if (class_exists($className) === false) {
             throw new \InvalidArgumentException('"' . $className . '" does not exist or is not the name of a class.', 1257168042);
         }
-        $this->loadOrReflectClassIfNecessary($className);
-
+        $className = $this->prepareClassReflectionForUsage($className);
         return (isset($this->classReflectionData[$className][self::DATA_CLASS_SUBCLASSES])) ? array_keys($this->classReflectionData[$className][self::DATA_CLASS_SUBCLASSES]) : [];
     }
 
@@ -445,9 +382,12 @@ public function isClassAnnotatedWith(string $className, string $annotationClassN
     /**
      * Returns the specified class annotations or an empty array
      *
-     * @param null|string $annotationClassName
+     * @param class-string $className
+     * @param null|class-string $annotationClassName
      * @return array<object>
-     *
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      */
     public function getClassAnnotations(string $className, string|null $annotationClassName = null): array
     {
@@ -476,6 +416,13 @@ public function getClassAnnotations(string $className, string|null $annotationCl
      *
      * If multiple annotations are set on the target you will
      * get the first instance of them.
+     *
+     * @param class-string $className
+     * @param class-string $annotationClassName
+     * @return object|null
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      */
     public function getClassAnnotation(string $className, string $annotationClassName): ?object
     {
@@ -492,6 +439,7 @@ public function getClassAnnotation(string $className, string $annotationClassNam
      *
      * @throws ClassLoadingForReflectionFailedException
      * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function isClassImplementationOf(string $className, string $interfaceName): bool
@@ -507,6 +455,10 @@ public function isClassImplementationOf(string $className, string $interfaceName
     /**
      * Tells if the specified class is abstract or not
      *
+     * @param class-string $className
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function isClassAbstract(string $className): bool
@@ -518,8 +470,10 @@ public function isClassAbstract(string $className): bool
     /**
      * Tells if the specified class is final or not
      *
-     * @param string $className Name of the class to analyze
-     * @return bool true if the class is final, otherwise false
+     * @param class-string $className Name of the class to analyze
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function isClassFinal(string $className): bool
@@ -533,6 +487,9 @@ public function isClassFinal(string $className): bool
      *
      * @param string $className Name of the class to analyze
      * @return bool true if the class is readonly, otherwise false
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function isClassReadonly(string $className): bool
@@ -584,6 +541,12 @@ public function getMethodsAnnotatedWith(string $className, string $annotationCla
     /**
      * Tells if the specified method is final or not
      *
+     * @param string $className
+     * @param string $methodName
+     * @return bool
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function isMethodFinal(string $className, string $methodName): bool
@@ -595,6 +558,10 @@ public function isMethodFinal(string $className, string $methodName): bool
     /**
      * Tells if the specified method is declared as static or not
      *
+     * @param class-string $className
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function isMethodStatic(string $className, string $methodName): bool
@@ -604,8 +571,10 @@ public function isMethodStatic(string $className, string $methodName): bool
     }
 
     /**
-     * Tells if the specified method is public
-     *
+     * @param class-string $className
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function isMethodPublic(string $className, string $methodName): bool
@@ -615,8 +584,10 @@ public function isMethodPublic(string $className, string $methodName): bool
     }
 
     /**
-     * Tells if the specified method is protected
-     *
+     * @param class-string $className
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function isMethodProtected(string $className, string $methodName): bool
@@ -626,8 +597,10 @@ public function isMethodProtected(string $className, string $methodName): bool
     }
 
     /**
-     * Tells if the specified method is private
-     *
+     * @param class-string $className
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function isMethodPrivate(string $className, string $methodName): bool
@@ -639,7 +612,7 @@ public function isMethodPrivate(string $className, string $methodName): bool
     /**
      * Tells if the specified method is tagged with the given tag
      *
-     * @throws ReflectionException
+     * @throws \ReflectionException
      * @api
      */
     public function isMethodTaggedWith(string $className, string $methodName, string $tag): bool
@@ -664,7 +637,11 @@ public function isAttributeIgnored(string $attributeName): bool
     /**
      * Tells if the specified method has the given annotation
      *
-     * @throws ReflectionException
+     * @param class-string $className
+     * @param string $methodName
+     * @param class-string $annotationClassName
+     * @return bool
+     * @throws \ReflectionException
      * @api
      */
     public function isMethodAnnotatedWith(string $className, string $methodName, string $annotationClassName): bool
@@ -675,14 +652,11 @@ public function isMethodAnnotatedWith(string $className, string $methodName, str
     /**
      * Returns the specified method annotations or an empty array
      *
-     * @param string $className
-     * @param string $methodName
-     * @param null|string $annotationClassName
+     * @param class-string $className
+     * @param class-string|null $annotationClassName
      * @return array<object>
      *
-     * @throws FilesException
-     * @throws ReflectionException
-     * @throws \Neos\Flow\Utility\Exception
+     * @throws \ReflectionException
      * @api
      *
      */
@@ -727,7 +701,7 @@ public function getMethodAnnotations(string $className, string $methodName, stri
      * If multiple annotations are set on the target you will
      * get the first instance of them.
      *
-     * @throws ReflectionException
+     * @throws \ReflectionException
      */
     public function getMethodAnnotation(string $className, string $methodName, string $annotationClassName): ?object
     {
@@ -742,6 +716,11 @@ public function getMethodAnnotation(string $className, string $methodName, strin
     /**
      * Returns the names of all properties of the specified class
      *
+     * @param class-string $className
+     * @return array<string>
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function getClassPropertyNames(string $className): array
@@ -753,6 +732,10 @@ public function getClassPropertyNames(string $className): array
     /**
      * Wrapper for method_exists() which tells if the given method exists.
      *
+     * @param class-string $className
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function hasMethod(string $className, string $methodName): bool
@@ -764,8 +747,8 @@ public function hasMethod(string $className, string $methodName): bool
     /**
      * Returns all tags and their values the specified method is tagged with
      *
-     * @throws ReflectionException
-     * @api
+     * @throws \ReflectionException
+     * @deprecated since 8.4
      */
     public function getMethodTagsValues(string $className, string $methodName): array
     {
@@ -781,7 +764,11 @@ public function getMethodTagsValues(string $className, string $methodName): arra
      * Returns an array of parameters of the given method. Each entry contains
      * additional information about the parameter position, type hint etc.
      *
+     * @param class-string $className
      * @return array An array of parameter names and additional information or an empty array of no parameters were found
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function getMethodParameters(string $className, string $methodName): array
@@ -798,8 +785,10 @@ public function getMethodParameters(string $className, string $methodName): arra
      * Returns the declared return type of a method (for PHP < 7.0 this will always return null)
      *
      * @param class-string $className
-     * @return ?string The declared return type of the method or null if none was declared
-     *
+     * @return string|null The declared return type of the method or null if none was declared
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      */
     public function getMethodDeclaredReturnType(string $className, string $methodName): ?string
     {
@@ -811,9 +800,13 @@ public function getMethodDeclaredReturnType(string $className, string $methodNam
      * Searches for and returns all names of class properties which are tagged by the specified tag.
      * If no properties were found, an empty array is returned.
      *
+     * @param class-string $className
+     * @return array<string>
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      *
-     * @psalm-param 'id'|'var' $tag
      */
     public function getPropertyNamesByTag(string $className, string $tag): array
     {
@@ -835,9 +828,15 @@ public function getPropertyNamesByTag(string $className, string $tag): array
     /**
      * Returns all tags and their values the specified class property is tagged with
      *
+     * @param class-string $className
+     * @param string $propertyName
+     * @return array
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
-    public function getPropertyTagsValues(string $className, string $propertyName): mixed
+    public function getPropertyTagsValues(string $className, string $propertyName): array
     {
         $className = $this->prepareClassReflectionForUsage($className);
         if (!isset($this->classReflectionData[$className][self::DATA_CLASS_PROPERTIES][$propertyName])) {
@@ -850,11 +849,17 @@ public function getPropertyTagsValues(string $className, string $propertyName):
     /**
      * Returns the values of the specified class property tag
      *
+     * @param class-string $className
+     * @param string $propertyName
+     * @param string $tag
+     * @return array
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      *
-     * @psalm-param 'var' $tag
      */
-    public function getPropertyTagValues(string $className, string $propertyName, string $tag)
+    public function getPropertyTagValues(string $className, string $propertyName, string $tag): array
     {
         $className = $this->prepareClassReflectionForUsage($className);
         if (!isset($this->classReflectionData[$className][self::DATA_CLASS_PROPERTIES][$propertyName])) {
@@ -866,15 +871,27 @@ public function getPropertyTagValues(string $className, string $propertyName, st
 
     /**
      * Returns the property type
+     *
+     * @param class-string $className
+     * @param string $propertyName
+     * @return string|null
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      */
     public function getPropertyType(string $className, string $propertyName): ?string
     {
+        $className = $this->prepareClassReflectionForUsage($className);
         return $this->classReflectionData[$className][self::DATA_CLASS_PROPERTIES][$propertyName][self::DATA_PROPERTY_TYPE] ?? null;
     }
 
     /**
-     * Tells if the specified property is private
-     *
+     * @param class-string $className
+     * @param string $propertyName
+     * @return bool
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function isPropertyPrivate(string $className, string $propertyName): bool
@@ -898,6 +915,13 @@ public function isPropertyPromoted(string $className, string $propertyName): boo
     /**
      * Tells if the specified class property is tagged with the given tag
      *
+     * @param class-string $className
+     * @param string $propertyName
+     * @param string $tag
+     * @return bool
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function isPropertyTaggedWith(string $className, string $propertyName, string $tag): bool
@@ -909,6 +933,13 @@ public function isPropertyTaggedWith(string $className, string $propertyName, st
     /**
      * Tells if the specified property has the given annotation
      *
+     * @param class-string $className
+     * @param string $propertyName
+     * @param class-string $annotationClassName
+     * @return bool
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function isPropertyAnnotatedWith(string $className, string $propertyName, string $annotationClassName): bool
@@ -921,6 +952,12 @@ public function isPropertyAnnotatedWith(string $className, string $propertyName,
      * Searches for and returns all names of class properties which are marked by the
      * specified annotation. If no properties were found, an empty array is returned.
      *
+     * @param class-string $className
+     * @param class-string $annotationClassName
+     * @return array<string>
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function getPropertyNamesByAnnotation(string $className, string $annotationClassName): array
@@ -943,7 +980,13 @@ public function getPropertyNamesByAnnotation(string $className, string $annotati
     /**
      * Returns the specified property annotations or an empty array
      *
+     * @param class-string $className
+     * @param string $propertyName
+     * @param class-string|null $annotationClassName
      * @return array<object>
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      * @api
      */
     public function getPropertyAnnotations(string $className, string $propertyName, ?string $annotationClassName = null): array
@@ -957,11 +1000,7 @@ public function getPropertyAnnotations(string $className, string $propertyName,
             return $this->classReflectionData[$className][self::DATA_CLASS_PROPERTIES][$propertyName][self::DATA_PROPERTY_ANNOTATIONS];
         }
 
-        if (isset($this->classReflectionData[$className][self::DATA_CLASS_PROPERTIES][$propertyName][self::DATA_PROPERTY_ANNOTATIONS][$annotationClassName])) {
-            return $this->classReflectionData[$className][self::DATA_CLASS_PROPERTIES][$propertyName][self::DATA_PROPERTY_ANNOTATIONS][$annotationClassName];
-        }
-
-        return [];
+        return $this->classReflectionData[$className][self::DATA_CLASS_PROPERTIES][$propertyName][self::DATA_PROPERTY_ANNOTATIONS][$annotationClassName] ?? [];
     }
 
     /**
@@ -969,6 +1008,14 @@ public function getPropertyAnnotations(string $className, string $propertyName,
      *
      * If multiple annotations are set on the target you will
      * get the first instance of them.
+     *
+     * @param string $className
+     * @param string $propertyName
+     * @param string $annotationClassName
+     * @return object|null
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      */
     public function getPropertyAnnotation(string $className, string $propertyName, string $annotationClassName): ?object
     {
@@ -981,7 +1028,9 @@ public function getPropertyAnnotation(string $className, string $propertyName, s
 
     /**
      * Returns the class schema for the given class
-     * @param class-string|string|object $classNameOrObject
+     *
+     * @param class-string|object $classNameOrObject
+     * @return ClassSchema|null
      */
     public function getClassSchema(string|object $classNameOrObject): ?ClassSchema
     {
@@ -1005,6 +1054,12 @@ public function getClassSchema(string|object $classNameOrObject): ?ClassSchema
 
     /**
      * Initializes the ReflectionService, cleans the given class name and finally reflects the class if necessary.
+     *
+     * @param class-string $className
+     * @return string
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      */
     protected function prepareClassReflectionForUsage(string $className): string
     {
@@ -1026,14 +1081,17 @@ protected function prepareClassReflectionForUsage(string $className): string
      * @throws ClassSchemaConstraintViolationException
      * @throws Exception
      * @throws InvalidClassException
-     * @throws ReflectionException
+     * @throws InvalidPropertyTypeException
+     * @throws InvalidValueObjectException
+     * @throws \ReflectionException
      */
     protected function reflectEmergedClasses(): void
     {
-        $classNamesToReflect = [];
-        foreach ($this->availableClassNames as $classNamesInOnePackage) {
-            $classNamesToReflect = array_merge($classNamesToReflect, $classNamesInOnePackage);
+        $availableClassnames = [];
+        foreach ($this->availableClassNames as $classNamesInPackage) {
+            $availableClassnames[] = $classNamesInPackage;
         }
+        $classNamesToReflect = array_merge([], ...$availableClassnames);
         $reflectedClassNames = array_keys($this->classReflectionData);
         sort($classNamesToReflect);
         sort($reflectedClassNames);
@@ -1046,7 +1104,7 @@ protected function reflectEmergedClasses(): void
         $count = 0;
 
         $classNameFilterFunction = function ($className) use (&$count): bool {
-            $this->reflectClass($className);
+            $this->loadOrReflectClassIfNecessary($className);
             if (
                 !$this->isClassAnnotatedWith($className, Flow\Entity::class) &&
                 !$this->isClassAnnotatedWith($className, ORM\Entity::class) &&
@@ -1092,9 +1150,10 @@ protected function isTagIgnored(string $tagName): bool
     /**
      * Reflects the given class and stores the results in this service's properties.
      *
+     * @param class-string $className
      * @throws ClassLoadingForReflectionFailedException
      * @throws InvalidClassException
-     * @throws ReflectionException
+     * @throws \ReflectionException
      */
     protected function reflectClass(string $className): void
     {
@@ -1106,10 +1165,14 @@ protected function reflectClass(string $className): void
         }
 
         $class = new ClassReflection($className);
-        if (!isset($this->classReflectionData[$className])) {
+        if (!isset($this->classReflectionData[$className]) || !is_array($this->classReflectionData[$className])) {
             $this->classReflectionData[$className] = [];
         }
 
+        if (!isset($this->classReflectionData[$className][self::DATA_INTERFACE_IMPLEMENTATIONS]) && $class->isInterface()) {
+            $this->classReflectionData[$className][self::DATA_INTERFACE_IMPLEMENTATIONS] = [];
+        }
+
         if ($class->isAbstract() || $class->isInterface()) {
             $this->classReflectionData[$className][self::DATA_CLASS_ABSTRACT] = true;
         }
@@ -1154,7 +1217,6 @@ protected function reflectClass(string $className): void
         // important for comparisons when checking if classes have changed in a
         // Development context.
         ksort($this->classReflectionData);
-
         $this->updatedReflectionData[$className] = true;
     }
 
@@ -1173,7 +1235,7 @@ public function reflectClassProperty(string $className, PropertyReflection $prop
             $this->classReflectionData[$className][self::DATA_CLASS_PROPERTIES][$propertyName][self::DATA_PROPERTY_TYPE] = trim((string)$property->getType(), '?');
         }
 
-        $visibility = $property->isPublic() ? self::VISIBILITY_PUBLIC : ($property->isProtected() ? self::VISIBILITY_PROTECTED : self::VISIBILITY_PRIVATE);
+        $visibility = $this->extractVisibility($property);
         $this->classReflectionData[$className][self::DATA_CLASS_PROPERTIES][$propertyName][self::DATA_PROPERTY_VISIBILITY] = $visibility;
 
         if ($property->isPromoted()) {
@@ -1230,13 +1292,13 @@ protected function reflectPropertyTag(string $className, PropertyReflection $pro
     /**
      * @throws InvalidClassException
      * @throws ClassLoadingForReflectionFailedException
-     * @throws ReflectionException
+     * @throws \ReflectionException
      */
     protected function addParentClass(string $className, ClassReflection $parentClass): void
     {
         $parentClassName = $parentClass->getName();
-        if (!isset($this->classReflectionData[$parentClassName])) {
-            $this->reflectClass($parentClassName);
+        if (!$this->isClassReflected($parentClassName)) {
+            $this->loadOrReflectClassIfNecessary($parentClassName);
         }
         $this->classReflectionData[$parentClassName][self::DATA_CLASS_SUBCLASSES][$className] = true;
     }
@@ -1244,7 +1306,7 @@ protected function addParentClass(string $className, ClassReflection $parentClas
     /**
      * @throws ClassLoadingForReflectionFailedException
      * @throws InvalidClassException
-     * @throws ReflectionException
+     * @throws \ReflectionException
      */
     protected function addImplementedInterface(string $className, ClassReflection $interface): void
     {
@@ -1253,16 +1315,17 @@ protected function addImplementedInterface(string $className, ClassReflection $i
         }
 
         $interfaceName = $interface->getName();
-        if (!isset($this->classReflectionData[$interfaceName])) {
-            $this->reflectClass($interfaceName);
+        if (!$this->isClassReflected($interfaceName)) {
+            $this->loadOrReflectClassIfNecessary($interfaceName);
         }
+
         $this->classReflectionData[$interfaceName][self::DATA_INTERFACE_IMPLEMENTATIONS][$className] = true;
     }
 
     /**
-     * @throws FilesException
-     * @throws ReflectionException
-     * @throws \Neos\Flow\Utility\Exception
+     * @param class-string $className
+     * @param MethodReflection $method
+     * @throws \ReflectionException
      */
     protected function reflectClassMethod(string $className, MethodReflection $method): void
     {
@@ -1273,8 +1336,7 @@ protected function reflectClassMethod(string $className, MethodReflection $metho
         if ($method->isStatic()) {
             $this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName][self::DATA_METHOD_STATIC] = true;
         }
-        $visibility = $method->isPublic() ? self::VISIBILITY_PUBLIC : ($method->isProtected() ? self::VISIBILITY_PROTECTED : self::VISIBILITY_PRIVATE);
-        $this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName][self::DATA_METHOD_VISIBILITY] = $visibility;
+        $this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName][self::DATA_METHOD_VISIBILITY] = $this->extractVisibility($method);
 
         foreach ($this->getMethodAnnotations($className, $methodName) as $methodAnnotation) {
             $annotationClassName = get_class($methodAnnotation);
@@ -1312,11 +1374,17 @@ protected function reflectClassMethod(string $className, MethodReflection $metho
         }
     }
 
+    protected function extractVisibility(MethodReflection|PropertyReflection $reflection): int
+    {
+        return match (true) {
+            $reflection->isPublic() => self::VISIBILITY_PUBLIC,
+            $reflection->isProtected() => self::VISIBILITY_PROTECTED,
+            default => self::VISIBILITY_PRIVATE
+        };
+    }
+
     /**
-     * @param string $className
-     * @param MethodReflection $method
-     * @param ParameterReflection $parameter
-     * @return void
+     * @param class-string $className
      */
     protected function reflectClassMethodParameter(string $className, MethodReflection $method, ParameterReflection $parameter): void
     {
@@ -1422,11 +1490,14 @@ protected function getParentClasses(ClassReflection $class, array $parentClasses
     /**
      * Builds class schemata from classes annotated as entities or value objects
      *
+     * @param array<int,class-string> $classNames
      * @throws ClassLoadingForReflectionFailedException
      * @throws ClassSchemaConstraintViolationException
      * @throws Exception
      * @throws InvalidClassException
+     * @throws InvalidPropertyTypeException
      * @throws InvalidValueObjectException
+     * @throws \ReflectionException
      */
     protected function buildClassSchemata(array $classNames): void
     {
@@ -1441,9 +1512,12 @@ protected function buildClassSchemata(array $classNames): void
     /**
      * @param class-string $className
      * @return ClassSchema
+     * @throws ClassLoadingForReflectionFailedException
      * @throws ClassSchemaConstraintViolationException
+     * @throws InvalidClassException
      * @throws InvalidPropertyTypeException
      * @throws InvalidValueObjectException
+     * @throws \ReflectionException
      */
     protected function buildClassSchema(string $className): ClassSchema
     {
@@ -1481,8 +1555,12 @@ protected function buildClassSchema(string $className): ClassSchema
      *
      * Invalid annotations will cause an exception to be thrown.
      *
-     * @throws InvalidPropertyTypeException
+     * @param ClassSchema $classSchema
+     * @throws ClassLoadingForReflectionFailedException
      * @throws ClassSchemaConstraintViolationException
+     * @throws InvalidClassException
+     * @throws InvalidPropertyTypeException
+     * @throws \ReflectionException
      */
     protected function addPropertiesToClassSchema(ClassSchema $classSchema): void
     {
@@ -1507,9 +1585,14 @@ protected function addPropertiesToClassSchema(ClassSchema $classSchema): void
     }
 
     /**
-     * @throws InvalidPropertyTypeException
-     * @throws \InvalidArgumentException
+     * @param ClassSchema $classSchema
+     * @param string $propertyName
+     * @return bool
+     * @throws ClassLoadingForReflectionFailedException
      * @throws ClassSchemaConstraintViolationException
+     * @throws InvalidClassException
+     * @throws InvalidPropertyTypeException
+     * @throws \ReflectionException
      */
     protected function evaluateClassPropertyAnnotationsForSchema(ClassSchema $classSchema, string $propertyName): bool
     {
@@ -1566,6 +1649,7 @@ protected function evaluateClassPropertyAnnotationsForSchema(ClassSchema $classS
      * @throws ClassLoadingForReflectionFailedException
      * @throws ClassSchemaConstraintViolationException
      * @throws InvalidClassException
+     * @throws \ReflectionException
      */
     protected function completeRepositoryAssignments(): void
     {
@@ -1597,9 +1681,11 @@ protected function completeRepositoryAssignments(): void
      * Assigns the repository of any aggregate root to all it's
      * subclasses, unless they are aggregate root already.
      *
+     * @param ClassSchema $classSchema
      * @throws ClassLoadingForReflectionFailedException
      * @throws ClassSchemaConstraintViolationException
      * @throws InvalidClassException
+     * @throws \ReflectionException
      */
     protected function makeChildClassesAggregateRoot(ClassSchema $classSchema): void
     {
@@ -1617,7 +1703,10 @@ protected function makeChildClassesAggregateRoot(ClassSchema $classSchema): void
      * Checks whether all aggregate roots having superclasses
      * have a repository assigned up to the tip of their hierarchy.
      *
+     * @throws ClassLoadingForReflectionFailedException
      * @throws Exception
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      */
     protected function ensureAggregateRootInheritanceChainConsistency(): void
     {
@@ -1651,7 +1740,7 @@ protected function checkValueObjectRequirements(string $className): void
             throw new InvalidValueObjectException('A value object must have a constructor, "' . $className . '" does not have one.', 1268740874);
         }
 
-        $setterMethods = array_filter($methods, function ($method) {
+        $setterMethods = array_filter($methods, static function ($method) {
             return str_starts_with($method, 'set');
         });
 
@@ -1751,29 +1840,15 @@ protected function convertParameterReflectionToArray(ParameterReflection $parame
      * accordingly.
      *
      * @return void
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      */
     protected function forgetChangedClasses(): void
     {
-        $frozenNamespaces = [];
-        foreach ($this->packageManager->getAvailablePackages() as $packageKey => $package) {
-            if ($this->packageManager->isPackageFrozen($packageKey)) {
-                $frozenNamespaces = array_merge($frozenNamespaces, $package->getNamespaces());
-            }
-        }
-        $frozenNamespaces = array_unique($frozenNamespaces);
-
         $classNames = array_keys($this->classReflectionData);
-        foreach ($frozenNamespaces as $namespace) {
-            $namespace .= '\\';
-            foreach ($classNames as $index => $className) {
-                if (str_starts_with($className, $namespace)) {
-                    unset($classNames[$index]);
-                }
-            }
-        }
-
         foreach ($classNames as $className) {
-            if (!$this->statusCache->has($this->produceCacheIdentifierFromClassName($className))) {
+            if (is_string($className) && !$this->reflectionDataRuntimeCache->has($this->produceCacheIdentifierFromClassName($className))) {
                 $this->forgetClass($className);
             }
         }
@@ -1782,11 +1857,13 @@ protected function forgetChangedClasses(): void
     /**
      * Forgets all reflection data related to the specified class
      *
-     * @param (int|string) $className
+     * @param class-string $className
      *
-     * @psalm-param array-key $className
+     * @throws ClassLoadingForReflectionFailedException
+     * @throws InvalidClassException
+     * @throws \ReflectionException
      */
-    protected function forgetClass($className): void
+    private function forgetClass(string $className): void
     {
         $this->log('Forget class ' . $className, LogLevel::DEBUG);
         if (isset($this->classesCurrentlyBeingForgotten[$className])) {
@@ -1798,6 +1875,7 @@ protected function forgetClass($className): void
         if (class_exists($className)) {
             $interfaceNames = class_implements($className);
             foreach ($interfaceNames as $interfaceName) {
+                $this->loadOrReflectClassIfNecessary($interfaceName);
                 if (isset($this->classReflectionData[$interfaceName][self::DATA_INTERFACE_IMPLEMENTATIONS][$className])) {
                     unset($this->classReflectionData[$interfaceName][self::DATA_INTERFACE_IMPLEMENTATIONS][$className]);
                 }
@@ -1805,6 +1883,7 @@ protected function forgetClass($className): void
         } else {
             foreach ($this->availableClassNames as $interfaceNames) {
                 foreach ($interfaceNames as $interfaceName) {
+                    $this->loadOrReflectClassIfNecessary($interfaceName);
                     if (isset($this->classReflectionData[$interfaceName][self::DATA_INTERFACE_IMPLEMENTATIONS][$className])) {
                         unset($this->classReflectionData[$interfaceName][self::DATA_INTERFACE_IMPLEMENTATIONS][$className]);
                     }
@@ -1814,7 +1893,7 @@ protected function forgetClass($className): void
 
         if (isset($this->classReflectionData[$className][self::DATA_CLASS_SUBCLASSES])) {
             foreach (array_keys($this->classReflectionData[$className][self::DATA_CLASS_SUBCLASSES]) as $subClassName) {
-                $this->forgetClass($subClassName);
+                $this->forgetClass((string)$subClassName);
             }
         }
 
@@ -1824,6 +1903,7 @@ protected function forgetClass($className): void
             }
         }
 
+        $this->getClassSchema($className);
         if (isset($this->classSchemata[$className])) {
             unset($this->classSchemata[$className]);
         }
@@ -1832,59 +1912,7 @@ protected function forgetClass($className): void
             unset($this->classesByMethodAnnotations[$annotationClassName][$className]);
         }
 
-        unset($this->classReflectionData[$className]);
-        unset($this->classesCurrentlyBeingForgotten[$className]);
-    }
-
-    /**
-     * Tries to load the reflection data from the compile time cache.
-     *
-     * The compile time cache is only supported for Development context and thus
-     * this function will return in any other context.
-     *
-     * If no reflection data was found, this method will at least load the precompiled
-     * reflection data of any possible frozen package. Even if precompiled reflection
-     * data could be loaded, false will be returned in order to signal that other
-     * packages still need to be reflected.
-     *
-     * @return bool true if reflection data could be loaded, otherwise false
-     * @throws FilesException
-     * @throws \Neos\Flow\Utility\Exception
-     */
-    protected function loadClassReflectionCompiletimeCache(): bool
-    {
-        $data = $this->reflectionDataCompiletimeCache->get('ReflectionData');
-
-        if ($data !== false) {
-            foreach ($data as $propertyName => $propertyValue) {
-                $this->$propertyName = $propertyValue;
-            }
-
-            return true;
-        }
-
-        if (!$this->context->isDevelopment()) {
-            return false;
-        }
-
-        $useIgBinary = extension_loaded('igbinary');
-        foreach ($this->packageManager->getAvailablePackages() as $packageKey => $package) {
-            if (!$this->packageManager->isPackageFrozen($packageKey)) {
-                continue;
-            }
-
-            $pathAndFilename = $this->getPrecompiledReflectionStoragePath() . $packageKey . '.dat';
-            if (!file_exists($pathAndFilename)) {
-                continue;
-            }
-
-            $data = ($useIgBinary ? igbinary_unserialize(file_get_contents($pathAndFilename)) : unserialize(file_get_contents($pathAndFilename)));
-            foreach ($data as $propertyName => $propertyValue) {
-                $this->$propertyName = Arrays::arrayMergeRecursiveOverrule($this->$propertyName, $propertyValue);
-            }
-        }
-
-        return false;
+        unset($this->classReflectionData[$className], $this->classesCurrentlyBeingForgotten[$className]);
     }
 
     /**
@@ -1897,161 +1925,45 @@ protected function loadClassReflectionCompiletimeCache(): bool
      * In Production context, with frozen caches, this method will load reflection
      * data for the specified class from the runtime cache.
      *
+     * @param class-string $className
      * @throws ClassLoadingForReflectionFailedException
      * @throws InvalidClassException
-     * @throws ReflectionException
+     * @throws \ReflectionException
      */
-    protected function loadOrReflectClassIfNecessary(string $className): void
+    private function loadOrReflectClassIfNecessary(string $className): void
     {
-        if (!isset($this->classReflectionData[$className]) || is_array($this->classReflectionData[$className])) {
+        if ($this->isClassReflected($className)) {
             return;
         }
 
-        if ($this->loadFromClassSchemaRuntimeCache === true) {
-            $this->classReflectionData[$className] = $this->reflectionDataRuntimeCache->get($this->produceCacheIdentifierFromClassName($className));
+        $this->classReflectionData[$className] = $this->reflectionDataRuntimeCache->get($this->produceCacheIdentifierFromClassName($className));
 
+        if ($this->isClassReflected($className)) {
             return;
         }
 
         $this->reflectClass($className);
     }
 
-    /**
-     * Stores the current reflection data related to classes of the specified package
-     * in the PrecompiledReflectionData directory for the current context.
-     *
-     * This method is used by the package manager.
-     *
-     * @param (int|string) $packageKey
-     *
-     * @psalm-param array-key $packageKey
-     */
-    public function freezePackageReflection($packageKey): void
-    {
-        if (!$this->initialized) {
-            $this->initialize();
-        }
-        if (empty($this->availableClassNames)) {
-            $this->availableClassNames = $this->reflectionDataRuntimeCache->get('__availableClassNames');
-        }
-
-        $reflectionData = [
-            'classReflectionData' => $this->classReflectionData,
-            'classSchemata' => $this->classSchemata,
-            'annotatedClasses' => $this->annotatedClasses,
-            'classesByMethodAnnotations' => $this->classesByMethodAnnotations
-        ];
-
-        $reflectionData['classReflectionData'] = $this->filterArrayByClassesInPackageNamespace($reflectionData['classReflectionData'], $packageKey);
-        $reflectionData['classSchemata'] = $this->filterArrayByClassesInPackageNamespace($reflectionData['classSchemata'], $packageKey);
-        $reflectionData['annotatedClasses'] = $this->filterArrayByClassesInPackageNamespace($reflectionData['annotatedClasses'], $packageKey);
-
-        $methodAnnotationsFilters = function ($className) use ($packageKey): bool {
-            return (isset($this->availableClassNames[$packageKey]) && in_array($className, $this->availableClassNames[$packageKey], true));
-        };
-
-        foreach ($reflectionData['classesByMethodAnnotations'] as $annotationClassName => $classNames) {
-            $reflectionData['classesByMethodAnnotations'][$annotationClassName] = array_filter($classNames, $methodAnnotationsFilters);
-        }
-
-        $precompiledReflectionStoragePath = $this->getPrecompiledReflectionStoragePath();
-        if (!is_dir($precompiledReflectionStoragePath)) {
-            Files::createDirectoryRecursively($precompiledReflectionStoragePath);
-        }
-        $pathAndFilename = $precompiledReflectionStoragePath . $packageKey . '.dat';
-        file_put_contents($pathAndFilename, extension_loaded('igbinary') ? igbinary_serialize($reflectionData) : serialize($reflectionData));
-    }
-
-    /**
-     * Filter an array of entries where keys are class names by being in the given package namespace.
-     *
-     * @param int|string $packageKey
-     *
-     * @psalm-param array-key $packageKey
-     */
-    protected function filterArrayByClassesInPackageNamespace(array $array, $packageKey): array
-    {
-        return array_filter($array, function ($className) use ($packageKey) {
-            return (isset($this->availableClassNames[$packageKey]) && in_array($className, $this->availableClassNames[$packageKey], true));
-        }, ARRAY_FILTER_USE_KEY);
-    }
-
-    /**
-     * Removes the precompiled reflection data of a frozen package
-     *
-     * This method is used by the package manager.
-     *
-     * @throws FilesException
-     * @throws \Neos\Flow\Utility\Exception
-     */
-    public function unfreezePackageReflection(string $packageKey): void
-    {
-        if (!$this->initialized) {
-            $this->initialize();
-        }
-        $pathAndFilename = $this->getPrecompiledReflectionStoragePath() . $packageKey . '.dat';
-        if (file_exists($pathAndFilename)) {
-            unlink($pathAndFilename);
-        }
-    }
-
     /**
      * Exports the internal reflection data into the ReflectionData cache
      *
      * This method is triggered by a signal which is connected to the bootstrap's
      * shutdown sequence.
      *
-     * If the reflection data has previously been loaded from the runtime cache,
-     * saving it is omitted as changes are not expected.
-     *
-     * In Production context the whole cache is written at once and then frozen in
-     * order to be consistent. Frozen cache data in Development is only produced for
-     * classes contained in frozen packages.
      * @throws Exception
      */
     public function saveToCache(): void
     {
-        if ($this->hasFrozenCacheInProduction()) {
+        if (empty($this->updatedReflectionData)) {
             return;
         }
+
         if (!$this->initialized) {
             $this->initialize();
         }
-        if ($this->loadFromClassSchemaRuntimeCache === true) {
-            return;
-        }
-
-        if (!empty($this->availableClassNames)) {
-            $this->reflectionDataRuntimeCache->set('__availableClassNames', $this->availableClassNames);
-        }
-
-        if ($this->updatedReflectionData !== []) {
-            $this->updateReflectionData();
-        }
 
-        if ($this->context->isProduction()) {
-            $this->saveProductionData();
-            return;
-        }
-
-        $this->saveDevelopmentData();
-    }
-
-    /**
-     * Save reflection data to cache in Development context.
-     *
-     * @throws FilesException
-     * @throws \Neos\Flow\Utility\Exception
-     */
-    protected function saveDevelopmentData(): void
-    {
-        foreach (array_keys($this->packageManager->getFrozenPackages()) as $packageKey) {
-            $pathAndFilename = $this->getPrecompiledReflectionStoragePath() . $packageKey . '.dat';
-            if (!file_exists($pathAndFilename)) {
-                $this->log(sprintf('Rebuilding precompiled reflection data for frozen package %s.', $packageKey), LogLevel::DEBUG);
-                $this->freezePackageReflection($packageKey);
-            }
-        }
+        $this->updateCacheEntries();
     }
 
     /**
@@ -2059,59 +1971,29 @@ protected function saveDevelopmentData(): void
      *
      * @throws Exception
      */
-    protected function saveProductionData(): void
+    private function updateCacheEntries(): void
     {
-        $this->reflectionDataRuntimeCache->flush();
-        $this->classSchemataRuntimeCache->flush();
-
         $classNames = [];
         foreach ($this->classReflectionData as $className => $reflectionData) {
-            $classNames[$className] = true;
+            if ($this->isClassReflected($className)) {
+                $classNames[$className] = true;
+            }
+        }
+
+        foreach (array_keys($this->updatedReflectionData) as $className) {
+            $reflectionData = $this->classReflectionData[$className];
             $cacheIdentifier = $this->produceCacheIdentifierFromClassName($className);
             $this->reflectionDataRuntimeCache->set($cacheIdentifier, $reflectionData);
             if (isset($this->classSchemata[$className])) {
                 $this->classSchemataRuntimeCache->set($cacheIdentifier, $this->classSchemata[$className]);
             }
         }
+
         $this->reflectionDataRuntimeCache->set('__classNames', $classNames);
         $this->reflectionDataRuntimeCache->set('__annotatedClasses', $this->annotatedClasses);
+        $this->reflectionDataRuntimeCache->set('__classesByMethodAnnotations', $this->classesByMethodAnnotations);
 
-        if ($this->reflectionDataRuntimeCache->getBackend() instanceof FreezableBackendInterface) {
-            $this->reflectionDataRuntimeCache->getBackend()->freeze();
-        }
-        if ($this->classSchemataRuntimeCache->getBackend() instanceof FreezableBackendInterface) {
-            $this->classSchemataRuntimeCache->getBackend()->freeze();
-        }
-
-        $this->log(sprintf('Built and froze reflection runtime caches (%s classes).', count($this->classReflectionData)), LogLevel::INFO);
-    }
-
-    /**
-     * Set updated reflection data to caches.
-     *
-     * @throws Exception
-     */
-    protected function updateReflectionData(): void
-    {
-        $this->log(sprintf('Found %s classes whose reflection data was not cached previously.', count($this->updatedReflectionData)), LogLevel::DEBUG);
-
-        foreach (array_keys($this->updatedReflectionData) as $className) {
-            $this->statusCache->set($this->produceCacheIdentifierFromClassName($className), '');
-        }
-
-        $data = [];
-        $propertyNames = [
-            'classReflectionData',
-            'classSchemata',
-            'annotatedClasses',
-            'classesByMethodAnnotations'
-        ];
-
-        foreach ($propertyNames as $propertyName) {
-            $data[$propertyName] = $this->$propertyName;
-        }
-
-        $this->reflectionDataCompiletimeCache->set('ReflectionData', $data);
+        $this->log(sprintf('Updated reflection caches (%s classes).', count($this->updatedReflectionData)));
     }
 
     /**
@@ -2139,37 +2021,24 @@ protected function log(string $message, string $severity = LogLevel::INFO, array
     }
 
     /**
-     * @throws \Neos\Flow\Utility\Exception
-     * @throws FilesException
+     * @param \ReflectionType|null $parameterType
+     * @return string|null
      */
-    protected function getPrecompiledReflectionStoragePath(): string
-    {
-        return Files::concatenatePaths([$this->environment->getPathToTemporaryDirectory(), 'PrecompiledReflectionData/']) . '/';
-    }
-
-    protected function hasFrozenCacheInProduction(): bool
-    {
-        return $this->environment->getContext()->isProduction()
-            && $this->reflectionDataRuntimeCache->getBackend() instanceof FreezableBackendInterface
-            && $this->reflectionDataRuntimeCache->getBackend()->isFrozen();
-    }
-
-    private function renderParameterType(?\ReflectionType $parameterType): ?string
+    private function renderParameterType(?\ReflectionType $parameterType = null): string|null
     {
-        $that = $this;
         return match (true) {
             $parameterType instanceof \ReflectionUnionType => implode('|', array_map(
-                static function (\ReflectionNamedType | \ReflectionIntersectionType $type) use ($that) {
-                    if ($type instanceof  \ReflectionNamedType) {
+                function (\ReflectionNamedType|\ReflectionIntersectionType $type) {
+                    if ($type instanceof \ReflectionNamedType) {
                         return $type->getName();
                     }
-                    return '(' . $that->renderParameterType($type) . ')';
+                    return '(' . $this->renderParameterType($type) . ')';
                 },
                 $parameterType->getTypes()
             )),
             $parameterType instanceof \ReflectionIntersectionType => implode('&', array_map(
-                static function (\ReflectionNamedType $type) use ($that) {
-                    return $that->renderParameterType($type);
+                function (\ReflectionNamedType $type) {
+                    return $this->renderParameterType($type);
                 },
                 $parameterType->getTypes()
             )),
diff --git a/Neos.Flow/Classes/Reflection/ReflectionServiceFactory.php b/Neos.Flow/Classes/Reflection/ReflectionServiceFactory.php
index c86ead9de3..e3e5ed1429 100644
--- a/Neos.Flow/Classes/Reflection/ReflectionServiceFactory.php
+++ b/Neos.Flow/Classes/Reflection/ReflectionServiceFactory.php
@@ -16,8 +16,6 @@
 use Neos\Flow\Configuration\ConfigurationManager;
 use Neos\Flow\Core\Bootstrap;
 use Neos\Flow\Log\PsrLoggerFactoryInterface;
-use Neos\Flow\Package\PackageManager;
-use Neos\Flow\Utility\Environment;
 
 /**
  * Factory for getting an reflection service instance.
@@ -64,12 +62,8 @@ public function create(): ReflectionService
         $reflectionService = new ReflectionService();
         $reflectionService->injectLogger($this->bootstrap->getEarlyInstance(PsrLoggerFactoryInterface::class)->get('systemLogger'));
         $reflectionService->injectSettings($settings);
-        $reflectionService->injectPackageManager($this->bootstrap->getEarlyInstance(PackageManager::class));
-        $reflectionService->setStatusCache($cacheManager->getCache('Flow_Reflection_Status'));
-        $reflectionService->setReflectionDataCompiletimeCache($cacheManager->getCache('Flow_Reflection_CompiletimeData'));
         $reflectionService->setReflectionDataRuntimeCache($cacheManager->getCache('Flow_Reflection_RuntimeData'));
         $reflectionService->setClassSchemataRuntimeCache($cacheManager->getCache('Flow_Reflection_RuntimeClassSchemata'));
-        $reflectionService->injectEnvironment($this->bootstrap->getEarlyInstance(Environment::class));
 
         $this->reflectionService = $reflectionService;
         return $reflectionService;
diff --git a/Neos.Flow/Configuration/Caches.yaml b/Neos.Flow/Configuration/Caches.yaml
index 839b42e41f..dacf32662f 100644
--- a/Neos.Flow/Configuration/Caches.yaml
+++ b/Neos.Flow/Configuration/Caches.yaml
@@ -95,16 +95,23 @@ Flow_Persistence_Doctrine_Results:
 Flow_Persistence_Doctrine_SecondLevel:
   backend: Neos\Cache\Backend\SimpleFileBackend
 
-# Flow_Reflection*
 #
+# DEPRECATED since 8.4
+# These caches will be removed in 9.0, they are unused so you can safely remove any configuration for them.
 #
 Flow_Reflection_Status:
   frontend: Neos\Cache\Frontend\StringFrontend
   backend: Neos\Cache\Backend\SimpleFileBackend
 Flow_Reflection_CompiletimeData:
   backend: Neos\Cache\Backend\SimpleFileBackend
-Flow_Reflection_RuntimeData: []
-Flow_Reflection_RuntimeClassSchemata: []
+
+# Flow_Reflection
+#
+#
+Flow_Reflection_RuntimeData:
+  backend: Neos\Cache\Backend\SimpleFileBackend
+Flow_Reflection_RuntimeClassSchemata:
+  backend: Neos\Cache\Backend\SimpleFileBackend
 
 # Flow_Resource_Status
 #
diff --git a/Neos.Flow/Tests/Functional/Reflection/ReflectionServiceTest.php b/Neos.Flow/Tests/Functional/Reflection/ReflectionServiceTest.php
index d16128b2f2..7b15423afb 100644
--- a/Neos.Flow/Tests/Functional/Reflection/ReflectionServiceTest.php
+++ b/Neos.Flow/Tests/Functional/Reflection/ReflectionServiceTest.php
@@ -57,6 +57,7 @@ public function classSchemaCanBeBuiltForAggregateRootsWithPlainOldPhpBaseClasses
     /**
      * @test
      * @throws
+     * @deprecated since 8.4
      */
     public function theReflectionServiceCorrectlyBuildsMethodTagsValues(): void
     {
diff --git a/Neos.Flow/Tests/Unit/Cache/CacheManagerTest.php b/Neos.Flow/Tests/Unit/Cache/CacheManagerTest.php
index 232e8e577a..5401b60a91 100644
--- a/Neos.Flow/Tests/Unit/Cache/CacheManagerTest.php
+++ b/Neos.Flow/Tests/Unit/Cache/CacheManagerTest.php
@@ -277,7 +277,7 @@ public function flushSystemCachesByChangedFilesWithChangedClassFileRemovesCacheE
     {
         $objectClassCache = $this->registerCache('Flow_Object_Classes');
         $objectConfigurationCache = $this->registerCache('Flow_Object_Configuration');
-        $this->registerCache('Flow_Reflection_Status');
+        $this->registerCache('Flow_Reflection_RuntimeData');
 
         $objectClassCache->expects(self::once())->method('remove')->with('Neos_Flow_Cache_CacheManager');
         $objectConfigurationCache->expects(self::once())->method('remove')->with('allCompiledCodeUpToDate');
@@ -294,7 +294,7 @@ public function flushSystemCachesByChangedFilesWithChangedTestFileRemovesCacheEn
     {
         $objectClassCache = $this->registerCache('Flow_Object_Classes');
         $objectConfigurationCache = $this->registerCache('Flow_Object_Configuration');
-        $this->registerCache('Flow_Reflection_Status');
+        $this->registerCache('Flow_Reflection_RuntimeData');
 
         $objectClassCache->expects(self::once())->method('remove')->with('Neos_Flow_Tests_Unit_Cache_CacheManagerTest');
         $objectConfigurationCache->expects(self::once())->method('remove')->with('allCompiledCodeUpToDate');
diff --git a/Neos.Flow/Tests/Unit/Package/PackageManagerTest.php b/Neos.Flow/Tests/Unit/Package/PackageManagerTest.php
index 60caf74770..103f239643 100644
--- a/Neos.Flow/Tests/Unit/Package/PackageManagerTest.php
+++ b/Neos.Flow/Tests/Unit/Package/PackageManagerTest.php
@@ -472,36 +472,4 @@ public function createPackageEmitsPackageStatesUpdatedSignal()
         $this->mockDispatcher->expects(self::once())->method('dispatch')->with(PackageManager::class, 'packageStatesUpdated');
         $this->packageManager->createPackage('Some.Package', [], 'vfs://Test/Packages/Application');
     }
-
-    /**
-     * @test
-     */
-    public function freezePackageEmitsPackageStatesUpdatedSignal()
-    {
-        $this->mockApplicationContext->expects(self::atLeastOnce())->method('isDevelopment')->will(self::returnValue(true));
-
-        $this->packageManager->createPackage('Some.Package', [
-            'name' => 'some/package'
-        ], 'vfs://Test/Packages/Application');
-
-        $this->mockDispatcher->expects(self::once())->method('dispatch')->with(PackageManager::class, 'packageStatesUpdated');
-        $this->packageManager->freezePackage('Some.Package');
-    }
-
-    /**
-     * @test
-     */
-    public function unfreezePackageEmitsPackageStatesUpdatedSignal()
-    {
-        $this->mockApplicationContext->expects(self::atLeastOnce())->method('isDevelopment')->will(self::returnValue(true));
-
-        $this->packageManager->createPackage('Some.Package', [
-            'name' => 'some/package',
-            'type' => 'neos-package'
-        ], 'vfs://Test/Packages/Application');
-        $this->packageManager->freezePackage('Some.Package');
-
-        $this->mockDispatcher->expects(self::once())->method('dispatch')->with(PackageManager::class, 'packageStatesUpdated');
-        $this->packageManager->unfreezePackage('Some.Package');
-    }
 }
diff --git a/Neos.FluidAdaptor/Classes/Package.php b/Neos.FluidAdaptor/Classes/Package.php
index 9f6a9cd540..84a32d31ed 100644
--- a/Neos.FluidAdaptor/Classes/Package.php
+++ b/Neos.FluidAdaptor/Classes/Package.php
@@ -48,10 +48,6 @@ public function boot(Bootstrap $bootstrap)
                     $packageManager = $bootstrap->getEarlyInstance(PackageManager::class);
                     /** @var FlowPackageInterface $package */
                     foreach ($packageManager->getFlowPackages() as $packageKey => $package) {
-                        if ($packageManager->isPackageFrozen($packageKey)) {
-                            continue;
-                        }
-
                         foreach (['Templates', 'Partials', 'Layouts'] as $path) {
                             $templatesPath = $package->getResourcesPath() . 'Private/' . $path;