@peerbit/shared-log 4.0.11 → 5.0.0

package/src/index.ts

@@ -48,7 +48,7 @@ import { CustomEvent } from "@libp2p/interface";
 import yallist from "yallist";
 import {
 	AcknowledgeDelivery,
-	AnyWhere,
+	DeliveryMode,
 	SeekDelivery,
 	SilentDelivery
 } from "@peerbit/stream-interface";
@@ -121,22 +121,25 @@ const isAdaptiveReplicatorOption = (
 	return false;
 };
 
-export type SharedLogOptions = {
+export type SharedLogOptions<T> = {
 	role?: RoleOptions;
 	replicas?: ReplicationLimitsOptions;
 	respondToIHaveTimeout?: number;
 	canReplicate?: (publicKey: PublicSignKey) => Promise<boolean> | boolean;
+	sync?: (entry: Entry<T>) => boolean;
+	timeUntilRoleMaturity?: number;
 };
 
 export const DEFAULT_MIN_REPLICAS = 2;
 export const WAIT_FOR_REPLICATOR_TIMEOUT = 9000;
 export const WAIT_FOR_ROLE_MATURITY = 5000;
-const REBALANCE_DEBOUNCE_INTERAVAL = 30;
+const REBALANCE_DEBOUNCE_INTERVAL = 100;
 
-export type Args<T> = LogProperties<T> & LogEvents<T> & SharedLogOptions;
+export type Args<T> = LogProperties<T> & LogEvents<T> & SharedLogOptions<T>;
 
 export type SharedAppendOptions<T> = AppendOptions<T> & {
 	replicas?: AbsoluteReplicas | number;
+	target?: "all" | "replicators";
 };
 
 type UpdateRoleEvent = { publicKey: PublicSignKey; role: Role };
@@ -195,12 +198,16 @@ export class SharedLog<T = Uint8Array> extends Program<
 
 	private openTime: number;
 
+	private sync?: (entry: Entry<T>) => boolean;
+
 	private rebalanceParticipationDebounced:
 		| ReturnType<typeof debounce>
 		| undefined;
 
 	replicas: ReplicationLimits;
 
+	timeUntilRoleMaturity: number;
+
 	constructor(properties?: { id?: Uint8Array }) {
 		super();
 		this.log = new Log(properties);
@@ -219,9 +226,8 @@ export class SharedLog<T = Uint8Array> extends Program<
 		this.rebalanceParticipationDebounced = debounce(
 			() => this.rebalanceParticipation(),
 			Math.max(
-				REBALANCE_DEBOUNCE_INTERAVAL,
-				(this.getReplicatorsSorted()?.length || 0) *
-					REBALANCE_DEBOUNCE_INTERAVAL
+				REBALANCE_DEBOUNCE_INTERVAL,
+				(this.getReplicatorsSorted()?.length || 0) * REBALANCE_DEBOUNCE_INTERVAL
 			)
 		);
 	}
@@ -229,10 +235,13 @@ export class SharedLog<T = Uint8Array> extends Program<
 		this.rebalanceParticipationDebounced = undefined;
 
 		const setupDebouncedRebalancing = (options?: AdaptiveReplicatorOptions) => {
-			this.replicationController = new PIDReplicationController({
-				targetMemoryLimit: options?.limits?.memory,
-				errorFunction: options?.error
-			});
+			this.replicationController = new PIDReplicationController(
+				this.node.identity.publicKey.hashcode(),
+				{
+					targetMemoryLimit: options?.limits?.memory,
+					errorFunction: options?.error
+				}
+			);
 
 			this.setupRebalanceDebounceFunction();
 		};
@@ -250,7 +259,10 @@ export class SharedLog<T = Uint8Array> extends Program<
 					setupDebouncedRebalancing(options);
 					this._roleOptions = options;
 				} else {
-					this._roleOptions = new Replicator({ factor: options.factor });
+					this._roleOptions = new Replicator({
+						factor: options.factor,
+						offset: hashToUniformNumber(this.node.identity.publicKey.bytes)
+					});
 				}
 			} else {
 				this._roleOptions = new Observer();
@@ -272,11 +284,13 @@ export class SharedLog<T = Uint8Array> extends Program<
 			if (this._roleOptions.limits) {
 				this._role = new Replicator({
 					// initial role in a dynamic setup
-					factor: 1
+					factor: 1,
+					offset: hashToUniformNumber(this.node.identity.publicKey.bytes)
 				});
 			} else {
 				this._role = new Replicator({
-					factor: 1
+					factor: 1,
+					offset: hashToUniformNumber(this.node.identity.publicKey.bytes)
 				});
 			}
 		}
