@mblaney/holster 2.0.0 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mblaney/holster",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Holster is a service that allows synchronising data between devices using Node, Deno, Bun or the browser.",
   "type": "module",
   "main": "index.js",

package/src/holster.js

@@ -420,9 +420,7 @@ const Holster = opt => {
         // ctx already removed by another chained callback is ok?
         if (!ctx) return
 
-        if (!ctx.cb) {
-          if (!cb) return
-
+        if (!ctx.cb && cb) {
           // This (and ack) allows nested objects to set their own callbacks.
           ctx.cb = cb
           cb = null
@@ -762,10 +760,7 @@ const Holster = opt => {
               // First remove the initial listener
               wire.off(initialLex, map.get(cb))
               // Then add listener on the related node
-              let relLex
-              if (lex) relLex = utils.obj.put(initialLex, "#", id)
-              else relLex = {"#": id, ".": null}
-              wire.on(relLex, map.get(cb), false, _opt)
+              wire.on({"#": id, ".": null}, map.get(cb), false, _opt)
               if (_get) map.get(cb)()
             } else if (_get) {
               // Not a rel, but _get was requested, so trigger callback.

package/src/radisk.js

@@ -55,16 +55,6 @@ const Radisk = opt => {
     return
   }
 
-  // Performance logging
-  const perfLog = (operation, startTime, key, size) => {
-    const duration = Date.now() - startTime
-    if (duration > 2000) {
-      console.log(
-        `[RADISK-SLOW] ${operation}: ${duration}ms for ${key}${size ? ` (${size} bytes)` : ""}`,
-      )
-    }
-  }
-
   // Memory monitoring and cache cleanup
   const checkMemoryUsage = () => {
     if (typeof process === "undefined" || !process.memoryUsage) return
@@ -129,7 +119,6 @@ const Radisk = opt => {
       }
 
       pendingReads.set(key, [cb])
-      const readStart = Date.now()
       // If radisk.read genuinely hangs (fd leak, stuck I/O), recover
       // callbacks as a cache miss so callers can fall through to the wire path.
       // 30s is long enough to distinguish a hang from a slow-but-healthy read.
@@ -142,7 +131,6 @@ const Radisk = opt => {
       }, 30000)
       return radisk.read(key, (err, result) => {
         clearTimeout(timeout)
-        perfLog("read", readStart, key)
         const callbacks = pendingReads.get(key) || []
         pendingReads.delete(key)
         callbacks.forEach(callback => callback(err, result))
@@ -175,7 +163,6 @@ const Radisk = opt => {
       return (radisk.thrash.more = true)
     }
 
-    const thrashStart = Date.now()
     clearTimeout(radisk.batch.timeout)
     radisk.thrash.more = false
     radisk.thrash.ing = true
@@ -191,7 +178,6 @@ const Radisk = opt => {
       // file needs to be split.
       if (++i > 1) return
 
-      perfLog("thrash", thrashStart, `batch-${batch.ed}`)
       if (err) opt.log(err)
       batch.acks.forEach(cb => cb(err))
       radisk.thrash.at = null
@@ -350,7 +336,6 @@ const Radisk = opt => {
     Radix.map(rad, write.each, true)
     // There is always accumulated write.text to store once write.each has
     // finished.
-    const writeStart = Date.now()
     opt.store.put(file, write.text, err => {
       // If a split occurred the cached radix tree still contains entries that
       // were moved to the sub-file. Invalidate so the next save.mix re-reads
@@ -359,7 +344,6 @@ const Radisk = opt => {
         cache.delete(file)
         fileListCache = null
       }
-      perfLog("file-write", writeStart, file, write.text.length)
       cb(err)
     })
   }

package/src/store.js

@@ -197,7 +197,7 @@ const Store = opt => {
   const radisk = Radisk(opt)
 
   return {
-    get: (lex, cb, _opt) => {
+    get: (lex, cb) => {
       if (!lex || !utils.obj.is(lex)) {
         cb("lex required")
         return
@@ -207,41 +207,54 @@ const Store = opt => {
         return
       }
 
-      if (!_opt) _opt = {}
-
       var soul = lex["#"]
-      var key = !_opt.secure && typeof lex["."] === "string" ? lex["."] : ""
+      var key = typeof lex["."] === "string" ? lex["."] : ""
       var node
       var signatures = {}
-      const each = (value, key) => {
-        // Always include userPublicKey for verification, regardless of filter
-        if (key !== utils.userPublicKey && !utils.match(lex["."], key)) return
+      const each = (value, k) => {
+        if (k !== utils.userPublicKey && !utils.match(lex["."], k)) return
 
         if (!node) node = {_: {"#": soul, ">": {}}}
-        node[key] = value[0]
-        node._[">"][key] = value[1]
+        node[k] = value[0]
+        node._[">"][k] = value[1]
         // If signature is present, store it in _["s"]
         if (value.length === 3 && value[2]) {
           signatures[value[1]] = value[2]
         }
       }
 
+      // When doing a targeted property lookup, also fetch userPublicKey in
+      // parallel so ham.js can verify signatures regardless of secure mode.
+      // Full-soul scans (key="") already surface it via Radix.map.
+      const needsPubKey = key !== "" && key !== utils.userPublicKey
+      let pending = needsPubKey ? 2 : 1
+      let cbErr = null
+      const finish = err => {
+        if (err && !cbErr) cbErr = err
+        if (--pending > 0) return
+        const graph = {[soul]: node}
+        if (node && Object.keys(signatures).length > 0) {
+          node._["s"] = signatures
+        }
+        cb(cbErr, graph)
+      }
+
       radisk(soul + enq + key, (err, value) => {
-        let graph
         if (utils.obj.is(value)) {
           Radix.map(value, each)
           if (!node) each(value, key)
-          graph = {[soul]: node}
         } else if (value) {
           each(value, key)
-          graph = {[soul]: node}
         }
-        // Only add _["s"] if we found any signatures
-        if (graph && graph[soul] && Object.keys(signatures).length > 0) {
-          graph[soul]._["s"] = signatures
-        }
-        cb(err, graph)
+        finish(err)
       })
+
+      if (needsPubKey) {
+        radisk(soul + enq + utils.userPublicKey, (err, value) => {
+          if (value && !utils.obj.is(value)) each(value, utils.userPublicKey)
+          finish(err)
+        })
+      }
     },
     put: (graph, cb) => {
       if (!graph) {

package/src/wire.js

@@ -206,7 +206,7 @@ const Wire = opt => {
 
   // Initialize rate limiting and connection management
   // Check if test environment (mock-socket usage)
-  const isTestEnv = opt.wss && opt.wss.constructor.name === "Server"
+  const isTestEnv = isNode && globalThis.WebSocket !== wsModule?.WebSocket
   const rateLimiter = createRateLimiter(isTestEnv)
   const connectionManager = createConnectionManager(opt.maxConnections || 1000)
 
@@ -270,22 +270,16 @@ const Wire = opt => {
         }),
       )
     } else {
-      // Always pass secure to ensure public key is fetched. User data may be
-      // requested that requires the public key for verification.
-      store.get(
-        msg.get,
-        (err, ack) => {
-          send(
-            JSON.stringify({
-              "#": dup.track(utils.text.random(9)),
-              "@": msg["#"],
-              put: ack,
-              err: err,
-            }),
-          )
-        },
-        {secure: true},
-      )
+      store.get(msg.get, (err, ack) => {
+        send(
+          JSON.stringify({
+            "#": dup.track(utils.text.random(9)),
+            "@": msg["#"],
+            put: ack,
+            err: err,
+          }),
+        )
+      })
     }
   }
 
@@ -467,9 +461,7 @@ const Wire = opt => {
           pendingTimeouts.delete(track)
           return
         }
-      },
-      _opt,
-    )
+      })
   }
 
   const api = send => {
@@ -726,6 +718,7 @@ const Wire = opt => {
   let clientThrottled = false
   let throttleUntil = 0
   let messageQueue = []
+  let offlinePuts = []
   let queueProcessor = null
   const maxQueueLength = opt.maxQueueLength || 10000
 
@@ -783,6 +776,11 @@ const Wire = opt => {
 
     if (sent || isStaleCheckMessage) {
       messageQueue.shift()
+    } else if (!sent && msg.put) {
+      // Hold offline PUTs separately so they don't block GET messages behind
+      // them. They'll be flushed back to the front of the queue on reconnect.
+      messageQueue.shift()
+      offlinePuts.push(data)
     }
 
     if (trackId && pendingTimeouts.has(trackId)) {
@@ -864,14 +862,22 @@ const Wire = opt => {
         ws = null
 
         if (retryHandler.shouldRetry()) {
-          const delay = retryHandler.getDelay()
+          const delay = isTestEnv ? 50 : retryHandler.getDelay()
           retryHandler.increment()
-          setTimeout(start, delay)
+          const t = setTimeout(start, delay)
+          if (t.unref) t.unref()
         }
       }
 
       ws.onopen = () => {
         retryHandler.reset()
+        if (offlinePuts.length > 0) {
+          messageQueue = offlinePuts.concat(messageQueue)
+          offlinePuts = []
+          if (!queueProcessor) {
+            queueProcessor = setTimeout(processQueue, 50)
+          }
+        }
       }
 
       ws.onerror = e => {

package/ts/src/holster.ts

@@ -521,8 +521,7 @@ const Holster = (opt?: HolsterOptions | string | string[]): HolsterAPI => {
         const ctx = allctx.get(ctxid!)
         if (!ctx) return
 
-        if (!ctx.cb) {
-          if (!callback) return
+        if (!ctx.cb && callback) {
           ctx.cb = callback as never
           callback = undefined
         }
@@ -845,10 +844,7 @@ const Holster = (opt?: HolsterOptions | string | string[]): HolsterAPI => {
             const id = utils.rel.is(current as GraphValue)
             if (id) {
               wire.off(initialLex as never, map.get(callback)!)
-              const relLex = (lexFilter
-                ? utils.obj.put(initialLex as never, "#", id)
-                : { "#": id, ".": null }) as Lex
-              wire.on(relLex, map.get(callback)!, false, opts)
+              wire.on({ "#": id, ".": null } as never, map.get(callback)!, false, opts)
               if (_get) map.get(callback)!()
             } else if (_get) {
               // Not a rel, but _get was requested, so trigger callback.

package/ts/src/radisk.ts

@@ -82,14 +82,6 @@ const Radisk = (opt: RadiskOptions) => {
   // After validation, store is guaranteed to be defined
   const store = options.store
 
-  const perfLog = (operation: string, startTime: number, key: string, size?: number): void => {
-    const duration = Date.now() - startTime
-    if (duration > 2000) {
-      console.log(
-        `[RADISK-SLOW] ${operation}: ${duration}ms for ${key}${size ? ` (${size} bytes)` : ""}`
-      )
-    }
-  }
 
   const checkMemoryUsage = (): void => {
     if (typeof process === "undefined" || !process.memoryUsage) return
@@ -143,7 +135,6 @@ const Radisk = (opt: RadiskOptions) => {
       }
 
       pendingReads.set(key, [callback])
-      const readStart = Date.now()
       const timeout = setTimeout(() => {
         const callbacks = pendingReads.get(key)
         if (!callbacks) return
@@ -153,7 +144,6 @@ const Radisk = (opt: RadiskOptions) => {
       }, 30000)
       return radisk.read(key, (err, result) => {
         clearTimeout(timeout)
-        perfLog("read", readStart, key)
         const callbacks = pendingReads.get(key) || []
         pendingReads.delete(key)
         callbacks.forEach(callback => callback(err, result))
@@ -184,7 +174,6 @@ const Radisk = (opt: RadiskOptions) => {
       return
     }
 
-    const thrashStart = Date.now()
     clearTimeout(radisk.batch.timeout)
     radisk.thrash.more = false
     radisk.thrash.ing = true
@@ -196,7 +185,6 @@ const Radisk = (opt: RadiskOptions) => {
     radisk.save(batch, err => {
       if (++i > 1) return
 
-      perfLog("thrash", thrashStart, `batch-${batch.ed}`)
       if (err) options.log(err)
       batch.acks.forEach(cb => cb(err))
       radisk.thrash.at = undefined
@@ -337,7 +325,6 @@ const Radisk = (opt: RadiskOptions) => {
       },
     }
     Radix.map(rad, write.each, true)
-    const writeStart = Date.now()
     store.put(file, write.text, err => {
       // If a split occurred the cached radix tree still contains entries that
       // were moved to the sub-file. Invalidate so the next save.mix re-reads
@@ -346,7 +333,6 @@ const Radisk = (opt: RadiskOptions) => {
         cache.delete(file)
         fileListCache = null
       }
-      perfLog("file-write", writeStart, file, write.text.length)
       cb(err)
     })
   }

package/ts/src/store.ts

@@ -212,7 +212,6 @@ export interface StoreInterface {
   get: (
     lex: Lex,
     cb: (err?: string | null, graph?: Graph) => void,
-    _opt?: { secure?: boolean }
   ) => void
   put: (graph: Graph, cb: (err?: string | null) => void) => void
 }
@@ -227,7 +226,7 @@ const Store = (opt?: StoreOptions): StoreInterface => {
   const radisk = Radisk(options as never)
 
   return {
-    get: (lex, cb, _opt) => {
+    get: (lex, cb) => {
       if (!lex || !utils.obj.is(lex)) {
         cb("lex required")
         return
@@ -237,42 +236,55 @@ const Store = (opt?: StoreOptions): StoreInterface => {
         return
       }
 
-      const opts = _opt || {}
       const soul = lex["#"]
-      const key =
-        !opts.secure && typeof lex["."] === "string" ? lex["."] : ""
+      const key = typeof lex["."] === "string" ? lex["."] : ""
       let node: GraphNode | undefined
       const signatures: Record<string, string> = {}
 
-      const each = (value: EncodedValue, key: string): void => {
-        // Always include userPublicKey for verification, regardless of filter
-        if (key !== utils.userPublicKey && !utils.match(lex["."], key)) return
+      const each = (value: EncodedValue, k: string): void => {
+        if (k !== utils.userPublicKey && !utils.match(lex["."], k)) return
 
         if (!node) node = { _: { "#": soul, ">": {} } }
-        node[key] = value[0]
-        node._[">"][key] = value[1]
+        node[k] = value[0]
+        node._[">"][k] = value[1]
         // If signature is present, store it in _["s"]
         if (value.length === 3 && value[2]) {
           signatures[value[1].toString()] = value[2]
         }
       }
 
+      // When doing a targeted property lookup, also fetch userPublicKey in
+      // parallel so ham.js can verify signatures regardless of secure mode.
+      // Full-soul scans (key="") already surface it via Radix.map.
+      const needsPubKey = key !== "" && key !== utils.userPublicKey
+      let pending = needsPubKey ? 2 : 1
+      let cbErr: string | null = null
+      const finish = (err: string | null | undefined): void => {
+        if (err && !cbErr) cbErr = err
+        if (--pending > 0) return
+        const graph: Graph = { [soul]: node! }
+        if (node && Object.keys(signatures).length > 0) {
+          node._["s"] = signatures
+        }
+        cb(cbErr, graph)
+      }
+
       radisk(soul + enq + key, (err, value) => {
-        let graph: Graph | undefined
         if (utils.obj.is(value)) {
           Radix.map(value as never, each)
           if (!node) each(value as never, key)
-          graph = { [soul]: node! }
         } else if (value) {
           each(value as EncodedValue, key)
-          graph = { [soul]: node! }
-        }
-        // Only add _["s"] if we found any signatures
-        if (graph && graph[soul] && Object.keys(signatures).length > 0) {
-          graph[soul]._["s"] = signatures
         }
-        cb(err, graph)
+        finish(err)
       })
+
+      if (needsPubKey) {
+        radisk(soul + enq + utils.userPublicKey, (err, value) => {
+          if (value && !utils.obj.is(value)) each(value as EncodedValue, utils.userPublicKey)
+          finish(err)
+        })
+      }
     },
     put: (graph, cb) => {
       if (!graph) {

package/ts/src/wire.ts

@@ -246,7 +246,7 @@ const Wire = (opt: HolsterOptions): WireAPI => {
     })
   }
 
-  const isTestEnv = options.wss && (options.wss as { constructor?: { name?: string } }).constructor?.name === "Server"
+  const isTestEnv = isNode && (globalThis.WebSocket as unknown) !== wsModule?.WebSocket
   const rateLimiter = createRateLimiter(isTestEnv)
   const connectionManager = createConnectionManager(options.maxConnections || 1000)
 
@@ -303,20 +303,16 @@ const Wire = (opt: HolsterOptions): WireAPI => {
         })
       )
     } else {
-      store.get(
-        msg.get,
-        (err, ack) => {
-          send(
-            JSON.stringify({
-              "#": dup.track(utils.text.random(9)),
-              "@": msg["#"],
-              put: ack,
-              err: err,
-            })
-          )
-        },
-        { secure: true }
-      )
+      store.get(msg.get, (err, ack) => {
+        send(
+          JSON.stringify({
+            "#": dup.track(utils.text.random(9)),
+            "@": msg["#"],
+            put: ack,
+            err: err,
+          })
+        )
+      })
     }
   }
 
@@ -492,9 +488,7 @@ const Wire = (opt: HolsterOptions): WireAPI => {
           pendingTimeouts.delete(track)
           return
         }
-      },
-      opts
-    )
+      })
   }
 
   const api = (send: (msg: string) => { err?: string } | void): WireAPI => {
@@ -603,7 +597,7 @@ const Wire = (opt: HolsterOptions): WireAPI => {
             if (typeof lex["."] === "string") {
               ack[id] = { [lex["."]]: null } as never
             }
-            cb({ "#": trackId, put: ack })
+            cb({ put: ack })
             delete queue[trackId]
           }
         }, isTestEnv ? 100 : 10000)
@@ -734,6 +728,7 @@ const Wire = (opt: HolsterOptions): WireAPI => {
   let clientThrottled = false
   let throttleUntil = 0
   let messageQueue: string[] = []
+  let offlinePuts: string[] = []
   let queueProcessor: NodeJS.Timeout | null = null
   const maxQueueLength = options.maxQueueLength || 10000
 
@@ -748,7 +743,7 @@ const Wire = (opt: HolsterOptions): WireAPI => {
         if (typeof lex["."] === "string") {
           ack[id] = { [lex["."]]: null } as never
         }
-        cb({ "#": trackId, put: ack })
+        cb({ put: ack })
         delete queue[trackId]
       }
     }, delay)
@@ -784,6 +779,11 @@ const Wire = (opt: HolsterOptions): WireAPI => {
 
     if (sent || isStaleCheckMessage) {
       messageQueue.shift()
+    } else if (!sent && msg.put) {
+      // Hold offline PUTs separately so they don't block GET messages behind
+      // them. They'll be flushed back to the front of the queue on reconnect.
+      messageQueue.shift()
+      offlinePuts.push(data)
     }
 
     if (trackId && pendingTimeouts.has(trackId)) {
@@ -863,14 +863,22 @@ const Wire = (opt: HolsterOptions): WireAPI => {
         ws = null
 
         if (retryHandler.shouldRetry()) {
-          const delay = retryHandler.getDelay()
+          const delay = isTestEnv ? 50 : retryHandler.getDelay()
           retryHandler.increment()
-          setTimeout(start, delay)
+          const t = setTimeout(start, delay)
+          if ((t as unknown as { unref?: () => void }).unref) (t as unknown as { unref: () => void }).unref()
         }
       }
 
       ws.onopen = () => {
         retryHandler.reset()
+        if (offlinePuts.length > 0) {
+          messageQueue = offlinePuts.concat(messageQueue)
+          offlinePuts = []
+          if (!queueProcessor) {
+            queueProcessor = setTimeout(processQueue, 50)
+          }
+        }
       }
 
       ws.onerror = (e: Event) => {