hyperbee2 1.1.2 → 1.2.0

package/index.js

@@ -1,7 +1,8 @@
 const b4a = require('b4a')
 const Hypercore = require('hypercore')
-const KeyValueStream = require('./lib/key-value-stream.js')
-const ChangesStream = require('./lib/changes-stream.js')
+const { RangeStream } = require('./lib/ranges.js')
+const { DiffStream } = require('./lib/diff.js')
+const { ChangesStream } = require('./lib/changes.js')
 const NodeCache = require('./lib/cache.js')
 const WriteBatch = require('./lib/write.js')
 const CoreContext = require('./lib/context.js')
@@ -111,7 +112,11 @@ class Hyperbee {
   }
 
   createReadStream(range) {
-    return new KeyValueStream(this, range)
+    return new RangeStream(this, range)
+  }
+
+  createDiffStream(right, range) {
+    return new DiffStream(this, right, range)
   }
 
   createChangesStream(options) {

package/lib/{changes-stream.js → changes.js}

@@ -1,8 +1,9 @@
 const { Readable } = require('streamx')
 
-module.exports = class ChangesStream extends Readable {
+class ChangesStream extends Readable {
   constructor(tree, options = {}) {
-    super({ eagerOpen: true })
+    const { highWaterMark } = options
+    super({ eagerOpen: true, highWaterMark })
 
     const { head = null, activeRequests = tree.activeRequests } = options
 
@@ -76,3 +77,5 @@ module.exports = class ChangesStream extends Readable {
     cb(null)
   }
 }
+
+exports.ChangesStream = ChangesStream

package/lib/compat.js

@@ -1,21 +1,23 @@
 // ported from the old protocol buffer impl in old bee
 
 const encodings = require('protocol-buffers-encodings')
+const b4a = require('b4a')
 const varint = encodings.varint
 const skip = encodings.skip
 
-module.exports = decodeCompat
+exports.decode = decodeCompat
+exports.encode = encodeCompat
 
 function decodeCompat(buffer, seq) {
-  const node = decodeNode(buffer)
-  const index = decodeYoloIndex(node.index)
+  const node = buffer.length > 1 ? decodeNode(buffer) : null
+  const index = node ? decodeYoloIndex(node.index) : { levels: [] }
   const morphed = {
     type: 0,
     checkpoint: 0,
     batch: { start: 0, end: 0 },
     previous: seq > 1 ? { core: 0, seq: seq - 1 } : null,
     tree: [],
-    data: [{ key: node.key, value: node.value }],
+    data: node ? [{ key: node.key, value: node.value }] : [],
     cores: null
   }
 
@@ -38,6 +40,53 @@ function decodeCompat(buffer, seq) {
   return morphed
 }
 
+function encodeCompat(node) {
+  const index = { levels: [] }
+
+  if (node.tree) {
+    for (const t of node.tree) {
+      const lvl = { keys: [], children: [] }
+      for (const k of t.keys) lvl.keys.push(k.seq)
+      for (const c of t.children) lvl.children.push(c.seq, c.offset)
+      index.levels.push(lvl)
+    }
+  }
+
+  const bufIndex = b4a.allocUnsafe(encodingLengthYoloIndex(index))
+  encodeYoloIndex(index, bufIndex, 0)
+
+  const n = {
+    key: node.data[0].key,
+    value: node.data[0].value,
+    index: bufIndex
+  }
+
+  const buf = b4a.allocUnsafe(encodingLengthNode(n))
+  return encodeNode(n, buf, 0)
+}
+
+function deflateIndex(index) {
+  const levels = index.map((l) => {
+    const keys = []
+    const children = []
+
+    for (let i = 0; i < l.value.keys.length; i++) {
+      keys.push(l.value.keys[i].seq)
+    }
+
+    for (let i = 0; i < l.value.children.length; i++) {
+      children.push(l.value.children[i].seq, l.value.children[i].offset)
+    }
+
+    return { keys, children }
+  })
+
+  const idx = { levels }
+  const buf = b4a.allocUnsafe(encodingLengthYoloIndex(idx))
+
+  return encodeYoloIndex(idx, buf, 0)
+}
+
 function decodeLevel(buf, offset, end) {
   if (!offset) offset = 0
   if (!end) end = buf.length
@@ -86,6 +135,74 @@ function decodeLevel(buf, offset, end) {
   }
 }
 
+function encodingLengthLevel(obj) {
+  let length = 0
+  if (obj.keys) {
+    let packedLen = 0
+    for (let i = 0; i < obj.keys.length; i++) {
+      if (!obj.keys[i]) continue
+      let len = encodings.varint.encodingLength(obj.keys[i])
+      packedLen += len
+    }
+    if (packedLen) {
+      length += 1 + packedLen + varint.encodingLength(packedLen)
+    }
+  }
+  if (obj.children) {
+    let packedLen = 0
+    for (let i = 0; i < obj.children.length; i++) {
+      if (!obj.children[i]) continue
+      let len = encodings.varint.encodingLength(obj.children[i])
+      packedLen += len
+    }
+    if (packedLen) {
+      length += 1 + packedLen + varint.encodingLength(packedLen)
+    }
+  }
+  return length
+}
+
+function encodeLevel(obj, buf, offset) {
+  if (!offset) offset = 0
+  let oldOffset = offset
+  if (obj.keys) {
+    let packedLen = 0
+    for (let i = 0; i < obj.keys.length; i++) {
+      if (!obj.keys[i]) continue
+      packedLen += encodings.varint.encodingLength(obj.keys[i])
+    }
+    if (packedLen) {
+      buf[offset++] = 10
+      varint.encode(packedLen, buf, offset)
+      offset += varint.encode.bytes
+    }
+    for (let i = 0; i < obj.keys.length; i++) {
+      if (!obj.keys[i]) continue
+      encodings.varint.encode(obj.keys[i], buf, offset)
+      offset += encodings.varint.encode.bytes
+    }
+  }
+  if (obj.children) {
+    let packedLen = 0
+    for (let i = 0; i < obj.children.length; i++) {
+      if (!obj.children[i]) continue
+      packedLen += encodings.varint.encodingLength(obj.children[i])
+    }
+    if (packedLen) {
+      buf[offset++] = 18
+      varint.encode(packedLen, buf, offset)
+      offset += varint.encode.bytes
+    }
+    for (let i = 0; i < obj.children.length; i++) {
+      if (!obj.children[i]) continue
+      encodings.varint.encode(obj.children[i], buf, offset)
+      offset += encodings.varint.encode.bytes
+    }
+  }
+  encodeLevel.bytes = offset - oldOffset
+  return buf
+}
+
 function decodeYoloIndex(buf, offset, end) {
   if (!offset) offset = 0
   if (!end) end = buf.length
@@ -117,6 +234,37 @@ function decodeYoloIndex(buf, offset, end) {
   }
 }
 
+function encodingLengthYoloIndex(obj) {
+  let length = 0
+  if (obj.levels) {
+    for (let i = 0; i < obj.levels.length; i++) {
+      if (!obj.levels[i]) continue
+      let len = encodingLengthLevel(obj.levels[i])
+      length += varint.encodingLength(len)
+      length += 1 + len
+    }
+  }
+  return length
+}
+
+function encodeYoloIndex(obj, buf, offset) {
+  if (!offset) offset = 0
+  let oldOffset = offset
+  if (obj.levels) {
+    for (let i = 0; i < obj.levels.length; i++) {
+      if (!obj.levels[i]) continue
+      buf[offset++] = 10
+      const len = encodingLengthLevel(obj.levels[i])
+      varint.encode(len, buf, offset)
+      offset += varint.encode.bytes
+      encodeLevel(obj.levels[i], buf, offset)
+      offset += encodeLevel.bytes
+    }
+  }
+  encodeYoloIndex.bytes = offset - oldOffset
+  return buf
+}
+
 function decodeNode(buf, offset, end) {
   if (!offset) offset = 0
   if (!end) end = buf.length
@@ -162,3 +310,34 @@ function decodeNode(buf, offset, end) {
     }
   }
 }
+
+function encodingLengthNode(obj) {
+  let length = 0
+  let len = encodings.bytes.encodingLength(obj.index)
+  length += 1 + len
+  len = encodings.bytes.encodingLength(obj.key)
+  length += 1 + len
+  if (obj.value) {
+    let len = encodings.bytes.encodingLength(obj.value)
+    length += 1 + len
+  }
+  return length
+}
+
+function encodeNode(obj, buf, offset) {
+  if (!offset) offset = 0
+  let oldOffset = offset
+  buf[offset++] = 10
+  encodings.bytes.encode(obj.index, buf, offset)
+  offset += encodings.bytes.encode.bytes
+  buf[offset++] = 18
+  encodings.bytes.encode(obj.key, buf, offset)
+  offset += encodings.bytes.encode.bytes
+  if (obj.value) {
+    buf[offset++] = 26
+    encodings.bytes.encode(obj.value, buf, offset)
+    offset += encodings.bytes.encode.bytes
+  }
+  encodeNode.bytes = offset - oldOffset
+  return buf
+}

package/lib/context.js

@@ -60,6 +60,8 @@ class CoreContext {
 
     this.changed = true
     this.cores.push({ key, fork: 0, length: 0, treeHash: null })
+    this.opened.push(null)
+
     return this.cores.length
   }
 
@@ -86,6 +88,7 @@ class CoreContext {
 
     this.changed = true
     this.cores.push({ key, fork: 0, length: 0, treeHash: null })
+    this.opened.push(null)
     return this.cores.length
   }
 
@@ -99,6 +102,15 @@ class CoreContext {
     return this.opened[index - 1]
   }
 
+  getCoreKey(index) {
+    if (index === 0) return this.core.key
+    if (index > this.cores.length) throw new Error('Bad core index: ' + index)
+    if (this.opened[index - 1] !== null && this.opened[index - 1].key) {
+      return this.opened[index - 1].key
+    }
+    return this.cores[index - 1].key
+  }
+
   async getBlock(seq, core, activeRequests) {
     if (core !== 0) await this.update(activeRequests)
     const hc = this.getCore(core)

package/lib/diff.js

@@ -0,0 +1,132 @@
+const { Readable } = require('streamx')
+const b4a = require('b4a')
+const { RangeIterator } = require('./ranges.js')
+
+class DiffIterator {
+  constructor(left, right, { limit = -1 } = {}) {
+    this.left = left
+    this.right = right
+
+    this.left.limit = this.right.limit = -1
+    this.limit = limit
+
+    this.nextLeft = null
+    this.nextRight = null
+  }
+
+  async open() {
+    await Promise.all([this.left.open(), this.right.open()])
+  }
+
+  _shiftRight() {
+    const right = this.nextRight
+    this.nextRight = null
+    if (this.limit > 0) this.limit--
+    return { left: null, right }
+  }
+
+  _shiftLeft() {
+    const left = this.nextLeft
+    this.nextLeft = null
+    if (this.limit > 0) this.limit--
+    return { left, right: null }
+  }
+
+  _fastForward() {
+    while (this.left.stack.length && this.right.stack.length) {
+      const a = this.left.stack[this.left.stack.length - 1]
+      const b = this.right.stack[this.right.stack.length - 1]
+
+      if (a.offset !== b.offset) return
+      if (!isSame(a.node, b.node)) return
+
+      this.left.stack.pop()
+      this.right.stack.pop()
+    }
+  }
+
+  async next() {
+    while (this.limit === -1 || this.limit > 0) {
+      const leftPromise = this.nextLeft ? null : this.left.next()
+      const rightPromise = this.nextRight ? null : this.right.next()
+
+      const [l, r] = await Promise.all([leftPromise, rightPromise])
+
+      if (leftPromise) this.nextLeft = l
+      if (rightPromise) this.nextRight = r
+
+      if (!this.nextLeft && !this.nextRight) return null
+      if (!this.nextLeft) return this._shiftRight()
+      if (!this.nextRight) return this._shiftLeft()
+
+      const cmp = b4a.compare(this.nextLeft.key, this.nextRight.key)
+
+      if (cmp === 0) {
+        const left = this.nextLeft
+        const right = this.nextRight
+
+        this.nextRight = this.nextLeft = null
+
+        if (isSame(left, right)) {
+          this._fastForward()
+          continue
+        }
+
+        if (this.limit > 0) this.limit--
+        return { left, right }
+      }
+
+      if (cmp < 0) return this._shiftLeft()
+      return this._shiftRight()
+    }
+
+    return null
+  }
+}
+
+class DiffStream extends Readable {
+  constructor(left, right, options = {}) {
+    const { highWaterMark } = options
+    super({ eagerOpen: true, highWaterMark })
+
+    this.left = left
+    this.right = right
+    this.iterator = new DiffIterator(
+      new RangeIterator(left, options),
+      new RangeIterator(right, options),
+      options
+    )
+  }
+
+  async _open(cb) {
+    try {
+      await this.iterator.open()
+    } catch (err) {
+      cb(err)
+      return
+    }
+    cb(null)
+  }
+
+  async _read(cb) {
+    try {
+      this.push(await this.iterator.next())
+    } catch (err) {
+      cb(err)
+      return
+    }
+    cb(null)
+  }
+}
+
+exports.DiffIterator = DiffIterator
+exports.DiffStream = DiffStream
+
+function isSame(a, b) {
+  if (a.seq !== b.seq || a.offset !== b.offset) return false
+
+  const k1 = a.context.getCoreKey(a.core)
+  const k2 = b.context.getCoreKey(b.core)
+
+  return k1 === k2 || b4a.equals(k1, k2) ? true : false
+}

package/lib/encoding.js

@@ -1,14 +1,19 @@
 const c = require('compact-encoding')
 const { getEncoding } = require('../spec/hyperschema')
-const decodeCompatBlock = require('./compat.js')
+const compat = require('./compat.js')
 
 const Block = getEncoding('@bee/block')
 
 exports.Block = Block
+exports.encodeBlock = encodeBlock
 exports.decodeBlock = decodeBlock
 
+function encodeBlock(block, format) {
+  return format === 2 ? compat.encode(block) : c.encode(Block, block)
+}
+
 function decodeBlock(buffer, seq) {
   const isCompat = buffer.length > 0 && buffer[0] === 0x0a
-  const block = isCompat ? decodeCompatBlock(buffer, seq) : c.decode(Block, buffer)
+  const block = isCompat ? compat.decode(buffer, seq) : c.decode(Block, buffer)
   return block
 }

package/lib/ranges.js

@@ -0,0 +1,139 @@
+const { Readable } = require('streamx')
+const b4a = require('b4a')
+
+class RangeIterator {
+  constructor(tree, { activeRequests = [], reverse = false, limit = -1, gte, gt, lte, lt } = {}) {
+    this.tree = tree
+    this.root = null
+    this.stack = []
+    this.activeRequests = activeRequests
+    this.reverse = reverse
+    this.limit = limit
+    this.start = gte || gt || null
+    this.end = lte || lt || null
+    this.inclusive = !!(reverse ? lte : gte)
+    this.compare = (reverse ? gte : lte) ? 0 : -1
+  }
+
+  async open() {
+    if (!this.root) this.root = await this.tree.bootstrap(this.activeRequests)
+    if (!this.root) return
+
+    if (this.limit === 0) return
+
+    this.stack.push({ node: this.root, offset: 0 })
+
+    if (this.reverse ? !this.end : !this.start) return
+
+    const offset = this.inclusive ? 0 : 1
+
+    while (true) {
+      const top = this.stack[this.stack.length - 1]
+      const v = top.node.value
+        ? this.tree.bump(top.node)
+        : await this.tree.inflate(top.node, this.activeRequests)
+
+      for (let i = 0; i < v.keys.length; i++) {
+        const j = this.reverse ? v.keys.length - 1 - i : i
+
+        const c = this.reverse
+          ? b4a.compare(v.keys[j].key, this.end)
+          : b4a.compare(this.start, v.keys[j].key)
+
+        if (c < 0) break
+        top.offset = 2 * i + 1 + (c === 0 ? offset : 1)
+      }
+
+      const child = (top.offset & 1) === 0
+      const k = top.offset >> 1
+
+      if (!child || k >= v.children.length) break
+
+      const j = this.reverse ? v.children.length - 1 - k : k
+
+      this.stack.push({
+        node: v.children[j],
+        offset: 0
+      })
+
+      top.offset++
+    }
+  }
+
+  async next() {
+    while (this.stack.length && (this.limit === -1 || this.limit > 0)) {
+      const top = this.stack.pop()
+      const v = top.node.value
+        ? this.tree.bump(top.node)
+        : await this.tree.inflate(top.node, this.activeRequests)
+
+      const offset = top.offset++
+      const child = (offset & 1) === 0
+      const k = offset >> 1
+
+      if (child) {
+        this.stack.push(top)
+        if (k < v.children.length) {
+          const j = this.reverse ? v.children.length - 1 - k : k
+          this.stack.push({ node: v.children[j], offset: 0 })
+        }
+        continue
+      }
+
+      if (k < v.keys.length) {
+        const j = this.reverse ? v.keys.length - 1 - k : k
+
+        const data = top.node.value.keys[j]
+
+        const c = this.reverse
+          ? this.start
+            ? b4a.compare(this.start, data.key)
+            : -1
+          : this.end
+            ? b4a.compare(data.key, this.end)
+            : -1
+
+        if (c > this.compare) break
+
+        this.stack.push(top)
+        if (this.limit !== -1) this.limit--
+        return data
+      }
+    }
+
+    return null
+  }
+}
+
+class RangeStream extends Readable {
+  constructor(tree, options = {}) {
+    const { highWaterMark } = options
+    super({ eagerOpen: true, highWaterMark })
+
+    this.tree = tree
+    this.iterator = new RangeIterator(tree, options)
+  }
+
+  async _open(cb) {
+    try {
+      await this.iterator.open()
+    } catch (err) {
+      cb(err)
+      return
+    }
+    cb(null)
+  }
+
+  async _read(cb) {
+    try {
+      this.push(await this.iterator.next())
+    } catch (err) {
+      cb(err)
+      return
+    }
+    cb(null)
+  }
+}
+
+exports.RangeIterator = RangeIterator
+exports.RangeStream = RangeStream

package/lib/write.js

@@ -1,7 +1,8 @@
 const b4a = require('b4a')
 const c = require('compact-encoding')
-const { Block } = require('./encoding.js')
+const { encodeBlock } = require('./encoding.js')
 const {
+  DataPointer,
   TreeNode,
   TreeNodePointer,
   MIN_KEYS,
@@ -11,23 +12,25 @@ const {
 } = require('./tree.js')
 
 module.exports = class WriteBatch {
-  constructor(tree, { length = -1, key = null, autoUpdate = true } = {}) {
+  constructor(tree, { length = -1, key = null, autoUpdate = true, blockFormat = 3 } = {}) {
     this.tree = tree
     this.snapshot = tree.snapshot()
     this.autoUpdate = autoUpdate
     this.length = length
     this.key = key
+    this.blockFormat = blockFormat
     this.closed = false
+    this.applied = 0
     this.root = null
     this.ops = []
   }
 
   tryPut(key, value) {
-    this.ops.push({ put: true, key, value })
+    this.ops.push({ put: true, applied: false, key, value })
   }
 
   tryDelete(key) {
-    this.ops.push({ put: false, key, value: null })
+    this.ops.push({ put: false, applied: false, key, value: null })
   }
 
   tryClear() {
@@ -51,7 +54,6 @@ module.exports = class WriteBatch {
 
     try {
       const ops = this.ops
-      this.ops = []
 
       const root = await this.tree.bootstrap()
 
@@ -72,8 +74,9 @@ module.exports = class WriteBatch {
       )
 
       for (const op of ops) {
-        if (op.put) await this._put(op.key, op.value)
-        else await this._delete(op.key)
+        if (op.put) op.applied = await this._put(op.key, op.value)
+        else op.applied = await this._delete(op.key)
+        if (op.applied) this.applied++
       }
 
       await this._flush()
@@ -115,10 +118,10 @@ module.exports = class WriteBatch {
         c = b4a.compare(target, m.key)
 
         if (c === 0) {
-          if (b4a.equals(m.value, value)) return
+          if (b4a.equals(m.value, value)) return false
           v.setValue(this.tree.context, mid, value)
           for (let i = 0; i < stack.length; i++) stack[i].changed = true
-          return
+          return true
         }
 
         if (c < 0) e = mid
@@ -132,7 +135,7 @@ module.exports = class WriteBatch {
     const v = ptr.value ? this.snapshot.bump(ptr) : await this.snapshot.inflate(ptr)
     let status = v.put(this.tree.context, target, value, null)
 
-    if (status === UNCHANGED) return
+    if (status === UNCHANGED) return false
 
     ptr.changed = true
 
@@ -155,6 +158,8 @@ module.exports = class WriteBatch {
         status = UNCHANGED
       }
     }
+
+    return true
   }
 
   async _delete(key) {
@@ -181,18 +186,20 @@ module.exports = class WriteBatch {
           // 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
           this.root = await this._rebalance(stack)
-          return
+          return true
         }
 
         if (c < 0) e = mid
         else s = mid + 1
       }
 
-      if (!v.children.length) return
+      if (!v.children.length) return false
 
       const i = c < 0 ? e : s
       ptr = v.children[i]
     }
+
+    return false
   }
 
   async _setKeyToNearestLeaf(v, index, stack) {
@@ -334,7 +341,7 @@ module.exports = class WriteBatch {
           continue
         }
 
-        if (first) {
+        if (first || this.blockFormat === 2) {
           stack.push({ update, node: n })
           first = false
         } else {
@@ -345,15 +352,15 @@ module.exports = class WriteBatch {
       }
     }
 
-    // if only the root was marked dirty and is === current bootstrap the batch is a noop - skip
-    if (update.node.length === 1 && update.keys.length === 0) {
-      const b = await this.tree.bootstrap()
-      const n = update.node[0]
-      if (b && b.context === n.context && b.core === n.core && b.seq === n.seq) return
-      if (!b && n.value.isEmpty()) return
+    const length = context.core.length
+
+    // if noop and not genesis, bail early
+    if (this.applied === 0 && length > 0) {
+      return
     }
 
-    const length = context.core.length
+    if (this.blockFormat === 2) toBlockFormat2(context, batch, this.ops)
+
     const blocks = new Array(batch.length)
 
     for (let i = 0; i < batch.length; i++) {
@@ -411,7 +418,7 @@ module.exports = class WriteBatch {
 
     for (let i = 0; i < blocks.length; i++) {
       blocks[i].checkpoint = context.checkpoint
-      buffers[i] = c.encode(Block, blocks[i])
+      buffers[i] = encodeBlock(blocks[i], this.blockFormat)
     }
 
     if (this.closed) {
@@ -429,3 +436,24 @@ module.exports = class WriteBatch {
     }
   }
 }
+
+function toBlockFormat2(context, batch, ops) {
+  const map = new Map()
+  let index = 0
+
+  for (const k of batch[0].keys) {
+    map.set(b4a.toString(k.key, 'hex'), k)
+  }
+
+  for (let i = ops.length - 1; i >= 0; i--) {
+    const op = ops[i]
+    if (!op.put && !op.applied) continue
+
+    const k = map.get(b4a.toString(op.key, 'hex'))
+    const j = index++
+    if (j === batch.length) batch.push({ node: [], keys: [] })
+    batch[j].keys = [k || new DataPointer(context, 0, 0, 0, false, op.key, op.value)]
+  }
+
+  return batch
+}

package/package.json

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

package/lib/key-value-stream.js

@@ -1,134 +0,0 @@
-const { Readable } = require('streamx')
-const b4a = require('b4a')
-
-module.exports = class KeyValueStream extends Readable {
-  constructor(tree, options = {}) {
-    super({ eagerOpen: true })
-
-    this.tree = tree
-    this.root = null
-
-    this._stack = []
-    this._activeRequests = options.activeRequests || this.tree.activeRequests
-    this._limit = options.limit === undefined ? -1 : options.limit
-    this._reverse = !!options.reverse
-    this._start = options.gte || options.gt || null
-    this._end = options.lte || options.lt || null
-    this._inclusive = !!(this._reverse ? options.lte : options.gte)
-    this._compare = (this._reverse ? options.gte : options.lte) ? 0 : -1
-  }
-
-  async _openp() {
-    if (!this.root) this.root = await this.tree.bootstrap(this._activeRequests)
-    if (!this.root) return
-
-    if (this._limit === 0) return
-
-    this._stack.push({ node: this.root, offset: 0 })
-
-    if (this._reverse ? !this._end : !this._start) return
-
-    const offset = this._inclusive ? 0 : 1
-
-    while (true) {
-      const top = this._stack[this._stack.length - 1]
-      const v = top.node.value
-        ? this.tree.bump(top.node)
-        : await this.tree.inflate(top.node, this._activeRequests)
-
-      for (let i = 0; i < v.keys.length; i++) {
-        const j = this._reverse ? v.keys.length - 1 - i : i
-
-        const c = this._reverse
-          ? b4a.compare(v.keys[j].key, this._end)
-          : b4a.compare(this._start, v.keys[j].key)
-
-        if (c < 0) break
-        top.offset = 2 * i + 1 + (c === 0 ? offset : 1)
-      }
-
-      const child = (top.offset & 1) === 0
-      const k = top.offset >> 1
-
-      if (!child || k >= v.children.length) break
-
-      const j = this._reverse ? v.children.length - 1 - k : k
-
-      this._stack.push({
-        node: v.children[j],
-        offset: 0
-      })
-
-      top.offset++
-    }
-  }
-
-  async _readp() {
-    while (this._stack.length && (this._limit === -1 || this._limit > 0)) {
-      const top = this._stack.pop()
-      const v = top.node.value
-        ? this.tree.bump(top.node)
-        : await this.tree.inflate(top.node, this._activeRequests)
-
-      const offset = top.offset++
-      const child = (offset & 1) === 0
-      const k = offset >> 1
-
-      if (child) {
-        this._stack.push(top)
-        if (k < v.children.length) {
-          const j = this._reverse ? v.children.length - 1 - k : k
-          this._stack.push({ node: v.children[j], offset: 0 })
-        }
-        continue
-      }
-
-      if (k < v.keys.length) {
-        const j = this._reverse ? v.keys.length - 1 - k : k
-
-        const data = top.node.value.keys[j]
-
-        const c = this._reverse
-          ? this._start
-            ? b4a.compare(this._start, data.key)
-            : -1
-          : this._end
-            ? b4a.compare(data.key, this._end)
-            : -1
-
-        if (c > this._compare) break
-
-        this._stack.push(top)
-        this.push(this._finalize(data))
-        if (this._limit !== -1) this._limit--
-        return
-      }
-    }
-
-    this.push(null)
-  }
-
-  _finalize(kv) {
-    return kv
-  }
-
-  async _open(cb) {
-    try {
-      await this._openp()
-    } catch (err) {
-      cb(err)
-      return
-    }
-    cb(null)
-  }
-
-  async _read(cb) {
-    try {
-      await this._readp()
-    } catch (err) {
-      cb(err)
-      return
-    }
-    cb(null)
-  }
-}