@peerbit/shared-log 10.3.2-6b5241d → 10.3.2

package/src/index.ts

@@ -694,32 +694,27 @@ export class SharedLog<
 
 					// also merge segments that are already in the index
 					if (this.domain.canMerge) {
-						const mergeRangesThatAlreadyExist = await getAllMergeCandiates(
+						const mergable = await getAllMergeCandiates(
 							this.replicationIndex,
 							range,
 							this.indexableDomain.numbers,
 						);
-						const mergeableFiltered: ReplicationRangeIndexable<R>[] = [];
+						const mergeableFiltered: ReplicationRangeIndexable<R>[] = [range];
 
-						for (const [_key, mergeCandidate] of mergeRangesThatAlreadyExist) {
+						for (const mergeCandidate of mergable) {
 							if (this.domain.canMerge(mergeCandidate, range)) {
 								mergeableFiltered.push(mergeCandidate);
+								if (mergeCandidate.idString !== range.idString) {
+									rangesToUnreplicate.push(mergeCandidate);
+								}
 							}
 						}
-
-						mergeableFiltered.push(range); // * we push this last, because mergeRanges will reuse ids of the first elements
 						if (mergeableFiltered.length > 1) {
-							// ** this is important here as we want to reuse ids of what we already persist, not the new ranges, so we dont get a delet add op, but just a update op
 							range = mergeRanges(
 								mergeableFiltered,
 								this.indexableDomain.numbers,
 							);
 						}
-						for (const [_key, mergeCandidate] of mergeRangesThatAlreadyExist) {
-							if (mergeCandidate.idString !== range.idString) {
-								rangesToUnreplicate.push(mergeCandidate);
-							}
-						}
 					}
 					rangesToReplicate = [range];
 				}
@@ -1010,9 +1005,6 @@ export class SharedLog<
 				this.pendingMaturity.delete(from.hashcode());
 			}
 		}
