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

package/dist/src/ranges.js

@@ -1,116 +1,33 @@
-import { equals } from "@peerbit/crypto";
-import { And, Compare, IntegerCompare, Or, SearchRequest, Sort, SortDirection, StringMatch, iterate, iteratorInSeries, } from "@peerbit/indexer-interface";
-import {} 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 { PublicSignKey, equals } from "@peerbit/crypto";
+import { And, ByteMatchQuery, Compare, IntegerCompare, Not, Or, SearchRequest, Sort, SortDirection, StringMatch, iterate, iteratorInSeries, } from "@peerbit/indexer-interface";
+import { ReplicationIntent, } from "./replication.js";
+import { MAX_U32, scaleToU32 } from "./role.js";
 const containingPoint = (rects, point, roleAgeLimit, matured, now, options) => {
     // 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,
                 }),
             ]),
         ]),
@@ -132,8 +49,7 @@ const containingPoint = (rects, point, roleAgeLimit, matured, now, options) => {
     }))
     return results.results.map(x => x.value) */
 };
-const getClosest = (direction, rects, point, roleAgeLimit, matured, now, scaled = false) => {
-    const scaledPoint = Math.round(point * (scaled ? 1 : SEGMENT_COORDINATE_SCALE));
+const getClosest = (direction, rects, point, roleAgeLimit, matured, now, includeStrict) => {
     const createQueries = (p, equality) => {
         let queries;
         if (direction === "below") {
@@ -165,23 +81,97 @@ const getClosest = (direction, rects, point, roleAgeLimit, matured, now, scaled
             ];
         }
         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" })
             : new Sort({ key: ["start1"], direction: "asc" }),
     }));
     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" })
             : new Sort({ key: ["start1"], direction: "asc" }),
     }));
-    return joinIterator([iterator, iteratorWrapped], scaledPoint, true, direction);
+    return joinIterator([iterator, iteratorWrapped], point, direction);
 };
-export const getDistance = (from, to, direction, end = SEGMENT_COORDINATE_SCALE) => {
+export const hasCoveringRange = async (rects, range) => {
+    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);
+};
+export const getDistance = (from, to, direction, 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
     // if direction is 'below' and from > to, then from needs to wrap around 1 to 0 and then to to
@@ -208,8 +198,7 @@ export const getDistance = (from, to, direction, end = SEGMENT_COORDINATE_SCALE)
     }
     throw new Error("Invalid direction");
 };