@@ -338,11 +352,20 @@ export class SharedLog<T = Uint8Array> extends Program<
 		}
 
 		const result = await this.log.append(data, appendOptions);
-		const leaders = await this.findLeaders(
-			result.entry.meta.gid,
-			decodeReplicas(result.entry).getValue(this)
-		);
-		const isLeader = leaders.includes(this.node.identity.publicKey.hashcode());
+		let mode: DeliveryMode | undefined = undefined;
+
+		if (options?.target === "replicators" || !options?.target) {
+			const leaders = await this.findLeaders(
+				result.entry.meta.gid,
+				decodeReplicas(result.entry).getValue(this)
+			);
+			const isLeader = leaders.includes(
+				this.node.identity.publicKey.hashcode()
+			);
+			mode = isLeader
+				? new SilentDelivery({ redundancy: 1, to: leaders })
+				: new AcknowledgeDelivery({ redundancy: 1, to: leaders });
+		}
 
 		await this.rpc.send(
 			await createExchangeHeadsMessage(
@@ -351,9 +374,7 @@ export class SharedLog<T = Uint8Array> extends Program<
 				this._gidParentCache
 			),
 			{
-				mode: isLeader
-					? new SilentDelivery({ redundancy: 1, to: leaders })
-					: new AcknowledgeDelivery({ redundancy: 1, to: leaders })
+				mode
 			}
 		);
 
@@ -381,11 +402,13 @@ export class SharedLog<T = Uint8Array> extends Program<
 		this._pendingIHave = new Map();
 		this.latestRoleMessages = new Map();
 		this.openTime = +new Date();
-
+		this.timeUntilRoleMaturity =
+			options?.timeUntilRoleMaturity || WAIT_FOR_ROLE_MATURITY;
 		this._gidParentCache = new Cache({ max: 1000 });
 		this._closeController = new AbortController();
 
 		this._canReplicate = options?.canReplicate;
+		this.sync = options?.sync;
 		this._logProperties = options;
 
 		this.setupRole(options?.role);
@@ -414,17 +437,6 @@ export class SharedLog<T = Uint8Array> extends Program<
 		this._sortedPeersCache = yallist.create();
 		this._gidPeersHistory = new Map();
 
-		await this.node.services.pubsub.addEventListener(
-			"subscribe",
-			this._onSubscriptionFn
-		);
-
-		this._onUnsubscriptionFn = this._onUnsubscription.bind(this);
-		await this.node.services.pubsub.addEventListener(
-			"unsubscribe",
-			this._onUnsubscriptionFn
-		);
-
 		const cache = await storage.sublevel("cache");
 
 		await this.log.open(this.remoteBlocks, this.node.identity, {
@@ -484,6 +496,17 @@ export class SharedLog<T = Uint8Array> extends Program<
 			topic: this.topic
 		});
 
+		await this.node.services.pubsub.addEventListener(
+			"subscribe",
+			this._onSubscriptionFn
+		);
+
+		this._onUnsubscriptionFn = this._onUnsubscription.bind(this);
+		await this.node.services.pubsub.addEventListener(
+			"unsubscribe",
+			this._onUnsubscriptionFn
+		);
+
 		await this.log.load();
 	}
 
@@ -612,8 +635,6 @@ export class SharedLog<T = Uint8Array> extends Program<
 					const groupedByGid = await groupByGid(filteredHeads);
 					const promises: Promise<void>[] = [];
 
