@loro-dev/streams-crdt 0.5.0 → 0.6.1

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

@@ -184,7 +184,8 @@ const DEFAULT_RECONNECT_CONFIG = {
 	jitterFraction: .2,
 	maxAttempts: Infinity,
 	connectTimeoutMs: 1e4,
-	pollTimeoutMs: 3e4
+	pollTimeoutMs: 3e4,
+	liveInactivityTimeoutMs: 45e3
 };
 /**
 * Apply jitter of +/- fraction to a base delay.
@@ -677,13 +678,29 @@ var StreamsTransportClient = class {
 	async readItemsSse(initialOffset, cursor, onControl, onOpen, signal) {
 		const opened = await this.openItemsSseSession(initialOffset, cursor, onOpen, signal);
 		if (opened.kind !== "ok") return opened;
-		const result = await opened.session.continue(onControl);
-		if (result.paused) await opened.session.cancel();
-		return {
-			kind: "ok",
-			latestOffset: result.latestOffset,
-			latestCursor: result.latestCursor
-		};
+		let abortHandler;
+		const abortRace = signal != null && !signal.aborted ? new Promise((_, reject) => {
+			abortHandler = () => {
+				opened.session.cancel();
+				reject(signal.reason ?? new DOMException("The operation was aborted.", "AbortError"));
+			};
+			signal.addEventListener("abort", abortHandler, { once: true });
+		}) : null;
+		try {
+			if (signal?.aborted) {
+				await opened.session.cancel();
+				throw signal.reason ?? new DOMException("The operation was aborted.", "AbortError");
+			}
+			const result = abortRace != null ? await Promise.race([opened.session.continue(onControl), abortRace]) : await opened.session.continue(onControl);
+			if (result.paused) await opened.session.cancel();
+			return {
+				kind: "ok",
+				latestOffset: result.latestOffset,
+				latestCursor: result.latestCursor
+			};
+		} finally {
+			if (abortHandler != null && signal != null) signal.removeEventListener("abort", abortHandler);
+		}
 	}
 	async openItemsSseSession(initialOffset, cursor, onOpen, signal) {
 		const result = await this.client.openSseSession({
@@ -1074,6 +1091,8 @@ function createJoinState(cursor, liveMode = "sse") {
 		refCount: 0,
 		closed: false,
 		status: "connecting",
+		readSubStatus: "connecting",
+		writeSubStatus: "ok",
 		statusListeners: /* @__PURE__ */ new Set(),
 		pendingLocal: new Deque(),
 		flushingLocal: false,
