@nxtedition/cache 2.1.11 → 2.1.12

package/lib/index.js

@@ -98,7 +98,6 @@ export class Cache                                              extends EventEmi
   #stale                                 
   #serializer               
 
-  #lockOrigin         = 0
   #lockId                = null
   #lockArray                    = null
   #lockSet                    
@@ -202,14 +201,8 @@ export class Cache                                              extends EventEmi
         }
       }
 
-      const sab = getOrCreate(`__@nxtedition/cache/${location}`, 8 + 1024)
-
-      const originArray = new BigInt64Array(sab, 0, 1)
-      Atomics.compareExchange(originArray, 0, 0n, BigInt(Date.now()))
-
-      this.#lockOrigin = Number(originArray[0])
       this.#lockId = randomUUID()
-      this.#lockArray = new Int32Array(sab, 8)
+      this.#lockArray = new Int32Array(getOrCreate(`__@nxtedition/cache/${location}`, 8 + 1024))
       this.#lockSet = new Set()
     }
 
@@ -531,13 +524,20 @@ export class Cache                                              extends EventEmi
     if (this.#lockId != null) {
       // Another process holds the lock — wait for the value instead of calling valueSelector.
       // Use deferred pattern so #waitForValue can check promise identity to detect delete+get races.
-      const lockIdx = this.#lockArray ? HASHER.h32(key) % this.#lockArray.length : -1
-      const lockResult = this.#tryAcquireLock(key, lockIdx)
-      if (typeof lockResult === 'number') {
+      let lockIdx = -1
+      let lockVal = 0
+      if (this.#lockArray) {
+        lockIdx = HASHER.h32(key) % this.#lockArray.length
+        lockVal = Atomics.load(this.#lockArray, lockIdx)
+      }
+
+      const lockRes = this.#tryAcquireLock(key, lockIdx)
+
+      if (typeof lockRes === 'number') {
         const { promise, resolve, reject } = Promise.withResolvers   ()
         promise.catch(noop)
         this.#dedupe.set(key, promise)
-        this.#waitForValue(args, key, lockIdx, lockResult, promise).then(resolve, reject)
+        this.#waitForValue(args, key, lockIdx, lockVal, lockRes, promise).then(resolve, reject)
         return { async: true, value: promise }
       }
     }
@@ -690,7 +690,7 @@ export class Cache                                              extends EventEmi
 
           if (this.#lockSet && this.#lockArray) {
             for (const idx of this.#lockSet) {
-              Atomics.store(this.#lockArray, idx, 0)
+              Atomics.add(this.#lockArray, idx, 1)
               Atomics.notify(this.#lockArray, idx)
             }
             this.#lockSet.clear()
@@ -784,8 +784,8 @@ export class Cache                                              extends EventEmi
       }
 
       if (row.lock_owner === this.#lockId) {
-        if (this.#lockArray && lockIdx >= 0) {
-          Atomics.store(this.#lockArray, lockIdx, now - this.#lockOrigin)
+        if (this.#lockArray) {
+          Atomics.add(this.#lockArray, lockIdx, 1)
         }
         return 'acquired'
       }
@@ -797,8 +797,8 @@ export class Cache                                              extends EventEmi
         // process wins if multiple try to steal concurrently.
         const stealResult = this.#lockStealQuery .run(now, this.#lockId, key, lockedAt)
         if (stealResult.changes === 1) {
-          if (this.#lockArray && lockIdx >= 0) {
-            Atomics.store(this.#lockArray, lockIdx, now - this.#lockOrigin)
+          if (this.#lockArray) {
+            Atomics.add(this.#lockArray, lockIdx, 1)
           }
           return 'acquired'
         }
@@ -844,6 +844,7 @@ export class Cache                                              extends EventEmi
     args   ,
     key        ,
     lockIdx        ,
+    lockVal        ,
     lockedAt        ,
     selfPromise            ,
   )             {
@@ -856,12 +857,7 @@ export class Cache                                              extends EventEmi
       )
 
       if (this.#lockArray != null && lockIdx >= 0) {
-        const { async, value } = Atomics.waitAsync(
-          this.#lockArray,
-          lockIdx,
-          lockedAt - this.#lockOrigin,
-          waitTime,
-        )
+        const { async, value } = Atomics.waitAsync(this.#lockArray, lockIdx, lockVal, waitTime)
         if (async) {
           await value
         }
@@ -885,10 +881,10 @@ export class Cache                                              extends EventEmi
       }
 
       // Try to acquire lock for takeover
-      const lockResult = this.#tryAcquireLock(key, lockIdx)
-      if (typeof lockResult === 'number') {
+      const lockRes = this.#tryAcquireLock(key, lockIdx)
+      if (typeof lockRes === 'number') {
         // Another process holds the lock — wait for them
-        lockedAt = lockResult
+        lockedAt = lockRes
       } else {
         // We acquired the lock or lock is unavailable — do the work
         break

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/cache",
-  "version": "2.1.11",
+  "version": "2.1.12",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -30,7 +30,7 @@
     "tsd": "^0.33.0",
     "typescript": "^5.9.3"
   },
-  "gitHead": "46cd2017c0b9d238f2509e3612afbdb11fbefb69",
+  "gitHead": "89b5cbdea4feddf44ef7955ba2b60105dea996f0",
   "dependencies": {
     "@nxtedition/shared": "^5.1.10",
     "xxhash-wasm": "^1.1.0"