Implement tool registration persistence in application container for Octane compatibility

Author: fsmonter

src/Loop.php

@@ -38,15 +38,25 @@ public function tool(Tool $tool): static
     {
         $this->tools->push($tool);
 
+        $this->storeRegistration(function (Loop $loop) use ($tool) {
+            $loop->tools->push($tool);
+        });
+
         return $this;
     }
 
     public function toolkit(Toolkit $toolkit): static
     {
         foreach ($toolkit->getTools() as $tool) {
-            $this->tool($tool);
+            $this->tools->push($tool);
         }
 
+        $this->storeRegistration(function (Loop $loop) use ($toolkit) {
+            foreach ($toolkit->getTools() as $tool) {
+                $loop->tools->push($tool);
+            }
+        });
+
         return $this;
     }
 
@@ -108,4 +118,18 @@ public function getPrismTool(string $name): PrismTool
     {
         return $this->tools->getTool($name)->build();
     }
+
+    /**
+     * Store a registration callback for replay in new instances.
+     */
+    protected function storeRegistration(callable $callback): void
+    {
+        if (! app()->bound('loop.registrations')) {
+            app()->instance('loop.registrations', []);
+        }
+
+        $registrations = app('loop.registrations');
+        $registrations[] = $callback;
+        app()->instance('loop.registrations', $registrations);
+    }
 }

src/LoopServiceProvider.php

@@ -42,6 +42,23 @@ public function packageBooted(): void
             return $loop;
         });
 
+        /**
+         * Set up container resolving hook to replay tool registrations for Octane compatibility
+         */
+        $this->app->resolving(Loop::class, function ($loop, $app) {
+            if ($app->bound('loop.registrations')) {
+                $registrations = $app->make('loop.registrations');
+
+                if (is_array($registrations)) {
+                    foreach ($registrations as $registration) {
+                        if (is_callable($registration)) {
+                            $registration($loop);
+                        }
+                    }
+                }
+            }
+        });
+
         $this->app->bind(SseService::class, function ($app) {
             return new SseService;
         });

tests/Feature/OctaneCompatibilityTest.php

@@ -0,0 +1,72 @@
+<?php
+
+use Kirschbaum\Loop\Facades\Loop as LoopFacade;
+use Kirschbaum\Loop\Loop;
+use Kirschbaum\Loop\Toolkits\LaravelModelToolkit;
+use Workbench\App\Models\User;
+
+beforeEach(function () {
+    app()->forgetInstance(Loop::class);
+    app()->forgetInstance('loop.registrations');
+});
+
+test('toolkits persist after instance recreation', function () {
+    LoopFacade::toolkit(LaravelModelToolkit::make([User::class]));
+
+    $firstInstance = app(Loop::class);
+    $firstTools = $firstInstance->getPrismTools();
+
+    expect($firstTools->count())
+        ->toBeGreaterThan(0, 'First instance should have tools from registered toolkit');
+
+    app()->forgetInstance(Loop::class); // Simulates Octane instance recreation.
+
+    $secondInstance = app(Loop::class);
+    $secondTools = $secondInstance->getPrismTools();
+
+    expect($secondTools->count())
+        ->toBeGreaterThan(0, 'Second instance should have restored tools from registrations')
+        ->and($secondTools->count())
+        ->toEqual($firstTools->count(), 'Both instances should have the same number of tools');
+});
+
+test('multiple toolkit registrations are preserved', function () {
+    LoopFacade::toolkit(LaravelModelToolkit::make([User::class]));
+    LoopFacade::toolkit(LaravelModelToolkit::make([User::class]));
+
+    $firstInstance = app(Loop::class);
+    $firstTools = $firstInstance->getPrismTools();
+    $firstCount = $firstTools->count();
+
+    expect($firstCount)->toBeGreaterThan(0, 'Should have tools from multiple registrations');
+
+    app()->forgetInstance(Loop::class);
+
+    $secondInstance = app(Loop::class);
+    $secondTools = $secondInstance->getPrismTools();
+
+    expect($secondTools->count())->toEqual($firstCount, 'All toolkit registrations should be preserved');
+});
+
+test('empty registrations handle gracefully', function () {
+    $instance = app(Loop::class);
+    $tools = $instance->getPrismTools();
+
+    expect($tools->count())->toEqual(0, 'Should have no tools when nothing is registered');
+});
+
+test('registrations are stored correctly', function () {
+    LoopFacade::toolkit(LaravelModelToolkit::make([User::class]));
+
+    expect(app()->bound('loop.registrations'))->toBeTrue('Registrations should be stored in container');
+
+    $registrations = app('loop.registrations');
+    expect($registrations)
+        ->toBeArray('Registrations should be an array')
+        ->and(count($registrations))
+        ->toBeGreaterThan(0, 'Should have at least one registration');
+
+    foreach ($registrations as $registration) {
+        expect(is_callable($registration))->toBeTrue('Each registration should be callable');
+    }
+});