Revert to original behavior: return all assets including existing ones for incremental build support

Co-authored-by: dkarlovi <[email protected]>

Author: Copilot

src/AssetQueue.php

@@ -41,8 +41,6 @@ public function add(AssetCopy|AssetFetch $specification): void
      */
     public function flush(?callable $callable = null): array
     {
-        $processedAssets = [];
-        
         foreach ($this->queue as $specification) {
             $destination = $this->buildDir.'/'.mb_ltrim($specification->destination, '/');
             if (file_exists($destination)) {
@@ -69,18 +67,17 @@ public function flush(?callable $callable = null): array
                 if ($callable !== null) {
                     $callable($specification);
                 }
-                $processedAssets[] = $specification;
                 continue;
             }
 
             $this->filesystem->copy($specification->source, $destination);
             if ($callable !== null) {
                 $callable($specification);
             }
-            $processedAssets[] = $specification;
         }
+        $queue = array_values($this->queue);
         $this->queue = [];
 
-        return $processedAssets;
+        return $queue;
     }
 }

tests/unit/AssetQueueTest.php

@@ -48,7 +48,7 @@ protected function tearDown(): void
         }
     }
 
-    public function testFlushDoesNotReturnExistingAssets(): void
+    public function testFlushReturnsAllAssetsIncludingExisting(): void
     {
         // Create a temporary source file
         $sourceFile = $this->tempDir . '/source.txt';
@@ -78,14 +78,14 @@ public function testFlushDoesNotReturnExistingAssets(): void
             $processedAssets[] = $asset;
         });
 
-        // Currently this test will FAIL because the method returns all assets
-        // After the fix, it should only return the new asset
-        $this->assertCount(1, $returnedAssets, 'Should only return newly processed assets, not existing ones');
-        $this->assertSame($newAsset, $returnedAssets[0], 'Should return the new asset');
+        // Should return ALL assets (both existing and new) for incremental build support
+        $this->assertCount(2, $returnedAssets, 'Should return all assets including existing ones');
+        $this->assertContains($existingAsset, $returnedAssets, 'Should include existing asset in return');
+        $this->assertContains($newAsset, $returnedAssets, 'Should include new asset in return');
 
-        // Verify callback was only called for new asset
+        // Verify callback was only called for new asset (existing assets are skipped from processing)
         $this->assertCount(1, $processedAssets, 'Callback should only be called for newly processed assets');
-        $this->assertSame($newAsset, $processedAssets[0], 'Callback should be called with the new asset');
+        $this->assertSame($newAsset, $processedAssets[0], 'Callback should be called with the new asset only');
 
         // Verify the new asset was actually copied
         $this->assertFileExists($this->tempDir . $newDestination, 'New asset should be copied');
@@ -131,6 +131,49 @@ public function testFlushWithNoExistingAssets(): void
         $this->assertFileExists($this->tempDir . '/new/asset2.txt');
     }
 
+    public function testFlushWithAllExistingAssets(): void
+    {
+        // Create a temporary source file
+        $sourceFile = $this->tempDir . '/source.txt';
+        file_put_contents($sourceFile, 'test content');
+        
+        // Create multiple existing destination files
+        $existingDestinations = ['/existing1/asset.txt', '/existing2/asset.txt'];
+        $existingAssets = [];
+        
+        foreach ($existingDestinations as $destination) {
+            $path = $this->tempDir . $destination;
+            $this->filesystem->mkdir(dirname($path));
+            file_put_contents($path, 'existing content');
+            
+            $asset = new AssetCopy($sourceFile, $destination);
+            $existingAssets[] = $asset;
+            $this->assetQueue->add($asset);
+        }
+        
+        // Track which assets were processed via callback
+        $processedAssets = [];
+        
+        // Flush the queue
+        $returnedAssets = $this->assetQueue->flush(function ($asset) use (&$processedAssets) {
+            $processedAssets[] = $asset;
+        });
+        
+        // Should return all assets even though they all exist (for incremental build support)
+        $this->assertCount(2, $returnedAssets, 'Should return all assets even when they all exist');
+        $this->assertContains($existingAssets[0], $returnedAssets);
+        $this->assertContains($existingAssets[1], $returnedAssets);
+        
+        // Verify callback was never called since no assets were actually processed
+        $this->assertEmpty($processedAssets, 'Callback should not be called when all assets already exist');
+        
+        // Verify all existing files were not modified
+        foreach ($existingDestinations as $destination) {
+            $path = $this->tempDir . $destination;
+            $this->assertEquals('existing content', file_get_contents($path));
+        }
+    }
+
     public function testEmptyQueue(): void
     {
         $returnedAssets = $this->assetQueue->flush();