@peerbit/shared-log 9.2.13 → 10.0.0

package/dist/src/ranges.js

@@ -7,35 +7,47 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { deserialize, field, serialize, variant } from "@dao-xyz/borsh";
-import { PublicSignKey, equals, randomBytes, toBase64 } from "@peerbit/crypto";
-import { And, BoolQuery, ByteMatchQuery, Compare, IntegerCompare, Not, Or, Sort, SortDirection, StringMatch, iteratorInSeries, } from "@peerbit/indexer-interface";
+import { deserialize, field, serialize, variant, vec } from "@dao-xyz/borsh";
+import { PublicSignKey, equals, randomBytes, sha256Base64Sync, toBase64, } from "@peerbit/crypto";
+import { And, BoolQuery, ByteMatchQuery, Compare, IntegerCompare, Not, Or, Sort, SortDirection, StringMatch,
+/* 	iteratorInSeries, */
+ } from "@peerbit/indexer-interface";
 import { id } from "@peerbit/indexer-interface";
 import { Meta, ShallowMeta } from "@peerbit/log";
+import { MAX_U32, MAX_U64, } from "./integers.js";
 import {} from "./replication-domain.js";
-import { MAX_U32, scaleToU32 } from "./role.js";
-import { groupByGidSync } from "./utils.js";
 export var ReplicationIntent;
 (function (ReplicationIntent) {
     ReplicationIntent[ReplicationIntent["NonStrict"] = 0] = "NonStrict";
     ReplicationIntent[ReplicationIntent["Strict"] = 1] = "Strict";
 })(ReplicationIntent || (ReplicationIntent = {}));
