@cero-base/cero 1.18.2 → 2.0.0

package/types/index.d.ts

@@ -1,73 +1,15 @@
-/**
- * @typedef {import('./handle/index.js').CeroHandle} CeroHandle
- */
-/**
- * @typedef {object} CeroOpts
- * @property {Identity} [identity]                     Pre-resolved identity. If absent, derived from `seed`/`phrase` or generated.
- * @property {Uint8Array} [seed]                       16- or 32-byte seed entropy.
- * @property {string} [phrase]                         BIP-39 mnemonic — alternative to `seed`.
- * @property {12 | 24} [words]                         Mnemonic length when generating a fresh identity.
- * @property {string | null} [name]                    Friendly device name persisted on the identity claim.
- * @property {boolean} [isMobile]                      Marks this device as mobile.
- * @property {Array<{ host: string, port: number }>} [bootstrap]  Custom DHT bootstrap nodes.
- * @property {number[]} [backoffs]                     Swarm reconnect backoff tiers in ms (testing/tuning).
- * @property {string} [channel]                        Optional network-isolation label; only same-channel peers connect.
- * @property {Array<string | Uint8Array>} [mirrors]    Blind-peer public keys. Rooms and files are mirrored through them so peers sync even when never online at the same time. Mirrors hold only encrypted blocks — they never read your data.
- * @property {Uint8Array} [key]                        Pre-existing database key (skip bootstrap).
- * @property {Uint8Array} [encryptionKey]              Pre-existing encryption key.
- * @property {Record<string, Function>} [routes]       Custom RPC routes for the database dispatcher.
- * @property {(err: any) => void} [onerror]            Background-task error handler.
- * @property {boolean} [recovery]                      Recovery flow — wipe local state and re-claim a writer slot.
- * @property {number} [recoveryTimeout]                Max wait for peer data + writer capability during recovery.
- * @property {Uint8Array} [storageKey]                 32-byte key encrypting local key material (master seed, device keypairs) at rest. Source it from the OS keychain — cero never stores it.
- * @property {boolean} [extensions]                    `false` disables the bundled extensions (profileSync, handleSync) for this instance. Build with `{ extensions: false }` too so the spec matches.
- * @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.
- *
- * @param {string} dir       Data directory.
- * @param {any} spec         Built spec — output of `cero/build`.
- * @param {CeroOpts} [opts]
- * @returns {Promise<CeroHandle>}
- */
-export function cero(dir: string, spec: any, opts?: CeroOpts): Promise<CeroHandle>;
-export namespace cero {
-    export { t };
-    export { put };
-    export { set };
-    export { get };
-    export { del };
-    export { count };
-    export { watch };
-    export { changes };
-    export { call };
-    export { open };
-    export { rotate };
-    export { before };
-    export { after };
-    export { peek };
-    export { restore };
-    export { schema };
-    export { bind };
-    export { define };
-    export { internal as _internal };
-    export function 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 `recovery: true`
- * so the writer slot is re-claimed.
- *
- * @param {Handle} me   Existing root handle to restore.
- * @param {string} phrase   BIP-39 mnemonic phrase.
- * @returns {Promise<Handle>}  Freshly restored root handle.
- */
-export function restore(me: Handle, phrase: string): Promise<Handle>;
-export { peek } from "./lib/peek.js";
-export type CeroHandle = import("./handle/index.js").CeroHandle;
+import { Identity } from '@cero-base/core/identity';
+import { Handle, Ref } from './handle/index.js';
+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 { 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';
+export { t, schema } from './lib/spec.js';
+export type CeroHandle = import('./handle/index.js').CeroHandle;
 export type CeroOpts = {
     /**
      * Pre-resolved identity. If absent, derived from `seed`/`phrase` or generated.
@@ -113,7 +55,7 @@ export type CeroOpts = {
      */
     mirrors?: Array<string | Uint8Array>;
     /**
-     * Pre-existing database key (skip bootstrap).
+     * Existing database key to recover into, skipping the pointer lookup.
      */
     key?: Uint8Array;
     /**
@@ -129,11 +71,7 @@ export type CeroOpts = {
      */
     onerror?: (err: any) => void;
     /**
-     * Recovery flow — wipe local state and re-claim a writer slot.
-     */
-    recovery?: boolean;
-    /**
-     * Max wait for peer data + writer capability during recovery.
+     * Max wait to find another device and be admitted, in ms. Defaults to 30000.
      */
     recoveryTimeout?: number;
     /**
@@ -152,31 +90,69 @@ export type CeroOpts = {
         backend?: any;
         maxOutbound?: number;
         maxInbound?: number;
-        pipe?: "l2cap" | "gatt";
+        pipe?: 'l2cap' | 'gatt';
     };
 };
-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 { changes } from './lib/operators.js';
-import { call } from './lib/operators.js';
-import { open } from './lib/operators.js';
-import { rotate } from './lib/operators.js';
-import { before } from './lib/operators.js';
-import { after } from './lib/operators.js';
-import { peek } from './lib/peek.js';
-import { schema } from './lib/spec.js';
-import { bind } from './lib/operators.js';
-import { define } from './lib/operators.js';
-import { internal } from './lib/internal.js';
-import { Handle } from './handle/index.js';
-import { Ref } from './handle/index.js';
-import { Local } from './local/index.js';
-import { Identity } from '@cero-base/core/identity';
-export { Handle, Ref, Local };
-export { put, set, get, del, count, watch, changes, call, open, rotate, before, after, bind, define } from "./lib/operators.js";
-export { t, schema } from "./lib/spec.js";
+/**
+ * @typedef {import('./handle/index.js').CeroHandle} CeroHandle
+ */
+/**
+ * @typedef {object} CeroOpts
+ * @property {Identity} [identity]                     Pre-resolved identity. If absent, derived from `seed`/`phrase` or generated.
+ * @property {Uint8Array} [seed]                       16- or 32-byte seed entropy.
+ * @property {string} [phrase]                         BIP-39 mnemonic — alternative to `seed`.
+ * @property {12 | 24} [words]                         Mnemonic length when generating a fresh identity.
+ * @property {string | null} [name]                    Friendly device name persisted on the identity claim.
+ * @property {boolean} [isMobile]                      Marks this device as mobile.
+ * @property {Array<{ host: string, port: number }>} [bootstrap]  Custom DHT bootstrap nodes.
+ * @property {number[]} [backoffs]                     Swarm reconnect backoff tiers in ms (testing/tuning).
+ * @property {string} [channel]                        Optional network-isolation label; only same-channel peers connect.
+ * @property {Array<string | Uint8Array>} [mirrors]    Blind-peer public keys. Rooms and files are mirrored through them so peers sync even when never online at the same time. Mirrors hold only encrypted blocks — they never read your data.
+ * @property {Uint8Array} [key]                        Existing database key to recover into, skipping the pointer lookup.
+ * @property {Uint8Array} [encryptionKey]              Pre-existing encryption key.
+ * @property {Record<string, Function>} [routes]       Custom RPC routes for the database dispatcher.
+ * @property {(err: any) => void} [onerror]            Background-task error handler.
+ * @property {number} [recoveryTimeout]                Max wait to find another device and be admitted, in ms. Defaults to 30000.
+ * @property {Uint8Array} [storageKey]                 32-byte key encrypting local key material (master seed, device keypairs) at rest. Source it from the OS keychain — cero never stores it.
+ * @property {boolean} [extensions]                    `false` disables the bundled extensions (profileSync, handleSync) for this instance. Build with `{ extensions: false }` too so the spec matches.
+ * @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`.
+ *
+ * @param {string} dir       Data directory.
+ * @param {any} spec         Built spec — output of `cero/build`.
+ * @param {CeroOpts} [opts]
+ * @returns {Promise<CeroHandle>}
+ */
+export declare function cero(dir: string, spec: any, opts?: CeroOpts): Promise<CeroHandle>;
+export declare namespace cero {
+    export { t };
+    export { put };
+    export { set };
+    export { get };
+    export { del };
+    export { count };
+    export { watch };
+    export { changes };
+    export { call };
+    export { open };
+    export { rotate };
+    export { before };
+    export { after };
+    export { peek };
+    export { restore };
+    export { schema };
+    export { bind };
+    export { define };
+    export { registry as _registry };
+    export var use: (...exts: any[]) => void;
+}
+/**
+ * Restore a cero instance from a mnemonic phrase.
+ *
+ * @param {Handle} me   Existing root handle to restore.
+ * @param {string} phrase   BIP-39 mnemonic phrase.
+ * @returns {Promise<Handle>}  Freshly restored root handle.
+ */
+export declare function restore(me: Handle, phrase: string): Promise<Handle>;

package/types/lib/bluetooth.d.ts

@@ -1,21 +1,22 @@
+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
  */
-export class Bluetooth extends ReadyResource {
+export declare class Bluetooth extends ReadyResource {
+    _handle: object;
+    _autoStart: boolean;
+    /** @type {{ hex: string, count: number, timer: any } | null} active invite rendezvous (single topic — one at a time) */
+    _announce: {
+        hex: string;
+        count: number;
+        timer: any;
+    } | null;
+    _restorePending: boolean;
+    _topic: any;
+    swarm: any;
     /**
      * @param {object} handle           Root cero Handle (network + identity + channel).
      * @param {object} [opts]
@@ -30,23 +31,14 @@ export class Bluetooth extends ReadyResource {
         autoStart?: boolean;
         maxOutbound?: number;
         maxInbound?: number;
-        pipe?: "l2cap" | "gatt";
+        pipe?: 'l2cap' | 'gatt';
     });
-    _handle: any;
-    _autoStart: boolean;
-    /** @type {{ hex: string, count: number, timer: any } | null} active invite rendezvous (single topic — one at a time) */
-    _announce: {
-        hex: string;
-        count: number;
-        timer: any;
-    } | null;
-    _restorePending: boolean;
-    _topic: any;
-    swarm: any;
     /** @returns {'unsupported'|'unauthorized'|'off'|'waiting'|'starting'|'on'} */
-    get state(): "unsupported" | "unauthorized" | "off" | "waiting" | "starting" | "on";
+    get state(): 'unsupported' | 'unauthorized' | 'off' | 'waiting' | 'starting' | 'on';
     /** @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.
      *
@@ -54,34 +46,19 @@ export 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.
      *
@@ -94,5 +71,6 @@ export class Bluetooth extends ReadyResource {
      * @returns {Promise<void>}
      */
     resume(): Promise<void>;
+    _stopAnnounce(): void;
+    _clearAnnounce(): void;
 }
-import ReadyResource from 'ready-resource';

package/types/lib/constants.d.ts

@@ -1,16 +1,5 @@
-export const NS: "cero";
-export const COUNTERS: "counters";
-export const EPOCHS: "epochs";
-export const TIMEOUT: 30000;
-export const FLUSH: 500;
-export namespace DB_TYPE {
-    let string: string;
-    let uint: string;
-    let int: string;
-    let bool: string;
-    let bytes: string;
-    let json: string;
-    let fixed32: string;
-    let fixed64: string;
-    let file: string;
-}
+export declare const NS = "cero";
+export declare const COUNTERS = "counters";
+export declare const EPOCHS = "epochs";
+export declare const TIMEOUT = 30000;
+export declare const FLUSH = 500;

package/types/lib/operators.d.ts

@@ -1,5 +1,18 @@
+export type Ref = import('./refs.js').Ref;
+export type CeroHandle = import('../handle/index.js').CeroHandle;
+export type SingleResult = {
+    data: any;
+};
+export type ListResult = {
+    data: any[];
+    total: number;
+    size: number;
+};
+export type GetByIdResult = {
+    data: any | null;
+};
 /**
- * @typedef {import('./utils.js').Ref} Ref
+ * @typedef {import('./refs.js').Ref} Ref
  * @typedef {import('../handle/index.js').CeroHandle} CeroHandle
  * @typedef {{ data: any }} SingleResult
  * @typedef {{ data: any[], total: number, size: number }} ListResult
@@ -14,7 +27,7 @@
  * @param {string} [name]
  * @returns {{ id: string, type: string, size: number, url: string, name?: string }}
  */
-export function resolveFile(handle: object, id: string, name?: string): {
+export declare function resolveFile(handle: object, id: string, name?: string): {
     id: string;
     type: string;
     size: number;
@@ -22,26 +35,22 @@ export 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
  * @returns {Promise<SingleResult>}
  */
-export function put(ref: Ref, row: Record<string, any>): Promise<SingleResult>;
+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
  * @param {{ upsert?: boolean }} [opts]
  * @returns {Promise<SingleResult>}
  */
-export function set(ref: Ref, row: Record<string, any>, opts?: {
+export declare function set(ref: Ref, row: Record<string, any>, opts?: {
     upsert?: boolean;
 }): Promise<SingleResult>;
 /**
@@ -51,7 +60,7 @@ export function set(ref: Ref, row: Record<string, any>, opts?: {
  * @param {string} [id]
  * @returns {Promise<void>}
  */
-export function del(ref: Ref, id?: string): Promise<void>;
+export declare function del(ref: Ref, id?: string): Promise<void>;
 /**
  * Count rows on `ref`, optionally filtered.
  *
@@ -59,7 +68,7 @@ export function del(ref: Ref, id?: string): Promise<void>;
  * @param {Record<string, any>} [q]
  * @returns {Promise<{ data: number }>}
  */
-export function count(ref: Ref, q?: Record<string, any>): Promise<{
+export declare function count(ref: Ref, q?: Record<string, any>): Promise<{
     data: number;
 }>;
 /**
@@ -69,18 +78,16 @@ export function count(ref: Ref, q?: Record<string, any>): Promise<{
  * @param {Record<string, any>} [d]
  * @returns {Promise<any>}
  */
-export function call(ref: Ref, d?: Record<string, any>): Promise<any>;
+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
  * @param {{ signal?: AbortSignal }} [opts]
  * @returns {() => void}
  */
-export function before(ref: Ref, fn: (ctx: {
+export declare function before(ref: Ref, fn: (ctx: {
     op: string;
     name: string;
     row: any;
@@ -88,16 +95,15 @@ export 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
  * @param {{ signal?: AbortSignal }} [opts]
  * @returns {() => void}
  */
-export function after(ref: Ref, fn: (ctx: {
+export declare function after(ref: Ref, fn: (ctx: {
     op: string;
     name: string;
     row: any;
@@ -105,50 +111,39 @@ export 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]
  * @returns {Promise<SingleResult | ListResult | GetByIdResult>}
  */
-export function get(ref: Ref, q?: string | Record<string, any>): Promise<SingleResult | ListResult | GetByIdResult>;
+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]
  * @param {{ signal?: AbortSignal }} [opts]
  * @returns {import('streamx').Readable}
  */
-export function watch(ref: Ref, q?: Record<string, any>, opts?: {
+export declare function watch(ref: Ref, q?: Record<string, any>, opts?: {
     signal?: AbortSignal;
-}): import("streamx").Readable;
+}): 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 function changes(ref: any, q: any, opts: any): any;
+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]
  * @returns {Promise<CeroHandle>}  The resolved child handle.
  */
-export function open(ref: Ref, arg?: string | {
+export declare function open(ref: Ref, arg?: string | {
     invite?: string;
     id?: string;
     name?: string;
@@ -157,54 +152,31 @@ export 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 }>}
  */
-export function rotate(handle: any): Promise<{
+export declare function rotate(handle: any): Promise<{
     epoch: number;
 }>;
 /**
  * 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
  * @returns {any} handle
  */
-export function bind(handle: any, arg: Record<string, any> | string | null): any;
+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
  */
-export function define(map: Record<string, any>): void;
+export declare function define(map: Record<string, any>): void;
 /** Test seam: clear all registered operators. */
-export function _clearDefined(): void;
-export type Ref = import("./utils.js").Ref;
-export type CeroHandle = import("../handle/index.js").CeroHandle;
-export type SingleResult = {
-    data: any;
-};
-export type ListResult = {
-    data: any[];
-    total: number;
-    size: number;
-};
-export type GetByIdResult = {
-    data: any | null;
-};
+export declare function _clearDefined(): void;

package/types/lib/peek.d.ts

@@ -1,10 +1,9 @@
 /**
- * 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)`.
  * @returns {Promise<boolean>}  `true` if a master seed exists on disk.
  */
-export function peek(dir: string, spec: any): Promise<boolean>;
+export declare function peek(dir: string, spec: any): Promise<boolean>;

package/types/lib/refs.d.ts

@@ -0,0 +1,36 @@
+export type RefKind = 'collection' | 'single' | 'action' | 'handle';
+export type RefInfo = {
+    kind?: string;
+    schema?: string;
+};
+/**
+ * @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`.
+ */
+export declare class Ref {
+    handle: any;
+    name: string;
+    kind: string;
+    schema: string;
+    /**
+     * @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);
+    /**
+     * Attach a `Ref` property to `target` for every entry in `refs`, so callers
+     * write `handle.someRef` instead of looking refs up by name.
+     *
+     * @param {any} target
+     * @param {Record<string, RefInfo>} refs
+     */
+    static attach(target: any, refs: Record<string, RefInfo>): void;
+}

package/types/lib/spec.d.ts

@@ -1 +1,5 @@
-export { t, schema } from "@cero-base/core/schema";
+/**
+ * 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';