@cero-base/cero 1.19.0 → 2.0.0

package/types/handle/index.d.ts

@@ -186,10 +186,6 @@ export type CeroHandle = Handle & Record<string, import('../lib/refs.js').Ref>;
  */
 /**
  * A cero handle — a single writable database session attached to a swarm.
- * The "root" handle is the user's facade; child handles (created via
- * `_create`/`_join`/`_load`) live under it and share the same identity,
- * network and corestore. Ref properties (`profile`, `members`, ...) are
- * attached dynamically per the schema; child handles also carry a `name`.
  */
 export declare class Handle extends ReadyResource {
     identity: any;
@@ -214,16 +210,45 @@ export declare class Handle extends ReadyResource {
     store: Database;
     pair: Pairing;
     _wantsPair: boolean;
-    _invitesSync: () => Promise<void>;
     _ac: AbortController;
+    _invitesSync: () => Promise<void>;
     /** @param {HandleOpts} [opts] */
     constructor(opts?: HandleOpts);
+    /**
+     * An `AbortSignal` that fires when this handle closes.
+     *
+     * @returns {AbortSignal}
+     */
+    get signal(): AbortSignal;
+    /** The top-most handle in the parent chain — itself for a root handle. */
+    get root(): this;
+    /**
+     * Lazily-built file server for this identity. Root-only — child handles
+     * reach it through `this.root.fileServer`.
+     *
+     * @returns {FileServer}
+     */
+    get fileServer(): FileServer;
+    /**
+     * Lazily-built blob store for THIS handle's writing device, at the current rotation epoch.
+     *
+     * @returns {Blobs}
+     */
+    get blobs(): Blobs;
+    /** Canonical id — identity id for the root handle, store key for children. */
+    get id(): any;
+    /** This device's id + name. `null` on child handles. */
+    get device(): {
+        id: any;
+        name: any;
+    };
+    get suspended(): boolean;
     _open(): Promise<void>;
     _close(): Promise<void>;
     /**
-     * Tie a destroyable resource (a `watch` stream, a timer, any `{ destroy }`)
-     * to this handle's lifecycle — it's destroyed automatically on close, so
-     * callers don't track cleanup. De-registers itself if destroyed earlier.
+     * Tie a destroyable resource (a `watch` stream, a timer, any `{ destroy }`) to this
+     * handle's lifecycle — it's destroyed automatically on close, so callers don't track
+     * cleanup.
      *
      * @template {{ destroy?: Function, once?: Function }} T
      * @param {T} resource
@@ -233,14 +258,6 @@ export declare class Handle extends ReadyResource {
         destroy?: Function;
         once?: Function;
     }>(resource: T): T;
-    /**
-     * An `AbortSignal` that fires when this handle closes. Pass it as
-     * `{ signal }` to `on`/`after`/`before`/`watch` to drop a subscription on
-     * close — or use your own `AbortController` for a finer scope.
-     *
-     * @returns {AbortSignal}
-     */
-    get signal(): AbortSignal;
     /**
      * `EventEmitter.on` plus an optional `{ signal }` that removes the listener
      * when the signal aborts — e.g. `me.on('handle', fn, { signal: me.signal })`.
@@ -253,24 +270,6 @@ export declare class Handle extends ReadyResource {
     on(event: string, fn: (...args: any[]) => void, opts?: {
         signal?: AbortSignal;
     }): this;
-    /** The top-most handle in the parent chain — itself for a root handle. */
-    get root(): this;
-    /**
-     * Lazily-built file server for this identity. Root-only — child handles
-     * reach it through `this.root.fileServer`.
-     *
-     * @returns {FileServer}
-     */
-    get fileServer(): FileServer;
-    /**
-     * @param {Uint8Array} coreKey
-     * @param {object} info
-     * @returns {{ key: Uint8Array, encryptionKey: Uint8Array } | null}
-     */
-    _resolveCore(coreKey: Uint8Array, info: object): {
-        key: Uint8Array;
-        encryptionKey: Uint8Array;
-    } | null;
     /**
      * Resolve a durable file id to an ephemeral download url via this identity's
      * file server.
@@ -279,38 +278,6 @@ export declare class Handle extends ReadyResource {
      * @returns {string}
      */
     getLink(id: string): string;
-    /**
-     * Lazily-built blob store for THIS handle's writing device, at the current
-     * rotation epoch. One core per writer per epoch that writes files: the base
-     * era uses the handle's encryptionKey, rotated epochs use a key derived
-     * from the epoch entropy — so a removed member cannot decrypt files added
-     * after the rotation. Instances carry `.stamp` so the file row records
-     * which era its core belongs to.
-     *
-     * @returns {Blobs}
-     */
-    get blobs(): Blobs;
-    _baseBlobs(): Blobs;
-    _makeBlobs(name: any, encryptionKey: any, stamp: any): Blobs;
-    /**
-     * Remember the blob-core key a file id points at so the file server can
-     * open the core. Lives on the Handle (not the shared operators) because the
-     * epoch-key derivation pulls native crypto — the RPC client must stay
-     * bundleable without it.
-     *
-     * @param {string} id
-     * @param {number} [stamp]
-     */
-    _registerBlobCore(id: string, stamp?: number): void;
-    _blobCoreKey(stamp: any): Uint8Array<ArrayBufferLike>;
-    /** Canonical id — identity id for the root handle, store key for children. */
-    get id(): any;
-    /** This device's id + name. `null` on child handles. */
-    get device(): {
-        id: any;
-        name: any;
-    };
-    get suspended(): boolean;
     /**
      * Initialise a fresh database: write the genesis claim, derive the writer.
      * Forwards to `Database.bootstrap`.
@@ -327,9 +294,9 @@ export declare class Handle extends ReadyResource {
      */
     claim(): Promise<void>;
     /**
-     * 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. Cheap, safe to call often.
+     * 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.
      *
      * @param {boolean} active
      * @returns {Promise<void>}
@@ -346,7 +313,6 @@ export declare class Handle extends ReadyResource {
         expiresIn?: number;
         data?: any;
     }): Promise<string>;
-    _syncInvites(): Promise<void>;
     /**
      * Revoke a previously-minted invite by its string form.
      *
@@ -363,7 +329,6 @@ export declare class Handle extends ReadyResource {
      * @returns {Promise<void>}
      */
     accept(candidate: any, { role, name }?: AcceptOpts): Promise<void>;
-    _checkGrant(role: any): Promise<void>;
     /**
      * Leave a child handle — removes it from the parent's `handles` collection
      * and closes the session. No-op on root handles.
@@ -372,9 +337,41 @@ export declare class Handle extends ReadyResource {
      */
     leave(): Promise<void>;
     /**
-     * Create a new child handle of `type`. Owner-flow — generates a fresh
-     * writer, adds it as a writer + member, and registers the child on the
-     * parent's `handles` collection.
+     * Pause networking + storage. Idempotent; no-op on child handles.
+     *
+     * @returns {Promise<void>}
+     */
+    suspend(): Promise<void>;
+    /**
+     * Resume a suspended root handle. Idempotent; no-op on child handles.
+     *
+     * @returns {Promise<void>}
+     */
+    resume(): Promise<void>;
+    /**
+     * @param {Uint8Array} coreKey
+     * @param {object} info
+     * @returns {{ key: Uint8Array, encryptionKey: Uint8Array } | null}
+     */
+    _resolveCore(coreKey: Uint8Array, info: object): {
+        key: Uint8Array;
+        encryptionKey: Uint8Array;
+    } | null;
+    _baseBlobs(): Blobs;
+    _makeBlobs(name: any, encryptionKey: any, stamp: any): Blobs;
+    /**
+     * Remember the blob-core key a file id points at so the file server can open the core.
+     *
+     * @param {string} id
+     * @param {number} [stamp]
+     */
+    _registerBlobCore(id: string, stamp?: number): void;
+    _blobCoreKey(stamp: any): Uint8Array<ArrayBufferLike>;
+    _syncInvites(): Promise<void>;
+    _checkGrant(role: any): Promise<void>;
+    /**
+     * Create a new child handle of `type`. Owner-flow — generates a fresh writer, adds it as a
+     * writer + member, and registers the child on the parent's `handles` collection.
      *
      * @param {string} type
      * @param {CreateChildOpts} [opts]
@@ -382,9 +379,7 @@ export declare class Handle extends ReadyResource {
      */
     _create(type: string, { name, routes, role, accept }?: CreateChildOpts): Promise<Handle>;
     /**
-     * Join a child handle by invite (joiner-flow). Waits for writer
-     * capability and registers the child on the parent's `handles`
-     * collection.
+     * Join a child handle by invite (joiner-flow).
      *
      * @param {string} invite
      * @param {string} type
@@ -401,9 +396,8 @@ export declare class Handle extends ReadyResource {
      */
     _pair(invite: string, type: string, { routes, timeout }?: JoinChildOpts, target?: Uint8Array | null): Promise<Handle>;
     /**
-     * Get an open child by id, or re-open it. Concurrent calls for the same id
-     * share one in-flight load, so the child is built — and `handle` emitted —
-     * exactly once.
+     * Get an open child by id, or re-open it. Concurrent calls for the same id share one
+     * in-flight load, so the child is built — and `handle` emitted — exactly once.
      *
      * @param {string} type
      * @param {string} id
@@ -419,29 +413,8 @@ export declare class Handle extends ReadyResource {
      * @returns {Promise<Handle>}
      */
     _reopen(type: string, id: string, opts: any): Promise<Handle>;
-    /**
-     * Pause networking + storage. Idempotent; no-op on child handles.
-     *
-     * @returns {Promise<void>}
-     */
-    suspend(): Promise<void>;
     _suspend(): Promise<void>;
-    /**
-     * Resume a suspended root handle. Idempotent; no-op on child handles.
-     *
-     * @returns {Promise<void>}
-     */
-    resume(): Promise<void>;
     _resume(): Promise<void>;
-    /**
-     * Pair into an existing handle via an invite, returning a brand-new
-     * `Handle` already configured with the resolved key + encryption key.
-     *
-     * @param {string} invite
-     * @param {StaticJoinOpts} [opts]
-     * @returns {Promise<Handle>}
-     */
-    static join(invite: string, { parent, network, identity, store, spec, namespace, routes, timeout }?: StaticJoinOpts): Promise<Handle>;
     /**
      * @param {Handle} child
      * @param {{ role?: string }} [opts]
@@ -466,4 +439,13 @@ export declare class Handle extends ReadyResource {
         publicKey: Uint8Array;
         secretKey: Uint8Array;
     } | null>;
+    /**
+     * Pair into an existing handle via an invite, returning a brand-new
+     * `Handle` already configured with the resolved key + encryption key.
+     *
+     * @param {string} invite
+     * @param {StaticJoinOpts} [opts]
+     * @returns {Promise<Handle>}
+     */
+    static join(invite: string, { parent, network, identity, store, spec, namespace, routes, timeout }?: StaticJoinOpts): Promise<Handle>;
 }

package/types/index.d.ts

@@ -4,7 +4,7 @@ import { Local } from './local/index.js';
 import { put, set, get, del, count, watch, changes, call, open, rotate, before, after, bind, define } from './lib/operators.js';
 import { peek } from './lib/peek.js';
 import { t, schema } from './lib/spec.js';
-import { internal } from './lib/internal.js';
+import { registry } from './extensions/index.js';
 export { Handle, Ref, Local };
 export { put, set, get, del, count, watch, changes, call, open, rotate, before, after, bind, define } from './lib/operators.js';
 export { peek } from './lib/peek.js';
@@ -118,9 +118,7 @@ export type CeroOpts = {
  * @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'`.
  */
 /**
- * Open (or create) a cero handle at `dir`. Sets up storage, network and
- * identity, then returns a ready root `Handle` with all schema refs
- * attached as properties.
+ * Open (or create) a cero handle at `dir`.
  *
  * @param {string} dir       Data directory.
  * @param {any} spec         Built spec — output of `cero/build`.
@@ -147,13 +145,11 @@ export declare namespace cero {
     export { schema };
     export { bind };
     export { define };
-    export { internal as _internal };
+    export { registry as _registry };
     export var use: (...exts: any[]) => void;
 }
 /**
- * Restore a cero instance from a mnemonic phrase. Closes the running
- * instance, wipes the on-disk `main/` tree and re-opens with the phrase, which
- * recovers so the writer slot is re-claimed.
+ * Restore a cero instance from a mnemonic phrase.
  *
  * @param {Handle} me   Existing root handle to restore.
  * @param {string} phrase   BIP-39 mnemonic phrase.

package/types/lib/bluetooth.d.ts

@@ -1,18 +1,7 @@
 import ReadyResource from 'ready-resource';
 /**
- * `me.bluetooth` — the app-facing surface for nearby (Bluetooth) sync, a thin
- * facade over ble-swarm. Bluetooth only changes how peers meet and carry
- * bytes; capability-gated replication still decides what syncs. Discovery is
- * one topic-derived service UUID at a time (tag `cero-ble`) — the data service
- * sits on a fixed per-tag UUID, so switching topics only retunes the radio.
- *
- * ```js
- * const me = await cero(dir, spec, { channel, bluetooth: true })
- * me.bluetooth.state          // 'unsupported' | 'unauthorized' | 'off' | 'waiting' | 'starting' | 'on'
- * await me.bluetooth.start()
- * me.bluetooth.peers          // Map of live BLE links
- * me.bluetooth.on('update', () => {})
- * ```
+ * `me.bluetooth` — the app-facing surface for nearby (Bluetooth) sync, a thin facade over
+ * ble-swarm.
  *
  * @extends ReadyResource
  */
@@ -49,6 +38,7 @@ export declare class Bluetooth extends ReadyResource {
     /** @returns {Map<string, any>} Live BLE links, keyed by peer public key. */
     get peers(): Map<string, any>;
     _open(): Promise<void>;
+    _close(): Promise<void>;
     /**
      * Begin advertising + scanning. Idempotent; no-op when unsupported.
      *
@@ -56,34 +46,19 @@ export declare class Bluetooth extends ReadyResource {
      */
     start(): Promise<void>;
     /**
-     * Stop advertising/scanning and drop links; open invite rendezvous end with
-     * the radio. Idempotent. Local data and the rest of the network (DHT) are
-     * untouched.
+     * Stop advertising/scanning and drop links; open invite rendezvous end with the radio.
      *
      * @returns {Promise<void>}
      */
     stop(): Promise<void>;
     /**
-     * Offline join rendezvous: retune the radio to the invite-derived topic so
-     * holder and joiner find each other with zero DHT. One topic at a time —
-     * announcing a new invite replaces the previous rendezvous. Returns a stop
-     * function — closing the QR must stop the rendezvous so a photographed
-     * invite doesn't stay an ambient discovery beacon (admission itself is
-     * always gated by blind-pairing verifying the invite). The retune back to
-     * the mesh topic waits for live links to drain: the link a join just
-     * established survives and carries the joiner's initial replication.
-     * Auto-stops at the invite's expiry, on `stop()`, and on close.
-     *
-     * Only active while nearby sync is on: before `start()` (and after `stop()`)
-     * this is a no-op — the user controls the radio, and a join must not touch
-     * Bluetooth (OS permissions, GATT server) they never enabled.
+     * Offline join rendezvous: retune the radio to the invite-derived topic so holder and
+     * joiner find each other with zero DHT.
      *
      * @param {string} invite  Z32 invite string.
      * @returns {() => void}
      */
     announce(invite: string): () => void;
-    _stopAnnounce(): void;
-    _clearAnnounce(): void;
     /**
      * Host-lifecycle pause (app backgrounded): radio down, user intent kept.
      *
@@ -96,5 +71,6 @@ export declare class Bluetooth extends ReadyResource {
      * @returns {Promise<void>}
      */
     resume(): Promise<void>;
-    _close(): Promise<void>;
+    _stopAnnounce(): void;
+    _clearAnnounce(): void;
 }

package/types/lib/constants.d.ts

@@ -3,14 +3,3 @@ export declare const COUNTERS = "counters";
 export declare const EPOCHS = "epochs";
 export declare const TIMEOUT = 30000;
 export declare const FLUSH = 500;
-export declare const DB_TYPE: {
-    string: string;
-    uint: string;
-    int: string;
-    bool: string;
-    bytes: string;
-    json: string;
-    fixed32: string;
-    fixed64: string;
-    file: string;
-};

package/types/lib/operators.d.ts

@@ -35,9 +35,7 @@ export declare function resolveFile(handle: object, id: string, name?: string):
     name?: string;
 };
 /**
- * Insert (or overwrite by id) a row on `ref`. The `files` builtin is special:
- * `put(handle.files, { data, type, name? })` uploads the bytes to this handle's
- * blob store, records `{ id, name }`, and resolves the file.
+ * Insert (or overwrite by id) a row on `ref`.
  *
  * @param {Ref} ref
  * @param {Record<string, any>} row
@@ -45,9 +43,7 @@ export declare function resolveFile(handle: object, id: string, name?: string):
  */
 export declare function put(ref: Ref, row: Record<string, any>): Promise<SingleResult>;
 /**
- * Upsert a row on `ref` — merges with the existing row and preserves
- * `createdAt`. Pass `{ upsert: false }` to update-only: a missing row is left
- * untouched instead of created (atomic — never resurrects a deleted row).
+ * Upsert a row on `ref` — merges with the existing row and preserves `createdAt`.
  *
  * @param {Ref} ref
  * @param {Record<string, any>} row
@@ -84,9 +80,7 @@ export declare function count(ref: Ref, q?: Record<string, any>): Promise<{
  */
 export declare function call(ref: Ref, d?: Record<string, any>): Promise<any>;
 /**
- * Intercept writes to `ref` before they commit — `fn(ctx)` runs in-path
- * (awaited). Return `false` to cancel the write, or mutate `ctx.row`.
- * Returns an unsubscribe fn; pass `{ signal }` to unsubscribe on abort.
+ * Intercept writes to `ref` before they commit — `fn(ctx)` runs in-path (awaited).
  *
  * @param {Ref} ref
  * @param {(ctx: { op: string, name: string, row: any }) => any} fn
@@ -101,9 +95,8 @@ export declare function before(ref: Ref, fn: (ctx: {
     signal?: AbortSignal;
 }): () => void;
 /**
- * Subscribe to writes on `ref` — fires after each committed write,
- * non-blocking (observe only). Returns an unsubscribe fn; pass `{ signal }`
- * to unsubscribe on abort.
+ * Subscribe to writes on `ref` — fires after each committed write, non-blocking (observe
+ * only).
  *
  * @param {Ref} ref
  * @param {(ctx: { op: string, name: string, row: any }) => void} fn
@@ -118,9 +111,7 @@ export declare function after(ref: Ref, fn: (ctx: {
     signal?: AbortSignal;
 }): () => void;
 /**
- * Read from `ref`. For data refs, dispatches to the underlying store. For
- * `handle`-kind refs, lists existing child handles of that type from the
- * parent's `handles` collection.
+ * Read from `ref`. For data refs, dispatches to the underlying store.
  *
  * @param {Ref} ref
  * @param {string | Record<string, any>} [q]
@@ -128,10 +119,8 @@ export declare function after(ref: Ref, fn: (ctx: {
  */
 export declare function get(ref: Ref, q?: string | Record<string, any>): Promise<SingleResult | ListResult | GetByIdResult>;
 /**
- * Live snapshot stream on `ref` — re-emits the latest `get()` result on
- * every underlying mutation. Tied to `ref.handle`'s lifecycle: closing the
- * handle destroys it. Pass `{ signal }` to bind it to a finer scope, or
- * destroy the stream directly to stop watching sooner.
+ * Live snapshot stream on `ref` — re-emits the latest `get()` result on every underlying
+ * mutation.
  *
  * @param {Ref} ref
  * @param {Record<string, any>} [q]
@@ -142,20 +131,13 @@ export declare function watch(ref: Ref, q?: Record<string, any>, opts?: {
     signal?: AbortSignal;
 }): import('streamx').Readable;
 /**
- * Delta subscription: batches of `{ prev, next }` row pairs instead of
- * full snapshots — lossless under backpressure, self-contained (the first
- * batch, and any batch after a view swap, replays current state as inserts
- * with `reset: true`). File-typed fields resolve on both sides.
+ * Delta subscription: batches of `{ prev, next }` row pairs instead of full snapshots —
+ * lossless under backpressure, self-contained (the first batch, and any batch after a view
+ * swap, replays current.
  */
 export declare function changes(ref: any, q: any, opts: any): any;
 /**
- * Open (or create / join / load) a child handle through a `handle`-kind
- * ref. Dispatches on the normalize of `arg`:
- *
- *   - `string`                → join via an invite string
- *   - `{ invite: string }`    → join via invite (object form)
- *   - `{ id: string }`        → load an existing handle by id
- *   - `object | undefined`    → create a new handle with the given opts
+ * Open (or create / join / load) a child handle through a `handle`-kind ref.
  *
  * @param {Ref} ref
  * @param {string | { invite?: string, id?: string, name?: string, routes?: any, role?: string, accept?: boolean } | undefined} [arg]
@@ -170,13 +152,9 @@ export declare function open(ref: Ref, arg?: string | {
     accept?: boolean;
 } | undefined): Promise<CeroHandle>;
 /**
- * Rotate a handle's encryption epoch. A fresh secret is sealed to every
- * current member and announced through the log — members removed before the
- * rotation cannot decrypt anything written after it. Requires the remove
- * permission (admin or owner). Compose with removal:
- *
- *   await cero.del(room.members, memberId)
- *   await cero.rotate(room)
+ * Rotate a handle's encryption epoch. A fresh secret is sealed to every current member and
+ * announced through the log — members removed before the rotation cannot decrypt anything
+ * written after it.
  *
  * @param {any} handle
  * @returns {Promise<{ epoch: number }>}
@@ -186,12 +164,7 @@ export declare function rotate(handle: any): Promise<{
 }>;
 /**
  * Put custom operators on `handle`, currying it as their first argument so
- * `handle.ns.fn(args)` calls `fn(handle, args)`. `arg` is either:
- *   - a `{ ns: module }` map  → bind exactly those, or
- *   - `null`                  → the registered root operators, or
- *   - a child-handle type     → the registered operators for that type.
- * The scope forms are how cero binds handles automatically; pass a map yourself
- * for manual binding.
+ * `handle.ns.fn(args)` calls `fn(handle, args)`.
  *
  * @param {any} handle
  * @param {Record<string, any> | string | null} arg
@@ -199,9 +172,8 @@ export declare function rotate(handle: any): Promise<{
  */
 export declare function bind(handle: any, arg: Record<string, any> | string | null): any;
 /**
- * Register custom operators by scope. A bare key binds on the root handle; a key
- * that names a child-handle type binds on every handle of that type. Call once
- * at startup, before `cero()` / `connect()`, in both processes.
+ * Register custom operators by scope. A bare key binds on the root handle; a key that
+ * names a child-handle type binds on every handle of that type.
  *
  * @param {Record<string, any>} map
  */

package/types/lib/peek.d.ts

@@ -1,7 +1,6 @@
 /**
- * Quickly check whether the on-disk directory at `dir` already holds an
- * initialised cero identity (i.e. a stored master seed). Opens the local store
- * read-only and closes everything before returning.
+ * Quickly check whether the on-disk directory at `dir` already holds an initialised cero
+ * identity (i.e. a stored master seed).
  *
  * @param {string} dir   Cero data directory.
  * @param {any} spec     Built spec — same value passed to `cero(dir, spec)`.

package/types/lib/refs.d.ts

@@ -11,9 +11,7 @@ export type RefInfo = {
  *   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.
+ * Typed pointer to a single ref (table or handle slot) on a `Handle` or `Local`.
  */
 export declare class Ref {
     handle: any;

package/types/lib/spec.d.ts

@@ -1,6 +1,5 @@
 /**
- * Re-exports of the schema DSL (`t`) and `schema()` wrapper from
- * `@cero-base/core/schema`, so cero apps can describe their tables without
- * pulling in the core package directly.
+ * Re-exports of the schema DSL (`t`) and `schema()` wrapper from `@cero-base/core/schema`,
+ * so cero apps can describe their tables without pulling in the core package directly.
  */
 export { t, schema } from '@cero-base/core/schema';

package/types/local/index.d.ts

@@ -21,9 +21,8 @@ export type LocalOpts = {
  * @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 declare class Local extends ReadyResource {
     dir: string;

package/types/rpc/client.d.ts

@@ -7,7 +7,7 @@ export type RefInfo = {
     kind?: 'single' | 'collection' | 'action' | 'handle';
     schema?: string;
     type?: string;
-    builtin?: boolean;
+    internal?: boolean;
 };
 export type Spec = import('@cero-base/core/rpc').Spec & {
     meta: {
@@ -50,10 +50,7 @@ export type HandleStub = {
  */
 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
- * `local: true`, so they hit the server's per-device store and never
- * replicate. Built-in local refs (identity master/keypair) are not exposed.
+ * Per-device `local`-namespace surface on a Client.
  */
 declare class LocalRefs {
     parent: Client;
@@ -68,9 +65,9 @@ declare class LocalRefs {
     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 declare class Client extends RPCClient {
     id: any;
@@ -115,9 +112,9 @@ export declare class Client extends RPCClient {
     _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.
+ * 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;
@@ -149,13 +146,8 @@ declare class Handle {
  */
 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.
+ * 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.

package/types/rpc/index.d.ts

@@ -1,7 +1,7 @@
 /**
- * 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.
+ * 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';