@cero-base/core 0.8.10 → 1.0.1

package/src/storage/index.js

@@ -85,6 +85,8 @@ export class Storage extends ReadyResource {
     }
 
     if (this.backend === ROCKS) {
+      if (!this.root)
+        throw CeroError.INVALID('rocks backend requires a root storage, not store-only')
       const cf = this.root.rocks.columnFamily(this._cf)
       this.db = HyperDB.rocks(cf, this.spec.database)
     } else {
@@ -129,19 +131,24 @@ export class Storage extends ReadyResource {
   }
 
   /**
-   * Upsert by merging with the existing row, preserving `createdAt`.
+   * Upsert by merging with the existing row, preserving `createdAt`. Pass
+   * `{ upsert: false }` to update-only — a missing row is left untouched
+   * (returns `null`) instead of created. Mirrors `Database.set`.
    *
    * @param {string} name
    * @param {Record<string, any>} row
-   * @returns {Promise<SingleResult>}
+   * @param {{ upsert?: boolean }} [opts]
+   * @returns {Promise<SingleResult | null>}
    */
-  async set(name, row) {
+  async set(name, row, { upsert = true } = {}) {
     this._guard()
     const ref = this._ref(name)
     const ts = Date.now()
     const existing = await this._read(ref, row?.id)
+    if (!upsert && !existing) return null
     /** @type {StoredRow} */
     const stored = {
+      ...existing,
       ...row,
       createdAt: existing?.createdAt ?? ts,
       updatedAt: ts
@@ -181,13 +188,16 @@ export class Storage extends ReadyResource {
 
     if (ref.kind === SINGLE) return { data: await this.db.findOne(col, {}) }
 
+    // keyed lookup, not a full scan + in-memory find
     if (typeof query === 'string') {
-      const rows = await this.db.find(col, {}).toArray()
-      return { data: rows.find((r) => r.id === query) ?? null }
+      return { data: (await this.db.get(col, { id: query })) ?? null }
     }
 
     const data = await this.db.find(col, query || {}).toArray()
-    const total = (await this.db.find(col, {}).toArray()).length
+    // a filter (or limit) caps `data`, so `total` needs a full count; with no
+    // query `data` is already everything — skip the second scan.
+    const filtered = query && Object.keys(query).length > 0
+    const total = filtered ? (await this.db.find(col, {}).toArray()).length : data.length
     return { data, total, size: data.length }
   }
 

package/types/blobs/codec.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Encode a coreKey + raw hyperblobs blobId + type into a durable string id.
+ *
+ * @param {Uint8Array} coreKey
+ * @param {RawBlobId} blobId
+ * @param {string} type
+ * @returns {string}
+ */
+export function encodeId(coreKey: Uint8Array, blobId: RawBlobId, type: string): string;
+/**
+ * Decode a string id back into its coreKey, raw blobId and type.
+ *
+ * @param {string} id
+ * @returns {{ coreKey: Uint8Array, blobId: RawBlobId, type: string }}
+ */
+export function decodeId(id: string): {
+    coreKey: Uint8Array;
+    blobId: RawBlobId;
+    type: string;
+};
+export type RawBlobId = {
+    blockOffset: number;
+    blockLength: number;
+    byteOffset: number;
+    byteLength: number;
+};

package/types/blobs/index.d.ts

@@ -1,28 +1,14 @@
 /**
  * @typedef {object} BlobsOpts
- * @property {any} store                                              Corestore (or compatible) used to host the blob core.
+ * @property {object} 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.
+ * @typedef {import('./codec.js').RawBlobId} RawBlobId
  */
+/** Thin wrapper over a single Hyperblobs core; deals only in raw blobIds. */
 export class Blobs extends ReadyResource {
     /** @param {BlobsOpts} [opts] */
     constructor({ store, identity, network, key, encryptionKey }?: BlobsOpts);
@@ -34,10 +20,6 @@ export class Blobs extends ReadyResource {
     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).
      *
@@ -57,66 +39,47 @@ export class Blobs extends ReadyResource {
      */
     get discoveryKey(): Uint8Array | null;
     /**
-     * Store a buffer or readable stream, returning its opaque id. Identical
-     * content from the same writer is deduplicated locally.
+     * Store a buffer or readable stream, returning its raw hyperblobs blobId.
      *
      * @param {Uint8Array | import('streamx').Readable} input
-     * @param {PutOpts} [opts]
-     * @returns {Promise<string>}
+     * @returns {Promise<RawBlobId>}
      */
-    put(input: Uint8Array | any, { meta, size }?: PutOpts): Promise<string>;
+    put(input: Uint8Array | import("streamx").Readable): Promise<RawBlobId>;
     /**
-     * Delete the blob with the given id and forget its local index entry.
-     *
-     * @param {string} id
-     * @returns {Promise<void>}
+     * @param {import('streamx').Readable} input
+     * @returns {Promise<RawBlobId>}
      */
-    delete(id: string): Promise<void>;
+    _putStream(input: import("streamx").Readable): Promise<RawBlobId>;
     /**
-     * Resolve the blob bytes for an id. Fetches from peers if not local.
+     * Resolve the blob bytes for a raw blobId. Fetches from peers if not local.
      *
-     * @param {string} id
-     * @param {any} [opts]
+     * @param {RawBlobId} blobId
+     * @param {object} [opts]
      * @returns {Promise<Uint8Array>}
      */
-    get(id: string, opts?: any): Promise<Uint8Array>;
+    get(blobId: RawBlobId, opts?: object): Promise<Uint8Array>;
     /**
-     * Streaming counterpart of `get` — returns a Readable over the blob bytes.
+     * Streaming counterpart of `get` — a Readable over the blob bytes.
      *
-     * @param {string} id
-     * @param {any} [opts]
+     * @param {RawBlobId} blobId
+     * @param {object} [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>;
+    createReadStream(blobId: RawBlobId, opts?: object): import("streamx").Readable;
     /**
-     * Pre-fetch the blocks for `id` from peers without reading the bytes.
+     * Clear the blocks backing a raw blobId from the local core.
      *
-     * @param {string} id
-     * @param {any} [opts]
+     * @param {RawBlobId} blobId
      * @returns {Promise<void>}
      */
-    fetch(id: string, opts?: any): Promise<void>;
+    clear(blobId: RawBlobId): Promise<void>;
     _guard(): void;
 }
 export type BlobsOpts = {
     /**
      * Corestore (or compatible) used to host the blob core.
      */
-    store: any;
+    store: object;
     /**
      * Identity supplying the default encryption key.
      */
@@ -134,36 +97,8 @@ export type BlobsOpts = {
      */
     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;
-};
+export type RawBlobId = import("./codec.js").RawBlobId;
 import ReadyResource from 'ready-resource';
+import { encodeId } from './codec.js';
+import { decodeId } from './codec.js';
+export { encodeId, decodeId };

package/types/blobs/server.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @typedef {{ key: Buffer, encryptionKey: Buffer | null }} Resolved
+ */
+/**
+ * HTTP server that turns a string file id into a renderable localhost URL.
+ * Wraps hypercore-blob-server; the underlying store session is owned by
+ * BlobServer and closed when `close()` is called.
+ */
+export class FileServer {
+    /**
+     * @param {object} opts
+     * @param {import('corestore')} opts.store
+     * @param {(coreKey: Buffer, info: object) => Resolved | null | Promise<Resolved | null>} opts.resolve
+     */
+    constructor({ store, resolve }: {
+        store: any;
+        resolve: (coreKey: Buffer, info: object) => Resolved | null | Promise<Resolved | null>;
+    });
+    resolve: (coreKey: Buffer, info: object) => Resolved | null | Promise<Resolved | null>;
+    server: any;
+    get port(): any;
+    listen(): Promise<void>;
+    /**
+     * Build a renderable localhost URL for a string file id.
+     *
+     * @param {string} id
+     * @returns {string}
+     */
+    getLink(id: string): string;
+    close(): Promise<void>;
+}
+export type Resolved = {
+    key: Buffer;
+    encryptionKey: Buffer | null;
+};

package/types/database/bootstrap.d.ts

@@ -7,7 +7,7 @@
  * @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 }?: {
+export function bootstrap(db: import("./index.js").Database, { name, isMobile, recovering, timeout }?: {
     name?: string | null;
     isMobile?: boolean;
     recovering?: boolean;

package/types/database/dispatch.d.ts

@@ -1,6 +1,29 @@
-export function makeDispatcher(spec: any, ns: any, routes: any): {
-    dispatcher: any;
-    apply(nodes: any, view: any, host: any): Promise<void>;
+/**
+ * Build the hyperdispatch router for a spec: wires membership, builtin, and
+ * spec-defined collection/action ops, returning the router plus an apply loop.
+ *
+ * @param {{ dispatch: { Router: Function }, meta?: { refs?: Record<string, { kind?: string, builtin?: boolean, verb?: string }> } }} spec  Generated hyperdispatch spec.
+ * @param {string} ns  Namespace prefix for collection and op names.
+ * @param {Record<string, Function>} routes  Custom action handlers keyed by route name.
+ * @returns {{ dispatcher: object, apply: (nodes: Array<{ value: Buffer, key: Buffer }>, view: object, host: object) => Promise<void> }}
+ */
+export function makeDispatcher(spec: {
+    dispatch: {
+        Router: Function;
+    };
+    meta?: {
+        refs?: Record<string, {
+            kind?: string;
+            builtin?: boolean;
+            verb?: string;
+        }>;
+    };
+}, ns: string, routes: Record<string, Function>): {
+    dispatcher: object;
+    apply: (nodes: Array<{
+        value: Buffer;
+        key: Buffer;
+    }>, view: object, host: object) => Promise<void>;
 };
 export const BUILTINS: {
     name: string;

package/types/database/index.d.ts

@@ -10,6 +10,7 @@
  * @property {(nodes: any, view: any, host: any) => Promise<void>} [apply]  Override the default apply function.
  * @property {Uint8Array | null} [key]                                Existing autobee key to reopen.
  * @property {import('../identity/index.js').KeyPair} [keyPair]       Device writer keypair; defaults to identity's keypair.
+ * @property {(err: Error) => void} [onerror]                         Called when a background after-hook or onApply callback fails.
  *
  * @typedef {{ data: any | null }} SingleResult
  * @typedef {{ data: any[], total: number, size: number }} ListResult
@@ -61,10 +62,14 @@ export class Database extends ReadyResource {
         publicKey: Uint8Array<ArrayBufferLike>;
         secretKey: Uint8Array<ArrayBufferLike>;
     };
+    _onerror: any;
     bee: any;
     dispatcher: {
-        dispatcher: any;
-        apply(nodes: any, view: any, host: any): Promise<void>;
+        dispatcher: object;
+        apply: (nodes: Array<{
+            value: Buffer;
+            key: Buffer;
+        }>, view: object, host: object) => Promise<void>;
     };
     beforeHooks: Map<any, any>;
     afterHooks: Map<any, any>;
@@ -75,11 +80,16 @@ export class Database extends ReadyResource {
     _discovery: import("../network/discovery.js").Discovery;
     /** Open the underlying autobee, wire dispatcher + apply, attach to network. */
     openBee(): Promise<void>;
-    get discoveryKey(): any;
-    get writerKey(): any;
+    /** @returns {Uint8Array | null} discovery key of the underlying bee */
+    get discoveryKey(): Uint8Array | null;
+    /** @returns {Uint8Array | null} this device's local writer key */
+    get writerKey(): Uint8Array | null;
+    /** @returns {boolean} whether the bee accepts local writes */
     get writable(): boolean;
-    get length(): any;
-    get view(): any;
+    /** @returns {number} number of ops in the local writer */
+    get length(): number;
+    /** @returns {object | null} the materialized HyperDB view */
+    get view(): object | null;
     /**
      * Register a pre-op hook. Returning `false` from `fn` aborts the op.
      *
@@ -182,6 +192,7 @@ export class Database extends ReadyResource {
      * @returns {Promise<T>}
      */
     tx<T>(fn: () => Promise<T> | T): Promise<T>;
+    _txChain: any;
     /**
      * Encode and append dispatch ops. Buffers into the active `tx` queue if one
      * is open.
@@ -217,7 +228,7 @@ export class Database extends ReadyResource {
      * @param {Query} [query]
      * @returns {import('streamx').Readable}
      */
-    watch(name: string, query?: Query): any;
+    watch(name: string, query?: Query): import("streamx").Readable;
     /**
      * First-run bootstrap: create the device writer, save it, and swap into it.
      *
@@ -263,20 +274,41 @@ export class Database extends ReadyResource {
      * @returns {Promise<void>}
      */
     removeWriter(publicKey: Uint8Array): Promise<void>;
+    /**
+     * Throw if the handle is closing/closed or the bee isn't ready yet.
+     *
+     * @returns {void}
+     */
     guard(): void;
-    ref(name: any): {
-        name: string;
-        kind: string;
-        verb: string;
-    };
-    col(ref: any): string;
-    matchIndex(name: any, query: any): {
+    /**
+     * Resolve a table name to its normalized `{ name, kind, verb }` ref.
+     *
+     * @param {string} name
+     * @returns {Ref}
+     */
+    ref(name: string): Ref;
+    /**
+     * Namespaced collection path for a ref.
+     *
+     * @param {Ref} ref
+     * @returns {string}
+     */
+    col(ref: Ref): string;
+    _checkFields(name: any, row: any): void;
+    /**
+     * Find a secondary index whose fields exactly match the query's equality keys.
+     *
+     * @param {string} name
+     * @param {Query} [query]
+     * @returns {{ path: string, range: { gte: object, lte: object } } | null}
+     */
+    matchIndex(name: string, query?: Query): {
         path: string;
         range: {
-            gte: {};
-            lte: {};
+            gte: object;
+            lte: object;
         };
-    };
+    } | null;
     _addHook(map: any, op: any, fn: any): () => void;
     _write(verb: any, hook: any, publicKey: any): Promise<void>;
 }
@@ -331,6 +363,10 @@ export type DatabaseOpts = {
      * Device writer keypair; defaults to identity's keypair.
      */
     keyPair?: import("../identity/index.js").KeyPair;
+    /**
+     * Called when a background after-hook or onApply callback fails.
+     */
+    onerror?: (err: Error) => void;
 };
 export type SingleResult = {
     data: any | null;

package/types/index.d.ts

@@ -1,11 +1,59 @@
 export * from "./identity/index.js";
-export * from "./storage/index.js";
 export * from "./network/index.js";
 export * from "./database/index.js";
 export * from "./blobs/index.js";
 export * from "./rpc/index.js";
 export * from "./pairing/index.js";
-export * from "./pairing/invite.js";
 export * from "./lib/schema.js";
 export * from "./lib/utils.js";
 export * from "./lib/errors.js";
+export { Storage } from "./storage/index.js";
+export { Invite } from "./pairing/invite.js";
+/**
+ * `Ref` / `SingleResult` / `ListResult` are JSDoc typedefs (types, not runtime exports), so they
+ * are re-exported as namespaced type aliases — `export { Ref as StorageRef }` fails at import
+ * because the module provides no runtime `Ref` export.
+ */
+export type StorageRef = import("./storage/index.js").Ref;
+/**
+ * `Ref` / `SingleResult` / `ListResult` are JSDoc typedefs (types, not runtime exports), so they
+ * are re-exported as namespaced type aliases — `export { Ref as StorageRef }` fails at import
+ * because the module provides no runtime `Ref` export.
+ */
+export type StorageSingleResult = import("./storage/index.js").SingleResult;
+/**
+ * `Ref` / `SingleResult` / `ListResult` are JSDoc typedefs (types, not runtime exports), so they
+ * are re-exported as namespaced type aliases — `export { Ref as StorageRef }` fails at import
+ * because the module provides no runtime `Ref` export.
+ */
+export type StorageListResult = import("./storage/index.js").ListResult;
+/**
+ * `Ref` / `SingleResult` / `ListResult` are JSDoc typedefs (types, not runtime exports), so they
+ * are re-exported as namespaced type aliases — `export { Ref as StorageRef }` fails at import
+ * because the module provides no runtime `Ref` export.
+ */
+export type StorageOpts = import("./storage/index.js").StorageOpts;
+/**
+ * `Ref` / `SingleResult` / `ListResult` are JSDoc typedefs (types, not runtime exports), so they
+ * are re-exported as namespaced type aliases — `export { Ref as StorageRef }` fails at import
+ * because the module provides no runtime `Ref` export.
+ */
+export type StoredRow = import("./storage/index.js").StoredRow;
+/**
+ * `Ref` / `SingleResult` / `ListResult` are JSDoc typedefs (types, not runtime exports), so they
+ * are re-exported as namespaced type aliases — `export { Ref as StorageRef }` fails at import
+ * because the module provides no runtime `Ref` export.
+ */
+export type GetByIdResult = import("./storage/index.js").GetByIdResult;
+/**
+ * `CreateInviteOpts` is a typedef (not a runtime export); re-export it as a type alias.
+ */
+export type MintInviteOpts = import("./pairing/invite.js").CreateInviteOpts;
+/**
+ * `CreateInviteOpts` is a typedef (not a runtime export); re-export it as a type alias.
+ */
+export type InviteFields = import("./pairing/invite.js").InviteFields;
+/**
+ * `CreateInviteOpts` is a typedef (not a runtime export); re-export it as a type alias.
+ */
+export type ParseInviteOpts = import("./pairing/invite.js").ParseInviteOpts;

package/types/lib/constants.d.ts

@@ -7,7 +7,30 @@ export const PASSIVE: "passive";
 export const ROCKS: "rocks";
 export const BEE: "bee";
 export const OWNER: "owner";
-export const WRITE: "write";
+export const ADMIN: "admin";
+export const MEMBER: "member";
+export const READER: "reader";
 export const READ: "read";
+export const WRITE: "write";
+export const DELETE: "delete";
+export const INVITE: "invite";
+export const REMOVE: "remove";
+export const ASSIGN: "assign";
+export namespace ROLE_PERMS {
+    let owner: string[];
+    let admin: string[];
+    let member: string[];
+    let reader: string[];
+}
+export namespace RANK {
+    let owner_1: number;
+    export { owner_1 as owner };
+    let admin_1: number;
+    export { admin_1 as admin };
+    let member_1: number;
+    export { member_1 as member };
+    let reader_1: number;
+    export { reader_1 as reader };
+}
 export const NAMESPACE: "cero";
 export const COUNTERS: "counters";

package/types/lib/schema.d.ts

@@ -14,6 +14,7 @@ export namespace t {
     let json: Prim;
     let fixed32: Prim;
     let fixed64: Prim;
+    let file: Prim;
     function required(marker: Prim): Prim;
     /**
      * Single-row table (one record, set/get by name).

package/types/lib/spec/index.d.ts

@@ -2,15 +2,12 @@ export function resolveStruct(name: any, v?: number): {
     preencode(state: any, m: any): void;
     encode(state: any, m: any): void;
     decode(state: any): {
-        hash: any;
         coreKey: any;
         blockOffset: any;
         blockLength: any;
         byteOffset: any;
         byteLength: any;
-        size: any;
-        createdAt: any;
-        meta: any;
+        type: any;
     } | {
         status: any;
         reason: any;
@@ -22,21 +19,20 @@ export function resolveStruct(name: any, v?: number): {
     } | {
         id: any;
         name: any;
+        role: any;
+        noAccept: boolean;
     };
 };
 export function getStruct(name: any, v?: number): {
     preencode(state: any, m: any): void;
     encode(state: any, m: any): void;
     decode(state: any): {
-        hash: any;
         coreKey: any;
         blockOffset: any;
         blockLength: any;
         byteOffset: any;
         byteLength: any;
-        size: any;
-        createdAt: any;
-        meta: any;
+        type: any;
     } | {
         status: any;
         reason: any;
@@ -48,6 +44,8 @@ export function getStruct(name: any, v?: number): {
     } | {
         id: any;
         name: any;
+        role: any;
+        noAccept: boolean;
     };
 };
 export function getEnum(name: any): void;
@@ -73,20 +71,19 @@ export function getEncoding(name: any): {
     decode(state: any): {
         id: any;
         name: any;
+        role: any;
+        noAccept: boolean;
     };
 } | {
     preencode(state: any, m: any): void;
     encode(state: any, m: any): void;
     decode(state: any): {
-        hash: any;
         coreKey: any;
         blockOffset: any;
         blockLength: any;
         byteOffset: any;
         byteLength: any;
-        size: any;
-        createdAt: any;
-        meta: any;
+        type: any;
     };
 };
 export function encode(name: any, value: any, v?: number): any;

package/types/lib/utils.d.ts

@@ -4,6 +4,14 @@
  * @returns {string}
  */
 export function genId(): string;
+/**
+ * Whether `role` is granted `perm` under the default policy.
+ *
+ * @param {string} role
+ * @param {string} perm
+ * @returns {boolean}
+ */
+export function can(role: string, perm: string): boolean;
 /**
  * Stream-of-snapshots primitive. Couples a `get` (returns the latest value)
  * with a `watch` (re-fires on change) and emits the newest snapshot every
@@ -12,13 +20,13 @@ export function genId(): string;
  * @template T
  * @param {object} args
  * @param {() => Promise<T> | T} args.get
- * @param {(fn: () => void) => (() => void) | void} args.watch  Returns an unsubscribe.
+ * @param {(fn: () => void) => (() => void) | void} args.watch
  * @returns {import('streamx').Readable<T>}
  */
 export function subscribe<T>({ get, watch }: {
     get: () => Promise<T> | T;
     watch: (fn: () => void) => (() => void) | void;
-}): any;
+}): import("streamx").Readable<T>;
 /**
  * z32-encode a 32-byte key into a canonical string id.
  *
@@ -37,3 +45,5 @@ export const toKey: (id: string) => Uint8Array;
  * @type {(id: string) => boolean}
  */
 export const isKeyId: (id: string) => boolean;
+export function grants(a: any, b: any): boolean;
+export function outranks(a: any, b: any): boolean;