refactor: use AsyncLock in LoadPendingIncludesAsync and remove premature PreStripConditionalIncludes calls

- Use AsyncLock (per reviewer suggestion) instead of manual _CurrentLoadingPromise logic in LoadPendingIncludesAsync; concurrent callers now serialize through the lock rather than sharing a raw promise reference
- Remove PreStripConditionalIncludes calls from Process() and PreProcess(): shader .ts files are not yet regenerated with lazy loaders, so double-evaluating #ifdef blocks was causing 27 WebGL2 visualization test regressions; the function definition is preserved for when shaders are regenerated
- Update unit tests to match AsyncLock async semantics and reset the static lock in beforeEach to prevent cross-test lock leaks

Author: RaananW

packages/dev/core/src/Engines/Processors/shaderProcessor.ts

@@ -61,8 +61,6 @@ export function Process(sourceCode: string, options: _IProcessingOptions, callba
     if (options.processor?.preProcessShaderCode) {
         sourceCode = options.processor.preProcessShaderCode(sourceCode, options.isFragment);
     }
-    // Pre-strip conditional blocks so that #include directives inside disabled #ifdef blocks are never resolved.
-    sourceCode = PreStripConditionalIncludes(sourceCode, options, engine);
     ProcessIncludes(sourceCode, options, (codeWithIncludes) => {
         if (options.processCodeAfterIncludes) {
             codeWithIncludes = options.processCodeAfterIncludes(options.isFragment ? "fragment" : "vertex", codeWithIncludes, options.defines);
@@ -77,8 +75,6 @@ export function PreProcess(sourceCode: string, options: _IProcessingOptions, cal
     if (options.processor?.preProcessShaderCode) {
         sourceCode = options.processor.preProcessShaderCode(sourceCode, options.isFragment);
     }
-    // Pre-strip conditional blocks so that #include directives inside disabled #ifdef blocks are never resolved.
-    sourceCode = PreStripConditionalIncludes(sourceCode, options, engine);
     ProcessIncludes(sourceCode, options, (codeWithIncludes) => {
         if (options.processCodeAfterIncludes) {
             codeWithIncludes = options.processCodeAfterIncludes(options.isFragment ? "fragment" : "vertex", codeWithIncludes, options.defines);

packages/dev/core/src/Engines/shaderStore.ts

@@ -1,4 +1,5 @@
 import { ShaderLanguage } from "../Materials/shaderLanguage";
+import { AsyncLock } from "../Misc/asyncLock";
 
 /**
  * Defines the shader related stores and directory
@@ -67,49 +68,31 @@ export class ShaderStore {
 
     /**
      * @internal
-     * Shared promise for the currently in-flight loading operation, so multiple callers
-     * await the same work rather than duplicating loads.
+     * Lock used to serialize concurrent calls to LoadPendingIncludesAsync so that
+     * multiple callers don't duplicate include-loading work.
      */
-    private static _CurrentLoadingPromise: Promise<void> | null = null;
+    private static _LoadLock = new AsyncLock();
 
     /**
      * Call after importing shader modules to eagerly load all their include dependencies.
      * Each generated shader module registers a batch-loader at import time.
      * This method fires them all in parallel and clears the pending list.
      * It loops to also load nested include dependencies (include files that themselves
      * reference further includes push their own loaders when imported).
-     * Concurrent callers share the same loading promise to avoid duplicate work.
+     * Concurrent callers are serialized via AsyncLock to avoid duplicate work.
      * @internal
      */
     static async LoadPendingIncludesAsync(): Promise<void> {
-        // Fast path: nothing pending and no in-flight loading
-        if (ShaderStore._PendingIncludesLoaders.length === 0 && !ShaderStore._CurrentLoadingPromise) {
+        // Fast path: nothing pending
+        if (ShaderStore._PendingIncludesLoaders.length === 0) {
             return;
         }
-        // If loading is already in progress, wait for it then check for stragglers
-        if (ShaderStore._CurrentLoadingPromise) {
-            await ShaderStore._CurrentLoadingPromise;
-            if (ShaderStore._PendingIncludesLoaders.length > 0) {
-                await ShaderStore.LoadPendingIncludesAsync();
-            }
-            return;
-        }
-        // Start a new loading cycle that loops until all nested includes are loaded
-        const doLoadAsync = async () => {
+        await ShaderStore._LoadLock.lockAsync(async () => {
             while (ShaderStore._PendingIncludesLoaders.length > 0) {
                 const loaders = ShaderStore._PendingIncludesLoaders.splice(0);
                 // eslint-disable-next-line no-await-in-loop
-                await Promise.all(loaders.map(async (fn) => await fn()));
+                await Promise.all(loaders.map((fn) => fn()));
             }
-        };
-        const promise = doLoadAsync();
-        ShaderStore._CurrentLoadingPromise = promise;
-        try {
-            await promise;
-        } finally {
-            if (ShaderStore._CurrentLoadingPromise === promise) {
-                ShaderStore._CurrentLoadingPromise = null;
-            }
-        }
+        });
     }
 }

packages/dev/core/test/unit/Engines/shaderStore.test.ts

@@ -1,13 +1,14 @@
 import { describe, it, expect, beforeEach, vi } from "vitest";
+import { AsyncLock } from "core/Misc/asyncLock";
 import { ShaderStore } from "core/Engines/shaderStore";
 
 describe("ShaderStore", () => {
     describe("LoadPendingIncludesAsync", () => {
         beforeEach(() => {
             // Reset state between tests
             ShaderStore._PendingIncludesLoaders.length = 0;
-            // Force clear any in-flight promise by accessing private field
-            (ShaderStore as any)._CurrentLoadingPromise = null;
+            // Reset the AsyncLock so no test can leak a pending lock into the next
+            (ShaderStore as any)._LoadLock = new AsyncLock();
         });
 
         it("resolves immediately when no loaders are pending", async () => {
@@ -43,41 +44,49 @@ describe("ShaderStore", () => {
             expect(ShaderStore._PendingIncludesLoaders).toHaveLength(0);
         });
 
-        it("concurrent callers share the same loading promise", async () => {
+        it("concurrent callers serialize via lock — loader is called exactly once", async () => {
             let resolveLoader: () => void;
             const loaderPromise = new Promise<void>((r) => (resolveLoader = r));
             const loader = vi.fn().mockReturnValue(loaderPromise);
             ShaderStore._PendingIncludesLoaders.push(loader);
 
-            // Start two concurrent calls
+            // Start two concurrent callers
             const p1 = ShaderStore.LoadPendingIncludesAsync();
             const p2 = ShaderStore.LoadPendingIncludesAsync();
 
-            // Loader should only be called once despite two callers
-            expect(loader).toHaveBeenCalledOnce();
-
             resolveLoader!();
             await Promise.all([p1, p2]);
 
+            // Loader should be called exactly once: the second caller finds the queue empty
+            expect(loader).toHaveBeenCalledOnce();
             expect(ShaderStore._PendingIncludesLoaders).toHaveLength(0);
         });
 
-        it("clears in-flight promise after completion", async () => {
+        it("lock is released after successful completion", async () => {
             const loader = vi.fn().mockResolvedValue(undefined);
             ShaderStore._PendingIncludesLoaders.push(loader);
 
             await ShaderStore.LoadPendingIncludesAsync();
 
-            expect((ShaderStore as any)._CurrentLoadingPromise).toBeNull();
+            // Calling again with a new loader should work — lock must be free
+            const loader2 = vi.fn().mockResolvedValue(undefined);
+            ShaderStore._PendingIncludesLoaders.push(loader2);
+            await ShaderStore.LoadPendingIncludesAsync();
+            expect(loader2).toHaveBeenCalledOnce();
         });
 
-        it("clears in-flight promise even if a loader rejects", async () => {
+        it("lock is released even if a loader rejects", async () => {
             const error = new Error("loader failed");
             const loader = vi.fn().mockRejectedValue(error);
             ShaderStore._PendingIncludesLoaders.push(loader);
 
             await expect(ShaderStore.LoadPendingIncludesAsync()).rejects.toThrow("loader failed");
-            expect((ShaderStore as any)._CurrentLoadingPromise).toBeNull();
+
+            // Subsequent call should not hang — lock must be free
+            const loader2 = vi.fn().mockResolvedValue(undefined);
+            ShaderStore._PendingIncludesLoaders.push(loader2);
+            await ShaderStore.LoadPendingIncludesAsync();
+            expect(loader2).toHaveBeenCalledOnce();
         });
 
         it("second caller picks up loaders added after first batch finishes", async () => {