@cero-base/core 0.2.0 → 0.4.0

package/src/rpc/client.js

@@ -0,0 +1,45 @@
+import ReadyResource from 'ready-resource'
+import safetyCatch from 'safety-catch'
+import FramedStream from 'framed-stream'
+
+import { bindCodec } from './index.js'
+
+/**
+ * Client-side RPC adapter. Mirror of `RPCServer` — wraps an IPC duplex
+ * in a length-framed stream and constructs the spec's hrpc binding ready
+ * to issue requests. Frames are paused until `_open` runs so handlers
+ * registered before `ready()` see a clean slate.
+ */
+export class RPCClient extends ReadyResource {
+  /**
+   * @param {any} ipc                                Duplex IPC stream (e.g. a socket or pipe).
+   * @param {import('./index.js').Spec} spec         Spec object exposing `rpc` and `schema`.
+   */
+  constructor(ipc, spec) {
+    super()
+    if (!ipc) throw new TypeError('ipc is required')
+    if (!spec) throw new TypeError('spec is required')
+    if (!spec.rpc) throw new TypeError('spec.rpc is required')
+
+    this.ipc = ipc
+    this.spec = spec
+    this.framed = new FramedStream(ipc)
+    this.framed.pause()
+    this.rpc = new spec.rpc(this.framed)
+  }
+
+  async _open() {
+    if (!this.spec.codec) bindCodec(this.spec)
+    this.framed.resume()
+  }
+
+  async _close() {
+    if (this.framed && !this.framed.destroyed) {
+      try {
+        this.framed.destroy()
+      } catch (err) {
+        safetyCatch(err)
+      }
+    }
+  }
+}

package/src/rpc/index.js

