@cero-base/cero 1.18.2 → 2.0.0

package/types/local/index.d.ts

@@ -1,3 +1,19 @@
+import ReadyResource from 'ready-resource';
+import { Storage } from '@cero-base/core/storage';
+export type LocalOpts = {
+    /**
+     * Pre-existing HypercoreStorage to reuse.
+     */
+    root?: any;
+    /**
+     * Pre-existing Corestore to reuse.
+     */
+    store?: any;
+    /**
+     * 32-byte key encrypting the local store at rest.
+     */
+    storageKey?: Uint8Array;
+};
 /**
  * @typedef {object} LocalOpts
  * @property {any} [root]   Pre-existing HypercoreStorage to reuse.
@@ -5,34 +21,19 @@
  * @property {Uint8Array} [storageKey]  32-byte key encrypting the local store at rest.
  */
 /**
- * Per-device, single-writer storage for cero — holds the master seed,
- * device keypair and any per-handle keypairs. Wraps a hyperbee-backed
- * `Storage` and exposes each local ref as a property of the instance.
+ * Per-device, single-writer storage for cero — holds the master seed, device keypair and
+ * any per-handle keypairs.
  */
-export class Local extends ReadyResource {
+export declare class Local extends ReadyResource {
+    dir: string;
+    spec: any;
+    store: Storage;
     /**
      * @param {string | null} dir   Directory for the local store, or `null` when reusing an external `store`.
      * @param {any} spec            Built cero spec — must include `spec.local.database` and `spec.meta.local`.
      * @param {LocalOpts} [opts]
      */
     constructor(dir: string | null, spec: any, { root, store, storageKey }?: LocalOpts);
-    dir: string;
-    spec: any;
-    store: Storage;
+    _open(): Promise<void>;
+    _close(): Promise<void>;
 }
-export type LocalOpts = {
-    /**
-     * Pre-existing HypercoreStorage to reuse.
-     */
-    root?: any;
-    /**
-     * Pre-existing Corestore to reuse.
-     */
-    store?: any;
-    /**
-     * 32-byte key encrypting the local store at rest.
-     */
-    storageKey?: Uint8Array;
-};
-import ReadyResource from 'ready-resource';
-import { Storage } from '@cero-base/core/storage';

package/types/rpc/client.d.ts

@@ -1,3 +1,45 @@
+import { RPCClient } from '@cero-base/core/rpc';
+import { put, set, get, del, count, watch, changes, call, open, rotate, bind, define } from '../lib/operators.js';
+import { t, schema } from '../lib/spec.js';
+export { put, set, get, del, count, watch, changes, call, open, rotate, bind, define, t, schema };
+export type BaseRPCClient = import('@cero-base/core/rpc').RPCClient;
+export type RefInfo = {
+    kind?: 'single' | 'collection' | 'action' | 'handle';
+    schema?: string;
+    type?: string;
+    internal?: boolean;
+};
+export type Spec = import('@cero-base/core/rpc').Spec & {
+    meta: {
+        ns?: string;
+        refs: Record<string, RefInfo>;
+        local?: {
+            refs: Record<string, RefInfo>;
+        };
+        handles?: Record<string, Spec>;
+    };
+    handles: Record<string, Spec>;
+};
+export type SingleResult = {
+    data: any;
+};
+export type ListResult = {
+    data: any[];
+    total: number;
+    size: number;
+};
+export type GetByIdResult = {
+    data: any | null;
+};
+export type ClientIdentity = {
+    id: string;
+    toPhrase: () => string | null;
+};
+export type HandleStub = {
+    id: string;
+    type: string;
+    name: string | null;
+};
 /**
  * Re-initialize a `Client` from a recovery phrase. Closes the existing
  * local state and reseeds identity from the phrase.
@@ -6,57 +48,28 @@
  * @param {string} phrase
  * @returns {Promise<Client>}
  */
-export function restore(me: Client, phrase: string): Promise<Client>;
-/**
- * Construct a `Client`, wait for `init` to complete, and return it.
- *
- * @param {any} ipc
- * @param {object} spec
- * @returns {Promise<Client>}
- */
-export function connect(ipc: any, spec: object): Promise<Client>;
+export declare function restore(me: Client, phrase: string): Promise<Client>;
 /**
- * Symmetric client entry. Mirrors the main `cero`, but `cero(ipc, spec)` connects
- * to a server (via `connect`) instead of opening a local store. The same operator
- * surface is attached, so `import { cero } from '@cero-base/cero/client'` works
- * just like `import { cero } from '@cero-base/cero'`.
- *
- * Note: `before`/`after`/`peek` are intentionally not exposed here — they hook the
- * local write path / probe a local store, which a client proxy has no notion of.
- *
- * @param {any} ipc    Framed IPC duplex stream.
- * @param {any} spec   Built cero spec.
- * @returns {Promise<Client>}
+ * Per-device `local`-namespace surface on a Client.
  */
-export function cero(ipc: any, spec: any): Promise<Client>;
-export namespace cero {
-    export { connect };
-    export { restore };
-    export { t };
-    export { put };
-    export { set };
-    export { get };
-    export { del };
-    export { count };
-    export { watch };
-    export { call };
-    export { open };
-    export { rotate };
-    export { bind };
-    export { define };
-    export { schema };
+declare class LocalRefs {
+    parent: Client;
+    spec: import("@cero-base/core").Spec;
+    store: this;
+    _local: boolean;
+    /** @param {Client} client */
+    constructor(client: Client);
+    /** Underlying RPC channel borrowed from the parent. */
+    get rpc(): any;
+    /** Root handle id (local ops are resolved against the root's local store). */
+    get id(): any;
 }
 /**
- * IPC-side RPC client for cero. Wraps an `hrpc` channel and exposes the
- * same handle/ref/row API as a local cero instance, transparently
- * routing every operation across the wire.
+ * IPC-side RPC client for cero. Wraps an `hrpc` channel and exposes the same
+ * handle/ref/row API as a local cero instance, transparently routing every operation
+ * across the wire.
  */
-export class Client extends RPCClient {
-    /**
-     * @param {any} ipc   Framed IPC stream (must be writable).
-     * @param {Spec} spec  Compiled cero spec (schema + rpc + handles).
-     */
-    constructor(ipc: any, spec: Spec);
+export declare class Client extends RPCClient {
     id: any;
     deviceId: any;
     store: this;
@@ -67,6 +80,12 @@ export class Client extends RPCClient {
         id: any;
         toPhrase: () => Promise<any>;
     };
+    /**
+     * @param {any} ipc   Framed IPC stream (must be writable).
+     * @param {Spec} spec  Compiled cero spec (schema + rpc + handles).
+     */
+    constructor(ipc: any, spec: Spec);
+    _open(): Promise<void>;
     /**
      * Create a new child handle of the given type.
      *
@@ -92,85 +111,18 @@ export class Client extends RPCClient {
      */
     _join(invite: string, type: string): Promise<Handle>;
 }
-export type BaseRPCClient = import("@cero-base/core/rpc").RPCClient;
-export type RefInfo = {
-    kind?: "single" | "collection" | "action" | "handle";
-    schema?: string;
-    type?: string;
-    builtin?: boolean;
-};
 /**
- * Built cero spec (schema + rpc + per-handle child specs).
+ * Client-side proxy for a remote handle. Exposes the same row-ops surface as `Client` but
+ * scoped to a single child handle id, and routes every call through the parent's RPC
+ * channel.
  */
-export type Spec = import("@cero-base/core/rpc").Spec & {
-    meta: {
-        ns?: string;
-        refs: Record<string, RefInfo>;
-        local?: {
-            refs: Record<string, RefInfo>;
-        };
-        handles?: Record<string, Spec>;
-    };
-    handles: Record<string, Spec>;
-};
-export type SingleResult = {
-    data: any;
-};
-export type ListResult = {
-    data: any[];
-    total: number;
-    size: number;
-};
-export type GetByIdResult = {
-    data: any | null;
-};
-export type ClientIdentity = {
-    id: string;
-    toPhrase: () => string | null;
-};
-export type HandleStub = {
+declare class Handle {
+    parent: Client;
     id: string;
     type: string;
-    name: string | null;
-};
-import { t } from '../lib/spec.js';
-import { put } from '../lib/operators.js';
-import { set } from '../lib/operators.js';
-import { get } from '../lib/operators.js';
-import { del } from '../lib/operators.js';
-import { count } from '../lib/operators.js';
-import { watch } from '../lib/operators.js';
-import { call } from '../lib/operators.js';
-import { open } from '../lib/operators.js';
-import { rotate } from '../lib/operators.js';
-import { bind } from '../lib/operators.js';
-import { define } from '../lib/operators.js';
-import { schema } from '../lib/spec.js';
-import { RPCClient } from '@cero-base/core/rpc';
-/**
- * Per-device `local`-namespace surface on a Client. Exposes each app-defined
- * local ref (e.g. `client.local.settings`) and routes ops over RPC with
- * `local: true`, so they hit the server's per-device store and never
- * replicate. Built-in local refs (identity master/keypair) are not exposed.
- */
-declare class LocalRefs {
-    /** @param {Client} client */
-    constructor(client: Client);
-    parent: Client;
-    spec: import("@cero-base/core").Spec;
+    name: string;
+    spec: Spec;
     store: this;
-    _local: boolean;
-    /** Underlying RPC channel borrowed from the parent. */
-    get rpc(): any;
-    /** Root handle id (local ops are resolved against the root's local store). */
-    get id(): any;
-}
-/**
- * Client-side proxy for a remote handle. Exposes the same row-ops surface
- * as `Client` but scoped to a single child handle id, and routes every
- * call through the parent's RPC channel.
- */
-declare class Handle {
     /**
      * @param {Client} parent
      * @param {string} id
@@ -178,12 +130,6 @@ declare class Handle {
      * @param {string|null} name
      */
     constructor(parent: Client, id: string, type: string, name: string | null);
-    parent: Client;
-    id: string;
-    type: string;
-    name: string;
-    spec: Spec;
-    store: this;
     /** Underlying RPC channel borrowed from the parent. */
     get rpc(): any;
     /** Tear down the remote handle without leaving the room. */
@@ -191,4 +137,38 @@ declare class Handle {
     /** Tear down the remote handle and drop membership. */
     leave(): any;
 }
-export { put, set, get, del, count, watch, call, open, rotate, bind, define, t, schema };
+/**
+ * Construct a `Client`, wait for `init` to complete, and return it.
+ *
+ * @param {any} ipc
+ * @param {object} spec
+ * @returns {Promise<Client>}
+ */
+export declare function connect(ipc: any, spec: object): Promise<Client>;
+/**
+ * Symmetric client entry. Mirrors the main `cero`, but `cero(ipc, spec)` connects to a
+ * server (via `connect`) instead of opening a local store.
+ *
+ * @param {any} ipc    Framed IPC duplex stream.
+ * @param {any} spec   Built cero spec.
+ * @returns {Promise<Client>}
+ */
+export declare function cero(ipc: any, spec: any): Promise<Client>;
+export declare namespace cero {
+    export { connect };
+    export { restore };
+    export { t };
+    export { put };
+    export { set };
+    export { get };
+    export { del };
+    export { count };
+    export { watch };
+    export { changes };
+    export { call };
+    export { open };
+    export { rotate };
+    export { bind };
+    export { define };
+    export { schema };
+}

package/types/rpc/index.d.ts

@@ -1,2 +1,7 @@
-export { Server, serve } from "./server.js";
-export { Client, connect } from "./client.js";
+/**
+ * RPC barrel — re-exports the `Server`/`Client` classes and their `serve()`/`connect()`
+ * helpers so consumers can spin up either side of the cero IPC bridge from a single
+ * import.
+ */
+export { Server, serve } from './server.js';
+export { Client, connect } from './client.js';

package/types/rpc/server.d.ts

@@ -1,17 +1,48 @@
-/**
- * Construct a `Server`, wait for it to be ready, and return it.
- *
- * @param {any} ipc
- * @param {ServerOpts} opts
- * @returns {Promise<Server>}
- */
-export function serve(ipc: any, opts: ServerOpts): Promise<Server>;
+import { RPCServer } from '@cero-base/core/rpc';
+export type BaseRPCServer = import('@cero-base/core/rpc').RPCServer;
+export type ServerOpts = {
+    /**
+     * Directory passed to `cero()` for the local store.
+     */
+    storage: string;
+    /**
+     * Optional display name forwarded to `cero()`.
+     */
+    name?: string;
+    /**
+     * Custom DHT bootstrap.
+     */
+    bootstrap?: Array<{
+        host: string;
+        port: number;
+    }>;
+    isMobile?: boolean;
+    onerror?: (err: Error) => void;
+};
+export type Identity = {
+    /**
+     * Long-lived cero identity id.
+     */
+    id: string;
+    /**
+     * Per-device id (empty when no `local` spec).
+     */
+    deviceId: string;
+};
+export type RefAndCodec = {
+    ref: any;
+    codec: any;
+};
+export type GetResult = {
+    data: any;
+    total?: number;
+    size?: number;
+};
 /**
  * @typedef {import('@cero-base/core/rpc').RPCServer} BaseRPCServer
  *
  * @typedef {object} ServerOpts
  * @property {string} storage   Directory passed to `cero()` for the local store.
- * @property {object} spec      Compiled cero spec (schema + rpc + handles).
  * @property {string} [name]    Optional display name forwarded to `cero()`.
  * @property {Array<{ host: string, port: number }>} [bootstrap]  Custom DHT bootstrap.
  * @property {boolean} [isMobile]
@@ -26,26 +57,14 @@ export function serve(ipc: any, opts: ServerOpts): Promise<Server>;
  * @typedef {{ data: any, total?: number, size?: number }} GetResult  Single-ref get omits `total`/`size`; list/handle refs include them.
  */
 /**
- * IPC-side RPC server for cero. Bridges an `hrpc` channel to a live
- * `Handle` tree: lazy-initializes the root via `cero()` on the first
- * `init` call, then exposes data ops, pairing, and handle lifecycle
- * over the wire using the spec-bound codec.
+ * IPC-side RPC server for cero. Bridges an `hrpc` channel to a live `Handle` tree:
+ * lazy-initializes the root via `cero()` on the first `init` call, then exposes data ops,
+ * pairing, and handle lifecycle.
  */
-export class Server extends RPCServer {
-    /**
-     * @param {any} ipc                Framed IPC stream (must be writable).
-     * @param {Partial<ServerOpts>} [opts]
-     */
-    constructor(ipc: any, { storage, spec, ...opts }?: Partial<ServerOpts>);
+export declare class Server extends RPCServer {
     storage: string;
     opts: {
-        /**
-         * Optional display name forwarded to `cero()`.
-         */
         name?: string;
-        /**
-         * Custom DHT bootstrap.
-         */
         bootstrap?: Array<{
             host: string;
             port: number;
@@ -53,12 +72,16 @@ export class Server extends RPCServer {
         isMobile?: boolean;
         onerror?: (err: Error) => void;
     };
-    me: any;
+    me: import("../handle/index.js").CeroHandle;
     handles: Map<any, any>;
     /** @type {Map<string, Set<object>>} handle id → its open watch streams */
     _watchStreams: Map<string, Set<object>>;
-    /** End every watch stream bound to a handle (e.g. when it closes or leaves). */
-    _endWatches(handle: any): void;
+    /**
+     * @param {any} ipc                Framed IPC stream (must be writable).
+     * @param {object} spec
+     * @param {Partial<ServerOpts>} [opts]
+     */
+    constructor(ipc: any, spec: object, { storage, ...opts }?: Partial<ServerOpts>);
     /**
      * Root cero id (null until `init` has run).
      *
@@ -71,6 +94,9 @@ export class Server extends RPCServer {
      * @returns {any}
      */
     get identity(): any;
+    _close(): Promise<void>;
+    /** End every watch stream bound to a handle (e.g. when it closes or leaves). */
+    _endWatches(handle: any): void;
     /** Wire the `init` handler that lazily constructs the root cero handle. */
     _wireInit(): void;
     /** Wire the `restore` handler that rebuilds the local store from a phrase. */
@@ -90,9 +116,7 @@ export class Server extends RPCServer {
      */
     _resolve(id: string): any;
     /**
-     * Resolve a `{ handle, ref }` pair to its `Ref` and codec. When `local` is
-     * set, the ref is resolved against the root's per-device `local` store and
-     * paired with the codec bound from the local schema.
+     * Resolve a `{ handle, ref }` pair to its `Ref` and codec.
      *
      * @param {string} id
      * @param {string} name
@@ -109,50 +133,12 @@ export class Server extends RPCServer {
     /** Wire the on-demand `seed` handler — surfaces the recovery phrase only when asked. */
     _wireSeed(): void;
 }
-export type BaseRPCServer = import("@cero-base/core/rpc").RPCServer;
-export type ServerOpts = {
-    /**
-     * Directory passed to `cero()` for the local store.
-     */
-    storage: string;
-    /**
-     * Compiled cero spec (schema + rpc + handles).
-     */
-    spec: object;
-    /**
-     * Optional display name forwarded to `cero()`.
-     */
-    name?: string;
-    /**
-     * Custom DHT bootstrap.
-     */
-    bootstrap?: Array<{
-        host: string;
-        port: number;
-    }>;
-    isMobile?: boolean;
-    onerror?: (err: Error) => void;
-};
-export type Identity = {
-    /**
-     * Long-lived cero identity id.
-     */
-    id: string;
-    /**
-     * Per-device id (empty when no `local` spec).
-     */
-    deviceId: string;
-};
-export type RefAndCodec = {
-    ref: any;
-    codec: any;
-};
 /**
- * Single-ref get omits `total`/`size`; list/handle refs include them.
+ * Construct a `Server`, wait for it to be ready, and return it.
+ *
+ * @param {any} ipc
+ * @param {object} spec
+ * @param {ServerOpts} opts
+ * @returns {Promise<Server>}
  */
-export type GetResult = {
-    data: any;
-    total?: number;
-    size?: number;
-};
-import { RPCServer } from '@cero-base/core/rpc';
+export declare function serve(ipc: any, spec: object, opts: ServerOpts): Promise<Server>;