@peerbit/shared-log 16.0.24 → 16.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peerbit/shared-log",
-  "version": "16.0.24",
+  "version": "16.0.25",
   "description": "Shared log",
   "sideEffects": false,
   "type": "module",
@@ -62,35 +62,35 @@
     "pidusage": "^4.0.1",
     "pino": "^9.4.0",
     "uint8arrays": "^5.1.0",
-    "@peerbit/any-store": "2.2.17",
     "@peerbit/blocks": "4.2.16",
-    "@peerbit/blocks-interface": "2.1.8",
     "@peerbit/cache": "3.1.1",
     "@peerbit/crypto": "3.1.6",
+    "@peerbit/blocks-interface": "2.1.8",
     "@peerbit/diagnostics": "0.0.1",
+    "@peerbit/any-store": "2.2.17",
     "@peerbit/indexer-interface": "3.0.13",
-    "@peerbit/log": "6.2.31",
     "@peerbit/logger": "2.0.2",
-    "@peerbit/indexer-sqlite3": "3.0.20",
     "@peerbit/program": "6.0.58",
-    "@peerbit/riblt": "1.2.0",
-    "@peerbit/time": "3.0.1",
+    "@peerbit/indexer-sqlite3": "3.0.20",
+    "@peerbit/pubsub": "5.4.5",
+    "@peerbit/pubsub-interface": "5.2.2",
+    "@peerbit/log": "6.2.31",
     "@peerbit/rpc": "6.1.26",
+    "@peerbit/riblt": "1.2.0",
     "@peerbit/stream-interface": "6.0.16",
-    "@peerbit/pubsub-interface": "5.2.2",
-    "@peerbit/pubsub": "5.4.5"
+    "@peerbit/time": "3.0.1"
   },
   "optionalDependencies": {
-    "@peerbit/shared-log-rust": "0.1.7",
-    "@peerbit/native-backbone": "0.2.12"
+    "@peerbit/native-backbone": "0.2.12",
+    "@peerbit/shared-log-rust": "0.1.7"
   },
   "devDependencies": {
     "@types/libsodium-wrappers": "^0.7.14",
     "@types/pidusage": "^2.0.5",
     "uuid": "^11.1.1",
-    "@peerbit/any-store-rust": "0.1.7",
-    "@peerbit/indexer-rust": "1.0.14",
     "@peerbit/indexer-simple": "1.2.17",
+    "@peerbit/indexer-rust": "1.0.14",
+    "@peerbit/any-store-rust": "0.1.7",
     "@peerbit/test-utils": "3.1.38",
     "peerbit": "5.3.38"
   },

package/src/exchange-heads.ts

@@ -383,6 +383,15 @@ export const SYNC_CAPABILITY_REPLICATION_INFO_V2_CONFIRM = 1 << 4;
  */
 export const SYNC_CAPABILITY_PERSISTED_ENTRY_RECEIPTS = 1 << 5;
 
