diff --git a/src/Tokenizer/src/Bootloader/TokenizerListenerBootloader.php b/src/Tokenizer/src/Bootloader/TokenizerListenerBootloader.php
index 4880253ed..07d73832f 100644
--- a/src/Tokenizer/src/Bootloader/TokenizerListenerBootloader.php
+++ b/src/Tokenizer/src/Bootloader/TokenizerListenerBootloader.php
@@ -56,20 +56,11 @@ public function addListener(TokenizationListenerInterface $listener): void
         $this->listeners[] = $listener;
     }
 
-    public function boot(AbstractKernel $kernel, TokenizerConfig $config): void
+    public function boot(AbstractKernel $kernel): void
     {
-        if ($config->isLoadClassesEnabled()) {
-            $kernel->booted($this->loadClasses(...));
-        }
-
-        if ($config->isLoadEnumsEnabled()) {
-            $kernel->booted($this->loadEnums(...));
-        }
-
-        if ($config->isLoadInterfacesEnabled()) {
-            $kernel->booted($this->loadInterfaces(...));
-        }
-
+        $kernel->booted($this->loadClasses(...));
+        $kernel->booted($this->loadEnums(...));
+        $kernel->booted($this->loadInterfaces(...));
         $kernel->booted($this->finalizeListeners(...));
     }
 