@@ -0,0 +1,141 @@
+import b4a from 'b4a'
+import c from 'compact-encoding'
+
+import { getEncoding } from '../lib/spec/index.js'
+
+export { RPCServer } from './server.js'
+export { RPCClient } from './client.js'
+
+const EMPTY = b4a.alloc(0)
+
+// Default envelope encodings for the @cero namespace, used when the supplied
+// spec does not provide its own rows/query/create types in its schema.
+const DEFAULT_ROWS = getEncoding('@cero/rows')
+const DEFAULT_QUERY = getEncoding('@cero/query')
+const DEFAULT_CREATE = getEncoding('@cero/create')
+
+/**
+ * @typedef {object} Spec
+ * @property {{ encode: (type: string, value: any) => Uint8Array, decode: (type: string, buf: Uint8Array) => any, getEncoding?: (name: string) => any }} schema   hyperschema-shaped module.
+ * @property {{ ns?: string }} [meta]                                                                                                                              Optional metadata; `ns` controls envelope type fqns.
+ * @property {any} [rpc]                                                                                                                                          hrpc constructor used by RPCServer/RPCClient.
+ * @property {Codec} [codec]                                                                                                                                      Filled in by `bindCodec`.
+ *
+ * @typedef {object} Codec
+ * @property {(type: string, row: any) => Uint8Array} encodeRow
+ * @property {(type: string, buf: Uint8Array) => any} decodeRow
+ * @property {(type: string, rows: any[]) => Uint8Array} encodeRows
+ * @property {(type: string, buf: Uint8Array) => any[]} decodeRows
+ * @property {(q: any) => Uint8Array} encodeQuery
+ * @property {(buf: Uint8Array) => any} decodeQuery
+ * @property {(row: any) => Uint8Array} encodeCreate
+ * @property {(buf: Uint8Array) => any} decodeCreate
+ * @property {(handle: any, op: string, data: any) => Uint8Array} encodeAction
+ * @property {(handle: any, op: string, buf: Uint8Array) => any} decodeAction
+ */
+
+/**
+ * Attach a `codec` namespace to a hyperschema-shaped `spec`. Looks up
+ * envelope types using the spec's namespace (`@<ns>/rows` etc.) and falls
+ * back to the bundled `@cero/*` envelopes when the spec has not declared
+ * its own. Returns the spec for chaining.
+ *
+ * @param {Spec} spec
+ * @returns {Spec}
+ */
+export function bindCodec(spec) {
+  if (!spec) throw new TypeError('spec is required')
+  const schema = spec.schema
+  if (!schema) throw new TypeError('spec.schema is required')
+
+  const ns = spec.meta?.ns
+  const ROWS = ns ? `@${ns}/rows` : null
+  const QUERY = ns ? `@${ns}/query` : null
+  const CREATE = ns ? `@${ns}/create` : null
+
+  spec.codec = {
+    encodeRow(type, row) {
+      if (row == null) return EMPTY
+      return schema.encode(type, row)
+    },
+    decodeRow(type, buf) {
+      if (!buf || buf.length === 0) return undefined
+      return schema.decode(type, buf)
+    },
+    encodeRows(type, rows) {
+      const data = (rows ?? []).map((r) => schema.encode(type, r))
+      return encodeEnvelope(schema, ROWS, DEFAULT_ROWS, { data })
+    },
+    decodeRows(type, buf) {
+      if (!buf || buf.length === 0) return []
+      const env = decodeEnvelope(schema, ROWS, DEFAULT_ROWS, buf)
+      const data = env?.data || []
+      return data.map((b) => schema.decode(type, b))
+    },
+    encodeQuery(q) {
+      if (q == null) return encodeEnvelope(schema, QUERY, DEFAULT_QUERY, {})
+      const { gt, gte, lt, lte, limit, reverse, ...rest } = q
+      const env = { gt, gte, lt, lte, limit, reverse }
+      if (Object.keys(rest).length > 0) env.data = rest
+      return encodeEnvelope(schema, QUERY, DEFAULT_QUERY, env)
+    },
+    decodeQuery(buf) {
+      if (!buf || buf.length === 0) return undefined
+      const env = decodeEnvelope(schema, QUERY, DEFAULT_QUERY, buf)
+      const out = {}
+      // Hyperschema fills optional uint/bool with 0/false defaults; only
+      // include fields the encoder actually wrote (truthy).
+      if (env.gt) out.gt = env.gt
+      if (env.gte) out.gte = env.gte
+      if (env.lt) out.lt = env.lt
+      if (env.lte) out.lte = env.lte
+      if (env.limit) out.limit = env.limit
+      if (env.reverse) out.reverse = env.reverse
+      if (env.data) Object.assign(out, env.data)
+      return Object.keys(out).length === 0 ? undefined : out
+    },
+    encodeCreate(row) {
+      if (row == null) return EMPTY
+      return encodeEnvelope(schema, CREATE, DEFAULT_CREATE, row)
+    },
+    decodeCreate(buf) {
+      if (!buf || buf.length === 0) return {}
+      return decodeEnvelope(schema, CREATE, DEFAULT_CREATE, buf)
+    },
+    encodeAction(handle, op, data) {
+      const ref = handle?.[op]
+      if (!ref || !ref.schema) throw new Error(`unknown action: ${op}`)
+      if (data == null) return EMPTY
+      return schema.encode(ref.schema, data)
+    },
+    decodeAction(handle, op, buf) {
+      const ref = handle?.[op]
+      if (!ref || !ref.schema) throw new Error(`unknown action: ${op}`)
+      if (!buf || buf.length === 0) return undefined
+      return schema.decode(ref.schema, buf)
+    }
+  }
+  return spec
+}
+
+// Tries the spec's own envelope type first; falls back to the built-in @cero
+// encoding bundled with this primitive. This lets callers point a foreign spec
+// at the codec without re-declaring the rows/query/create envelopes.
+function encodeEnvelope(schema, fqn, fallback, value) {
+  if (fqn && schemaHas(schema, fqn)) return schema.encode(fqn, value)
+  return c.encode(fallback, value)
+}
+
+function decodeEnvelope(schema, fqn, fallback, buf) {
+  if (fqn && schemaHas(schema, fqn)) return schema.decode(fqn, buf)
+  return c.decode(fallback, buf)
+}
+
+function schemaHas(schema, name) {
+  if (typeof schema.getEncoding !== 'function') return false
+  try {
+    return schema.getEncoding(name) != null
+  } catch {
+    return false
+  }
+}

package/src/rpc/server.js