-export const getSegmentsFromOffsetAndRange = (offset, factor) => {
+export var SyncStatus;
+(function (SyncStatus) {
+    SyncStatus[SyncStatus["Unsynced"] = 0] = "Unsynced";
+    SyncStatus[SyncStatus["Synced"] = 1] = "Synced";
+})(SyncStatus || (SyncStatus = {}));
+const min = (a, b) => (a < b ? a : b);
+const getSegmentsFromOffsetAndRange = (offset, factor, zero, max) => {
     let start1 = offset;
+    // @ts-ignore
     let end1Unscaled = offset + factor; // only add factor if it is not 1 to prevent numerical issues (like (0.9 + 1) % 1 => 0.8999999)
-    let end1 = Math.min(end1Unscaled, MAX_U32);
+    let end1 = min(end1Unscaled, max);
     return [
         [start1, end1],
-        end1Unscaled > MAX_U32
-            ? [0, (factor !== MAX_U32 ? offset + factor : offset) % MAX_U32]
+        /* eslint-disable no-irregular-whitespace */
+        // @ts-ignore
+        end1Unscaled > max
+            ? /* eslint-disable no-irregular-whitespace */
+                // @ts-ignore
+                [zero, (factor !== max ? offset + factor : offset) % max]
             : [start1, end1],
     ];
 };
 export const shouldAssigneToRangeBoundary = (leaders, minReplicas) => {
     let assignedToRangeBoundary = leaders === false || leaders.size < minReplicas;
     if (!assignedToRangeBoundary && leaders) {
-        for (const [_, { intersecting }] of leaders) {
-            if (!intersecting) {
+        for (const [_, value] of leaders) {
+            if (!value.intersecting) {
                 assignedToRangeBoundary = true;
                 break;
             }
@@ -43,20 +55,21 @@ export const shouldAssigneToRangeBoundary = (leaders, minReplicas) => {
     }
     return assignedToRangeBoundary;
 };
-export class EntryReplicated {
-    id; // hash + coordinate
+export const isEntryReplicated = (x) => {
+    return x instanceof EntryReplicatedU32 || x instanceof EntryReplicatedU64;
+};
+export class EntryReplicatedU32 {
     hash;
     gid;
-    coordinate;
+    coordinates;
     wallTime;
     assignedToRangeBoundary;
     _meta;
     _metaResolved;
     constructor(properties) {
-        this.coordinate = properties.coordinate;
+        this.coordinates = properties.coordinates;
         this.hash = properties.hash;
         this.gid = properties.meta.gid;
-        this.id = this.hash + "-" + this.coordinate;
         this.wallTime = properties.meta.clock.timestamp.wallTime;
         const shallow = properties.meta instanceof Meta
             ? new ShallowMeta(properties.meta)
@@ -76,38 +89,92 @@ export class EntryReplicated {
 __decorate([
     id({ type: "string" }),
     __metadata("design:type", String)
-], EntryReplicated.prototype, "id", void 0);
+], EntryReplicatedU32.prototype, "hash", void 0);
 __decorate([
     field({ type: "string" }),
     __metadata("design:type", String)
-], EntryReplicated.prototype, "hash", void 0);
+], EntryReplicatedU32.prototype, "gid", void 0);
+__decorate([
+    field({ type: vec("u32") }),
+    __metadata("design:type", Array)
+], EntryReplicatedU32.prototype, "coordinates", void 0);
+__decorate([
+    field({ type: "u64" }),
+    __metadata("design:type", BigInt)
+], EntryReplicatedU32.prototype, "wallTime", void 0);
+__decorate([
+    field({ type: "bool" }),
+    __metadata("design:type", Boolean)
+], EntryReplicatedU32.prototype, "assignedToRangeBoundary", void 0);
+__decorate([
+    field({ type: Uint8Array }),
+    __metadata("design:type", Uint8Array)
+], EntryReplicatedU32.prototype, "_meta", void 0);
+export class EntryReplicatedU64 {
+    hash;
+    gid;
+    coordinates;
+    wallTime;
+    assignedToRangeBoundary;
+    _meta;
+    _metaResolved;
+    constructor(properties) {
+        this.coordinates = properties.coordinates;
+        this.hash = properties.hash;
+        this.gid = properties.meta.gid;
+        this.wallTime = properties.meta.clock.timestamp.wallTime;
+        const shallow = properties.meta instanceof Meta
+            ? new ShallowMeta(properties.meta)
+            : properties.meta;
+        this._meta = serialize(shallow);
+        this._metaResolved = deserialize(this._meta, ShallowMeta);
+        this._metaResolved = properties.meta;
+        this.assignedToRangeBoundary = properties.assignedToRangeBoundary;
+    }
+    get meta() {
+        if (!this._metaResolved) {
+            this._metaResolved = deserialize(this._meta, ShallowMeta);
+        }
+        return this._metaResolved;
+    }
+}
+__decorate([
+    id({ type: "string" }),
+    __metadata("design:type", String)
+], EntryReplicatedU64.prototype, "hash", void 0);
 __decorate([
     field({ type: "string" }),
     __metadata("design:type", String)
-], EntryReplicated.prototype, "gid", void 0);
+], EntryReplicatedU64.prototype, "gid", void 0);
 __decorate([
-    field({ type: "u32" }),
-    __metadata("design:type", Number)
-], EntryReplicated.prototype, "coordinate", void 0);
+    field({ type: vec("u64") }),
+    __metadata("design:type", Array)
+], EntryReplicatedU64.prototype, "coordinates", void 0);
 __decorate([
     field({ type: "u64" }),
     __metadata("design:type", BigInt)
-], EntryReplicated.prototype, "wallTime", void 0);
+], EntryReplicatedU64.prototype, "wallTime", void 0);
 __decorate([
     field({ type: "bool" }),
     __metadata("design:type", Boolean)
-], EntryReplicated.prototype, "assignedToRangeBoundary", void 0);
+], EntryReplicatedU64.prototype, "assignedToRangeBoundary", void 0);
 __decorate([
     field({ type: Uint8Array }),
     __metadata("design:type", Uint8Array)
-], EntryReplicated.prototype, "_meta", void 0);
-let ReplicationRange = class ReplicationRange {
+], EntryReplicatedU64.prototype, "_meta", void 0);
+export const isReplicationRangeMessage = (x) => {
+    return x instanceof ReplicationRangeMessage;
+};
+export class ReplicationRangeMessage {
+}
+let ReplicationRangeMessageU32 = class ReplicationRangeMessageU32 extends ReplicationRangeMessage {
     id;
     timestamp;
     _offset;
     _factor;
     mode;
     constructor(properties) {
+        super();
         const { id, offset, factor, timestamp, mode } = properties;
         this.id = id;
         this._offset = offset;
@@ -122,7 +189,7 @@ let ReplicationRange = class ReplicationRange {
         return this._offset;
     }
     toReplicationRangeIndexable(key) {
-        return new ReplicationRangeIndexable({
+        return new ReplicationRangeIndexableU32({
             id: this.id,
             publicKeyHash: key.hashcode(),
             offset: this.offset,
@@ -135,29 +202,154 @@ let ReplicationRange = class ReplicationRange {
 __decorate([
     field({ type: Uint8Array }),
     __metadata("design:type", Uint8Array)
-], ReplicationRange.prototype, "id", void 0);
+], ReplicationRangeMessageU32.prototype, "id", void 0);
 __decorate([
     field({ type: "u64" }),
     __metadata("design:type", BigInt)
-], ReplicationRange.prototype, "timestamp", void 0);
+], ReplicationRangeMessageU32.prototype, "timestamp", void 0);
 __decorate([
     field({ type: "u32" }),
     __metadata("design:type", Number)
-], ReplicationRange.prototype, "_offset", void 0);
+], ReplicationRangeMessageU32.prototype, "_offset", void 0);
 __decorate([
     field({ type: "u32" }),
     __metadata("design:type", Number)
-], ReplicationRange.prototype, "_factor", void 0);
+], ReplicationRangeMessageU32.prototype, "_factor", void 0);
 __decorate([
     field({ type: "u8" }),
     __metadata("design:type", Number)
-], ReplicationRange.prototype, "mode", void 0);
-ReplicationRange = __decorate([
+], ReplicationRangeMessageU32.prototype, "mode", void 0);
+ReplicationRangeMessageU32 = __decorate([
     variant(0),
     __metadata("design:paramtypes", [Object])
-], ReplicationRange);
-export { ReplicationRange };
-export class ReplicationRangeIndexable {
+], ReplicationRangeMessageU32);
+export { ReplicationRangeMessageU32 };
+let ReplicationRangeMessageU64 = class ReplicationRangeMessageU64 extends ReplicationRangeMessage {
+    id;
+    timestamp;
+    _offset;
+    _factor;
+    mode;
+    constructor(properties) {
+        super();
+        const { id, offset, factor, timestamp, mode } = properties;
+        this.id = id;
+        this._offset = offset;
+        this._factor = factor;
+        this.timestamp = timestamp;
+        this.mode = mode;
+    }
+    get factor() {
+        return this._factor;
+    }
+    get offset() {
+        return this._offset;
+    }
+    toReplicationRangeIndexable(key) {
+        return new ReplicationRangeIndexableU64({
+            id: this.id,
+            publicKeyHash: key.hashcode(),
+            offset: this.offset,
+            length: this.factor,
+            timestamp: this.timestamp,
+            mode: this.mode,
+        });
+    }
+};
+__decorate([
+    field({ type: Uint8Array }),
+    __metadata("design:type", Uint8Array)
+], ReplicationRangeMessageU64.prototype, "id", void 0);
+__decorate([
+    field({ type: "u64" }),
+    __metadata("design:type", BigInt)
+], ReplicationRangeMessageU64.prototype, "timestamp", void 0);
+__decorate([
+    field({ type: "u64" }),
+    __metadata("design:type", BigInt)
+], ReplicationRangeMessageU64.prototype, "_offset", void 0);
+__decorate([
+    field({ type: "u64" }),
+    __metadata("design:type", BigInt)
+], ReplicationRangeMessageU64.prototype, "_factor", void 0);
+__decorate([
+    field({ type: "u8" }),
+    __metadata("design:type", Number)
+], ReplicationRangeMessageU64.prototype, "mode", void 0);
+ReplicationRangeMessageU64 = __decorate([
+    variant(1),
+    __metadata("design:paramtypes", [Object])
+], ReplicationRangeMessageU64);
+export { ReplicationRangeMessageU64 };
+class HashableSegmentU32 {
+    start1;
+    end1;
+    start2;
+    end2;
+    mode;
+    constructor(properties) {
+        this.start1 = properties.start1;
+        this.end1 = properties.end1;
+        this.start2 = properties.start2;
+        this.end2 = properties.end2;
+        this.mode = properties.mode;
+    }
+}
+__decorate([
+    field({ type: "u32" }),
+    __metadata("design:type", Number)
+], HashableSegmentU32.prototype, "start1", void 0);
+__decorate([
+    field({ type: "u32" }),
+    __metadata("design:type", Number)
+], HashableSegmentU32.prototype, "end1", void 0);
+__decorate([
+    field({ type: "u32" }),
+    __metadata("design:type", Number)
+], HashableSegmentU32.prototype, "start2", void 0);
+__decorate([
+    field({ type: "u32" }),
+    __metadata("design:type", Number)
+], HashableSegmentU32.prototype, "end2", void 0);
+__decorate([
+    field({ type: "u8" }),
+    __metadata("design:type", Number)
+], HashableSegmentU32.prototype, "mode", void 0);
+class HashableSegmentU64 {
+    start1;
+    end1;
+    start2;
+    end2;
+    mode;
+    constructor(properties) {
+        this.start1 = properties.start1;
+        this.end1 = properties.end1;
+        this.start2 = properties.start2;
+        this.end2 = properties.end2;
+        this.mode = properties.mode;
+    }
+}
+__decorate([
+    field({ type: "u64" }),
+    __metadata("design:type", BigInt)
+], HashableSegmentU64.prototype, "start1", void 0);
+__decorate([
+    field({ type: "u64" }),
+    __metadata("design:type", BigInt)
+], HashableSegmentU64.prototype, "end1", void 0);
+__decorate([
+    field({ type: "u64" }),
+    __metadata("design:type", BigInt)
+], HashableSegmentU64.prototype, "start2", void 0);
+__decorate([
+    field({ type: "u64" }),
+    __metadata("design:type", BigInt)
+], HashableSegmentU64.prototype, "end2", void 0);
+__decorate([
+    field({ type: "u8" }),
+    __metadata("design:type", Number)
+], HashableSegmentU64.prototype, "mode", void 0);
+export class ReplicationRangeIndexableU32 {
     id;
     hash;
     timestamp;
@@ -172,20 +364,12 @@ export class ReplicationRangeIndexable {
         this.hash =
             properties.publicKeyHash ||
                 properties.publicKey.hashcode();
-        if (!properties.normalized) {
-            this.transform({ length: properties.length, offset: properties.offset });
-        }
-        else {
-            this.transform({
-                length: scaleToU32(properties.length),
-                offset: scaleToU32(properties.offset),
-            });
-        }
+        this.transform({ length: properties.length, offset: properties.offset });
         this.mode = properties.mode ?? ReplicationIntent.NonStrict;
         this.timestamp = properties.timestamp || BigInt(0);
     }
     transform(properties) {
-        const ranges = getSegmentsFromOffsetAndRange(properties.offset, properties.length);
+        const ranges = getSegmentsFromOffsetAndRange(properties.offset, properties.length, 0, MAX_U32);
         this.start1 = Math.round(ranges[0][0]);
         this.end1 = Math.round(ranges[0][1]);
         this.start2 = Math.round(ranges[1][0]);
@@ -194,11 +378,11 @@ export class ReplicationRangeIndexable {
             this.end1 -
                 this.start1 +
                 (this.end2 < this.end1 ? this.end2 - this.start2 : 0);
-        if (this.start1 > 0xffffffff ||
-            this.end1 > 0xffffffff ||
-            this.start2 > 0xffffffff ||
-            this.end2 > 0xffffffff ||
-            this.width > 0xffffffff ||
+        if (this.start1 > MAX_U32 ||
+            this.end1 > MAX_U32 ||
+            this.start2 > MAX_U32 ||
+            this.end2 > MAX_U32 ||
+            this.width > MAX_U32 ||
             this.width < 0) {
             throw new Error("Segment coordinate out of bounds");
         }
@@ -223,7 +407,7 @@ export class ReplicationRangeIndexable {
         return false;
     }
     toReplicationRange() {
-        return new ReplicationRange({
+        return new ReplicationRangeMessageU32({
             id: this.id,
             offset: this.start1,
             factor: this.width,
@@ -231,10 +415,6 @@ export class ReplicationRangeIndexable {
             mode: this.mode,
         });
     }
-    distanceTo(point) {
-        let wrappedPoint = MAX_U32 - point;
-        return Math.min(Math.abs(this.start1 - point), Math.abs(this.end2 - point), Math.abs(this.start1 - wrappedPoint), Math.abs(this.end2 - wrappedPoint));
-    }
     get wrapped() {
         return this.end2 < this.end1;
     }
@@ -271,84 +451,371 @@ export class ReplicationRangeIndexable {
     toStringDetailed() {
         return `(hash ${this.hash} range: ${this.toString()})`;
     }
+    toUniqueSegmentId() {
+        // return a unique id as a function of the segments location and the replication intent
+        const hashable = new HashableSegmentU32(this);
+        return sha256Base64Sync(serialize(hashable));
+    }
 }
 __decorate([
     id({ type: Uint8Array }),
     __metadata("design:type", Uint8Array)
-], ReplicationRangeIndexable.prototype, "id", void 0);
+], ReplicationRangeIndexableU32.prototype, "id", void 0);
 __decorate([
     field({ type: "string" }),
     __metadata("design:type", String)
-], ReplicationRangeIndexable.prototype, "hash", void 0);
+], ReplicationRangeIndexableU32.prototype, "hash", void 0);
 __decorate([
     field({ type: "u64" }),
     __metadata("design:type", BigInt)
-], ReplicationRangeIndexable.prototype, "timestamp", void 0);
+], ReplicationRangeIndexableU32.prototype, "timestamp", void 0);
 __decorate([
     field({ type: "u32" }),
     __metadata("design:type", Number)
-], ReplicationRangeIndexable.prototype, "start1", void 0);
+], ReplicationRangeIndexableU32.prototype, "start1", void 0);
 __decorate([
     field({ type: "u32" }),
     __metadata("design:type", Number)
-], ReplicationRangeIndexable.prototype, "end1", void 0);
+], ReplicationRangeIndexableU32.prototype, "end1", void 0);
 __decorate([
     field({ type: "u32" }),
     __metadata("design:type", Number)
-], ReplicationRangeIndexable.prototype, "start2", void 0);
+], ReplicationRangeIndexableU32.prototype, "start2", void 0);
 __decorate([
     field({ type: "u32" }),
     __metadata("design:type", Number)
-], ReplicationRangeIndexable.prototype, "end2", void 0);
+], ReplicationRangeIndexableU32.prototype, "end2", void 0);
 __decorate([
     field({ type: "u32" }),
     __metadata("design:type", Number)
-], ReplicationRangeIndexable.prototype, "width", void 0);
+], ReplicationRangeIndexableU32.prototype, "width", void 0);
 __decorate([
     field({ type: "u8" }),
     __metadata("design:type", Number)
-], ReplicationRangeIndexable.prototype, "mode", void 0);
-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
-    let queries = [
-        new Or([
-            new And([
-                new IntegerCompare({
-                    key: "start1",
-                    compare: Compare.LessOrEqual,
-                    value: point,
-                }),
-                new IntegerCompare({
-                    key: "end1",
-                    compare: Compare.Greater,
-                    value: point,
-                }),
-            ]),
-            new And([
-                new IntegerCompare({
-                    key: "start2",
-                    compare: Compare.LessOrEqual,
-                    value: point,
-                }),
-                new IntegerCompare({
-                    key: "end2",
-                    compare: Compare.Greater,
-                    value: point,
-                }),
-            ]),
-        ]),
-        new IntegerCompare({
+], ReplicationRangeIndexableU32.prototype, "mode", void 0);
+export class ReplicationRangeIndexableU64 {
+    id;
+    hash;
+    timestamp;
+    start1;
+    end1;
+    start2;
+    end2;
+    width;
+    mode;
+    constructor(properties) {
+        this.id = properties.id ?? randomBytes(32);
+        this.hash =
+            properties.publicKeyHash ||
+                properties.publicKey.hashcode();
+        this.transform({ length: properties.length, offset: properties.offset });
+        this.mode = properties.mode ?? ReplicationIntent.NonStrict;
+        this.timestamp = properties.timestamp || BigInt(0);
+    }
+    transform(properties) {
+        const ranges = getSegmentsFromOffsetAndRange(BigInt(properties.offset), BigInt(properties.length), 0n, MAX_U64);
+        this.start1 = ranges[0][0];
+        this.end1 = ranges[0][1];
+        this.start2 = ranges[1][0];
+        this.end2 = ranges[1][1];
+        this.width =
+            this.end1 -
+                this.start1 +
+                (this.end2 < this.end1 ? this.end2 - this.start2 : 0n);
+        if (this.start1 > MAX_U64 ||
+            this.end1 > MAX_U64 ||
+            this.start2 > MAX_U64 ||
+            this.end2 > MAX_U64 ||
+            this.width > MAX_U64 ||
+            this.width < 0n) {
+            throw new Error("Segment coordinate out of bounds");
+        }
+    }
+    get idString() {
+        return toBase64(this.id);
+    }
+    contains(point) {
+        return ((point >= this.start1 && point < this.end1) ||
+            (point >= this.start2 && point < this.end2));
+    }
+    overlaps(other, checkOther = true) {
+        if (this.contains(other.start1) ||
+            this.contains(other.start2) ||
+            this.contains(other.end1 - 1n) ||
+            this.contains(other.end2 - 1n)) {
+            return true;
+        }
+        if (checkOther) {
+            return other.overlaps(this, false);
+        }
+        return false;
+    }
+    toReplicationRange() {
+        return new ReplicationRangeMessageU64({
+            id: this.id,
+            offset: this.start1,
+            factor: this.width,
+            timestamp: this.timestamp,
+            mode: this.mode,
+        });
+    }
+    get wrapped() {
+        return this.end2 < this.end1;
+    }
+    get widthNormalized() {
+        return Number(this.width) / Number(MAX_U64);
+    }
+    equals(other) {
+        if (equals(this.id, other.id) &&
+            this.hash === other.hash &&
+            this.timestamp === other.timestamp &&
+            this.mode === other.mode &&
+            this.start1 === other.start1 &&
+            this.end1 === other.end1 &&
+            this.start2 === other.start2 &&
+            this.end2 === other.end2 &&
+            this.width === other.width) {
+            return true;
+        }
+        return false;
+    }
+    equalRange(other) {
+        return (this.start1 === other.start1 &&
+            this.end1 === other.end1 &&
+            this.start2 === other.start2 &&
+            this.end2 === other.end2);
+    }
+    toString() {
+        let roundToTwoDecimals = (num) => Math.round(num * 100) / 100;
+        if (Math.abs(Number(this.start1 - this.start2)) < 0.0001) {
+            return `([${roundToTwoDecimals(Number(this.start1) / Number(MAX_U64))}, ${roundToTwoDecimals(Number(this.start1) / Number(MAX_U64))}])`;
+        }
+        return `([${roundToTwoDecimals(Number(this.start1) / Number(MAX_U64))}, ${roundToTwoDecimals(Number(this.start1) / Number(MAX_U64))}] [${roundToTwoDecimals(Number(this.start2) / Number(MAX_U64))}, ${roundToTwoDecimals(Number(this.end2) / Number(MAX_U64))}])`;
+    }
+    toStringDetailed() {
+        return `(hash ${this.hash} range: ${this.toString()})`;
+    }
+    toUniqueSegmentId() {
+        // return a unique id as a function of the segments location and the replication intent
+        const hashable = new HashableSegmentU64(this);
+        return sha256Base64Sync(serialize(hashable));
+    }
+}
+__decorate([
+    id({ type: Uint8Array }),
+    __metadata("design:type", Uint8Array)
+], ReplicationRangeIndexableU64.prototype, "id", void 0);
+__decorate([
+    field({ type: "string" }),
+    __metadata("design:type", String)
+], ReplicationRangeIndexableU64.prototype, "hash", void 0);
+__decorate([
+    field({ type: "u64" }),
+    __metadata("design:type", BigInt)
+], ReplicationRangeIndexableU64.prototype, "timestamp", void 0);
+__decorate([
+    field({ type: "u64" }),
+    __metadata("design:type", BigInt)
+], ReplicationRangeIndexableU64.prototype, "start1", void 0);
+__decorate([
+    field({ type: "u64" }),
+    __metadata("design:type", BigInt)
+], ReplicationRangeIndexableU64.prototype, "end1", void 0);
+__decorate([
+    field({ type: "u64" }),
+    __metadata("design:type", BigInt)
+], ReplicationRangeIndexableU64.prototype, "start2", void 0);
+__decorate([
+    field({ type: "u64" }),
+    __metadata("design:type", BigInt)
+], ReplicationRangeIndexableU64.prototype, "end2", void 0);
+__decorate([
+    field({ type: "u64" }),
+    __metadata("design:type", BigInt)
+], ReplicationRangeIndexableU64.prototype, "width", void 0);
+__decorate([
+    field({ type: "u8" }),
+    __metadata("design:type", Number)
+], ReplicationRangeIndexableU64.prototype, "mode", void 0);
+export const mergeRanges = (segments, numbers) => {
+    if (segments.length === 0) {
+        throw new Error("No segments to merge");
+    }
+    if (segments.length === 1) {
+        return segments[0];
+    }
+    // only allow merging from same publicKeyHash
+    const sameHash = segments.every((x) => x.hash === segments[0].hash);
+    if (!sameHash) {
+        throw new Error("Segments have different publicKeyHash");
+    }
+    // only allow merging segments with length 1 (trivial)
+    const sameLength = segments.every((x) => x.width === 1 || x.width === 1n);
+    if (!sameLength) {
+        throw new Error("Segments have different length, only merging of segments length 1 is supported");
+    }
+    const sorted = segments.sort((a, b) => Number(a.start1 - b.start1));
+    let calculateLargeGap = () => {
+        let last = sorted[sorted.length - 1];
+        let largestArc = numbers.zero;
+        let largestArcIndex = -1;
+        for (let i = 0; i < sorted.length; i++) {
+            const current = sorted[i];
+            if (current.start1 !== last.start1) {
+                let arc = numbers.zero;
+                if (current.start1 < last.end2) {
+                    arc += (numbers.maxValue - last.end2);
+                    arc += (current.start1 - numbers.zero);
+                }
+                else {
+                    arc += (current.start1 - last.end2);
+                }
+                if (arc > largestArc) {
+                    largestArc = arc;
+                    largestArcIndex = i;
+                }
+            }
+            last = current;
+        }
+        return [largestArc, largestArcIndex];
+    };
+    const [largestArc, largestArcIndex] = calculateLargeGap();
+    let totalLengthFinal = numbers.maxValue - largestArc;
+    if (largestArcIndex === -1) {
+        return segments[0]; // all ranges are the same
+    }
+    // use segments[0] constructor to create a new object
+    const proto = segments[0].constructor;
+    return new proto({
+        length: totalLengthFinal,
+        offset: segments[largestArcIndex].start1,
+        publicKeyHash: segments[0].hash,
+    });
+};
+const createContainingPointQuery = (points, options) => {
+    const or = [];
+    for (const point of Array.isArray(points) ? points : [points]) {
+        or.push(new And([
+            new IntegerCompare({
+                key: "start1",
+                compare: Compare.LessOrEqual,
+                value: point,
+            }),
+            new IntegerCompare({
+                key: "end1",
+                compare: Compare.Greater,
+                value: point,
+            }),
+        ]));
+        or.push(new And([
+            new IntegerCompare({
+                key: "start2",
+                compare: Compare.LessOrEqual,
+                value: point,
+            }),
+            new IntegerCompare({
+                key: "end2",
+                compare: Compare.Greater,
+                value: point,
+            }),
+        ]));
+    }
+    if (options?.time) {
+        let queries = [
+            new Or(or),
+            new IntegerCompare({
+                key: "timestamp",
+                compare: options.time.matured ? Compare.LessOrEqual : Compare.Greater,
+                value: BigInt(options.time.now - options.time.roleAgeLimit),
+            }),
+        ];
+        return queries;
+    }
+    else {
+        return new Or(or);
+    }
+};
+const createContainingPartialPointQuery = (point, first, options) => {
+    let query;
+    if (first) {
+        query = [
+            new IntegerCompare({
+                key: "start1",
+                compare: Compare.LessOrEqual,
+                value: point,
+            }),
+            new IntegerCompare({
+                key: "end1",
+                compare: Compare.Greater,
+                value: point,
+            }),
+        ];
+    }
+    else {
+        query = [
+            new IntegerCompare({
+                key: "start2",
+                compare: Compare.LessOrEqual,
+                value: point,
+            }),
+            new IntegerCompare({
+                key: "end2",
+                compare: Compare.Greater,
+                value: point,
+            }),
+        ];
+    }
+    if (options?.time) {
+        query.push(new IntegerCompare({
             key: "timestamp",
-            compare: matured ? Compare.LessOrEqual : Compare.Greater,
-            value: BigInt(now - roleAgeLimit),
-        }),
-    ];
+            compare: options.time.matured ? Compare.LessOrEqual : Compare.Greater,
+            value: BigInt(options.time.now - options.time.roleAgeLimit),
+        }));
+    }
+    return query;
+};
+const iterateRangesContainingPoint = (rects, points, 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
     return rects.iterate({
-        query: queries,
+        query: createContainingPointQuery(points, {
+            time: options?.time,
+        }), // new Or(points.map(point => new And(createContainingPointQuery(point, roleAgeLimit, matured, now)))
         sort: options?.sort,
     }, options);
 };
