@peerbit/shared-log 9.0.10 → 9.1.0-57b8640

package/src/ranges.ts

@@ -1,12 +1,14 @@
-import { type PublicSignKey, equals } from "@peerbit/crypto";
+import { PublicSignKey, equals } from "@peerbit/crypto";
 import {
 	And,
+	ByteMatchQuery,
 	Compare,
 	type Index,
 	type IndexIterator,
 	type IndexedResult,
 	type IndexedResults,
 	IntegerCompare,
+	Not,
 	Or,
 	type Query,
 	SearchRequest,
@@ -16,95 +18,12 @@ import {
 	iterate,
 	iteratorInSeries,
 } from "@peerbit/indexer-interface";
+import type { u32 } from "./replication-domain.js";
 import {
-	/* getSegmentsFromOffsetAndRange, */
+	ReplicationIntent,
 	type ReplicationRangeIndexable,
 } from "./replication.js";
-import { SEGMENT_COORDINATE_SCALE } from "./role.js";
-
-/* 
-export const containsPoint = (
-	rect: { offset: number; length: number },
-	point: number,
-	eps = 0.00001 // we do this to handle numerical errors
-) => {
-	if (rect.factor === 0) {
-		return false;
-	}
-	const start = rect.offset;
-	const width = rect.factor + eps; // we do this to handle numerical errors. It is better to be more inclusive
-	const endUnwrapped = rect.offset + width;
-	let end = endUnwrapped;
-	let wrapped = false;
-	if (endUnwrapped > 1) {
-		end = endUnwrapped % 1;
-		wrapped = true;
-	}
-
-	const inFirstInterval = point >= start && point < Math.min(endUnwrapped, 1);
-	const inSecondInterval =
-		!inFirstInterval && wrapped && point >= 0 && point < end;
-
-	return inFirstInterval || inSecondInterval;
-}; */
-
-/* const resolveRectsThatContainPoint = async (
-	rects: Index<ReplicationRangeIndexable>,
-	point: number,
-	roleAgeLimit: number,
-	matured: boolean
-): Promise<ReplicationRangeIndexable[]> => {
-	// point is between 0 and 1, and the range can start at any offset between 0 and 1 and have length between 0 and 1
-	// so we need to query for all ranges that contain the point
-	const scaledPoint = Math.round(point * SEGMENT_COORDINATE_SCALE)
-	let queries = [
-		new IntegerCompare({ key: 'start', compare: Compare.LessOrEqual, value: scaledPoint }),
-		new IntegerCompare({ key: 'end', compare: Compare.Greater, value: scaledPoint }),
-		new IntegerCompare({ key: 'timestamp', compare: matured ? Compare.LessOrEqual : Compare.Greater, value: Date.now() - roleAgeLimit })
-	]
-
-	const results = await rects.query(new SearchRequest({
-		query: [
-			new Nested({
-				path: 'segments',
-				query: queries
-			})
-		]
-	}))
-	return results.results.map(x => x.value)
-} */
-
-/* const resolveRectsInRange = async (rects: Index<ReplicationRangeIndexable>,
-	start: number,
-	end: number,
-	roleAgeLimit: number,
-	matured: boolean
-): Promise<ReplicationRangeIndexable[]> => {
-	// point is between 0 and 1, and the range can start at any offset between 0 and 1 and have length between 0 and 1
-	// so we need to query for all ranges that contain the point
-	let endScaled = Math.round(end * SEGMENT_COORDINATE_SCALE);
-	let startScaled = Math.round(start * SEGMENT_COORDINATE_SCALE);
-	let queries = [
-		new Or([
-			new And([
-				new IntegerCompare({ key: 'start1', compare: Compare.Less, value: endScaled }),
-				new IntegerCompare({ key: 'end1', compare: Compare.GreaterOrEqual, value: startScaled }),
-			]),
-			new And([
-				new IntegerCompare({ key: 'start2', compare: Compare.Less, value: endScaled }),
-				new IntegerCompare({ key: 'end2', compare: Compare.GreaterOrEqual, value: startScaled }),
-			])
-		]),
-		new IntegerCompare({ key: 'timestamp', compare: matured ? Compare.LessOrEqual : Compare.Greater, value: BigInt(+new Date - roleAgeLimit) })
-	]
-
-	const results = await rects.query(new SearchRequest({
-		query: queries,
-		sort: [new Sort({ key: "start1" }), new Sort({ key: "start2" })],
-		fetch: 0xffffffff
-	}))
-	return results.results.map(x => x.value)
-} */
+import { MAX_U32, scaleToU32 } from "./role.js";
 
 const containingPoint = (
 	rects: Index<ReplicationRangeIndexable>,
@@ -114,38 +33,34 @@ const containingPoint = (
 	now: number,
 	options?: {
 		sort?: Sort[];
-		scaled?: boolean;
 	},
 ): IndexIterator<ReplicationRangeIndexable> => {
 	// point is between 0 and 1, and the range can start at any offset between 0 and 1 and have length between 0 and 1
-	// so we need to query for all ranges that contain the point
-	let pointScaled = Math.round(
-		point * (options?.scaled ? 1 : SEGMENT_COORDINATE_SCALE),
-	);
+
 	let queries = [
 		new Or([
 			new And([
 				new IntegerCompare({
 					key: "start1",
 					compare: Compare.LessOrEqual,
-					value: pointScaled,
+					value: point,
 				}),
 				new IntegerCompare({
 					key: "end1",
 					compare: Compare.Greater,
-					value: pointScaled,
+					value: point,
 				}),
 			]),
 			new And([
 				new IntegerCompare({
 					key: "start2",
 					compare: Compare.LessOrEqual,
-					value: pointScaled,
+					value: point,
 				}),
 				new IntegerCompare({
 					key: "end2",
 					compare: Compare.Greater,
-					value: pointScaled,
+					value: point,
 				}),
 			]),
 		]),
@@ -178,11 +93,8 @@ const getClosest = (
 	roleAgeLimit: number,
 	matured: boolean,
 	now: number,
-	scaled: boolean = false,
+	includeStrict: boolean,
 ): IndexIterator<ReplicationRangeIndexable> => {
-	const scaledPoint = Math.round(
-		point * (scaled ? 1 : SEGMENT_COORDINATE_SCALE),
-	);
 	const createQueries = (p: number, equality: boolean) => {
 		let queries: Query[];
 		if (direction === "below") {
@@ -215,13 +127,23 @@ const getClosest = (
 		queries.push(
 			new IntegerCompare({ key: "width", compare: Compare.Greater, value: 0 }),
 		);
+
+		if (!includeStrict) {
+			queries.push(
+				new IntegerCompare({
+					key: "mode",
+					compare: Compare.Equal,
+					value: ReplicationIntent.NonStrict,
+				}),
+			);
+		}
 		return queries;
 	};
 
 	const iterator = iterate(
 		rects,
 		new SearchRequest({
-			query: createQueries(scaledPoint, false),
+			query: createQueries(point, false),
 			sort:
 				direction === "below"
 					? new Sort({ key: ["end2"], direction: "desc" })
@@ -231,10 +153,7 @@ const getClosest = (
 	const iteratorWrapped = iterate(
 		rects,
 		new SearchRequest({
-			query: createQueries(
-				direction === "below" ? SEGMENT_COORDINATE_SCALE : 0,
-				true,
-			),
+			query: createQueries(direction === "below" ? MAX_U32 : 0, true),
 			sort:
 				direction === "below"
 					? new Sort({ key: ["end2"], direction: "desc" })
@@ -242,11 +161,83 @@ const getClosest = (
 		}),
 	);
 
-	return joinIterator(
-		[iterator, iteratorWrapped],
-		scaledPoint,
-		true,
-		direction,
+	return joinIterator([iterator, iteratorWrapped], point, direction);
+};
+
+export const hasCoveringRange = async (
+	rects: Index<ReplicationRangeIndexable>,
+	range: ReplicationRangeIndexable,
+) => {
+	return (
+		(await rects.count(
+			new SearchRequest({
+				query: [
+					new Or([
+						new And([
+							new IntegerCompare({
+								key: "start1",
+								compare: Compare.LessOrEqual,
+								value: range.start1,
+							}),
+							new IntegerCompare({
+								key: "end1",
+								compare: Compare.GreaterOrEqual,
+								value: range.end1,
+							}),
+						]),
+						new And([
+							new IntegerCompare({
+								key: "start2",
+								compare: Compare.LessOrEqual,
+								value: range.start1,
+							}),
+							new IntegerCompare({
+								key: "end2",
+								compare: Compare.GreaterOrEqual,
+								value: range.end1,
+							}),
+						]),
+					]),
+					new Or([
+						new And([
+							new IntegerCompare({
+								key: "start1",
+								compare: Compare.LessOrEqual,
+								value: range.start2,
+							}),
+							new IntegerCompare({
+								key: "end1",
+								compare: Compare.GreaterOrEqual,
+								value: range.end2,
+							}),
+						]),
+						new And([
+							new IntegerCompare({
+								key: "start2",
+								compare: Compare.LessOrEqual,
+								value: range.start2,
+							}),
+							new IntegerCompare({
+								key: "end2",
+								compare: Compare.GreaterOrEqual,
+								value: range.end2,
+							}),
+						]),
+					]),
+					new StringMatch({
+						key: "hash",
+						value: range.hash,
+					}),
+					// assume that we are looking for other ranges, not want to update an existing one
+					new Not(
+						new ByteMatchQuery({
+							key: "id",
+							value: range.id,
+						}),
+					),
+				],
+			}),
+		)) > 0
 	);
 };
 
@@ -254,7 +245,7 @@ export const getDistance = (
 	from: number,
 	to: number,
 	direction: "above" | "below" | "closest",
-	end = SEGMENT_COORDINATE_SCALE,
+	end = MAX_U32,
 ) => {
 	// if direction is 'above' only measure distance from 'from to 'to' from above.
 	// i.e if from < to, then from needs to wrap around 0 to 1 and then to to
@@ -292,12 +283,8 @@ export const getDistance = (
 const joinIterator = (
 	iterators: IndexIterator<ReplicationRangeIndexable>[],
 	point: number,
-	scaled: boolean,
 	direction: "above" | "below" | "closest",
 ) => {
-	const scaledPoint = Math.round(
-		point * (scaled ? 1 : SEGMENT_COORDINATE_SCALE),
-	);
 	let queues: {
 		kept: number;
 		elements: {
@@ -331,13 +318,13 @@ const joinIterator = (
 						let dist: number;
 						if (direction === "closest") {
 							dist = Math.min(
-								getDistance(closest.start1, scaledPoint, direction),
-								getDistance(closest.end2, scaledPoint, direction),
+								getDistance(closest.start1, point, direction),
+								getDistance(closest.end2, point, direction),
 							);
 						} else if (direction === "above") {
-							dist = getDistance(closest.start1, scaledPoint, direction);
+							dist = getDistance(closest.start1, point, direction);
 						} else if (direction === "below") {
-							dist = getDistance(closest.end2, scaledPoint, direction);
+							dist = getDistance(closest.end2, point, direction);
 						} else {
 							throw new Error("Invalid direction");
 						}
@@ -401,7 +388,8 @@ const getClosestAround = (
 	point: number,
 	roleAge: number,
 	now: number,
-	scaled: boolean,
+	includeStrictBelow: boolean,
+	includeStrictAbove: boolean,
 ) => {
 	const closestBelow = getClosest(
 		"below",
@@ -410,7 +398,7 @@ const getClosestAround = (
 		roleAge,
 		true,
 		now,
-		scaled,
+		includeStrictBelow,
 	);
 	const closestAbove = getClosest(
 		"above",
@@ -419,15 +407,13 @@ const getClosestAround = (
 		roleAge,
 		true,
 		now,
-		scaled,
+		includeStrictAbove,
 	);
-	const containing = containingPoint(peers, point, roleAge, true, now, {
-		scaled: scaled,
-	});
+	const containing = containingPoint(peers, point, roleAge, true, now);
 
 	return iteratorInSeries(
 		containing,
-		joinIterator([closestBelow, closestAbove], point, scaled, "closest"),
+		joinIterator([closestBelow, closestAbove], point, "closest"),
 	);
 };
 
@@ -435,13 +421,11 @@ const collectNodesAroundPoint = async (
 	roleAge: number,
 	peers: Index<ReplicationRangeIndexable>,
 	collector: (rect: ReplicationRangeIndexable, matured: boolean) => void,
-	point: number,
+	point: u32,
 	now: number,
 	done: () => boolean = () => true,
 ) => {
-	const containing = containingPoint(peers, point, 0, true, now, {
-		scaled: false,
-	});
+	const containing = containingPoint(peers, point, 0, true, now);
 
 	const allContaining = await containing.next(0xffffffff);
 	for (const rect of allContaining.results) {
@@ -457,7 +441,6 @@ const collectNodesAroundPoint = async (
 	const aroundIterator = joinIterator(
 		[closestBelow, closestAbove],
 		point,
-		false,
 		"closest",
 	);
 	while (aroundIterator.done() === false && done() === false) {
@@ -480,13 +463,12 @@ export const isMatured = (
 };
 
 export const getSamples = async (
-	cursor: number,
+	cursor: u32,
 	peers: Index<ReplicationRangeIndexable>,
 	amount: number,
 	roleAge: number,
 ) => {
 	const leaders: Set<string> = new Set();
-	const width = 1;
 	if (!peers) {
 		return [];
 	}
@@ -504,14 +486,13 @@ export const getSamples = async (
 	const maturedLeaders = new Set();
 	for (let i = 0; i < amount; i++) {
 		// evenly distributed
-		const point = ((cursor + i / amount) % 1) * width;
+		const point = Math.round(cursor + (i * MAX_U32) / amount) % MAX_U32;
 
 		// aquire at least one unique node for each point
 		await collectNodesAroundPoint(
 			roleAge,
 			peers,
 			(rect, m) => {
-				// console.log(m, rect.start1 / SEGMENT_COORDINATE_SCALE, rect.width / SEGMENT_COORDINATE_SCALE)
 				if (m) {
 					maturedLeaders.add(rect.hash);
 				}
@@ -537,82 +518,84 @@ const fetchOne = async (iterator: IndexIterator<ReplicationRangeIndexable>) => {
 	return value.results[0]?.value;
 };
 
-export const getCoverSet = async (
-	coveringWidth: number,
-	peers: Index<ReplicationRangeIndexable>,
-	roleAge: number,
-	startNodeIdentity?: PublicSignKey,
-): Promise<Set<string>> => {
-	let now = +new Date();
+export const minimumWidthToCover = async (
+	minReplicas: number /* , replicatorCount: number */,
+) => {
+	/* minReplicas = Math.min(minReplicas, replicatorCount); */ // TODO do we need this?
 
-	// find a good starting point
-	let startNode: ReplicationRangeIndexable | undefined = undefined;
-	if (startNodeIdentity) {
-		// start at our node (local first)
-		let result = await peers.query(
+	// If min replicas = 2
+	// then we need to make sure we cover 0.5 of the total 'width' of the replication space
+	// to make sure we reach sufficient amount of nodes such that at least one one has
+	// the entry we are looking for
+
+	let widthToCoverScaled = Math.round(MAX_U32 / minReplicas);
+	return widthToCoverScaled;
+};
+
+export const getCoverSet = async (properties: {
+	peers: Index<ReplicationRangeIndexable>;
+	start: number | PublicSignKey | undefined;
+	widthToCoverScaled: number;
+	roleAge: number;
+	intervalWidth?: number;
+	eager?:
+		| {
+				unmaturedFetchCoverSize?: number;
+		  }
+		| boolean;
+}): Promise<Set<string>> => {
+	let intervalWidth: number = properties.intervalWidth ?? MAX_U32;
+	const { peers, start, widthToCoverScaled, roleAge } = properties;
+
+	const now = Date.now();
+	const { startNode, startLocation, endLocation } = await getStartAndEnd(
+		peers,
+		start,
+		widthToCoverScaled,
+		roleAge,
+		now,
+		intervalWidth,
+	);
+
+	let ret = new Set<string>();
+
+	// if start node (assume is self) and not mature, ask all known remotes if limited
+	// TODO consider a more robust stragety here in a scenario where there are many nodes, lets say
+	// a social media app with 1m user, then it does not makes sense to query "all" just because we started
+	if (properties.eager) {
+		const eagerFetch =
+			properties.eager === true
+				? 1000
+				: properties.eager.unmaturedFetchCoverSize;
+
+		// pull all umatured
+		const rects = await peers.query(
 			new SearchRequest({
+				fetch: eagerFetch,
 				query: [
-					new StringMatch({ key: "hash", value: startNodeIdentity.hashcode() }),
+					new IntegerCompare({
+						key: "timestamp",
+						compare: Compare.GreaterOrEqual,
+						value: BigInt(now - roleAge),
+					}),
 				],
-				fetch: 1,
 			}),
 		);
-		startNode = result.results[0]?.value;
-
-		if (startNode) {
-			if (!isMatured(startNode, now, roleAge)) {
-				const matured = await fetchOne(
-					getClosestAround(peers, startNode.start1, roleAge, now, true),
-				);
-				if (matured) {
-					startNode = matured;
-				}
-			}
+		for (const rect of rects.results) {
+			ret.add(rect.value.hash);
 		}
 	}
-	let startLocation: number;
 
-	if (!startNode) {
-		startLocation = Math.random() * SEGMENT_COORDINATE_SCALE;
-		startNode = await fetchOne(
-			getClosestAround(peers, startLocation, roleAge, now, true),
-		);
-	} else {
-		// TODO choose start location as the point with the longest range?
-		startLocation =
-			startNode.start1 ?? Math.random() * SEGMENT_COORDINATE_SCALE;
-	}
-
-	if (!startNode) {
-		return new Set();
-	}
-
-	let results: ReplicationRangeIndexable[] = [];
-
-	let widthToCoverScaled = coveringWidth * SEGMENT_COORDINATE_SCALE;
-	const endLocation =
-		(startLocation + widthToCoverScaled) % SEGMENT_COORDINATE_SCALE;
 	const endIsWrapped = endLocation <= startLocation;
 
-	const endRect =
-		(await fetchOne(
-			getClosestAround(peers, endLocation, roleAge, now, true),
-		)) || (await fetchOne(getClosestAround(peers, endLocation, 0, now, true))); // (await getClosest('above', peers, nextLocation, roleAge, true, 1, true))[0]
-
-	if (!endRect) {
-		return new Set();
+	if (!startNode) {
+		return ret;
 	}
 
-	let current =
-		/* (await getClosestAround(peers, startLocation, roleAge, 1, true))[0] */ startNode ||
-		(await fetchOne(getClosestAround(peers, startLocation, 0, now, true))); //(await getClosest('above', peers, startLocation, roleAge, true, 1, true))[0]
-	let coveredLength = current.width;
-	let nextLocation = current.end2;
+	let current = startNode;
 
 	// push edges
-	results.push(endRect);
-	results.push(current);
-	/* const endIsSameAsStart = equals(endRect.id, current.id); */
+	ret.add(current.hash);
 
 	const resolveNextContaining = async (
 		nextLocation: number,
@@ -620,7 +603,6 @@ export const getCoverSet = async (
 	) => {
 		let next = await fetchOne(
 			containingPoint(peers, nextLocation, roleAge, true, now, {
-				scaled: true,
 				sort: [new Sort({ key: "end2", direction: SortDirection.DESC })],
 			}),
 		); // get entersecting sort by largest end2
@@ -649,13 +631,25 @@ export const getCoverSet = async (
 	// fill the middle
 	let wrappedOnce = current.end2 < current.end1;
 
-	let maturedCoveredLength = coveredLength;
-	/* 	let lastMatured = isMatured(startNode, now, roleAge) ? startNode : undefined;
-	 */
+	let coveredLength = 0;
+	const addLength = (from: number) => {
+		if (current.end2 < from || current.wrapped) {
+			wrappedOnce = true;
+			coveredLength += MAX_U32 - from;
+			coveredLength += current.end2;
+		} else {
+			coveredLength += current.end1 - from;
+		}
+	};
+	addLength(startLocation);
+
+	let maturedCoveredLength =
+		coveredLength; /* TODO only increase matured length when startNode is matured? i.e. do isMatured(startNode, now, roleAge) ? coveredLength : 0; */
+	let nextLocation = current.end2;
 
 	while (
-		maturedCoveredLength < widthToCoverScaled &&
-		coveredLength <= SEGMENT_COORDINATE_SCALE
+		maturedCoveredLength < widthToCoverScaled && // eslint-disable-line no-unmodified-loop-condition
+		coveredLength <= MAX_U32 // eslint-disable-line no-unmodified-loop-condition
 	) {
 		let nextCandidate = await resolveNext(nextLocation, roleAge);
 		/* let fromAbove = false; */
@@ -671,53 +665,44 @@ export const getCoverSet = async (
 			break;
 		}
 
+		let nextIsCurrent = equals(nextCandidate[0].id, current.id);
+		if (nextIsCurrent) {
+			break;
+		}
+		let last = current;
 		current = nextCandidate[0];
 
 		let distanceBefore = coveredLength;
 
-		if (current.end2 < nextLocation) {
-			wrappedOnce = true;
-			coveredLength += SEGMENT_COORDINATE_SCALE - nextLocation;
-			coveredLength += current.end2;
-		} else {
-			coveredLength += current.end1 - nextLocation;
-		}
+		addLength(nextLocation);
 
 		let isLast =
 			distanceBefore < widthToCoverScaled &&
 			coveredLength >= widthToCoverScaled;
+
 		if (
-			(isLast &&
-				!nextCandidate[1]) /* || Math.min(current.start1, current.start2) > Math.min(endRect.start1, endRect.start2) */ /* (Math.min(current.start1, current.start2) > endLocation) */ ||
-			equals(endRect.id, current.id)
+			!isLast ||
+			nextCandidate[1] ||
+			Math.min(
+				getDistance(last.start1, endLocation, "closest"),
+				getDistance(last.end2, endLocation, "closest"),
+			) >
+				Math.min(
+					getDistance(current.start1, endLocation, "closest"),
+					getDistance(current.end2, endLocation, "closest"),
+				)
 		) {
-			/* if ((isLast && ((endIsWrapped && wrappedOnce) || (!endIsWrapped))) && (current.start1 > endLocation || equals(current.id, endRect.id))) { */
-			// this is the end!
-			/* if (lastMatured && lastMatured.distanceTo(endLocation) < current.distanceTo(endLocation)) {
-				breaks;
-			} */
-			break;
+			ret.add(current.hash);
 		}
 
-		/* if (fromAbove && next && next.start1 > endRect.start1 && (endIsWrapped === false || wrappedOnce)) {
+		if (isLast && !nextCandidate[1] /*  || equals(endRect.id, current.id) */) {
 			break;
-		} */
-
-		// this is a skip condition to not include too many rects
+		}
 
 		if (matured) {
 			maturedCoveredLength = coveredLength;
-			/* lastMatured = current; */
 		}
 
-		results.push(current);
-		/* 
-		
-				if (current.start1 > endLocation && (wrappedOnce || !endIsWrapped)) {
-					break;
-				}
-		
-		 */
 		nextLocation = endIsWrapped
 			? wrappedOnce
 				? Math.min(current.end2, endLocation)
@@ -725,154 +710,122 @@ export const getCoverSet = async (
 			: Math.min(current.end2, endLocation);
 	}
 
-	const res = new Set(results.map((x) => x.hash));
-	startNodeIdentity && res.add(startNodeIdentity.hashcode());
-	return res;
-
-	//
-	/* const set: Set<string> = new Set();
-	let currentNode = startNode;
-	const t = +new Date();
-	
-	let wrappedOnce = false;
-	const startPoint = startNode.segment.offset;
-	
-	const getNextPoint = (): [number, number, number, boolean] => {
-		let nextPoint =
-			currentNode.segment.offset + currentNode.segment.factor;
-	
-		if (nextPoint > 1 || nextPoint < startPoint) {
-			wrappedOnce = true;
-		}
-	
-		nextPoint = nextPoint % 1;
-		let distanceStart: number;
-	
-		if (wrappedOnce) {
-			distanceStart = (1 - startPoint + currentNode.segment.offset) % 1;
-		} else {
-			distanceStart = (currentNode.segment.offset - startPoint) % 1;
-		}
-	
-		const distanceEnd = distanceStart + currentNode.segment.factor;
-	
-		return [nextPoint, distanceStart, distanceEnd, wrappedOnce];
-	};
-	
-	const getNextMatured = async (from: ReplicatorRect) => {
-		let next = (await peers.query(new SearchRequest({ query: [new IntegerCompare({ key: ['segment', 'offset'], compare: Compare.Greater, value: from.segment.offset })], fetch: 1 })))?.results[0]?.value  // (from.next || peers.head)!;
-		while (
-			next.hash !== from.hash &&
-			next.hash !== startNode.hash
-		) {
-			if (isMatured(next.segment, t, roleAge)) {
-				return next;
-			}
-			next = (next.next || peers.head)!;
-		}
-		return undefined;
-	}; */
-
-	/**
-	 * The purpose of this loop is to cover at least coveringWidth
-	 * so that if we query all nodes in this range, we know we will
-	 * "query" all data in that range
-	 */
-
-	/* let isPastThePoint = false;
-	outer: while (currentNode) {
-		if (set.has(currentNode.hash)) break;
-	
-		const [nextPoint, distanceStart, distanceEnd, wrapped] = getNextPoint();
-	
-		if (distanceStart <= coveringWidth) {
-			set.add(currentNode.hash);
-		}
-	
-		if (distanceEnd >= coveringWidth) {
-			break;
-		}
-	
-		let next = currentNode.next || peers.head;
-		while (next) {
-			if (next.value.publicKey.equals(startNode.value.publicKey)) {
-				break outer;
-			}
-	
-			const prevOffset = (next.prev || peers.tail)!.value.role.offset;
-			const nextOffset = next.value.role.offset;
-			const nextHasWrapped = nextOffset < prevOffset;
-	
-			if (
-				(!wrapped && nextOffset > nextPoint) ||
-				(nextHasWrapped &&
-					(wrapped ? nextOffset > nextPoint : prevOffset < nextPoint)) ||
-				(!nextHasWrapped && prevOffset < nextPoint && nextPoint <= nextOffset)
-			) {
-				isPastThePoint = true;
-			}
-	
-			if (isPastThePoint) {
-				break; // include this next in the set;
-			}
-	
-			const overlapsRange = containsPoint(next.value.role, nextPoint);
-	
-			if (overlapsRange) {
-				// Find out if there is a better choice ahead of us
-				const nextNext = await getNextMatured(next);
-				if (
-					nextNext &&
-					nextNext.hash === currentNode.hash &&
-					nextNext.segment.offset < nextPoint &&
-					nextNext.segment.offset + nextNext.segment.factor > nextPoint
-				) {
-					// nextNext is better (continue to iterate)
-				} else {
-					// done
-					break;
-				}
-			} else {
-				// (continue to iterate)
+	start instanceof PublicSignKey && ret.add(start.hashcode());
+	return ret;
+};
+
+export const fetchOneFromPublicKey = async (
+	publicKey: PublicSignKey,
+	index: Index<ReplicationRangeIndexable>,
+	roleAge: number,
+	now: number,
+) => {
+	let result = await index.query(
+		new SearchRequest({
+			query: [new StringMatch({ key: "hash", value: publicKey.hashcode() })],
+			fetch: 1,
+		}),
+	);
+	let node = result.results[0]?.value;
+	if (node) {
+		if (!isMatured(node, now, roleAge)) {
+			const matured = await fetchOne(
+				getClosestAround(index, node.start1, roleAge, now, false, false),
+			);
+			if (matured) {
+				node = matured;
 			}
-	
-			next = next.next || peers.head;
 		}
-		currentNode = next!;
-	} */
-
-	// collect 1 point around the boundary of the start and one at the end,
-	// preferrd matured and that we already have it
-	/* for (const point of [
-		startNode.segment.offset,
-		(startNode.segment.offset + coveringWidth) % 1
-	]) {
-		let done = false;
-		const unmatured: string[] = [];
-		collectNodesAroundPoint(
-			t,
-			roleAge,
+	}
+	return node;
+};
+
+export const getStartAndEnd = async (
+	peers: Index<ReplicationRangeIndexable>,
+	start: number | PublicSignKey | undefined | undefined,
+	widthToCoverScaled: number,
+	roleAge: number,
+	now: number,
+	intervalWidth: number,
+) => {
+	// find a good starting point
+	let startNode: ReplicationRangeIndexable | undefined = undefined;
+	let startLocation: number | undefined = undefined;
+
+	const nodeFromPoint = async (point = scaleToU32(Math.random())) => {
+		startLocation = point;
+		startNode = await fetchOneClosest(
 			peers,
-			isMatured(startNode.segment, t, roleAge) ? startNode : peers.head, // start at startNode is matured, else start at head (we only seek to find one matured node at the point)
-			(rect, matured) => {
-				if (matured) {
-					if (set.has(rect.hash)) {
-						// great!
-					} else {
-						set.add(rect.hash);
-					}
-					done = true;
-				} else {
-					unmatured.push(rect.hash);
-				}
-			},
-			point,
-			() => done
+			startLocation,
+			roleAge,
+			now,
+			false,
+			true,
 		);
-		if (!done && unmatured.length > 0) {
-			set.add(unmatured[0]);
-			// TODO add more elements?
+	};
+
+	if (start instanceof PublicSignKey) {
+		// start at our node (local first)
+		startNode = await fetchOneFromPublicKey(start, peers, roleAge, now);
+		if (!startNode) {
+			// fetch randomly
+			await nodeFromPoint();
+		} else {
+			startLocation = startNode.start1;
 		}
+	} else if (typeof start === "number") {
+		await nodeFromPoint(start);
+	} else {
+		await nodeFromPoint();
 	}
-	return set; */
+
+	if (!startNode || startLocation == null) {
+		return { startNode: undefined, startLocation: 0, endLocation: 0 };
+	}
+
+	let endLocation = startLocation + widthToCoverScaled;
+	if (intervalWidth != null) {
+		endLocation = endLocation % intervalWidth;
+	}
+
+	// if start location is after endLocation and startNode is strict then return undefined because this is not a node we want to choose
+	let coveredDistanceToStart = 0;
+	if (startNode.start1 < startLocation) {
+		coveredDistanceToStart += intervalWidth - startLocation + startNode.start1;
+	} else {
+		coveredDistanceToStart += startNode.start1 - startLocation;
+	}
+
+	if (
+		startNode.mode === ReplicationIntent.Strict &&
+		coveredDistanceToStart > widthToCoverScaled
+	) {
+		return { startNode: undefined, startLocation: 0, endLocation: 0 };
+	}
+
+	return {
+		startNode,
+		startLocation: Math.round(startLocation),
+		endLocation: Math.round(endLocation),
+	};
+};
+
+export const fetchOneClosest = (
+	peers: Index<ReplicationRangeIndexable>,
+	point: number,
+	roleAge: number,
+	now: number,
+	includeStrictBelow: boolean,
+	includeStrictAbove: boolean,
+) => {
+	return fetchOne(
+		getClosestAround(
+			peers,
+			point,
+			roleAge,
+			now,
+			includeStrictBelow,
+			includeStrictAbove,
+		),
+	);
 };