@peerbit/shared-log 10.3.2 → 10.3.3-2ec6eb5

package/src/index.ts

@@ -694,27 +694,38 @@ export class SharedLog<
 
 					// also merge segments that are already in the index
 					if (this.domain.canMerge) {
-						const mergable = await getAllMergeCandiates(
+						const mergeRangesThatAlreadyExist = await getAllMergeCandiates(
 							this.replicationIndex,
 							range,
 							this.indexableDomain.numbers,
 						);
-						const mergeableFiltered: ReplicationRangeIndexable<R>[] = [range];
+						const mergeableFiltered: ReplicationRangeIndexable<R>[] = [];
+						const toKeep: Set<string> = new Set();
 
-						for (const mergeCandidate of mergable) {
+						for (const [_key, mergeCandidate] of mergeRangesThatAlreadyExist) {
 							if (this.domain.canMerge(mergeCandidate, range)) {
 								mergeableFiltered.push(mergeCandidate);
-								if (mergeCandidate.idString !== range.idString) {
-									rangesToUnreplicate.push(mergeCandidate);
-								}
+							} else {
+								toKeep.add(mergeCandidate.idString);
 							}
 						}
+
+						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 &&
+								!toKeep.has(mergeCandidate.idString)
+							) {
+								rangesToUnreplicate.push(mergeCandidate);
+							}
+						}
 					}
 					rangesToReplicate = [range];
 				}
@@ -1005,6 +1016,9 @@ export class SharedLog<
 				this.pendingMaturity.delete(from.hashcode());
 			}
 		}
+		if (ranges.length === 0) {
+			throw new Error("???");
+		}
 
 		await this.replicationIndex.del({
 			query: new Or(
@@ -1303,24 +1317,29 @@ export class SharedLog<
 			logger.warn("Not allowed to replicate by canReplicate");
 		}
 
-		let message: AllReplicatingSegmentsMessage | AddedReplicationSegmentMessage;
-
 		if (change) {
-			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,
-				});
+			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,
+					});
+				}
 			}
 		}
 	}
@@ -2284,10 +2303,7 @@ 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,
@@ -2484,6 +2500,7 @@ export class SharedLog<
 					msg.segmentIds,
 					context.from,
 				);
+
 				await this.removeReplicationRanges(rangesToRemove, context.from);
 				const timestamp = BigInt(+new Date());
 				for (const range of rangesToRemove) {
@@ -3635,7 +3652,6 @@ 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,68 +1019,112 @@ export const mergeRanges = <R extends "u32" | "u64">(
 		throw new Error("Segments have different publicKeyHash");
 	}
 
-	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;
-			}
-
-			if (current.start1 !== last.start1) {
-				let arc = numbers.zero;
-				if (current.start1 < last.end2) {
-					arc += ((numbers.maxValue as any) - last.end2) as any;
-
-					arc += (current.start1 - numbers.zero) as any;
-				} else {
-					arc += (current.start1 - last.end2) as any;
-				}
+	// 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;
+	});
 
-				if (arc > largestArc) {
-					largestArc = arc;
-					largestArcIndex = i;
-				}
+	// 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];
 			}
-			last = current;
-		}
 
-		return [largestArc, largestArcIndex, mode];
-	};
-	const [largestArc, largestArcIndex, mode] = calculateLargeGap();
+			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];
+			}
+		},
+		[],
+	);
 
-	let totalLengthFinal: number = numbers.maxValue - largestArc;
+	// 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>;
+			}
 
-	const proto = segments[0].constructor;
+			if (gap > acc.largestGap) {
+				return { largestGap: gap, largestGapIndex: (i + 1) % arr.length };
+			}
+			return acc;
+		},
+		{ largestGap: numbers.zero, largestGapIndex: -1 },
+	);
 
-	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
+	// Single arc coverage = "the ring minus largestGap"
+	const totalCoverage = (numbers.maxValue - largestGap) as number;
+	const offset = merged[largestGapIndex].start1;
 
-	return new (proto as any)({
-		width: totalLengthFinal,
-		offset: segments[largestArcIndex].start1,
+	const proto = segments[0].constructor as any;
+	return new proto({
+		width: totalCoverage,
+		offset,
 		publicKeyHash: segments[0].hash,
-		mode,
+		mode: finalMode,
 	});
 };
 
@@ -1802,7 +1846,7 @@ export const getAllMergeCandiates = async <R extends "u32" | "u64">(
 		id: Uint8Array;
 	},
 	numbers: Numbers<R>,
-): Promise<MapIterator<ReplicationRangeIndexable<R>>> => {
+): Promise<Map<string, ReplicationRangeIndexable<R>>> => {
 	const adjacent = await getAdjecentSameOwner(peers, range, numbers);
 	const covering = await getCoveringRangesSameOwner(peers, range).all();
 
@@ -1816,7 +1860,7 @@ export const getAllMergeCandiates = async <R extends "u32" | "u64">(
 	for (const range of covering) {
 		ret.set(range.value.idString, range.value);
 	}
-	return ret.values();
+	return ret;
 };
 
 export const isMatured = (