@cero-base/cero 1.18.1 → 1.19.0

package/types/rpc/client.d.ts

@@ -1,108 +1,15 @@
-/**
- * Re-initialize a `Client` from a recovery phrase. Closes the existing
- * local state and reseeds identity from the phrase.
- *
- * @param {Client} me
- * @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>;
-/**
- * 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>}
- */
-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 };
-}
-/**
- * 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);
-    id: any;
-    deviceId: any;
-    store: this;
-    local: LocalRefs;
-    _fileBase: any;
-    _fileToken: any;
-    identity: {
-        id: any;
-        toPhrase: () => Promise<any>;
-    };
-    /**
-     * Create a new child handle of the given type.
-     *
-     * @param {string} type
-     * @param {Record<string, any>} [opts]
-     * @returns {Promise<Handle>}
-     */
-    _create(type: string, opts?: Record<string, any>): Promise<Handle>;
-    /**
-     * Load an existing child handle by id.
-     *
-     * @param {string} type
-     * @param {string} id
-     * @returns {Promise<Handle>}
-     */
-    _load(type: string, id: string): Promise<Handle>;
-    /**
-     * Join a child handle via invite.
-     *
-     * @param {string} invite
-     * @param {string} type
-     * @returns {Promise<Handle>}
-     */
-    _join(invite: string, type: string): Promise<Handle>;
-}
-export type BaseRPCClient = import("@cero-base/core/rpc").RPCClient;
+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";
+    kind?: 'single' | 'collection' | 'action' | 'handle';
     schema?: string;
     type?: string;
     builtin?: boolean;
 };