@@ -0,0 +1,45 @@
+import ReadyResource from 'ready-resource'
+import safetyCatch from 'safety-catch'
+import FramedStream from 'framed-stream'
+
+import { bindCodec } from './index.js'
+
+/**
+ * Server-side RPC adapter. Wraps an IPC duplex in a length-framed stream
+ * and instantiates the spec's hrpc binding once `bindCodec` has populated
+ * envelope encoders. Reads are paused until `_open` runs so the
+ * application has a chance to register handlers before frames flow.
+ */
+export class RPCServer extends ReadyResource {
+  /**
+   * @param {any} ipc                                Duplex IPC stream (e.g. a socket or pipe).
+   * @param {import('./index.js').Spec} spec         Spec object exposing `rpc` and `schema`.
+   */
+  constructor(ipc, spec) {
+    super()
+    if (!ipc) throw new TypeError('ipc is required')
+    if (!spec) throw new TypeError('spec is required')
+    if (!spec.rpc) throw new TypeError('spec.rpc is required')
+
+    this.ipc = ipc
+    this.spec = spec
+    this.framed = new FramedStream(ipc)
+    this.framed.pause()
+    this.rpc = new spec.rpc(this.framed)
+  }
+
+  async _open() {
+    if (!this.spec.codec) bindCodec(this.spec)
+    this.framed.resume()
+  }
+
+  async _close() {
+    if (this.framed && !this.framed.destroyed) {
+      try {
+        this.framed.destroy()
+      } catch (err) {
+        safetyCatch(err)
+      }
+    }
+  }
+}

package/src/storage/index.js