-		if (ranges.length === 0) {
-			throw new Error("???");
-		}
 
 		await this.replicationIndex.del({
 			query: new Or(
@@ -1311,29 +1303,24 @@ export class SharedLog<
 			logger.warn("Not allowed to replicate by canReplicate");
 		}
 
+		let message: AllReplicatingSegmentsMessage | AddedReplicationSegmentMessage;
+
 		if (change) {
-			let addedOrReplaced = change.filter((x) => x.type !== "removed");
-			if (addedOrReplaced.length > 0) {
-				let message:
-					| AllReplicatingSegmentsMessage
-					| AddedReplicationSegmentMessage
-					| undefined = undefined;
-				if (options.reset) {
-					message = new AllReplicatingSegmentsMessage({
-						segments: addedOrReplaced.map((x) => x.range.toReplicationRange()),
-					});
-				} else {
-					message = new AddedReplicationSegmentMessage({
-						segments: addedOrReplaced.map((x) => x.range.toReplicationRange()),
-					});
-				}
-				if (options.announce) {
-					return options.announce(message);
-				} else {
-					await this.rpc.send(message, {
-						priority: 1,
-					});
-				}
+			if (options.reset) {
+				message = new AllReplicatingSegmentsMessage({
+					segments: range.map((x) => x.toReplicationRange()),
+				});
+			} else {
+				message = new AddedReplicationSegmentMessage({
+					segments: range.map((x) => x.toReplicationRange()),
+				});
+			}
+			if (options.announce) {
+				return options.announce(message);
+			} else {
+				await this.rpc.send(message, {
+					priority: 1,
+				});
 			}
 		}
 	}
@@ -2297,7 +2284,10 @@ export class SharedLog<
 					}
 
 					if (isLeader) {
+						//console.log("IS  LEADER", this.node.identity.publicKey.hashcode(), hash);
+
 						hasAndIsLeader.push(hash);
+
 						hasAndIsLeader.length > 0 &&
 							this.responseToPruneDebouncedFn.add({
 								hashes: hasAndIsLeader,
@@ -2494,7 +2484,6 @@ export class SharedLog<
 					msg.segmentIds,
 					context.from,
 				);
-
 				await this.removeReplicationRanges(rangesToRemove, context.from);
 				const timestamp = BigInt(+new Date());
 				for (const range of rangesToRemove) {
@@ -3646,6 +3635,7 @@ export class SharedLog<
 						});
 					}
 
+					// console.log("DELETE RESPONSE AS LEADER", this.node.identity.publicKey.hashcode(), entryReplicated.hash)
 					this.responseToPruneDebouncedFn.delete(entryReplicated.hash); // don't allow others to prune because of expecting me to replicating this entry
 				} else {
 					this.pruneDebouncedFn.delete(entryReplicated.hash);

package/src/ranges.ts

@@ -1019,112 +1019,68 @@ export const mergeRanges = <R extends "u32" | "u64">(
 		throw new Error("Segments have different publicKeyHash");
 	}
 
-	// 1) Sort by start offset (avoid subtracting bigints).
-	//    We do slice() to avoid mutating the original 'segments'.
-	const sorted = segments.slice().sort((a, b) => {
-		if (a.start1 < b.start1) return -1;
-		if (a.start1 > b.start1) return 1;
-		return 0;
-	});
-
-	// 2) Merge overlapping arcs in a purely functional way
-	//    so we don’t mutate any intermediate objects.
-	const merged = sorted.reduce<ReplicationRangeIndexable<R>[]>(
-		(acc, current) => {
-			if (acc.length === 0) {
-				return [current];
+	const sorted = segments.sort((a, b) => Number(a.start1 - b.start1));
+
+	let calculateLargeGap = (): [
+		NumberFromType<R>,
+		number,
+		ReplicationIntent,
+	] => {
+		let last = sorted[sorted.length - 1];
+		let largestArc = numbers.zero;
+		let largestArcIndex = -1;
+		let mode = ReplicationIntent.NonStrict;
+		for (let i = 0; i < sorted.length; i++) {
+			const current = sorted[i];
+
+			if (current.mode === ReplicationIntent.Strict) {
+				mode = ReplicationIntent.Strict;
 			}
 
-			const last = acc[acc.length - 1];
-
-			// Check overlap: next arc starts before (or exactly at) last arc's end => overlap
-			if (current.start1 <= last.end2) {
-				// Merge them:
-				// - end2 is the max of last.end2 and current.end2
-				// - width is adjusted so total covers both
-				// - mode is strict if either arc is strict
-				const newEnd2 = last.end2 > current.end2 ? last.end2 : current.end2;
-				const extendedWidth = Number(newEnd2 - last.start1); // safe if smaller arcs
-
-				// If you need to handle big widths carefully, you might do BigInt logic here.
-				const newMode =
-					last.mode === ReplicationIntent.Strict ||
-					current.mode === ReplicationIntent.Strict
-						? ReplicationIntent.Strict
-						: ReplicationIntent.NonStrict;
-
-				// Create a new merged arc object (no mutation of last)
-				const proto = segments[0].constructor as any;
-				const mergedArc = new proto({
-					width: extendedWidth,
-					offset: last.start1,
-					publicKeyHash: last.hash,
-					mode: newMode,
-					id: last.id, // re-use id
-				});
-
-				// Return a new array with the last item replaced by mergedArc
-				return [...acc.slice(0, -1), mergedArc];
-			} else {
-				// No overlap => just append current
-				return [...acc, current];
-			}
-		},
-		[],
-	);
+			if (current.start1 !== last.start1) {
+				let arc = numbers.zero;
+				if (current.start1 < last.end2) {
+					arc += ((numbers.maxValue as any) - last.end2) as any;
 
-	// After the merge pass:
-	if (merged.length === 1) {
-		// Everything merged into one arc already
-		return merged[0];
-	}
-
-	// 3) OPTIONAL: If your existing logic always wants to produce a single ring arc
-	//    that covers "everything except the largest gap," do it here:
-
-	// Determine if any arc ended up Strict
-	const finalMode = merged.some((m) => m.mode === ReplicationIntent.Strict)
-		? ReplicationIntent.Strict
-		: ReplicationIntent.NonStrict;
-
-	// Find the largest gap on a ring among these disjoint arcs
-	const { largestGap, largestGapIndex } = merged.reduce<{
-		largestGap: NumberFromType<R>;
-		largestGapIndex: number;
-	}>(
-		(acc, arc, i, arr) => {
-			// next arc in a ring
-			const nextArc = arr[(i + 1) % arr.length];
-
-			// measure gap from arc.end2 -> nextArc.start1
-			let gap: NumberFromType<R>;
-			if (nextArc.start1 < arc.end2) {
-				// wrap-around scenario
-				gap = (numbers.maxValue -
-					arc.end2 +
-					(nextArc.start1 - numbers.zero)) as NumberFromType<R>;
-			} else {
-				gap = (nextArc.start1 - arc.end2) as NumberFromType<R>;
-			}
+					arc += (current.start1 - numbers.zero) as any;
+				} else {
+					arc += (current.start1 - last.end2) as any;
+				}
 
-			if (gap > acc.largestGap) {
-				return { largestGap: gap, largestGapIndex: (i + 1) % arr.length };
+				if (arc > largestArc) {
+					largestArc = arc;
+					largestArcIndex = i;
+				}
 			}
-			return acc;
-		},
-		{ largestGap: numbers.zero, largestGapIndex: -1 },
-	);
+			last = current;
+		}
+
+		return [largestArc, largestArcIndex, mode];
+	};
+	const [largestArc, largestArcIndex, mode] = calculateLargeGap();
+
+	let totalLengthFinal: number = numbers.maxValue - largestArc;
 
-	// Single arc coverage = "the ring minus largestGap"
-	const totalCoverage = (numbers.maxValue - largestGap) as number;
-	const offset = merged[largestGapIndex].start1;
+	const proto = segments[0].constructor;
 
-	const proto = segments[0].constructor as any;
-	return new proto({
-		width: totalCoverage,
-		offset,
+	if (largestArcIndex === -1) {
+		if (mode !== segments[0].mode) {
+			return new (proto as any)({
+				width: segments[0].width,
+				offset: segments[0].start1,
+				publicKeyHash: segments[0].hash,
+				mode,
+			});
+		}
+		return segments[0]; // all ranges are the same
+	}
+	// use segments[0] constructor to create a new object
+
+	return new (proto as any)({
+		width: totalLengthFinal,
+		offset: segments[largestArcIndex].start1,
 		publicKeyHash: segments[0].hash,
-		mode: finalMode,
+		mode,
 	});
 };
 
@@ -1846,7 +1802,7 @@ export const getAllMergeCandiates = async <R extends "u32" | "u64">(
 		id: Uint8Array;
 	},
 	numbers: Numbers<R>,
-): Promise<Map<string, ReplicationRangeIndexable<R>>> => {
+): Promise<MapIterator<ReplicationRangeIndexable<R>>> => {
 	const adjacent = await getAdjecentSameOwner(peers, range, numbers);
 	const covering = await getCoveringRangesSameOwner(peers, range).all();
 
@@ -1860,7 +1816,7 @@ export const getAllMergeCandiates = async <R extends "u32" | "u64">(
 	for (const range of covering) {
 		ret.set(range.value.idString, range.value);
 	}
-	return ret;
+	return ret.values();
 };
 
 export const isMatured = (