@cero-base/core 1.8.1 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cero-base/core",
-  "version": "1.8.1",
+  "version": "1.9.0",
   "description": "cero p2p primitives — identity, storage, network, database, blobs, rpc, pairing.",
   "type": "module",
   "sideEffects": false,

package/src/pairing/index.js

@@ -69,7 +69,8 @@ export class Pairing extends ReadyResource {
     host = true,
     inviteEncoding = null,
     joinerEncoding = null,
-    onerror = safetyCatch
+    onerror = safetyCatch,
+    onconsume = null
   } = {}) {
     super()
     if (!network) throw CeroError.REQUIRED('network')
@@ -82,6 +83,9 @@ export class Pairing extends ReadyResource {
     this.inviteEncoding = inviteEncoding
     this.joinerEncoding = joinerEncoding
     this._onerror = onerror
+    // Fired with an invite's hex id when this instance stops serving it
+    // (single-use settled, or expired) — lets the owner drop its persisted row.
+    this.onconsume = onconsume
 
     this._blind = null
     this._member = null
@@ -168,12 +172,68 @@ export class Pairing extends ReadyResource {
       seed: blind.seed,
       publicKey: blind.publicKey,
       invite,
-      reuse
+      reuse,
+      // minted here and possibly not yet persisted/replicated — syncRows must
+      // never drop it for being absent from the store
+      local: true
     })
 
     return invite.toString()
   }
 
+  /**
+   * Look up the in-memory record for a minted invite by its string form.
+   *
+   * @param {string} inviteStr
+   * @returns {{ id: Uint8Array, seed: Uint8Array, publicKey: Uint8Array, invite: import('./invite.js').Invite, reuse: boolean } | null}
+   */
+  recordOf(inviteStr) {
+    for (const record of this._invites.values()) {
+      if (record.invite.toString() === inviteStr) return record
+    }
+    return null
+  }
+
+  /**
+   * Reconcile the served-invite set with persisted rows (the room's `invites`
+   * collection). Adds unknown rows so ANY member replica can serve them across
+   * restarts; drops replicated records whose row disappeared (revoked or
+   * consumed elsewhere). Locally-minted records not yet visible as rows are
+   * kept.
+   *
+   * @param {Array<{ id: string, invite: Uint8Array, publicKey: Uint8Array, seed: Uint8Array, reuse?: boolean }>} rows
+   */
+  syncRows(rows) {
+    const seen = new Set()
+    for (const row of rows) {
+      if (!row?.id || !row.invite || !row.publicKey || !row.seed) continue
+      seen.add(row.id)
+      const existing = this._invites.get(row.id)
+      if (existing) {
+        existing.local = false
+        continue
+      }
+      let invite
+      try {
+        invite = Invite.parse(b4a.toString(row.invite))
+      } catch {
+        continue
+      }
+      if (invite.expired) continue
+      this._invites.set(row.id, {
+        id: b4a.from(row.id, 'hex'),
+        seed: row.seed,
+        publicKey: row.publicKey,
+        invite,
+        reuse: !!row.reuse,
+        local: false
+      })
+    }
+    for (const [id, record] of this._invites) {
+      if (!seen.has(id) && !record.local) this._invites.delete(id)
+    }
+  }
+
   /**
    * Forget a previously-minted invite. New candidates carrying it will be
    * dropped silently.
@@ -273,6 +333,7 @@ export class Pairing extends ReadyResource {
     if (!record) return
     if (record.invite.expired) {
       this._invites.delete(id)
+      this.onconsume?.(id)
       return
     }
 
@@ -292,7 +353,10 @@ export class Pairing extends ReadyResource {
       seed: record.seed,
       userData,
       onsettle: () => {
-        if (!record.reuse) this._invites.delete(id)
+        if (!record.reuse) {
+          this._invites.delete(id)
+          this.onconsume?.(id)
+        }
       }
     })
 

package/types/pairing/index.d.ts

@@ -57,7 +57,7 @@ export class Pairing extends ReadyResource {
      */
     static isInvite(str: unknown): boolean;
     /** @param {PairingOpts} [opts] */
-    constructor({ network, identity, topic, host, inviteEncoding, joinerEncoding, onerror }?: PairingOpts);
+    constructor({ network, identity, topic, host, inviteEncoding, joinerEncoding, onerror, onconsume }?: PairingOpts);
     network: import("../index.js").Network;
     identity: import("../index.js").Identity;
     topic: Uint8Array<ArrayBufferLike>;
@@ -65,6 +65,7 @@ export class Pairing extends ReadyResource {
     inviteEncoding: any;
     joinerEncoding: any;
     _onerror: (err: Error) => void;
+    onconsume: any;
     _blind: any;
     _member: any;
     _invites: Map<any, any>;
@@ -76,6 +77,35 @@ export class Pairing extends ReadyResource {
      * @returns {Promise<string>}
      */
     createInvite({ role, expiresIn, data, reuse }?: CreateInviteOpts): Promise<string>;
+    /**
+     * Look up the in-memory record for a minted invite by its string form.
+     *
+     * @param {string} inviteStr
+     * @returns {{ id: Uint8Array, seed: Uint8Array, publicKey: Uint8Array, invite: import('./invite.js').Invite, reuse: boolean } | null}
+     */
+    recordOf(inviteStr: string): {
+        id: Uint8Array;
+        seed: Uint8Array;
+        publicKey: Uint8Array;
+        invite: import("./invite.js").Invite;
+        reuse: boolean;
+    } | null;
+    /**
+     * Reconcile the served-invite set with persisted rows (the room's `invites`
+     * collection). Adds unknown rows so ANY member replica can serve them across
+     * restarts; drops replicated records whose row disappeared (revoked or
+     * consumed elsewhere). Locally-minted records not yet visible as rows are
+     * kept.
+     *
+     * @param {Array<{ id: string, invite: Uint8Array, publicKey: Uint8Array, seed: Uint8Array, reuse?: boolean }>} rows
+     */
+    syncRows(rows: Array<{
+        id: string;
+        invite: Uint8Array;
+        publicKey: Uint8Array;
+        seed: Uint8Array;
+        reuse?: boolean;
+    }>): void;
     /**
      * Forget a previously-minted invite. New candidates carrying it will be
      * dropped silently.