hyperbee2 2.1.1 → 2.3.0

package/index.js

@@ -6,14 +6,7 @@ const { ChangesStream } = require('./lib/changes.js')
 const NodeCache = require('./lib/cache.js')
 const WriteBatch = require('./lib/write.js')
 const CoreContext = require('./lib/context.js')
-const {
-  Pointer,
-  KeyPointer,
-  ValuePointer,
-  TreeNode,
-  TreeNodePointer,
-  EMPTY
-} = require('./lib/tree.js')
+const { Pointer, KeyPointer, ValuePointer, TreeNode, EMPTY } = require('./lib/tree.js')
 const { DeltaOp, DeltaCohort, OP_COHORT } = require('./lib/compression.js')
 
 class Hyperbee {
@@ -22,26 +15,27 @@ class Hyperbee {
       t = 128, // legacy number for now, should be 128 now
       key = null,
       encryption = null,
-      core = key ? store.get(key) : store.get({ key, name: 'bee', encryption }),
-      context = new CoreContext(store, core, core, encryption, t),
       maxCacheSize = 4096,
-      cache = new NodeCache(maxCacheSize),
+      core = key ? store.get(key) : store.get({ key, name: 'bee', encryption }),
+      context = new CoreContext(store, core, new NodeCache(maxCacheSize), core, encryption, t),
       root = null,
       activeRequests = [],
       view = false,
       writable = true,
-      unbatch = 0
+      unbatch = 0,
+      autoUpdate = false
     } = options
 
     this.store = store
     this.root = root
-    this.cache = cache
     this.context = context
     this.activeRequests = activeRequests
     this.view = view
     this.writable = writable
     this.unbatch = unbatch
 
+    this._autoUpdate = autoUpdate
+
     this.ready().catch(noop)
   }
 
@@ -55,6 +49,10 @@ class Hyperbee {
     return { length: this.root.seq + 1, key: this.root.context.core.key }
   }
 
+  get cache() {
+    return this.context.cache
+  }
+
   get core() {
     return this.context.core
   }