-const joinIterator = (iterators, point, scaled, direction) => {
-    const scaledPoint = Math.round(point * (scaled ? 1 : SEGMENT_COORDINATE_SCALE));
+const joinIterator = (iterators, point, direction) => {
     let queues = [];
     return {
         next: async (count) => {
@@ -231,13 +220,13 @@ const joinIterator = (iterators, point, scaled, direction) => {
                         const closest = el.value;
                         let dist;
                         if (direction === "closest") {
-                            dist = Math.min(getDistance(closest.start1, scaledPoint, direction), getDistance(closest.end2, scaledPoint, direction));
+                            dist = Math.min(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");
@@ -289,18 +278,14 @@ const joinIterator = (iterators, point, scaled, direction) => {
         },
     };
 };
-const getClosestAround = (peers, point, roleAge, now, scaled) => {
-    const closestBelow = getClosest("below", peers, point, roleAge, true, now, scaled);
-    const closestAbove = getClosest("above", peers, point, roleAge, true, now, scaled);
-    const containing = containingPoint(peers, point, roleAge, true, now, {
-        scaled: scaled,
-    });
-    return iteratorInSeries(containing, joinIterator([closestBelow, closestAbove], point, scaled, "closest"));
+const getClosestAround = (peers, point, roleAge, now, includeStrictBelow, includeStrictAbove) => {
+    const closestBelow = getClosest("below", peers, point, roleAge, true, now, includeStrictBelow);
+    const closestAbove = getClosest("above", peers, point, roleAge, true, now, includeStrictAbove);
+    const containing = containingPoint(peers, point, roleAge, true, now);
+    return iteratorInSeries(containing, joinIterator([closestBelow, closestAbove], point, "closest"));
 };
 const collectNodesAroundPoint = async (roleAge, peers, collector, point, now, done = () => 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) {
         collector(rect.value, isMatured(rect.value, now, roleAge));
@@ -310,7 +295,7 @@ const collectNodesAroundPoint = async (roleAge, peers, collector, point, now, do
     }
     const closestBelow = getClosest("below", peers, point, 0, true, now, false);
     const closestAbove = getClosest("above", peers, point, 0, true, now, false);
-    const aroundIterator = joinIterator([closestBelow, closestAbove], point, false, "closest");
+    const aroundIterator = joinIterator([closestBelow, closestAbove], point, "closest");
     while (aroundIterator.done() === false && done() === false) {
         const res = await aroundIterator.next(1);
         for (const rect of res.results) {
@@ -326,7 +311,6 @@ export const isMatured = (segment, now, minAge) => {
 };
 export const getSamples = async (cursor, peers, amount, roleAge) => {
     const leaders = new Set();
-    const width = 1;
     if (!peers) {
         return [];
     }
@@ -339,10 +323,9 @@ export const getSamples = async (cursor, peers, amount, roleAge) => {
     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);
             }
@@ -361,61 +344,52 @@ const fetchOne = async (iterator) => {
     await iterator.close();
     return value.results[0]?.value;
 };
-export const getCoverSet = async (coveringWidth, peers, roleAge, startNodeIdentity) => {
-    let now = +new Date();
-    // find a good starting point
-    let startNode = undefined;
-    if (startNodeIdentity) {
-        // start at our node (local first)
-        let result = await peers.query(new SearchRequest({
+export const minimumWidthToCover = async (minReplicas /* , replicatorCount: number */) => {
+    /* minReplicas = Math.min(minReplicas, replicatorCount); */ // TODO do we need this?
+    // 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) => {
+    let intervalWidth = 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();
+    // 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;
-    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 = [];
-    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, roleAge) => {
         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
         return next;
@@ -434,11 +408,23 @@ export const getCoverSet = async (coveringWidth, peers, roleAge, startNodeIdenti
     };
     // fill the middle
     let wrappedOnce = current.end2 < current.end1;
-    let maturedCoveredLength = coveredLength;
-    /* 	let lastMatured = isMatured(startNode, now, roleAge) ? startNode : undefined;
-     */
-    while (maturedCoveredLength < widthToCoverScaled &&
-        coveredLength <= SEGMENT_COORDINATE_SCALE) {
+    let coveredLength = 0;
+    const addLength = (from) => {
+        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 && // 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; */
         let matured = true;
@@ -450,195 +436,104 @@ export const getCoverSet = async (coveringWidth, peers, roleAge, startNodeIdenti
         if (!nextCandidate[0]) {
             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)) {
-            /* 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;
+        if (!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"))) {
+            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)
                 : current.end2
             : 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;
+    start instanceof PublicSignKey && ret.add(start.hashcode());
+    return ret;
+};
+export const fetchOneFromPublicKey = async (publicKey, index, roleAge, now) => {
+    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)!;
-        }
-        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)
-            }
-    
-            next = next.next || peers.head;
+    }
+    return node;
+};
+export const getStartAndEnd = async (peers, start, widthToCoverScaled, roleAge, now, intervalWidth) => {
+    // find a good starting point
+    let startNode = undefined;
+    let startLocation = undefined;
+    const nodeFromPoint = async (point = scaleToU32(Math.random())) => {
+        startLocation = point;
+        startNode = await fetchOneClosest(peers, startLocation, roleAge, now, false, true);
+    };
+    if (start instanceof PublicSignKey) {
+        // start at our node (local first)
+        startNode = await fetchOneFromPublicKey(start, peers, roleAge, now);
+        if (!startNode) {
+            // fetch randomly
+            await nodeFromPoint();
         }
-        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,
-            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
-        );
-        if (!done && unmatured.length > 0) {
-            set.add(unmatured[0]);
-            // TODO add more elements?
+        else {
+            startLocation = startNode.start1;
         }
     }
-    return set; */
+    else if (typeof start === "number") {
+        await nodeFromPoint(start);
+    }
+    else {
+        await nodeFromPoint();
+    }
+    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, point, roleAge, now, includeStrictBelow, includeStrictAbove) => {
+    return fetchOne(getClosestAround(peers, point, roleAge, now, includeStrictBelow, includeStrictAbove));
 };
 //# sourceMappingURL=ranges.js.map