@peerbit/shared-log 13.2.36 → 15.0.0

package/src/index.ts

@@ -144,6 +144,7 @@ import {
 	debouncedAccumulatorMap,
 } from "./debounce.js";
 import {
+	CompatibilityModeRetiredError,
 	NativeDurableCommitError,
 	NoPeersError,
 	isNotStartedError,
@@ -248,6 +249,10 @@ import {
 	type ReplicationDomain,
 	type ReplicationDomainConstructor,
 } from "./replication-domain.js";
+import type {
+	AddedReplicationInfoMutation,
+	FullReplicationInfoMutation,
+} from "./replication-info-mutation.js";
 import { ReplicationInfoV2ReceiveCoordinator } from "./replication-info-v2-receive.js";
 import { ReplicationInfoV2SendCoordinator } from "./replication-info-v2-send.js";
 import {
@@ -428,6 +433,7 @@ export {
 	EntryReplicatedU32,
 	EntryReplicatedU64,
 	type CoverRange,
+	CompatibilityModeRetiredError,
 	NativeDurableCommitError,
 	NoPeersError,
 };
@@ -1248,7 +1254,6 @@ export type SharedLogOptions<
 	waitForPruneDelay?: number;
 	distributionDebounceTime?: number;
 	strictFullReplicaFallback?: boolean;
-	compatibility?: number;
 	domain?: ReplicationDomainConstructor<D>;
 	eagerBlocks?: EagerBlocksSetting;
 	fanout?: SharedLogFanoutOptions;
@@ -3760,7 +3765,10 @@ export class SharedLog<
 	}
 
 	get compatibility(): number | undefined {
-		return this._logProperties?.compatibility;
+		// B12: the open option was removed and any defined value rejects at
+		// open(); this is permanently undefined and dies with the residual
+		// gates in a later cleanup stage.
+		return (this._logProperties as any)?.compatibility;
 	}
 
 	/**
@@ -5710,7 +5718,7 @@ export class SharedLog<
 			mergeSegments?: boolean;
 			rebalance?: boolean;
 			announce?: (
-				msg: AddedReplicationSegmentMessage | AllReplicatingSegmentsMessage,
+				msg: AddedReplicationInfoMutation | FullReplicationInfoMutation,
 			) => void;
 		} = {},
 		replicationOwnershipLifecycleController = this.captureReplicationOwnershipLifecycle(),
@@ -5946,9 +5954,11 @@ export class SharedLog<
 
 			if (confirmedPreliminaryRemovals.length > 0) {
 				await this._announcements.sendReplicationAnnouncement(
-					new StoppedReplicating({
-						segmentIds: confirmedPreliminaryRemovals.map((x) => x.id),
-					}),
+					{
+						stopped: {
+							segmentIds: confirmedPreliminaryRemovals.map((x) => x.id),
+						},
+					},
 					replicationOwnershipLifecycleController,
 				);
 				this.throwIfReplicationOwnershipLifecycleInactive(
@@ -5973,7 +5983,7 @@ export class SharedLog<
 				);
 				this.validatePersistedReplicationRangeSnapshot(segments);
 				await this._announcements.sendReplicationAnnouncement(
-					new AllReplicatingSegmentsMessage({ segments }),
+					{ full: { segments } },
 					replicationOwnershipLifecycleController,
 				);
 			} catch (error) {
@@ -6029,7 +6039,7 @@ export class SharedLog<
 			rebalance?: boolean;
 			mergeSegments?: boolean;
 			announce?: (
-				msg: AllReplicatingSegmentsMessage | AddedReplicationSegmentMessage,
+				msg: FullReplicationInfoMutation | AddedReplicationInfoMutation,
 			) => void;
 		},
 	) {
@@ -6270,7 +6280,7 @@ export class SharedLog<
 		}
 		try {
 			await this._announcements.sendReplicationAnnouncement(
-				new StoppedReplicating({ segmentIds: removedSegmentIds }),
+				{ stopped: { segmentIds: removedSegmentIds } },
 				replicationOwnershipLifecycleController,
 			);
 			this.throwIfReplicationOwnershipLifecycleInactive(
@@ -6567,7 +6577,7 @@ export class SharedLog<
 				if (isMe && !ownerHasRanges) {
 					try {
 						await this._announcements.sendReplicationAnnouncement(
-							new AllReplicatingSegmentsMessage({ segments: [] }),
+							{ full: { segments: [] } },
 							replicationOwnershipLifecycleController,
 						);
 					} catch (error) {
@@ -7490,7 +7500,7 @@ export class SharedLog<
 			rebalance?: boolean;
 			shouldApply?: () => boolean;
 			announce?: (
-				msg: AllReplicatingSegmentsMessage | AddedReplicationSegmentMessage,
+				msg: FullReplicationInfoMutation | AddedReplicationInfoMutation,
 			) => void;
 		} = {},
 		replicationOwnershipLifecycleController = this.captureReplicationOwnershipLifecycle(),
@@ -7537,7 +7547,7 @@ export class SharedLog<
 				);
 				this.validatePersistedReplicationRangeSnapshot(segments);
 				await this._announcements.sendReplicationAnnouncement(
-					new AllReplicatingSegmentsMessage({ segments }),
+					{ full: { segments } },
 					replicationOwnershipLifecycleController,
 				);
 			} catch (error) {
@@ -7588,17 +7598,17 @@ export class SharedLog<
 				}
 
 				let message:
-					| AllReplicatingSegmentsMessage
-					| AddedReplicationSegmentMessage
+					| FullReplicationInfoMutation
+					| AddedReplicationInfoMutation
 					| undefined = undefined;
 				if (options.reset) {
-					message = new AllReplicatingSegmentsMessage({
-						segments: added.map((x) => x.range.toReplicationRange()),
-					});
+					message = {
+						full: { segments: added.map((x) => x.range.toReplicationRange()) },
+					};
 				} else {
-					message = new AddedReplicationSegmentMessage({
-						segments: added.map((x) => x.range.toReplicationRange()),
-					});
+					message = {
+						added: { segments: added.map((x) => x.range.toReplicationRange()) },
+					};
 				}
 				if (options.announce) {
 					return options.announce(message);
@@ -14166,6 +14176,17 @@ export class SharedLog<
 	}
 
 	async open(options?: Args<T, D, R>): Promise<void> {
+		// B12: replication-info network compatibility modes are retired. Read the
+		// RAW argument value (the option no longer exists on the type) so untyped
+		// JS callers cannot smuggle a value past the removed field, and reject
+		// ANY defined value — including 10, which previously behaved like the
+		// default — BEFORE any open-time side effect (rpc.open, index/native
+		// setup, domain resolution, synchronizer creation, subscription setup).
+		// An explicitly-present `undefined` stays accepted.
+		const rawCompatibility = (options as any)?.compatibility;
+		if (rawCompatibility !== undefined) {
+			throw new CompatibilityModeRetiredError(rawCompatibility);
+		}
 		this.ensureNativeDurabilityRuntimeState();
 		this._nativeStrictDurableTransactionsClosing = false;
 		this._replicationRangeMutationsClosing = false;
@@ -14227,7 +14248,8 @@ export class SharedLog<
 		this.domain = options?.domain
 			? (options.domain(this) as unknown as D)
 			: (createReplicationDomainHash(
-					options?.compatibility !== undefined && options.compatibility < 10
+					(options as any)?.compatibility !== undefined &&
+						(options as any).compatibility < 10
 						? "u32"
 						: "u64",
 				)(this) as unknown as D);
@@ -14837,7 +14859,7 @@ export class SharedLog<
 				sendOptions?: { priority?: number; signal?: AbortSignal },
 			) => this.trySendFusedRawExchangeHeads(hashes, to, sendOptions),
 			warn,
-			compatibility: this._logProperties?.compatibility,
+			compatibility: (this._logProperties as any)?.compatibility,
 			resolution: this.domain.resolution,
 			sync: options?.sync,
 			syncronizer: options?.syncronizer,
@@ -20540,7 +20562,7 @@ export class SharedLog<
 		throwIfInactive();
 
 		if (options?.replicate) {
-			let messageToSend: AddedReplicationSegmentMessage | undefined = undefined;
+			let messageToSend: AddedReplicationInfoMutation | undefined = undefined;
 
 			if (assumeSynced) {
 				throwIfInactive();
@@ -20568,14 +20590,14 @@ export class SharedLog<
 				// in one large message instead
 				announce: (msg) => {
 					throwIfInactive();
-					if (msg instanceof AllReplicatingSegmentsMessage) {
+					if (!("added" in msg)) {
 						throw new Error("Unexpected");
 					}
 
 					if (messageToSend) {
 						// merge segments to make it into one messages
-						for (const segment of msg.segments) {
-							messageToSend.segments.push(segment);
+						for (const segment of msg.added.segments) {
+							messageToSend.added.segments.push(segment);
 						}
 					} else {
 						messageToSend = msg;

package/src/replication-announcement.ts

@@ -10,6 +10,7 @@ import { TimeoutError, debounceFixedInterval } from "@peerbit/time";
 import { isNotStartedError } from "./errors.js";
 import type { TransportMessage } from "./message.js";
 import type { ReplicationRangeIndexable } from "./ranges.js";
+import type { ReplicationInfoMutation } from "./replication-info-mutation.js";
 import {
 	AddedReplicationSegmentMessage,
 	AllReplicatingSegmentsMessage,
@@ -206,14 +207,34 @@ export type ReplicationAnnouncementDeps<R extends "u32" | "u64"> = {
 	queueCurrentReplicationStateAnnouncementRetry: (error: unknown) => boolean;
 	// V2 is always current. Legacy publication is enabled only for an explicit
 	// compatibility open and retains its exact rejection/retry semantics there.
-	enqueueReplicationInfoV2: (message: LegacyReplicationInfoMessage) => void;
+	enqueueReplicationInfoV2: (mutation: ReplicationInfoMutation) => void;
 	isLegacyReplicationInfoEnabled: () => boolean;
 };
 
-type LegacyReplicationInfoMessage =
+/**
+ * The dormant legacy tail still broadcasts the retired wire classes when an
+ * explicit compatibility open enabled it (impossible since B12 stage 1; the
+ * tail is deleted in stage 3). Materialize the frame from the neutral
+ * mutation locally so the tail keeps its exact byte semantics until then.
+ */
+const toLegacyReplicationInfoFrame = (
+	mutation: ReplicationInfoMutation,
+):
 	| AllReplicatingSegmentsMessage
 	| AddedReplicationSegmentMessage
-	| StoppedReplicating;
+	| StoppedReplicating => {
+	if ("full" in mutation) {
+		return new AllReplicatingSegmentsMessage({
+			segments: mutation.full.segments,
+		});
+	}
+	if ("added" in mutation) {
+		return new AddedReplicationSegmentMessage({
+			segments: mutation.added.segments,
+		});
+	}
+	return new StoppedReplicating({ segmentIds: mutation.stopped.segmentIds });
+};
 
 export class ReplicationAnnouncementCoordinator<R extends "u32" | "u64"> {
 	replicationAnnouncementRetryDebounced:
@@ -627,7 +648,7 @@ export class ReplicationAnnouncementCoordinator<R extends "u32" | "u64"> {
 	}
 
 	async sendReplicationAnnouncement(
-		message: LegacyReplicationInfoMessage,
+		mutation: ReplicationInfoMutation,
 		ownershipLifecycleController = this.deps.captureReplicationOwnershipLifecycle(),
 		options?: { shouldSend?: () => boolean },
 	): Promise<void> {
@@ -652,12 +673,12 @@ export class ReplicationAnnouncementCoordinator<R extends "u32" | "u64"> {
 				// after that stale send settles.
 				this.rotateAnnouncementSession();
 				this.advanceCurrentReplicationStateAnnouncementRepairGeneration();
-				this.deps.enqueueReplicationInfoV2(message);
+				this.deps.enqueueReplicationInfoV2(mutation);
 				if (!this.deps.isLegacyReplicationInfoEnabled()) {
 					return;
 				}
 				try {
-					await this.deps.getRpc().send(message, {
+					await this.deps.getRpc().send(toLegacyReplicationInfoFrame(mutation), {
 						priority: CONVERGENCE_MESSAGE_PRIORITY,
 						signal: ownershipLifecycleController.signal,
 					});

package/src/replication-info-mutation.ts

@@ -0,0 +1,34 @@
+import type { ReplicationRangeMessage } from "./ranges.js";
+
+/**
+ * Neutral internal representation of a local replication-state mutation.
+ *
+ * Producers (replicate/unreplicate/join and their corrective snapshot paths)
+ * hand these plain tagged objects to the announcement coordinator, which maps
+ * them onto the directed V2 wire messages:
+ *
+ * - `full`    -> FullReplicationInfoV2Message (authoritative snapshot)
+ * - `added`   -> AddedReplicationInfoV2Message (incremental delta)
+ * - `stopped` -> StoppedReplicationInfoV2Message (retired segment ids)
+ *
+ * The retired legacy announcement classes (AllReplicatingSegmentsMessage,
+ * AddedReplicationSegmentMessage, StoppedReplicating) remain registered
+ * decode tombstones on the wire surface but are no longer the internal
+ * currency between mutation producers and the V2 sender.
+ */
+export type FullReplicationInfoMutation = {
+	full: { segments: ReplicationRangeMessage<any>[] };
+};
+
+export type AddedReplicationInfoMutation = {
+	added: { segments: ReplicationRangeMessage<any>[] };
+};
+
+export type StoppedReplicationInfoMutation = {
+	stopped: { segmentIds: Uint8Array[] };
+};
+
+export type ReplicationInfoMutation =
+	| FullReplicationInfoMutation
+	| AddedReplicationInfoMutation
+	| StoppedReplicationInfoMutation;

package/src/replication-info-v2-send.ts

@@ -8,13 +8,11 @@ import {
 import type { TransportMessage } from "./message.js";
 import type { ReplicationRangeIndexable } from "./ranges.js";
 import { deriveReplicationInfoV2ReceiverBinding } from "./replication-info-v2-binding.js";
+import type { ReplicationInfoMutation } from "./replication-info-mutation.js";
 import {
 	AddedReplicationInfoV2Message,
-	AddedReplicationSegmentMessage,
-	AllReplicatingSegmentsMessage,
 	FullReplicationInfoV2Message,
 	RequestReplicationInfoV2Message,
-	StoppedReplicating,
 	StoppedReplicationInfoV2Message,
 } from "./replication.js";
 
@@ -27,14 +25,9 @@ const MAX_BACKOFF_EXPONENT = 20;
 
 export { deriveReplicationInfoV2ReceiverBinding } from "./replication-info-v2-binding.js";
 
-export type LegacyReplicationInfoMessage =
-	| AllReplicatingSegmentsMessage
-	| AddedReplicationSegmentMessage
-	| StoppedReplicating;
-
 type SendRequest =
 	| { kind: "snapshot" }
-	| { kind: "message"; message: LegacyReplicationInfoMessage };
+	| { kind: "mutation"; mutation: ReplicationInfoMutation };
 
 export type ReplicationInfoV2SendState = {
 	peerHash: string;
@@ -393,9 +386,9 @@ export class ReplicationInfoV2SendCoordinator<R extends "u32" | "u64"> {
 		return true;
 	}
 
-	enqueue(message: LegacyReplicationInfoMessage): void {
+	enqueue(mutation: ReplicationInfoMutation): void {
 		for (const state of [...this._sendStates.values()]) {
-			this.enqueueState(state, { kind: "message", message });
+			this.enqueueState(state, { kind: "mutation", mutation });
 		}
 	}
 
@@ -538,20 +531,21 @@ export class ReplicationInfoV2SendCoordinator<R extends "u32" | "u64"> {
 			this.deps.validatePersistedReplicationRangeSnapshot(segments);
 			return new FullReplicationInfoV2Message({ ...common, segments });
 		}
-		if (request.message instanceof AllReplicatingSegmentsMessage) {
-			const segments = request.message.segments;
+		const { mutation } = request;
+		if ("full" in mutation) {
+			const segments = mutation.full.segments;
 			this.deps.validatePersistedReplicationRangeSnapshot(segments);
 			return new FullReplicationInfoV2Message({ ...common, segments });
 		}
-		if (request.message instanceof AddedReplicationSegmentMessage) {
+		if ("added" in mutation) {
 			return new AddedReplicationInfoV2Message({
 				...common,
-				segments: request.message.segments,
+				segments: mutation.added.segments,
 			});
 		}
 		return new StoppedReplicationInfoV2Message({
 			...common,
-			segmentIds: request.message.segmentIds,
+			segmentIds: mutation.stopped.segmentIds,
 		});
 	}