@rljson/db 0.0.21 → 0.0.23

package/dist/connector/connector.d.ts

@@ -1,8 +1,14 @@
 import { Socket } from '@rljson/io';
-import { AckPayload, ClientId, ConflictCallback, InsertHistoryTimeId, Route, SyncConfig, SyncEventNames } from '@rljson/rljson';
+import { AckPayload, ClientId, ConflictCallback, Route, SyncConfig, SyncEventNames } from '@rljson/rljson';
 import { Db } from '../db.ts';
 export type { ConnectorPayload } from '@rljson/rljson';
-export type ConnectorCallback = (ref: string) => Promise<any>;
+/**
+ * Invoked for each deduplicated incoming ref. `predecessorRefs` carries the
+ * causal predecessor *content refs* (shared identity across clients) when
+ * `causalOrdering` is enabled, so the receiver can record correct ancestry in
+ * its own InsertHistory. Empty/undefined for roots or when causal ordering is off.
+ */
+export type ConnectorCallback = (ref: string, predecessorRefs?: string[]) => Promise<any>;
 export declare class Connector {
     private readonly _db;
     private readonly _route;
@@ -11,6 +17,7 @@ export declare class Connector {
     private _callbacks;
     private _conflictCallbacks;
     private _missedRef;
+    private _missedPredecessorRefs;
     private _lastSentRef;
     private _isListening;
     private _sentRefsCurrent;
@@ -39,10 +46,12 @@ export declare class Connector {
      */
     sendWithAck(ref: string): Promise<AckPayload>;
     /**
-     * Sets the causal predecessors for the next send.
-     * @param predecessors - The InsertHistory timeIds of causal predecessors
+     * Sets the causal predecessors (content refs) attached to the next send.
+     * Normally auto-populated from the InsertHistoryRow; exposed for tests/manual
+     * control.
+     * @param predecessors - The predecessor content refs
      */
-    setPredecessors(predecessors: InsertHistoryTimeId[]): void;
+    setPredecessors(predecessors: string[]): void;
     /**
      * Registers a callback for incoming refs on this route.
      *
@@ -64,6 +73,20 @@ export declare class Connector {
      * @param callback - Invoked with the detected Conflict
      */
     onConflict(callback: ConflictCallback): void;
+    /**
+     * Removes a ref from the received-dedup set so a later re-advertisement of
+     * the same ref (e.g. the server's bootstrap heartbeat, which only re-sends
+     * the *latest* ref) is delivered to listeners again instead of being
+     * silently deduplicated.
+     *
+     * A ref is added to the dedup set the instant it is *received* — before the
+     * listener callback (which materializes it) has a chance to succeed. If that
+     * apply step fails terminally, the ref is stuck in the dedup set forever and
+     * the heartbeat can never heal it. Consumers whose apply failed call this so
+     * recovery becomes eventually-consistent rather than permanent loss.
+     * @param ref - The ref to allow re-delivery for.
+     */
+    invalidateReceived(ref: string): void;
     /**
      * Returns the current sequence number.
      * Only meaningful when `causalOrdering` is enabled.

package/dist/db.js

@@ -24,6 +24,7 @@ class Connector {
   _callbacks = [];
   _conflictCallbacks = [];
   _missedRef = null;
+  _missedPredecessorRefs = void 0;
   _lastSentRef = null;
   _isListening = false;
   // Two-generation dedup sets — bounded memory
@@ -37,6 +38,9 @@ class Connector {
   _clientId;
   _events;
   _seq = 0;
+  // Predecessor *content refs* (not timeIds) attached to the next send. Refs are
+  // the only identity shared across clients, so the receiver can map them to its
+  // own local ancestry. Auto-populated from the InsertHistoryRow on db inserts.
   _lastPredecessors = [];
   _peerSeqs = /* @__PURE__ */ new Map();
   // ...........................................................................
@@ -92,8 +96,10 @@ class Connector {
   }
   // ...........................................................................
   /**
-   * Sets the causal predecessors for the next send.
-   * @param predecessors - The InsertHistory timeIds of causal predecessors
+   * Sets the causal predecessors (content refs) attached to the next send.
+   * Normally auto-populated from the InsertHistoryRow; exposed for tests/manual
+   * control.
+   * @param predecessors - The predecessor content refs
    */
   setPredecessors(predecessors) {
     this._lastPredecessors = predecessors;
@@ -111,8 +117,12 @@ class Connector {
     this._callbacks.push(callback);
     if (this._missedRef !== null) {
       const ref = this._missedRef;
+      const predecessorRefs = this._missedPredecessorRefs;
       this._missedRef = null;
-      Promise.resolve(callback(ref)).catch(console.error);
+      this._missedPredecessorRefs = void 0;
+      Promise.resolve(
+        predecessorRefs ? callback(ref, predecessorRefs) : callback(ref)
+      ).catch(console.error);
     }
   }
   // ...........................................................................
@@ -131,6 +141,24 @@ class Connector {
     this._conflictCallbacks.push(callback);
   }
   // ...........................................................................
+  /**
+   * Removes a ref from the received-dedup set so a later re-advertisement of
+   * the same ref (e.g. the server's bootstrap heartbeat, which only re-sends
+   * the *latest* ref) is delivered to listeners again instead of being
+   * silently deduplicated.
+   *
+   * A ref is added to the dedup set the instant it is *received* — before the
+   * listener callback (which materializes it) has a chance to succeed. If that
+   * apply step fails terminally, the ref is stuck in the dedup set forever and
+   * the heartbeat can never heal it. Consumers whose apply failed call this so
+   * recovery becomes eventually-consistent rather than permanent loss.
+   * @param ref - The ref to allow re-delivery for.
+   */
+  invalidateReceived(ref) {
+    this._receivedRefsCurrent.delete(ref);
+    this._receivedRefsPrevious.delete(ref);
+  }
+  // ...........................................................................
   /**
    * Returns the current sequence number.
    * Only meaningful when `causalOrdering` is enabled.
@@ -209,12 +237,17 @@ class Connector {
       this._receivedRefsCurrent = /* @__PURE__ */ new Set();
     }
   }
-  _notifyCallbacks(ref) {
+  _notifyCallbacks(ref, predecessorRefs) {
     if (this._callbacks.length === 0) {
       this._missedRef = ref;
+      this._missedPredecessorRefs = predecessorRefs;
       return;
     }
-    Promise.all(this._callbacks.map((cb) => cb(ref))).catch((err) => {
+    Promise.all(
+      this._callbacks.map(
+        (cb) => predecessorRefs ? cb(ref, predecessorRefs) : cb(ref)
+      )
+    ).catch((err) => {
       console.error(`Error notifying connector callbacks for ref ${ref}:`, err);
     });
   }
@@ -235,7 +268,7 @@ class Connector {
       this._peerSeqs.set(payload.c, payload.seq);
     }
     this._addReceivedRef(ref);
-    this._notifyCallbacks(ref);
+    this._notifyCallbacks(ref, payload.p);
     if (this._syncConfig?.requireAck) {
       this._socket.emit(this._events.ackClient, { r: ref });
     }
@@ -273,19 +306,23 @@ class Connector {
     });
   }
   _registerDbObserver() {
-    this._db.registerObserver(this._route, (ins) => {
-      return new Promise((resolve) => {
-        const ref = ins[this.route.root.tableKey + "Ref"];
-        if (this._hasSentRef(ref)) {
-          resolve();
-          return;
-        }
-        if (this._syncConfig?.causalOrdering && ins.previous?.length) {
-          this._lastPredecessors = [...ins.previous];
+    this._db.registerObserver(this._route, async (ins) => {
+      const tableKey = this.route.root.tableKey;
+      const ref = ins[tableKey + "Ref"];
+      if (this._hasSentRef(ref)) {
+        return;
+      }
+      if (this._syncConfig?.causalOrdering && ins.previous?.length) {
+        const refs = [];
+        for (const timeId2 of ins.previous) {
+          const predRef = await this._db.getRefOfTimeId(tableKey, timeId2);
+          if (predRef) {
+            refs.push(predRef);
+          }
         }
-        this.send(ref);
-        resolve();
-      });
+        this._lastPredecessors = refs;
+      }
+      this.send(ref);
     });
   }
   get socket() {