@@ -0,0 +1,261 @@
+import HypercoreStorage from 'hypercore-storage'
+import Corestore from 'corestore'
+import HyperDB from 'hyperdb'
+import ReadyResource from 'ready-resource'
+
+import { ROCKS, BEE, SINGLE, COLLECTION } from '../lib/constants.js'
+import { genId, subscribe } from '../lib/utils.js'
+import { CeroError } from '../lib/errors.js'
+
+/**
+ * @typedef {object} StorageOpts
+ * @property {{ database: any, meta?: { ns?: string, refs?: Record<string, { kind?: string }> } }} spec
+ * @property {'rocks' | 'bee'} backend
+ * @property {any} [root]   Pre-existing HypercoreStorage to reuse.
+ * @property {any} [store]  Pre-existing Corestore to reuse.
+ *
+ * @typedef {{ name: string, kind: string }} Ref
+ * @typedef {{ id?: string, createdAt: number, updatedAt: number, [k: string]: any }} StoredRow
+ * @typedef {{ data: any }} SingleResult
+ * @typedef {{ data: any[], total: number, size: number }} ListResult
+ * @typedef {{ data: any | null }} GetByIdResult
+ */
+
+/**
+ * Local, single-writer storage. Backed by either RocksDB (`rocks`) or a
+ * Hyperbee on top of corestore (`bee`). Exposes the same `put/get/...`
+ * surface as `Database` but without networking or multi-writer apply.
+ */
+export class Storage extends ReadyResource {
+  /**
+   * @param {string} dir
+   * @param {StorageOpts} [opts]
+   */
+  constructor(dir, { spec, backend, root, store } = {}) {
+    super()
+    if (!root && !store && (typeof dir !== 'string' || !dir))
+      throw CeroError.REQUIRED('dir, root, or store')
+    if (!spec || !spec.database) throw CeroError.REQUIRED('spec.database')
+    if (backend !== ROCKS && backend !== BEE)
+      throw CeroError.INVALID('backend must be "rocks" or "bee"')
+
+    this.dir = dir
+    this.spec = spec
+    this.backend = backend
+    this.ns = spec.meta?.ns || 'cero'
+    this.refs = spec.meta?.refs || {}
+
+    this._cf = `${this.ns}/local`
+    this._ownsRoot = !root && !store
+    this._ownsStore = !store
+    this.root = root || null
+    this.store = store || null
+    this.db = null
+  }
+
+  /**
+   * Construct a RocksDB-backed Storage.
+   *
+   * @param {string} dir
+   * @param {Omit<StorageOpts, 'backend'>} opts
+   */
+  static rocks(dir, opts) {
+    return new Storage(dir, { ...opts, backend: ROCKS })
+  }
+
+  /**
+   * Construct a Hyperbee-backed Storage.
+   *
+   * @param {string} dir
+   * @param {Omit<StorageOpts, 'backend'>} opts
+   */
+  static bee(dir, opts) {
+    return new Storage(dir, { ...opts, backend: BEE })
+  }
+
+  async _open() {
+    if (this._ownsRoot) {
+      this.root = new HypercoreStorage(this.dir, { columnFamilies: [this._cf] })
+      await this.root.ready()
+    }
+
+    if (this._ownsStore) {
+      this.store = new Corestore(this.root, { manifestVersion: 2 })
+      await this.store.ready()
+    }
+
+    if (this.backend === ROCKS) {
+      const cf = this.root.rocks.columnFamily(this._cf)
+      this.db = HyperDB.rocks(cf, this.spec.database)
+    } else {
+      const core = this.store.get({ name: 'local' })
+      await core.ready()
+      this.db = HyperDB.bee(core, this.spec.database, { extension: false, autoUpdate: true })
+    }
+    await this.db.ready()
+  }
+
+  async _close() {
+    if (this.db) {
+      if (this.db.flush) await this.db.flush()
+      await this.db.close()
+      this.db = null
+    }
+    if (this._ownsStore && this.store) {
+      await this.store.close()
+      this.store = null
+    }
+    if (this._ownsRoot && this.root) {
+      await this.root.close()
+      this.root = null
+    }
+  }
+
+  /**
+   * Insert (or overwrite by id) a row, stamping `id`/`createdAt`/`updatedAt`.
+   *
+   * @param {string} name
+   * @param {Record<string, any>} row
+   * @returns {Promise<SingleResult>}
+   */
+  async put(name, row) {
+    this._guard()
+    const ref = this._ref(name)
+    const id = row.id ?? genId()
+    const ts = Date.now()
+    const stored = { id, createdAt: ts, updatedAt: ts, ...row }
+    await this._write(ref, stored)
+    return { data: stored }
+  }
+
+  /**
+   * Upsert by merging with the existing row, preserving `createdAt`.
+   *
+   * @param {string} name
+   * @param {Record<string, any>} row
+   * @returns {Promise<SingleResult>}
+   */
+  async set(name, row) {
+    this._guard()
+    const ref = this._ref(name)
+    const ts = Date.now()
+    const existing = await this._read(ref, row?.id)
+    /** @type {StoredRow} */
+    const stored = {
+      ...row,
+      createdAt: existing?.createdAt ?? ts,
+      updatedAt: ts
+    }
+    if (ref.kind === COLLECTION && !stored.id) stored.id = genId()
+    await this._write(ref, stored)
+    return { data: stored }
+  }
+
+  /**
+   * Delete by id (collection) or wipe the whole single-row table.
+   *
+   * @param {string} name
+   * @param {string} [id]
+   * @returns {Promise<void>}
+   */
+  async del(name, id) {
+    this._guard()
+    const ref = this._ref(name)
+    const col = this._col(ref)
+    await this.db.delete(col, id != null ? { id } : {})
+    await this.db.flush()
+  }
+
+  /**
+   * Read a row. With no `query`: list all (collection) or fetch the one
+   * record (single). With a string id: fetch that specific row.
+   *
+   * @param {string} name
+   * @param {string | Record<string, any>} [query]
+   * @returns {Promise<SingleResult | ListResult | GetByIdResult>}
+   */
+  async get(name, query) {
+    this._guard()
+    const ref = this._ref(name)
+    const col = this._col(ref)
+
+    if (ref.kind === SINGLE) return { data: await this.db.findOne(col, {}) }
+
+    if (typeof query === 'string') {
+      const rows = await this.db.find(col, {}).toArray()
+      return { data: rows.find((r) => r.id === query) ?? null }
+    }
+
+    const data = await this.db.find(col, query || {}).toArray()
+    const total = (await this.db.find(col, {}).toArray()).length
+    return { data, total, size: data.length }
+  }
+
+  /**
+   * Number of rows that match `query` (or total if omitted).
+   *
+   * @param {string} name
+   * @param {Record<string, any>} [query]
+   * @returns {Promise<{ data: number }>}
+   */
+  async count(name, query) {
+    this._guard()
+    const ref = this._ref(name)
+    const col = this._col(ref)
+    const rows = await this.db.find(col, query || {}).toArray()
+    return { data: rows.length }
+  }
+
+  /**
+   * Live snapshot stream — re-emits the latest `get()` result on every
+   * underlying mutation. Destroy the stream to stop watching.
+   *
+   * @param {string} name
+   * @param {Record<string, any>} [query]
+   * @returns {import('streamx').Readable}
+   */
+  watch(name, query) {
+    this._guard()
+    this._ref(name)
+    return subscribe({
+      get: () => this.get(name, query),
+      watch: (fn) => {
+        this.db.watch(fn)
+        return () => this.db.unwatch(fn)
+      }
+    })
+  }
+
+  _guard() {
+    if (this.closing || this.closed) throw CeroError.CLOSED('Storage')
+    if (!this.db) throw CeroError.NOT_READY('Storage', 'storage')
+  }
+
+  /** @param {string} name @returns {Ref} */
+  _ref(name) {
+    if (typeof name !== 'string' || !name)
+      throw CeroError.INVALID('name must be a non-empty string')
+    const ref = this.refs[name]
+    if (!ref) throw CeroError.UNKNOWN('ref', name)
+    return { name, kind: ref.kind || COLLECTION }
+  }
+
+  /** @param {Ref} ref @returns {string} */
+  _col(ref) {
+    return `@${this.ns}/${ref.name}`
+  }
+
+  /** @param {Ref} ref @param {string} [id] @returns {Promise<any | null>} */
+  async _read(ref, id) {
+    if (ref.kind === SINGLE) return this.db.findOne(this._col(ref), {})
+    if (id == null) return null
+    const rows = await this.db.find(this._col(ref), {}).toArray()
+    return rows.find((r) => r.id === id) ?? null
+  }
+
+  /** @param {Ref} ref @param {Record<string, any>} row @returns {Promise<void>} */
+  async _write(ref, row) {
+    await this.db.insert(this._col(ref), row)
+    await this.db.flush()
+  }
+}