@@ -130,27 +121,36 @@ private function makeCachedLoader(
     }
 
     private function loadClasses(
+        TokenizerConfig $config,
         ClassesInterface $classes,
         ClassesLoaderInterface $loader,
         ListenerInvoker $invoker,
     ): void {
-        $this->loadReflections($invoker, $classes->getClasses(...), $loader->loadClasses(...));
+        if ($config->isLoadClassesEnabled()) {
+            $this->loadReflections($invoker, $classes->getClasses(...), $loader->loadClasses(...));
+        }
     }
 
     private function loadEnums(
+        TokenizerConfig $config,
         EnumsInterface $enums,
         EnumsLoaderInterface $loader,
         ListenerInvoker $invoker,
     ): void {
-        $this->loadReflections($invoker, $enums->getEnums(...), $loader->loadEnums(...));
+        if ($config->isLoadEnumsEnabled()) {
+            $this->loadReflections($invoker, $enums->getEnums(...), $loader->loadEnums(...));
+        }
     }
 
     private function loadInterfaces(
+        TokenizerConfig $config,
         InterfacesInterface $interfaces,
         InterfacesLoaderInterface $loader,
         ListenerInvoker $invoker,
     ): void {
-        $this->loadReflections($invoker, $interfaces->getInterfaces(...), $loader->loadInterfaces(...));
+        if ($config->isLoadInterfacesEnabled()) {
+            $this->loadReflections($invoker, $interfaces->getInterfaces(...), $loader->loadInterfaces(...));
+        }
     }
 
     /**
diff --git a/src/Tokenizer/tests/Bootloader/TokenizerListenerBootloaderTest.php b/src/Tokenizer/tests/Bootloader/TokenizerListenerBootloaderTest.php
index 5d8f815ff..933ada4fa 100644
--- a/src/Tokenizer/tests/Bootloader/TokenizerListenerBootloaderTest.php
+++ b/src/Tokenizer/tests/Bootloader/TokenizerListenerBootloaderTest.php
@@ -14,6 +14,7 @@
 use Spiral\Boot\MemoryInterface;
 use Spiral\Core\Container;
 use Spiral\Core\FactoryInterface;
+use Spiral\Tests\Tokenizer\Fixtures\TestCoreWithTokenizer;
 use Spiral\Tokenizer\Bootloader\TokenizerListenerBootloader;
 use Spiral\Tokenizer\ClassesInterface;
 use Spiral\Tokenizer\Config\TokenizerConfig;
@@ -267,6 +268,19 @@ public function testCastingReadCacheEnvVariable(mixed $readCache, bool $expected
         $this->assertSame($expected, (new \ReflectionProperty($interfaceLoader, 'readCache'))->getValue($interfaceLoader));
     }
 
+    public function testAddDirectoryInBootloaderInit(): void
+    {
+        $container = new Container();
+
+        $kernel = TestCoreWithTokenizer::create(directories: ['root' => __DIR__], container: $container);
+        $kernel->run();
+
+        $this->assertTrue(\in_array(
+            \dirname(__DIR__) . '/Fixtures/Bootloader',
+            $container->get(TokenizerConfig::class)->getDirectories()
+        ));
+    }
+
     public static function readCacheDataProvider(): \Traversable
     {
         yield [true, true];
diff --git a/src/Tokenizer/tests/Fixtures/Bootloader/DirectoryBootloader.php b/src/Tokenizer/tests/Fixtures/Bootloader/DirectoryBootloader.php
new file mode 100644
index 000000000..301b3eece
--- /dev/null
+++ b/src/Tokenizer/tests/Fixtures/Bootloader/DirectoryBootloader.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Spiral\Tests\Tokenizer\Fixtures\Bootloader;
+
+use Spiral\Boot\Bootloader\Bootloader;
+use Spiral\Tokenizer\Bootloader\TokenizerBootloader;
+
+final class DirectoryBootloader extends Bootloader
+{
+    public function init(TokenizerBootloader $tokenizer): void
+    {
+        $tokenizer->addDirectory(\dirname(__DIR__, 2) . '/Fixtures/Bootloader');
+    }
+}
diff --git a/src/Tokenizer/tests/Fixtures/TestCore.php b/src/Tokenizer/tests/Fixtures/TestCore.php
new file mode 100644
index 000000000..86dae0197
--- /dev/null
+++ b/src/Tokenizer/tests/Fixtures/TestCore.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Spiral\Tests\Tokenizer\Fixtures;
+
+use Spiral\Boot\AbstractKernel;
+use Spiral\Boot\Bootloader\CoreBootloader;
+
+class TestCore extends AbstractKernel
+{
+    protected const SYSTEM = [
+        CoreBootloader::class,
+    ];
+
+    protected function bootstrap(): void
+    {
+    }
+
+    protected function mapDirectories(array $directories): array
+    {
+        $dir = \dirname(__DIR__) . '/Fixtures';
+
+        return $directories + ['config' => $dir, 'app' => $dir, 'resources' => $dir, 'runtime' => $dir];
+    }
+}
diff --git a/src/Tokenizer/tests/Fixtures/TestCoreWithTokenizer.php b/src/Tokenizer/tests/Fixtures/TestCoreWithTokenizer.php
new file mode 100644
index 000000000..c27dc5346
--- /dev/null
+++ b/src/Tokenizer/tests/Fixtures/TestCoreWithTokenizer.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Spiral\Tests\Tokenizer\Fixtures;
+
+use Spiral\Boot\AbstractKernel;
+use Spiral\Boot\Bootloader\CoreBootloader;
+use Spiral\Tests\Tokenizer\Fixtures\Bootloader\DirectoryBootloader;
+use Spiral\Tokenizer\Bootloader\TokenizerListenerBootloader;
+
+class TestCoreWithTokenizer extends AbstractKernel
+{
+    protected const SYSTEM = [
+        CoreBootloader::class,
+        TokenizerListenerBootloader::class,
+    ];
+
+    protected const LOAD = [
+        DirectoryBootloader::class,
+    ];
+
+    protected function bootstrap(): void
+    {
+    }
+
+    protected function mapDirectories(array $directories): array
+    {
+        $dir = \dirname(__DIR__) . '/Fixtures';
+
+        return $directories + ['config' => $dir, 'app' => $dir, 'resources' => $dir, 'runtime' => $dir];
+    }
+}
diff --git a/src/Tokenizer/tests/Listener/ListenerInvokerTest.php b/src/Tokenizer/tests/Listener/ListenerInvokerTest.php
index a8132b508..29d802348 100644
--- a/src/Tokenizer/tests/Listener/ListenerInvokerTest.php
+++ b/src/Tokenizer/tests/Listener/ListenerInvokerTest.php
@@ -6,18 +6,18 @@
 
 use Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration;
 use PHPUnit\Framework\TestCase;
-use Spiral\Boot\BootloadManager\BootloadManager;
-use Spiral\Boot\BootloadManager\Initializer;
-use Spiral\Boot\BootloadManager\InitializerInterface;
-use Spiral\Boot\BootloadManager\StrategyBasedBootloadManager;
 use Spiral\Core\Container;
-use Spiral\Tests\Boot\Fixtures\TestCore;
 use Spiral\Tokenizer\Bootloader\TokenizerListenerBootloader;
 use Spiral\Tokenizer\ClassesInterface;
 use Spiral\Tokenizer\Config\TokenizerConfig;
+use Spiral\Tokenizer\EnumsInterface;
+use Spiral\Tokenizer\InterfacesInterface;
 use Spiral\Tokenizer\Listener\ClassesLoaderInterface;
+use Spiral\Tokenizer\Listener\EnumsLoaderInterface;
+use Spiral\Tokenizer\Listener\InterfacesLoaderInterface;
 use Spiral\Tokenizer\Listener\ListenerInvoker;
 use Spiral\Tests\Tokenizer\Classes\Targets;
+use Spiral\Tests\Tokenizer\Fixtures\TestCore;
 use Spiral\Tokenizer\TokenizationListenerInterface;
 
 final class ListenerInvokerTest extends TestCase
@@ -59,8 +59,20 @@ public function testInvokerViaKernel(): void
             ->once()
             ->andReturn([self::class => new \ReflectionClass($this)]);
 
-        $loader = \Mockery::mock(ClassesLoaderInterface::class);
-        $loader->shouldReceive('loadClasses')->once()->andReturnFalse();
+        $classesLoader = \Mockery::mock(ClassesLoaderInterface::class);
+        $classesLoader->shouldReceive('loadClasses')->once()->andReturnFalse();
+
+        $enums = \Mockery::mock(EnumsInterface::class);
+        $enums->shouldReceive('getEnums')->never();
+
+        $enumsLoader = \Mockery::mock(EnumsLoaderInterface::class);
+        $enumsLoader->shouldReceive('loadEnums')->never();
+
+        $interfaces = \Mockery::mock(InterfacesInterface::class);
+        $interfaces->shouldReceive('getInterfaces')->never();
+
+        $interfacesLoader = \Mockery::mock(InterfacesLoaderInterface::class);
+        $interfacesLoader->shouldReceive('loadInterfaces')->never();
 
         $listener = \Mockery::mock(TokenizationListenerInterface::class);
         $listener->shouldReceive('listen')->once();
@@ -68,22 +80,28 @@ public function testInvokerViaKernel(): void
 
         $container = new Container();
         $container->bind(ClassesInterface::class, $classes);
-        $container->bind(ClassesLoaderInterface::class, $loader);
-
-        $kernel = TestCore::create(['root' => __DIR__], true, null, $container);
-
-        $bootloader = new TokenizerListenerBootloader();
-        $bootloader->addListener($listener);
-
-        $config = new TokenizerConfig([
+        $container->bind(ClassesLoaderInterface::class, $classesLoader);
+        $container->bind(EnumsInterface::class, $enums);
+        $container->bind(EnumsLoaderInterface::class, $enumsLoader);
+        $container->bind(InterfacesInterface::class, $interfaces);
+        $container->bind(InterfacesLoaderInterface::class, $interfacesLoader);
+        $container->bind(TokenizerConfig::class, new TokenizerConfig([
             'load' => [
                 'classes' => true,
                 'enums' => false,
                 'interfaces' => false,
             ],
-        ]);
+        ]));
+
+        $kernel = TestCore::create(directories: ['root' => __DIR__], container: $container);
 
-        $container->invoke([$bootloader, 'boot'], compact('kernel', 'config'));
+        $bootloader = $container->get(TokenizerListenerBootloader::class);
+        $bootloader->addListener($listener);
+
+        $container->invoke(
+            [$bootloader, 'boot'],
+            ['kernel' => $kernel, 'config' => $container->get(TokenizerConfig::class)]
+        );
 
         $kernel->run();
     }