@cero-base/cero 2.0.0 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cero-base/cero",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "The ideal p2p API — everything is a handle, handles contain refs, refs contain rows.",
   "type": "module",
   "sideEffects": false,
@@ -98,7 +98,7 @@
     "test:node": "find test -name '*.test.js' | sort | xargs -P1 -n1 brittle-node"
   },
   "dependencies": {
-    "@cero-base/core": "^2.0.0",
+    "@cero-base/core": "^2.1.0",
     "b4a": "^1.8.1",
     "bare-abort-controller": "^1.1.2",
     "bare-crypto": "^1.15.3",

package/src/build/index.js

@@ -1,5 +1,6 @@
-import { join } from 'path'
+import { join, resolve } from 'path'
 import { promises as fs } from 'fs'
+import { pathToFileURL } from 'url'
 
 import Hyperschema from 'hyperschema'
 import HyperdbBuilder from 'hyperdb/builder'
@@ -9,7 +10,7 @@ import HRPCBuilder from 'hrpc'
 import { CeroError } from '@cero-base/core/errors'
 
 import { NS } from '../lib/constants.js'
-import { registry } from '../extensions/index.js'
+import { extensionsOf } from '../extensions/index.js'
 import * as internal from './internal.js'
 
 /**
@@ -19,6 +20,8 @@ import * as internal from './internal.js'
  *
  * @typedef {object} BuildOpts
  * @property {string} [ns]  Namespace prefix for emitted schema ids. Defaults to `'cero'`.
+ * @property {string | import('../extensions/index.js').Extension[]} [extensions]  The extensions to fold in. A module specifier, relative to `specDir`, is imported here for its `extensions` export and written into the spec, so every process runs the same list. A list is folded in only. The bundled two by default, `[]` for none.
+ * @property {string} [operators]  A module specifier, relative to `specDir`, written into the spec for its `operators` export, so every process binds the same map.
  */
 
 /**
@@ -29,30 +32,34 @@ import * as internal from './internal.js'
  * @param {BuildOpts} [opts]
  * @returns {Promise<void>}
  */
-export async function build(specDir, schema, { ns = NS, extensions = true } = {}) {
+export async function build(specDir, schema, { ns = NS, extensions, operators } = {}) {
   const raw = /** @type {SchemaDefs & { local?: SchemaDefs }} */ (schema?.defs || schema)
   if (!raw || typeof raw !== 'object') throw CeroError.REQUIRED('schema')
+  const from = { extensions: str(extensions), operators: str(operators) }
+  const exts = extensionsOf(
+    null,
+    from.extensions ? await load(from.extensions, specDir) : extensions
+  )
 
-  // t.extend entries by internal type: app schema first, then each extension
+  // t.extend entries by internal type: the app schema first, then each extension at its scope
   const extend = {}
   const defs = {}
-  const collect = (entries, fromExt = false) => {
+  const fold = (entries, target, fromExt) => {
     for (const [k, v] of Object.entries(entries)) {
       if (v && v.kind === 'extend') {
         const type = internal.defs.main[k]?.type
         if (!type) throw CeroError.INVALID(`'${k}' is not an extendable builtin`)
         // app schema wins on field conflicts, extensions only add new fields
         extend[type] = fromExt ? { ...v.fields, ...extend[type] } : { ...extend[type], ...v.fields }
-      } else if (!fromExt || !(k in defs)) {
-        defs[k] = v // app schema wins over an extension's default
+      } else if (fromExt && isPlainHandle(v)) {
+        fold(v, (target[k] = { ...target[k] }), true) // into the handle type, the app's refs kept
+      } else if (!fromExt || !(k in target)) {
+        target[k] = v // app schema wins over an extension's default
       }
     }
   }
-  collect(raw)
-  for (const ext of registry) {
-    if (ext.bundled && extensions === false) continue
-    if (ext.schema) collect(ext.schema, true)
-  }
+  fold(raw, defs, false)
+  for (const ext of exts) if (ext.schema) fold(ext.schema, defs, true)
 
   const main = compile(splitMain(defs), ns, 'main')
   const local = compile(defs.local || {}, ns, 'local')
@@ -81,7 +88,24 @@ export async function build(specDir, schema, { ns = NS, extensions = true } = {}
     if (meta.refs[name]) meta.refs[name] = { kind: 'handle', type: name, schema: `@${ns}/handle` }
   }
 
-  await fs.writeFile(join(specDir, 'index.js'), wireModule(meta, Object.keys(handles)), 'utf-8')
+  await fs.writeFile(
+    join(specDir, 'index.js'),
+    wireModule(meta, Object.keys(handles), from),
+    'utf-8'
+  )
+}
+
+const str = (v) => (typeof v === 'string' ? v : null)
+
+async function load(specifier, specDir) {
+  const url = specifier.startsWith('.')
+    ? pathToFileURL(resolve(specDir, specifier)).href
+    : specifier
+  const { extensions } = await import(url)
+  if (!Array.isArray(extensions)) {
+    throw CeroError.INVALID(`'${specifier}' must export an extensions array`)
+  }
+  return extensions
 }
 
 function splitMain(defs) {
@@ -295,7 +319,10 @@ function handleEntries(names, kinds) {
     .join(',\n')
 }
 
-function wireModule(meta, names) {
+// the spec imports what the build named, so every process finds the same lists
+const named = (what, from) => (from ? `import { ${what} } from '${from}'` : `const ${what} = null`)
+
+function wireModule(meta, names, from) {
   const kinds = ['database', 'dispatch', 'schema']
   return `// autogenerated by cero/build
 import database from './main/db/index.js'
@@ -305,6 +332,8 @@ import rpc from './main/rpc/index.js'
 import localDatabase from './local/db/index.js'
 import * as localSchema from './local/schema/index.js'
 ${handleImports(names, kinds)}
+${named('extensions', from.extensions)}
+${named('operators', from.operators)}
 
 export const meta = ${JSON.stringify(meta, null, 2)}
 
@@ -315,6 +344,8 @@ export const spec = {
   rpc,
   local: { database: localDatabase, schema: localSchema, meta: meta.local },
   meta,
+  extensions,
+  operators,
   handles: {
 ${handleEntries(names, kinds)}
   }

package/src/build/internal.js

@@ -99,7 +99,6 @@ const COMMANDS = [
   ['get', 'req-query', 'res-rows'],
   ['get-one', 'req-id', 'res-data'],
   ['del', 'req-id', 'res-ok'],
-  ['count', 'req-query', 'res-count'],
   ['watch', 'req-query', 'res-rows', true],
   ['call', 'req-call', 'res-data'],
   ['invite', 'req-invite', 'res-invite'],
@@ -109,7 +108,10 @@ const COMMANDS = [
   ['close-handle', 'req-handle', 'res-ok'],
   ['leave', 'req-handle', 'res-ok'],
   ['changes', 'req-query', 'res-changes', true],
-  ['rotate', 'req-handle', 'res-epoch']
+  ['rotate', 'req-handle', 'res-epoch'],
+  ['set-active', 'req-set-active', 'res-ok'],
+  ['suspend', 'req-empty', 'res-ok'],
+  ['resume', 'req-empty', 'res-ok']
 ]
 
 export function commands(ns) {

package/src/build/schemas.js

@@ -159,6 +159,10 @@ export const rpc = {
   'req-handle': {
     handle: required(string)
   },
+  'req-set-active': {
+    handle: required(string),
+    active: bool
+  },
   'res-data': {
     data: bytes
   },
@@ -171,9 +175,6 @@ export const rpc = {
     changes: required(bytes),
     reset: bool
   },
-  'res-count': {
-    count: required(int)
-  },
   'res-invite': {
     invite: required(string)
   },

package/src/extensions/handle-sync.js

@@ -10,7 +10,6 @@ import { get, set, watch } from '../lib/operators.js'
 export function handleSync({ fields = { avatar: t.string } } = {}) {
   return {
     name: 'handle-sync',
-    bundled: true,
     schema: { handles: t.extend(fields) },
     setup(me) {
       const keys = ['name', ...Object.keys(fields)]

package/src/extensions/index.js

@@ -1,8 +1,88 @@
 import { profileSync } from './profile-sync.js'
 import { handleSync } from './handle-sync.js'
+import { t, schema } from '../lib/spec.js'
+import * as operators from '../lib/operators.js'
 
 export * from './profile-sync.js'
 export * from './handle-sync.js'
 
-// process-wide: build() folds in each schema, cero() runs each setup
-export const registry = [profileSync(), handleSync()]
+// everything an extension module needs, light enough for the UI bundle the spec pulls it into
+export { t, schema }
+export const { put, set, get, del, watch, changes, call, open, rotate, before, after } = operators
+export const cero = {
+  t,
+  schema,
+  put,
+  set,
+  get,
+  del,
+  watch,
+  changes,
+  call,
+  open,
+  rotate,
+  before,
+  after
+}
+
+/**
+ * @typedef {object} Extension
+ * @property {Record<string, any>} [schema]  Refs to add, or `t.extend` on a builtin, nested by handle type like the app schema.
+ * @property {(me: any) => any} [setup]      Runs once the root is ready; a returned function runs on close.
+ */
+
+/** The two every app gets unless its build names a list. */
+export const bundled = [profileSync(), handleSync()]
+
+/**
+ * The extensions a spec carries, else the bundled two. A bare function is `{ setup }`.
+ *
+ * @param {any} spec
+ * @param {Array<any>} [override]
+ * @returns {Extension[]}
+ */
+export function extensionsOf(spec, override) {
+  const list = override || spec?.extensions || bundled
+  return list.map((e) => (typeof e === 'function' ? { setup: e } : e))
+}
+
+/**
+ * The operators a spec carries: functions taking the handle first, keyed by namespace, a
+ * key naming a handle type holding that type's namespaces.
+ *
+ * @param {any} spec
+ * @param {Record<string, any>} [override]
+ * @returns {Record<string, any>}
+ */
+export function operatorsOf(spec, override) {
+  return override || spec?.operators || {}
+}
+
+// handle.ns.fn(args) calls fn(handle, args)
+function attach(handle, ns, fns) {
+  const bound = {}
+  for (const key of Object.keys(fns)) {
+    if (typeof fns[key] === 'function') bound[key] = (...args) => fns[key](handle, ...args)
+  }
+  handle[ns] = bound
+}
+
+/**
+ * Put the operators for `handle` on it: the root when `type` is null, else a child of `type`.
+ *
+ * @param {any} handle
+ * @param {string | null} type
+ * @param {Record<string, any>} operators
+ * @returns {any} handle
+ */
+export function bind(handle, type, operators) {
+  const handles = handle.spec?.meta?.handles || {}
+  for (const [ns, fns] of Object.entries(operators)) {
+    if (type === null) {
+      if (!(ns in handles)) attach(handle, ns, fns)
+    } else if (ns === type) {
+      for (const [k, group] of Object.entries(fns)) attach(handle, k, group)
+    }
+  }
+  return handle
+}

package/src/extensions/profile-sync.js

@@ -1,5 +1,5 @@
 import { t } from '../lib/spec.js'
-import { get, set, after } from '../lib/operators.js'
+import { get, set, changes } from '../lib/operators.js'
 
 /**
  * Mirror your `profile` onto your `member` row in every handle you're in.
@@ -9,31 +9,35 @@ import { get, set, after } from '../lib/operators.js'
 export function profileSync({ fields = { avatar: t.string } } = {}) {
   return {
     name: 'profile-sync',
-    bundled: true,
     schema: {
       profile: t.single({ name: t.string, ...fields }),
       members: t.extend(fields)
     },
     setup(me) {
       const keys = ['name', ...Object.keys(fields)]
-      const publish = (child, profile) =>
-        set(child.members, { id: me.identity.id, ...profile }, { upsert: false }).catch(me._onerror)
 
       // an unconditional set on every open is a room-wide op forever
-      const onHandle = async (child) => {
-        const { data: profile } = await get(me.profile)
-        if (!profile) return
+      const publish = async (child, profile) => {
         const { data: member } = await get(child.members, me.identity.id)
         if (member && keys.every((k) => member[k] === profile[k])) return
-        publish(child, profile)
+        await set(child.members, { id: me.identity.id, ...profile }, { upsert: false })
       }
 
-      const onProfile = (ctx) => {
-        if (ctx.row) me.children.forEach((child) => publish(child, ctx.row))
+      const onHandle = async (child) => {
+        const { data: profile } = await get(me.profile)
+        if (profile) await publish(child, profile)
       }
 
       me.on('handle', (child) => onHandle(child).catch(me._onerror), { signal: me.signal })
-      after(me.profile, onProfile, { signal: me.signal })
+
+      // a local edit and one replicated from another device both land here
+      const stream = changes(me.profile, {}, { signal: me.signal })
+      stream.on('error', me._onerror)
+      stream.on('data', ({ changes: batch }) => {
+        for (const { next } of batch) {
+          if (next) me.children.forEach((child) => publish(child, next).catch(me._onerror))
+        }
+      })
     }
   }
 }

package/src/handle/index.js

@@ -22,7 +22,8 @@ import { FileServer } from '@cero-base/core/blobs/server'
 import { NS, TIMEOUT } from '../lib/constants.js'
 
 import { Ref } from '../lib/refs.js'
-import { bind } from '../lib/operators.js'
+import { extensionsOf, operatorsOf, bind } from '../extensions/index.js'
+import { before, after } from '../lib/operators.js'
 
 export { Ref } from '../lib/refs.js'
 
@@ -48,7 +49,6 @@ export { Ref } from '../lib/refs.js'
  * @property {Array<{ epoch: number, entropy: Uint8Array }>} [epochs]  Rotation epochs delivered at join.
  * @property {string} [namespace]              Corestore namespace.
  * @property {KeyPair} [keyPair]               Writer keypair.
- * @property {boolean} [passive]               Join discovery server-only; flip later with `setActive`.
  * @property {boolean} [pair]                  When `false`, skips creating a `Pairing` session.
  *
  * @typedef {object} CreateChildOpts
@@ -114,8 +114,11 @@ export class Handle extends ReadyResource {
     this._discovery = opts.discovery || null
     this._dir = opts.dir || null
     this._opts = opts.opts || {}
+    this.extensions = parent?.extensions || extensionsOf(spec, this._opts.extensions)
+    this.operators = parent?.operators || operatorsOf(spec, this._opts.operators)
     this._onerror = this._opts.onerror || safetyCatch
     this.children = parent ? null : new Set()
+    this._typeHooks = parent ? null : new Set()
     this._loading = parent ? null : new Map()
     this._joining = parent ? null : new Map()
     this._coreKeys = parent ? null : new Map()
@@ -139,7 +142,7 @@ export class Handle extends ReadyResource {
       epochs: opts.epochs,
       namespace: opts.namespace,
       keyPair: opts.keyPair,
-      passive: opts.passive,
+      pinned: !parent,
       onerror: this._onerror
     })
     this.pair = null
@@ -201,6 +204,11 @@ export class Handle extends ReadyResource {
     return blobs
   }
 
+  /** The handle type of a child, null on the root. */
+  get type() {
+    return this.spec.meta.type || null
+  }
+
   /** Canonical id — identity id for the root handle, store key for children. */
   get id() {
     if (!this.parent) return this.identity.id
@@ -233,10 +241,12 @@ export class Handle extends ReadyResource {
       await this.pair.ready()
       // serve invites persisted by any member, in step with the rows
       await this._syncInvites().catch(safetyCatch)
-      this._invitesSync = () => this._syncInvites().catch(safetyCatch)
+      this._invitesSync = (touched) => {
+        if (touched.has('*') || touched.has('invites')) this._syncInvites().catch(safetyCatch)
+      }
       this.store.on('update', this._invitesSync)
     }
-    Ref.attach(this, this.store.refs)
+    Ref.attach(this, this.store.refs, this.spec.handles)
     this.root._coreKeys.set(b4a.toString(this.store.key, 'hex'), this.store.encryptionKey)
     if (!this.parent) await this.fileServer.listen()
   }
@@ -349,15 +359,13 @@ export class Handle extends ReadyResource {
   }
 
   /**
-   * Flip this handle's swarm announce mode — `setActive(false)` demotes an idle/background
-   * room to server-only (still reachable, stops searching); `setActive(true)` promotes it
-   * back on focus.
+   * `true` ranks this handle as just touched, `false` takes it out of the swarm until the
+   * next update lands in it.
    *
    * @param {boolean} active
-   * @returns {Promise<void>}
    */
   setActive(active) {
-    return this.store.setActive(active)
+    this.store.setActive(active)
   }
 
   /**
@@ -467,16 +475,16 @@ export class Handle extends ReadyResource {
     }
 
     const sig = this.identity.sign(admission(this.store.key, writerKey, this.store.writerKey))
+    // one batch: the member row, then the writer that belongs to it; a refusal discards both
     await this.store.tx(async (tx) => {
+      await tx.call('add-member', member)
       await tx.call('add-writer', {
         sig,
         master: this.identity.publicKey,
         writer: writerKey,
-        // add-member in the same transaction decides the rank, a refusal discards both
         memberId: member.id,
         ts: member.updatedAt || Date.now()
       })
-      await tx.call('add-member', member)
     })
   }
 
@@ -675,9 +683,7 @@ export class Handle extends ReadyResource {
       })
 
       if (accept !== false) this._wireAccept(child, { role })
-      bind(child, type)
-      this.children.add(child)
-      this.emit('handle', child, { name, role })
+      this._adopt(child, { name, role })
       publish(child)
       this._loading?.delete(id)
       return child
@@ -781,9 +787,7 @@ export class Handle extends ReadyResource {
         updatedAt: ts
       })
       this._wireAccept(child)
-      bind(child, type)
-      this.children.add(child)
-      this.emit('handle', child, {})
+      this._adopt(child, {})
       publish(child)
       this._loading?.delete(id)
       return child
@@ -852,9 +856,7 @@ export class Handle extends ReadyResource {
     }
     // `accept: false` is a host-approval gate, re-arming it silently is worse
     if (opts?.accept !== false) this._wireAccept(child, { role: opts?.role })
-    bind(child, type)
-    this.children.add(child)
-    this.emit('handle', child, {})
+    this._adopt(child, {})
     return child
   }
 
@@ -882,6 +884,35 @@ export class Handle extends ReadyResource {
     await Promise.all([...this.children].map((child) => child.pair?.resume()))
   }
 
+  // a child is a child once it has its operators, the hooks declared for its type, and a slot
+  _adopt(child, info) {
+    bind(child, child.type, this.operators)
+    for (const hook of this._typeHooks) hook.apply(child)
+    this.children.add(child)
+    this.emit('handle', child, info)
+  }
+
+  // before(me.room.notes, fn): on every room open now and every one opened later
+  _hookType(op, ref, fn, opts) {
+    const offs = new Map()
+    const hook = {
+      apply: (child) => {
+        if (child.type !== ref.type) return
+        offs.set(child, op(child[ref.name], fn))
+        child.once('close', () => offs.delete(child))
+      }
+    }
+    this._typeHooks.add(hook)
+    for (const child of this.children) hook.apply(child)
+    const off = () => {
+      this._typeHooks.delete(hook)
+      for (const o of offs.values()) o()
+      offs.clear()
+    }
+    onAbort(opts?.signal, off)
+    return off
+  }
+
   /**
    * @param {Handle} child
    * @param {{ role?: string }} [opts]

package/src/index.js

@@ -17,21 +17,18 @@ import {
   set,
   get,
   del,
-  count,
   watch,
   changes,
   call,
   open,
   rotate,
   before,
-  after,
-  bind,
-  define
+  after
 } from './lib/operators.js'
 import { peek } from './lib/peek.js'
 import { t, schema } from './lib/spec.js'
 import { FLUSH, TIMEOUT } from './lib/constants.js'
-import { registry } from './extensions/index.js'
+import { bind } from './extensions/index.js'
 
 export { Handle, Ref, Local }
 export {
@@ -39,16 +36,13 @@ export {
   set,
   get,
   del,
-  count,
   watch,
   changes,
   call,
   open,
   rotate,
   before,
-  after,
-  bind,
-  define
+  after
 } from './lib/operators.js'
 export { peek } from './lib/peek.js'
 export { t, schema } from './lib/spec.js'
@@ -69,13 +63,15 @@ export { t, schema } from './lib/spec.js'
  * @property {number[]} [backoffs]                     Swarm reconnect backoff tiers in ms (testing/tuning).
  * @property {string} [channel]                        Optional network-isolation label; only same-channel peers connect.
  * @property {Array<string | Uint8Array>} [mirrors]    Blind-peer public keys. Rooms and files are mirrored through them so peers sync even when never online at the same time. Mirrors hold only encrypted blocks — they never read your data.
+ * @property {{ active?: number, announced?: number, idle?: number }} [presence]  How many rooms search, how many only announce, and the idle ms before the rest leave the swarm.
  * @property {Uint8Array} [key]                        Existing database key to recover into, skipping the pointer lookup.
  * @property {Uint8Array} [encryptionKey]              Pre-existing encryption key.
  * @property {Record<string, Function>} [routes]       Custom RPC routes for the database dispatcher.
  * @property {(err: any) => void} [onerror]            Background-task error handler.
  * @property {number} [recoveryTimeout]                Max wait to find another device and be admitted, in ms. Defaults to 30000.
  * @property {Uint8Array} [storageKey]                 32-byte key encrypting local key material (master seed, device keypairs) at rest. Source it from the OS keychain — cero never stores it.
- * @property {boolean} [extensions]                    `false` disables the bundled extensions (profileSync, handleSync) for this instance. Build with `{ extensions: false }` too so the spec matches.
+ * @property {import('./extensions/index.js').Extension[]} [extensions]  The extensions this instance runs, instead of the ones the spec carries. Build with the same list.
+ * @property {Record<string, any>} [operators]  The operators to bind, instead of the ones the spec carries.
  * @property {boolean | { autoStart?: boolean, backend?: any, maxOutbound?: number, maxInbound?: number, pipe?: 'l2cap' | 'gatt' }} [bluetooth]  `true` enables nearby (Bluetooth) sync via `me.bluetooth` (auto-started). `{ autoStart: false }` creates the facade without starting the radio — the app calls `me.bluetooth.start()`/`stop()` (user toggle). `backend` injects a bare-bluetooth-shaped backend (tests). `maxOutbound`/`maxInbound` cap concurrent outbound links and inbound sessions. `pipe` picks the data pipe — `'l2cap'` (default, faster) or `'gatt'`; both peers must match. Absent backend on an unsupported host → `me.bluetooth.state === 'unsupported'`.
  */
 
@@ -129,7 +125,8 @@ export async function cero(dir, spec, opts = {}) {
       backoffs: opts.backoffs,
       channel: opts.channel,
       store,
-      mirrors: opts.mirrors
+      mirrors: opts.mirrors,
+      presence: opts.presence
     })
     await network.ready()
     discovery = network.join(identity.topic)
@@ -183,22 +180,12 @@ export async function cero(dir, spec, opts = {}) {
           secretKey: result.writer.secretKey
         })
       }
-      if (!recovering) {
-        const ts = Date.now()
-        await me.store.call('add-member', {
-          id: identity.id,
-          key: me.store.writerKey,
-          role: 'owner',
-          name: opts.name || null,
-          createdAt: ts,
-          updatedAt: ts
-        })
-        if (pointer.length === 0) await pointer.append(c.encode(c.fixed32, me.store.key))
+      if (!recovering && pointer.length === 0) {
+        await pointer.append(c.encode(c.fixed32, me.store.key))
       }
     }
 
-    for (const ext of registry) {
-      if (ext.bundled && opts.extensions === false) continue
+    for (const ext of me.extensions) {
       const off = await ext.setup?.(me)
       if (typeof off === 'function') me.once('close', off)
     }
@@ -217,7 +204,7 @@ export async function cero(dir, spec, opts = {}) {
       await me.bluetooth.ready()
     }
 
-    bind(me, null)
+    bind(me, null, me.operators)
     return me
   } catch (err) {
     // before the root Handle exists, tear the raw resources down in reverse order
@@ -266,7 +253,6 @@ cero.put = put
 cero.set = set
 cero.get = get
 cero.del = del
-cero.count = count
 cero.watch = watch
 cero.changes = changes
 cero.call = call
@@ -277,18 +263,6 @@ cero.after = after
 cero.peek = peek
 cero.restore = restore
 cero.schema = schema
-cero.bind = bind
-cero.define = define
-// test-only
-cero._registry = registry
-// a bare function is shorthand for { setup }; a named extension replaces one of the same name
-cero.use = (...exts) => {
-  for (const e of exts.flat().map((e) => (typeof e === 'function' ? { setup: e } : e))) {
-    const i = e.name ? registry.findIndex((x) => x.name === e.name) : -1
-    if (i >= 0) registry[i] = e
-    else registry.push(e)
-  }
-}
 
 function pointerManifest(store, identity) {
   return { version: store.manifestVersion, signers: [{ publicKey: identity.publicKey }] }