@cero-base/core 1.3.0 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cero-base/core",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "cero p2p primitives — identity, storage, network, database, blobs, rpc, pairing.",
   "type": "module",
   "sideEffects": false,
@@ -41,9 +41,13 @@
       "types": "./types/network/index.d.ts",
       "default": "./src/network/index.js"
     },
-    "./network/bluetooth": {
-      "types": "./types/network/bluetooth.d.ts",
-      "default": "./src/network/bluetooth.js"
+    "./network/transports/ble": {
+      "types": "./types/network/transports/ble.d.ts",
+      "default": "./src/network/transports/ble.js"
+    },
+    "./network/transports/dht": {
+      "types": "./types/network/transports/dht.d.ts",
+      "default": "./src/network/transports/dht.js"
     },
     "./database": {
       "types": "./types/database/index.d.ts",
@@ -117,6 +121,10 @@
     "crypto": {
       "bare": "bare-crypto",
       "default": "crypto"
+    },
+    "events": {
+      "bare": "bare-events",
+      "default": "events"
     }
   },
   "scripts": {
@@ -125,28 +133,31 @@
     "build:types": "rm -rf types && tsc -p .",
     "pretest": "npm run build:test",
     "prepublishOnly": "npm run build:types",
-    "test": "brittle-node test/*.test.js",
-    "test:bare": "npx bare test/bare-smoke.js"
+    "test": "npm run test:node",
+    "test:bare": "brittle-bare test/bare.js test/*.test.js",
+    "pretest:bare": "npm run build:test",
+    "test:node": "brittle-node test/*.test.js"
   },
   "dependencies": {
     "@hyperswarm/secret-stream": "^6.9.1",
-    "autobee": "^1.0.9",
+    "autobee": "^1.0.10",
     "b4a": "^1.8.1",
     "bare-crypto": "^1.15.3",
-    "bare-fs": "^4.7.2",
-    "bare-path": "^3.0.1",
+    "bare-fs": "^4.7.4",
+    "bare-path": "^3.1.1",
     "bip39-mnemonic": "^2.5.0",
     "blind-pairing": "^2.3.1",
-    "compact-encoding": "^3.2.0",
-    "corestore": "^7.10.1",
+    "blind-peering": "^2.5.0",
+    "compact-encoding": "^3.3.0",
+    "corestore": "^7.11.1",
     "framed-stream": "^1.0.1",
     "hrpc": "^4.3.0",
     "hyperblobs": "^2.12.1",
-    "hypercore": "^11.33.1",
-    "hypercore-blob-server": "^1.12.0",
+    "hypercore": "^11.34.1",
+    "hypercore-blob-server": "^1.15.0",
     "hypercore-crypto": "^3.7.0",
     "hypercore-id-encoding": "^1.3.0",
-    "hypercore-storage": "^3.1.1",
+    "hypercore-storage": "^3.2.0",
     "hyperdb": "^6.7.0",
     "hyperdispatch": "^1.6.0",
     "hyperschema": "^1.21.0",
@@ -161,7 +172,13 @@
   },
   "devDependencies": {
     "@hyperswarm/testnet": "^3.1.4",
-    "brittle": "^4.0.2",
+    "bare-abort-controller": "^1.1.2",
+    "bare-events": "^2.9.1",
+    "bare-fetch": "^3.0.3",
+    "bare-process": "^4.4.1",
+    "bare-url": "^2.2.1",
+    "blind-peer": "^3.12.2",
+    "brittle": "^4.1.0",
     "typescript": "^5.9.3"
   },
   "license": "Apache-2.0"

package/src/database/bootstrap.js

@@ -21,16 +21,39 @@ export async function bootstrap(db, { name, isMobile, recovering = false, timeou
   }
   const writerKey = Hypercore.key(manifest)
 
-  if (recovering) await waitForFirstPeerAppend(db, timeout)
-  await saveWriter(db, writerKey, { name, isMobile })
+  if (recovering) {
+    await waitForFirstPeerAppend(db, timeout)
+    // reopen so the bee's writer state is built over the replicated genesis
+    // core — a writer opened before replication stamps ops at stale lengths
+    // and autobee silently drops them
+    await reopenBee(db)
+  }
+  if (recovering) {
+    // gate the swap on the admission actually applying: write() can resolve
+    // with the ops stalled in the drain (update() bumps heal that) or dropped
+    // outright when they were stamped behind a mid-replication core — each
+    // retry stamps past the collision, and the ops are idempotent
+    await admitWriter(db, writerKey, { name, isMobile }, timeout)
+  } else {
+    await saveWriter(db, writerKey, { name, isMobile })
+  }
   await swapWriter(db, keyPair, manifest)
 
   return { id: writerKey, writer: keyPair }
 }
 
 async function waitForFirstPeerAppend(db, timeout = 30000) {
-  if (db.bee.local.length > 0 || !db.network?.swarm) return
-  await new Promise((resolve, reject) => {
+  if (!db.network?.swarm) return
+  if (db.bee.local.length === 0) await waitForLength(db, 1, timeout)
+  await db.bee.update()
+  // the first block may not be the whole core — writes stamped below the
+  // length the system already attributes to this writer are silently dropped
+  const info = await db.bee.system.get(db.bee.local.key).catch(() => null)
+  if (info && info.length > db.bee.local.length) await waitForLength(db, info.length, timeout)
+}
+
+function waitForLength(db, length, timeout) {
+  return new Promise((resolve, reject) => {
     let done = false
     const finish = (err) => {
       if (done) return
@@ -43,7 +66,7 @@ async function waitForFirstPeerAppend(db, timeout = 30000) {
     }
     // timeout + close handling so a peer that never replicates can't hang the
     // recovery forever, and the append listener is always removed.
-    const onAppend = () => db.bee.local.length > 0 && finish()
+    const onAppend = () => db.bee.local.length >= length && finish()
     const onClose = () => finish(CeroError.CLOSED('Database'))
     const timer = setTimeout(
       () => finish(CeroError.TIMED_OUT('recovery — no peer append')),
@@ -52,17 +75,46 @@ async function waitForFirstPeerAppend(db, timeout = 30000) {
     db.bee.local.on('append', onAppend)
     db.on('close', onClose)
   })
-  await db.bee.update()
+}
+
+async function admitWriter(db, writerKey, opts, timeout) {
+  const deadline = Date.now() + timeout
+  const id = toId(writerKey)
+  while (true) {
+    await saveWriter(db, writerKey, opts)
+    if (await deviceApplied(db, id, Math.min(3000, deadline - Date.now()))) return
+    if (Date.now() >= deadline) throw CeroError.TIMED_OUT('recovery — writer not admitted')
+  }
+}
+
+async function deviceApplied(db, id, timeout) {
+  const deadline = Date.now() + timeout
+  while (Date.now() < deadline) {
+    const { data } = await db.get('devices', id)
+    if (data) return true
+    await db.bee.update()
+    await new Promise((resolve) => setTimeout(resolve, 25))
+  }
+  return false
+}
+
+async function reopenBee(db) {
+  if (db.network) db.network.detach(db.bee)
+  await db.bee.close()
+  db.bee = null
+  await db.openBee()
 }
 
 async function saveWriter(db, writerKey, { name, isMobile }) {
+  const ts = Date.now()
   await db.write([
     [
       'add-writer',
       {
         master: db.identity.publicKey,
         writer: writerKey,
-        sig: db.identity.sign(addWriterPayload(db.key, writerKey, db.writerKey))
+        sig: db.identity.sign(addWriterPayload(db.key, writerKey, db.writerKey)),
+        ts
       }
     ],
     [
@@ -70,7 +122,9 @@ async function saveWriter(db, writerKey, { name, isMobile }) {
       {
         id: toId(writerKey),
         name: name || null,
-        isMobile: isMobile === true
+        isMobile: isMobile === true,
+        createdAt: ts,
+        updatedAt: ts
       }
     ]
   ])

package/src/database/changes.js

@@ -0,0 +1,120 @@
+import { Readable } from 'streamx'
+import b4a from 'b4a'
+
+// the pinned hyperbee2 snapshot inside a hyperdb snapshot — internals reach
+// (pear-sdk does the same); kept in one helper so an upstream rename is a
+// one-line fix
+const beeOf = (snap) => snap.engineSnapshot.snapshot
+
+/**
+ * Pull-driven delta stream over a collection: batches of `{ prev, next }`
+ * pairs diffed between per-stream snapshot cursors. Update ticks only mark
+ * the stream dirty — the diff runs when the reader demands, so backpressure
+ * folds bursts into one bigger batch and nothing is ever dropped. The first
+ * batch, and any batch after the view is swapped or fast-forwarded to a new
+ * core, carries the full matching state as inserts with `reset: true`.
+ *
+ * @param {import('./index.js').Database} db
+ * @param {string} name    Ref name (scopes the update ticks).
+ * @param {string} col     Collection path (`@ns/name`).
+ * @param {(row: any) => boolean} matches
+ * @returns {import('streamx').Readable}
+ */
+export function makeChanges(db, name, col, matches) {
+  let cursor = null
+  let cursorView = null
+  let dirty = true
+  let busy = false
+  let off = null
+
+  const stream = new Readable({
+    open(cb) {
+      off = db.onUpdate(mark, name)
+      pump()
+      cb(null)
+    },
+    read(cb) {
+      pump()
+      cb(null)
+    },
+    predestroy() {
+      if (off) off()
+    },
+    destroy(cb) {
+      release().then(() => cb(null), cb)
+    }
+  })
+
+  const mark = () => {
+    dirty = true
+    pump()
+  }
+
+  const pump = () => {
+    if (busy || !dirty || stream.destroyed) return
+    busy = true
+    run()
+      .catch((err) => stream.destroy(err))
+      .finally(() => {
+        busy = false
+      })
+  }
+
+  const run = async () => {
+    while (dirty && !stream.destroyed) {
+      dirty = false
+      const batch = await diff()
+      if (batch && stream.push(batch) === false) return
+    }
+  }
+
+  const diff = async () => {
+    const snap = db.view.snapshot()
+    try {
+      const fresh =
+        !cursor ||
+        cursorView !== db.view ||
+        !b4a.equals(beeOf(cursor).core.key, beeOf(snap).core.key)
+      const batch = fresh ? await initial(snap) : await delta(snap)
+      if (cursor) await cursor.close()
+      cursor = snap
+      cursorView = db.view
+      return batch
+    } catch (err) {
+      await snap.close().catch(() => {})
+      throw err
+    }
+  }
+
+  const initial = async (snap) => {
+    const changes = []
+    for (const next of await snap.find(col, {}).toArray()) {
+      if (matches(next)) changes.push({ prev: null, next })
+    }
+    return { changes, reset: true }
+  }
+
+  const delta = async (snap) => {
+    const collection = db.view.definition.resolveCollection(col)
+    const range = collection.encodeKeyRange({})
+    const changes = []
+    for await (const { left, right } of beeOf(cursor).createDiffStream(beeOf(snap), range)) {
+      const prev = left ? collection.reconstruct(db.view.versions, left.key, left.value) : null
+      const next = right ? collection.reconstruct(db.view.versions, right.key, right.value) : null
+      const from = prev && matches(prev) ? prev : null
+      const to = next && matches(next) ? next : null
+      if (!from && !to) continue
+      changes.push({ prev: from, next: to })
+    }
+    return changes.length ? { changes, reset: false } : null
+  }
+
+  const release = async () => {
+    if (!cursor) return
+    const held = cursor
+    cursor = null
+    await held.close().catch(() => {})
+  }
+
+  return stream
+}

package/src/database/dispatch.js

@@ -105,7 +105,7 @@ export function makeDispatcher(spec, ns, routes, onerror = safetyCatch, getDbKey
     if (!Identity.verify(op.master, addWriterPayload(ctx.dbKey, op.writer, ctx.key), op.sig)) return
     if (!(await isGenesis(ctx.view)) && !can(await getRole(ctx.view, op.master), INVITE)) return
     await ctx.host.addWriter(op.writer, { isIndexer: op.isIndexer !== false })
-    const ts = Date.now()
+    const ts = op.ts || 0
     await insert(ctx.view, 'devices', `@${ns}/devices`, {
       id: toId(op.writer),
       memberId: toId(op.master),
@@ -131,7 +131,7 @@ export function makeDispatcher(spec, ns, routes, onerror = safetyCatch, getDbKey
     const memberId = toId(op.identity)
     if (!can(await getRole(ctx.view, op.identity), WRITE)) return
     await ctx.host.addWriter(op.writer, { isIndexer: true })
-    const ts = Date.now()
+    const ts = op.ts || 0
     await insert(ctx.view, 'devices', `@${ns}/devices`, {
       id: toId(op.writer),
       memberId,
@@ -149,13 +149,13 @@ export function makeDispatcher(spec, ns, routes, onerror = safetyCatch, getDbKey
     await insert(ctx.view, 'members', `@${ns}/members`, op)
     const deviceId = toId(op.key)
     const existingDevice = await getDevice(ctx.view, deviceId)
-    const ts = Date.now()
+    const ts = op.updatedAt || 0
     await insert(ctx.view, 'devices', `@${ns}/devices`, {
       id: deviceId,
       memberId: op.id,
       name: existingDevice?.name ?? null,
       isMobile: existingDevice?.isMobile ?? false,
-      createdAt: existingDevice?.createdAt ?? ts,
+      createdAt: existingDevice?.createdAt || op.createdAt || ts,
       updatedAt: ts
     })
   })
@@ -203,11 +203,11 @@ export function makeDispatcher(spec, ns, routes, onerror = safetyCatch, getDbKey
       })
       add(`set-${b.verb}`, async (op, ctx) => {
         const existing = await getDevice(ctx.view, op.id)
-        const ts = Date.now()
+        const ts = op.updatedAt || 0
         await insert(ctx.view, b.name, col, {
           ...op,
           memberId: existing?.memberId ?? op.memberId ?? null,
-          createdAt: existing?.createdAt ?? ts,
+          createdAt: existing?.createdAt || op.createdAt || ts,
           updatedAt: ts
         })
       })

package/src/database/envelope.js

@@ -0,0 +1,32 @@
+import b4a from 'b4a'
+import c from 'compact-encoding'
+
+// 0xff is the c.uint prefix for a 64-bit route id — unreachable for real
+// hyperdispatch routes, so it safely marks a version-enveloped op. Peers too
+// old to know the envelope throw on it and skip deterministically.
+const SENTINEL = 0xff
+
+/**
+ * Prefix an encoded op with the app's contract version.
+ *
+ * @param {number} version
+ * @param {Uint8Array} body
+ * @returns {Uint8Array}
+ */
+export function wrap(version, body) {
+  return b4a.concat([b4a.from([SENTINEL]), c.encode(c.uint, version), body])
+}
+
+/**
+ * Split an op into contract version and payload. Ops written before the
+ * envelope existed carry no sentinel and read as version 0.
+ *
+ * @param {Uint8Array} buf
+ * @returns {{ version: number, body: Uint8Array }}
+ */
+export function unwrap(buf) {
+  if (buf.byteLength === 0 || buf[0] !== SENTINEL) return { version: 0, body: buf }
+  const state = { buffer: buf, start: 1, end: buf.byteLength }
+  const version = c.uint.decode(state)
+  return { version, body: buf.subarray(state.start) }
+}

package/src/database/index.js

@@ -1,5 +1,6 @@
 import Autobee from 'autobee'
 import HyperDB from 'hyperdb'
+import c from 'compact-encoding'
 import Hypercore from 'hypercore'
 import ReadyResource from 'ready-resource'
 import safetyCatch from 'safety-catch'
@@ -7,8 +8,10 @@ import b4a from 'b4a'
 
 import { NAMESPACE, SINGLE, COLLECTION, ACTION, ACTIVE, PASSIVE } from '../lib/constants.js'
 import { genId, subscribe, addWriterPayload, claimWriterPayload } from '../lib/utils.js'
+import { wrap, unwrap } from './envelope.js'
 import { CeroError } from '../lib/errors.js'
 import { bootstrap } from './bootstrap.js'
+import { makeChanges } from './changes.js'
 import { makeDispatcher } from './dispatch.js'
 
 /**
@@ -57,6 +60,8 @@ export class Database extends ReadyResource {
     this.meta = opts.spec.meta || { ns: NAMESPACE, refs: {} }
     this.ns = this.meta.ns || NAMESPACE
     this.refs = this.meta.refs || {}
+    this.version = this.meta.version || 1
+    this.behind = null
     this.routes = opts.routes || {}
     this.namespace = opts.namespace || NAMESPACE
     this.encryptionKey = opts.encryptionKey || opts.identity.encryptionKey || null
@@ -124,9 +129,21 @@ export class Database extends ReadyResource {
       wakeup: wakeup || undefined,
       open: (b) => HyperDB.bee2(b, this.spec.database, { autoUpdate: true }),
       apply: async (nodes, view, host) => {
-        const result = await (this.applyOverride || this.dispatcher.apply)(nodes, view, host)
-        if (this.updaters.size) this._touch(nodes)
-        if (this.onApplyHooks.size) this._observe(nodes)
+        // envelope handling lives here, once: unwrap every node and skip ops
+        // from a newer app version (deterministic — they stay in the log), so
+        // the dispatcher AND custom apply overrides see plain op bytes
+        const ready = []
+        for (const node of nodes) {
+          const { version, body } = unwrap(node.value)
+          if (version > this.version) {
+            this._onFuture(version)
+            continue
+          }
+          ready.push(version === 0 ? node : { ...node, value: body })
+        }
+        const result = await (this.applyOverride || this.dispatcher.apply)(ready, view, host)
+        if (this.updaters.size) this._touch(ready)
+        if (this.onApplyHooks.size) this._observe(ready)
         return result
       },
       update: async (db) => {
@@ -149,6 +166,21 @@ export class Database extends ReadyResource {
     this.bee = bee
     this.key = bee.key
 
+    const behind = await bee.local.getUserData('cero/behind')
+    this.behind = behind ? c.decode(c.uint, behind) : null
+
+    // ops we once skipped are now within our contract — wipe the boot record
+    // so the next open replays the whole log through the current handlers
+    if (this.behind !== null && this.behind <= this.version) {
+      await bee.local.setUserData('autobee/head', null)
+      await bee.local.setUserData('cero/behind', null)
+      await bee.close()
+      this.behind = null
+      await this.openBee()
+      this.emit('rebuild')
+      return
+    }
+
     bee.on('writable', () => this.emit('writable'))
     // without a listener autobee escalates apply/view errors to a process crash
     bee.on('error', this._onerror)
@@ -503,7 +535,49 @@ export class Database extends ReadyResource {
     const encoded = ops.map(([op, payload]) =>
       this.spec.dispatch.encode(`@${this.ns}/${op}`, payload)
     )
-    await this.bee.append(encoded.length === 1 ? encoded[0] : encoded)
+    await this._dryRun(encoded)
+    const wrapped = encoded.map((value) => wrap(this.version, value))
+    await this.bee.append(wrapped.length === 1 ? wrapped[0] : wrapped)
+  }
+
+  /**
+   * Record that the log contains ops from a newer app version than this
+   * peer understands. Fires `'behind'` once per version so apps can prompt
+   * an upgrade; the marker survives restarts via local core userData.
+   *
+   * @param {number} version
+   */
+  _onFuture(version) {
+    if (this.behind !== null && version <= this.behind) return
+    this.behind = version
+    this.bee.local.setUserData('cero/behind', c.encode(c.uint, version)).catch(this._onerror)
+    this.emit('behind', version)
+  }
+
+  /**
+   * Validate ops against the committed view before appending: each op runs in
+   * a throwaway transaction with host effects stubbed, so a throwing handler
+   * rejects the write and nothing enters the permanent log. Permission gates
+   * that `return` are not rejections — apply stays the authority at
+   * linearization time.
+   *
+   * @param {Uint8Array[]} encoded
+   */
+  async _dryRun(encoded) {
+    const tx = this.view.transaction()
+    const host = { addWriter: async () => {}, removeWriter: async () => {} }
+    try {
+      for (const value of encoded) {
+        await this.dispatcher.dispatcher.dispatch(value, {
+          view: tx,
+          host,
+          key: this.writerKey,
+          dbKey: this.key
+        })
+      }
+    } finally {
+      await tx.close()
+    }
   }
 
   /**
@@ -634,6 +708,31 @@ export class Database extends ReadyResource {
     })
   }
 
+  /**
+   * Delta subscription: batches of `{ prev, next }` row pairs instead of
+   * full snapshots. The first batch (and any batch after a view swap) carries
+   * the current matching rows as inserts with `reset: true` — replaying every
+   * batch into a Map keyed by row id always reconstructs current state.
+   * `limit`/`reverse` are not applied; deltas are unwindowed by design.
+   *
+   * @param {string} name
+   * @param {Query} [query]
+   * @returns {import('streamx').Readable}
+   */
+  changes(name, query = {}) {
+    this.guard()
+    const col = `@${this.ns}/${name}`
+    if (!this.view.definition.resolveCollection(col)) {
+      throw CeroError.UNKNOWN('collection', name)
+    }
+    const filter = { ...query }
+    delete filter.limit
+    delete filter.reverse
+    delete filter.total
+    const matches = (row) => paginate([row], filter).length > 0
+    return makeChanges(this, name, col, matches)
+  }
+
   /**
    * First-run bootstrap: create the device writer, save it, and swap into it.
    *
@@ -661,9 +760,10 @@ export class Database extends ReadyResource {
     const encoded = this.spec.dispatch.encode(`@${this.ns}/claim-writer`, {
       identity: this.identity.publicKey,
       writer: writerKey,
-      sig
+      sig,
+      ts: Date.now()
     })
-    await this.bee.append(encoded, { optimistic: true })
+    await this.bee.append(wrap(this.version, encoded), { optimistic: true })
     await this.bee.update()
     if (!this.bee.writable) await this.whenWritable()
   }
@@ -826,7 +926,9 @@ export class Database extends ReadyResource {
       signers: [{ publicKey }]
     })
     const sig = this.identity.sign(addWriterPayload(this.key, writerKey, this.writerKey))
-    await this.write([[verb, { master: this.identity.publicKey, writer: writerKey, sig }]])
+    await this.write([
+      [verb, { master: this.identity.publicKey, writer: writerKey, sig, ts: Date.now() }]
+    ])
     await this.runAfter(hook, ctx)
   }
 }

package/src/lib/spec/index.js

@@ -1,12 +1,12 @@
 // This file is autogenerated by the hyperschema compiler
-// Schema Version: 1
+// Schema Version: 2
 /* eslint-disable camelcase */
 /* eslint-disable quotes */
 /* eslint-disable space-before-function-paren */
 
 import { c } from 'hyperschema/runtime'
 
-const VERSION = 1
+const VERSION = 2
 
 // eslint-disable-next-line no-unused-vars
 let version = VERSION
@@ -274,6 +274,37 @@ const encoding6 = {
   }
 }
 
+// @cero/changes.prev
+const encoding7_0 = encoding3_0
+// @cero/changes.next
+const encoding7_1 = encoding3_0
+
+// @cero/changes
+const encoding7 = {
+  preencode(state, m) {
+    state.end++ // max flag is 2 so always one byte
+
+    if (version >= 2 && m.prev) encoding7_0.preencode(state, m.prev)
+    if (version >= 2 && m.next) encoding7_1.preencode(state, m.next)
+  },
+  encode(state, m) {
+    const flags = ((version >= 2 && m.prev) ? 1 : 0) | ((version >= 2 && m.next) ? 2 : 0)
+
+    c.uint.encode(state, flags)
+
+    if (version >= 2 && m.prev) encoding7_0.encode(state, m.prev)
+    if (version >= 2 && m.next) encoding7_1.encode(state, m.next)
+  },
+  decode(state) {
+    const flags = c.uint.decode(state)
+
+    return {
+      prev: (version >= 2 && (flags & 1) !== 0) ? encoding7_0.decode(state) : null,
+      next: (version >= 2 && (flags & 2) !== 0) ? encoding7_1.decode(state) : null
+    }
+  }
+}
+
 function setVersion(v) {
   version = v
 }
@@ -311,6 +342,8 @@ function getEncoding(name) {
       return encoding5
     case '@cero/blob-id':
       return encoding6
+    case '@cero/changes':
+      return encoding7
     default:
       throw new Error('Encoder not found ' + name)
   }

package/src/lib/spec/schema.json

@@ -1,5 +1,5 @@
 {
-  "version": 1,
+  "version": 2,
   "schema": [
     {
       "name": "invite-body",
@@ -273,6 +273,28 @@
           "version": 1
         }
       ]
+    },
+    {
+      "name": "changes",
+      "namespace": "cero",
+      "compact": false,
+      "flagsPosition": 0,
+      "fields": [
+        {
+          "name": "prev",
+          "required": false,
+          "array": true,
+          "type": "buffer",
+          "version": 2
+        },
+        {
+          "name": "next",
+          "required": false,
+          "array": true,
+          "type": "buffer",
+          "version": 2
+        }
+      ]
     }
   ]
 }