hyperbee2 2.3.0 → 2.4.2

package/index.js

@@ -6,6 +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 SessionConfig = require('./lib/session-config.js')
 const { Pointer, KeyPointer, ValuePointer, TreeNode, EMPTY } = require('./lib/tree.js')
 const { DeltaOp, DeltaCohort, OP_COHORT } = require('./lib/compression.js')
 
@@ -16,10 +17,13 @@ class Hyperbee {
       key = null,
       encryption = null,
       maxCacheSize = 4096,
+      config = new SessionConfig([], 0, true),
+      activeRequests = config.activeRequests,
+      timeout = config.timeout,
+      wait = config.wait,
       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,
@@ -29,7 +33,7 @@ class Hyperbee {
     this.store = store
     this.root = root
     this.context = context
-    this.activeRequests = activeRequests
+    this.config = config.sub(activeRequests, timeout, wait)
     this.view = view
     this.writable = writable
     this.unbatch = unbatch
@@ -79,6 +83,8 @@ class Hyperbee {
 
   _makeView(context, root, writable, unbatch) {
     return new Hyperbee(this.store, {
+      config: this.config,
+      core: context.core,
       context,
       root,
       view: true,
@@ -123,7 +129,7 @@ class Hyperbee {
   }
 
   async close() {
-    if (this.activeRequests.length) Hypercore.clearRequests(this.activeRequests)
+    if (this.config.activeRequests.length) Hypercore.clearRequests(this.config.activeRequests)
     if (!this.view) await this.store.close()
   }
 
@@ -163,15 +169,15 @@ class Hyperbee {
   }
 
   // TODO: unslab these
-  async inflate(ptr, activeRequests = this.activeRequests) {
+  async inflate(ptr, config) {
     if (ptr.value) {
       this.bump(ptr)
       return ptr.value
     }
 
     const [block, context] = await Promise.all([
-      ptr.context.getBlock(ptr.seq, ptr.core, activeRequests),
-      ptr.context.getContext(ptr.core, activeRequests)
+      ptr.context.getBlock(ptr.seq, ptr.core, config),
+      ptr.context.getContext(ptr.core, config)
     ])
 
     const tree = block.tree[ptr.offset]
@@ -181,15 +187,17 @@ class Hyperbee {
 
     for (let i = 0; i < keys.length; i++) {
       const d = tree.keys[i]
-      keys[i] = inflateKey(context, d, ptr, block, activeRequests)
+      keys[i] = inflateKey(context, d, ptr, block, config)
     }
 
     for (let i = 0; i < children.length; i++) {
       const d = tree.children[i]
-      children[i] = inflateChild(context, d, ptr, block, activeRequests)
+      children[i] = inflateChild(context, d, ptr, block, config)
     }
 
-    const value = new TreeNode(await Promise.all(keys), await Promise.all(children))
+    const [k, c] = await Promise.all([Promise.all(keys), Promise.all(children)])
+
+    const value = new TreeNode(k, c)
     if (!ptr.value) ptr.value = value
 
     this.bump(ptr)
@@ -197,8 +205,8 @@ class Hyperbee {
     return ptr.value
   }
 
-  async finalizeKeyPointer(key, activeRequests = this.activeRequests) {
-    const value = key.value || (await this.inflateValue(key, activeRequests))
+  async finalizeKeyPointer(key, config) {
+    const value = key.value || (await this.inflateValue(key, config))
 
     return {
       core: key.context.getCore(key.core),
@@ -209,20 +217,20 @@ class Hyperbee {
     }
   }
 
-  async inflateValue(key, activeRequests = this.activeRequests) {
+  async inflateValue(key, config) {
     if (key.value) return key.value
     if (!key.valuePointer) return null
 
     const ptr = key.valuePointer
 
     if (ptr.split === 0) {
-      const block = await ptr.context.getBlock(ptr.seq, ptr.core, activeRequests)
+      const block = await ptr.context.getBlock(ptr.seq, ptr.core, config)
       return block.values[ptr.offset]
     }
 
     const blockPromises = new Array(ptr.split + 1)
     for (let i = 0; i < blockPromises.length; i++) {
-      blockPromises[i] = ptr.context.getBlock(ptr.seq - ptr.split + i, ptr.core, activeRequests)
+      blockPromises[i] = ptr.context.getBlock(ptr.seq - ptr.split + i, ptr.core, config)
     }
     const blocks = await Promise.all(blockPromises)
     const splitValue = new Array(blockPromises.length)
@@ -233,13 +241,13 @@ class Hyperbee {
     return b4a.concat(splitValue)
   }
 
-  async bootstrap(activeRequests = this.activeRequests) {
+  async bootstrap(config) {
     if (!this.root) await this.ready()
-    if (this.unbatch) await this._rollback(activeRequests)
+    if (this.unbatch) await this._rollback(config)
     return this.root === EMPTY ? null : this.root
   }
 
-  async _rollback(activeRequests) {
+  async _rollback(config) {
     const expected = this.unbatch
 
     let n = expected
@@ -248,14 +256,14 @@ class Hyperbee {
 
     while (n > 0 && length > 0 && expected === this.unbatch) {
       const seq = length - 1
-      const blk = await context.getBlock(seq, 0, activeRequests)
+      const blk = await context.getBlock(seq, 0, config)
 
       if (!blk.previous) {
         length = 0
         break
       }
 
-      context = await context.getContext(blk.previous.core, activeRequests)
+      context = await context.getContext(blk.previous.core, config)
       length = blk.previous.seq + 1
       n--
     }
@@ -272,12 +280,14 @@ class Hyperbee {
     this.unbatch = 0
   }
 
-  async get(key, { activeRequests = this.activeRequests } = {}) {
-    let ptr = await this.bootstrap(activeRequests)
+  async get(key, opts) {
+    const config = this.config.options(opts)
+
+    let ptr = await this.bootstrap(config)
     if (!ptr) return null
 
     while (true) {
-      const v = ptr.value ? this.bump(ptr) : await this.inflate(ptr, activeRequests)
+      const v = ptr.value ? this.bump(ptr) : await this.inflate(ptr, config)
 
       let s = 0
       let e = v.keys.length
@@ -289,7 +299,7 @@ class Hyperbee {
 
         c = b4a.compare(key, m.key)
 
-        if (c === 0) return this.finalizeKeyPointer(m, activeRequests)
+        if (c === 0) return this.finalizeKeyPointer(m, config)
 
         if (c < 0) e = mid
         else s = mid + 1
@@ -307,12 +317,12 @@ module.exports = Hyperbee
 
 function noop() {}
 
-function inflateKey(context, d, ptr, block, activeRequests) {
-  if (d.type === OP_COHORT) return inflateKeyCohort(context, d, ptr, block, activeRequests)
-  return inflateKeyDelta(context, d, ptr, block, activeRequests)
+function inflateKey(context, d, ptr, block, config) {
+  if (d.type === OP_COHORT) return inflateKeyCohort(context, d, ptr, block, config)
+  return inflateKeyDelta(context, d, ptr, block, config)
 }
 
-async function inflateKeyDelta(context, d, ptr, block, activeRequests) {
+async function inflateKeyDelta(context, d, ptr, block, config) {
   const k = d.pointer
 
   if (!k) return new DeltaOp(false, d.type, d.index, null)
@@ -320,7 +330,7 @@ async function inflateKeyDelta(context, d, ptr, block, activeRequests) {
   const blk =
     k.seq === ptr.seq && k.core === 0 && ptr.core === 0
       ? block
-      : await context.getBlock(k.seq, k.core, activeRequests)
+      : await context.getBlock(k.seq, k.core, config)
 
   const bk = blk.keys[k.offset]
 
@@ -328,7 +338,7 @@ async function inflateKeyDelta(context, d, ptr, block, activeRequests) {
 
   if (bk.valuePointer) {
     const p = bk.valuePointer
-    const ctx = await context.getContext(k.core, activeRequests)
+    const ctx = await context.getContext(k.core, config)
     vp = new ValuePointer(ctx, p.core, p.seq, p.offset, p.split)
   }
 
@@ -336,20 +346,20 @@ async function inflateKeyDelta(context, d, ptr, block, activeRequests) {
   return new DeltaOp(false, d.type, d.index, kp)
 }
 
-async function inflateKeyCohort(context, d, ptr, block, activeRequests) {
+async function inflateKeyCohort(context, d, ptr, block, config) {
   const co = d.pointer
 
   const blk =
     co.seq === ptr.seq && co.core === 0 && ptr.core === 0
       ? block
-      : await context.getBlock(co.seq, co.core, activeRequests)
+      : await context.getBlock(co.seq, co.core, config)
 
   const cohort = blk.cohorts[co.offset]
   const promises = new Array(cohort.length)
 
   for (let i = 0; i < cohort.length; i++) {
     const p = cohort[i]
-    const k = inflateKeyDelta(context, p, co, blk, activeRequests)
+    const k = inflateKeyDelta(context, p, co, blk, config)
     promises[i] = k
   }
 
@@ -357,31 +367,31 @@ async function inflateKeyCohort(context, d, ptr, block, activeRequests) {
   return new DeltaCohort(false, p, await Promise.all(promises))
 }
 
-function inflateChild(context, d, ptr, block, activeRequests) {
-  if (d.type === OP_COHORT) return inflateChildCohort(context, d, ptr, block, activeRequests)
-  return Promise.resolve(inflateChildDelta(context, d, ptr, block, activeRequests))
+function inflateChild(context, d, ptr, block, config) {
+  if (d.type === OP_COHORT) return inflateChildCohort(context, d, ptr, block, config)
+  return Promise.resolve(inflateChildDelta(context, d, ptr, block, config))
 }
 
-function inflateChildDelta(context, d, ptr, block, activeRequests) {
+function inflateChildDelta(context, d, ptr, block, config) {
   const p = d.pointer
   const c = p && context.createTreeNode(p.core, p.seq, p.offset, false, null)
   return new DeltaOp(false, d.type, d.index, c)
 }
 
-async function inflateChildCohort(context, d, ptr, block, activeRequests) {
+async function inflateChildCohort(context, d, ptr, block, config) {
   const co = d.pointer
 
   const blk =
     co.seq === ptr.seq && co.core === 0 && ptr.core === 0
       ? block
-      : await context.getBlock(co.seq, co.core, activeRequests)
+      : await context.getBlock(co.seq, co.core, config)
 
   const cohort = blk.cohorts[co.offset]
   const deltas = new Array(cohort.length)
 
   for (let i = 0; i < cohort.length; i++) {
     const c = cohort[i]
-    deltas[i] = inflateChildDelta(context, c, co, blk, activeRequests)
+    deltas[i] = inflateChildDelta(context, c, co, blk, config)
   }
 
   const p = new Pointer(context, co.core, co.seq, co.offset)

package/lib/changes.js

@@ -1,43 +1,41 @@
 const { Readable } = require('streamx')
 
 class ChangesStream extends Readable {
-  constructor(tree, options = {}) {
-    const { highWaterMark } = options
+  constructor(tree, opts = {}) {
+    const { highWaterMark, head = null } = opts
     super({ eagerOpen: true, highWaterMark })
 
-    const { head = null, activeRequests = tree.activeRequests } = options
-
     this.tree = tree
 
-    this._head = head
-    this._context = null
-    this._activeRequests = activeRequests
+    this.head = head
+    this.context = null
+    this.config = tree.config.options(opts)
   }
 
   async _openp() {
-    await this.tree.bootstrap(this._activeRequests)
-    if (this._head === null) this._head = this.tree.head()
-    if (this._head !== null) this._context = this.tree.context.getContextByKey(this._head.key)
+    await this.tree.bootstrap(this.config)
+    if (this.head === null) this.head = this.tree.head()
+    if (this.head !== null) this.context = this.tree.context.getContextByKey(this.head.key)
   }
 
   async _readp() {
-    if (!this._context || this._head.length === 0) {
+    if (!this.context || this.head.length === 0) {
       this.push(null)
       return
     }
 
     const data = {
-      head: this._head,
+      head: this.head,
       batch: []
     }
 
-    const seq = this._head.length - 1
-    const blk = await this._context.getBlock(seq, 0, this._activeRequests)
+    const seq = this.head.length - 1
+    const blk = await this.context.getBlock(seq, 0, this.config)
     const batchStart = seq - blk.batch.start
     const remaining = new Array(blk.batch.start)
 
     for (let i = 0; i < remaining.length; i++) {
-      remaining[i] = this._context.getBlock(batchStart + i, 0, this._activeRequests)
+      remaining[i] = this.context.getBlock(batchStart + i, 0, this.config)
     }
 
     for (const blk of await Promise.all(remaining)) data.batch.push(blk)
@@ -46,13 +44,13 @@ class ChangesStream extends Readable {
     this.push(data)
 
     if (!blk.previous) {
-      this._head = null
-      this._context = null
+      this.head = null
+      this.context = null
       return
     }
 
-    this._context = await this._context.getContext(blk.previous.core, this._activeRequests)
-    this._head = { key: this._context.core.key, length: blk.previous.seq + 1 }
+    this.context = await this.context.getContext(blk.previous.core, this.config)
+    this.head = { key: this.context.core.key, length: blk.previous.seq + 1 }
   }
 
   async _open(cb) {

package/lib/context.js

@@ -1,5 +1,6 @@
 const b4a = require('b4a')
 const ScopeLock = require('scope-lock')
+const { BLOCK_NOT_AVAILABLE } = require('hypercore-errors')
 const { TreeNodePointer } = require('./tree.js')
 const { decodeBlock } = require('./encoding.js')
 
@@ -27,20 +28,26 @@ class CoreContext {
   //   return '[CoreContext]'
   // }
 
-  async update(activeRequests) {
+  async update(config) {
     await this.core.ready()
 
     if (this.length === this.core.length || this.core.length === 0) return
 
     const length = this.core.length
     const seq = length - 1
-    const buffer = await this.core.get(seq, { activeRequests })
+    const buffer = await this.core.get(seq, config)
     const block = decodeBlock(buffer, seq)
+
+    await this._inflateCheckpoint(length, block, config)
+  }
+
+  async _inflateCheckpoint(length, block, config) {
     const checkpoint = block.checkpoint
 
     if (checkpoint > 0) {
-      const buffer = await this.core.get(checkpoint - 1)
-      const block = decodeBlock(buffer, checkpoint - 1)
+      const seq = checkpoint - 1
+      const buffer = await this.core.get(seq, config)
+      const block = decodeBlock(buffer, seq)
 
       if (length < this.length) return
 
@@ -84,12 +91,12 @@ class CoreContext {
     return this.cores.length
   }
 
-  async getCoreOffset(context, core, activeRequests) {
-    if (core !== 0 && core - 1 >= context.cores.length) await context.update(activeRequests)
+  async getCoreOffset(context, core, config) {
+    if (core !== 0 && core - 1 >= context.cores.length) await context.update(config)
     return this.getCoreOffsetLocal(context, core)
   }
 
-  async getCoreOffsetByKey(key, activeRequests) {
+  async getCoreOffsetByKey(key, config) {
     await this.core.ready()
 
     if (b4a.equals(key, this.core.key)) return 0
@@ -101,7 +108,7 @@ class CoreContext {
       }
     }
 
-    await this.update(activeRequests)
+    await this.update(config)
 
     for (let i = 0; i < this.cores.length; i++) {
       const k = this.cores[i].key
@@ -135,11 +142,18 @@ class CoreContext {
     return this.cores[index - 1].key
   }
 
-  async getBlock(seq, core, activeRequests) {
-    if (core !== 0 && core - 1 >= this.cores.length) await this.update(activeRequests)
+  async getBlock(seq, core, config) {
+    if (core !== 0 && core - 1 >= this.cores.length) await this.update(config)
+
     const hc = this.getCore(core)
-    const buffer = await hc.get(seq, { activeRequests })
+    const buffer = await hc.get(seq, config)
+    if (buffer === null) throw BLOCK_NOT_AVAILABLE()
     const block = decodeBlock(buffer, seq)
+
+    if (block.checkpoint > this.checkpoint) {
+      await this._inflateCheckpoint(seq + 1, block, config)
+    }
+
     return block
   }
 
@@ -158,9 +172,9 @@ class CoreContext {
     return ctx
   }
 
-  async getContext(core, activeRequests) {
+  async getContext(core, config) {
     if (core === 0) return this
-    if (core > this.cores.length) await this.update(activeRequests)
+    if (core > this.cores.length) await this.update(config)
     if (core > this.cores.length) throw new Error('Bad core index: ' + core)
 
     const hex = b4a.toString(this.cores[core - 1].key, 'hex')

package/lib/diff.js

@@ -3,7 +3,9 @@ const b4a = require('b4a')
 const { RangeIterator } = require('./ranges.js')
 
 class DiffIterator {
-  constructor(tree, left, right, { limit = -1, activeRequests = [] } = {}) {
+  constructor(tree, left, right, opts = {}) {
+    const { limit = -1 } = opts
+
     this.tree = tree
 
     this.left = left
@@ -11,7 +13,7 @@ class DiffIterator {
 
     this.left.limit = this.right.limit = -1
 
-    this.activeRequests = activeRequests
+    this.config = tree.config.options(opts)
     this.limit = limit
 
     this.nextLeft = null
@@ -23,14 +25,14 @@ class DiffIterator {
   }
 
   async _shiftRight() {
-    const right = await this.tree.finalizeKeyPointer(this.nextRight, this.activeRequests)
+    const right = await this.tree.finalizeKeyPointer(this.nextRight, this.config)
     this.nextRight = null
     if (this.limit > 0) this.limit--
     return { left: null, right }
   }
 
   async _shiftLeft() {
-    const left = await this.tree.finalizeKeyPointer(this.nextLeft, this.activeRequests)
+    const left = await this.tree.finalizeKeyPointer(this.nextLeft, this.config)
     this.nextLeft = null
     if (this.limit > 0) this.limit--
     return { left, right: null }
@@ -77,8 +79,8 @@ class DiffIterator {
         }
 
         const [left, right] = await Promise.all([
-          this.tree.finalizeKeyPointer(leftKey, this.activeRequests),
-          this.tree.finalizeKeyPointer(rightKey, this.activeRequests)
+          this.tree.finalizeKeyPointer(leftKey, this.config),
+          this.tree.finalizeKeyPointer(rightKey, this.config)
         ])
 
         if (this.limit > 0) this.limit--

package/lib/ranges.js

@@ -3,21 +3,12 @@ const b4a = require('b4a')
 
 class RangeIterator {
   constructor(tree, opts = {}) {
-    const {
-      activeRequests = [],
-      prefetch = true,
-      reverse = false,
-      limit = -1,
-      gte,
-      gt,
-      lte,
-      lt
-    } = opts
+    const { prefetch = true, reverse = false, limit = -1, gte, gt, lte, lt } = opts
 
     this.tree = tree
     this.root = null
     this.stack = []
-    this.activeRequests = activeRequests
+    this.config = tree.config.options(opts)
     this.reverse = reverse
     this.limit = limit
     this.start = gte || gt || null
@@ -29,7 +20,7 @@ class RangeIterator {
   }
 
   async open() {
-    if (!this.root) this.root = await this.tree.bootstrap(this.activeRequests)
+    if (!this.root) this.root = await this.tree.bootstrap(this.config)
     if (!this.root) return
 
     if (this.limit === 0) return
@@ -44,7 +35,7 @@ class RangeIterator {
       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)
+        : await this.tree.inflate(top.node, this.config)
 
       for (let i = 0; i < v.keys.length; i++) {
         const j = this.reverse ? v.keys.length - 1 - i : i
@@ -75,7 +66,7 @@ class RangeIterator {
 
   async next() {
     const key = await this.nextKey()
-    return key === null ? key : this.tree.finalizeKeyPointer(key, this.activeRequests)
+    return key === null ? key : this.tree.finalizeKeyPointer(key, this.config)
   }
 
   async nextKey() {
@@ -83,7 +74,7 @@ class RangeIterator {
       const top = this.stack.pop()
       const v = top.node.value
         ? this.tree.bump(top.node)
-        : await this.tree.inflate(top.node, this.activeRequests)
+        : await this.tree.inflate(top.node, this.config)
 
       const offset = top.offset++
       const child = (offset & 1) === 0
@@ -150,7 +141,7 @@ class RangeIterator {
       if (cmp > this.compare) break
 
       const c = pv.children.get(i)
-      if (!c.value) this.tree.inflate(c, this.activeRequests).catch(noop)
+      if (!c.value) this.tree.inflate(c, this.config).catch(noop)
 
       limit = Math.max(limit - this.tree.context.minKeys, 0)
       if (limit === 0) break

package/lib/session-config.js

@@ -0,0 +1,23 @@
+class SessionConfig {
+  constructor(activeRequests, timeout, wait) {
+    this.activeRequests = activeRequests
+    this.timeout = timeout
+    this.wait = wait
+  }
+
+  sub(activeRequests, timeout, wait) {
+    if (this.activeRequests === activeRequests && this.timeout === timeout && this.wait === wait) {
+      return this
+    }
+
+    return new SessionConfig(activeRequests, timeout, wait)
+  }
+
+  options(opts) {
+    if (!opts) return this
+    const { activeRequests = this.activeRequests, timeout = this.timeout, wait = this.wait } = opts
+    return this.sub(activeRequests, timeout, wait)
+  }
+}
+
+module.exports = SessionConfig

package/lib/write.js

@@ -23,6 +23,7 @@ module.exports = class WriteBatch {
     } = opts
 
     this.tree = tree
+    this.config = tree.config.options(opts)
     this.deltaMax = deltaMax
     this.deltaMin = deltaMin
     this.inlineValueSize = inlineValueSize
@@ -68,7 +69,7 @@ module.exports = class WriteBatch {
     try {
       const ops = this.ops
 
-      const root = await this.tree.bootstrap()
+      const root = await this.tree.bootstrap(this.config)
 
       const length = this._getLength(root)
       const context = this._getContext(root)
@@ -106,11 +107,12 @@ module.exports = class WriteBatch {
     const stack = []
     const target = key
     const snap = this.snapshot
+    const conf = this.config
 
     let ptr = this.root
 
     while (true) {
-      const v = await retainAndInflate(ptr, snap)
+      const v = await retainAndInflate(ptr, snap, conf)
       if (!v.children.ulength) break
 
       stack.push(ptr)
@@ -126,7 +128,7 @@ module.exports = class WriteBatch {
         c = b4a.compare(target, m.key)
 
         if (c === 0) {
-          const existing = await snap.inflateValue(m)
+          const existing = await snap.inflateValue(m, conf)
           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
@@ -141,13 +143,13 @@ module.exports = class WriteBatch {
       ptr = v.children.uget(i)
     }
 
-    const v = await retainAndInflate(ptr, snap)
+    const v = await retainAndInflate(ptr, snap, conf)
     let status = v.insertLeaf(this.tree.context, target, value)
 
     if (status >= 0) {
       // already exists, upsert if changed
       const m = v.keys.uget(status)
-      const existing = await snap.inflateValue(m)
+      const existing = await snap.inflateValue(m, conf)
       if (b4a.equals(existing, value)) return false
       v.setValue(this.tree.context, status, value)
     }
@@ -156,12 +158,12 @@ module.exports = class WriteBatch {
     for (let i = 0; i < stack.length; i++) stack[i].changed = true
 
     while (status === NEEDS_SPLIT) {
-      const v = await retainAndInflate(ptr, snap)
+      const v = await retainAndInflate(ptr, snap, conf)
       const parent = stack.pop()
       const { median, right } = v.split(this.tree.context)
 
       if (parent) {
-        const p = await retainAndInflate(parent, snap)
+        const p = await retainAndInflate(parent, snap, conf)
         status = p.insertNode(this.tree.context, median, right)
         ptr = parent
       } else {
@@ -182,7 +184,7 @@ module.exports = class WriteBatch {
     const stack = []
 
     while (true) {
-      const v = await retainAndInflate(ptr, this.snapshot)
+      const v = await retainAndInflate(ptr, this.snapshot, this.config)
       stack.push(ptr)
 
       let s = 0
@@ -217,6 +219,7 @@ module.exports = class WriteBatch {
 
   async _setKeyToNearestLeaf(v, index, stack) {
     const snap = this.snapshot
+    const conf = this.config
 
     let left = v.children.uget(index)
     let right = v.children.uget(index + 1)
@@ -226,21 +229,21 @@ module.exports = class WriteBatch {
     if (ls < rs) {
       // if fewer leaves on the left
       stack.push(right)
-      let r = await retainAndInflate(right, snap)
+      let r = await retainAndInflate(right, snap, conf)
       while (r.children.ulength) {
         right = r.children.uget(0)
         stack.push(right)
-        r = await retainAndInflate(right, snap)
+        r = await retainAndInflate(right, snap, conf)
       }
       v.keys.set(index, r.keys.shift())
     } else {
       // if fewer leaves on the right
       stack.push(left)
-      let l = await retainAndInflate(left, snap)
+      let l = await retainAndInflate(left, snap, conf)
       while (l.children.ulength) {
         left = l.children.uget(l.children.ulength - 1)
         stack.push(left)
-        l = await retainAndInflate(left, snap)
+        l = await retainAndInflate(left, snap, conf)
       }
       v.keys.set(index, l.keys.pop())
     }
@@ -248,11 +251,12 @@ module.exports = class WriteBatch {
 
   async _leafSize(ptr, goLeft) {
     const snap = this.snapshot
+    const conf = this.config
 
-    let v = await retainAndInflate(ptr, snap)
+    let v = await retainAndInflate(ptr, snap, conf)
     while (v.children.ulength) {
       ptr = v.children.uget(goLeft ? 0 : v.children.ulength - 1)
-      v = await retainAndInflate(ptr, snap)
+      v = await retainAndInflate(ptr, snap, conf)
     }
     return v.keys.ulength
   }
@@ -261,20 +265,21 @@ module.exports = class WriteBatch {
     const root = stack[0]
     const minKeys = this.tree.context.minKeys
     const snap = this.snapshot
+    const conf = this.config
 
     while (stack.length > 1) {
       const ptr = stack.pop()
       const parent = stack[stack.length - 1]
 
-      const v = await retainAndInflate(ptr, snap)
+      const v = await retainAndInflate(ptr, snap, conf)
 
       if (v.keys.ulength >= minKeys) return root
 
-      const p = await retainAndInflate(parent, snap)
+      const p = await retainAndInflate(parent, snap, conf)
 
       let { left, index, right } = v.siblings(p)
 
-      let l = left && (await retainAndInflate(left, snap))
+      let l = left && (await retainAndInflate(left, snap, conf))
 
       // maybe borrow from left sibling?
       if (l && l.keys.ulength > minKeys) {
@@ -285,7 +290,7 @@ module.exports = class WriteBatch {
         return root
       }
 
-      let r = right && (await retainAndInflate(right, snap))
+      let r = right && (await retainAndInflate(right, snap, conf))
 
       // maybe borrow from right sibling?
       if (r && r.keys.ulength > minKeys) {
@@ -313,7 +318,7 @@ module.exports = class WriteBatch {
       p.removeKey(index)
     }
 
-    const r = await retainAndInflate(root, snap)
+    const r = await retainAndInflate(root, snap, conf)
     // check if the tree shrunk
     if (!r.keys.ulength && r.children.ulength) return r.children.uget(0)
     return root
@@ -330,7 +335,7 @@ module.exports = class WriteBatch {
       return
     }
 
-    if (!this.root.value) await this.snapshot.inflate(this.root)
+    if (!this.root.value) await this.snapshot.inflate(this.root, this.config)
 
     let update = { size: 0, nodes: [], keys: [], values: [] }
     let minValue = -1
@@ -342,9 +347,9 @@ module.exports = class WriteBatch {
     const values = []
 
     const context = this.tree.context.getLocalContext()
-    const activeRequests = this.tree.activeRequests
+    const config = this.tree.config
 
-    await context.update(activeRequests)
+    await context.update(config)
 
     while (stack.length > 0) {
       const node = stack.pop()
@@ -485,7 +490,7 @@ module.exports = class WriteBatch {
     const buffers = new Array(blocks.length)
 
     if (blocks.length > 0 && this.length > 0) {
-      const core = this.key ? await context.getCoreOffsetByKey(this.key, activeRequests) : 0
+      const core = this.key ? await context.getCoreOffsetByKey(this.key, config) : 0
       blocks[blocks.length - 1].previous = { core, seq: this.length - 1 }
     }
 
@@ -600,11 +605,11 @@ function supportsCompression(type) {
   return type !== TYPE_COMPAT && type !== 0
 }
 
-async function retainAndInflate(ptr, snap) {
+async function retainAndInflate(ptr, snap, conf) {
   if (ptr.value) {
     ptr.retain()
     return ptr.value
   }
   ptr.retain()
-  return await snap.inflate(ptr)
+  return await snap.inflate(ptr, conf)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hyperbee2",
-  "version": "2.3.0",
+  "version": "2.4.2",
   "description": "btree",
   "main": "index.js",
   "files": [
@@ -19,6 +19,7 @@
     "b4a": "^1.6.7",
     "compact-encoding": "^2.16.1",
     "hypercore": "^11.15.0",
+    "hypercore-errors": "^1.5.0",
     "hyperschema": "^1.14.0",
     "protocol-buffers-encodings": "^1.2.0",
     "scope-lock": "^1.2.4",