-/**
- * Built cero spec (schema + rpc + per-handle child specs).
- */
-export type Spec = import("@cero-base/core/rpc").Spec & {
+export type Spec = import('@cero-base/core/rpc').Spec & {
     meta: {
         ns?: string;
         refs: Record<string, RefInfo>;
@@ -133,20 +40,15 @@ export type HandleStub = {
     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';
+/**
+ * Re-initialize a `Client` from a recovery phrase. Closes the existing
+ * local state and reseeds identity from the phrase.
+ *
+ * @param {Client} me
+ * @param {string} phrase
+ * @returns {Promise<Client>}
+ */
+export declare function restore(me: Client, phrase: string): Promise<Client>;
 /**
  * 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
@@ -154,23 +56,76 @@ import { RPCClient } from '@cero-base/core/rpc';
  * 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;
     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.
+ */
+export declare class Client extends RPCClient {
+    id: any;
+    deviceId: any;
+    store: this;
+    local: LocalRefs;
+    _fileBase: any;
+    _fileToken: any;
+    identity: {
+        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.
+     *
+     * @param {string} type
+     * @param {Record<string, any>} [opts]
+     * @returns {Promise<Handle>}
+     */
+    _create(type: string, opts?: Record<string, any>): Promise<Handle>;
+    /**
+     * Load an existing child handle by id.
+     *
+     * @param {string} type
+     * @param {string} id
+     * @returns {Promise<Handle>}
+     */
+    _load(type: string, id: string): Promise<Handle>;
+    /**
+     * Join a child handle via invite.
+     *
+     * @param {string} invite
+     * @param {string} type
+     * @returns {Promise<Handle>}
+     */
+    _join(invite: string, type: string): Promise<Handle>;
+}
 /**
  * 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 {
+    parent: Client;
+    id: string;
+    type: string;
+    name: string;
+    spec: Spec;
+    store: this;
     /**
      * @param {Client} parent
      * @param {string} id
@@ -178,12 +133,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 +140,43 @@ 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. 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>}
+ */
+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]
@@ -31,21 +62,10 @@ export function serve(ipc: any, opts: ServerOpts): Promise<Server>;
  * `init` call, then exposes data ops, pairing, and handle lifecycle
  * over the wire using the spec-bound codec.
  */
-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,10 +73,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>>;
+    /**
+     * @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>);
     /** End every watch stream bound to a handle (e.g. when it closes or leaves). */
     _endWatches(handle: any): void;
     /**
@@ -71,6 +97,7 @@ export class Server extends RPCServer {
      * @returns {any}
      */
     get identity(): any;
+    _close(): Promise<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. */
@@ -109,50 +136,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>;

package/src/lib/utils.js

@@ -1,67 +0,0 @@
-import { CeroError } from '@cero-base/core/errors'
-
-/**
- * @typedef {'collection' | 'single' | 'action' | 'handle'} RefKind
- * @typedef {{ kind?: string, schema?: string }} RefInfo
- *   Shape of the entries in `meta.refs` — describes a single ref name.
- *   `kind` is one of {@link RefKind}, kept as `string` since it originates
- *   from a generated spec.
- */
-
-/**
- * Typed pointer to a single ref (table or handle slot) on a `Handle` or
- * `Local`. Operators (`put`/`get`/`open`/...) take a `Ref` as their first
- * argument and dispatch through the owning handle's store.
- */
-export class Ref {
-  /**
-   * @param {any} handle  Owner — a `Handle` (or `Local`) the ref lives on.
-   * @param {string} name  Ref name as declared in the schema.
-   * @param {string} kind  Ref kind: `'collection'`, `'single'`, `'action'`, or `'handle'`.
-   * @param {string | null} [schema]  Fully-qualified schema id, if any.
-   */
-  constructor(handle, name, kind, schema = null) {
-    this.handle = handle
-    this.name = name
-    this.kind = kind
-    this.schema = schema
-  }
-}
-
-/**
- * Attach a `Ref` property to `target` for every entry in `refs`. Used by
- * `Handle` and `Local` during `_open()` so callers can write
- * `handle.someRef` instead of looking refs up by name.
- *
- * @param {any} target
- * @param {Record<string, RefInfo>} refs
- */
-export function attachRefs(target, refs) {
-  for (const [name, info] of Object.entries(refs || {})) {
-    // Fail loud rather than silently overwrite a method/property (close, on,
-    // store, …) when a schema declares a ref named like a reserved member.
-    if (name in target) {
-      throw CeroError.INVALID(
-        `schema ref '${name}' collides with a reserved ${target.constructor?.name || 'handle'} member — rename it`
-      )
-    }
-    target[name] = new Ref(target, name, info.kind, info.schema)
-  }
-}
-
-/**
- * Run `cb` when `signal` aborts — or immediately if it already has. No-op
- * without a signal. The listener removes itself on fire. Returns a disposer that
- * detaches the listener early, so a manual unsubscribe doesn't leave it lingering
- * on a long-lived signal.
- *
- * @param {AbortSignal | undefined} signal
- * @param {() => void} cb
- * @returns {(() => void) | undefined}
- */
-export function onAbort(signal, cb) {
-  if (!signal) return
-  if (signal.aborted) return void cb()
-  signal.addEventListener('abort', cb, { once: true })
-  return () => signal.removeEventListener('abort', cb)
-}

package/types/lib/utils.d.ts

@@ -1,55 +0,0 @@
-/**
- * Attach a `Ref` property to `target` for every entry in `refs`. Used by
- * `Handle` and `Local` during `_open()` so callers can write
- * `handle.someRef` instead of looking refs up by name.
- *
- * @param {any} target
- * @param {Record<string, RefInfo>} refs
- */
-export function attachRefs(target: any, refs: Record<string, RefInfo>): void;
-/**
- * Run `cb` when `signal` aborts — or immediately if it already has. No-op
- * without a signal. The listener removes itself on fire. Returns a disposer that
- * detaches the listener early, so a manual unsubscribe doesn't leave it lingering
- * on a long-lived signal.
- *
- * @param {AbortSignal | undefined} signal
- * @param {() => void} cb
- * @returns {(() => void) | undefined}
- */
-export function onAbort(signal: AbortSignal | undefined, cb: () => void): (() => void) | undefined;
-/**
- * @typedef {'collection' | 'single' | 'action' | 'handle'} RefKind
- * @typedef {{ kind?: string, schema?: string }} RefInfo
- *   Shape of the entries in `meta.refs` — describes a single ref name.
- *   `kind` is one of {@link RefKind}, kept as `string` since it originates
- *   from a generated spec.
- */
-/**
- * Typed pointer to a single ref (table or handle slot) on a `Handle` or
- * `Local`. Operators (`put`/`get`/`open`/...) take a `Ref` as their first
- * argument and dispatch through the owning handle's store.
- */
-export class Ref {
-    /**
-     * @param {any} handle  Owner — a `Handle` (or `Local`) the ref lives on.
-     * @param {string} name  Ref name as declared in the schema.
-     * @param {string} kind  Ref kind: `'collection'`, `'single'`, `'action'`, or `'handle'`.
-     * @param {string | null} [schema]  Fully-qualified schema id, if any.
-     */
-    constructor(handle: any, name: string, kind: string, schema?: string | null);
-    handle: any;
-    name: string;
-    kind: string;
-    schema: string;
-}
-export type RefKind = "collection" | "single" | "action" | "handle";
-/**
- * Shape of the entries in `meta.refs` — describes a single ref name.
- * `kind` is one of {@link RefKind}, kept as `string` since it originates
- * from a generated spec.
- */
-export type RefInfo = {
-    kind?: string;
-    schema?: string;
-};