+/**
+ * Transient authenticated recovery hint: the receiver of this exact
+ * `SyncCapabilitiesMessage` should re-arm its current replication-info V2
+ * receiver and issue a fresh Full request. This bit is deliberately omitted
+ * from steady capability advertisements and must never be retained as a
+ * negotiated capability. Older peers safely ignore the unknown bit.
+ */
+export const SYNC_CAPABILITY_REPLICATION_INFO_V2_REARM = 1 << 6;
+
 /**
  * One-shot capability advertisement, sent to a peer when it (or we) subscribe
  * to the program topic. Peers that do not know this message drop it as an

package/src/index.ts

@@ -169,6 +169,7 @@ import {
 	SYNC_CAPABILITY_REPLICATION_INFO_V2_APPLY,
 	SYNC_CAPABILITY_REPLICATION_INFO_V2_CONFIRM,
 	SYNC_CAPABILITY_REPLICATION_INFO_V2_DECODE,
+	SYNC_CAPABILITY_REPLICATION_INFO_V2_REARM,
 	SYNC_CAPABILITY_REPLICATION_INFO_V2_SEND,
 	StashBackedRawExchangeHeadsMessage,
 	SyncCapabilitiesMessage,
@@ -4071,6 +4072,7 @@ export class SharedLog<
 		peerSession: PeerSession;
 		receiveEpoch: object | null;
 		signal: AbortSignal;
+		requestRemoteFullRearm?: boolean;
 	}): Promise<
 		{ receiverTransportSession: bigint; requestNotBeforeMs: number } | undefined
 	> {
@@ -4078,7 +4080,11 @@ export class SharedLog<
 		const receiverTransportSession = this.ownTransportSession();
 		await this.rpc.send(
 			new SyncCapabilitiesMessage({
-				capabilities: this.replicationInfoV2ReceiveCapabilities(),
+				capabilities:
+					this.replicationInfoV2ReceiveCapabilities() |
+					(properties.requestRemoteFullRearm
+						? SYNC_CAPABILITY_REPLICATION_INFO_V2_REARM
+						: 0),
 			}),
 			{
 				mode: new AcknowledgeDelivery({
@@ -4145,6 +4151,7 @@ export class SharedLog<
 					peerSession: properties.peerSession as PeerSession,
 					receiveEpoch: properties.receiveEpoch,
 					signal: properties.signal,
+					requestRemoteFullRearm: properties.requestRemoteFullRearm,
 				}),
 			onRequestError: (error) => {
 				if (
@@ -5851,7 +5858,13 @@ export class SharedLog<
 
 	private persistedReceiptPeerSession(
 		peerHash: string,
-	): { capabilitySession: bigint; peerSession: PeerSession } | undefined {
+	):
+		| {
+				capabilitySession: bigint;
+				peerSession: PeerSession;
+				receiveEpoch: object | null;
+		  }
+		| undefined {
 		// This is a hot receipt/transfer-loop predicate. Keep it allocation-light,
 		// while mirroring every exact-session gate in
 		// persistedReceiptReadinessCandidate (which additionally creates public
@@ -5884,7 +5897,7 @@ export class SharedLog<
 		) {
 			return undefined;
 		}
-		return { capabilitySession, peerSession };
+		return { capabilitySession, peerSession, receiveEpoch };
 	}
 
 	private async waitPersistedReceiptRetry(
@@ -23168,6 +23181,17 @@ export class SharedLog<
 					if (!context.from.equals(this.node.identity.publicKey)) {
 						const capabilityTransportSession = context.message?.header?.session;
 						const capabilityTimestamp = context.message?.header?.timestamp;
+						const previousCapabilitySession =
+							this._peerSyncCapabilitySessions.get(receiveFromHash);
+						const previousCapabilityTimestamp =
+							this._peerSyncCapabilityTimestamps.get(receiveFromHash);
+						const requestsRemoteFullRearm =
+							(msg.capabilities & SYNC_CAPABILITY_REPLICATION_INFO_V2_REARM) !==
+							0;
+						// The rearm bit is a one-shot authenticated command, not a sticky
+						// negotiated capability. Store and promote only the steady bits.
+						const steadyCapabilities =
+							msg.capabilities & ~SYNC_CAPABILITY_REPLICATION_INFO_V2_REARM;
 						// No await separates this from the capture above, so the captured
 						// window state is exact: the legacy re-read of the opening map here
 						// could never observe a different value.
@@ -23180,7 +23204,7 @@ export class SharedLog<
 							// cleanup cannot erase it before the opening transition commits.
 							this.observePeerSyncCapabilities({
 								peerHash: receiveFromHash,
-								capabilities: msg.capabilities,
+								capabilities: steadyCapabilities,
 								transportSession: capabilityTransportSession,
 								timestamp: capabilityTimestamp,
 								openingSession: receiveSession!,
@@ -23188,7 +23212,7 @@ export class SharedLog<
 						} else {
 							const observed = this.observePeerSyncCapabilities({
 								peerHash: receiveFromHash,
-								capabilities: msg.capabilities,
+								capabilities: steadyCapabilities,
 								transportSession: capabilityTransportSession,
 								timestamp: capabilityTimestamp,
 							});
@@ -23197,6 +23221,33 @@ export class SharedLog<
 									context.from,
 									receiveSession,
 								);
+								const freshExactRearm =
+									requestsRemoteFullRearm &&
+									capabilityTransportSession !== undefined &&
+									capabilityTimestamp !== undefined &&
+									previousCapabilitySession === capabilityTransportSession &&
+									previousCapabilityTimestamp !== undefined &&
+									capabilityTimestamp > previousCapabilityTimestamp;
+								if (
+									freshExactRearm &&
+									this._v2Receive.isCurrentActive({
+										peerHash: receiveFromHash,
+										peerSession: receiveSession,
+										receiveEpoch:
+											this._peerSessions.receiveEpoch(receiveFromHash),
+										senderTransportSession: capabilityTransportSession,
+									})
+								) {
+									// Rotate the receiver grant/challenge before requesting Full. A
+									// sender rebuilt from no state starts at sequence one, which an
+									// active receiver's old sequence fence must otherwise reject.
+									this._v2Receive.advanceRecovery({
+										peerHash: receiveFromHash,
+										peerSession: receiveSession,
+										receiveEpoch:
+											this._peerSessions.receiveEpoch(receiveFromHash),
+									});
+								}
 							} else if (observed && receiveSession === null) {
 								// A capability can arrive before the sender's topic Subscribe after
 								// reconnect. Ask that authenticated peer for its authoritative
@@ -24327,8 +24378,11 @@ export class SharedLog<
 		throwIfInactive();
 	}
 
-	private nudgePersistedReceiptPeerReadiness(publicKey: PublicSignKey): void {
-		if (this.closed) return;
+	private nudgePersistedReceiptPeerReadiness(
+		publicKey: PublicSignKey,
+		signal: AbortSignal,
+	): void {
+		if (this.closed || signal.aborted) return;
 		const peerHash = publicKey.hashcode();
 		const peerSession = this._peerSessions.current(peerHash);
 		if (
@@ -24359,6 +24413,22 @@ export class SharedLog<
 			peerSession,
 			receiveEpoch,
 		});
+		const receiptTarget = this.persistedReceiptPeerSession(peerHash);
+		if (
+			receiptTarget &&
+			!this._v2Send.hasCurrentStateForPeer({
+				peerHash,
+				peerSession: receiptTarget.peerSession,
+				receiverTransportSession: receiptTarget.capabilitySession,
+			})
+		) {
+			this._v2Receive.reAdvertiseLocalCapabilityForRemoteFull({
+				peerHash,
+				peerSession: receiptTarget.peerSession,
+				receiveEpoch: receiptTarget.receiveEpoch,
+				signal,
+			});
+		}
 		this.scheduleReplicationInfoV2Recovery(publicKey);
 	}
 
@@ -24627,18 +24697,26 @@ export class SharedLog<
 				throw new AbortError("Persisted-receipt readiness wait settled");
 			}
 		};
+		const recoveryDelayMs = Math.max(
+			50,
+			Math.min(1_000, this.waitForReplicatorRequestIntervalMs),
+		);
 		const armRecoveryTick = () => {
 			if (settled || recoveryTimer) return;
-			const delayMs = Math.max(
-				50,
-				Math.min(1_000, this.waitForReplicatorRequestIntervalMs),
-			);
 			recoveryTimer = setTimeout(() => {
 				recoveryTimer = undefined;
 				if (!continueWait()) return;
-				this.nudgePersistedReceiptPeerReadiness(key);
+				this.nudgePersistedReceiptPeerReadiness(key, operationSignal);
+				if (checkInFlight) {
+					// Confirmation can legitimately span several recovery intervals.
+					// Keep repairing the exact current generation without aborting its
+					// one application-confirmation waiter on every tick.
+					rerun = true;
+					armRecoveryTick();
+					return;
+				}
 				scheduleCheck();
-			}, delayMs);
+			}, recoveryDelayMs);
 			recoveryTimer.unref?.();
 		};
 		const runCheck = async () => {
@@ -24671,6 +24749,11 @@ export class SharedLog<
 				) {
 					const target = this.persistedReceiptPeerSession(peerHash);
 					if (target) {
+						// A confirmation waiter cannot create an outbound V2 stream when
+						// that exact session state is missing. Nudge first, then keep the
+						// recovery tick alive while the single confirmation wait remains.
+						this.nudgePersistedReceiptPeerReadiness(key, operationSignal);
+						armRecoveryTick();
 						const currentConfirmationController = new AbortController();
 						confirmationController = currentConfirmationController;
 						try {
@@ -24715,7 +24798,7 @@ export class SharedLog<
 					}
 				}
 				if (!continueWait()) return;
-				this.nudgePersistedReceiptPeerReadiness(key);
+				this.nudgePersistedReceiptPeerReadiness(key, operationSignal);
 			} catch (error) {
 				if (!settled) reject(error);
 			} finally {

package/src/replication-info-v2-receive.ts

@@ -112,6 +112,11 @@ export type ReplicationInfoV2LocalCapabilityAdvertisement = {
 	firstAttempt?: Promise<void>;
 };
 
+type ReplicationInfoV2RemoteFullRearm = {
+	lastAttemptAt: number;
+	inFlight?: Promise<void>;
+};
+
 export type ReplicationInfoV2LocalCapabilityRefresh = {
 	receiverTransportSession: bigint;
 	requestNotBeforeMs: number;
@@ -183,6 +188,7 @@ export type ReplicationInfoV2ReceiveDeps = {
 		peerSession: object;
 		receiveEpoch: object | null;
 		signal: AbortSignal;
+		requestRemoteFullRearm?: boolean;
 	}) => Promise<ReplicationInfoV2LocalCapabilityRefresh | undefined>;
 	onRequestError?: (error: unknown) => void;
 	onLocalCapabilityError?: (error: unknown) => void;
@@ -217,6 +223,7 @@ export class ReplicationInfoV2ReceiveCoordinator {
 		string,
 		ReplicationInfoV2LocalCapabilityAdvertisement
 	>;
+	_remoteFullRearmBySession!: WeakMap<object, ReplicationInfoV2RemoteFullRearm>;
 	_reservedAdmissionsByPeer!: Map<string, ReplicationInfoV2ReceiveAdmission>;
 
 	private readonly now: () => number;
@@ -243,6 +250,7 @@ export class ReplicationInfoV2ReceiveCoordinator {
 		this._localCapabilityReadyBySession = new WeakMap();
 		this._localCapabilityContextBySession = new WeakMap();
 		this._localCapabilityAdvertisementsByPeer = new Map();
+		this._remoteFullRearmBySession = new WeakMap();
 		this._reservedAdmissionsByPeer = new Map();
 	}
 
@@ -253,6 +261,7 @@ export class ReplicationInfoV2ReceiveCoordinator {
 		this._localCapabilityReadyBySession = new WeakMap();
 		this._localCapabilityContextBySession = new WeakMap();
 		this._localCapabilityAdvertisementsByPeer = new Map();
+		this._remoteFullRearmBySession = new WeakMap();
 		this._reservedAdmissionsByPeer = new Map();
 	}
 
@@ -270,6 +279,7 @@ export class ReplicationInfoV2ReceiveCoordinator {
 		this._cutoverPeerSessions = new WeakSet();
 		this._localCapabilityReadyBySession = new WeakMap();
 		this._localCapabilityContextBySession = new WeakMap();
+		this._remoteFullRearmBySession = new WeakMap();
 	}
 
 	clearPeer(peerHash: string, expectedSession?: object): void {
@@ -291,6 +301,7 @@ export class ReplicationInfoV2ReceiveCoordinator {
 		if (expectedSession) {
 			this._localCapabilityReadyBySession.delete(expectedSession);
 			this._localCapabilityContextBySession.delete(expectedSession);
+			this._remoteFullRearmBySession.delete(expectedSession);
 			this._cutoverPeerSessions.delete(expectedSession);
 		}
 	}
@@ -625,6 +636,117 @@ export class ReplicationInfoV2ReceiveCoordinator {
 		};
 	}
 
+	/**
+	 * Send one transient, authenticated rearm hint for the exact current local
+	 * receive grant. The hint asks a patched remote receiver to rotate its
+	 * challenge and issue another Full request, rebuilding an outbound sender
+	 * stream that was lost while both directions otherwise remained current.
+	 *
+	 * This deliberately does not mutate the steady advertisement worker. One
+	 * attempt is coalesced per PeerSession and bound to the caller's signal; the
+	 * readiness wait's bounded recovery tick decides whether another attempt is
+	 * needed.
+	 */
+	reAdvertiseLocalCapabilityForRemoteFull(properties: {
+		peerHash: string;
+		peerSession: object;
+		receiveEpoch: object | null;
+		signal: AbortSignal;
+	}): boolean {
+		const context = this._localCapabilityContextBySession.get(
+			properties.peerSession,
+		);
+		const ready = this._localCapabilityReadyBySession.get(
+			properties.peerSession,
+		);
+		if (
+			properties.signal.aborted ||
+			!context ||
+			context.peerHash !== properties.peerHash ||
+			context.lifecycleSignal.aborted ||
+			this.deps.isClosed() ||
+			!this.deps.isPeerStateCurrent(
+				properties.peerHash,
+				properties.peerSession,
+				properties.receiveEpoch,
+			) ||
+			!ready ||
+			ready.peerHash !== properties.peerHash ||
+			ready.receiveEpoch !== properties.receiveEpoch ||
+			ready.receiverTransportSession !== this.deps.getReceiverTransportSession()
+		) {
+			return false;
+		}
+
+		const now = this.now();
+		let rearm = this._remoteFullRearmBySession.get(properties.peerSession);
+		if (rearm?.inFlight) {
+			return true;
+		}
+		if (
+			rearm !== undefined &&
+			now - rearm.lastAttemptAt < this.requestRetryMs
+		) {
+			return true;
+		}
+		if (!rearm) {
+			rearm = { lastAttemptAt: now };
+			this._remoteFullRearmBySession.set(properties.peerSession, rearm);
+		} else {
+			rearm.lastAttemptAt = now;
+		}
+
+		const operationSignal = AbortSignal.any([
+			context.lifecycleSignal,
+			properties.signal,
+		]);
+		let operation: Promise<void>;
+		const detach = () => {
+			if (rearm?.inFlight === operation) {
+				rearm.inFlight = undefined;
+			}
+		};
+		operation = Promise.resolve()
+			.then(() => {
+				if (operationSignal.aborted) {
+					throw operationSignal.reason;
+				}
+				return this.deps.refreshLocalCapability({
+					peerHash: properties.peerHash,
+					target: context.target,
+					peerSession: properties.peerSession,
+					receiveEpoch: properties.receiveEpoch,
+					signal: operationSignal,
+					requestRemoteFullRearm: true,
+				});
+			})
+			.then(() => undefined)
+			.catch((error) => {
+				if (
+					!operationSignal.aborted &&
+					!this.deps.isClosed() &&
+					this.deps.isPeerStateCurrent(
+						properties.peerHash,
+						properties.peerSession,
+						properties.receiveEpoch,
+					)
+				) {
+					this.deps.onLocalCapabilityError?.(error);
+				}
+			})
+			.finally(() => {
+				operationSignal.removeEventListener("abort", detach);
+				detach();
+			});
+		rearm.inFlight = operation;
+		operationSignal.addEventListener("abort", detach, { once: true });
+		if (operationSignal.aborted) {
+			detach();
+		}
+		void operation;
+		return true;
+	}
+
 	private promoteLocalCapabilityAdvertisement(
 		state: ReplicationInfoV2LocalCapabilityAdvertisement,
 	): boolean {

package/src/replication-info-v2-send.ts

@@ -561,6 +561,22 @@ export class ReplicationInfoV2SendCoordinator<R extends "u32" | "u64"> {
 		);
 	}
 
+	/**
+	 * Whether the exact current destination generation already has an outbound
+	 * V2 stream. A missing/stale stream cannot be repaired by confirmation
+	 * retries alone: the remote receiver must issue another Full request first.
+	 */
+	hasCurrentStateForPeer(target: ApplicationConfirmationTarget): boolean {
+		const state = this._sendStates.get(target.peerHash);
+		return (
+			state !== undefined &&
+			state.peerSession === target.peerSession &&
+			state.receiverTransportSession === target.receiverTransportSession &&
+			this.isCurrent(state) &&
+			this.supportsApplicationConfirmation(state)
+		);
+	}
+
 	private trackRetiringWorker(state: ReplicationInfoV2SendState): void {
 		const worker = state.worker;
 		if (!worker) {