@cero-base/core 1.12.0 → 1.14.0

package/src/network/index.js

@@ -1,18 +1,22 @@
 import NoiseSecretStream from '@hyperswarm/secret-stream'
+import Autobee from 'autobee'
 import BlindPairing from 'blind-pairing'
 import BlindPeering from 'blind-peering'
 import ProtomuxWakeup from 'protomux-wakeup'
 import ReadyResource from 'ready-resource'
 import safetyCatch from 'safety-catch'
 import { decode as decodeKey } from 'hypercore-id-encoding'
+import { hash } from 'hypercore-crypto'
+import Hyperswarm from 'hyperswarm'
 import b4a from 'b4a'
 
 import { ACTIVE, PASSIVE } from '../lib/constants.js'
 import { CeroError } from '../lib/errors.js'
 import { Discovery } from './discovery.js'
-import { DHTTransport, channelTopic } from './transports/dht.js'
 
-export { channelTopic }
+export function channelTopic(topic, channel) {
+  return channel ? hash([topic, b4a.from(channel)]) : topic
+}
 
 /**
  * @typedef {object} NetworkOpts
@@ -43,7 +47,7 @@ export class Network extends ReadyResource {
     this.store = store || null
     this.mirrors = (mirrors || []).map((k) => (typeof k === 'string' ? decodeKey(k) : k))
 
-    this._dht = null
+    this._swarm = null
     this.wakeup = new ProtomuxWakeup()
 
     this._replicateables = new Set()
@@ -55,7 +59,7 @@ export class Network extends ReadyResource {
 
   /** @returns {any} The underlying hyperswarm, or null before ready / after close. */
   get swarm() {
-    return this._dht ? this._dht.swarm : null
+    return this._swarm
   }
 
   /**
@@ -108,6 +112,7 @@ export class Network extends ReadyResource {
    * @returns {Promise<any>}
    */
   async blind() {
+    if (this.closing || this.closed) throw CeroError.CLOSED('Network')
     if (!this._blind) {
       const blind = new BlindPairing(this.swarm)
       this._blind = blind.ready().then(() => {
@@ -156,17 +161,15 @@ export class Network extends ReadyResource {
   }
 
   async _open() {
-    this._dht = new DHTTransport({
-      identity: this.identity,
-      bootstrap: this.bootstrap,
-      firewall: this.firewall,
-      relayThrough: this.relayThrough,
-      channel: this.channel
-    })
+    const opts = {}
+    if (this.identity) {
+      opts.keyPair = { publicKey: this.identity.publicKey, secretKey: this.identity.secretKey }
+    }
+    if (this.bootstrap) opts.bootstrap = this.bootstrap
+    if (this.firewall) opts.firewall = this.firewall
+    if (this.relayThrough) opts.relayThrough = this.relayThrough
 
-    // DHTTransport owns the swarm's lifecycle; Network subscribes to its events
-    // because the handlers touch Network state (wakeup, replicateables, emit).
-    const swarm = this._dht.swarm
+    const swarm = (this._swarm = new Hyperswarm(opts))
     swarm.on('connection', (stream, info) => {
       if (this.closing || this.closed) {
         stream.destroy()
@@ -176,12 +179,10 @@ export class Network extends ReadyResource {
       for (const r of this._replicateables) replicateInto(r, stream)
       this.emit('connection', stream, info)
     })
-    swarm.on('peer-add', (peer) => this.emit('peer-add', peer))
-    swarm.on('peer-remove', (peer) => this.emit('peer-remove', peer))
 
     if (this.store && this.mirrors.length) {
       this._blindPeering = new BlindPeering(swarm.dht, this.store, {
-        keys: this.mirrors,
+        blindPeers: this.mirrors.map((key) => ({ key })),
         wakeup: this.wakeup,
         pick: 2
       })
@@ -194,8 +195,9 @@ export class Network extends ReadyResource {
    * @param {{ timeout?: number }} [opts]
    * @returns {Promise<void>}
    */
-  async flush(opts) {
-    await this._dht?.flush(opts)
+  async flush({ timeout = 500 } = {}) {
+    if (!this._swarm) return
+    await Promise.race([this._swarm.flush(), new Promise((r) => setTimeout(r, timeout))])
   }
 
   /**
@@ -206,7 +208,11 @@ export class Network extends ReadyResource {
   async suspend() {
     if (this.closing || this.closed) return
     await this._blindPeering?.suspend()
-    await this._dht?.suspend()
+    try {
+      await this._swarm?.suspend()
+    } catch (err) {
+      safetyCatch(err)
+    }
   }
 
   /**
@@ -216,7 +222,11 @@ export class Network extends ReadyResource {
    */
   async resume() {
     if (this.closing || this.closed) return
-    await this._dht?.resume()
+    try {
+      await this._swarm?.resume()
+    } catch (err) {
+      safetyCatch(err)
+    }
     await this._blindPeering?.resume()
   }
 
@@ -256,13 +266,14 @@ export class Network extends ReadyResource {
       this._blind = null
     }
 
-    if (this._dht) {
+    if (this._swarm) {
       try {
-        await this._dht.destroy()
+        await this.flush()
+        await this._swarm.destroy()
       } catch (err) {
         safetyCatch(err)
       }
-      this._dht = null
+      this._swarm = null
     }
 
     if (this.wakeup) {
@@ -289,10 +300,10 @@ export class Network extends ReadyResource {
     if (!this.swarm) throw CeroError.NOT_READY('Network', 'network')
     if (!isTopic(topic)) throw CeroError.INVALID('topic must be a 32-byte buffer')
 
-    const session =
-      mode === ACTIVE
-        ? this.swarm.join(topic, { client: true, server: true })
-        : this.swarm.join(topic, { client: false, server: true })
+    const session = this.swarm.join(channelTopic(topic, this.channel), {
+      client: mode === ACTIVE,
+      server: true
+    })
 
     const discovery = new Discovery(this, session, mode)
     this._discoveries.add(discovery)
@@ -313,7 +324,7 @@ export class Network extends ReadyResource {
     // mirror the core so it stays available when its writers are offline —
     // autobees announce their whole writer set, plain cores (blobs) just themselves
     if (this._blindPeering) {
-      if (core.wakeupCapability) this._blindPeering.addAutobaseBackground(core)
+      if (Autobee.isAutobee(core)) this._blindPeering.addAutobaseBackground(core)
       else this._blindPeering.addCoreBackground(core)
     }
   }

package/src/pairing/index.js

@@ -6,6 +6,7 @@ import c from 'compact-encoding'
 import { discoveryKey, keyPair, sign } from 'hypercore-crypto'
 
 import { Invite } from './invite.js'
+import { channelTopic } from '../network/index.js'
 import { getEncoding } from '../lib/spec/index.js'
 import { CeroError } from '../lib/errors.js'
 
@@ -103,7 +104,8 @@ export class Pairing extends ReadyResource {
     // identity throw 'Active member already exist'
     if (this.host) {
       this._member = this._blind.addMember({
-        discoveryKey: discoveryKey(this.topic),
+        // channel-scoped; the candidate hashes identically (no channel → identity)
+        discoveryKey: channelTopic(discoveryKey(this.topic), this.network.channel),
         onadd: (req) => this._onCandidate(req).catch(this._onerror)
       })
     }
@@ -486,6 +488,8 @@ class Candidate {
         this._candidate = this.pairing._blind.addCandidate({
           invite: this.invite.blind,
           userData: this.userData,
+          // must hash exactly like the member side — see Pairing._open
+          discoveryKey: channelTopic(this.invite.discoveryKey, this.pairing.network.channel),
           onadd: (result) => this._done(result)
         })
         this._candidate.request.on('rejected', (err) => this._fail(fromBlindError(err)))
@@ -560,7 +564,9 @@ function decodeUserData(buf, encoding) {
 }
 
 function fromBlindError(err) {
-  if (!err || !err.code) return CeroError.DENIED(err?.message || null)
+  // code-less rejections are protocol failures (undecodable reply, key
+  // mismatch, bad signature) — never a host decision, don't report DENIED
+  if (!err || !err.code) return CeroError.NETWORK_ERROR(err?.message || 'pairing failed')
   switch (err.code) {
     case 'INVITE_EXPIRED':
       return CeroError.EXPIRED(err.message)

package/src/rpc/peer.js

@@ -25,8 +25,11 @@ export class RPCPeer extends ReadyResource {
     this.ipc = ipc
     this.spec = spec
     this.framed = new FramedStream(ipc)
-    this.framed.pause()
     this.rpc = new spec.rpc(this.framed)
+    // pause AFTER hrpc attaches its 'data' listener — streamx re-resumes a
+    // paused stream the moment a listener attaches, so pausing first holds
+    // nothing and early frames would dispatch before the codec is bound
+    this.framed.pause()
   }
 
   async _open() {

package/src/storage/index.js

@@ -5,11 +5,19 @@ import Corestore from 'corestore'
 import HyperDB from 'hyperdb'
 import ReadyResource from 'ready-resource'
 
-import { ROCKS, BEE, SINGLE, COLLECTION } from '../lib/constants.js'
-import { genId, subscribe } from '../lib/utils.js'
+import { ROCKS, BEE, SINGLE, COLLECTION, QUERY_RESERVED } from '../lib/constants.js'
+import { genId, subscribe, searchHit } from '../lib/utils.js'
 import { CeroError } from '../lib/errors.js'
 
-const RANGE_OPS = new Set(['gt', 'gte', 'lt', 'lte', 'reverse', 'limit'])
+// The subset of the query grammar hyperdb itself honors (pushed down);
+// the rest of QUERY_RESERVED is applied in memory here.
+const RANGE_OPS = ['gt', 'gte', 'lt', 'lte', 'reverse', 'limit']
+
+const pick = (query, keys) => {
+  const out = {}
+  if (query) for (const k of keys) if (query[k] !== undefined) out[k] = query[k]
+  return out
+}
 
 /**
  * @typedef {object} StorageOpts
@@ -204,17 +212,18 @@ export class Storage extends ReadyResource {
       return { data: (await this.db.get(col, { id: query })) ?? null }
     }
 
-    // hyperdb only honors range/limit operators — equality fields must be
-    // filtered here or they are silently ignored and every row comes back
-    const eq = Object.keys(query || {}).filter((k) => !RANGE_OPS.has(k))
-    if (eq.length) {
+    // hyperdb only honors range/limit operators — equality fields and search
+    // must be applied here or they are silently ignored and every row comes back
+    const eq = Object.keys(query || {}).filter((k) => !QUERY_RESERVED.has(k))
+    if (eq.length || query?.search) {
       const rows = await this.db.find(col, {}).toArray()
-      const matched = rows.filter((r) => eq.every((k) => r[k] === query[k]))
+      let matched = rows.filter((r) => eq.every((k) => r[k] === query[k]))
+      if (query.search) matched = matched.filter((r) => searchHit(r, query.search, query.fields))
       const data = query.limit != null ? matched.slice(0, query.limit) : matched
       return { data, total: matched.length, size: data.length }
     }
 
-    const data = await this.db.find(col, query || {}).toArray()
+    const data = await this.db.find(col, pick(query, RANGE_OPS)).toArray()
     // a limit caps `data`, so `total` needs a full count; with no query
     // `data` is already everything — skip the second scan.
     const filtered = query && Object.keys(query).length > 0
@@ -233,9 +242,11 @@ export class Storage extends ReadyResource {
     this._guard()
     const ref = this._ref(name)
     const col = this._col(ref)
-    const eq = Object.keys(query || {}).filter((k) => !RANGE_OPS.has(k))
-    const rows = await this.db.find(col, eq.length ? {} : query || {}).toArray()
-    const matched = eq.length ? rows.filter((r) => eq.every((k) => r[k] === query[k])) : rows
+    const eq = Object.keys(query || {}).filter((k) => !QUERY_RESERVED.has(k))
+    const filtered = eq.length || query?.search
+    const rows = await this.db.find(col, filtered ? {} : pick(query, RANGE_OPS)).toArray()
+    let matched = filtered ? rows.filter((r) => eq.every((k) => r[k] === query[k])) : rows
+    if (query?.search) matched = matched.filter((r) => searchHit(r, query.search, query.fields))
     return { data: matched.length }
   }
 

package/types/database/changes.d.ts

@@ -1,10 +1,11 @@
 /**
  * Pull-driven delta stream over a collection: batches of `{ prev, next }`
- * pairs diffed between per-stream snapshot cursors. Update ticks only mark
- * the stream dirty — the diff runs when the reader demands, so backpressure
- * folds bursts into one bigger batch and nothing is ever dropped. The first
- * batch, and any batch after the view is swapped or fast-forwarded to a new
- * core, carries the full matching state as inserts with `reset: true`.
+ * pairs diffed between per-stream head cursors (`db.diff(col, { from })`).
+ * Update ticks only mark the stream dirty — the diff runs when the reader
+ * demands, so backpressure folds bursts into one bigger batch and nothing is
+ * ever dropped. The first batch, and any batch after the view is swapped or
+ * fast-forwarded to a new core, carries the full matching state as inserts
+ * with `reset: true`.
  *
  * @param {import('./index.js').Database} db
  * @param {string} name    Ref name (scopes the update ticks).

package/types/database/encryption.d.ts

@@ -7,6 +7,8 @@
  * @returns {Uint8Array}
  */
 export function blobEpochKey(entropy: Uint8Array): Uint8Array;
+/** Prime a keyring from a local core's persisted epoch stash. */
+export function loadEpochs(keyring: any, local: any): Promise<void>;
 /**
  * Wire codec for a rotation announcement's envelope list — one sealed box
  * per remaining member, addressed by member id.
@@ -46,7 +48,6 @@ export class Keyring {
     seq: number;
     /** bumped on every add/remove — cheap change detection for retries */
     version: number;
-    primed: boolean;
     /** @returns {Array<{ epoch: number, stamp: number, entropy: Uint8Array }>} ascending by seq */
     all(): Array<{
         epoch: number;
@@ -86,12 +87,12 @@ export class EpochEncryption {
 export class EpochAutobee {
     constructor(store: any, key: any, handlers?: {});
     keyring: any;
+    _epochStalled: Set<any>;
     _epochRetry: any;
     _epochRetryDelay: number;
     _epochRetrySeen: number;
-    _bootState(): Promise<void>;
     _bumpPendingWriters(): Promise<any>;
-    _parkOnUnknownEpoch(w: any): void;
+    _applyWakeupHints(): Promise<any>;
     _scheduleEpochRetry(): void;
     _close(): Promise<any>;
 }

package/types/database/index.d.ts

@@ -90,7 +90,7 @@ export class Database extends ReadyResource {
     onApplyHooks: Set<any>;
     _applySeq: number;
     _touched: Set<any>;
-    txQueue: any[];
+    txQueue: any;
     _discovery: import("../network/discovery.js").Discovery;
     /** Open the underlying autobee, wire dispatcher + apply, attach to network. */
     openBee(): Promise<void>;
@@ -258,14 +258,19 @@ export class Database extends ReadyResource {
      */
     _healEpochs(): Promise<void>;
     /**
-     * Batch every write performed inside `fn` into a single autobee append.
-     * Nested calls reuse the outer queue.
+     * Batch every write made through the transaction handle passed to `fn`
+     * into a single autobee append. The handle is this database with its own
+     * write queue — same surface (`put`/`set`/`del`/`call`), but writes buffer
+     * until `fn` returns, and are discarded if it throws. Writes made on the
+     * database itself meanwhile append normally: an unrelated concurrent write
+     * can never be swallowed into (and rolled back with) a transaction.
+     * Nested `tx()` on the handle joins the same batch.
      *
      * @template T
-     * @param {() => Promise<T> | T} fn
+     * @param {(tx: Database) => Promise<T> | T} fn
      * @returns {Promise<T>}
      */
-    tx<T>(fn: () => Promise<T> | T): Promise<T>;
+    tx<T>(fn: (tx: Database) => Promise<T> | T): Promise<T>;
     _txChain: any;
     /**
      * Encode and append dispatch ops. Buffers into the active `tx` queue if one

package/types/lib/constants.d.ts

@@ -33,5 +33,6 @@ export namespace RANK {
     export { reader_1 as reader };
 }
 export const NAMESPACE: "cero";
+export const QUERY_RESERVED: Set<string>;
 export const COUNTERS: "counters";
 export const EPOCHS: "epochs";

package/types/lib/utils.d.ts

@@ -27,6 +27,7 @@ export function subscribe<T>({ get, watch }: {
     get: () => Promise<T> | T;
     watch: (fn: () => void) => (() => void) | void;
 }): import("streamx").Readable<T>;
+export function searchHit(row: any, term: any, fields: any): boolean;
 /**
  * z32-encode a 32-byte key into a canonical string id.
  *

package/types/network/index.d.ts

@@ -1,4 +1,4 @@
-export { channelTopic };
+export function channelTopic(topic: any, channel: any): any;
 /**
  * @typedef {object} NetworkOpts
  * @property {import('../identity/index.js').Identity} [identity]  Long-lived keypair used as the swarm identity.
@@ -28,7 +28,7 @@ export class Network extends ReadyResource {
     channel: string;
     store: any;
     mirrors: any[];
-    _dht: DHTTransport;
+    _swarm: any;
     wakeup: any;
     _replicateables: Set<any>;
     _discoveries: Set<any>;
@@ -82,7 +82,7 @@ export class Network extends ReadyResource {
      * @param {{ timeout?: number }} [opts]
      * @returns {Promise<void>}
      */
-    flush(opts?: {
+    flush({ timeout }?: {
         timeout?: number;
     }): Promise<void>;
     /**
@@ -168,7 +168,5 @@ export type NetworkOpts = {
 export type Replicable = {
     replicate: (stream: any) => any;
 };
-import { channelTopic } from './transports/dht.js';
 import ReadyResource from 'ready-resource';
-import { DHTTransport } from './transports/dht.js';
 import { Discovery } from './discovery.js';