package/types/blobs/index.d.ts

@@ -0,0 +1,169 @@
+/**
+ * @typedef {object} BlobsOpts
+ * @property {any} store                                              Corestore (or compatible) used to host the blob core.
+ * @property {import('../identity/index.js').Identity} [identity]     Identity supplying the default encryption key.
+ * @property {import('../network/index.js').Network} [network]        Optional network used to announce + replicate the core.
+ * @property {Uint8Array} [key]                                       Pre-existing blob core key — joins an existing blob feed.
+ * @property {Uint8Array} [encryptionKey]                             Explicit encryption key, overrides `identity.encryptionKey`.
+ *
+ * @typedef {object} BlobEntry
+ * @property {string} id                                              Opaque z32 id used by `get`/`info`/`delete`.
+ * @property {string} hash                                            Content hash (z32-encoded blake2b of the bytes).
+ * @property {number} size                                            Logical byte length recorded at put-time.
+ * @property {any} meta                                               Caller-provided metadata, stored verbatim.
+ * @property {number} createdAt                                       Wall-clock timestamp of the put.
+ *
+ * @typedef {object} PutOpts
+ * @property {any} [meta]                                             Arbitrary metadata persisted alongside the blob.
+ * @property {number} [size]                                          Override the recorded size (defaults to byte length).
+ */
+/**
+ * Content-addressable blob store backed by a single Hyperblobs core.
+ * Writes dedupe locally by content hash, reads/streams are positional
+ * descriptors, and the underlying core is attached to the supplied
+ * network for replication.
+ */
+export class Blobs extends ReadyResource {
+    /** @param {BlobsOpts} [opts] */
+    constructor({ store, identity, network, key, encryptionKey }?: BlobsOpts);
+    store: any;
+    identity: import("../index.js").Identity;
+    network: import("../index.js").Network;
+    encryptionKey: Uint8Array<ArrayBufferLike>;
+    _coreKey: Uint8Array<ArrayBufferLike>;
+    core: any;
+    hyperblobs: any;
+    _discovery: import("../network/discovery.js").Discovery;
+    /** @type {Map<string, BlobEntry>} contentHash → entry */
+    _index: Map<string, BlobEntry>;
+    /** @type {Map<string, BlobEntry>} id → entry (so info/has/delete by id work) */
+    _byId: Map<string, BlobEntry>;
+    /**
+     * Canonical z32 id of the underlying core (null until ready).
+     *
+     * @returns {string | null}
+     */
+    get id(): string | null;
+    /**
+     * Public key of the underlying core.
+     *
+     * @returns {Uint8Array | null}
+     */
+    get key(): Uint8Array | null;
+    /**
+     * Discovery key derived from the core key, used for swarm topics.
+     *
+     * @returns {Uint8Array | null}
+     */
+    get discoveryKey(): Uint8Array | null;
+    /**
+     * Store a buffer or readable stream, returning its opaque id. Identical
+     * content from the same writer is deduplicated locally.
+     *
+     * @param {Uint8Array | import('streamx').Readable} input
+     * @param {PutOpts} [opts]
+     * @returns {Promise<string>}
+     */
+    put(input: Uint8Array | any, { meta, size }?: PutOpts): Promise<string>;
+    /**
+     * Delete the blob with the given id and forget its local index entry.
+     *
+     * @param {string} id
+     * @returns {Promise<void>}
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Resolve the blob bytes for an id. Fetches from peers if not local.
+     *
+     * @param {string} id
+     * @param {any} [opts]
+     * @returns {Promise<Uint8Array>}
+     */
+    get(id: string, opts?: any): Promise<Uint8Array>;
+    /**
+     * Streaming counterpart of `get` — returns a Readable over the blob bytes.
+     *
+     * @param {string} id
+     * @param {any} [opts]
+     * @returns {import('streamx').Readable}
+     */
+    read(id: string, opts?: any): any;
+    /**
+     * Look up the locally-cached metadata for a blob id, or `null` if absent.
+     *
+     * @param {string} id
+     * @returns {Promise<BlobEntry | null>}
+     */
+    info(id: string): Promise<BlobEntry | null>;
+    /**
+     * Whether the underlying blocks for the blob are present in the local core.
+     *
+     * @param {string} id
+     * @returns {Promise<boolean>}
+     */
+    has(id: string): Promise<boolean>;
+    /**
+     * Pre-fetch the blocks for `id` from peers without reading the bytes.
+     *
+     * @param {string} id
+     * @param {any} [opts]
+     * @returns {Promise<void>}
+     */
+    fetch(id: string, opts?: any): Promise<void>;
+    _guard(): void;
+}
+export type BlobsOpts = {
+    /**
+     * Corestore (or compatible) used to host the blob core.
+     */
+    store: any;
+    /**
+     * Identity supplying the default encryption key.
+     */
+    identity?: import("../identity/index.js").Identity;
+    /**
+     * Optional network used to announce + replicate the core.
+     */
+    network?: import("../network/index.js").Network;
+    /**
+     * Pre-existing blob core key — joins an existing blob feed.
+     */
+    key?: Uint8Array;
+    /**
+     * Explicit encryption key, overrides `identity.encryptionKey`.
+     */
+    encryptionKey?: Uint8Array;
+};
+export type BlobEntry = {
+    /**
+     * Opaque z32 id used by `get`/`info`/`delete`.
+     */
+    id: string;
+    /**
+     * Content hash (z32-encoded blake2b of the bytes).
+     */
+    hash: string;
+    /**
+     * Logical byte length recorded at put-time.
+     */
+    size: number;
+    /**
+     * Caller-provided metadata, stored verbatim.
+     */
+    meta: any;
+    /**
+     * Wall-clock timestamp of the put.
+     */
+    createdAt: number;
+};
+export type PutOpts = {
+    /**
+     * Arbitrary metadata persisted alongside the blob.
+     */
+    meta?: any;
+    /**
+     * Override the recorded size (defaults to byte length).
+     */
+    size?: number;
+};
+import ReadyResource from 'ready-resource';

package/types/database/bootstrap.d.ts

@@ -0,0 +1,17 @@
+/**
+ * First-run device provisioning: mint a device writer keypair, persist it as a
+ * writer, then swap the autobee's local core over to it. With `recovering`,
+ * waits for the first peer-replicated append before swapping.
+ *
+ * @param {import('./index.js').Database} db
+ * @param {{ name?: string | null, isMobile?: boolean, recovering?: boolean }} [opts]
+ * @returns {Promise<{ id: Uint8Array, writer: import('../identity/index.js').KeyPair }>}
+ */
+export function bootstrap(db: import("./index.js").Database, { name, isMobile, recovering }?: {
+    name?: string | null;
+    isMobile?: boolean;
+    recovering?: boolean;
+}): Promise<{
+    id: Uint8Array;
+    writer: import("../identity/index.js").KeyPair;
+}>;

package/types/database/dispatch.d.ts

@@ -0,0 +1,8 @@
+export function makeDispatcher(spec: any, ns: any, routes: any): {
+    dispatcher: any;
+    apply(nodes: any, view: any, host: any): Promise<void>;
+};
+export const BUILTINS: {
+    name: string;
+    verb: string;
+}[];