@mblaney/holster 1.0.36 → 2.0.1

package/package.json

@@ -1,19 +1,18 @@
 {
   "name": "@mblaney/holster",
-  "version": "1.0.36",
+  "version": "2.0.1",
   "description": "Holster is a service that allows synchronising data between devices using Node, Deno, Bun or the browser.",
   "type": "module",
   "main": "index.js",
   "scripts": {
     "test": "node --test",
-    "test:ts": "node --test --import tsx/esm ts/test/**/*.test.ts",
-    "test:ts:system": "node --test --import tsx/esm ts/test/system/**/*.test.ts",
+    "test:ts": "node --test --import tsx/esm ts/test/*.test.ts ts/test/system/*.test.ts",
     "build": "esbuild src/holster.js --bundle --format=esm --sourcemap \"--external:node:*\" \"--external:ws\" --minify --outdir=build",
     "build:ts": "esbuild ts/src/holster.ts --bundle --format=esm --sourcemap \"--external:node:*\" \"--external:ws\" --minify --outdir=dist",
     "build:all": "npm run build && npm run build:ts",
     "prepublishOnly": "npm run build:all",
-    "type-check": "tsc --noEmit",
-    "type-check:tests": "tsc --noEmit --project tsconfig.test.json"
+    "type-check": "tsc -p tsconfig.json",
+    "type-check:tests": "tsc -p tsconfig.test.json"
   },
   "files": [
     "src",

package/src/dup.js

@@ -1,6 +1,5 @@
-const Dup = maxAge => {
-  // Allow maxAge to be passed in as tests wait on the setTimeout.
-  if (!maxAge) maxAge = 9000
+const Dup = () => {
+  const maxAge = 9000
   const dup = {store: {}}
   dup.check = id => (dup.store[id] ? dup.track(id) : false)
   dup.track = id => {
@@ -8,14 +7,14 @@ const Dup = maxAge => {
     dup.store[id] = Date.now()
     if (!dup.expiry) {
       dup.expiry = setTimeout(() => {
-        if (dup.expiry) return
-
         const now = Date.now()
         Object.keys(dup.store).forEach(id => {
           if (now - dup.store[id] > maxAge) delete dup.store[id]
         })
         dup.expiry = null
       }, maxAge)
+      // Don't block process exit — cleanup is best-effort.
+      if (dup.expiry.unref) dup.expiry.unref()
     }
     return id
   }

package/src/get.js

@@ -43,17 +43,20 @@ const Get = (lex, graph, fast) => {
     // return undefined to ensure we get all matching properties from store.
     if (!fast) return
 
+    let found = false
     for (const key of Object.keys(graph[soul])) {
       // Always include userPublicKey for verification, regardless of filter
-      if (key === userPublicKey || match(lex["."], key)) {
+      if (key !== "_" && (key === userPublicKey || match(lex["."], key))) {
         node[key] = graph[soul][key]
         node._[">"][key] = graph[soul]._[">"][key]
         const state = graph[soul]._[">"][key]
         if (graph[soul]._["s"] && graph[soul]._["s"][state]) {
           signatures[state] = graph[soul]._["s"][state]
         }
+        found = true
       }
     }
+    if (!found) return
   }
   if (Object.keys(signatures).length > 0) {
     node._["s"] = signatures

package/src/ham.js

@@ -35,7 +35,7 @@ const Ham = (state, currentState, value, currentValue, signed = false) => {
   return {incoming: true}
 }
 
-Ham.mix = async (change, graph, secure, listen) => {
+Ham.mix = async (change, graph, hasNode, secure, listen) => {
   if (!change || typeof change !== "object") {
     throw new TypeError("change must be an object")
   }
@@ -226,7 +226,10 @@ Ham.mix = async (change, graph, secure, listen) => {
       })
       .sort((a, b) => a.maxState - b.maxState)
     const remove = soulsByAge.slice(0, souls.length - MAX_GRAPH_SIZE)
-    remove.forEach(({soul}) => delete graph[soul])
+    remove.forEach(({soul}) => {
+      delete graph[soul]
+      if (hasNode) hasNode.delete(soul)
+    })
   }
 
   return {now: now, defer: defer, wait: wait, listeners: listeners}

package/src/holster.js

@@ -64,30 +64,28 @@ const Holster = opt => {
             delete msg.put[soul][utils.userPublicKey]
             delete msg.put[soul][utils.userSignature]
             // Resolve any rels on the node before returning to the user.
-            for (const key of Object.keys(msg.put[soul])) {
+            await Promise.all(Object.keys(msg.put[soul]).map(async key => {
               const id = utils.rel.is(msg.put[soul][key])
-              if (id) {
-                // Retry with delays if we get null
-                const attemptRead = async (retries = 0) => {
-                  const data = await new Promise(res => {
-                    const _ctxid = utils.text.random()
-                    const ctx = allctx.get(ctxid)
-                    allctx.set(_ctxid, {
-                      chain: [{item: null, soul: id}],
-                      user: ctx ? ctx.user : null,
-                    })
-                    api(_ctxid).next(null, res, _opt)
+              if (!id) return
+              const attemptRead = async (retries = 0) => {
+                const data = await new Promise(res => {
+                  const _ctxid = utils.text.random()
+                  const ctx = allctx.get(ctxid)
+                  allctx.set(_ctxid, {
+                    chain: [{item: null, soul: id}],
+                    user: ctx ? ctx.user : null,
                   })
-                  if (data !== null || retries >= 5) {
-                    return data
-                  }
-                  // Data not ready, retry after delay
-                  await new Promise(resolve => setTimeout(resolve, 50))
-                  return attemptRead(retries + 1)
+                  api(_ctxid).next(null, res, _opt)
+                })
+                if (data !== null || retries >= 5) {
+                  return data
                 }
-                msg.put[soul][key] = await attemptRead()
+                // Data not ready, retry after delay
+                await new Promise(resolve => setTimeout(resolve, 50))
+                return attemptRead(retries + 1)
               }
-            }
+              msg.put[soul][key] = await attemptRead()
+            }))
             ack(msg.put[soul])
           } else {
             // No data callback.
@@ -132,11 +130,13 @@ const Holster = opt => {
       }
     }
 
-    const watchForRel = (soul, item, ctx, i, request, cb) => {
+    const watchForRel = (soul, item, ctx, i, request, cb, on = true) => {
+      let timer = null
       const handler = () => {
         // Bail out if the context was removed by off().
         if (!allctx.has(ctxid)) {
           wire.off({"#": soul, ".": item}, handler)
+          if (timer) clearTimeout(timer)
           return
         }
         wire.get(
@@ -144,16 +144,39 @@ const Holster = opt => {
           msg => {
             const node = msg.put && msg.put[soul]
             const id = utils.rel.is(node && node[item])
-            if (!id) return
+            if (!id) {
+              // If it's a plain value (not a rel) and this is a get, deliver it.
+              // node._ guards against timeout null-acks which lack metadata.
+              if (!on && node && node._ && typeof node[item] !== "undefined") {
+                if (timer) clearTimeout(timer)
+                wire.off({"#": soul, ".": item}, handler)
+                cb(node[item])
+              }
+              return
+            }
+            if (timer) clearTimeout(timer)
             wire.off({"#": soul, ".": item}, handler)
             ctx.chain[i].soul = id
             allctx.set(ctxid, {...ctx})
-            api(ctxid).on(request.on, cb, request._get, request._opt)
+            if (on) {
+              api(ctxid).on(request.on, cb, request._get, request._opt)
+            } else {
+              api(ctxid).next(null, request.get, cb, request._opt)
+            }
           },
-          {...request._opt, secure: ctx.user || opt.secure},
+          {...request._opt, secure: !!(ctx.user || opt.secure)},
         )
       }
       wire.on({"#": soul, ".": item}, handler, false, request._opt)
+      // Time out after the same total duration as the on() retry loop
+      // (1+2+4+8+16 = 31s) so callers are not blocked forever if the node
+      // genuinely doesn't exist.
+      if (!on) {
+        timer = setTimeout(() => {
+          wire.off({"#": soul, ".": item}, handler)
+          if (cb) cb(null)
+        }, 31000)
+      }
     }
 
     const resolve = (request, cb) => {
@@ -169,6 +192,7 @@ const Holster = opt => {
 
       let found = false
       const ctx = allctx.get(ctxid)
+      if (!ctx) return {item: null, soul: null}
       for (var i = 1; i < ctx.chain.length; i++) {
         if (ctx.chain[i].soul !== null) continue
 
@@ -255,13 +279,22 @@ const Holster = opt => {
                 // Node doesn't exist yet — watch for it to appear.
                 watchForRel(soul, item, ctx, i, request, cb)
                 if (request._get) cb(null)
+              } else if (get && node) {
+                const sv = node._ && node._[">"]
+                if (sv && Object.keys(sv).length > 0 && typeof sv[item] === "undefined") {
+                  // State vector has other properties but not this one — never written.
+                  if (cb) cb(null)
+                } else {
+                  // Empty state vector or item is tracked — may arrive via push.
+                  watchForRel(soul, item, ctx, i, request, cb, false)
+                }
               } else {
-                // Allow querying a node that doesn't exist.
+                // Soul doesn't exist or no get — return null.
                 if (cb) cb(null)
               }
             }
           },
-          {...request._opt, secure: ctx.user || opt.secure},
+          {...request._opt, secure: !!(ctx.user || opt.secure)},
         )
         // Callback has been passed to next soul lookup or called above, so
         // return false as the calling code should not continue.
@@ -387,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
@@ -406,7 +437,7 @@ const Holster = opt => {
 
         // Resolve the current context before putting data. (Note that set is
         // not passed to resolve because it's already been applied above.)
-        const {item, soul} = resolve({put: data}, _ack)
+        const {item, soul} = resolve({put: data, _opt: {put: true}}, _ack)
         if (!soul) return
 
         if (result === true) {
@@ -475,7 +506,7 @@ const Holster = opt => {
                 wire.put(g, _ack)
               })
             },
-            {secure: ctx.user || opt.secure},
+            {secure: !!(ctx.user || opt.secure), put: true},
           )
           return
         }
@@ -515,7 +546,7 @@ const Holster = opt => {
                   } else {
                     const _ctxid = utils.text.random()
                     const chain = [{item: item, soul: soul}]
-                    // Pass on the previous context's callback and user flag here.
+                    // Pass on the previous ctx's callback and user flag here.
                     allctx.set(_ctxid, {
                       chain: chain,
                       user: ctx.user,
@@ -564,7 +595,7 @@ const Holster = opt => {
 
               wire.put(g, _ack)
             },
-            {secure: ctx.user || opt.secure},
+            {secure: !!(ctx.user || opt.secure), put: true},
           )
         }
         attemptRead()
@@ -611,8 +642,8 @@ const Holster = opt => {
         map.set(cb, () => {
           // Bail out if off() has already cleaned up this context — the mapped
           // callback can fire twice (once from wire.on and once from the _get
-          // immediate-read path) and the second call after async context cleanup
-          // would crash in resolve(). Matches the guard in watchForRel.
+          // immediate-read path) and the second call after async context
+          // cleanup would crash in resolve(). Matches the guard in watchForRel.
           if (!allctx.has(ctxid)) return
           // Cancel any pending retry — the persistent listener firing means we
           // have an update and should not call cb twice.
@@ -635,7 +666,8 @@ const Holster = opt => {
                       chain: [{item: null, soul: id}],
                       user: ctx ? ctx.user : null,
                     })
-                    api(_ctxid).next(null, res, retries === 0 ? utils.obj.put(_opt, "fast", true) : _opt)
+                    api(_ctxid).next(null, res, retries === 0 ?
+                                     utils.obj.put(_opt, "fast", true) : _opt)
                   })
                   if (data !== null || retries >= 5) {
                     retryCount = 0 // Reset retry counter on success
@@ -661,7 +693,8 @@ const Holster = opt => {
                   // miss and never fire again if the data doesn't change while
                   // the listener is attached, so we must poll for initial load.
                   const retry = () => {
-                    const delay = Math.min(retryDelay * Math.pow(2, retryCount), 30000)
+                    const delay =
+                          Math.min(retryDelay * Math.pow(2, retryCount), 30000)
                     retryCount++
                     retryTimer = setTimeout(() => {
                       wire.get(
@@ -680,7 +713,7 @@ const Holster = opt => {
                             cb(null)
                           }
                         },
-                        {..._opt, secure: ctx.user || opt.secure},
+                        {..._opt, secure: !!(ctx.user || opt.secure)},
                       )
                     }, delay)
                   }
@@ -690,7 +723,7 @@ const Holster = opt => {
                 }
               }
             },
-            {..._opt, secure: ctx.user || opt.secure},
+            {..._opt, secure: !!(ctx.user || opt.secure)},
           )
         })
 
@@ -727,17 +760,14 @@ 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.
               map.get(cb)()
             }
           },
-          {..._opt, secure: ctx.user || opt.secure},
+          {..._opt, secure: !!(ctx.user || opt.secure)},
         )
       },
       off: cb => {
@@ -751,9 +781,10 @@ const Holster = opt => {
         const {item, soul} = resolve({off: true}, cb)
         if (!soul) return
 
-        // Remove listener immediately from the original soul to avoid race condition.
-        // The listener may be on a related soul if item is a rel, but we remove
-        // from the original soul first since that's where it's initially registered.
+        // Remove listener immediately from the original soul to avoid a race
+        // condition. The listener may be on a related soul if item is a rel,
+        // but we remove from the original soul first since that's where it's
+        //initially registered.
         wire.off({"#": soul}, map.get(cb))
 
         // Check if item is a rel and remove from the related node as well.

package/src/index.js

@@ -3,7 +3,7 @@ import path from "path"
 import {fileURLToPath} from "url"
 import Holster from "./holster.js"
 
-const holster = Holster()
+const holster = Holster({port: 8765})
 
 // Note that express is only used here to serve the examples folder. It is not
 // required to run Holster itself.

package/src/radisk.js

@@ -34,7 +34,6 @@ const Radisk = opt => {
   if (!opt.write) opt.write = 1 // Wait time before write in milliseconds
   if (!opt.size) opt.size = 1024 * 1024 // File size on disk, default 1MB
   if (!opt.memoryLimit) opt.memoryLimit = 500 // Memory limit in MB
-  if (!opt.readTimeout) opt.readTimeout = 1000 // Read timeout in milliseconds
   if (typeof opt.cache === "undefined") opt.cache = true
 
   if (!opt.store) {
@@ -59,7 +58,7 @@ const Radisk = opt => {
   // Performance logging
   const perfLog = (operation, startTime, key, size) => {
     const duration = Date.now() - startTime
-    if (duration > 2000) {
+    if (duration > 3000) {
       console.log(
         `[RADISK-SLOW] ${operation}: ${duration}ms for ${key}${size ? ` (${size} bytes)` : ""}`,
       )
@@ -124,37 +123,29 @@ const Radisk = opt => {
         }
       }
 
-      // Check if there's already a pending read for this key
       if (pendingReads.has(key)) {
-        // Add callback to existing pending read
-        pendingReads.get(key).callbacks.push(cb)
+        pendingReads.get(key).push(cb)
         return
       }
 
-      // Start new read and create callback queue with fired flag
-      const pending = {callbacks: [cb], fired: false, timeoutId: null}
-      pendingReads.set(key, pending)
-
-      // Set a timeout to fire callbacks if read takes too long
-      pending.timeoutId = setTimeout(() => {
-        if (!pending.fired) {
-          pending.fired = true
-          pendingReads.delete(key)
-          const err = new Error("radisk read timeout")
-          pending.callbacks.forEach(callback => callback(err, undefined))
-        }
-      }, opt.readTimeout)
-
+      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.
+      const timeout = setTimeout(() => {
+        const callbacks = pendingReads.get(key)
+        if (!callbacks) return
+        opt.log(`radisk read hang detected for key: ${key}`)
+        pendingReads.delete(key)
+        callbacks.forEach(callback => callback(null, null))
+      }, 30000)
       return radisk.read(key, (err, result) => {
-        clearTimeout(pending.timeoutId)
+        clearTimeout(timeout)
         perfLog("read", readStart, key)
-        // Execute all pending callbacks for this key if timeout hasn't fired
-        if (!pending.fired) {
-          pending.fired = true
-          pendingReads.delete(key)
-          pending.callbacks.forEach(callback => callback(err, result))
-        }
+        const callbacks = pendingReads.get(key) || []
+        pendingReads.delete(key)
+        callbacks.forEach(callback => callback(err, result))
       })
     }
 
@@ -288,6 +279,8 @@ const Radisk = opt => {
       limit: "",
       done: false,
       count: 0,
+      halfKey: "",   // soul ID at the ~opt.size/2 mark for a balanced split
+      halfOffset: 0, // write.text.length before that entry
       each: (value, key, k, pre) => {
         // each is called for all keys, but stop adding to write.text when
         // write.slice is called, then the current contents of write.text
@@ -298,17 +291,46 @@ const Radisk = opt => {
         value = typeof value === "undefined" ? "" : "=" + Radisk.encode(value)
         const enc =
           Radisk.encode(pre.length) + "#" + Radisk.encode(k) + value + "\n"
-        // Cannot split the file if only have one entry to write. Also don't
-        // start a split if in the middle of writing a node (pre > 0).
+        // Cannot split the file if only have one entry to write. Allow splitting
+        // at depth > 0 only when k itself contains enq, meaning k is a full
+        // "soulId\x05property" key, not merely a property suffix of a shared
+        // soul prefix. Use the full key (pre + k) to extract the soul boundary.
+        const validBoundary =
+          pre.length === 0 || (pre.length === 1 && k.includes(enq))
+
+        // Record the first valid split boundary past the halfway mark so a
+        // full overflow can split here instead of at the tail, keeping both
+        // halves near opt.size/2 rather than leaving the file always full.
+        if (
+          !write.halfKey &&
+          write.count > 1 &&
+          write.text.length > opt.size / 2 &&
+          validBoundary
+        ) {
+          const fullKey = pre.join("") + k
+          const end = fullKey.indexOf(enq)
+          write.halfKey =
+            end === -1 ? fullKey : fullKey.substring(0, end)
+          write.halfOffset = write.text.length
+        }
+
         if (
           write.count > 1 &&
-          pre.length === 0 &&
-          write.text.length + enc.length > opt.size
+          write.text.length + enc.length > opt.size &&
+          validBoundary
         ) {
-          const end = k.indexOf(enq)
-          write.limit = end === -1 ? k : k.substring(0, end)
-          // Cannot split if they key is the same as the current file name.
+          const fullKey = pre.join("") + k
+          const end = fullKey.indexOf(enq)
+          write.limit =
+            write.halfKey ||
+            (end === -1 ? fullKey : fullKey.substring(0, end))
+          // Cannot split if the key is the same as the current file name.
           if (write.limit !== file) {
+            // Truncate to the balanced split point — text after halfOffset is
+            // handled by the write.slice call below, which reads from rad.
+            if (write.halfKey) {
+              write.text = write.text.substring(0, write.halfOffset)
+            }
             write.done = true
             write.sub = Radix()
             Radix.map(rad, write.slice)
@@ -330,6 +352,13 @@ const Radisk = opt => {
     // 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
+      // from disk rather than re-writing those entries back to this file.
+      if (write.done) {
+        cache.delete(file)
+        fileListCache = null
+      }
       perfLog("file-write", writeStart, file, write.text.length)
       cb(err)
     })
@@ -340,71 +369,45 @@ const Radisk = opt => {
     const end = key.indexOf(enq)
     const soul = end === -1 ? key : key.substring(0, end)
 
-    const read = {
-      lex: file => {
-        // store.list should call lex without a file last, which means all file
-        // names were compared to soul, so the current read.file is ok to use.
-        if (!file) {
-          if (!read.file) {
-            cb("no file found", u)
-            return
-          }
-
-          // Check multi-file cache first
-          if (opt.cache && cache.has(read.file)) {
-            const cachedRadix = cache.get(read.file)
-            read.value = cachedRadix(key)
-            // Return cached result (defined or undefined) since in-memory
-            // radix tree is authoritative
-            return cb(u, read.value)
-          }
-
-          radisk.parse(read.file, read.it)
-          return
-        }
-
-        // Want the filename closest to soul.
-        if (file > soul || file < read.file) return
+    // Binary search for largest filename <= soul in a sorted array.
+    const findFile = files => {
+      let lo = 0, hi = files.length - 1, result = null
+      while (lo <= hi) {
+        const mid = (lo + hi) >> 1
+        if (files[mid] <= soul) { result = files[mid]; lo = mid + 1 }
+        else { hi = mid - 1 }
+      }
+      return result
+    }
 
-        read.file = file
-      },
-      it: (err, disk) => {
+    const read = file => {
+      if (!file) { cb("no file found", u); return }
+      if (opt.cache && cache.has(file)) {
+        return cb(u, cache.get(file)(key))
+      }
+      radisk.parse(file, (err, disk) => {
         if (err) opt.log(err)
-        if (disk) {
-          if (opt.cache) {
-            cache.set(read.file, disk)
-            checkMemoryUsage() // Check memory usage after adding to cache
-          }
-          read.value = disk(key)
+        if (disk && opt.cache) {
+          cache.set(file, disk)
+          checkMemoryUsage()
         }
-        cb(err, read.value)
-      },
+        cb(err, disk ? disk(key) : u)
+      })
     }
+
     const now = Date.now()
-    if (
-      opt.cache &&
-      fileListCache &&
-      now - fileListCacheTime < FILE_LIST_CACHE_TTL
-    ) {
-      // Use cached file list
-      fileListCache.forEach(file => read.lex(file))
-      read.lex() // Signal end of list
+    if (opt.cache && fileListCache && now - fileListCacheTime < FILE_LIST_CACHE_TTL) {
+      read(findFile(fileListCache, soul))
     } else {
-      // Refresh cache
       const files = []
-      const originalLex = read.lex
-      read.lex = file => {
-        if (file) files.push(file)
-        return originalLex(file)
-      }
-
       opt.store.list(file => {
-        read.lex(file)
-        if (!file && opt.cache) {
-          // End of list - cache the results
+        if (file) { files.push(file); return }
+        files.sort()
+        if (opt.cache) {
           fileListCache = files
           fileListCacheTime = now
         }
+        read(findFile(files, soul))
       })
     }
   }

package/src/sea-utils.js

@@ -1,6 +1,6 @@
 import SafeBuffer from "./buffer.js"
 
-const isNode = typeof document === "undefined"
+const isNode = typeof process !== "undefined" && process.versions?.node != null
 const crypto = isNode
   ? (await import(/*webpackIgnore: true*/ "node:crypto")).webcrypto
   : globalThis.crypto

package/src/store.js

@@ -2,7 +2,7 @@ import Radisk from "./radisk.js"
 import Radix from "./radix.js"
 import * as utils from "./utils.js"
 
-const isNode = typeof document === "undefined"
+const isNode = typeof process !== "undefined" && process.versions?.node != null
 const fs = isNode ? await import(/*webpackIgnore: true*/ "node:fs") : undefined
 
 // ASCII character for enquiry.

package/src/user.js

@@ -5,7 +5,6 @@ import {userPublicKey, userSignature} from "./utils.js"
 
 const User = (opt, wire) => {
   if (!wire) wire = Wire(opt)
-  const wait = opt?.wait ?? 5000
   let pubs = []
   let creating = false
   let authing = false
@@ -76,7 +75,6 @@ const User = (opt, wire) => {
 
           done(null)
         },
-        {wait: wait},
       )
     }
 
@@ -103,7 +101,6 @@ const User = (opt, wire) => {
         pubs = Object.keys(data)
         next()
       },
-      {wait: wait},
     )
   }
 
@@ -183,7 +180,6 @@ const User = (opt, wire) => {
             })
           })
         },
-        {wait: wait},
       )
     },
     auth: (username, password, cb) => {