@@ -82,7 +80,6 @@ class Hyperbee {
   _makeView(context, root, writable, unbatch) {
     return new Hyperbee(this.store, {
       context,
-      cache: this.cache,
       root,
       view: true,
       writable,
@@ -92,7 +89,7 @@ class Hyperbee {
 
   checkout({ length = this.core.length, key = null, writable = false } = {}) {
     const context = key ? this.context.getContextByKey(key) : this.context
-    const root = length === 0 ? EMPTY : new TreeNodePointer(context, 0, length - 1, 0, false, null)
+    const root = length === 0 ? EMPTY : context.createTreeNode(0, length - 1, 0, false, null)
     return this._makeView(context, root, writable, 0)
   }
 
@@ -116,7 +113,13 @@ class Hyperbee {
     this.root =
       this.context.core.length === 0
         ? EMPTY
-        : new TreeNodePointer(this.context, 0, this.core.length - 1, 0, false, null)
+        : this.context.createTreeNode(0, this.core.length - 1, 0, false, null)
+
+    if (this._autoUpdate) {
+      this.core.on('append', () => {
+        this.update()
+      })
+    }
   }
 
   async close() {
@@ -154,12 +157,12 @@ class Hyperbee {
 
   bump(ptr) {
     if (ptr.changed) return ptr.value
-    this.cache.bump(ptr)
-    this.cache.gc()
+    this.context.cache.bump(ptr)
+    this.context.cache.gc()
     return ptr.value
   }
 
-  // TODO: unslab these and parallize
+  // TODO: unslab these
   async inflate(ptr, activeRequests = this.activeRequests) {
     if (ptr.value) {
       this.bump(ptr)
@@ -259,7 +262,7 @@ class Hyperbee {
 
     if (expected === this.unbatch) {
       this.context = context
-      this.root = length === 0 ? EMPTY : new TreeNodePointer(context, 0, length - 1, 0, false, null)
+      this.root = length === 0 ? EMPTY : context.createTreeNode(0, length - 1, 0, false, null)
       this.unbatch = 0
     }
   }
@@ -361,7 +364,7 @@ function inflateChild(context, d, ptr, block, activeRequests) {
 
 function inflateChildDelta(context, d, ptr, block, activeRequests) {
   const p = d.pointer
-  const c = p && new TreeNodePointer(context, p.core, p.seq, p.offset, false, null)
+  const c = p && context.createTreeNode(p.core, p.seq, p.offset, false, null)
   return new DeltaOp(false, d.type, d.index, c)
 }
 

package/lib/cache.js

@@ -3,6 +3,8 @@ module.exports = class NodeCache {
     this.size = 0
     this.maxSize = maxSize
     this.latest = null
+    this.retained = 0
+    this.byId = new Map()
   }
 
   oldest() {
@@ -20,7 +22,7 @@ module.exports = class NodeCache {
   gc() {
     while (this.size > this.maxSize) {
       const old = this.oldest()
-      if (old.changed) break
+      if (old.retained > this.retained) break
       this.remove(old)
       old.value = null
     }
@@ -29,6 +31,10 @@ module.exports = class NodeCache {
   bump(node) {
     if (node === this.latest) return
 
+    if (node.next === null && node.prev === null) {
+      this.byId.set(cacheId(node), node)
+    }
+
     if (node.prev) this.remove(node)
     this.size++
 
@@ -44,6 +50,10 @@ module.exports = class NodeCache {
     }
   }
 
+  get(node) {
+    return this.byId.get(cacheId(node)) || null
+  }
+
   remove(node) {
     if (node.prev) {
       this.size--
@@ -57,6 +67,11 @@ module.exports = class NodeCache {
     }
 
     node.prev = node.next = null
+
+    const id = cacheId(node)
+    if (this.byId.get(id) === node) {
+      this.byId.delete(id)
+    }
   }
 
   *[Symbol.iterator]() {
@@ -71,3 +86,8 @@ module.exports = class NodeCache {
     } while (node !== next)
   }
 }
+
+function cacheId(node) {
+  const id = node.core === 0 ? node.context.core.id : node.context.opened[node.core - 1].id
+  return id + '@' + node.seq + '.' + node.offset
+}

package/lib/compression.js

@@ -23,6 +23,8 @@ class CompressedArray {
   constructor(delta) {
     this.entries = []
     this.delta = delta
+    this.uentries = null
+    this.updates = 0
 
     for (const d of delta) {
       if (d.type === OP_COHORT) {
@@ -39,8 +41,32 @@ class CompressedArray {
     return this.entries.length
   }
 
-  touch(index) {
-    const pointer = this.entries[index]
+  get ulength() {
+    return this.uentries ? this.uentries.length : this.entries.length
+  }
+
+  commit() {
+    const c = new CompressedArray([])
+
+    c.delta = this.delta
+    c.entries = this.uentries || this.entries.slice(0)
+
+    this.delta = this.delta.slice(0, this.updates)
+    this.uentries = null
+    this.updates = 0
+
+    return c
+  }
+
+  _update() {
+    if (this.uentries) return
+    this.uentries = this.entries.slice(0)
+  }
+
+  touch(index, pointer) {
+    if (pointer) this.entries[index] = pointer
+    else pointer = this.entries[index]
+
     if (pointer.changedBy === this) return
     this.set(index, pointer)
   }
@@ -49,8 +75,13 @@ class CompressedArray {
     return this.entries[index]
   }
 
+  uget(index) {
+    return this.uentries ? this.uentries[index] : this.entries[index]
+  }
+
   push(pointer) {
-    this.insert(this.entries.length, pointer)
+    if (!this.uentries) this._update()
+    this.insert(this.uentries.length, pointer)
   }
 
   unshift(pointer) {
@@ -58,37 +89,43 @@ class CompressedArray {
   }
 
   pop() {
-    if (this.entries.length === 0) return
-    const head = this.entries[this.entries.length - 1]
-    this.delete(this.entries.length - 1)
+    if (!this.uentries) this._update()
+    if (this.uentries.length === 0) return
+    const head = this.uentries[this.uentries.length - 1]
+    this.delete(this.uentries.length - 1)
     return head
   }
 
   shift() {
-    if (this.entries.length === 0) return
-    const tail = this.entries[0]
+    if (!this.uentries) this._update()
+    if (this.uentries.length === 0) return
+    const tail = this.uentries[0]
     this.delete(0)
     return tail
   }
 
   _touch(pointer) {
+    this.updates++
     if (pointer) pointer.changedBy = this
   }
 
   insert(index, pointer) {
-    if (!insert(this.entries, index, pointer)) return
+    if (!this.uentries) this._update()
+    if (!insert(this.uentries, index, pointer)) return
     this._touch(pointer)
     this.delta.push(new DeltaOp(true, OP_INSERT, index, pointer))
   }
 
   delete(index) {
-    if (!del(this.entries, index)) return
+    if (!this.uentries) this._update()
+    if (!del(this.uentries, index)) return
     this._touch(null)
     this.delta.push(new DeltaOp(true, OP_DEL, index, null))
   }
 
   set(index, pointer) {
-    if (!set(this.entries, index, pointer)) return
+    if (!this.uentries) this._update()
+    if (!set(this.uentries, index, pointer)) return
     this._touch(pointer)
     this.delta.push(new DeltaOp(true, OP_SET, index, pointer))
   }

package/lib/context.js

@@ -1,11 +1,13 @@
 const b4a = require('b4a')
 const ScopeLock = require('scope-lock')
+const { TreeNodePointer } = require('./tree.js')
 const { decodeBlock } = require('./encoding.js')
 
 class CoreContext {
-  constructor(store, local, core, encryption, t, lock = new ScopeLock(), other = new Map()) {
+  constructor(store, local, cache, core, encryption, t, lock = new ScopeLock(), other = new Map()) {
     this.store = store
     this.local = local
+    this.cache = cache
     this.core = core
     this.t = t
     this.minKeys = t - 1
@@ -52,6 +54,14 @@ class CoreContext {
     this.length = length
   }
 
+  createTreeNode(core, seq, offset, changed, value) {
+    const ptr = new TreeNodePointer(this, core, seq, offset, changed, value)
+    if (ptr.value || changed) return ptr
+    const existing = this.cache.get(ptr)
+    if (existing) return existing
+    return ptr
+  }
+
   getCoreOffsetLocal(context, core) {
     if (context === this) return core
 
@@ -171,11 +181,12 @@ class CoreContext {
   _createContext(core) {
     const store = this.store
     const local = this.local
+    const cache = this.cache
     const encryption = this.encryption
     const t = this.t
     const lock = this.lock
     const other = this.other
-    return new CoreContext(store, local, core, encryption, t, lock, other)
+    return new CoreContext(store, local, cache, core, encryption, t, lock, other)
   }
 }
 

package/lib/tree.js

@@ -23,9 +23,14 @@ class Pointer {
     this.seq = seq
     this.offset = offset
     this.changed = changed
+    this.retained = 0
 
     this.changedBy = null
   }
+
+  retain() {
+    this.retained = this.context.cache.retained + 1
+  }
 }
 
 class KeyPointer extends Pointer {
@@ -38,11 +43,9 @@ class KeyPointer extends Pointer {
   }
 
   // TODO: remove, left here for easier debugging for now
-  // [Symbol.for('nodejs.util.inspect.custom')]() {
-  //   return (
-  //     `[KeyPointer core=${this.core} seq=${this.seq}, offset=${this.offset}, key="${b4a.toString(this.key)}"]`
-  //   )
-  // }
+  [Symbol.for('nodejs.util.inspect.custom')]() {
+    return `[KeyPointer core=${this.core} seq=${this.seq}, offset=${this.offset}, key="${b4a.toString(this.key)}"]`
+  }
 }
 
 class TreeNodePointer extends Pointer {
@@ -55,12 +58,19 @@ class TreeNodePointer extends Pointer {
     this.prev = null
   }
 
+  commit() {
+    this.changed = false
+    const value = new TreeNode([], [])
+    value.keys = this.value.keys.commit()
+    value.children = this.value.children.commit()
+    const ptr = this.context.createTreeNode(this.core, 0, 0, true, value)
+    return ptr
+  }
+
   // TODO: remove, left here for easier debugging for now
-  // [Symbol.for('nodejs.util.inspect.custom')]() {
-  //   return (
-  //     `[TreeNodePointer core=${this.core} seq=${this.seq} offset=${this.offset} changed=${this.changed}]`
-  //   )
-  // }
+  [Symbol.for('nodejs.util.inspect.custom')]() {
+    return `[TreeNodePointer core=${this.core} seq=${this.seq} offset=${this.offset} changed=${this.changed}]`
+  }
 }
 
 class TreeNode {
@@ -70,17 +80,17 @@ class TreeNode {
   }
 
   isEmpty() {
-    return this.keys.length === 0 && this.children.length === 0
+    return this.keys.ulength === 0 && this.children.ulength === 0
   }
 
   insertLeaf(context, key, value) {
     let s = 0
-    let e = this.keys.length
+    let e = this.keys.ulength
     let c = 0
 
     while (s < e) {
       const mid = (s + e) >> 1
-      const k = this.keys.get(mid)
+      const k = this.keys.uget(mid)
 
       c = b4a.compare(key, k.key)
 
@@ -91,19 +101,20 @@ class TreeNode {
     }
 
     const i = c < 0 ? e : s
+
     this.keys.insert(i, new KeyPointer(context, 0, 0, 0, true, key, value, null))
 
-    return this.keys.length <= context.maxKeys ? INSERTED : NEEDS_SPLIT
+    return this.keys.ulength <= context.maxKeys ? INSERTED : NEEDS_SPLIT
   }
 
   insertNode(context, keyPointer, treePointer) {
     let s = 0
-    let e = this.keys.length
+    let e = this.keys.ulength
     let c = 0
 
     while (s < e) {
       const mid = (s + e) >> 1
-      const k = this.keys.get(mid)
+      const k = this.keys.uget(mid)
 
       c = b4a.compare(keyPointer.key, k.key)
 
@@ -117,16 +128,16 @@ class TreeNode {
     this.keys.insert(i, keyPointer)
     this.children.insert(i + 1, treePointer)
 
-    return this.keys.length <= context.maxKeys ? INSERTED : NEEDS_SPLIT
+    return this.keys.ulength <= context.maxKeys ? INSERTED : NEEDS_SPLIT
   }
 
   setValue(context, i, value) {
-    this.keys.set(i, new KeyPointer(context, 0, 0, 0, true, this.keys.get(i).key, value, null))
+    this.keys.set(i, new KeyPointer(context, 0, 0, 0, true, this.keys.uget(i).key, value, null))
   }
 
   removeKey(i) {
     this.keys.delete(i)
-    if (this.children.length) {
+    if (this.children.ulength) {
       this.children.delete(i + 1)
     }
   }
@@ -134,11 +145,11 @@ class TreeNode {
   siblings(parent) {
     const pc = parent.children
 
-    for (let i = 0; i < pc.length; i++) {
-      if (pc.get(i).value !== this) continue // TODO: move to a seq/offset check instead
+    for (let i = 0; i < pc.ulength; i++) {
+      if (pc.uget(i).value !== this) continue // TODO: move to a seq/offset check instead
 
-      const left = i ? pc.get(i - 1) : null
-      const right = i < pc.length - 1 ? pc.get(i + 1) : null
+      const left = i ? pc.uget(i - 1) : null
+      const right = i < pc.ulength - 1 ? pc.uget(i + 1) : null
       return { left, index: i, right }
     }
 
@@ -152,13 +163,13 @@ class TreeNode {
 
     this.keys.push(median)
 
-    for (let i = 0; i < keys.length; i++) this.keys.push(keys.get(i))
-    for (let i = 0; i < children.length; i++) this.children.push(children.get(i))
+    for (let i = 0; i < keys.ulength; i++) this.keys.push(keys.uget(i))
+    for (let i = 0; i < children.ulength; i++) this.children.push(children.uget(i))
   }
 
   split(context) {
-    const len = this.keys.length >> 1
-    const right = new TreeNodePointer(context, 0, 0, 0, true, new TreeNode([], []))
+    const len = this.keys.ulength >> 1
+    const right = context.createTreeNode(0, 0, 0, true, new TreeNode([], []))
 
     const k = []
     while (k.length < len) k.push(this.keys.pop())
@@ -166,7 +177,7 @@ class TreeNode {
 
     const median = this.keys.pop()
 
-    if (this.children.length) {
+    if (this.children.ulength) {
       const c = []
       while (c.length < len + 1) c.push(this.children.pop())
       for (let i = c.length - 1; i >= 0; i--) right.value.children.push(c[i])

package/lib/write.js

@@ -2,15 +2,7 @@ const b4a = require('b4a')
 const c = require('compact-encoding')
 const { OP_COHORT } = require('./compression.js')
 const { encodeBlock, TYPE_COMPAT, TYPE_LATEST } = require('./encoding.js')
-const {
-  Pointer,
-  KeyPointer,
-  ValuePointer,
-  TreeNode,
-  TreeNodePointer,
-  INSERTED,
-  NEEDS_SPLIT
-} = require('./tree.js')
+const { Pointer, KeyPointer, ValuePointer, TreeNode, INSERTED, NEEDS_SPLIT } = require('./tree.js')
 
 const PREFERRED_BLOCK_SIZE = 4096
 const INLINE_VALUE_SIZE = 4096
@@ -86,7 +78,7 @@ module.exports = class WriteBatch {
       const value = changed ? new TreeNode([], []) : null
 
       this.length = length
-      this.root = new TreeNodePointer(context, 0, seq, 0, changed, value)
+      this.root = context.createTreeNode(0, seq, 0, changed, value)
 
       for (const op of ops) {
         if (op.put) op.applied = await this._put(op.key, op.value)
@@ -113,27 +105,28 @@ module.exports = class WriteBatch {
   async _put(key, value) {
     const stack = []
     const target = key
+    const snap = this.snapshot
 
     let ptr = this.root
 
     while (true) {
-      const v = ptr.value ? this.snapshot.bump(ptr) : await this.snapshot.inflate(ptr)
-      if (!v.children.length) break
+      const v = await retainAndInflate(ptr, snap)
+      if (!v.children.ulength) break
 
       stack.push(ptr)
 
       let s = 0
-      let e = v.keys.length
+      let e = v.keys.ulength
       let c = 0
 
       while (s < e) {
         const mid = (s + e) >> 1
-        const m = v.keys.get(mid)
+        const m = v.keys.uget(mid)
 
         c = b4a.compare(target, m.key)
 
         if (c === 0) {
-          const existing = await this.snapshot.inflateValue(m)
+          const existing = await snap.inflateValue(m)
           if (b4a.equals(existing, value)) return false
           v.setValue(this.tree.context, mid, value)
           for (let i = 0; i < stack.length; i++) stack[i].changed = true
@@ -145,16 +138,16 @@ module.exports = class WriteBatch {
       }
 
       const i = c < 0 ? e : s
-      ptr = v.children.get(i)
+      ptr = v.children.uget(i)
     }
 
-    const v = ptr.value ? this.snapshot.bump(ptr) : await this.snapshot.inflate(ptr)
+    const v = await retainAndInflate(ptr, snap)
     let status = v.insertLeaf(this.tree.context, target, value)
 
     if (status >= 0) {
       // already exists, upsert if changed
-      const m = v.keys.get(status)
-      const existing = await this.snapshot.inflateValue(m)
+      const m = v.keys.uget(status)
+      const existing = await snap.inflateValue(m)
       if (b4a.equals(existing, value)) return false
       v.setValue(this.tree.context, status, value)
     }
@@ -163,20 +156,19 @@ module.exports = class WriteBatch {
     for (let i = 0; i < stack.length; i++) stack[i].changed = true
 
     while (status === NEEDS_SPLIT) {
-      const v = ptr.value ? this.snapshot.bump(ptr) : await this.snapshot.inflate(ptr)
+      const v = await retainAndInflate(ptr, snap)
       const parent = stack.pop()
       const { median, right } = v.split(this.tree.context)
 
       if (parent) {
-        const p = parent.value ? this.snapshot.bump(parent) : await this.snapshot.inflate(parent)
+        const p = await retainAndInflate(parent, snap)
         status = p.insertNode(this.tree.context, median, right)
         ptr = parent
       } else {
-        this.root = new TreeNodePointer(this.tree.context, 0, 0, 0, true, new TreeNode([], []))
+        this.root = this.tree.context.createTreeNode(0, 0, 0, true, new TreeNode([], []))
         this.root.value.keys.push(median)
         this.root.value.children.push(ptr)
         this.root.value.children.push(right)
-        this.snapshot.bump(this.root)
         status = INSERTED
       }
     }
@@ -190,19 +182,19 @@ module.exports = class WriteBatch {
     const stack = []
 
     while (true) {
-      const v = ptr.value ? this.snapshot.bump(ptr) : await this.snapshot.inflate(ptr)
+      const v = await retainAndInflate(ptr, this.snapshot)
       stack.push(ptr)
 
       let s = 0
-      let e = v.keys.length
+      let e = v.keys.ulength
       let c = 0
 
       while (s < e) {
         const mid = (s + e) >> 1
-        c = b4a.compare(key, v.keys.get(mid).key)
+        c = b4a.compare(key, v.keys.uget(mid).key)
 
         if (c === 0) {
-          if (v.children.length) await this._setKeyToNearestLeaf(v, mid, stack)
+          if (v.children.ulength) await this._setKeyToNearestLeaf(v, mid, stack)
           else v.removeKey(mid)
           // we mark these as changed late, so we don't rewrite them if it is a 404
           for (let i = 0; i < stack.length; i++) stack[i].changed = true
@@ -214,88 +206,92 @@ module.exports = class WriteBatch {
         else s = mid + 1
       }
 
-      if (!v.children.length) return false
+      if (!v.children.ulength) return false
 
       const i = c < 0 ? e : s
-      ptr = v.children.get(i)
+      ptr = v.children.uget(i)
     }
 
     return false
   }
 
   async _setKeyToNearestLeaf(v, index, stack) {
-    let left = v.children.get(index)
-    let right = v.children.get(index + 1)
+    const snap = this.snapshot
+
+    let left = v.children.uget(index)
+    let right = v.children.uget(index + 1)
 
     const [ls, rs] = await Promise.all([this._leafSize(left, false), this._leafSize(right, true)])
 
     if (ls < rs) {
       // if fewer leaves on the left
       stack.push(right)
-      let r = right.value ? this.snapshot.bump(right) : await this.snapshot.inflate(right)
-      while (r.children.length) {
-        right = r.children.get(0)
+      let r = await retainAndInflate(right, snap)
+      while (r.children.ulength) {
+        right = r.children.uget(0)
         stack.push(right)
-        r = right.value ? this.snapshot.bump(right) : await this.snapshot.inflate(right)
+        r = await retainAndInflate(right, snap)
       }
       v.keys.set(index, r.keys.shift())
     } else {
       // if fewer leaves on the right
       stack.push(left)
-      let l = left.value ? this.snapshot.bump(left) : await this.snapshot.inflate(left)
-      while (l.children.length) {
-        left = l.children.get(l.children.length - 1)
+      let l = await retainAndInflate(left, snap)
+      while (l.children.ulength) {
+        left = l.children.uget(l.children.ulength - 1)
         stack.push(left)
-        l = left.value ? this.snapshot.bump(left) : await this.snapshot.inflate(left)
+        l = await retainAndInflate(left, snap)
       }
       v.keys.set(index, l.keys.pop())
     }
   }
 
   async _leafSize(ptr, goLeft) {
-    let v = ptr.value ? this.snapshot.bump(ptr) : await this.snapshot.inflate(ptr)
-    while (v.children.length) {
-      ptr = v.children.get(goLeft ? 0 : v.children.length - 1)
-      v = ptr.value ? this.snapshot.bump(ptr) : await this.snapshot.inflate(ptr)
+    const snap = this.snapshot
+
+    let v = await retainAndInflate(ptr, snap)
+    while (v.children.ulength) {
+      ptr = v.children.uget(goLeft ? 0 : v.children.ulength - 1)
+      v = await retainAndInflate(ptr, snap)
     }
-    return v.keys.length
+    return v.keys.ulength
   }
 
   async _rebalance(stack) {
     const root = stack[0]
     const minKeys = this.tree.context.minKeys
+    const snap = this.snapshot
 
     while (stack.length > 1) {
       const ptr = stack.pop()
       const parent = stack[stack.length - 1]
 
-      const v = ptr.value ? this.snapshot.bump(ptr) : await this.snapshot.inflate(ptr)
+      const v = await retainAndInflate(ptr, snap)
 
-      if (v.keys.length >= minKeys) return root
+      if (v.keys.ulength >= minKeys) return root
 
-      const p = parent.value ? this.snapshot.bump(parent) : await this.snapshot.inflate(parent)
+      const p = await retainAndInflate(parent, snap)
 
       let { left, index, right } = v.siblings(p)
 
-      let l = left && (left.value ? this.snapshot.bump(left) : await this.snapshot.inflate(left))
+      let l = left && (await retainAndInflate(left, snap))
 
       // maybe borrow from left sibling?
-      if (l && l.keys.length > minKeys) {
+      if (l && l.keys.ulength > minKeys) {
         left.changed = true
-        v.keys.unshift(p.keys.get(index - 1))
-        if (l.children.length) v.children.unshift(l.children.pop())
+        v.keys.unshift(p.keys.uget(index - 1))
+        if (l.children.ulength) v.children.unshift(l.children.pop())
         p.keys.set(index - 1, l.keys.pop())
         return root
       }
 
-      let r =
-        right && (right.value ? this.snapshot.bump(right) : await this.snapshot.inflate(right))
+      let r = right && (await retainAndInflate(right, snap))
 
       // maybe borrow from right sibling?
-      if (r && r.keys.length > minKeys) {
+      if (r && r.keys.ulength > minKeys) {
         right.changed = true
-        v.keys.push(p.keys.get(index))
-        if (r.children.length) v.children.push(r.children.shift())
+        v.keys.push(p.keys.uget(index))
+        if (r.children.ulength) v.children.push(r.children.shift())
         p.keys.set(index, r.keys.shift())
         return root
       }
@@ -311,15 +307,15 @@ module.exports = class WriteBatch {
       }
 
       left.changed = true
-      l.merge(r, p.keys.get(index))
+      l.merge(r, p.keys.uget(index))
 
       parent.changed = true
       p.removeKey(index)
     }
 
-    const r = root.value ? this.snapshot.bump(root) : await this.snapshot.inflate(root)
+    const r = await retainAndInflate(root, snap)
     // check if the tree shrunk
-    if (!r.keys.length && r.children.length) return r.children.get(0)
+    if (!r.keys.ulength && r.children.ulength) return r.children.uget(0)
     return root
   }
 
@@ -339,6 +335,8 @@ module.exports = class WriteBatch {
     let update = { size: 0, nodes: [], keys: [], values: [] }
     let minValue = -1
 
+    this.root = this.root.commit()
+
     const batch = [update]
     const stack = [this.root]
     const values = []
@@ -382,8 +380,9 @@ module.exports = class WriteBatch {
       for (let i = 0; i < children.entries.length; i++) {
         const c = children.entries[i]
         if (!c.value || !c.changed) continue
-        children.touch(i)
-        stack.push(c)
+        const node = c.commit()
+        children.touch(i, node)
+        stack.push(node)
       }
     }
 
@@ -515,6 +514,9 @@ module.exports = class WriteBatch {
         this.snapshot.bump(node)
       }
     }
+
+    context.cache.retained++
+    context.cache.gc()
   }
 }
 
@@ -597,3 +599,12 @@ function prepareCohorts(context, block, seq, deltas, keys) {
 function supportsCompression(type) {
   return type !== TYPE_COMPAT && type !== 0
 }
+
+async function retainAndInflate(ptr, snap) {
+  if (ptr.value) {
+    ptr.retain()
+    return ptr.value
+  }
+  ptr.retain()
+  return await snap.inflate(ptr)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hyperbee2",
-  "version": "2.1.1",
+  "version": "2.3.0",
   "description": "btree",
   "main": "index.js",
   "files": [