autobee 2.0.0-rc.0 → 2.0.0-rc.10

package/encoding/compat.js

@@ -169,7 +169,7 @@ module.exports = function buildAutobaseSchema(schema, DIR) {
       },
       {
         name: 'value',
-        type: 'buffer',
+        type: 'optionalBuffer',
         required: true
       }
     ]

package/encoding/legacy.js

@@ -153,18 +153,18 @@ const Node = {
   preencode(state, m) {
     Clock.preencode(state, m.heads)
     c.uint.preencode(state, m.batch)
-    c.buffer.preencode(state, m.value)
+    c.optionalBuffer.preencode(state, m.value)
   },
   encode(state, m) {
     Clock.encode(state, m.heads)
     c.uint.encode(state, m.batch)
-    c.buffer.encode(state, m.value)
+    c.optionalBuffer.encode(state, m.value)
   },
   decode(state, m) {
     return {
       heads: Clock.decode(state),
       batch: c.uint.decode(state),
-      value: c.buffer.decode(state)
+      value: c.optionalBuffer.decode(state)
     }
   }
 }

package/encoding/spec/autobee/index.js

@@ -97,8 +97,9 @@ const encoding4 = {
 // @autobase-compat/boot-record
 const encoding5 = {
   preencode(state, m) {
-    c.uint.preencode(state, m.version)
-    switch (m.version) {
+    const v = m.version ?? 3
+    c.uint.preencode(state, v)
+    switch (v) {
       case 0:
         encoding3.preencode(state, m)
         break
@@ -112,8 +113,9 @@ const encoding5 = {
     }
   },
   encode(state, m) {
-    c.uint.encode(state, m.version)
-    switch (m.version) {
+    const v = m.version ?? 3
+    c.uint.encode(state, v)
+    switch (v) {
       case 0:
         encoding3.encode(state, m)
         break
@@ -236,17 +238,17 @@ const encoding9 = {
   preencode(state, m) {
     encoding1.preencode(state, m.heads)
     c.uint.preencode(state, m.batch)
-    c.buffer.preencode(state, m.value)
+    c.optionalBuffer.preencode(state, m.value)
   },
   encode(state, m) {
     encoding1.encode(state, m.heads)
     c.uint.encode(state, m.batch)
-    c.buffer.encode(state, m.value)
+    c.optionalBuffer.encode(state, m.value)
   },
   decode(state) {
     const r0 = encoding1.decode(state)
     const r1 = c.uint.decode(state)
-    const r2 = c.buffer.decode(state)
+    const r2 = c.optionalBuffer.decode(state)
 
     return {
       heads: r0,
@@ -496,8 +498,9 @@ const encoding18 = {
 // @autobee/system-info
 const encoding19 = {
   preencode(state, m) {
-    c.uint.preencode(state, m.version)
-    switch (m.version) {
+    const v = m.version ?? 3
+    c.uint.preencode(state, v)
+    switch (v) {
       case 0:
       case 1:
         encoding15.preencode(state, m)
@@ -513,8 +516,9 @@ const encoding19 = {
     }
   },
   encode(state, m) {
-    c.uint.encode(state, m.version)
-    switch (m.version) {
+    const v = m.version ?? 3
+    c.uint.encode(state, v)
+    switch (v) {
       case 0:
       case 1:
         encoding15.encode(state, m)
@@ -603,8 +607,9 @@ const encoding20 = {
 // @autobee/system-writer
 const encoding21 = {
   preencode(state, m) {
-    c.uint.preencode(state, m.version)
-    switch (m.version) {
+    const v = m.version ?? 4
+    c.uint.preencode(state, v)
+    switch (v) {
       case 0:
       case 1:
       case 2:
@@ -619,8 +624,9 @@ const encoding21 = {
     }
   },
   encode(state, m) {
-    c.uint.encode(state, m.version)
-    switch (m.version) {
+    const v = m.version ?? 4
+    c.uint.encode(state, v)
+    switch (v) {
       case 0:
       case 1:
       case 2:
@@ -905,8 +911,9 @@ const encoding29 = {
 // @autobee/oplog
 const encoding30 = {
   preencode(state, m) {
-    c.uint.preencode(state, m.version)
-    switch (m.version) {
+    const v = m.version ?? 3
+    c.uint.preencode(state, v)
+    switch (v) {
       case 0:
         encoding12.preencode(state, m)
         break
@@ -924,8 +931,9 @@ const encoding30 = {
     }
   },
   encode(state, m) {
-    c.uint.encode(state, m.version)
-    switch (m.version) {
+    const v = m.version ?? 3
+    c.uint.encode(state, v)
+    switch (v) {
       case 0:
         encoding12.encode(state, m)
         break

package/encoding/spec/autobee/schema.json

@@ -194,7 +194,7 @@
         {
           "name": "value",
           "required": true,
-          "type": "buffer",
+          "type": "optionalBuffer",
           "version": 1
         }
       ]
@@ -805,5 +805,15 @@
         }
       ]
     }
+  ],
+  "namespaces": [
+    {
+      "name": "autobee",
+      "external": "../../legacy.js"
+    },
+    {
+      "name": "autobase-compat",
+      "external": "../../legacy.js"
+    }
   ]
 }

package/index.js

@@ -105,6 +105,8 @@ module.exports = class Autobee extends ReadyResource {
     this._hasApply = !!handlers.apply
     this._hasUpdate = !!handlers.update
     this._needsUpdate = false
+    this._ackRequired = false
+    this._ackedHeads = new Map()
     this._updateLocalCore = null
     this._host = new ApplyCalls(this)
     this._notifyHandler = null
@@ -227,6 +229,7 @@ module.exports = class Autobee extends ReadyResource {
     await this.local.close()
     await this.system.close()
     await this._wakeup.close()
+    if (this.bootstrap && !this.bootstrap.closed) await this.bootstrap.close()
     await this._workingBee.close()
     await this.bee.close()
     await this.store.close()
@@ -250,7 +253,12 @@ module.exports = class Autobee extends ReadyResource {
       view: info ? info.view : EMPTY_HEAD
     }
 
-    const shared = await this.system.commonAncestor(system || EMPTY_HEAD)
+    // no common ancestor (null) -> flushes -1 never matches, forcing a full diff
+    const shared = (await this.system.commonAncestor(system || EMPTY_HEAD)) || {
+      flushes: -1,
+      system: EMPTY_HEAD,
+      view: EMPTY_HEAD
+    }
 
     return UpdateChanges.from(shared, current)
   }
@@ -374,13 +382,18 @@ module.exports = class Autobee extends ReadyResource {
 
     // Use the view position from the system info (authoritative, post-processing)
     // rather than from the oplog (stale, captured at append time before _bump)
-    let view = this.system.view || EMPTY_HEAD
+    let view = this.system.view
+    if (!view) {
+      const migrated = await this.local.getUserData('autobee/migrated-view')
+      view = migrated ? encoding.decodeBootRecord(migrated) : EMPTY_HEAD
+    }
 
     // @todo migration
     if (result.migration) {
       if (this.handlers.migrate) {
         view = (await this.handlers.migrate(result.migration.views)) || EMPTY_HEAD
         this._catchupMigratedNodes = result.migration.catchup
+        await this._storeMigratedView(view)
       }
 
       // ff boot invalidated by migration
@@ -476,6 +489,8 @@ module.exports = class Autobee extends ReadyResource {
   }
 
   async _drain() {
+    if (this._updating) await this._updating
+
     if (this.bootFrom) {
       await this._initFromHead(this.bootFrom)
       this.bootFrom = null
@@ -484,6 +499,8 @@ module.exports = class Autobee extends ReadyResource {
     // tracked across drain iteration
     this.system.shared = null
 
+    this._ackRequired = false
+
     const changes = this._hasUpdate ? new UpdateChanges(this) : null
     if (changes) changes.track()
 
@@ -503,7 +520,12 @@ module.exports = class Autobee extends ReadyResource {
             break // revaluate conditions...
           }
 
-          if (!(await this._bumpPendingWriters())) break
+          if (await this._bumpPendingWriters()) {
+            this._needsUpdate = true
+            continue
+          }
+
+          if (!this._appendAck()) break
           this._needsUpdate = true
         }
 
@@ -518,7 +540,15 @@ module.exports = class Autobee extends ReadyResource {
     if (this._interrupting) return
 
     if (this._needsUpdate) {
-      await this._update(changes)
+      const updating = rrp()
+      this._updating = updating.promise
+
+      try {
+        await this._update(changes)
+      } finally {
+        this._updating = null
+        updating.resolve()
+      }
     }
   }
 
@@ -564,58 +594,74 @@ module.exports = class Autobee extends ReadyResource {
     }
   }
 
-  async _getOplog(key, length) {
+  async _getOplog(key, length, opts = null) {
     const core = this.openCore(key)
-    await core.ready()
 
-    const target = length >= 0 ? length : core.length
-    if (target === 0) return null
+    try {
+      await core.ready()
 
-    const buf = await core.get(target - 1)
-    let op = encoding.decodeOplog(buf)
+      const target = length >= 0 ? length : core.length
+      if (target === 0) return null
 
-    if (op.version < 3) {
-      op = await this._inflateLegacyOplog(buf, core, target - 1)
-    }
+      const buf = await core.get(target - 1, opts)
+      if (buf === null) return null
 
-    await core.close()
+      let op = encoding.decodeOplog(buf)
 
-    if (buf === null) return null
+      // legacy nodes always inflate, but only indexers carry views - callers
+      // that need system info must check op.views
+      if (op.version < 3) {
+        op = await this._inflateLegacyOplog(buf, core, target - 1, opts)
+      }
 
-    return {
-      key,
-      length: target,
-      op
+      return {
+        key,
+        length: target,
+        op
+      }
+    } finally {
+      await core.close()
     }
   }
 
-  async _inflateLegacyOplog(buf, core, seq) {
+  async _inflateLegacyOplog(buf, core, seq, opts = null) {
     const m = encoding.decodeRawOplog(buf)
+
+    const op = {
+      version: m.version,
+      timestamp: 0,
+      links: m.node.heads,
+      batch: { start: 0, end: m.node.batch - 1 },
+      views: null,
+      optimistic: !!m.optimistic,
+      value: m.node.value
+    }
+
+    if (m.digest === null || m.checkpoint === null) return op
+
     const fetches = []
 
-    fetches.push(m.digest.pointer ? core.get(seq - m.digest.pointer) : buf)
-    fetches.push(m.checkpoint.pointer ? core.get(seq - m.checkpoint.system.checkpointer) : buf)
+    fetches.push(m.digest.pointer ? core.get(seq - m.digest.pointer, opts) : buf)
+    fetches.push(
+      m.checkpoint.pointer ? core.get(seq - m.checkpoint.system.checkpointer, opts) : buf
+    )
 
     const [digestNode, checkpointNode] = await Promise.all(fetches)
+    // a wait: false get we could not satisfy locally
+    if (digestNode === null || checkpointNode === null) return op
 
     const { digest } = encoding.decodeRawOplog(digestNode)
     const { checkpoint } = encoding.decodeRawOplog(checkpointNode)
 
-    return {
-      version: m.version,
-      timestamp: 0,
-      links: m.node.heads,
-      batch: { start: 0, end: m.node.batch - 1 },
-      views: {
-        system: {
-          key: digest.key,
-          length: checkpoint.system.checkpoint.length
-        },
-        flushes: seq
+    op.views = {
+      system: {
+        key: digest.key,
+        length: checkpoint.system.checkpoint.length
       },
-      optimistic: !!m.optimistic,
-      value: m.node.value
+      flushes: seq
     }
+
+    return op
   }
 
   async _update(changes) {
@@ -744,6 +790,39 @@ module.exports = class Autobee extends ReadyResource {
     }
   }
 
+  // append a null value node to ack writer
+  _appendAck() {
+    if (!this._ackRequired) return false
+    if (!this.writers.writable) return false
+
+    if (this.writers.localWriter.pending !== null) return false
+
+    const links = this.system.getLinks(this.local.key)
+    const t = Math.max(this._now(), this.system.timestamp)
+
+    let unlinked = false
+    for (const { key, length } of links) {
+      const hex = b4a.toString(key, 'hex')
+      const acked = this._ackedHeads.get(hex) || 0
+      if (length > acked) {
+        unlinked = true
+        break
+      }
+    }
+    if (!unlinked) {
+      this._ackRequired = false
+      return false
+    }
+
+    for (const { key, length } of links) {
+      this._ackedHeads.set(b4a.toString(key, 'hex'), length)
+    }
+
+    this.writers.appendLocal(null, t, { start: 0, end: 0 }, links, false, null)
+    this._ackRequired = false
+    return true
+  }
+
   async _bumpPendingWriters() {
     if (this._catchupMigratedNodes !== null) {
       await this._bumpMigratedWriters()
@@ -917,11 +996,17 @@ module.exports = class Autobee extends ReadyResource {
     const boot = this.system.bootRecord()
     if (boot) {
       proms.push(this.local.setUserData('autobee/head', encoding.encodeBootRecord(boot)))
+      if (this.system.view) proms.push(this._storeMigratedView(EMPTY_HEAD))
     }
 
     return Promise.all(proms)
   }
 
+  _storeMigratedView(view) {
+    const value = view.key ? encoding.encodeBootRecord(view) : null
+    return this.local.setUserData('autobee/migrated-view', value)
+  }
+
   static decodeValue(buf, opts) {
     return encoding.decodeValue(buf, opts)
   }
@@ -1071,14 +1156,16 @@ module.exports = class Autobee extends ReadyResource {
 
   async _rebootFromHead(head, trusted, { force = false, wait = true } = {}) {
     const oplog = await this._getOplog(head.key, head.length)
-    if (!oplog) return false
+    if (!oplog) return null
 
     const verified = trusted ? await this._getOplog(trusted.key, trusted.length) : oplog
+    if (!verified) return null
 
-    if (!verified.op.views) return null
+    // legacy nodes from non-indexers have no system info to reboot from
+    if (!oplog.op.views || !verified.op.views) return null
 
     if (!force && verified.op.views.flushes - this.system.flushes < MIN_FF_GAP) {
-      return false
+      return null
     }
 
     const moved = await this._moveTo(batchToHead(verified.op.views.system), {
@@ -1145,12 +1232,16 @@ module.exports = class Autobee extends ReadyResource {
     this.system.bee.move(head)
     await this.system.reset()
 
-    // todo: binary search to find shared common tree and pass as undo
-    this.system.shared = { flushes: -1, view: EMPTY_HEAD, system: EMPTY_HEAD }
+    this.system.shared = this.rebootTo.shared || {
+      flushes: -1,
+      view: EMPTY_HEAD,
+      system: EMPTY_HEAD
+    }
 
     // migrate is set when fast-forwarding from a legacy head
     if (migrate) {
       const view = (await this.handlers.migrate(migrate)) || EMPTY_HEAD
+      await this._storeMigratedView(view)
       this.bee.move(view)
       this._workingBee.move(view)
     } else {
@@ -1161,6 +1252,8 @@ module.exports = class Autobee extends ReadyResource {
     this.rebootTo = null
     await this.writers.refresh()
 
+    await this._storeBoot()
+
     await this._update(changes)
 
     this.emit('move-to', to, from)

package/lib/apply-calls.js

@@ -1,4 +1,5 @@
 const ID = require('hypercore-id-encoding')
+const b4a = require('b4a')
 
 class ApplyCalls {
   constructor(auto) {
@@ -39,6 +40,10 @@ class ApplyCalls {
 
   ackWriter(key) {
     if (typeof key === 'string') key = ID.decode(key)
+    // acking an optimistic node means we owe it a linking node
+    if (this.applying && this.applying[0].optimistic && !b4a.equals(key, this.auto.local.key)) {
+      this.auto._ackRequired = true
+    }
     return this.auto.system.ackWriter(key)
   }
 

package/lib/reboot.js

@@ -86,10 +86,23 @@ module.exports = class Reboot {
     await Promise.all(promises)
     if (this.destroyed) return null
 
+    const shared = await this._commonAncestor()
+    if (this.destroyed) return null
+
     return {
       head: this.head,
       tip: this.tip,
-      migrate: null
+      migrate: null,
+      shared
+    }
+  }
+
+  async _commonAncestor() {
+    try {
+      return await this.auto.system.commonAncestor(this.head)
+    } catch (err) {
+      safetyCatch(err)
+      return null
     }
   }
 

package/lib/system.js

@@ -2,7 +2,6 @@ const Hyperbee = require('hyperbee2')
 const b4a = require('b4a')
 
 const { AUTOBEE_VERSION } = require('./constants')
-const asserts = require('./asserts.js')
 const encoding = require('./encoding.js')
 const topo = require('./topo.js')
 
@@ -13,6 +12,27 @@ const INDEXER_LT = b4a.from([3])
 const EMPTY_HEAD = { length: 0, key: null }
 const EMPTY = b4a.from([])
 
+class SystemSnapshot {
+  constructor(bee) {
+    this.bee = bee
+  }
+
+  async get(key, { timeout } = {}) {
+    const node = await this.bee.get(encoding.encodeSystemWriterKey(key), { timeout })
+    return node !== null ? encoding.decodeSystemWriter(node.key, node.value) : null
+  }
+
+  async has(link) {
+    const node = await this.get(link.key)
+    if (!node || node.length < link.length) return false
+    return true
+  }
+
+  close() {
+    return this.bee.close()
+  }
+}
+
 module.exports = class Systembee {
   constructor(store, name, opts = {}) {
     this.name = name // for debuggin
@@ -96,44 +116,57 @@ module.exports = class Systembee {
   }
 
   async commonAncestor(head) {
-    const info = await this.getInfo()
-
     const snap = this.bee.checkout(head)
 
-    const hist1 = this.bee.createChangesStream()[Symbol.asyncIterator]()
-    const hist2 = snap.createChangesStream()[Symbol.asyncIterator]()
+    const ca = infoIterator(this.bee)
+    const cb = infoIterator(snap)
+
+    let l = await next(ca)
+    let r = await next(cb)
+
+    while (l && r) {
+      if (l.legacy && r.legacy) {
+        // legacy nodes just compare head
+        if (sameHead(l.node.head, r.node.head)) {
+          return {
+            flushes: l.info.flushes,
+            system: l.node.head,
+            view: l.info.view || EMPTY_HEAD
+          }
+        }
 
-    let a = await hist1.next()
-    let b = await hist2.next()
+        // different legacy cores never converge - genuinely unrelated history
+        if (!b4a.equals(l.node.head.key, r.node.head.key)) return null
 
-    if (!a.value || !b.value) {
-      return { flushes: 0, system: EMPTY_HEAD, view: EMPTY_HEAD }
-    }
+        if (l.node.head.length >= r.node.head.length) l = await next(ca)
+        else r = await next(cb)
+        continue
+      }
 
-    let l = getInfo(a.value)
-    let r = getInfo(b.value)
+      if (l.legacy !== r.legacy) {
+        // current-format history sits above the legacy band: descend it
+        if (!l.legacy) l = await next(ca)
+        else r = await next(cb)
+        continue
+      }
 
-    while (!a.done || !b.done) {
-      if (l.flushes === r.flushes && sameHead(l.view, r.view)) {
+      if (l.info.flushes === r.info.flushes && sameHead(l.info.view, r.info.view)) {
         return {
-          flushes: l.flushes,
-          system: a.value.head,
-          view: l.view || EMPTY_HEAD
+          flushes: l.info.flushes,
+          system: l.node.head,
+          view: l.info.view || EMPTY_HEAD
         }
       }
 
-      if (l.flushes >= r.flushes) {
-        a = await hist1.next()
-        if (a.value) l = getInfo(a.value)
-      }
+      const lf = l.info.flushes
+      const rf = r.info.flushes
 
-      if (r.flushes >= l.flushes) {
-        b = await hist2.next()
-        if (b.value) r = getInfo(b.value)
-      }
+      if (lf >= rf) l = await next(ca)
+      if (rf >= lf) r = await next(cb)
     }
 
-    return { flushes: 0, system: EMPTY_HEAD, view: EMPTY_HEAD }
+    // no common ancestor
+    return null
   }
 
   async reset({ timeout } = {}) {
@@ -228,6 +261,14 @@ module.exports = class Systembee {
     return info ? !info.isRemoved : !!optimistic
   }
 
+  snapshot(head = null) {
+    const bee =
+      head === null
+        ? this.bee.snapshot()
+        : this.bee.checkout({ length: head.length, key: head.key })
+    return new SystemSnapshot(bee)
+  }
+
   async get(key, { unflushed = false, timeout } = {}) {
     const node = await this.bee.get(encoding.encodeSystemWriterKey(key), { timeout })
     const info = node !== null ? encoding.decodeSystemWriter(node.key, node.value) : null
@@ -434,6 +475,8 @@ module.exports = class Systembee {
 
     w.tryPut(INFO_KEY, encoding.encodeSystemInfo(info))
 
+    this.view = info.view
+
     await w.flush()
 
     // Can enable if needed during debuggin
@@ -460,12 +503,16 @@ function getInfo(data) {
       const prefix = k.key[0]
 
       if (prefix === 0) {
-        return encoding.decodeSystemInfo(k.value)
+        try {
+          return encoding.decodeSystemInfo(k.value)
+        } catch {
+          return null
+        }
       }
     }
   }
 
-  asserts.bail('Bad system node')
+  return null
 }
 
 function sameHead(a, b) {
@@ -473,3 +520,35 @@ function sameHead(a, b) {
   if (!a.key || !b.key) return a.key === b.key
   return b4a.equals(a.key, b.key)
 }
+
+async function* infoIterator(bee) {
+  try {
+    for await (const node of bee.createChangesStream()) {
+      const legacy = topo.isLegacyNode(node)
+      const info = legacy ? getLegacyInfo(node) : getInfo(node)
+      if (info) yield { node, info, legacy }
+    }
+  } catch {
+    // fall through
+  }
+}
+
+async function next(it) {
+  const res = await it.next()
+  return res.done ? null : res.value
+}
+
+function getLegacyInfo(data) {
+  for (const { keys } of data.batch) {
+    for (const k of keys) {
+      if (b4a.equals(k.key, INFO_LEGACY_KEY)) {
+        try {
+          return encoding.decodeSystemInfo(k.value)
+        } catch {
+          return null
+        }
+      }
+    }
+  }
+  return null
+}

package/lib/topo.js

@@ -13,6 +13,7 @@ exports.getMostRecentHead = getMostRecentHead
 
 exports.isLinking = isLinking
 exports.isLinkingAll = isLinkingAll
+exports.isLegacyNode = isLegacyNode
 
 class Clock {
   constructor() {
@@ -65,17 +66,66 @@ async function rollback(auto, system, verified) {
   }
 }
 
+// nodes we cannot resolve are returned as null rather than dropped, so callers
+// can tell an incomplete replay from a short one
 async function replay(auto) {
-  const ch = auto.system.bee.createChangesStream()
   const replay = []
 
-  for await (const data of ch) {
-    const { ref } = getOplog(data)
-    replay.push(ref)
+  for await (const entry of oplogIterator(auto.system.bee)) {
+    // the walk was cut short, nothing below this point is reachable
+    if (entry === null) {
+      replay.push(null)
+      break
+    }
+
+    for (const ref of entry.refs) replay.push(ref)
   }
 
-  const inflated = await inflate(auto, replay.reverse())
-  return inflated.flatMap((b) => b.batch)
+  // same reasoning as the iterator - never block on what we do not have
+  const inflated = await inflate(auto, replay.reverse(), { wait: false })
+  return inflated.flatMap((b) => (b === null ? [null] : b.batch))
+}
+
+// tolerates legacy nodes instead of asserting
+async function* oplogIterator(bee) {
+  try {
+    for await (const node of bee.createChangesStream({ wait: false })) {
+      const legacy = isLegacyNode(node)
+      const refs = getOplogs(node)
+      if (refs.length) yield { node, refs, legacy }
+    }
+  } catch {
+    yield null // signal data not available
+  }
+}
+
+// legacy nodes carry no isOplog flag so we cannot tell which writer update is
+// the oplog to fetch - yield every candidate until we have a better signal
+function getOplogs(data) {
+  const undo = data.tail || EMPTY_HEAD
+  const oplogs = []
+  const candidates = []
+
+  for (const { keys } of data.batch) {
+    for (const k of keys) {
+      if (k.key[0] !== 1) continue
+
+      let value = null
+      try {
+        value = encoding.decodeSystemWriter(k.key, k.value)
+      } catch {
+        continue
+      }
+
+      // writer was just added, nothing to fetch
+      if (!value.length) continue
+
+      if (value.isOplog) oplogs.push({ undo, oplog: value })
+      else candidates.push({ undo, oplog: value })
+    }
+  }
+
+  return oplogs.length ? oplogs : candidates
 }
 
 async function sort(auto, batch) {
@@ -192,12 +242,19 @@ function cmp(a, b) {
   return a.length < b.length ? -1 : 1
 }
 
-async function inflate(auto, reorder) {
+async function inflate(auto, reorder, opts = null) {
   const promises = []
   const sessions = new Map()
 
   for (let i = 0; i < reorder.length; i++) {
     const ref = reorder[i]
+
+    // marker for a node we could not resolve, pass it through
+    if (ref === null) {
+      promises.push(null)
+      continue
+    }
+
     const id = b4a.toString(ref.oplog.key, 'hex')
     // only seeds the node - reapplication re-resolves from the witness
     const weight = ref.oplog.weight
@@ -214,7 +271,7 @@ async function inflate(auto, reorder) {
       sessions.set(id, core)
     }
 
-    promises.push(getOplogBatch(ref.undo, core, ref.oplog.length, weight, i))
+    promises.push(getOplogBatch(ref.undo, core, ref.oplog.length, weight, i, opts))
   }
 
   try {
@@ -224,9 +281,10 @@ async function inflate(auto, reorder) {
   }
 }
 
-async function getOplogBatch(undo, core, length, weight, index) {
+async function getOplogBatch(undo, core, length, weight, index, opts = null) {
   const seq = length - 1
-  const block = await core.get(seq)
+  const block = await core.get(seq, opts)
+  if (block === null) return null
   const oplog = encoding.decodeOplog(block)
   const head = createNode(core, length, weight, oplog)
 
@@ -238,12 +296,18 @@ async function getOplogBatch(undo, core, length, weight, index) {
   const end = seq + head.batch.end // skip head, we have it
 
   for (let i = start; i < end; i++) {
-    remaining.push(core.get(i))
+    remaining.push(core.get(i, opts))
   }
 
   if (remaining.length) {
     const blocks = await Promise.all(remaining)
     for (let i = 0; i < blocks.length; i++) {
+      // keep the hole so the gap in the batch stays visible
+      if (blocks[i] === null) {
+        batch.push(null)
+        continue
+      }
+
       const oplog = encoding.decodeOplog(blocks[i])
       batch.push(createNode(core, i + start + 1, weight, oplog))
     }
@@ -254,8 +318,12 @@ async function getOplogBatch(undo, core, length, weight, index) {
 }
 
 function getLocalBatch(undo, writer, length, weight, index) {
+  if (writer.core.closed) throw new Error('Writer core is closed')
+
   if (length > writer.core.length) {
-    if (!writer.pending) throw new Error('No local nodes')
+    if (!writer.pending) {
+      throw new Error(`No local nodes: looking for ${length}, found ${writer.core.length}`)
+    }
 
     let i = 0
     while (i < writer.pending.length) {

package/lib/writers.js

@@ -214,7 +214,10 @@ class ActiveWriters {
       return
     }
 
-    w = new Writer(this, this.auto.system, false, bootstrap, id)
+    const session = bootstrap.session()
+    session.setEncryption(this.auto._getEncryptionProvider())
+
+    w = new Writer(this, this.auto.system, false, session, id)
     w.attach()
     w.couple()
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autobee",
-  "version": "2.0.0-rc.0",
+  "version": "2.0.0-rc.10",
   "description": "Bee based autobase",
   "license": "Apache-2.0",
   "author": "Holepunch Inc.",
@@ -26,7 +26,7 @@
     "autobee-encryption": "^0.1.2",
     "autobee-wakeup": "^1.1.3",
     "b4a": "^1.8.0",
-    "compact-encoding": "^2.18.0",
+    "compact-encoding": "^3.3.0",
     "hyperbee2": "^2.10.3",
     "hypercore": "^11.33.2",
     "hypercore-id-encoding": "^1.3.0",