-					/// console.log("ADD CACHE", this.node.identity.publicKey.hashcode(), context.from!.hashcode(), groupedByGid.size)
-
 					for (const [gid, entries] of groupedByGid) {
 						const fn = async () => {
 							const headsWithGid = this.log.headsIndex.gids.get(gid);
@@ -628,10 +649,15 @@ export class SharedLog<T = Uint8Array> extends Program<
 								entries.map((x) => x.entry)
 							);
 
-							const leaders = await this.waitForIsLeader(
-								gid,
-								Math.max(maxReplicasFromHead, maxReplicasFromNewEntries)
-							);
+							const leaders = await (this.role instanceof Observer
+								? this.findLeaders(
+										gid,
+										Math.max(maxReplicasFromHead, maxReplicasFromNewEntries)
+									)
+								: this.waitForIsLeader(
+										gid,
+										Math.max(maxReplicasFromHead, maxReplicasFromNewEntries)
+									));
 							const isLeader = !!leaders;
 							if (isLeader) {
 								if (leaders.find((x) => x === context.from!.hashcode())) {
@@ -649,7 +675,7 @@ export class SharedLog<T = Uint8Array> extends Program<
 							}
 
 							outer: for (const entry of entries) {
-								if (isLeader) {
+								if (isLeader || this.sync?.(entry.entry)) {
 									toMerge.push(entry);
 								} else {
 									for (const ref of entry.references) {
@@ -754,7 +780,6 @@ export class SharedLog<T = Uint8Array> extends Program<
 								}
 
 								prevPendingIHave && prevPendingIHave.callback(entry);
-
 								this._pendingIHave.delete(entry.hash);
 							}
 						};
@@ -804,8 +829,6 @@ export class SharedLog<T = Uint8Array> extends Program<
 					timeout: WAIT_FOR_REPLICATOR_TIMEOUT
 				})
 					.then(async () => {
-						/* await delay(1000 * Math.random()) */
-
 						const prev = this.latestRoleMessages.get(context.from!.hashcode());
 						if (prev && prev > context.timestamp) {
 							return;
@@ -982,7 +1005,7 @@ export class SharedLog<T = Uint8Array> extends Program<
 		const startNode = currentNode;
 		const diffs: { diff: number; rect: ReplicatorRect }[] = [];
 		while (currentNode && !done()) {
-			const start = currentNode.value.offset % width;
+			const start = currentNode.value.role.offset % width;
 			const absDelta = Math.abs(start - point());
 			const diff = Math.min(absDelta, width - absDelta);
 
@@ -1041,7 +1064,7 @@ export class SharedLog<T = Uint8Array> extends Program<
 		const t = +new Date();
 		const roleAge =
 			options?.roleAge ??
-			Math.min(WAIT_FOR_ROLE_MATURITY, +new Date() - this.openTime);
+			Math.min(this.timeUntilRoleMaturity, +new Date() - this.openTime);
 
 		for (let i = 0; i < numberOfLeaders; i++) {
 			const point = ((cursor + i / numberOfLeaders) % 1) * width;
@@ -1064,7 +1087,7 @@ export class SharedLog<T = Uint8Array> extends Program<
 	 *
 	 * @returns groups where at least one in any group will have the entry you are looking for
 	 */
-	getReplicatorUnion(roleAge: number = WAIT_FOR_ROLE_MATURITY) {
+	getReplicatorUnion(roleAge: number = this.timeUntilRoleMaturity) {
 		if (this.closed === true) {
 			throw new Error("Closed");
 		}
@@ -1112,7 +1135,7 @@ export class SharedLog<T = Uint8Array> extends Program<
 			return [];
 		}
 
-		let nextPoint = startNode.value.offset;
+		let nextPoint = startNode.value.role.offset;
 		const t = +new Date();
 		this.collectNodesAroundPoint(
 			t,
@@ -1158,7 +1181,7 @@ export class SharedLog<T = Uint8Array> extends Program<
 				this._closeController.signal.removeEventListener("abort", listener);
 				await this.rebalanceParticipationDebounced?.();
 				this.distribute();
-			}, WAIT_FOR_ROLE_MATURITY + 2000);
+			}, this.timeUntilRoleMaturity + 2000);
 
 			const listener = () => {
 				clearTimeout(timer);
@@ -1179,14 +1202,13 @@ export class SharedLog<T = Uint8Array> extends Program<
 		publicKey: PublicSignKey
 	) {
 		const update = await this._modifyReplicators(role, publicKey);
+
 		if (update.changed !== "none") {
 			if (update.changed === "added" || update.changed === "removed") {
 				this.setupRebalanceDebounceFunction();
 			}
 
-			if (this.rebalanceParticipationDebounced) {
-				await this.rebalanceParticipationDebounced?.(); /* await this.rebalanceParticipation(false); */
-			}
+			await this.rebalanceParticipationDebounced?.(); /* await this.rebalanceParticipation(false); */
 			if (update.changed === "added") {
 				await this.rpc.send(new ResponseRoleMessage({ role: this._role }), {
 					mode: new SeekDelivery({
@@ -1236,10 +1258,8 @@ export class SharedLog<T = Uint8Array> extends Program<
 
 			if (isOnline) {
 				// insert or if already there do nothing
-				const code = hashToUniformNumber(publicKey.bytes);
 				const rect: ReplicatorRect = {
 					publicKey,
-					offset: code,
 					role
 				};
 
@@ -1261,7 +1281,7 @@ export class SharedLog<T = Uint8Array> extends Program<
 							return { prev: prev.role, changed: "updated" };
 						}
 
-						if (code > currentNode.value.offset) {
+						if (role.offset > currentNode.value.role.offset) {
 							const next = currentNode?.next;
 							if (next) {
 								currentNode = next;
@@ -1306,29 +1326,28 @@ export class SharedLog<T = Uint8Array> extends Program<
 		changes: string[],
 		subscribed: boolean
 	) {
-		if (subscribed) {
-			if (this.role instanceof Replicator) {
-				for (const subscription of changes) {
-					if (this.log.idString !== subscription) {
-						continue;
-					}
-					this.rpc
-						.send(new ResponseRoleMessage({ role: this._role }), {
-							mode: new SeekDelivery({ redundancy: 1, to: [publicKey] })
-						})
-						.catch((e) => logger.error(e.toString()));
-				}
+		for (const topic of changes) {
+			if (this.log.idString !== topic) {
+				continue;
 			}
+		}
 
-			//if(evt.detail.subscriptions.map((x) => x.topic).includes())
-		} else {
-			for (const topic of changes) {
-				if (this.log.idString !== topic) {
-					continue;
-				}
+		if (!subscribed) {
+			for (const [_a, b] of this._gidPeersHistory) {
+				b.delete(publicKey.hashcode());
+			}
+		}
 
-				await this.modifyReplicators(new Observer(), publicKey);
+		if (subscribed) {
+			if (this.role instanceof Replicator) {
+				this.rpc
+					.send(new ResponseRoleMessage({ role: this._role }), {
+						mode: new SeekDelivery({ redundancy: 1, to: [publicKey] })
+					})
+					.catch((e) => logger.error(e.toString()));
 			}
+		} else {
+			await this.modifyReplicators(new Observer(), publicKey);
 		}
 	}
 
@@ -1469,7 +1488,7 @@ export class SharedLog<T = Uint8Array> extends Program<
 	_queue: PQueue;
 	async distribute() {
 		if (this._queue?.size > 0) {
-			return;
+			return this._queue.onEmpty();
 		}
 		(this._queue || (this._queue = new PQueue({ concurrency: 1 }))).add(() =>
 			this._distribute()
@@ -1507,6 +1526,7 @@ export class SharedLog<T = Uint8Array> extends Program<
 				gid,
 				maxReplicas(this, entries) // pick max replication policy of all entries, so all information is treated equally important as the most important
 			);
+
 			const isLeader = currentPeers.find(
 				(x) => x === this.node.identity.publicKey.hashcode()
 			);
@@ -1552,8 +1572,6 @@ export class SharedLog<T = Uint8Array> extends Program<
 		}
 
 		for (const [target, entries] of uncheckedDeliver) {
-			const promise: Promise<any> = Promise.resolve();
-
 			// TODO better choice of step size
 			for (let i = 0; i < entries.length; i += 100) {
 				const message = await createExchangeHeadsMessage(
@@ -1646,10 +1664,14 @@ export class SharedLog<T = Uint8Array> extends Program<
 		);
 	}
 
+	xxx: number;
 	async rebalanceParticipation(onRoleChange = true) {
 		// update more participation rate to converge to the average expected rate or bounded by
 		// resources such as memory and or cpu
 
+		const t = +new Date();
+		// console.log(t - this.xxx)
+		this.xxx = t;
 		if (this.closed) {
 			return false;
 		}
@@ -1675,15 +1697,16 @@ export class SharedLog<T = Uint8Array> extends Program<
 					peers?.length || 1
 				);
 
-			const newRole = new Replicator({
-				factor: newFactor,
-				timestamp: this._role.timestamp
-			});
-
 			const relativeDifference =
-				Math.abs(this._role.factor - newRole.factor) / this._role.factor;
+				Math.abs(this._role.factor - newFactor) / this._role.factor;
 
 			if (relativeDifference > 0.0001) {
+				const newRole = new Replicator({
+					factor: newFactor,
+					timestamp: this._role.timestamp,
+					offset: hashToUniformNumber(this.node.identity.publicKey.bytes)
+				});
+
 				const canReplicate =
 					!this._canReplicate ||
 					(await this._canReplicate(this.node.identity.publicKey, newRole));
@@ -1692,7 +1715,11 @@ export class SharedLog<T = Uint8Array> extends Program<
 				}
 
 				await this._updateRole(newRole, onRoleChange);
+				this.rebalanceParticipationDebounced?.();
+
 				return true;
+			} else {
+				this.rebalanceParticipationDebounced?.();
 			}
 			return false;
 		}

package/src/pid.ts

@@ -8,13 +8,14 @@ export class PIDReplicationController {
 	integral: number;
 	prevError: number;
 	prevMemoryUsage: number;
-	lastTs: number;
+	prevTotalFactor: number;
 	kp: number;
 	ki: number;
 	kd: number;
 	errorFunction: ReplicationErrorFunction;
 	targetMemoryLimit?: number;
 	constructor(
+		readonly id: string,
 		options: {
 			errorFunction?: ReplicationErrorFunction;
 			targetMemoryLimit?: number;
@@ -25,11 +26,14 @@ export class PIDReplicationController {
 	) {
 		const {
 			targetMemoryLimit,
-			kp = 0.5,
-			ki = 0.1,
-			kd = 0.25,
-			errorFunction = ({ balance, coverage, memory }) =>
-				memory * 0.8 + balance * 0.1 + coverage * 0.1
+			kp = 0.7,
+			ki = 0.025,
+			kd = 0.05,
+			errorFunction = ({ balance, coverage, memory }) => {
+				return memory < 0
+					? memory * 0.9 + balance * 0.06 + coverage * 0.04
+					: balance * 0.6 + coverage * 0.4;
+			}
 		} = options;
 		this.reset();
 		this.kp = kp;
@@ -39,18 +43,27 @@ export class PIDReplicationController {
 		this.errorFunction = errorFunction;
 	}
 
+	/**
+	 * Call this function on a period interval since it does not track time passed
+	 * @param memoryUsage
+	 * @param currentFactor
+	 * @param totalFactor
+	 * @param peerCount
+	 * @returns
+	 */
 	async adjustReplicationFactor(
 		memoryUsage: number,
 		currentFactor: number,
 		totalFactor: number,
 		peerCount: number
 	) {
+		const totalFactorDiff = totalFactor - this.prevTotalFactor;
+		this.prevTotalFactor = totalFactor;
 		this.prevMemoryUsage = memoryUsage;
 
 		const estimatedTotalSize = memoryUsage / currentFactor;
 
 		let errorMemory = 0;
-		const errorTarget = 1 / peerCount - currentFactor;
 
 		if (this.targetMemoryLimit != null) {
 			errorMemory =
@@ -59,42 +72,39 @@ export class PIDReplicationController {
 							Math.min(1, this.targetMemoryLimit / estimatedTotalSize),
 							0
 						) - currentFactor
-					: 0.0001;
+					: 0;
 		}
 
 		const errorCoverageUnmodified = Math.min(1 - totalFactor, 1);
-		const includeCoverageError =
-			Math.max(Math.abs(errorTarget), Math.abs(errorMemory)) < 0.01;
-		const errorCoverage = includeCoverageError ? errorCoverageUnmodified : 0; /// 1 / (Math.max(Math.abs(errorTarget), Math.abs(errorMemory))) * errorCoverage / 100;
+		const errorCoverage =
+			(this.targetMemoryLimit ? 1 - Math.sqrt(Math.abs(errorMemory)) : 1) *
+			errorCoverageUnmodified;
 
-		let totalError = this.errorFunction({
-			balance: errorTarget,
+		const errorFromEven = 1 / peerCount - currentFactor;
+
+		const balanceErrorScaler = this.targetMemoryLimit
+			? Math.abs(errorMemory)
+			: 1 - Math.abs(errorCoverage);
+
+		const errorBalance = (this.targetMemoryLimit ? errorMemory > -0.01 : true)
+			? errorFromEven > 0
+				? balanceErrorScaler * errorFromEven
+				: 0
+			: 0;
+
+		const totalError = this.errorFunction({
+			balance: errorBalance,
 			coverage: errorCoverage,
 			memory: errorMemory
 		});
 
-		if (totalError === 0 && !includeCoverageError) {
-			totalError = this.errorFunction({
-				balance: errorTarget,
-				coverage: errorCoverageUnmodified,
-				memory: errorMemory
-			});
-		}
-
-		if (this.lastTs === 0) {
-			this.lastTs = +new Date();
-		}
-		const kpAdjusted = Math.min(
-			Math.max(this.kp, (+new Date() - this.lastTs) / 100),
-			0.8
-		);
-		const pTerm = kpAdjusted * totalError;
-
-		this.lastTs = +new Date();
+		const pTerm = this.kp * totalError;
 
 		// Integral term
 		this.integral += totalError;
-		const beta = 0.5;
+
+		// Beta controls how much of the accumulated error we should forget
+		const beta = 0.8;
 		this.integral = beta * totalError + (1 - beta) * this.integral;
 
 		const iTerm = this.ki * this.integral;
@@ -114,19 +124,30 @@ export class PIDReplicationController {
 			this.integral = 0;
 		}
 
+		// prevent drift when everone wants to do less
+		/* if (newFactor < currentFactor && totalFactorDiff < 0 && totalFactor < 0.5) {
+			newFactor = currentFactor;
+			this.integral = 0;
+		}
+			*/
+
 		/* console.log({
-			newFactor,
+			id: this.id,
 			currentFactor,
+			newFactor,
+			factorDiff: newFactor - currentFactor,
 			pTerm,
 			dTerm,
 			iTerm,
-			kpAdjusted,
 			totalError,
-			errorTarget,
+			errorTarget: errorBalance,
 			errorCoverage,
 			errorMemory,
 			peerCount,
-			totalFactor
+			totalFactor,
+			totalFactorDiff,
+			targetScaler: balanceErrorScaler,
+			estimatedTotalSize
 		}); */
 
 		return Math.max(Math.min(newFactor, 1), 0);
@@ -136,6 +157,5 @@ export class PIDReplicationController {
 		this.prevError = 0;
 		this.integral = 0;
 		this.prevMemoryUsage = 0;
-		this.lastTs = 0;
 	}
 }

package/src/replication.ts

@@ -15,7 +15,6 @@ export type ReplicationLimits = { min: MinReplicas; max?: MinReplicas };
 
 export type ReplicatorRect = {
 	publicKey: PublicSignKey;
-	offset: number;
 	role: Replicator;
 };
 

package/src/role.ts

@@ -31,13 +31,13 @@ class ReplicationSegment {
 	@field({ type: "u32" })
 	private factorNominator: number;
 
-	@field({ type: option("u32") })
-	private offsetNominator?: number;
+	@field({ type: "u32" })
+	private offsetNominator: number;
 
 	constructor(properties: {
 		factor: number;
+		offset: number;
 		timestamp?: bigint;
-		offset?: number;
 	}) {
 		const { factor, timestamp, offset } = properties;
 		if (factor > 1 || factor < 0) {
@@ -47,24 +47,18 @@ class ReplicationSegment {
 		this.timestamp = timestamp ?? BigInt(+new Date());
 		this.factorNominator = Math.round(4294967295 * factor);
 
-		if (offset != null) {
-			if (offset > 1 || offset < 0) {
-				throw new Error(
-					"Expecting offset to be between 0 and 1, got: " + offset
-				);
-			}
-			this.offsetNominator = Math.round(4294967295 * offset);
+		if (offset > 1 || offset < 0) {
+			throw new Error("Expecting offset to be between 0 and 1, got: " + offset);
 		}
+		this.offsetNominator = Math.round(4294967295 * offset);
 	}
 
 	get factor(): number {
 		return this.factorNominator / 4294967295;
 	}
 
-	get offset(): number | undefined {
-		return this.offsetNominator != null
-			? this.offsetNominator / 4294967295
-			: undefined;
+	get offset(): number {
+		return this.offsetNominator / 4294967295;
 	}
 }
 
@@ -76,7 +70,7 @@ export class Replicator extends Role {
 	constructor(properties: {
 		factor: number;
 		timestamp?: bigint;
-		offset?: number;
+		offset: number;
 	}) {
 		super();
 		const segment: ReplicationSegment = new ReplicationSegment(properties);
@@ -87,7 +81,7 @@ export class Replicator extends Role {
 		return this.segments[0]!.factor;
 	}
 
-	get offset(): number | undefined {
+	get offset(): number {
 		return this.segments[0]!.offset;
 	}