@cero-base/cero 1.19.0 → 2.0.0

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,6 +95,8 @@ 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. */
@@ -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;
-    })[];
-};