autobee 1.0.2 → 1.0.4

package/encoding/spec/autobee/index.js

@@ -0,0 +1,987 @@
+// This file is autogenerated by the hyperschema compiler
+// Schema Version: 1
+/* eslint-disable camelcase */
+/* eslint-disable quotes */
+/* eslint-disable space-before-function-paren */
+
+const { c } = require('hyperschema/runtime')
+const external0 = require('../../legacy.js')
+
+const VERSION = 1
+
+// eslint-disable-next-line no-unused-vars
+let version = VERSION
+
+// @autobase-compat/checkout
+const encoding0 = {
+  preencode(state, m) {
+    c.fixed32.preencode(state, m.key)
+    c.uint.preencode(state, m.length)
+  },
+  encode(state, m) {
+    c.fixed32.encode(state, m.key)
+    c.uint.encode(state, m.length)
+  },
+  decode(state) {
+    const r0 = c.fixed32.decode(state)
+    const r1 = c.uint.decode(state)
+
+    return {
+      key: r0,
+      length: r1
+    }
+  }
+}
+
+// @autobase-compat/clock
+const encoding1 = c.array(encoding0)
+
+// @autobase-compat/index-checkpoint
+const encoding2 = {
+  preencode(state, m) {
+    c.fixed64.preencode(state, m.signature)
+    c.uint.preencode(state, m.length)
+  },
+  encode(state, m) {
+    c.fixed64.encode(state, m.signature)
+    c.uint.encode(state, m.length)
+  },
+  decode(state) {
+    const r0 = c.fixed64.decode(state)
+    const r1 = c.uint.decode(state)
+
+    return {
+      signature: r0,
+      length: r1
+    }
+  }
+}
+
+const encoding3 = external0.BootRecordV0
+
+// @autobase-compat/boot-record-raw
+const encoding4 = {
+  preencode(state, m) {
+    c.fixed32.preencode(state, m.key)
+    c.uint.preencode(state, m.systemLength)
+    state.end++ // max flag is 4 so always one byte
+
+    if (m.recoveries) c.uint.preencode(state, m.recoveries)
+  },
+  encode(state, m) {
+    const flags = (m.indexersUpdated ? 1 : 0) | (m.fastForwarding ? 2 : 0) | (m.recoveries ? 4 : 0)
+
+    c.fixed32.encode(state, m.key)
+    c.uint.encode(state, m.systemLength)
+    c.uint.encode(state, flags)
+
+    if (m.recoveries) c.uint.encode(state, m.recoveries)
+  },
+  decode(state) {
+    const v = c.uint.decode(state)
+    const r0 = c.fixed32.decode(state)
+    const r1 = c.uint.decode(state)
+    const flags = c.uint.decode(state)
+
+    return {
+      version: v,
+      key: r0,
+      systemLength: r1,
+      indexersUpdated: (flags & 1) !== 0,
+      fastForwarding: (flags & 2) !== 0,
+      recoveries: (flags & 4) !== 0 ? c.uint.decode(state) : 0
+    }
+  }
+}
+
+// @autobase-compat/boot-record
+const encoding5 = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.version)
+    switch (m.version) {
+      case 0:
+        encoding3.preencode(state, m)
+        break
+      case 1:
+      case 2:
+      case 3:
+        encoding4.preencode(state, m)
+        break
+      default:
+        throw new Error('Unsupported version')
+    }
+  },
+  encode(state, m) {
+    c.uint.encode(state, m.version)
+    switch (m.version) {
+      case 0:
+        encoding3.encode(state, m)
+        break
+      case 1:
+      case 2:
+      case 3:
+        encoding4.encode(state, m)
+        break
+      default:
+        throw new Error('Unsupported version')
+    }
+  },
+  decode(state) {
+    const start = state.start
+    const v = c.uint.decode(state)
+    state.start = start
+    switch (v) {
+      case 0: {
+        const decoded = encoding3.decode(state)
+        return decoded
+      }
+      case 1:
+      case 2:
+      case 3: {
+        const decoded = encoding4.decode(state)
+        return decoded
+      }
+      default:
+        throw new Error('Unsupported version')
+    }
+  }
+}
+
+// @autobase-compat/checkpointer
+const encoding6 = {
+  preencode(state, m) {
+    state.end++ // flags are fixed size
+
+    if (m.checkpointer) c.uint.preencode(state, m.checkpointer)
+    if (m.checkpoint) encoding2.preencode(state, m.checkpoint)
+  },
+  encode(state, m) {
+    const flags = (m.checkpointer ? 1 : 0) | (m.checkpoint ? 2 : 0)
+
+    c.uint8.encode(state, flags)
+
+    if (m.checkpointer) c.uint.encode(state, m.checkpointer)
+    if (m.checkpoint) encoding2.encode(state, m.checkpoint)
+  },
+  decode(state) {
+    const flags = c.uint8.decode(state)
+
+    return {
+      checkpointer: (flags & 1) !== 0 ? c.uint.decode(state) : 0,
+      checkpoint: (flags & 2) !== 0 ? encoding2.decode(state) : null
+    }
+  }
+}
+
+// @autobase-compat/checkpoint.user
+const encoding7_2 = c.array(encoding6)
+
+// @autobase-compat/checkpoint
+const encoding7 = {
+  preencode(state, m) {
+    state.end++ // max flag is 4 so always one byte
+
+    if (m.system) encoding6.preencode(state, m.system)
+    if (m.encryption) encoding6.preencode(state, m.encryption)
+    if (m.user) encoding7_2.preencode(state, m.user)
+  },
+  encode(state, m) {
+    const flags = (m.system ? 1 : 0) | (m.encryption ? 2 : 0) | (m.user ? 4 : 0)
+
+    c.uint.encode(state, flags)
+
+    if (m.system) encoding6.encode(state, m.system)
+    if (m.encryption) encoding6.encode(state, m.encryption)
+    if (m.user) encoding7_2.encode(state, m.user)
+  },
+  decode(state) {
+    const flags = c.uint.decode(state)
+
+    return {
+      system: (flags & 1) !== 0 ? encoding6.decode(state) : null,
+      encryption: (flags & 2) !== 0 ? encoding6.decode(state) : null,
+      user: (flags & 4) !== 0 ? encoding7_2.decode(state) : null
+    }
+  }
+}
+
+// @autobase-compat/digest
+const encoding8 = {
+  preencode(state, m) {
+    state.end++ // max flag is 2 so always one byte
+
+    if (m.pointer) c.uint.preencode(state, m.pointer)
+    if (m.key) c.fixed32.preencode(state, m.key)
+  },
+  encode(state, m) {
+    const flags = (m.pointer ? 1 : 0) | (m.key ? 2 : 0)
+
+    c.uint.encode(state, flags)
+
+    if (m.pointer) c.uint.encode(state, m.pointer)
+    if (m.key) c.fixed32.encode(state, m.key)
+  },
+  decode(state) {
+    const flags = c.uint.decode(state)
+
+    return {
+      pointer: (flags & 1) !== 0 ? c.uint.decode(state) : 0,
+      key: (flags & 2) !== 0 ? c.fixed32.decode(state) : null
+    }
+  }
+}
+
+// @autobase-compat/node
+const encoding9 = {
+  preencode(state, m) {
+    encoding1.preencode(state, m.heads)
+    c.uint.preencode(state, m.batch)
+    c.buffer.preencode(state, m.value)
+  },
+  encode(state, m) {
+    encoding1.encode(state, m.heads)
+    c.uint.encode(state, m.batch)
+    c.buffer.encode(state, m.value)
+  },
+  decode(state) {
+    const r0 = encoding1.decode(state)
+    const r1 = c.uint.decode(state)
+    const r2 = c.buffer.decode(state)
+
+    return {
+      heads: r0,
+      batch: r1,
+      value: r2
+    }
+  }
+}
+
+// @autobase-compat/user-view-trace.blocks
+const encoding10_1 = c.array(c.uint)
+
+// @autobase-compat/user-view-trace
+const encoding10 = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.view)
+    encoding10_1.preencode(state, m.blocks)
+  },
+  encode(state, m) {
+    c.uint.encode(state, m.view)
+    encoding10_1.encode(state, m.blocks)
+  },
+  decode(state) {
+    const r0 = c.uint.decode(state)
+    const r1 = encoding10_1.decode(state)
+
+    return {
+      view: r0,
+      blocks: r1
+    }
+  }
+}
+
+// @autobase-compat/trace.system
+const encoding11_0 = encoding10_1
+// @autobase-compat/trace.encryption
+const encoding11_1 = encoding10_1
+// @autobase-compat/trace.user
+const encoding11_2 = c.array(encoding10)
+
+// @autobase-compat/trace
+const encoding11 = {
+  preencode(state, m) {
+    encoding11_0.preencode(state, m.system)
+    encoding11_1.preencode(state, m.encryption)
+    encoding11_2.preencode(state, m.user)
+  },
+  encode(state, m) {
+    encoding11_0.encode(state, m.system)
+    encoding11_1.encode(state, m.encryption)
+    encoding11_2.encode(state, m.user)
+  },
+  decode(state) {
+    const r0 = encoding11_0.decode(state)
+    const r1 = encoding11_1.decode(state)
+    const r2 = encoding11_2.decode(state)
+
+    return {
+      system: r0,
+      encryption: r1,
+      user: r2
+    }
+  }
+}
+
+const encoding12 = external0.OplogMessageV0
+
+const encoding13 = external0.OplogMessageV1
+
+// @autobase-compat/oplog-message-v2.checkpoint
+const encoding14_1 = c.frame(encoding7)
+// @autobase-compat/oplog-message-v2.digest
+const encoding14_2 = c.frame(encoding8)
+// @autobase-compat/oplog-message-v2.trace
+const encoding14_4 = c.frame(encoding11)
+
+// @autobase-compat/oplog-message-v2
+const encoding14 = {
+  preencode(state, m) {
+    encoding9.preencode(state, m.node)
+    state.end++ // max flag is 8 so always one byte
+
+    if (m.checkpoint) encoding14_1.preencode(state, m.checkpoint)
+    if (m.digest) encoding14_2.preencode(state, m.digest)
+    if (m.trace) encoding14_4.preencode(state, m.trace)
+  },
+  encode(state, m) {
+    const flags =
+      (m.checkpoint ? 1 : 0) | (m.digest ? 2 : 0) | (m.optimistic ? 4 : 0) | (m.trace ? 8 : 0)
+
+    encoding9.encode(state, m.node)
+    c.uint.encode(state, flags)
+
+    if (m.checkpoint) encoding14_1.encode(state, m.checkpoint)
+    if (m.digest) encoding14_2.encode(state, m.digest)
+    if (m.trace) encoding14_4.encode(state, m.trace)
+  },
+  decode(state) {
+    const v = c.uint.decode(state)
+    const r0 = encoding9.decode(state)
+    const flags = c.uint.decode(state)
+
+    return {
+      version: v,
+      node: r0,
+      checkpoint: (flags & 1) !== 0 ? encoding14_1.decode(state) : null,
+      digest: (flags & 2) !== 0 ? encoding14_2.decode(state) : null,
+      optimistic: (flags & 4) !== 0,
+      trace: (flags & 8) !== 0 ? encoding14_4.decode(state) : null
+    }
+  }
+}
+
+// @autobase-compat/info-v1.pendingIndexers
+const encoding15_1 = c.array(c.fixed32)
+
+// @autobase-compat/info-v1
+const encoding15 = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.members)
+    encoding15_1.preencode(state, m.pendingIndexers)
+    encoding1.preencode(state, m.indexers)
+    encoding1.preencode(state, m.heads)
+    encoding1.preencode(state, m.views)
+  },
+  encode(state, m) {
+    c.uint.encode(state, m.members)
+    encoding15_1.encode(state, m.pendingIndexers)
+    encoding1.encode(state, m.indexers)
+    encoding1.encode(state, m.heads)
+    encoding1.encode(state, m.views)
+  },
+  decode(state) {
+    const v = c.uint.decode(state)
+    const r0 = c.uint.decode(state)
+    const r1 = encoding15_1.decode(state)
+    const r2 = encoding1.decode(state)
+    const r3 = encoding1.decode(state)
+    const r4 = encoding1.decode(state)
+
+    return {
+      version: v,
+      members: r0,
+      pendingIndexers: r1,
+      indexers: r2,
+      heads: r3,
+      views: r4
+    }
+  }
+}
+
+// @autobase-compat/info-v2.pendingIndexers
+const encoding16_1 = encoding15_1
+
+// @autobase-compat/info-v2
+const encoding16 = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.members)
+    encoding16_1.preencode(state, m.pendingIndexers)
+    encoding1.preencode(state, m.indexers)
+    encoding1.preencode(state, m.heads)
+    encoding1.preencode(state, m.views)
+    c.uint.preencode(state, m.encryptionLength)
+    state.end++ // max flag is 1 so always one byte
+
+    if (m.entropy) c.fixed32.preencode(state, m.entropy)
+  },
+  encode(state, m) {
+    const flags = m.entropy ? 1 : 0
+
+    c.uint.encode(state, m.members)
+    encoding16_1.encode(state, m.pendingIndexers)
+    encoding1.encode(state, m.indexers)
+    encoding1.encode(state, m.heads)
+    encoding1.encode(state, m.views)
+    c.uint.encode(state, m.encryptionLength)
+    c.uint.encode(state, flags)
+
+    if (m.entropy) c.fixed32.encode(state, m.entropy)
+  },
+  decode(state) {
+    const v = c.uint.decode(state)
+    const r0 = c.uint.decode(state)
+    const r1 = encoding16_1.decode(state)
+    const r2 = encoding1.decode(state)
+    const r3 = encoding1.decode(state)
+    const r4 = encoding1.decode(state)
+    const r5 = c.uint.decode(state)
+    const flags = c.uint.decode(state)
+
+    return {
+      version: v,
+      members: r0,
+      pendingIndexers: r1,
+      indexers: r2,
+      heads: r3,
+      views: r4,
+      encryptionLength: r5,
+      entropy: (flags & 1) !== 0 ? c.fixed32.decode(state) : null
+    }
+  }
+}
+
+const encoding17 = external0.SystemWriterV0
+
+// @autobee/system-info-v3
+const encoding18 = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.timestamp)
+    c.uint.preencode(state, m.flushes)
+    encoding22.preencode(state, m.view)
+    encoding18_3.preencode(state, m.heads)
+    state.end++ // max flag is 1 so always one byte
+
+    if (m.indexers) encoding18_4.preencode(state, m.indexers)
+  },
+  encode(state, m) {
+    const flags = m.indexers ? 1 : 0
+
+    c.uint.encode(state, m.timestamp)
+    c.uint.encode(state, m.flushes)
+    encoding22.encode(state, m.view)
+    encoding18_3.encode(state, m.heads)
+    c.uint.encode(state, flags)
+
+    if (m.indexers) encoding18_4.encode(state, m.indexers)
+  },
+  decode(state) {
+    const v = c.uint.decode(state)
+    const r0 = c.uint.decode(state)
+    const r1 = c.uint.decode(state)
+    const r2 = encoding22.decode(state)
+    const r3 = encoding18_3.decode(state)
+    const flags = c.uint.decode(state)
+
+    return {
+      version: v,
+      timestamp: r0,
+      flushes: r1,
+      view: r2,
+      heads: r3,
+      indexers: (flags & 1) !== 0 ? encoding18_4.decode(state) : null
+    }
+  }
+}
+
+// @autobee/system-info
+const encoding19 = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.version)
+    switch (m.version) {
+      case 0:
+      case 1:
+        encoding15.preencode(state, m)
+        break
+      case 2:
+        encoding16.preencode(state, m)
+        break
+      case 3:
+        encoding18.preencode(state, m)
+        break
+      default:
+        throw new Error('Unsupported version')
+    }
+  },
+  encode(state, m) {
+    c.uint.encode(state, m.version)
+    switch (m.version) {
+      case 0:
+      case 1:
+        encoding15.encode(state, m)
+        break
+      case 2:
+        encoding16.encode(state, m)
+        break
+      case 3:
+        encoding18.encode(state, m)
+        break
+      default:
+        throw new Error('Unsupported version')
+    }
+  },
+  decode(state) {
+    const start = state.start
+    const v = c.uint.decode(state)
+    state.start = start
+    switch (v) {
+      case 0:
+      case 1: {
+        const decoded = encoding15.decode(state)
+        const map = external0.infoLegacyMap
+        return map(decoded)
+      }
+      case 2: {
+        const decoded = encoding16.decode(state)
+        return decoded
+      }
+      case 3: {
+        const decoded = encoding18.decode(state)
+        return decoded
+      }
+      default:
+        throw new Error('Unsupported version')
+    }
+  }
+}
+
+// @autobee/system-writer-v4
+const encoding20 = {
+  preencode(state, m) {
+    state.end++ // max flag is 2 so always one byte
+    c.uint.preencode(state, m.weight)
+    c.uint.preencode(state, m.length)
+    c.uint.preencode(state, m.clock)
+  },
+  encode(state, m) {
+    const flags = (m.isRemoved ? 1 : 0) | (m.isOplog ? 2 : 0)
+
+    c.uint.encode(state, flags)
+    c.uint.encode(state, m.weight)
+    c.uint.encode(state, m.length)
+    c.uint.encode(state, m.clock)
+  },
+  decode(state) {
+    const v = c.uint.decode(state)
+    const flags = c.uint.decode(state)
+
+    return {
+      version: v,
+      isRemoved: (flags & 1) !== 0,
+      isOplog: (flags & 2) !== 0,
+      weight: c.uint.decode(state),
+      length: c.uint.decode(state),
+      clock: c.uint.decode(state)
+    }
+  }
+}
+
+// @autobee/system-writer
+const encoding21 = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.version)
+    switch (m.version) {
+      case 0:
+      case 1:
+      case 2:
+      case 3:
+        encoding17.preencode(state, m)
+        break
+      case 4:
+        encoding20.preencode(state, m)
+        break
+      default:
+        throw new Error('Unsupported version')
+    }
+  },
+  encode(state, m) {
+    c.uint.encode(state, m.version)
+    switch (m.version) {
+      case 0:
+      case 1:
+      case 2:
+      case 3:
+        encoding17.encode(state, m)
+        break
+      case 4:
+        encoding20.encode(state, m)
+        break
+      default:
+        throw new Error('Unsupported version')
+    }
+  },
+  decode(state) {
+    const start = state.start
+    const v = c.uint.decode(state)
+    state.start = start
+    switch (v) {
+      case 0:
+      case 1:
+      case 2:
+      case 3: {
+        const decoded = encoding17.decode(state)
+        const map = external0.memberLegacyMap
+        return map(decoded)
+      }
+      case 4: {
+        const decoded = encoding20.decode(state)
+        return decoded
+      }
+      default:
+        throw new Error('Unsupported version')
+    }
+  }
+}
+
+// @autobee/link
+const encoding22 = encoding0
+
+// @autobee/batch
+const encoding23 = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.start)
+    c.uint.preencode(state, m.end)
+  },
+  encode(state, m) {
+    c.uint.encode(state, m.start)
+    c.uint.encode(state, m.end)
+  },
+  decode(state) {
+    const r0 = c.uint.decode(state)
+    const r1 = c.uint.decode(state)
+
+    return {
+      start: r0,
+      end: r1
+    }
+  }
+}
+
+// @autobee/views
+const encoding24 = {
+  preencode(state, m) {
+    encoding22.preencode(state, m.system)
+    c.uint.preencode(state, m.flushes)
+    state.end++ // flags are fixed size
+
+    if (m.view) encoding22.preencode(state, m.view)
+  },
+  encode(state, m) {
+    const flags = m.view ? 1 : 0
+
+    encoding22.encode(state, m.system)
+    c.uint.encode(state, m.flushes)
+    c.uint8.encode(state, flags)
+
+    if (m.view) encoding22.encode(state, m.view)
+  },
+  decode(state) {
+    const r0 = encoding22.decode(state)
+    const r1 = c.uint.decode(state)
+    const flags = c.uint8.decode(state)
+
+    return {
+      system: r0,
+      flushes: r1,
+      view: (flags & 1) !== 0 ? encoding22.decode(state) : null
+    }
+  }
+}
+
+// @autobee/views (inline)
+const encoding24_inline = {
+  preencode(state, m) {
+    encoding22.preencode(state, m.system)
+    c.uint.preencode(state, m.flushes)
+
+    if (m.view) encoding22.preencode(state, m.view)
+  },
+  encode(state, m) {
+    encoding22.encode(state, m.system)
+    c.uint.encode(state, m.flushes)
+
+    if (m.view) encoding22.encode(state, m.view)
+  },
+  decode(state, inlining) {
+    const r0 = encoding22.decode(state)
+    const r1 = c.uint.decode(state)
+    const flags = inlining
+
+    return {
+      system: r0,
+      flushes: r1,
+      view: (flags & 1) !== 0 ? encoding22.decode(state) : null
+    }
+  }
+}
+
+// @autobee/oplog-message-v3
+const encoding25 = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.timestamp)
+    encoding25_1.preencode(state, m.links)
+    state.end++ // max flag is 16 so always one byte
+
+    if (m.batch) encoding23.preencode(state, m.batch)
+    if (m.views) encoding24_inline.preencode(state, m.views)
+    if (m.value) c.buffer.preencode(state, m.value)
+  },
+  encode(state, m) {
+    let flags = (m.batch ? 1 : 0) | (m.views ? 2 : 0) | (m.optimistic ? 8 : 0) | (m.value ? 16 : 0)
+    if (m.views) {
+      flags |= m.views.view ? 4 : 0
+    }
+
+    c.uint.encode(state, m.timestamp)
+    encoding25_1.encode(state, m.links)
+    c.uint.encode(state, flags)
+
+    if (m.batch) encoding23.encode(state, m.batch)
+    if (m.views) encoding24_inline.encode(state, m.views)
+    if (m.value) c.buffer.encode(state, m.value)
+  },
+  decode(state) {
+    const v = c.uint.decode(state)
+    const r0 = c.uint.decode(state)
+    const r1 = encoding25_1.decode(state)
+    const flags = c.uint.decode(state)
+
+    return {
+      version: v,
+      timestamp: r0,
+      links: r1,
+      batch: (flags & 1) !== 0 ? encoding23.decode(state) : null,
+      views: (flags & 2) !== 0 ? encoding24_inline.decode(state, flags >>> 2) : null,
+      optimistic: (flags & 8) !== 0,
+      value: (flags & 16) !== 0 ? c.buffer.decode(state) : null
+    }
+  }
+}
+
+// @autobee/oplog
+const encoding26 = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.version)
+    switch (m.version) {
+      case 0:
+        encoding12.preencode(state, m)
+        break
+      case 1:
+        encoding13.preencode(state, m)
+        break
+      case 2:
+        encoding14.preencode(state, m)
+        break
+      case 3:
+        encoding25.preencode(state, m)
+        break
+      default:
+        throw new Error('Unsupported version')
+    }
+  },
+  encode(state, m) {
+    c.uint.encode(state, m.version)
+    switch (m.version) {
+      case 0:
+        encoding12.encode(state, m)
+        break
+      case 1:
+        encoding13.encode(state, m)
+        break
+      case 2:
+        encoding14.encode(state, m)
+        break
+      case 3:
+        encoding25.encode(state, m)
+        break
+      default:
+        throw new Error('Unsupported version')
+    }
+  },
+  decode(state) {
+    const start = state.start
+    const v = c.uint.decode(state)
+    state.start = start
+    switch (v) {
+      case 0: {
+        const decoded = encoding12.decode(state)
+        return decoded
+      }
+      case 1: {
+        const decoded = encoding13.decode(state)
+        return decoded
+      }
+      case 2: {
+        const decoded = encoding14.decode(state)
+        return decoded
+      }
+      case 3: {
+        const decoded = encoding25.decode(state)
+        return decoded
+      }
+      default:
+        throw new Error('Unsupported version')
+    }
+  }
+}
+
+// @autobee/manifest-data
+const encoding27 = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.version)
+    state.end++ // max flag is 2 so always one byte
+
+    if (m.legacyBlocks) c.uint.preencode(state, m.legacyBlocks)
+    if (m.namespace) c.fixed32.preencode(state, m.namespace)
+  },
+  encode(state, m) {
+    const flags = (m.legacyBlocks ? 1 : 0) | (m.namespace ? 2 : 0)
+
+    c.uint.encode(state, m.version)
+    c.uint.encode(state, flags)
+
+    if (m.legacyBlocks) c.uint.encode(state, m.legacyBlocks)
+    if (m.namespace) c.fixed32.encode(state, m.namespace)
+  },
+  decode(state) {
+    const r0 = c.uint.decode(state)
+    const flags = c.uint.decode(state)
+
+    return {
+      version: r0,
+      legacyBlocks: (flags & 1) !== 0 ? c.uint.decode(state) : 0,
+      namespace: (flags & 2) !== 0 ? c.fixed32.decode(state) : null
+    }
+  }
+}
+
+// @autobee/system-info-v3.heads, deferred due to recusive use
+const encoding18_3 = c.array(encoding22)
+// @autobee/system-info-v3.indexers, deferred due to recusive use
+const encoding18_4 = encoding18_3
+// @autobee/oplog-message-v3.links, deferred due to recusive use
+const encoding25_1 = encoding18_3
+
+function setVersion(v) {
+  version = v
+}
+
+function encode(name, value, v = VERSION) {
+  version = v
+  return c.encode(getEncoding(name), value)
+}
+
+function decode(name, buffer, v = VERSION) {
+  version = v
+  return c.decode(getEncoding(name), buffer)
+}
+
+function getEnum(name) {
+  switch (name) {
+    default:
+      throw new Error('Enum not found ' + name)
+  }
+}
+
+function getEncoding(name) {
+  switch (name) {
+    case '@autobase-compat/checkout':
+      return encoding0
+    case '@autobase-compat/clock':
+      return encoding1
+    case '@autobase-compat/index-checkpoint':
+      return encoding2
+    case '@autobase-compat/boot-record-v0':
+      return encoding3
+    case '@autobase-compat/boot-record-raw':
+      return encoding4
+    case '@autobase-compat/boot-record':
+      return encoding5
+    case '@autobase-compat/checkpointer':
+      return encoding6
+    case '@autobase-compat/checkpoint':
+      return encoding7
+    case '@autobase-compat/digest':
+      return encoding8
+    case '@autobase-compat/node':
+      return encoding9
+    case '@autobase-compat/user-view-trace':
+      return encoding10
+    case '@autobase-compat/trace':
+      return encoding11
+    case '@autobase-compat/oplog-message-v0':
+      return encoding12
+    case '@autobase-compat/oplog-message-v1':
+      return encoding13
+    case '@autobase-compat/oplog-message-v2':
+      return encoding14
+    case '@autobase-compat/info-v1':
+      return encoding15
+    case '@autobase-compat/info-v2':
+      return encoding16
+    case '@autobase-compat/member':
+      return encoding17
+    case '@autobee/system-info-v3':
+      return encoding18
+    case '@autobee/system-info':
+      return encoding19
+    case '@autobee/system-writer-v4':
+      return encoding20
+    case '@autobee/system-writer':
+      return encoding21
+    case '@autobee/link':
+      return encoding22
+    case '@autobee/batch':
+      return encoding23
+    case '@autobee/views':
+      return encoding24
+    case '@autobee/oplog-message-v3':
+      return encoding25
+    case '@autobee/oplog':
+      return encoding26
+    case '@autobee/manifest-data':
+      return encoding27
+    default:
+      throw new Error('Encoder not found ' + name)
+  }
+}
+
+function getStruct(name, v = VERSION) {
+  const enc = getEncoding(name)
+  return {
+    preencode(state, m) {
+      version = v
+      enc.preencode(state, m)
+    },
+    encode(state, m) {
+      version = v
+      enc.encode(state, m)
+    },
+    decode(state) {
+      version = v
+      return enc.decode(state)
+    }
+  }
+}
+
+const resolveStruct = getStruct // compat
+
+module.exports = {
+  resolveStruct,
+  getStruct,
+  getEnum,
+  getEncoding,
+  encode,
+  decode,
+  setVersion,
+  version
+}