@peerbit/shared-log 12.3.1 → 12.3.2

package/src/index.ts

@@ -2445,35 +2445,35 @@ export class SharedLog<
 				set.add(key);
 			}
 
-				if (options?.reachableOnly) {
-					// Prefer the live pubsub subscriber set when filtering reachability.
-					// `uniqueReplicators` is primarily driven by replication messages and can lag during
-					// joins/restarts; using subscribers prevents excluding peers that are reachable but
-					// whose replication ranges were loaded from disk or haven't been processed yet.
-					const subscribers =
-						(await this.node.services.pubsub.getSubscribers(this.topic)) ??
-						undefined;
-					const subscriberHashcodes = subscribers
-						? new Set(subscribers.map((key) => key.hashcode()))
-						: undefined;
+			if (options?.reachableOnly) {
+				// Prefer the live pubsub subscriber set when filtering reachability.
+				// `uniqueReplicators` is primarily driven by replication messages and can lag during
+				// joins/restarts; using subscribers prevents excluding peers that are reachable but
+				// whose replication ranges were loaded from disk or haven't been processed yet.
+				const subscribers =
+					(await this.node.services.pubsub.getSubscribers(this.topic)) ??
+					undefined;
+				const subscriberHashcodes = subscribers
+					? new Set(subscribers.map((key) => key.hashcode()))
+					: undefined;
 
-					const reachable: string[] = [];
-					const selfHash = this.node.identity.publicKey.hashcode();
-					for (const peer of set) {
-						if (peer === selfHash) {
-							reachable.push(peer);
-							continue;
-						}
-						if (
-							subscriberHashcodes
-								? subscriberHashcodes.has(peer)
-								: this.uniqueReplicators.has(peer)
-						) {
-							reachable.push(peer);
-						}
+				const reachable: string[] = [];
+				const selfHash = this.node.identity.publicKey.hashcode();
+				for (const peer of set) {
+					if (peer === selfHash) {
+						reachable.push(peer);
+						continue;
+					}
+					if (
+						subscriberHashcodes
+							? subscriberHashcodes.has(peer)
+							: this.uniqueReplicators.has(peer)
+					) {
+						reachable.push(peer);
 					}
-					return reachable;
 				}
+				return reachable;
+			}
 
 			return [...set];
 		} catch (error) {
@@ -2952,60 +2952,63 @@ export class SharedLog<
 					}
 				}
 			} else if (
-					msg instanceof AllReplicatingSegmentsMessage ||
-					msg instanceof AddedReplicationSegmentMessage
-				) {
-					if (context.from.equals(this.node.identity.publicKey)) {
+				msg instanceof AllReplicatingSegmentsMessage ||
+				msg instanceof AddedReplicationSegmentMessage
+			) {
+				if (context.from.equals(this.node.identity.publicKey)) {
+					return;
+				}
+
+				const replicationInfoMessage = msg as
+					| AllReplicatingSegmentsMessage
+					| AddedReplicationSegmentMessage;
+
+				// Process replication updates even if the sender isn't yet considered "ready" by
+				// `Program.waitFor()`. Dropping these messages can lead to missing replicator info
+				// (and downstream `waitForReplicator()` timeouts) under timing-sensitive joins.
+				const from = context.from!;
+				const messageTimestamp = context.message.header.timestamp;
+				(async () => {
+					const prev = this.latestReplicationInfoMessage.get(from.hashcode());
+					if (prev && prev > messageTimestamp) {
 						return;
 					}
 
-					const replicationInfoMessage = msg as
-						| AllReplicatingSegmentsMessage
-						| AddedReplicationSegmentMessage;
-
-					// Process replication updates even if the sender isn't yet considered "ready" by
-					// `Program.waitFor()`. Dropping these messages can lead to missing replicator info
-					// (and downstream `waitForReplicator()` timeouts) under timing-sensitive joins.
-					const from = context.from!;
-					const messageTimestamp = context.message.header.timestamp;
-					(async () => {
-						const prev = this.latestReplicationInfoMessage.get(from.hashcode());
-						if (prev && prev > messageTimestamp) {
-							return;
-						}
-
-						this.latestReplicationInfoMessage.set(from.hashcode(), messageTimestamp);
+					this.latestReplicationInfoMessage.set(
+						from.hashcode(),
+						messageTimestamp,
+					);
 
-						if (this.closed) {
-							return;
-						}
+					if (this.closed) {
+						return;
+					}
 
-						const reset = msg instanceof AllReplicatingSegmentsMessage;
-						await this.addReplicationRange(
-							replicationInfoMessage.segments.map((x) =>
-								x.toReplicationRangeIndexable(from),
-							),
-							from,
-							{
-								reset,
-								checkDuplicates: true,
-								timestamp: Number(messageTimestamp),
-							},
-						);
-					})().catch((e) => {
-						if (isNotStartedError(e)) {
-							return;
-						}
-						logger.error(
-							`Failed to apply replication settings from '${from.hashcode()}': ${
-								e?.message ?? e
-							}`,
-						);
-					});
-				} else if (msg instanceof StoppedReplicating) {
-					if (context.from.equals(this.node.identity.publicKey)) {
+					const reset = msg instanceof AllReplicatingSegmentsMessage;
+					await this.addReplicationRange(
+						replicationInfoMessage.segments.map((x) =>
+							x.toReplicationRangeIndexable(from),
+						),
+						from,
+						{
+							reset,
+							checkDuplicates: true,
+							timestamp: Number(messageTimestamp),
+						},
+					);
+				})().catch((e) => {
+					if (isNotStartedError(e)) {
 						return;
 					}
+					logger.error(
+						`Failed to apply replication settings from '${from.hashcode()}': ${
+							e?.message ?? e
+						}`,
+					);
+				});
+			} else if (msg instanceof StoppedReplicating) {
+				if (context.from.equals(this.node.identity.publicKey)) {
+					return;
+				}
 
 				const rangesToRemove = await this.resolveReplicationRangesFromIdsAndKey(
 					msg.segmentIds,
@@ -4466,7 +4469,9 @@ export class SharedLog<
 					cpuUsage: this.cpuUsage?.value(),
 				});
 
-				const absoluteDifference = Math.abs(dynamicRange.widthNormalized - newFactor);
+				const absoluteDifference = Math.abs(
+					dynamicRange.widthNormalized - newFactor,
+				);
 				const relativeDifference =
 					absoluteDifference /
 					Math.max(

package/src/ranges.ts

@@ -2255,22 +2255,22 @@ export const getCoverSet = async <R extends "u32" | "u64">(properties: {
 		return next;
 	};
 
-		const resolveNextAbove = async (
-			nextLocation: NumberFromType<R>,
-			roleAge: number,
-		) => {
-			// if not get closest from above
-			const next = await fetchOne<undefined, R>(
-				getClosest("above", peers, nextLocation, true, properties.numbers, {
-					time: {
-						matured: true,
-						roleAgeLimit: roleAge,
-						now,
-					},
-				}),
-			);
-			return next;
-		};
+	const resolveNextAbove = async (
+		nextLocation: NumberFromType<R>,
+		roleAge: number,
+	) => {
+		// if not get closest from above
+		const next = await fetchOne<undefined, R>(
+			getClosest("above", peers, nextLocation, true, properties.numbers, {
+				time: {
+					matured: true,
+					roleAgeLimit: roleAge,
+					now,
+				},
+			}),
+		);
+		return next;
+	};
 
 	const resolveNext = async (
 		nextLocation: NumberFromType<R>,
@@ -2366,7 +2366,8 @@ export const getCoverSet = async <R extends "u32" | "u64">(properties: {
 		current = nextCandidate[0];
 
 		const isLast =
-			distanceBefore < widthToCoverScaled && coveredLength >= widthToCoverScaled;
+			distanceBefore < widthToCoverScaled &&
+			coveredLength >= widthToCoverScaled;
 
 		const lastDistanceToEndLocation = properties.numbers.min(
 			getDistance(
@@ -2642,8 +2643,10 @@ export const mergeReplicationChanges = <R extends NumericType>(
 							const newer = v[j];
 							if (newer.type === "added" && !newer.matured) {
 								adjusted = true;
-								const { rangesFromA: updatedRemoved, rangesFromB: updatedNewer } =
-									symmetricDifferenceRanges(v[i].range, newer.range);
+								const {
+									rangesFromA: updatedRemoved,
+									rangesFromB: updatedNewer,
+								} = symmetricDifferenceRanges(v[i].range, newer.range);
 
 								for (const diff of updatedRemoved) {
 									results.push({

package/src/sync/rateless-iblt.ts

@@ -13,10 +13,7 @@ import type { RPC, RequestContext } from "@peerbit/rpc";
 import { SilentDelivery } from "@peerbit/stream-interface";
 import { type EntryWithRefs } from "../exchange-heads.js";
 import { TransportMessage } from "../message.js";
-import {
-	type EntryReplicated,
-	matchEntriesInRangeQuery,
-} from "../ranges.js";
+import { type EntryReplicated, matchEntriesInRangeQuery } from "../ranges.js";
 import type {
 	SyncableKey,
 	SynchronizerComponents,
@@ -220,9 +217,7 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 		}
 	>;
 
-	constructor(
-		readonly properties: SynchronizerComponents<D>,
-	) {
+	constructor(readonly properties: SynchronizerComponents<D>) {
 		this.simple = new SimpleSyncronizer(properties);
 		this.outgoingSyncProcesses = new Map();
 		this.ingoingSyncProcesses = new Map();
@@ -472,7 +467,10 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 
 		const startSync = new StartSync({ from: start, to: end, symbols: [] });
 		const encoder = new EncoderWrapper();
-		if (typeof BigUint64Array !== "undefined" && sortedEntries instanceof BigUint64Array) {
+		if (
+			typeof BigUint64Array !== "undefined" &&
+			sortedEntries instanceof BigUint64Array
+		) {
 			encoder.add_symbols(sortedEntries);
 		} else {
 			for (const entry of sortedEntries) {

package/src/sync/simple.ts

@@ -16,7 +16,7 @@ import {
 } from "../exchange-heads.js";
 import { TransportMessage } from "../message.js";
 import type { EntryReplicated } from "../ranges.js";
-import type { SyncableKey, SyncOptions, Syncronizer } from "./index.js";
+import type { SyncOptions, SyncableKey, Syncronizer } from "./index.js";
 
 @variant([0, 1])
 export class RequestMaybeSync extends TransportMessage {
@@ -157,13 +157,10 @@ export class SimpleSyncronizer<R extends "u32" | "u64">
 			hashes = [...properties.entries.keys()];
 		}
 
-		return this.rpc.send(
-			new RequestMaybeSync({ hashes }),
-			{
-				priority: 1,
-				mode: new SilentDelivery({ to: properties.targets, redundancy: 1 }),
-			},
-		);
+		return this.rpc.send(new RequestMaybeSync({ hashes }), {
+			priority: 1,
+			mode: new SilentDelivery({ to: properties.targets, redundancy: 1 }),
+		});
 	}
 
 	async onMessage(