@loro-dev/streams-crdt 0.4.0 → 0.5.0

package/dist/{stream-id-TsPj50Jj.js → stream-id-nPEdFo7c.js}

@@ -775,7 +775,7 @@ var TransportCursorManager = class {
 		let nextVersion = cursor.serverLowerBoundVersion;
 		if (snapshot.byteLength > 0) nextVersion = await this.adapter.applySnapshot(this.decodeSnapshot == null ? snapshot : await this.decodeSnapshot(snapshot));
 		if (updates.length > 0) nextVersion = await this.adapter.applyRemoteUpdates([...updates], nextVersion);
-		return await this.saveRemoteCursor({
+		return await this.finalizeCursor({
 			...cursor,
 			nextOffset,
 			serverLowerBoundVersion: nextVersion
@@ -786,7 +786,7 @@ var TransportCursorManager = class {
 		return await this.applyBootstrapPayload(cursor, snapshot, items.slice(1), nextOffset);
 	}
 	async applyRemoteItems(cursor, items, nextOffset) {
-		return await this.applyRemotePayload(cursor, [...items], nextOffset, "remote");
+		return await this.applyRemotePayload(cursor, [...items], nextOffset, "remote", void 0);
 	}
 	async applyCatchupResult(cursor, result, onRemoteVersionApplied) {
 		return await this.applyRemotePayload(cursor, result.updates, result.nextOffset, "remote", onRemoteVersionApplied);
@@ -798,7 +798,7 @@ var TransportCursorManager = class {
 			nextVersion = await this.adapter.applyRemoteUpdates([...result.updates], nextVersion);
 			await onRemoteVersionApplied?.(previousVersion, nextVersion);
 		}
-		return await this.saveRemoteCursor({
+		return await this.finalizeCursor({
 			...cursor,
 			nextOffset: resolveNextOffsetAfterConcurrentAdvance(requestOffset, cursor.nextOffset, result.nextOffset),
 			serverLowerBoundVersion: nextVersion
@@ -811,12 +811,15 @@ var TransportCursorManager = class {
 			nextVersion = await this.adapter.applyRemoteUpdates([...updates], nextVersion);
 			await onRemoteVersionApplied?.(previousVersion, nextVersion);
 		}
-		return await this.saveRemoteCursor({
+		return await this.finalizeCursor({
 			...cursor,
 			nextOffset,
 			serverLowerBoundVersion: nextVersion
 		}, source);
 	}
+	async finalizeCursor(cursor, source) {
+		return await this.saveRemoteCursor(cursor, source);
+	}
 };
 //#endregion
 //#region src/deque.ts
@@ -1105,6 +1108,8 @@ var StreamsCrdt = class StreamsCrdt {
 	createStreamIfMissing;
 	client;
 	cursorManager;
+	volatileCursorManager;
+	decodeSnapshot;
 	reconnectConfig;
 	debug;
 	beforeRemoteCursorSave;
@@ -1115,6 +1120,11 @@ var StreamsCrdt = class StreamsCrdt {
 	joinState;
 	opQueue = Promise.resolve();
 	/**
+	* Internal catch-up result used when callers need to handle 410 by
+	* preserving local state before rebuilding through bootstrap.
+	*/
+	static GONE_CATCHUP = { kind: "gone" };
+	/**
 	* Creates a transport for one stream URL and one local adapter instance.
 	*/
 	constructor(options) {
@@ -1132,6 +1142,7 @@ var StreamsCrdt = class StreamsCrdt {
 		this.beforeRemoteCursorSave = composeBeforeRemoteCursorSaveHooks(options.beforeRemoteCursorSave, ...options.beforeRemoteCursorSaveHooks ?? []);
 		const snapshotCodec = normalizeSnapshotCodec(options.snapshotCodec);
 		const snapshotUploadConfig = normalizeSnapshotUploadConfig(options.snapshotUpload);
+		this.decodeSnapshot = snapshotCodec?.decompress;
 		this.client = new StreamsTransportClient({
 			streamUrl: this.streamUrl,
 			adapter: this.adapter,
@@ -1139,11 +1150,8 @@ var StreamsCrdt = class StreamsCrdt {
 			fetchImpl,
 			reconnectConfig: this.reconnectConfig
 		});
-		this.cursorManager = new TransportCursorManager({
-			adapter: this.adapter,
-			decodeSnapshot: snapshotCodec?.decompress,
-			saveRemoteCursor: (cursor, source) => this.saveRemoteCursor(cursor, source)
-		});
+		this.cursorManager = this.createCursorManager(this.adapter, (cursor, source) => this.saveRemoteCursor(cursor, source));
+		this.volatileCursorManager = this.createCursorManager(this.adapter, async (cursor) => cursor);
 		this.snapshotManager = new TransportSnapshotManager({
 			adapter: this.adapter,
 			config: snapshotUploadConfig,
@@ -1364,24 +1372,7 @@ var StreamsCrdt = class StreamsCrdt {
 		}
 	}
 	async syncOnce() {
-		const loaded = await this.remoteCursorStore.load(this.streamUrl);
-		let cursor = loaded ?? createInitialRemoteCursor({
-			streamUrl: this.streamUrl,
-			nextOffset: "-1",
-			serverLowerBoundVersion: this.adapter.emptyVersion()
-		});
-		try {
-			if (loaded == null) cursor = await this.bootstrapIntoState(cursor);
-			else cursor = (await this.catchup(cursor)).cursor;
-		} catch (error) {
-			if (!isStreamNotFoundError(error) || !this.createStreamIfMissing) throw error;
-			await this.createStreamRequest();
-			cursor = await this.bootstrapIntoState({
-				...cursor,
-				nextOffset: "-1",
-				serverLowerBoundVersion: this.adapter.emptyVersion()
-			});
-		}
+		let cursor = (await this.resolveInitialRemoteState()).cursor;
 		const localBatch = this.exportUpdates(cursor.serverLowerBoundVersion);
 		if (localBatch.batch != null) {
 			cursor = await this.appendLocalBatch(cursor, localBatch.batch);
@@ -1390,32 +1381,11 @@ var StreamsCrdt = class StreamsCrdt {
 		return cursor;
 	}
 	async performInitialJoinSync(preferredLiveMode) {
-		const loaded = await this.remoteCursorStore.load(this.streamUrl);
-		let cursor = loaded ?? createInitialRemoteCursor({
-			streamUrl: this.streamUrl,
-			nextOffset: "-1",
-			serverLowerBoundVersion: this.adapter.emptyVersion()
-		});
+		const initial = await this.resolveInitialRemoteState();
+		let cursor = initial.cursor;
 		let localExportRefVersion = cursor.serverLowerBoundVersion;
-		let streamCursor;
+		let streamCursor = initial.streamCursor;
 		let liveMode = preferredLiveMode;
-		try {
-			if (loaded == null) cursor = await this.bootstrapIntoState(cursor);
-			else {
-				const caughtUp = await this.catchup(cursor);
-				cursor = caughtUp.cursor;
-				streamCursor = caughtUp.streamCursor;
-			}
-		} catch (error) {
-			if (!isStreamNotFoundError(error) || !this.createStreamIfMissing) throw error;
-			await this.createStreamRequest();
-			cursor = await this.bootstrapIntoState({
-				...cursor,
-				nextOffset: "-1",
-				serverLowerBoundVersion: this.adapter.emptyVersion()
-			});
-		}
-		localExportRefVersion = cursor.serverLowerBoundVersion;
 		const exportedLocal = this.exportUpdates(localExportRefVersion);
 		localExportRefVersion = exportedLocal.nextRefVersion;
 		if (exportedLocal.batch != null) {
@@ -1432,26 +1402,74 @@ var StreamsCrdt = class StreamsCrdt {
 			localExportRefVersion
 		};
 	}
-	async bootstrapIntoState(cursor) {
+	createInitialCursor() {
+		return createInitialRemoteCursor({
+			streamUrl: this.streamUrl,
+			nextOffset: "-1",
+			serverLowerBoundVersion: this.adapter.emptyVersion()
+		});
+	}
+	async resolveInitialRemoteState() {
+		const loaded = await this.remoteCursorStore.load(this.streamUrl);
+		const cursor = loaded ?? this.createInitialCursor();
+		try {
+			if (loaded == null) return await this.bootstrapState(cursor);
+			const caughtUp = await this.catchupOrGone(cursor, { goneStrategy: "return-gone" });
+			if ("kind" in caughtUp) return await this.recoverFromGoneWithLocalBootstrap(cursor);
+			return caughtUp;
+		} catch (error) {
+			if (!isStreamNotFoundError(error) || !this.createStreamIfMissing) throw error;
+			await this.createStreamRequest();
+			return await this.bootstrapState(this.createInitialCursor());
+		}
+	}
+	async bootstrapState(cursor, options = {}) {
+		const cursorManager = options.cursorManager ?? this.cursorManager;
 		const result = await this.bootstrap(this.streamUrl);
-		const saved = await this.cursorManager.applyBootstrapPayload(cursor, result.snapshot, result.updates, result.nextOffset);
-		if (!result.upToDate) return (await this.catchup(saved)).cursor;
-		return saved;
+		let saved = await cursorManager.applyBootstrapPayload(cursor, result.snapshot, result.updates, result.nextOffset);
+		let bootstrapCursor = result.streamCursor;
+		if (!result.upToDate) {
+			const caughtUp = await this.catchupOrGone(saved, {
+				streamCursor: bootstrapCursor,
+				cursorManager
+			});
+			if ("kind" in caughtUp) throw new Error("bootstrap catch-up unexpectedly returned gone");
+			saved = caughtUp.cursor;
+			bootstrapCursor = caughtUp.streamCursor;
+		}
+		return {
+			cursor: saved,
+			streamCursor: bootstrapCursor
+		};
 	}
 	async catchup(cursor, live, streamCursor, onRemoteVersionApplied) {
+		const result = await this.catchupOrGone(cursor, {
+			live,
+			streamCursor,
+			onRemoteVersionApplied
+		});
+		if ("kind" in result) throw new Error("catchup unexpectedly returned gone");
+		return result;
+	}
+	async catchupOrGone(cursor, options = {}) {
 		let current = cursor;
-		let currentStreamCursor = streamCursor;
+		let currentStreamCursor = options.streamCursor;
+		const goneStrategy = options.goneStrategy ?? "bootstrap";
+		const cursorManager = options.cursorManager ?? this.cursorManager;
 		while (true) {
 			const requestOffset = current.nextOffset;
-			const response = await this.readFromOffset(this.streamUrl, requestOffset, currentStreamCursor, live);
-			if (response.kind === "gone") return { cursor: await this.bootstrapIntoState({
-				...current,
-				nextOffset: "-1",
-				serverLowerBoundVersion: this.adapter.emptyVersion()
-			}) };
+			const response = await this.readFromOffset(this.streamUrl, requestOffset, currentStreamCursor, options.live);
+			if (response.kind === "gone") {
+				if (goneStrategy === "return-gone") return StreamsCrdt.GONE_CATCHUP;
+				return await this.bootstrapState({
+					...current,
+					nextOffset: "-1",
+					serverLowerBoundVersion: this.adapter.emptyVersion()
+				}, { cursorManager });
+			}
 			const result = response.value;
 			if (isReadNoProgress(requestOffset, result)) throw new Error(`catch-up made no progress at offset ${requestOffset}; server returned empty updates and unchanged next offset with up_to_date=false`);
-			current = await this.cursorManager.applyCatchupResult(current, result, onRemoteVersionApplied);
+			current = await cursorManager.applyCatchupResult(current, result, options.onRemoteVersionApplied);
 			currentStreamCursor = result.streamCursor;
 			if (result.upToDate) return {
 				cursor: current,
@@ -1459,7 +1477,7 @@ var StreamsCrdt = class StreamsCrdt {
 			};
 		}
 	}
-	async appendLocalBatch(cursor, batch) {
+	async appendLocalBatch(cursor, batch, persist = true) {
 		let producerSession = {
 			producerId: this.producerId,
 			producerEpoch: this.producerEpoch,
@@ -1475,7 +1493,7 @@ var StreamsCrdt = class StreamsCrdt {
 					nextOffset: result.nextOffset,
 					serverLowerBoundVersion: this.adapter.mergeVersions(cursor.serverLowerBoundVersion, batch.version)
 				};
-				return await this.saveRemoteCursor(next, "local");
+				return persist ? await this.saveRemoteCursor(next, "local") : next;
 			}
 			if (result.kind === "seq-gap") {
 				producerSession = {
@@ -1508,6 +1526,45 @@ var StreamsCrdt = class StreamsCrdt {
 	async applyRemoteItems(cursor, items, nextOffset) {
 		return await this.cursorManager.applyRemoteItems(cursor, items, nextOffset);
 	}
+	createCursorManager(adapter, saveRemoteCursor) {
+		return new TransportCursorManager({
+			adapter,
+			decodeSnapshot: this.decodeSnapshot,
+			saveRemoteCursor
+		});
+	}
+	async createIsolatedCursorManager() {
+		const isolated = await this.adapter.createIsolatedAdapter?.();
+		if (isolated == null) return null;
+		return this.createCursorManager(isolated, async (cursor) => cursor);
+	}
+	async recoverFromGoneWithLocalBootstrap(cursor) {
+		const isolatedCursorManager = await this.createIsolatedCursorManager();
+		const bootstrapCursor = {
+			...cursor,
+			nextOffset: "-1",
+			serverLowerBoundVersion: this.adapter.emptyVersion()
+		};
+		if (isolatedCursorManager != null) {
+			const inferredRemote = await this.bootstrapState(bootstrapCursor, { cursorManager: isolatedCursorManager });
+			const localBatch = this.exportUpdates(inferredRemote.cursor.serverLowerBoundVersion);
+			if (localBatch.batch != null) await this.appendLocalBatch(inferredRemote.cursor, localBatch.batch, false);
+			return await this.bootstrapState(bootstrapCursor);
+		}
+		const preservedLocalSnapshot = this.adapter.exportSnapshot();
+		let restoredLocalSnapshot = false;
+		try {
+			const inferredRemote = await this.bootstrapState(bootstrapCursor, { cursorManager: this.volatileCursorManager });
+			await this.adapter.applySnapshot(preservedLocalSnapshot);
+			restoredLocalSnapshot = true;
+			const localBatch = this.exportUpdates(inferredRemote.cursor.serverLowerBoundVersion);
+			if (localBatch.batch != null) await this.appendLocalBatch(inferredRemote.cursor, localBatch.batch, false);
+			return await this.bootstrapState(bootstrapCursor);
+		} catch (error) {
+			if (!restoredLocalSnapshot) await this.adapter.applySnapshot(preservedLocalSnapshot);
+			throw error;
+		}
+	}
 	async runReadLoop(state) {
 		state.requestController ??= new AbortController();
 		while (!state.closed) try {
@@ -1515,12 +1572,13 @@ var StreamsCrdt = class StreamsCrdt {
 				const requestOffset = state.cursor.nextOffset;
 				const response = await this.readFromOffset(this.streamUrl, requestOffset, state.streamCursor, "long-poll", state.requestController?.signal);
 				if (response.kind === "gone") {
-					state.cursor = await this.bootstrapIntoState({
+					const bootstrapped = await this.bootstrapState({
 						...state.cursor,
 						nextOffset: "-1",
 						serverLowerBoundVersion: this.adapter.emptyVersion()
 					});
-					state.streamCursor = void 0;
+					state.cursor = bootstrapped.cursor;
+					state.streamCursor = bootstrapped.streamCursor;
 					state.retryAttempt = 0;
 					continue;
 				}
@@ -1540,21 +1598,38 @@ var StreamsCrdt = class StreamsCrdt {
 				continue;
 			}
 			const sseRequestOffset = state.cursor.nextOffset;
-			const sseResult = await this.readFromOffsetSseItems(this.streamUrl, sseRequestOffset, state.streamCursor, async (updates, nextOffset, _upToDate, streamCursor) => {
-				await this.enqueueExclusive(async () => {
-					if (state.closed) return;
-					state.cursor = await this.cursorManager.applyLiveResult(state.cursor, sseRequestOffset, {
-						nextOffset,
-						updates
-					}, (previousVersion, nextVersion) => {
-						this.snapshotManager.observeRemoteVersion(state, previousVersion, nextVersion);
+			const pendingRemote = [];
+			let flushChain = Promise.resolve();
+			const sseResult = await this.readFromOffsetSseItems(this.streamUrl, sseRequestOffset, state.streamCursor, (updates, nextOffset, _upToDate, streamCursor) => {
+				pendingRemote.push({
+					updates,
+					nextOffset,
+					streamCursor
+				});
+				flushChain = flushChain.then(async () => {
+					const events = pendingRemote.splice(0);
+					if (events.length === 0 || state.closed) return;
+					const allUpdates = events.flatMap((e) => e.updates);
+					const lastEvent = events[events.length - 1];
+					await this.enqueueExclusive(async () => {
+						if (state.closed) return;
+						state.cursor = await this.cursorManager.applyLiveResult(state.cursor, sseRequestOffset, {
+							nextOffset: lastEvent.nextOffset,
+							updates: allUpdates
+						}, (previousVersion, nextVersion) => {
+							this.snapshotManager.observeRemoteVersion(state, previousVersion, nextVersion);
+						});
+						for (let i = events.length - 1; i >= 0; i--) if (events[i].streamCursor != null) {
+							state.streamCursor = events[i].streamCursor;
+							break;
+						}
 					});
-					if (streamCursor != null) state.streamCursor = streamCursor;
+					this.setJoinStatus(state, "joined");
 				});
-				this.setJoinStatus(state, "joined");
 			}, () => {
 				this.setJoinStatus(state, "joined");
 			}, state.requestController?.signal);
+			await flushChain;
 			if (state.closed) return;
 			if (sseResult.kind === "ok") {
 				state.retryAttempt = 0;
@@ -1575,12 +1650,13 @@ var StreamsCrdt = class StreamsCrdt {
 				this.setJoinStatus(state, "error");
 				return;
 			}
-			state.cursor = await this.bootstrapIntoState({
+			const bootstrapped = await this.bootstrapState({
 				...state.cursor,
 				nextOffset: "-1",
 				serverLowerBoundVersion: this.adapter.emptyVersion()
 			});
-			state.streamCursor = void 0;
+			state.cursor = bootstrapped.cursor;
+			state.streamCursor = bootstrapped.streamCursor;
 			state.retryAttempt = 0;
 		} catch (error) {
 			if (state.closed) return;
@@ -1779,4 +1855,4 @@ function createStreamUrl(input) {
 //#endregion
 export { InMemoryRemoteCursorStore as a, StreamsCrdt as i, isValidBucketId as n, IndexedDbRemoteCursorStore as o, isValidRillId as r, createInitialRemoteCursor as s, createStreamUrl as t };
 
-//# sourceMappingURL=stream-id-TsPj50Jj.js.map
+//# sourceMappingURL=stream-id-nPEdFo7c.js.map