@@ -1082,7 +1101,8 @@ function createJoinState(cursor, liveMode = "sse") {
 		cursor,
 		liveMode,
 		snapshot: createTransportSnapshotState(),
-		started: Promise.resolve()
+		started: Promise.resolve(),
+		syncWaiters: []
 	};
 }
 async function disposeJoinState(state, options) {
@@ -1094,6 +1114,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
@@ -1156,8 +1178,8 @@ var StreamsCrdt = class StreamsCrdt {
 			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),
@@ -1175,22 +1197,31 @@ var StreamsCrdt = class StreamsCrdt {
 	* Resets the retry counter and immediately attempts to reconnect.
 	*
 	* Use this after device wake or network recovery to skip any pending
-	* backoff delay. No-op when the room is already joined or no join is active.
+	* backoff delay. No-op when the room is already fully healthy (both
+	* read and write sub-statuses are "ok") or no join is active.
 	*
-	* If the room reached `"disconnected"` status (only possible with a finite
-	* `maxAttempts` config), this restarts the read loop.
+	* If the room reached `"disconnected"` or `"error"` status, this
+	* restarts the affected loop(s).
 	*/
 	rejoin() {
 		const state = this.joinState;
-		if (state == null || state.closed || state.status === "joined") return;
-		const wasDisconnected = state.status === "disconnected";
+		if (state == null || state.closed) return;
+		if (state.readSubStatus === "ok" && state.writeSubStatus === "ok") return;
 		state.retryAttempt = 0;
 		state.retrySleepController.abort();
 		state.retrySleepController = new AbortController();
-		if (wasDisconnected) {
-			this.setJoinStatus(state, "reconnecting");
+		const previousController = state.requestController;
+		state.requestController = new AbortController();
+		previousController?.abort();
+		if (state.readSubStatus === "disconnected" || state.readSubStatus === "error") {
+			this.setReadSubStatus(state, "reconnecting");
 			this.runReadLoop(state);
 		}
+		if (state.writeSubStatus === "error") {
+			state.writeSubStatus = state.pendingLocal.length > 0 ? "reconnecting" : "ok";
+			this.recomputeJoinStatus(state);
+			if (state.pendingLocal.length > 0) this.flushPendingLocal(state);
+		}
 	}
 	/**
 	* Reads the latest remote snapshot offset, if the server exposes one.
@@ -1199,7 +1230,7 @@ var StreamsCrdt = class StreamsCrdt {
 		try {
 			return {
 				ok: true,
-				value: await this.readSnapshotOffsetValue()
+				value: await this.client.readSnapshotOffsetValue()
 			};
 		} catch (error) {
 			return {
@@ -1215,7 +1246,7 @@ var StreamsCrdt = class StreamsCrdt {
 		try {
 			return {
 				ok: true,
-				value: { created: await this.createStreamRequest() }
+				value: { created: await this.client.createStreamRequest() }
 			};
 		} catch (error) {
 			return {
@@ -1233,7 +1264,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;
@@ -1330,6 +1361,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
+					});
+				});
 			}
 		};
 	}
@@ -1361,13 +1405,16 @@ var StreamsCrdt = class StreamsCrdt {
 				if (state.status === "error" || state.status === "disconnected") throw new Error("join local sync failed before subscription became ready");
 			}
 			if (state.closed) return;
-			this.setJoinStatus(state, "joined");
+			this.setReadSubStatus(state, "ok");
+			this.setWriteSubStatus(state, "ok");
 			this.runReadLoop(state);
 		} catch (error) {
 			if (state.closed) return;
 			this.snapshotManager.dispose(state);
 			this.logError("join first sync failed", error, { streamUrl: this.streamUrl });
-			this.setJoinStatus(state, "error");
+			state.readSubStatus = "error";
+			state.writeSubStatus = "error";
+			this.recomputeJoinStatus(state);
 			throw error;
 		}
 	}
@@ -1419,13 +1466,13 @@ var StreamsCrdt = class StreamsCrdt {
 			return caughtUp;
 		} catch (error) {
 			if (!isStreamNotFoundError(error) || !this.createStreamIfMissing) throw error;
-			await this.createStreamRequest();
+			await this.ensureStreamExists();
 			return await this.bootstrapState(this.createInitialCursor());
 		}
 	}
 	async bootstrapState(cursor, options = {}) {
 		const cursorManager = options.cursorManager ?? this.cursorManager;
-		const result = await this.bootstrap(this.streamUrl);
+		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) {
@@ -1458,7 +1505,7 @@ var StreamsCrdt = class StreamsCrdt {
 		const cursorManager = options.cursorManager ?? this.cursorManager;
 		while (true) {
 			const requestOffset = current.nextOffset;
-			const response = await this.readFromOffset(this.streamUrl, requestOffset, currentStreamCursor, options.live);
+			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({
@@ -1484,7 +1531,16 @@ var StreamsCrdt = class StreamsCrdt {
 			nextProducerSeq: this.nextProducerSeq
 		};
 		for (let attempt = 0; attempt < 3; attempt += 1) {
-			const result = await this.appendUpdates(this.streamUrl, batch.updates, producerSession);
+			let result;
+			try {
+				result = await this.client.appendUpdates(batch.updates, producerSession);
+			} catch (error) {
+				if (isStreamNotFoundError(error) && this.createStreamIfMissing) {
+					await this.ensureStreamExists();
+					continue;
+				}
+				throw error;
+			}
 			if (result.kind === "ok") {
 				this.producerEpoch = result.ackEpoch;
 				this.nextProducerSeq = result.ackSeq + 1;
@@ -1510,6 +1566,17 @@ var StreamsCrdt = class StreamsCrdt {
 		}
 		throw new Error("append retry budget exhausted");
 	}
+	/**
+	* Ensures the target stream exists, creating it if necessary.
+	* Tolerates 409 Conflict (stream already created concurrently).
+	*/
+	async ensureStreamExists() {
+		try {
+			await this.client.createStreamRequest();
+		} catch (error) {
+			if (!(error instanceof HttpError && error.status === 409)) throw error;
+		}
+	}
 	exportUpdates(fromVersion) {
 		const exported = this.adapter.exportUpdates(fromVersion);
 		if (exported == null) return { nextRefVersion: fromVersion };
@@ -1538,6 +1605,17 @@ var StreamsCrdt = class StreamsCrdt {
 		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 = {
@@ -1545,12 +1623,7 @@ var StreamsCrdt = class StreamsCrdt {
 			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);
-		}
+		if (isolatedCursorManager != null) return await this.inferRemoteAndAppendLocal(bootstrapCursor, isolatedCursorManager);
 		const preservedLocalSnapshot = this.adapter.exportSnapshot();
 		let restoredLocalSnapshot = false;
 		try {
@@ -1567,121 +1640,166 @@ var StreamsCrdt = class StreamsCrdt {
 	}
 	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);
-				if (response.kind === "gone") {
-					const bootstrapped = await this.bootstrapState({
-						...state.cursor,
-						nextOffset: "-1",
-						serverLowerBoundVersion: this.adapter.emptyVersion()
+		while (!state.closed) {
+			const capturedController = state.requestController;
+			let inactivityTimer = null;
+			let inactivityTriggered = false;
+			const clearInactivity = () => {
+				if (inactivityTimer != null) {
+					clearTimeout(inactivityTimer);
+					inactivityTimer = null;
+				}
+			};
+			const resetInactivity = () => {
+				clearInactivity();
+				const timeoutMs = this.reconnectConfig.liveInactivityTimeoutMs;
+				if (timeoutMs != null && timeoutMs > 0 && !state.closed) inactivityTimer = setTimeout(() => {
+					inactivityTriggered = true;
+					capturedController?.abort();
+				}, timeoutMs);
+			};
+			try {
+				if (state.liveMode === "long-poll") {
+					const requestOffset = state.cursor.nextOffset;
+					const response = await this.client.readFromOffset(requestOffset, state.streamCursor, "long-poll", capturedController?.signal);
+					if (response.kind === "gone") {
+						const bootstrapped = await this.bootstrapState({
+							...state.cursor,
+							nextOffset: "-1",
+							serverLowerBoundVersion: this.adapter.emptyVersion()
+						});
+						state.cursor = bootstrapped.cursor;
+						state.streamCursor = bootstrapped.streamCursor;
+						state.retryAttempt = 0;
+						continue;
+					}
+					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`);
+					await this.enqueueExclusive(async () => {
+						if (state.closed) return;
+						state.cursor = await this.cursorManager.applyLiveResult(state.cursor, requestOffset, result, (previousVersion, nextVersion) => {
+							this.snapshotManager.observeRemoteVersion(state, previousVersion, nextVersion);
+						});
+						if (result.streamCursor != null) state.streamCursor = result.streamCursor;
 					});
-					state.cursor = bootstrapped.cursor;
-					state.streamCursor = bootstrapped.streamCursor;
+					if (state.closed) return;
 					state.retryAttempt = 0;
+					this.setReadSubStatus(state, "ok");
+					await sleep(0);
 					continue;
 				}
-				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`);
-				await this.enqueueExclusive(async () => {
-					if (state.closed) return;
-					state.cursor = await this.cursorManager.applyLiveResult(state.cursor, requestOffset, result, (previousVersion, nextVersion) => {
-						this.snapshotManager.observeRemoteVersion(state, previousVersion, nextVersion);
+				const sseRequestOffset = state.cursor.nextOffset;
+				const pendingRemote = [];
+				let flushChain = Promise.resolve();
+				resetInactivity();
+				const sseResult = await this.client.readFromOffsetSseItems(sseRequestOffset, state.streamCursor, (updates, nextOffset, _upToDate, streamCursor) => {
+					resetInactivity();
+					pendingRemote.push({
+						updates,
+						nextOffset,
+						streamCursor
 					});
-					if (result.streamCursor != null) state.streamCursor = result.streamCursor;
-				});
-				if (state.closed) return;
-				state.retryAttempt = 0;
-				this.setJoinStatus(state, "joined");
-				await sleep(0);
-				continue;
-			}
-			const sseRequestOffset = state.cursor.nextOffset;
-			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);
+					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;
+							}
 						});
-						for (let i = events.length - 1; i >= 0; i--) if (events[i].streamCursor != null) {
-							state.streamCursor = events[i].streamCursor;
-							break;
-						}
+						this.setReadSubStatus(state, "ok");
+					});
+				}, () => {
+					resetInactivity();
+					this.setReadSubStatus(state, "ok");
+				}, capturedController?.signal);
+				clearInactivity();
+				await flushChain;
+				if (state.closed) return;
+				if (sseResult.kind === "ok") {
+					state.retryAttempt = 0;
+					state.streamCursor = sseResult.latestCursor;
+					await sleep(0);
+					continue;
+				}
+				if (sseResult.kind === "unsupported") {
+					state.liveMode = "long-poll";
+					await sleep(0);
+					continue;
+				}
+				if (sseResult.kind === "not-found") {
+					this.logError("live read failed", new HttpError("stream not found", 404), {
+						streamUrl: this.streamUrl,
+						code: "stream_not_found"
 					});
-					this.setJoinStatus(state, "joined");
+					this.setReadSubStatus(state, "error");
+					return;
+				}
+				const bootstrapped = await this.bootstrapState({
+					...state.cursor,
+					nextOffset: "-1",
+					serverLowerBoundVersion: this.adapter.emptyVersion()
 				});
-			}, () => {
-				this.setJoinStatus(state, "joined");
-			}, state.requestController?.signal);
-			await flushChain;
-			if (state.closed) return;
-			if (sseResult.kind === "ok") {
+				state.cursor = bootstrapped.cursor;
+				state.streamCursor = bootstrapped.streamCursor;
 				state.retryAttempt = 0;
-				state.streamCursor = sseResult.latestCursor;
-				await sleep(0);
-				continue;
-			}
-			if (sseResult.kind === "unsupported") {
-				state.liveMode = "long-poll";
-				await sleep(0);
-				continue;
-			}
-			if (sseResult.kind === "not-found") {
-				this.logError("live read failed", new HttpError("stream not found", 404), {
-					streamUrl: this.streamUrl,
-					code: "stream_not_found"
-				});
-				this.setJoinStatus(state, "error");
-				return;
-			}
-			const bootstrapped = await this.bootstrapState({
-				...state.cursor,
-				nextOffset: "-1",
-				serverLowerBoundVersion: this.adapter.emptyVersion()
-			});
-			state.cursor = bootstrapped.cursor;
-			state.streamCursor = bootstrapped.streamCursor;
-			state.retryAttempt = 0;
-		} catch (error) {
-			if (state.closed) return;
-			const classified = classifyFetchError(error);
-			if (!classified.retriable || isAuthOrProtocolError(error)) {
-				this.logError("live read failed", error, {
-					streamUrl: this.streamUrl,
-					code: classified.code
-				});
-				this.setJoinStatus(state, "error");
-				return;
-			}
-			this.setJoinStatus(state, "reconnecting");
-			const maxAttempts = this.reconnectConfig.maxAttempts;
-			if (state.retryAttempt >= maxAttempts) {
-				this.logError("live read reconnect exhausted", error, {
-					streamUrl: this.streamUrl,
-					attempts: state.retryAttempt
-				});
-				this.setJoinStatus(state, "disconnected");
-				return;
+			} catch (error) {
+				clearInactivity();
+				if (state.closed) return;
+				if (capturedController?.signal.aborted) {
+					if (inactivityTriggered) {
+						if (state.requestController === capturedController) state.requestController = new AbortController();
+						this.logDebug("sse inactivity timeout", { streamUrl: this.streamUrl });
+						this.setReadSubStatus(state, "reconnecting");
+						const maxAttempts = this.reconnectConfig.maxAttempts;
+						if (state.retryAttempt >= maxAttempts) {
+							this.logError("live read reconnect exhausted (inactivity)", error, {
+								streamUrl: this.streamUrl,
+								attempts: state.retryAttempt
+							});
+							this.setReadSubStatus(state, "disconnected");
+							return;
+						}
+						state.retryAttempt += 1;
+						continue;
+					}
+					state.retryAttempt = 0;
+					this.setReadSubStatus(state, "reconnecting");
+					continue;
+				}
+				const classified = classifyFetchError(error);
+				if (!classified.retriable || isAuthOrProtocolError(error)) {
+					this.logError("live read failed", error, {
+						streamUrl: this.streamUrl,
+						code: classified.code
+					});
+					this.setReadSubStatus(state, "error");
+					return;
+				}
+				this.setReadSubStatus(state, "reconnecting");
+				const maxAttempts = this.reconnectConfig.maxAttempts;
+				if (state.retryAttempt >= maxAttempts) {
+					this.logError("live read reconnect exhausted", error, {
+						streamUrl: this.streamUrl,
+						attempts: state.retryAttempt
+					});
+					this.setReadSubStatus(state, "disconnected");
+					return;
+				}
+				const delay = computeRetryDelay(state.retryAttempt, this.reconnectConfig);
+				state.retryAttempt += 1;
+				await sleep(delay, state.retrySleepController.signal);
 			}
-			const delay = computeRetryDelay(state.retryAttempt, this.reconnectConfig);
-			state.retryAttempt += 1;
-			await sleep(delay, state.retrySleepController.signal);
 		}
 	}
 	/** Maximum encoded size (bytes) for a single batched append. */
@@ -1732,7 +1850,8 @@ 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.setJoinStatus(state, "joined");
+					this.notifySyncWaiters(state, drained.count);
+					this.setWriteSubStatus(state, "ok");
 					this.snapshotManager.schedule(state);
 					break;
 				} catch (error) {
@@ -1742,15 +1861,17 @@ var StreamsCrdt = class StreamsCrdt {
 							streamUrl: this.streamUrl,
 							code: classified.code
 						});
