@peerbit/shared-log 13.2.34 → 13.2.36

package/src/replication-announcement.ts

@@ -204,9 +204,10 @@ export type ReplicationAnnouncementDeps<R extends "u32" | "u64"> = {
 	// Owner-routed so coordinator spies keep observing re-entrant queueing.
 	queueCurrentReplicationStateAnnouncementRepair: () => void;
 	queueCurrentReplicationStateAnnouncementRetry: (error: unknown) => boolean;
-	// Best-effort sidecar. The legacy publish remains the primary operation and
-	// retains its exact rejection/retry semantics during mixed-version rollout.
+	// V2 is always current. Legacy publication is enabled only for an explicit
+	// compatibility open and retains its exact rejection/retry semantics there.
 	enqueueReplicationInfoV2: (message: LegacyReplicationInfoMessage) => void;
+	isLegacyReplicationInfoEnabled: () => boolean;
 };
 
 type LegacyReplicationInfoMessage =
@@ -270,6 +271,7 @@ export class ReplicationAnnouncementCoordinator<R extends "u32" | "u64"> {
 
 	queueCurrentReplicationStateAnnouncementRetry(error: unknown): boolean {
 		if (
+			!this.deps.isLegacyReplicationInfoEnabled() ||
 			this.deps.isClosed() ||
 			this.deps.getCloseSignal().aborted ||
 			this._replicationAnnouncementRetryController.signal.aborted ||
@@ -362,6 +364,7 @@ export class ReplicationAnnouncementCoordinator<R extends "u32" | "u64"> {
 
 	queueCurrentReplicationStateAnnouncementRepair(): void {
 		if (
+			!this.deps.isLegacyReplicationInfoEnabled() ||
 			this.deps.isClosed() ||
 			this.deps.getCloseSignal().aborted ||
 			this._replicationAnnouncementRepairController.signal.aborted ||
@@ -437,6 +440,11 @@ export class ReplicationAnnouncementCoordinator<R extends "u32" | "u64"> {
 	async repairCurrentReplicationStateAnnouncement(
 		context?: ReplicationAnnouncementRepairWorkerContext,
 	): Promise<void> {
+		if (!this.deps.isLegacyReplicationInfoEnabled()) {
+			this._announcementRepairBinding.pending = false;
+			this._announcementRepairBinding.targets.clear();
+			return;
+		}
 		if (!this._announcementRepairBinding.pending) {
 			return;
 		}
@@ -645,6 +653,9 @@ export class ReplicationAnnouncementCoordinator<R extends "u32" | "u64"> {
 				this.rotateAnnouncementSession();
 				this.advanceCurrentReplicationStateAnnouncementRepairGeneration();
 				this.deps.enqueueReplicationInfoV2(message);
+				if (!this.deps.isLegacyReplicationInfoEnabled()) {
+					return;
+				}
 				try {
 					await this.deps.getRpc().send(message, {
 						priority: CONVERGENCE_MESSAGE_PRIORITY,
@@ -677,6 +688,10 @@ export class ReplicationAnnouncementCoordinator<R extends "u32" | "u64"> {
 	}
 
 	async retryCurrentReplicationStateAnnouncement(): Promise<void> {
+		if (!this.deps.isLegacyReplicationInfoEnabled()) {
+			this._replicationAnnouncementRetryPending = false;
+			return;
+		}
 		const session = this._announcementSession;
 		const controller = this._replicationAnnouncementRetryController;
 		try {

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

@@ -991,6 +991,83 @@ export class ReplicationInfoV2ReceiveCoordinator {
 		return true;
 	}
 
+	/**
+	 * Whether the request generation for this exact peer state is parked: the
+	 * bounded retry cycle exhausted its attempts and no timer or send is in
+	 * flight. Read-only probe for the host's recovery scheduler.
+	 */
+	isRequestParked(properties: {
+		peerHash: string;
+		peerSession: object;
+		receiveEpoch: object | null;
+	}): boolean {
+		const state = this._receiveStates.get(properties.peerHash);
+		return (
+			state !== undefined &&
+			state.peerSession === properties.peerSession &&
+			state.receiveEpoch === properties.receiveEpoch &&
+			state.phase !== "active" &&
+			state.requestParked &&
+			state.requestTimer === undefined &&
+			state.requestInFlight === undefined
+		);
+	}
+
+	/**
+	 * Resume only a request generation that exhausted its bounded retries.
+	 * Wait/liveness callers may nudge recovery without invalidating an active,
+	 * timed or in-flight request and without advancing the receive epoch.
+	 */
+	resumeParkedRequest(properties: {
+		peerHash: string;
+		peerSession: object;
+		receiveEpoch: object | null;
+	}): boolean {
+		const state = this._receiveStates.get(properties.peerHash);
+		if (
+			!state ||
+			state.peerSession !== properties.peerSession ||
+			state.receiveEpoch !== properties.receiveEpoch ||
+			!this.deps.isPeerStateCurrent(
+				properties.peerHash,
+				properties.peerSession,
+				properties.receiveEpoch,
+			) ||
+			state.phase === "active" ||
+			!state.requestParked ||
+			state.requestTimer !== undefined ||
+			state.requestInFlight !== undefined ||
+			this._reservedAdmissionsByPeer.has(properties.peerHash) ||
+			state.receiverBinding === undefined ||
+			state.lastSequence === MAX_U64
+		) {
+			return false;
+		}
+		state.requestAttempts = 0;
+		state.requestsSinceCapabilityRefresh = 0;
+		if (!state.capabilityRefreshRequired) {
+			// Only rotate the grant when it is genuinely stale: the peer's
+			// capability rotation paths already flagged a refresh, and a missing
+			// or transport-outdated local grant cannot authorize a request. A
+			// still-current grant must keep its challenge so a Full already in
+			// flight for the pre-park request generation still applies.
+			const ready = this._localCapabilityReadyBySession.get(state.peerSession);
+			const grantCurrent =
+				ready !== undefined &&
+				ready.peerHash === state.peerHash &&
+				ready.receiveEpoch === state.receiveEpoch &&
+				ready.receiverTransportSession === state.receiverTransportSession &&
+				ready.receiverTransportSession ===
+					this.deps.getReceiverTransportSession();
+			if (!grantCurrent) {
+				state.capabilityRefreshRequired = true;
+			}
+		}
+		state.requestParked = false;
+		this.armRequest(state, 0);
+		return true;
+	}
+
 	private transitionToResync(
 		state: ReplicationInfoV2ReceiveState,
 		options?: { force?: boolean; refreshCapability?: boolean },
@@ -1154,6 +1231,14 @@ export class ReplicationInfoV2ReceiveCoordinator {
 		const { state } = admission;
 		this._reservedAdmissionsByPeer.set(peerHash, admission);
 		state.reservedAdmission = admission;
+		if (state.requestTimer) {
+			clearTimeout(state.requestTimer);
+			state.requestTimer = undefined;
+		}
+		if (state.legacyFallbackTimer) {
+			clearTimeout(state.legacyFallbackTimer);
+			state.legacyFallbackTimer = undefined;
+		}
 		return admission;
 	}
 
@@ -1174,6 +1259,30 @@ export class ReplicationInfoV2ReceiveCoordinator {
 				(currentState !== state && currentState.phase !== "active"))
 		) {
 			this.transitionToResync(currentState, { force: true });
+		} else if (
+			currentState === state &&
+			!admission.committed &&
+			this.isStateCurrent(state) &&
+			state.phase !== "active" &&
+			state.requestTimer === undefined &&
+			state.requestInFlight === undefined &&
+			!state.requestParked
+		) {
+			// Reserving a Full pauses this generation's retry timer. If its host
+			// apply lane releases without committing, restore the bounded request
+			// worker so the exact current generation cannot become stranded.
+			this.armRequest(state, 0);
+		}
+		if (
+			currentState === state &&
+			this.isStateCurrent(state) &&
+			state.phase === "active" &&
+			state.legacyFallbackFingerprint !== undefined
+		) {
+			// A reservation also pauses compat sidecar recovery. Matching commits
+			// clear the evidence; an uncommitted or non-matching frame restores its
+			// bounded fallback without invalidating work in the host apply lane.
+			this.armLegacyFallback(state);
 		}
 	}
 
@@ -1281,6 +1390,19 @@ export class ReplicationInfoV2ReceiveCoordinator {
 		if (state.legacyFallbackTimer) {
 			return true;
 		}
+		this.armLegacyFallback(state);
+		return true;
+	}
+
+	private armLegacyFallback(state: ReplicationInfoV2ReceiveState): void {
+		if (
+			state.legacyFallbackTimer ||
+			state.phase !== "active" ||
+			state.legacyFallbackFingerprint === undefined ||
+			this._reservedAdmissionsByPeer.has(state.peerHash)
+		) {
+			return;
+		}
 		state.legacyFallbackTimer = setTimeout(() => {
 			state.legacyFallbackTimer = undefined;
 			if (this.isStateCurrent(state) && state.phase === "active") {
@@ -1291,7 +1413,6 @@ export class ReplicationInfoV2ReceiveCoordinator {
 			}
 		}, this.legacyFallbackDelayMs);
 		state.legacyFallbackTimer.unref?.();
-		return true;
 	}
 
 	private clearLegacyFallback(state: ReplicationInfoV2ReceiveState): void {
@@ -1418,8 +1539,7 @@ export class ReplicationInfoV2ReceiveCoordinator {
 			this._receiveStates.get(state.peerHash) !== state ||
 			state.controller.signal.aborted ||
 			this.deps.isClosed() ||
-			(this._reservedAdmissionsByPeer.has(state.peerHash) &&
-				this._reservedAdmissionsByPeer.get(state.peerHash)?.state !== state) ||
+			this._reservedAdmissionsByPeer.has(state.peerHash) ||
 			state.receiverBinding === undefined ||
 			state.phase === "active" ||
 			state.requestParked ||
@@ -1449,6 +1569,7 @@ export class ReplicationInfoV2ReceiveCoordinator {
 	private async refreshGrant(
 		state: ReplicationInfoV2ReceiveState,
 	): Promise<boolean> {
+		const version = state.version;
 		const refreshed = await this.deps.refreshLocalCapability({
 			peerHash: state.peerHash,
 			target: state.target,
@@ -1458,6 +1579,8 @@ export class ReplicationInfoV2ReceiveCoordinator {
 		});
 		if (
 			!refreshed ||
+			state.version !== version ||
+			this._reservedAdmissionsByPeer.has(state.peerHash) ||
 			!this.isStateCurrent(state) ||
 			this.deps.getReceiverTransportSession() !==
 				refreshed.receiverTransportSession
@@ -1489,7 +1612,10 @@ export class ReplicationInfoV2ReceiveCoordinator {
 		if (state.requestInFlight) {
 			return;
 		}
-		if (!this.isStateCurrent(state)) {
+		if (
+			!this.isStateCurrent(state) ||
+			this._reservedAdmissionsByPeer.has(state.peerHash)
+		) {
 			return;
 		}
 		if (
@@ -1512,7 +1638,10 @@ export class ReplicationInfoV2ReceiveCoordinator {
 					return;
 				}
 			}
-			if (!this.isStateCurrent(state)) {
+			if (
+				!this.isStateCurrent(state) ||
+				this._reservedAdmissionsByPeer.has(state.peerHash)
+			) {
 				return;
 			}
 			const ready = this._localCapabilityReadyBySession.get(state.peerSession);
@@ -1558,6 +1687,7 @@ export class ReplicationInfoV2ReceiveCoordinator {
 				if (
 					this._receiveStates.get(state.peerHash) === state &&
 					!state.controller.signal.aborted &&
+					!this._reservedAdmissionsByPeer.has(state.peerHash) &&
 					!state.requestTimer &&
 					state.phase !== "active"
 				) {

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

@@ -649,7 +649,27 @@ export class ReplicationInfoV2SendCoordinator<R extends "u32" | "u64"> {
 				sends.push(Promise.reject(error));
 			}
 		}
-		await Promise.allSettled(sends);
+		if (sends.length === 0 || signal.aborted) {
+			return;
+		}
+
+		// Terminal reset is best-effort and the caller owns its close/drop bound.
+		// A transport is expected to observe the signal, but a disconnected
+		// acknowledgement path can leave its promise pending indefinitely. Do not
+		// let such a transport retain the whole terminal operation past the bound.
+		await new Promise<void>((resolve) => {
+			let finished = false;
+			const finish = () => {
+				if (finished) return;
+				finished = true;
+				signal.removeEventListener("abort", finish);
+				resolve();
+			};
+			signal.addEventListener("abort", finish, { once: true });
+			void Promise.allSettled(sends).then(finish);
+			// Close the check/listener race if the caller aborted synchronously.
+			if (signal.aborted) finish();
+		});
 	}
 
 	async drain(signal?: AbortSignal): Promise<void> {

package/src/sync/factory.ts

@@ -114,7 +114,7 @@ export function createSyncronizer<R extends "u32" | "u64">(
 			sendRawExchangeHeads: props.sendRawExchangeHeads,
 		});
 	} else {
-		if (props.compatibility && props.compatibility < 10) {
+		if (props.compatibility !== undefined && props.compatibility < 10) {
 			return new SimpleSyncronizer({
 				log: props.log,
 				rpc: props.rpc,