@needle-tools/gltf-progressive 3.6.0 → 3.6.1

package/lib/extension.js

@@ -796,6 +796,8 @@ export class NEEDLE_progressive {
             }
         }
         else {
+            // Requests already waiting for a queue slot must not populate a new cache lifetime.
+            this.cacheGeneration++;
             this.lodInfos.clear();
             for (const [, entryRef] of this.lowresCache) {
                 const entry = entryRef.deref();
@@ -840,6 +842,7 @@ export class NEEDLE_progressive {
         else {
             // Promise — may be in-flight or already resolved.
             // Attach disposal to run after resolution.
+            this.disposedRequests.add(entry);
             entry.then(resource => {
                 if (resource) {
                     if (Array.isArray(resource)) {
@@ -938,8 +941,11 @@ export class NEEDLE_progressive {
         }
     }
     static workers = [];
+    static cacheGeneration = 0;
+    static disposedRequests = new WeakSet();
     static _workersIndex = 0;
     static async getOrLoadLOD(current, level, options) {
+        const generation = this.cacheGeneration;
         const debugverbose = debug == "verbose";
         /** this key is used to lookup the LOD information */
         const LOD = this.getAssignedLODInformation(current);
@@ -1010,6 +1016,8 @@ export class NEEDLE_progressive {
                 const KEY = lod_url + "_" + lodInfo.guid;
                 // check if the requested file is currently being loaded or was previously loaded
                 const cached = await this.tryResolveLODCacheEntry(this.cache.get(KEY), KEY, lod_url, current, level, debugverbose);
+                if (generation !== this.cacheGeneration)
+                    return null;
                 if (cached.found)
                     return cached.value;
                 if (options?.isCurrent?.() === false) {
@@ -1018,6 +1026,8 @@ export class NEEDLE_progressive {
                     return null;
                 }
                 const slot = await this.queue.slot(lod_url);
+                if (generation !== this.cacheGeneration)
+                    return null;
                 if (options?.isCurrent?.() === false) {
                     if (debugverbose)
                         console.log(`Skipping stale LOD ${level} request after queue: ${lod_url}`);
@@ -1026,8 +1036,20 @@ export class NEEDLE_progressive {
                 // Another request can fill the cache while this one waits for a queue slot.
                 // Re-checking here avoids duplicate loads for heavily instanced assets.
                 const cachedAfterQueue = await this.tryResolveLODCacheEntry(this.cache.get(KEY), KEY, lod_url, current, level, debugverbose);
+                if (generation !== this.cacheGeneration)
+                    return null;
                 if (cachedAfterQueue.found)
                     return cachedAfterQueue.value;
+                // Even a cache miss above yields a microtask. Another slot holder can
+                // start this same request before that continuation resumes.
+                const startedMeanwhile = this.cache.get(KEY);
+                if (startedMeanwhile !== undefined) {
+                    const cached = await this.tryResolveLODCacheEntry(startedMeanwhile, KEY, lod_url, current, level, debugverbose);
+                    if (generation !== this.cacheGeneration)
+                        return null;
+                    if (cached.found)
+                        return cached.value;
+                }
                 // #region loading
                 if (!slot.use) {
                     if (debug)
@@ -1175,6 +1197,10 @@ export class NEEDLE_progressive {
                 this.cache.set(KEY, request);
                 slot.use(request);
                 const res = await request;
+                // dispose() owns cleanup of removed pending entries. Do not return their
+                // disposed resources to callers or overwrite a newer request for this key.
+                if (generation !== this.cacheGeneration || this.cache.get(KEY) !== request)
+                    return null;
                 // Optimize cache entry: replace loading promise with lightweight reference.
                 // This releases closure variables captured during the loading function.
                 if (res != null) {
@@ -1212,7 +1238,7 @@ export class NEEDLE_progressive {
                         console.log("Load texture from uri: " + lod_url);
                     const loader = new TextureLoader();
                     const tex = await loader.loadAsync(lod_url);
-                    if (options?.isCurrent?.() === false) {
+                    if (generation !== this.cacheGeneration || options?.isCurrent?.() === false) {
                         tex?.dispose();
                         return null;
                     }
@@ -1269,6 +1295,8 @@ export class NEEDLE_progressive {
             console.error(`Error loading LOD ${level} from ${lodUrl}\n`, err);
             return null;
         });
+        if (this.disposedRequests.has(existing))
+            return { found: true, value: null };
         let resourceIsDisposed = false;
         if (res == null) {
             // Failed loads stay cached as null so we don't retry the same missing resource forever.

package/lib/version.js

@@ -1,4 +1,4 @@
 // replaced at build time
-export const version = "3.6.0";
+export const version = "3.6.1";
 globalThis["GLTF_PROGRESSIVE_VERSION"] = version;
 console.debug(`[gltf-progressive] version ${version || "-"}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/gltf-progressive",
-  "version": "3.6.0",
+  "version": "3.6.1",
   "description": "three.js support for loading glTF or GLB files that contain progressive loading data",
   "homepage": "https://needle.tools",
   "author": {