-						this.setJoinStatus(state, "error");
+						this.rejectSyncWaiters(state, /* @__PURE__ */ new Error(`local append failed: ${classified.code}`));
+						this.setWriteSubStatus(state, "error");
 						return;
 					}
 					const maxAttempts = this.reconnectConfig.maxAttempts;
 					if (attempts >= maxAttempts) {
-						this.setJoinStatus(state, "error");
+						this.rejectSyncWaiters(state, /* @__PURE__ */ new Error("local append retry budget exhausted"));
+						this.setWriteSubStatus(state, "error");
 						return;
 					}
-					this.setJoinStatus(state, "reconnecting");
+					this.setWriteSubStatus(state, "reconnecting");
 					const delay = computeRetryDelay(attempts, this.reconnectConfig);
 					attempts += 1;
 					await sleep(delay, state.retrySleepController.signal);
@@ -1760,6 +1881,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,
@@ -1768,34 +1908,29 @@ var StreamsCrdt = class StreamsCrdt {
 			beforeRemoteCursorSave: this.beforeRemoteCursorSave
 		});
 	}
-	setJoinStatus(state, status) {
+	setReadSubStatus(state, sub) {
+		if (state.readSubStatus === sub) return;
+		state.readSubStatus = sub;
+		this.recomputeJoinStatus(state);
+	}
+	setWriteSubStatus(state, sub) {
+		if (state.writeSubStatus === sub) return;
+		state.writeSubStatus = sub;
+		this.recomputeJoinStatus(state);
+	}
+	recomputeJoinStatus(state) {
+		const status = this.computeOverallStatus(state);
 		if (state.status === status) return;
 		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);
+	computeOverallStatus(state) {
+		const { readSubStatus, writeSubStatus } = state;
+		if (readSubStatus === "error" || writeSubStatus === "error") return "error";
+		if (readSubStatus === "disconnected") return "disconnected";
+		if (readSubStatus === "connecting") return "connecting";
+		if (readSubStatus === "reconnecting" || writeSubStatus === "reconnecting") return "reconnecting";
+		return "joined";
 	}
 	enqueueExclusive(task) {
 		const run = this.opQueue.then(task, task);
@@ -1855,4 +1990,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-nPEdFo7c.js.map
+//# sourceMappingURL=stream-id-0dTFsiaO.js.map