@loro-dev/streams-crdt 0.4.1 → 0.6.0

package/dist/{stream-id-TsPj50Jj.js → stream-id-DBym_2Mj.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
@@ -1079,7 +1082,8 @@ function createJoinState(cursor, liveMode = "sse") {
 		cursor,
 		liveMode,
 		snapshot: createTransportSnapshotState(),
-		started: Promise.resolve()
+		started: Promise.resolve(),
+		syncWaiters: []
 	};
 }
 async function disposeJoinState(state, options) {
@@ -1091,6 +1095,8 @@ async function disposeJoinState(state, options) {
 	state.unsubscribeLocal = void 0;
 	requestController?.abort();
 	unsubscribeLocal?.();
+	const disposedError = /* @__PURE__ */ new Error("subscription closed");
+	for (const waiter of state.syncWaiters.splice(0)) waiter.reject(disposedError);
 	options.onDisposed?.();
 }
 //#endregion
@@ -1105,6 +1111,8 @@ var StreamsCrdt = class StreamsCrdt {
 	createStreamIfMissing;
 	client;
 	cursorManager;
+	volatileCursorManager;
+	decodeSnapshot;
 	reconnectConfig;
 	debug;
 	beforeRemoteCursorSave;
@@ -1115,6 +1123,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 +1145,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,17 +1153,14 @@ 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,
 			encodeSnapshot: snapshotCodec?.compress,
-			readSnapshotOffsetValue: () => this.readSnapshotOffsetValue(),
-			putSnapshotAt: (snapshotOffset, snapshot) => this.putSnapshotAt(snapshotOffset, snapshot),
+			readSnapshotOffsetValue: () => this.client.readSnapshotOffsetValue(),
+			putSnapshotAt: (snapshotOffset, snapshot) => this.client.putSnapshotAt(snapshotOffset, snapshot),
 			enqueueExclusive: (task) => this.enqueueExclusive(task),
 			logDebug: (message, detail) => this.logDebug(message, detail),
 			logError: (message, error, detail) => this.logError(message, error, detail),
@@ -1191,7 +1202,7 @@ var StreamsCrdt = class StreamsCrdt {
 		try {
 			return {
 				ok: true,
-				value: await this.readSnapshotOffsetValue()
+				value: await this.client.readSnapshotOffsetValue()
 			};
 		} catch (error) {
 			return {
@@ -1207,7 +1218,7 @@ var StreamsCrdt = class StreamsCrdt {
 		try {
 			return {
 				ok: true,
-				value: { created: await this.createStreamRequest() }
+				value: { created: await this.client.createStreamRequest() }
 			};
 		} catch (error) {
 			return {
@@ -1225,7 +1236,7 @@ var StreamsCrdt = class StreamsCrdt {
 			return {
 				ok: true,
 				value: { deleted: await this.enqueueExclusive(async () => {
-					const deleted = await this.deleteStreamRequest();
+					const deleted = await this.client.deleteStreamRequest();
 					await this.remoteCursorStore.delete?.(this.streamUrl);
 					this.producerEpoch = 0;
 					this.nextProducerSeq = 0;
@@ -1322,6 +1333,19 @@ var StreamsCrdt = class StreamsCrdt {
 				return () => {
 					state.statusListeners.delete(listener);
 				};
+			},
+			waitUntilSynced: async () => {
+				await this.adapter.flushLocalExports?.();
+				if (state.closed) throw new Error("subscription closed");
+				const remaining = state.pendingLocal.length;
+				if (remaining === 0) return;
+				return new Promise((resolve, reject) => {
+					state.syncWaiters.push({
+						remaining,
+						resolve,
+						reject
+					});
+				});
 			}
 		};
 	}
@@ -1364,24 +1388,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 +1397,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 +1418,74 @@ var StreamsCrdt = class StreamsCrdt {
 			localExportRefVersion
 		};
 	}
-	async bootstrapIntoState(cursor) {
-		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;
+	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.client.createStreamRequest();
+			return await this.bootstrapState(this.createInitialCursor());
+		}
+	}
+	async bootstrapState(cursor, options = {}) {
+		const cursorManager = options.cursorManager ?? this.cursorManager;
+		const result = await this.client.bootstrap();
+		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.client.readFromOffset(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,14 +1493,14 @@ var StreamsCrdt = class StreamsCrdt {
 			};
 		}
 	}
-	async appendLocalBatch(cursor, batch) {
+	async appendLocalBatch(cursor, batch, persist = true) {
 		let producerSession = {
 			producerId: this.producerId,
 			producerEpoch: this.producerEpoch,
 			nextProducerSeq: this.nextProducerSeq
 		};
 		for (let attempt = 0; attempt < 3; attempt += 1) {
-			const result = await this.appendUpdates(this.streamUrl, batch.updates, producerSession);
+			const result = await this.client.appendUpdates(batch.updates, producerSession);
 			if (result.kind === "ok") {
 				this.producerEpoch = result.ackEpoch;
 				this.nextProducerSeq = result.ackSeq + 1;
@@ -1475,7 +1509,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,19 +1542,65 @@ 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);
+	}
+	/**
+	* Infers remote state via bootstrap with the given cursor manager,
+	* exports and appends any local delta, then re-bootstraps to converge
+	* persisted cursor and local CRDT state on server truth.
+	*/
+	async inferRemoteAndAppendLocal(bootstrapCursor, cursorManager) {
+		const inferredRemote = await this.bootstrapState(bootstrapCursor, { cursorManager });
+		const localBatch = this.exportUpdates(inferredRemote.cursor.serverLowerBoundVersion);
+		if (localBatch.batch != null) await this.appendLocalBatch(inferredRemote.cursor, localBatch.batch, false);
+		return await this.bootstrapState(bootstrapCursor);
+	}
+	async recoverFromGoneWithLocalBootstrap(cursor) {
+		const isolatedCursorManager = await this.createIsolatedCursorManager();
+		const bootstrapCursor = {
+			...cursor,
+			nextOffset: "-1",
+			serverLowerBoundVersion: this.adapter.emptyVersion()
+		};
+		if (isolatedCursorManager != null) return await this.inferRemoteAndAppendLocal(bootstrapCursor, isolatedCursorManager);
+		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 {
 			if (state.liveMode === "long-poll") {
 				const requestOffset = state.cursor.nextOffset;
-				const response = await this.readFromOffset(this.streamUrl, requestOffset, state.streamCursor, "long-poll", state.requestController?.signal);
+				const response = await this.client.readFromOffset(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 +1620,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.client.readFromOffsetSseItems(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 +1672,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;
@@ -1656,6 +1754,7 @@ var StreamsCrdt = class StreamsCrdt {
 				while (!state.closed) try {
 					state.cursor = await this.enqueueExclusive(async () => this.appendLocalBatch(state.cursor, drained.batch));
 					for (let i = 0; i < drained.count; i += 1) state.pendingLocal.popFront();
+					this.notifySyncWaiters(state, drained.count);
 					this.setJoinStatus(state, "joined");
 					this.snapshotManager.schedule(state);
 					break;
@@ -1666,11 +1765,13 @@ var StreamsCrdt = class StreamsCrdt {
 							streamUrl: this.streamUrl,
 							code: classified.code
 						});
+						this.rejectSyncWaiters(state, /* @__PURE__ */ new Error(`local append failed: ${classified.code}`));
 						this.setJoinStatus(state, "error");
 						return;
 					}
 					const maxAttempts = this.reconnectConfig.maxAttempts;
 					if (attempts >= maxAttempts) {
+						this.rejectSyncWaiters(state, /* @__PURE__ */ new Error("local append retry budget exhausted"));
 						this.setJoinStatus(state, "error");
 						return;
 					}
@@ -1684,6 +1785,25 @@ var StreamsCrdt = class StreamsCrdt {
 			state.flushingLocal = false;
 		}
 	}
+	/**
+	* Decrements all sync waiters by the number of flushed batches and
+	* resolves any that have reached zero.
+	*/
+	notifySyncWaiters(state, flushedCount) {
+		let i = 0;
+		while (i < state.syncWaiters.length) {
+			const waiter = state.syncWaiters[i];
+			waiter.remaining -= flushedCount;
+			if (waiter.remaining <= 0) {
+				state.syncWaiters.splice(i, 1);
+				waiter.resolve();
+			} else i += 1;
+		}
+	}
+	/** Rejects and removes all sync waiters. */
+	rejectSyncWaiters(state, error) {
+		for (const waiter of state.syncWaiters.splice(0)) waiter.reject(error);
+	}
 	async saveRemoteCursor(cursor, source) {
 		return await persistRemoteCursor({
 			remoteCursorStore: this.remoteCursorStore,
@@ -1697,30 +1817,6 @@ var StreamsCrdt = class StreamsCrdt {
 		state.status = status;
 		for (const listener of state.statusListeners) listener(status);
 	}
-	async createStreamRequest() {
-		return await this.client.createStreamRequest();
-	}
-	async deleteStreamRequest() {
-		return await this.client.deleteStreamRequest();
-	}
-	async readFromOffsetSseItems(_streamUrl, offset, cursor, onControl, onOpen, signal) {
-		return await this.client.readFromOffsetSseItems(offset, cursor, onControl, onOpen, signal);
-	}
-	async readFromOffset(_streamUrl, offset, cursor, live, signal) {
-		return await this.client.readFromOffset(offset, cursor, live, signal);
-	}
-	async bootstrap(_streamUrl) {
-		return await this.client.bootstrap();
-	}
-	async readSnapshotOffsetValue() {
-		return await this.client.readSnapshotOffsetValue();
-	}
-	async putSnapshotAt(snapshotOffset, snapshot) {
-		await this.client.putSnapshotAt(snapshotOffset, snapshot);
-	}
-	async appendUpdates(_streamUrl, updates, producerSession) {
-		return await this.client.appendUpdates(updates, producerSession);
-	}
 	enqueueExclusive(task) {
 		const run = this.opQueue.then(task, task);
 		this.opQueue = run.then(() => void 0, () => void 0);
@@ -1779,4 +1875,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-DBym_2Mj.js.map