@cero-base/cero 1.18.2 → 1.19.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 { internal } from './lib/internal.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,73 @@ 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`. 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 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 { internal as _internal };
+    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.
+ *
+ * @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,3 +1,4 @@
+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
@@ -15,7 +16,18 @@
  *
  * @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 +42,13 @@ 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>;
     /**
      * Begin advertising + scanning. Idempotent; no-op when unsupported.
      *
@@ -94,5 +96,5 @@ export class Bluetooth extends ReadyResource {
      * @returns {Promise<void>}
      */
     resume(): Promise<void>;
+    _close(): Promise<void>;
 }
-import ReadyResource from 'ready-resource';

package/types/lib/constants.d.ts

@@ -1,16 +1,16 @@
-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;
+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/internal.d.ts

@@ -1,11 +1,11 @@
-export namespace internal {
-    let extensions: ({
+export declare const internal: {
+    extensions: ({
         name: string;
         bundled: boolean;
         schema: {
             profile: import("@cero-base/core").TypeDef;
             members: {
-                kind: "extend";
+                kind: 'extend';
                 fields: Record<string, import("@cero-base/core").Prim>;
             };
         };
@@ -15,10 +15,10 @@ export namespace internal {
         bundled: boolean;
         schema: {
             handles: {
-                kind: "extend";
+                kind: 'extend';
                 fields: Record<string, import("@cero-base/core").Prim>;
             };
         };
         setup(me: any): void;
     })[];
-}
+};

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;
@@ -30,7 +43,7 @@ export function resolveFile(handle: object, id: string, name?: string): {
  * @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
@@ -41,7 +54,7 @@ export function put(ref: Ref, row: Record<string, any>): Promise<SingleResult>;
  * @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 +64,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 +72,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,7 +82,7 @@ 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`.
@@ -80,7 +93,7 @@ export function call(ref: Ref, d?: Record<string, any>): Promise<any>;
  * @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;
@@ -97,7 +110,7 @@ export function before(ref: Ref, fn: (ctx: {
  * @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;
@@ -113,7 +126,7 @@ export function after(ref: Ref, fn: (ctx: {
  * @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
@@ -125,16 +138,16 @@ export function get(ref: Ref, q?: string | Record<string, any>): Promise<SingleR
  * @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.
  */
-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`:
@@ -148,7 +161,7 @@ export function changes(ref: any, q: any, opts: any): any;
  * @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;
@@ -168,7 +181,7 @@ export function open(ref: Ref, arg?: string | {
  * @param {any} handle
  * @returns {Promise<{ epoch: number }>}
  */
-export function rotate(handle: any): Promise<{
+export declare function rotate(handle: any): Promise<{
     epoch: number;
 }>;
 /**
@@ -184,7 +197,7 @@ export function rotate(handle: any): Promise<{
  * @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
@@ -192,19 +205,6 @@ export function bind(handle: any, arg: Record<string, any> | string | null): any
  *
  * @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

@@ -7,4 +7,4 @@
  * @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,38 @@
+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`. Operators (`put`/`get`/`open`/...) take a `Ref` as their first
+ * argument and dispatch through the owning handle's store.
+ */
+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,6 @@
-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';

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.
@@ -9,30 +25,16 @@
  * device keypair and any per-handle keypairs. Wraps a hyperbee-backed
  * `Storage` and exposes each local ref as a property of the instance.
  */
-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';