@cero-base/cero 1.19.0 → 2.1.0

package/types/lib/operators.d.ts

@@ -1,4 +1,5 @@
 export type Ref = import('./refs.js').Ref;
+export type HookContext = import('@cero-base/core/database').HookContext;
 export type CeroHandle = import('../handle/index.js').CeroHandle;
 export type SingleResult = {
     data: any;
@@ -13,6 +14,7 @@ export type GetByIdResult = {
 };
 /**
  * @typedef {import('./refs.js').Ref} Ref
+ * @typedef {import('@cero-base/core/database').HookContext} HookContext
  * @typedef {import('../handle/index.js').CeroHandle} CeroHandle
  * @typedef {{ data: any }} SingleResult
  * @typedef {{ data: any[], total: number, size: number }} ListResult
@@ -35,9 +37,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 +45,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
@@ -65,16 +63,6 @@ export declare function set(ref: Ref, row: Record<string, any>, opts?: {
  * @returns {Promise<void>}
  */
 export declare function del(ref: Ref, id?: string): Promise<void>;
-/**
- * Count rows on `ref`, optionally filtered.
- *
- * @param {Ref} ref
- * @param {Record<string, any>} [q]
- * @returns {Promise<{ data: number }>}
- */
-export declare function count(ref: Ref, q?: Record<string, any>): Promise<{
-    data: number;
-}>;
 /**
  * Invoke an `action`-kind ref (a custom mutation declared in the schema).
  *
@@ -84,43 +72,39 @@ 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.
+ * Rule that runs before a write to `ref` lands — at apply, on every peer, inside the op's
+ * transaction. Return `false` to refuse it: the writer's own call rejects with `REFUSED`.
+ * `ctx` is `{ op, name, row, existing, id, memberId, role, get, put, set, del }`; mutate
+ * `ctx.row` to rewrite what is stored. `op` is the op as it applies, so an upsert on a
+ * collection is a `put`. The four operators on `ctx` read and write the room as it stands at
+ * this op, inside the transaction. Must be deterministic — read only `ctx`, never a clock or
+ * local state — and registered before any op applies, in the process that owns the data. The
+ * imported operators throw inside a hook; use the ones on `ctx`. Not available over RPC.
  *
  * @param {Ref} ref
- * @param {(ctx: { op: string, name: string, row: any }) => any} fn
+ * @param {(ctx: HookContext) => unknown} fn
  * @param {{ signal?: AbortSignal }} [opts]
  * @returns {() => void}
  */
-export declare function before(ref: Ref, fn: (ctx: {
-    op: string;
-    name: string;
-    row: any;
-}) => any, opts?: {
+export declare function before(ref: Ref, fn: (ctx: HookContext) => unknown, opts?: {
     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.
+ * Rule that runs after a write to `ref` lands — at apply, on every peer, inside the op's
+ * transaction. Write derived rows through `ctx.put` / `ctx.set` / `ctx.del`; a throw refuses
+ * the whole op. Same `ctx` and the same determinism and registration rules as `before`. Use
+ * `changes(ref)` instead to observe writes locally.
  *
  * @param {Ref} ref
- * @param {(ctx: { op: string, name: string, row: any }) => void} fn
+ * @param {(ctx: HookContext) => unknown} fn
  * @param {{ signal?: AbortSignal }} [opts]
  * @returns {() => void}
  */
-export declare function after(ref: Ref, fn: (ctx: {
-    op: string;
-    name: string;
-    row: any;
-}) => void, opts?: {
+export declare function after(ref: Ref, fn: (ctx: HookContext) => unknown, opts?: {
     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 +112,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 +124,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 +145,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 }>}
@@ -184,27 +155,3 @@ export declare function open(ref: Ref, arg?: string | {
 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.
- *
- * @param {any} handle
- * @param {Record<string, any> | string | null} arg
- * @returns {any} handle
- */
-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.
- *
- * @param {Record<string, any>} map
- */
-export declare function define(map: Record<string, any>): void;
-/** Test seam: clear all registered operators. */
-export declare function _clearDefined(): void;

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,28 +11,28 @@ 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;
     name: string;
     kind: string;
     schema: string;
+    type: any;
     /**
      * @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);
+    constructor(handle: any, name: string, kind: string, schema?: string | null, type?: any);
     /**
      * 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
+     * @param {Record<string, any>} [handles]  The handle types, so `target.room.notes` names every room's notes.
      */
-    static attach(target: any, refs: Record<string, RefInfo>): void;
+    static attach(target: any, refs: Record<string, RefInfo>, handles?: Record<string, any>): void;
 }

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

@@ -1,13 +1,13 @@
 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 { put, set, get, del, watch, changes, call, open, rotate } 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 { put, set, get, del, watch, changes, call, open, rotate, t, schema };
 export type BaseRPCClient = import('@cero-base/core/rpc').RPCClient;
 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,11 +65,12 @@ 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 {
+    operators: Record<string, any>;
     id: any;
     deviceId: any;
     store: this;
@@ -86,9 +84,16 @@ export declare class Client extends RPCClient {
     /**
      * @param {any} ipc   Framed IPC stream (must be writable).
      * @param {Spec} spec  Compiled cero spec (schema + rpc + handles).
+     * @param {{ operators?: Record<string, any> }} [opts]  The operators to bind, instead of the ones the spec carries.
      */
-    constructor(ipc: any, spec: Spec);
+    constructor(ipc: any, spec: Spec, opts?: {
+        operators?: Record<string, any>;
+    });
     _open(): Promise<void>;
+    /** Pause networking and storage on the server. Idempotent. */
+    suspend(): Promise<void>;
+    /** Resume a suspended server. Idempotent. */
+    resume(): Promise<void>;
     /**
      * Create a new child handle of the given type.
      *
@@ -115,9 +120,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;
@@ -145,23 +150,24 @@ declare class Handle {
  *
  * @param {any} ipc
  * @param {object} spec
+ * @param {{ operators?: Record<string, any> }} [opts]
  * @returns {Promise<Client>}
  */
-export declare function connect(ipc: any, spec: object): Promise<Client>;
+export declare function connect(ipc: any, spec: object, opts?: {
+    operators?: Record<string, any>;
+}): 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.
+ * @param {{ operators?: Record<string, any> }} [opts]
  * @returns {Promise<Client>}
  */
-export declare function cero(ipc: any, spec: any): Promise<Client>;
+export declare function cero(ipc: any, spec: any, opts?: {
+    operators?: Record<string, any>;
+}): Promise<Client>;
 export declare namespace cero {
     export { connect };
     export { restore };
@@ -170,13 +176,10 @@ export declare namespace cero {
     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,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';

package/types/rpc/server.d.ts

@@ -57,10 +57,9 @@ export type GetResult = {
  * @typedef {{ data: any, total?: number, size?: number }} GetResult  Single-ref get omits `total`/`size`; list/handle refs include them.
  */
 /**
- * IPC-side RPC server for cero. Bridges an `hrpc` channel to a live
- * `Handle` tree: lazy-initializes the root via `cero()` on the first
- * `init` call, then exposes data ops, pairing, and handle lifecycle
- * over the wire using the spec-bound codec.
+ * IPC-side RPC server for cero. Bridges an `hrpc` channel to a live `Handle` tree:
+ * lazy-initializes the root via `cero()` on the first `init` call, then exposes data ops,
+ * pairing, and handle lifecycle.
  */
 export declare class Server extends RPCServer {
     storage: string;
@@ -83,8 +82,6 @@ export declare class Server extends RPCServer {
      * @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;
     /**
      * Root cero id (null until `init` has run).
      *
@@ -98,11 +95,13 @@ export declare class Server extends RPCServer {
      */
     get identity(): any;
     _close(): Promise<void>;
+    /** End every watch stream bound to a handle (e.g. when it closes or leaves). */
+    _endWatches(handle: any): void;
     /** Wire the `init` handler that lazily constructs the root cero handle. */
     _wireInit(): void;
     /** Wire the `restore` handler that rebuilds the local store from a phrase. */
     _wireRestore(): void;
-    /** Register the row-level RPC handlers (put/set/get/del/count/watch/call). */
+    /** Register the row-level RPC handlers (put/set/get/del/watch/call). */
     _wireData(): void;
     /** Register invite/revoke/join RPC handlers. */
     _wirePairing(): void;
@@ -117,9 +116,7 @@ export declare class Server extends RPCServer {
      */
     _resolve(id: string): any;
     /**
-     * Resolve a `{ handle, ref }` pair to its `Ref` and codec. When `local` is
-     * set, the ref is resolved against the root's per-device `local` store and
-     * paired with the codec bound from the local schema.
+     * Resolve a `{ handle, ref }` pair to its `Ref` and codec.
      *
      * @param {string} id
      * @param {string} name

package/src/build/builtins.js

@@ -1,174 +0,0 @@
-// Build wiring for the builtin schemas (schemas.js): turns the grouped field
-// maps into the type / collection / dispatch / command descriptors the builder
-// registers. Every cero schema includes these; app refs are added on top.
-import { CeroError } from '@cero-base/core/errors'
-import { COUNTERS, EPOCHS, DB_TYPE } from '../lib/constants.js'
-import * as schemas from './schemas.js'
-
-// Builtin collections by scope — ref name → { type, kind? }. kind defaults to
-// 'collection' (id-keyed); 'single' has no key. Dispatches are derived for
-// main; counters is internal (a collection with no add/set/del).
-export const refs = {
-  main: {
-    members: { type: 'member' },
-    devices: { type: 'device' },
-    invites: { type: 'invite' },
-    handles: { type: 'handle' },
-    files: { type: 'file' }
-  },
-  local: {
-    master: { type: 'master', kind: 'single' },
-    keypair: { type: 'keypair', kind: 'single' },
-    'handle-keypairs': { type: 'handle-keypair' },
-    environment: { type: 'environment', kind: 'single' }
-  }
-}
-
-export function getHyperdbType(prim) {
-  return DB_TYPE[prim] || 'string'
-}
-
-const at = (ns, n) => `@${ns}/${n}`
-const keyOf = (def) => (def.kind === 'single' ? [] : ['id'])
-
-const fields = (map) =>
-  Object.entries(map).map(([name, m]) => ({
-    name,
-    type: getHyperdbType(m.prim),
-    required: m.required === true
-  }))
-
-// Merge app `t.extend` fields into a builtin's base fields — base can't be redeclared.
-const merge = (type, base, extra) => {
-  if (!extra) return base
-  for (const k in extra) {
-    if (k in base) {
-      throw CeroError.INVALID(`'${k}' is a base field of '${type}' and cannot be redeclared`)
-    }
-  }
-  return { ...base, ...extra }
-}
-
-const descriptors = (group, extend = {}) =>
-  Object.entries(group).map(([name, base]) => ({
-    name,
-    compact: false,
-    fields: fields(merge(name, base, extend[name]))
-  }))
-
-// meta.refs entries for a scope's builtins.
-export function builtinRefs(ns, scope) {
-  return Object.fromEntries(
-    Object.entries(refs[scope]).map(([name, def]) => [
-      name,
-      {
-        kind: def.kind || 'collection',
-        path: [name],
-        builtin: true,
-        ...(scope === 'main' && { verb: def.type }),
-        schema: at(ns, def.type)
-      }
-    ])
-  )
-}
-
-// hyperschema type descriptors. scope is 'main' | 'local' | 'rpc'; `extend`
-// merges app `t.extend` fields into the matching type.
-export function builtinTypes(scope, extend) {
-  return descriptors(schemas[scope], extend)
-}
-export function rpcTypes() {
-  return descriptors(schemas.rpc)
-}
-
-// hyperdb collection descriptors for a scope.
-export function builtinCollections(ns, scope) {
-  const out = Object.entries(refs[scope]).map(([name, def]) => ({
-    name,
-    schema: at(ns, def.type),
-    key: keyOf(def)
-  }))
-  if (scope === 'main') {
-    out.push({ name: COUNTERS, schema: at(ns, 'counter'), key: ['name'] })
-    out.push({ name: EPOCHS, schema: at(ns, 'epoch'), key: ['epoch'] })
-  }
-  return out
-}
-
-// hyperdispatch descriptors (main scope only).
-export function builtinDispatches(ns) {
-  return [
-    { name: 'add-writer', requestType: at(ns, 'writer') },
-    { name: 'del-writer', requestType: at(ns, 'writer') },
-    { name: 'claim-writer', requestType: at(ns, 'claim') },
-    ...Object.values(refs.main).flatMap(({ type }) => [
-      { name: `add-${type}`, requestType: at(ns, type) },
-      { name: `set-${type}`, requestType: at(ns, type) },
-      { name: `del-${type}`, requestType: at(ns, 'del-by-id') }
-    ])
-  ]
-}
-
-// Registered AFTER the app's own dispatches (see build/index.js): hyperdispatch
-// numbers routes positionally and persists them, so a spec built before
-// rotation must see rotate-key appended at the end — inserting it into the
-// builtin group would collide with the app's persisted route ids on an
-// incremental rebuild.
-export function rotateDispatch(ns) {
-  return { name: 'rotate-key', requestType: at(ns, 'epoch') }
-}
-
-export function rpcCommands(ns) {
-  const ref = (n) => at(ns, n)
-  return [
-    { name: 'init', request: { name: ref('req-empty') }, response: { name: ref('res-identity') } },
-    {
-      name: 'restore',
-      request: { name: ref('req-restore') },
-      response: { name: ref('res-identity') }
-    },
-    { name: 'seed', request: { name: ref('req-empty') }, response: { name: ref('res-seed') } },
-    { name: 'add-row', request: { name: ref('req-row') }, response: { name: ref('res-data') } },
-    {
-      name: 'add-file',
-      request: { name: ref('req-add-file') },
-      response: { name: ref('res-data') }
-    },
-    {
-      name: 'add-handle',
-      request: { name: ref('req-row') },
-      response: { name: ref('res-handle') }
-    },
-    { name: 'set', request: { name: ref('req-row') }, response: { name: ref('res-data') } },
-    { name: 'get', request: { name: ref('req-query') }, response: { name: ref('res-rows') } },
-    { name: 'get-one', request: { name: ref('req-id') }, response: { name: ref('res-data') } },
-    { name: 'del', request: { name: ref('req-id') }, response: { name: ref('res-ok') } },
-    { name: 'count', request: { name: ref('req-query') }, response: { name: ref('res-count') } },
-    {
-      name: 'watch',
-      request: { name: ref('req-query') },
-      response: { name: ref('res-rows'), stream: true }
-    },
-    { name: 'call', request: { name: ref('req-call') }, response: { name: ref('res-data') } },
-    { name: 'invite', request: { name: ref('req-invite') }, response: { name: ref('res-invite') } },
-    { name: 'revoke', request: { name: ref('req-revoke') }, response: { name: ref('res-ok') } },
-    { name: 'join', request: { name: ref('req-join') }, response: { name: ref('res-handle') } },
-    {
-      name: 'open-handle',
-      request: { name: ref('req-open') },
-      response: { name: ref('res-handle') }
-    },
-    {
-      name: 'close-handle',
-      request: { name: ref('req-handle') },
-      response: { name: ref('res-ok') }
-    },
-    { name: 'leave', request: { name: ref('req-handle') }, response: { name: ref('res-ok') } },
-    {
-      name: 'changes',
-      request: { name: ref('req-query') },
-      response: { name: ref('res-changes'), stream: true }
-    },
-    { name: 'rotate', request: { name: ref('req-handle') }, response: { name: ref('res-epoch') } }
-  ]
-}

package/src/lib/internal.js

@@ -1,9 +0,0 @@
-// Process-wide registry for extensions registered via `cero.use()`.
-// `build()` folds in each extension's schema; `cero()` runs each setup.
-// The bundled extensions are on by default — `cero.use(profileSync({...}))`
-// replaces a default by name, `{ extensions: false }` (on build and cero)
-// leaves them out entirely.
-import { profileSync } from '../extensions/profile-sync.js'
-import { handleSync } from '../extensions/handle-sync.js'
-
-export const internal = { extensions: [profileSync(), handleSync()] }

package/types/lib/internal.d.ts

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