-const getClosest = (direction, rects, point, roleAgeLimit, matured, now, includeStrict, options) => {
+const allRangesContainingPoint = async (rects, points, 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
+    let allResults = [];
+    for (const point of Array.isArray(points) ? points : [points]) {
+        const firstIterator = rects.iterate({
+            query: createContainingPartialPointQuery(point, false, options),
+            sort: options?.sort,
+        }, options);
+        const secondIterator = rects.iterate({
+            query: createContainingPartialPointQuery(point, true, options),
+            sort: options?.sort,
+        }, options);
+        [...(await firstIterator.all()), ...(await secondIterator.all())].forEach((x) => allResults.push(x));
+    }
+    return allResults;
+    /* return [...await iterateRangesContainingPoint(rects, points, options).all()]; */
+};
+const countRangesContainingPoint = async (rects, point, options) => {
+    return rects.count({
+        query: createContainingPointQuery(point, options),
+    });
+};
+export const appromixateCoverage = async (properties) => {
+    const grid = properties.numbers.getGrid(properties.numbers.zero, properties.samples);
+    /* const now = +new Date(); */
+    let hits = 0;
+    for (const point of grid) {
+        const count = await countRangesContainingPoint(properties.peers, point);
+        hits += properties.normalized ? (count > 0 ? 1 : 0) : count;
+    }
+    return hits / properties.samples;
+};
+const getClosest = (direction, rects, point, roleAgeLimit, matured, now, includeStrict, numbers, options) => {
     const createQueries = (p, equality) => {
         let queries;
         if (direction === "below") {
@@ -402,7 +869,7 @@ const getClosest = (direction, rects, point, roleAgeLimit, matured, now, include
         ],
     }, options);
     const iteratorWrapped = rects.iterate({
-        query: createQueries(direction === "below" ? MAX_U32 : 0, true),
+        query: createQueries(direction === "below" ? numbers.maxValue : numbers.zero, true),
         sort: [
             direction === "below"
                 ? new Sort({ key: ["end2"], direction: "desc" })
@@ -411,63 +878,68 @@ const getClosest = (direction, rects, point, roleAgeLimit, matured, now, include
             sortByHash,
         ],
     }, options);
-    return joinIterator([iterator, iteratorWrapped], point, direction);
+    return joinIterator([iterator, iteratorWrapped], point, direction, numbers);
 };
-export const hasCoveringRange = async (rects, range) => {
-    return ((await rects.count({
-        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,
-                    }),
-                ]),
+export const getCoveringRangeQuery = (range) => {
+    return [
+        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 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 And([
+                new IntegerCompare({
+                    key: "start2",
+                    compare: Compare.LessOrEqual,
+                    value: range.start2,
+                }),
+                new IntegerCompare({
+                    key: "end2",
+                    compare: Compare.GreaterOrEqual,
+                    value: range.end2,
+                }),
             ]),
+        ]),
+    ];
+};
+export const iHaveCoveringRange = async (rects, range) => {
+    return ((await rects.count({
+        query: [
+            ...getCoveringRangeQuery(range),
             new StringMatch({
                 key: "hash",
                 value: range.hash,
@@ -480,34 +952,33 @@ export const hasCoveringRange = async (rects, range) => {
         ],
     })) > 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
-    // if direction is 'closest' then the shortest distance is the distance
-    // also from is 0.1 and to is 0.9, then distance should be 0.2 not 0.8
-    // same as for if from is 0.9 and to is 0.1, then distance should be 0.2 not 0.8
+// TODO
+export function getDistance(from, to, direction, end) {
+    const abs = (value) => value < 0 ? -value : value;
+    const diff = (a, b) => abs(a - b);
     if (direction === "closest") {
         if (from === to) {
-            return 0;
+            return typeof from === "number" ? 0 : 0n; // returns 0 of the correct type
         }
-        return Math.min(Math.abs(from - to), Math.abs(end - Math.abs(from - to)));
+        return diff(from, to) < diff(end, diff(from, to))
+            ? diff(from, to)
+            : diff(end, diff(from, to));
     }
     if (direction === "above") {
         if (from <= to) {
-            return Math.abs(end - to) + from;
+            return end - to + from;
         }
         return from - to;
     }
     if (direction === "below") {
         if (from >= to) {
-            return Math.abs(end - from) + to;
+            return end - from + to;
         }
         return to - from;
     }
     throw new Error("Invalid direction");
-};
-const joinIterator = (iterators, point, direction) => {
+}
+const joinIterator = (iterators, point, direction, numbers) => {
     let queues = [];
     return {
         next: async (count) => {
@@ -525,13 +996,13 @@ const joinIterator = (iterators, point, direction) => {
                         const closest = el.value;
                         let dist;
                         if (direction === "closest") {
-                            dist = Math.min(getDistance(closest.start1, point, direction), getDistance(closest.end2, point, direction));
+                            dist = numbers.min(getDistance(closest.start1, point, direction, numbers.maxValue), getDistance(closest.end2, point, direction, numbers.maxValue));
                         }
                         else if (direction === "above") {
-                            dist = getDistance(closest.start1, point, direction);
+                            dist = getDistance(closest.start1, point, direction, numbers.maxValue);
                         }
                         else if (direction === "below") {
-                            dist = getDistance(closest.end2, point, direction);
+                            dist = getDistance(closest.end2, point, direction, numbers.maxValue);
                         }
                         else {
                             throw new Error("Invalid direction");
@@ -543,7 +1014,7 @@ const joinIterator = (iterators, point, direction) => {
             // pull the 'count' the closest element from one of the queue
             for (let i = 0; i < count; i++) {
                 let closestQueue = -1;
-                let closestDist = Number.MAX_SAFE_INTEGER;
+                let closestDist = Number.MAX_VALUE;
                 for (let j = 0; j < queues.length; j++) {
                     let queue = queues[j];
                     if (queue && queue.elements.length > 0) {
@@ -584,25 +1055,84 @@ const joinIterator = (iterators, point, direction) => {
         },
     };
 };
-const getClosestAround = (peers, point, roleAge, now, includeStrictBelow, includeStrictAbove, options) => {
-    const closestBelow = getClosest("below", peers, point, roleAge, true, now, includeStrictBelow, options);
-    const closestAbove = getClosest("above", peers, point, roleAge, true, now, includeStrictAbove, options);
-    const containing = containingPoint(peers, point, roleAge, true, now, options);
-    return iteratorInSeries(containing, joinIterator([closestBelow, closestAbove], point, "closest"));
+const getClosestAround = (peers, point, roleAge, now, includeStrictBelow, includeStrictAbove, numbers, options) => {
+    const closestBelow = getClosest("below", peers, point, roleAge, true, now, includeStrictBelow, numbers, options);
+    const closestAbove = getClosest("above", peers, point, roleAge, true, now, includeStrictAbove, numbers, options);
+    /* const containing = iterateRangesContainingPoint<S, R>(
+        peers,
+        point,
+        {
+            time: {
+                roleAgeLimit: roleAge,
+                matured: true,
+                now,
+            }
+        }
+    );
+
+    return iteratorInSeries(
+        containing,
+        joinIterator<S, R>([closestBelow, closestAbove], point, "closest", numbers),
+    ); */
+    return joinIterator([closestBelow, closestAbove], point, "closest", numbers);
+};
+export const isMatured = (segment, now, minAge) => {
+    return now - Number(segment.timestamp) >= minAge;
 };
-const collectNodesAroundPoint = async (roleAge, peers, collector, point, now, done = () => true) => {
-    /* let shape = { timestamp: true, hash: true } as const */
-    const containing = containingPoint(peers, point, 0, true, now /* , { shape } */);
+/*
+
+const collectNodesAroundPoint = async <R extends "u32" | "u64">(
+    roleAge: number,
+    peers: Index<ReplicationRangeIndexable<R>>,
+    collector: (
+        rect: { hash: string },
+        matured: boolean,
+        intersecting: boolean,
+    ) => void,
+    point: NumberFromType<R>,
+    now: number,
+    numbers: Numbers<R>,
+    done: () => boolean = () => true,
+) => {
+    const containing = iterateRangesContainingPoint<
+        { timestamp: true, hash: true },
+        R
+    >(peers, point, 0, true, now, { shape: { timestamp: true, hash: true } as const });
     const allContaining = await containing.all();
     for (const rect of allContaining) {
         collector(rect.value, isMatured(rect.value, now, roleAge), true);
     }
+
     if (done()) {
         return;
     }
-    const closestBelow = getClosest("below", peers, point, 0, true, now, false /* , { shape } */);
-    const closestAbove = getClosest("above", peers, point, 0, true, now, false /* , { shape } */);
-    const aroundIterator = joinIterator([closestBelow, closestAbove], point, "closest");
+
+    const closestBelow = getClosest<undefined, R>(
+        "below",
+        peers,
+        point,
+        0,
+        true,
+        now,
+        false,
+        numbers
+    );
+    const closestAbove = getClosest<undefined, R>(
+        "above",
+        peers,
+        point,
+        0,
+        true,
+        now,
+        false,
+        numbers
+    );
+    const aroundIterator = joinIterator<undefined, R>(
+        [closestBelow, closestAbove],
+        point,
+        "closest",
+        numbers,
+    );
     while (aroundIterator.done() !== true && done() !== true) {
         const res = await aroundIterator.next(1);
         for (const rect of res) {
@@ -613,45 +1143,87 @@ const collectNodesAroundPoint = async (roleAge, peers, collector, point, now, do
         }
     }
 };
-export const getEvenlySpacedU32 = (from, count) => {
-    let ret = new Array(count);
-    for (let i = 0; i < count; i++) {
-        ret[i] = Math.round(from + (i * MAX_U32) / count) % MAX_U32;
+ */
+const collectClosestAround = async (roleAge, peers, collector, point, now, numbers, done = () => true) => {
+    const closestBelow = getClosest("below", peers, point, 0, true, now, false, numbers);
+    const closestAbove = getClosest("above", peers, point, 0, true, now, false, numbers);
+    /* 	const containingIterator = iterateRangesContainingPoint<undefined, R>(
+            peers,
+            point,
+        );
+     */
+    const aroundIterator = joinIterator([/* containingIterator,  */ closestBelow, closestAbove], point, "closest", numbers);
+    let visited = new Set();
+    while (aroundIterator.done() !== true && done() !== true) {
+        const res = await aroundIterator.next(100);
+        for (const rect of res) {
+            visited.add(rect.value.idString);
+            collector(rect.value, isMatured(rect.value, now, roleAge));
+            if (done()) {
+                return;
+            }
+        }
     }
-    return ret;
-};
-export const isMatured = (segment, now, minAge) => {
-    return now - Number(segment.timestamp) >= minAge;
 };
 // get peer sample that are responsible for the cursor point
 // will return a list of peers that want to replicate the data,
 // but also if necessary a list of peers that are responsible for the data
 // but have not explicitly replicating a range that cover the cursor point
-export const getSamples = async (cursor, peers, roleAge) => {
+export const getSamples = async (cursor, peers, roleAge, numbers, options) => {
     const leaders = new Map();
     if (!peers) {
         return new Map();
     }
     const now = +new Date();
-    const maturedLeaders = new Set();
+    let matured = 0;
+    /* let missingForCursors: NumberFromType<R>[] = [] */
+    let uniqueVisited = new Set();
     for (let i = 0; i < cursor.length; i++) {
-        // evenly distributed
-        // aquire at least one unique node for each point
-        await collectNodesAroundPoint(roleAge, peers, (rect, m, intersecting) => {
-            if (m) {
-                maturedLeaders.add(rect.hash);
+        let point = cursor[i];
+        const allContaining = await allRangesContainingPoint(peers, point);
+        for (const rect of allContaining) {
+            uniqueVisited.add(rect.value.hash);
+            let prev = leaders.get(rect.value.hash);
+            if (!prev) {
+                if (isMatured(rect.value, now, roleAge)) {
+                    matured++;
+                }
+                leaders.set(rect.value.hash, { intersecting: true });
             }
-            const prev = leaders.get(rect.hash);
-            if (!prev || (intersecting && !prev.intersecting)) {
-                leaders.set(rect.hash, { intersecting });
+            else {
+                prev.intersecting = true;
             }
-        }, cursor[i], now, () => {
-            if (maturedLeaders.size > i) {
-                return true;
+        }
+        if (options?.uniqueReplicators) {
+            if (options.uniqueReplicators.size === leaders.size ||
+                options.uniqueReplicators.size === uniqueVisited.size) {
+                break; // nothing more to find
             }
-            return false;
-        });
+        }
+        if (options?.onlyIntersecting || matured > i) {
+            continue;
+        }
+        let foundOneUniqueMatured = false;
+        await collectClosestAround(roleAge, peers, (rect, m) => {
+            uniqueVisited.add(rect.hash);
+            const prev = leaders.get(rect.hash);
+            if (m) {
+                if (!prev) {
+                    matured++;
+                    leaders.set(rect.hash, { intersecting: false });
+                }
+                if (matured > i) {
+                    foundOneUniqueMatured = true;
+                }
+            }
+        }, point, now, numbers, () => foundOneUniqueMatured);
+        /* if (!foundOneUniqueMatured) {
+            missingForCursors.push(point);
+        } */
     }
+    /* if (leaders.size < cursor.length) {
+        throw new Error("Missing leaders got: " + leaders.size + " -- expected -- " + cursor.length + " role age " + roleAge + " missing " + missingForCursors.length + " replication index size: " + (await peers.count()));
+    } */
     return leaders;
 };
 const fetchOne = async (iterator) => {
@@ -659,20 +1231,19 @@ const fetchOne = async (iterator) => {
     await iterator.close();
     return value[0]?.value;
 };
-export const minimumWidthToCover = async (minReplicas /* , replicatorCount: number */) => {
+export const minimumWidthToCover = async (minReplicas /* , replicatorCount: number */, numbers) => {
     /* 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);
+    let widthToCoverScaled = numbers.divRound(numbers.maxValue, 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);
+    const { startNode, startLocation, endLocation } = await getStartAndEnd(peers, start, widthToCoverScaled, roleAge, now, properties.numbers);
     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
@@ -705,14 +1276,19 @@ export const getCoverSet = async (properties) => {
     // push edges
     ret.add(current.hash);
     const resolveNextContaining = async (nextLocation, roleAge) => {
-        let next = await fetchOne(containingPoint(peers, nextLocation, roleAge, true, now, {
+        let next = await fetchOne(iterateRangesContainingPoint(peers, nextLocation, {
             sort: [new Sort({ key: "end2", direction: SortDirection.DESC })],
+            time: {
+                matured: true,
+                roleAgeLimit: roleAge,
+                now,
+            },
         })); // get entersecting sort by largest end2
         return next;
     };
     const resolveNextAbove = async (nextLocation, roleAge) => {
         // if not get closest from above
-        let next = await fetchOne(getClosest("above", peers, nextLocation, roleAge, true, now, true));
+        let next = await fetchOne(getClosest("above", peers, nextLocation, roleAge, true, now, true, properties.numbers));
         return next;
     };
     const resolveNext = async (nextLocation, roleAge) => {
@@ -724,14 +1300,17 @@ export const getCoverSet = async (properties) => {
     };
     // fill the middle
     let wrappedOnce = current.end2 < current.end1;
-    let coveredLength = 0;
+    let coveredLength = properties.numbers.zero;
     const addLength = (from) => {
         if (current.end2 < from || current.wrapped) {
             wrappedOnce = true;
-            coveredLength += MAX_U32 - from;
+            // @ts-ignore
+            coveredLength += properties.numbers.maxValue - from;
+            // @ts-ignore
             coveredLength += current.end2;
         }
         else {
+            // @ts-ignore
             coveredLength += current.end1 - from;
         }
     };
@@ -739,7 +1318,7 @@ export const getCoverSet = async (properties) => {
     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
+        coveredLength <= properties.numbers.maxValue // eslint-disable-line no-unmodified-loop-condition
     ) {
         let nextCandidate = await resolveNext(nextLocation, roleAge);
         /* let fromAbove = false; */
@@ -764,8 +1343,8 @@ export const getCoverSet = async (properties) => {
             coveredLength >= widthToCoverScaled;
         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"))) {
+            properties.numbers.min(getDistance(last.start1, endLocation, "closest", properties.numbers.maxValue), getDistance(last.end2, endLocation, "closest", properties.numbers.maxValue)) >
+                properties.numbers.min(getDistance(current.start1, endLocation, "closest", properties.numbers.maxValue), getDistance(current.end2, endLocation, "closest", properties.numbers.maxValue))) {
             ret.add(current.hash);
         }
         if (isLast && !nextCandidate[1] /*  || equals(endRect.id, current.id) */) {
@@ -776,9 +1355,9 @@ export const getCoverSet = async (properties) => {
         }
         nextLocation = endIsWrapped
             ? wrappedOnce
-                ? Math.min(current.end2, endLocation)
+                ? properties.numbers.min(current.end2, endLocation)
                 : current.end2
-            : Math.min(current.end2, endLocation);
+            : properties.numbers.min(current.end2, endLocation);
     }
     start instanceof PublicSignKey && ret.add(start.hashcode());
     return ret;
@@ -787,53 +1366,58 @@ export const getCoverSet = async (properties) => {
     // reduce the change set to only regions that are changed for each peer
     // i.e. subtract removed regions from added regions, and vice versa
     const result = new Map<string, { range: ReplicationRangeIndexable, added: boolean }[]>();
-
+    
     for (const addedChange of changes.added ?? []) {
         let prev = result.get(addedChange.hash) ?? [];
         for (const [_hash, ranges] of result.entries()) {
             for (const r of ranges) {
-
+    
             }
         }
     }
 }
  */
-const matchRangeQuery = (range) => {
-    let ors = [];
-    ors.push(new And([
+export const matchEntriesInRangeQuery = (range) => {
+    const c1 = new And([
         new IntegerCompare({
-            key: "coordinate",
+            key: "coordinates",
             compare: "gte",
             value: range.start1,
         }),
         new IntegerCompare({
-            key: "coordinate",
+            key: "coordinates",
             compare: "lt",
             value: range.end1,
         }),
-    ]));
-    ors.push(new And([
-        new IntegerCompare({
-            key: "coordinate",
-            compare: "gte",
-            value: range.start2,
-        }),
-        new IntegerCompare({
-            key: "coordinate",
-            compare: "lt",
-            value: range.end2,
-        }),
-    ]));
+    ]);
+    if (range.start2 === range.end2) {
+        return c1;
+    }
+    let ors = [
+        c1,
+        new And([
+            new IntegerCompare({
+                key: "coordinates",
+                compare: "gte",
+                value: range.start2,
+            }),
+            new IntegerCompare({
+                key: "coordinates",
+                compare: "lt",
+                value: range.end2,
+            }),
+        ]),
+    ];
     return new Or(ors);
 };
 export const toRebalance = (changes, index) => {
     const assignedRangesQuery = (changes) => {
         let ors = [];
         for (const change of changes) {
-            const matchRange = matchRangeQuery(change.range);
+            const matchRange = matchEntriesInRangeQuery(change.range);
             if (change.type === "updated") {
                 // assuming a range is to be removed, is this entry still enoughly replicated
-                const prevMatchRange = matchRangeQuery(change.prev);
+                const prevMatchRange = matchEntriesInRangeQuery(change.prev);
                 ors.push(prevMatchRange);
                 ors.push(matchRange);
             }
@@ -855,17 +1439,19 @@ export const toRebalance = (changes, index) => {
                 query: assignedRangesQuery(changes),
             });
             while (iterator.done() !== true) {
-                const entries = await iterator.next(1000); // TODO choose right batch sizes here for optimal memory usage / speed
-                // TODO do we need this
-                const grouped = await groupByGidSync(entries.map((x) => x.value));
+                const entries = await iterator.all(); // TODO choose right batch sizes here for optimal memory usage / speed
+                /* const grouped = await groupByGidSync(entries.map((x) => x.value));
                 for (const [gid, entries] of grouped.entries()) {
                     yield { gid, entries };
+                } */
+                for (const entry of entries) {
+                    yield entry.value;
                 }
             }
         },
     };
 };
-export const fetchOneFromPublicKey = async (publicKey, index, roleAge, now, options) => {
+export const fetchOneFromPublicKey = async (publicKey, index, roleAge, now, numbers, options) => {
     let iterator = index.iterate({
         query: [new StringMatch({ key: "hash", value: publicKey.hashcode() })],
     }, options);
@@ -874,7 +1460,7 @@ export const fetchOneFromPublicKey = async (publicKey, index, roleAge, now, opti
     let node = result[0]?.value;
     if (node) {
         if (!isMatured(node, now, roleAge)) {
-            const matured = await fetchOne(getClosestAround(index, node.start1, roleAge, now, false, false, options));
+            const matured = await fetchOne(getClosestAround(index, node.start1, roleAge, now, false, false, numbers, options));
             if (matured) {
                 node = matured;
             }
@@ -882,17 +1468,17 @@ export const fetchOneFromPublicKey = async (publicKey, index, roleAge, now, opti
     }
     return node;
 };
-export const getStartAndEnd = async (peers, start, widthToCoverScaled, roleAge, now, intervalWidth, options) => {
+export const getStartAndEnd = async (peers, start, widthToCoverScaled, roleAge, now, numbers, options) => {
     // find a good starting point
     let startNode = undefined;
     let startLocation = undefined;
-    const nodeFromPoint = async (point = scaleToU32(Math.random())) => {
+    const nodeFromPoint = async (point = numbers.random()) => {
         startLocation = point;
-        startNode = await fetchOneClosest(peers, startLocation, roleAge, now, false, true, options);
+        startNode = await fetchOneClosest(peers, startLocation, roleAge, now, false, true, numbers, options);
     };
     if (start instanceof PublicSignKey) {
         // start at our node (local first)
-        startNode = await fetchOneFromPublicKey(start, peers, roleAge, now, options);
+        startNode = await fetchOneFromPublicKey(start, peers, roleAge, now, numbers, options);
         if (!startNode) {
             // fetch randomly
             await nodeFromPoint();
@@ -901,38 +1487,49 @@ export const getStartAndEnd = async (peers, start, widthToCoverScaled, roleAge,
             startLocation = startNode.start1;
         }
     }
-    else if (typeof start === "number") {
+    else if (typeof start === "number" || typeof start === "bigint") {
         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;
+        return {
+            startNode: undefined,
+            startLocation: numbers.zero,
+            endLocation: numbers.zero,
+        };
     }
-    else {
-        coveredDistanceToStart += startNode.start1 - startLocation;
-    }
-    if (startNode.mode === ReplicationIntent.Strict &&
-        coveredDistanceToStart > widthToCoverScaled) {
-        return { startNode: undefined, startLocation: 0, endLocation: 0 };
+    // @ts-ignore
+    let endLocation = (startLocation + widthToCoverScaled) % numbers.maxValue;
+    // if the start node range is not containing the start point, then figure out if the startNode is ideal
+    if (!startNode.contains(startLocation)) {
+        let coveredDistanceToStart = numbers.zero;
+        if (startNode.start1 < startLocation) {
+            coveredDistanceToStart +=
+                numbers.maxValue - startLocation + startNode.start1;
+        }
+        else {
+            coveredDistanceToStart += (startNode.start1 -
+                startLocation);
+        }
+        // in this case, the gap to the start point is larger than the width we want to cover. Assume there are no good points
+        if (startNode.mode === ReplicationIntent.Strict &&
+            coveredDistanceToStart > widthToCoverScaled) {
+            return {
+                startNode: undefined,
+                startLocation: numbers.zero,
+                endLocation: numbers.zero,
+            };
+        }
     }
     return {
         startNode,
-        startLocation: Math.round(startLocation),
-        endLocation: Math.round(endLocation),
+        startLocation,
+        endLocation,
     };
 };
-export const fetchOneClosest = (peers, point, roleAge, now, includeStrictBelow, includeStrictAbove, options) => {
-    return fetchOne(getClosestAround(peers, point, roleAge, now, includeStrictBelow, includeStrictAbove, options));
+export const fetchOneClosest = (peers, point, roleAge, now, includeStrictBelow, includeStrictAbove, numbers, options) => {
+    return fetchOne(getClosestAround(peers, point, roleAge, now, includeStrictBelow, includeStrictAbove, numbers, options));
 };
 //# sourceMappingURL=ranges.js.map