@loro-dev/streams-crdt 0.8.0 → 0.8.2

package/dist/{stream-id-CF1egQDz.js → stream-id-BjmGvObf.js}

@@ -597,6 +597,12 @@ function mergeAbortSignals(...signals) {
 function classifyFetchError(err) {
 	const message = err instanceof Error ? err.message : String(err);
 	const status = err instanceof HttpError ? err.status : void 0;
+	if (isCrdtApplyIncompleteError(err)) return {
+		code: "apply_incomplete",
+		message,
+		retriable: true,
+		atMs: Date.now()
+	};
 	if (status === 401 || status === 403) return {
 		code: "auth_failed",
 		message,
@@ -650,6 +656,12 @@ function isStreamNotFoundError(error) {
 	return error instanceof HttpError && error.status === 404;
 }
 function toTransportError(error) {
+	if (isCrdtApplyIncompleteError(error)) return {
+		code: "apply_incomplete",
+		retryable: true,
+		reason: "loro_pending_updates",
+		message: error instanceof Error ? error.message : String(error)
+	};
 	if (isStreamNotFoundError(error)) return {
 		code: "stream_not_found",
 		retryable: false
@@ -710,6 +722,9 @@ function toTransportError(error) {
 		message: String(error)
 	};
 }
+function isCrdtApplyIncompleteError(error) {
+	return error instanceof Error && Array.isArray(error.unresolved) && error.message.includes("CRDT apply incomplete");
+}
 function isReadNoProgress(requestOffset, result) {
 	return !result.upToDate && result.updates.length === 0 && result.nextOffset === requestOffset;
 }
@@ -1231,8 +1246,6 @@ var EphemeralStreamCrdt = class {
 	client;
 	/** Retry policy shared by the read loop and local write queue. */
 	reconnectConfig;
-	/** Period for republishing full local ephemeral state, or `false` to disable it. */
-	heartbeatMs;
 	/** Enables diagnostic console errors for failed read/write loops. */
 	debug;
 	/** Current shared subscription state, if the stream is joined. */
@@ -1244,7 +1257,6 @@ var EphemeralStreamCrdt = class {
 			...DEFAULT_RECONNECT_CONFIG,
 			...options.reconnectConfig
 		};
-		this.heartbeatMs = options.heartbeatMs ?? 15e3;
 		this.debug = options.debug ?? false;
 		this.client = new StreamsTransportClient({
 			streamUrl: options.streamUrl,
@@ -1325,18 +1337,15 @@ var EphemeralStreamCrdt = class {
 		};
 	}
 	async startJoin(state) {
+		state.unsubscribeLocal = this.adaptor.subscribeLocalUpdates((update) => {
+			this.enqueueLocal(state, normalizeEphemeralUpdate(update));
+		});
 		state.requestController = new AbortController();
 		const firstOpen = this.waitForFirstOpen(state);
 		this.runReadLoop(state);
 		await firstOpen;
 		if (state.closed) return;
-		state.unsubscribeLocal = this.adaptor.subscribeLocalUpdates((update) => {
-			this.enqueueLocal(state, normalizeEphemeralUpdate(update));
-		});
 		this.setWriteStatus(state, "ok");
-		const fullState = normalizeEphemeralUpdate(await this.adaptor.encodeAll());
-		if (fullState != null) state.pendingLocal.pushBack(fullState);
-		this.startHeartbeat(state);
 		await this.flushPendingLocal(state);
 		if (state.status === "error" || state.status === "disconnected") throw new Error(`ephemeral stream failed to join: ${state.status}`);
 	}
@@ -1394,7 +1403,6 @@ var EphemeralStreamCrdt = class {
 		if (state.closed) return;
 		state.closed = true;
 		state.unsubscribeLocal?.();
-		if (state.heartbeatTimer != null) clearInterval(state.heartbeatTimer);
 		state.requestController?.abort();
 		state.retrySleepController.abort();
 		this.rejectFirstOpen(state, closedSubscriptionError());
@@ -1420,7 +1428,6 @@ var EphemeralStreamCrdt = class {
 					if (bootstrap.byteLength > 0) await this.adaptor.applyRemoteUpdates([bootstrap]);
 					this.setReadStatus(state, "ok");
 					this.resolveFirstOpen(state);
-					if (state.unsubscribeLocal != null) this.enqueueFullState(state);
 				}, async (update) => {
 					if (update.byteLength > 0) await this.adaptor.applyRemoteUpdates([update]);
 				}, capturedController.signal);
@@ -1466,25 +1473,10 @@ var EphemeralStreamCrdt = class {
 			}
 		}
 	}
-	startHeartbeat(state) {
-		if (this.heartbeatMs === false || this.heartbeatMs <= 0) return;
-		state.heartbeatTimer = setInterval(() => {
-			this.enqueueFullState(state);
-		}, this.heartbeatMs);
-	}
-	async enqueueFullState(state) {
-		try {
-			const update = await this.adaptor.encodeAll();
-			this.enqueueLocal(state, normalizeEphemeralUpdate(update));
-		} catch (error) {
-			this.logError("ephemeral encodeAll failed", error, { streamUrl: this.streamUrl });
-			this.setWriteStatus(state, "error");
-		}
-	}
 	enqueueLocal(state, update) {
 		if (state.closed || update == null || update.byteLength === 0) return;
 		state.pendingLocal.pushBack(update);
-		this.flushPendingLocal(state);
+		if (state.writeStatus !== "connecting") this.flushPendingLocal(state);
 	}
 	async flushPendingLocal(state) {
 		if (state.flushingLocal || state.closed) return;
@@ -1737,67 +1729,115 @@ function createInitialRemoteCursor(input) {
 }
 //#endregion
 //#region src/transport-cursor.ts
+var CrdtApplyIncompleteError = class extends Error {
+	unresolved;
+	constructor(unresolved) {
+		super("CRDT apply incomplete: unresolved remote updates remain");
+		this.unresolved = unresolved;
+	}
+};
+function isApplyOutcome(value) {
+	return typeof value === "object" && value != null && "version" in value && "complete" in value && typeof value.complete === "boolean";
+}
+function normalizeApplyReturn(value) {
+	if (isApplyOutcome(value)) return value;
+	return {
+		version: value,
+		complete: true
+	};
+}
 var TransportCursorManager = class {
 	adapter;
 	decodeSnapshot;
 	decodeUpdateItems;
 	saveRemoteCursor;
+	incompleteCursors = /* @__PURE__ */ new WeakMap();
 	constructor(options) {
 		this.adapter = options.adapter;
 		this.decodeSnapshot = options.decodeSnapshot;
 		this.decodeUpdateItems = options.decodeUpdateItems;
 		this.saveRemoteCursor = options.saveRemoteCursor;
 	}
-	async applyBootstrapPayload(cursor, snapshot, updates, nextOffset) {
+	isCursorComplete(cursor) {
+		return !this.incompleteCursors.has(cursor);
+	}
+	async applyBootstrapPayload(cursor, snapshot, updates, nextOffset, upToDate = false) {
 		let nextVersion = cursor.serverLowerBoundVersion;
-		if (snapshot.byteLength > 0) nextVersion = await this.adapter.applySnapshot(this.decodeSnapshot == null ? snapshot : await this.decodeSnapshot(snapshot));
+		let complete = true;
+		let unresolved = [];
+		if (snapshot.byteLength > 0) {
+			const outcome = normalizeApplyReturn(await this.adapter.applySnapshot(this.decodeSnapshot == null ? snapshot : await this.decodeSnapshot(snapshot)));
+			nextVersion = outcome.version;
+			complete = outcome.complete;
+			unresolved = outcome.unresolved ?? [];
+		}
 		const clearUpdates = await this.decodeRemoteUpdateItems(updates);
-		if (clearUpdates.length > 0) nextVersion = await this.adapter.applyRemoteUpdates(clearUpdates, nextVersion);
+		if (clearUpdates.length > 0) {
+			const outcome = normalizeApplyReturn(await this.adapter.applyRemoteUpdates(clearUpdates, nextVersion));
+			nextVersion = outcome.version;
+			complete = outcome.complete;
+			unresolved = outcome.unresolved ?? [];
+		}
 		return await this.finalizeCursor({
 			...cursor,
 			nextOffset,
 			serverLowerBoundVersion: nextVersion
-		}, "bootstrap");
+		}, "bootstrap", complete, unresolved, upToDate);
 	}
-	async applyBootstrapItems(cursor, items, nextOffset) {
+	async applyBootstrapItems(cursor, items, nextOffset, upToDate = false) {
 		const snapshot = items[0] ?? new Uint8Array();
-		return await this.applyBootstrapPayload(cursor, snapshot, items.slice(1), nextOffset);
+		return await this.applyBootstrapPayload(cursor, snapshot, items.slice(1), nextOffset, upToDate);
 	}
 	async applyRemoteItems(cursor, items, nextOffset) {
 		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);
+		return await this.applyRemotePayload(cursor, result.updates, result.nextOffset, "remote", onRemoteVersionApplied, result.upToDate);
 	}
 	async applyLiveResult(cursor, requestOffset, result, onRemoteVersionApplied) {
 		const previousVersion = cursor.serverLowerBoundVersion;
 		let nextVersion = previousVersion;
+		let complete = this.isCursorComplete(cursor);
+		let unresolved = this.incompleteCursors.get(cursor) ?? [];
 		const clearUpdates = await this.decodeRemoteUpdateItems(result.updates);
 		if (clearUpdates.length > 0) {
-			nextVersion = await this.adapter.applyRemoteUpdates(clearUpdates, nextVersion);
+			const outcome = normalizeApplyReturn(await this.adapter.applyRemoteUpdates(clearUpdates, nextVersion));
+			nextVersion = outcome.version;
+			complete = outcome.complete;
+			unresolved = outcome.unresolved ?? [];
 			await onRemoteVersionApplied?.(previousVersion, nextVersion);
 		}
 		return await this.finalizeCursor({
 			...cursor,
 			nextOffset: resolveNextOffsetAfterConcurrentAdvance(requestOffset, cursor.nextOffset, result.nextOffset),
 			serverLowerBoundVersion: nextVersion
-		}, "remote");
+		}, "remote", complete, unresolved, result.upToDate === true);
 	}
-	async applyRemotePayload(cursor, updates, nextOffset, source, onRemoteVersionApplied) {
+	async applyRemotePayload(cursor, updates, nextOffset, source, onRemoteVersionApplied, upToDate = false) {
 		const previousVersion = cursor.serverLowerBoundVersion;
 		let nextVersion = previousVersion;
+		let complete = this.isCursorComplete(cursor);
+		let unresolved = this.incompleteCursors.get(cursor) ?? [];
 		const clearUpdates = await this.decodeRemoteUpdateItems(updates);
 		if (clearUpdates.length > 0) {
-			nextVersion = await this.adapter.applyRemoteUpdates(clearUpdates, nextVersion);
+			const outcome = normalizeApplyReturn(await this.adapter.applyRemoteUpdates(clearUpdates, nextVersion));
+			nextVersion = outcome.version;
+			complete = outcome.complete;
+			unresolved = outcome.unresolved ?? [];
 			await onRemoteVersionApplied?.(previousVersion, nextVersion);
 		}
 		return await this.finalizeCursor({
 			...cursor,
 			nextOffset,
 			serverLowerBoundVersion: nextVersion
-		}, source);
+		}, source, complete, unresolved, upToDate);
 	}
-	async finalizeCursor(cursor, source) {
+	async finalizeCursor(cursor, source, complete, unresolved, upToDate) {
+		if (!complete) {
+			if (upToDate) throw new CrdtApplyIncompleteError(unresolved);
+			this.incompleteCursors.set(cursor, unresolved);
+			return cursor;
+		}
 		return await this.saveRemoteCursor(cursor, source);
 	}
 	async decodeRemoteUpdateItems(items) {
@@ -1830,6 +1870,7 @@ var TransportSnapshotManager = class {
 	logDebug;
 	logError;
 	isCurrentState;
+	isCursorComplete;
 	constructor(options) {
 		this.adapter = options.adapter;
 		this.config = options.config;
@@ -1840,6 +1881,7 @@ var TransportSnapshotManager = class {
 		this.logDebug = options.logDebug;
 		this.logError = options.logError;
 		this.isCurrentState = options.isCurrentState;
+		this.isCursorComplete = options.isCursorComplete;
 	}
 	dispose(state) {
 		this.clearDebounceTimer(state.snapshot);
@@ -1889,6 +1931,10 @@ var TransportSnapshotManager = class {
 	async maybeUpload(state) {
 		const config = await this.resolveUploadConfig(state);
 		if (config == null) return;
+		if (!this.isCursorComplete(state.cursor)) {
+			this.logDebug("skip snapshot upload: current cursor is incomplete", { offset: state.cursor.nextOffset });
+			return;
+		}
 		const tailBytes = parseSnapshotByteOffset(state.cursor.nextOffset);
 		if (tailBytes == null) {
 			this.logDebug("skip snapshot upload: non-numeric offset token", { offset: state.cursor.nextOffset });
@@ -2003,6 +2049,7 @@ var StreamsCrdt = class StreamsCrdt {
 	nextProducerSeq = 0;
 	frozenLocalAppend;
 	committedPendingCount;
+	committedLocalStreamCursor;
 	pendingWriteOnly = new Deque();
 	writeOnlyCursor;
 	unsubscribeWriteOnlyLocal;
@@ -2060,7 +2107,8 @@ var StreamsCrdt = class StreamsCrdt {
 			enqueueExclusive: (task) => this.enqueueExclusive(task),
 			logDebug: (message, detail) => this.logDebug(message, detail),
 			logError: (message, error, detail) => this.logError(message, error, detail),
-			isCurrentState: (state) => this.joinState === state
+			isCurrentState: (state) => this.joinState === state,
+			isCursorComplete: (cursor) => this.cursorManager.isCursorComplete(cursor)
 		});
 		this.writeOnlyCursor = this.createInitialCursor();
 		this.unsubscribeWriteOnlyLocal = this.adapter.subscribeLocalUpdates((batch) => {
@@ -2214,6 +2262,7 @@ var StreamsCrdt = class StreamsCrdt {
 					this.nextProducerSeq = 0;
 					this.frozenLocalAppend = void 0;
 					this.committedPendingCount = void 0;
+					this.committedLocalStreamCursor = void 0;
 					return deleted;
 				}) }
 			};
@@ -2449,10 +2498,7 @@ var StreamsCrdt = class StreamsCrdt {
 	async syncOnce() {
 		let cursor = (await this.finalizeDirectLocalAppendIfNeeded(await this.resolveInitialRemoteState())).cursor;
 		const localBatch = this.exportUpdates(cursor.serverLowerBoundVersion);
-		if (localBatch.batch != null) {
-			cursor = await this.appendLocalBatch(cursor, localBatch.batch);
-			cursor = (await this.catchup(cursor)).cursor;
-		}
+		if (localBatch.batch != null) cursor = (await this.appendLocalBatchDurably(cursor, localBatch.batch)).cursor;
 		return cursor;
 	}
 	async performInitialJoinSync(preferredLiveMode) {
@@ -2464,10 +2510,9 @@ var StreamsCrdt = class StreamsCrdt {
 		const exportedLocal = this.exportUpdates(localExportRefVersion);
 		localExportRefVersion = exportedLocal.nextRefVersion;
 		if (exportedLocal.batch != null) {
-			cursor = await this.appendLocalBatch(cursor, exportedLocal.batch);
-			const caughtUp = await this.catchup(cursor);
-			cursor = caughtUp.cursor;
-			streamCursor = caughtUp.streamCursor;
+			const committed = await this.appendLocalBatchDurably(cursor, exportedLocal.batch, void 0, "direct", streamCursor);
+			cursor = committed.cursor;
+			streamCursor = committed.streamCursor;
 		}
 		localExportRefVersion = cursor.serverLowerBoundVersion;
 		return {
@@ -2501,7 +2546,7 @@ var StreamsCrdt = class StreamsCrdt {
 	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 saved = await cursorManager.applyBootstrapPayload(cursor, result.snapshot, result.updates, result.nextOffset, result.upToDate);
 		let bootstrapCursor = result.streamCursor;
 		if (!result.upToDate) {
 			const caughtUp = await this.catchupOrGone(saved, {
@@ -2544,7 +2589,16 @@ var StreamsCrdt = class StreamsCrdt {
 			}
 			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 cursorManager.applyCatchupResult(current, result, options.onRemoteVersionApplied);
+			try {
+				current = await cursorManager.applyCatchupResult(current, result, options.onRemoteVersionApplied);
+			} catch (error) {
+				if (error instanceof CrdtApplyIncompleteError && result.upToDate) return await this.bootstrapState({
+					...current,
+					nextOffset: "-1",
+					serverLowerBoundVersion: this.adapter.emptyVersion()
+				}, { cursorManager });
+				throw error;
+			}
 			currentStreamCursor = result.streamCursor;
 			if (result.upToDate) return {
 				cursor: current,
@@ -2552,20 +2606,64 @@ var StreamsCrdt = class StreamsCrdt {
 			};
 		}
 	}
-	async appendLocalBatch(cursor, batch, pendingCount) {
+	async recoverLiveIncompleteRemoteApply(state) {
+		try {
+			const bootstrapped = await this.bootstrapState({
+				...state.cursor,
+				nextOffset: "-1",
+				serverLowerBoundVersion: this.adapter.emptyVersion()
+			});
+			state.cursor = bootstrapped.cursor;
+			state.streamCursor = bootstrapped.streamCursor;
+			state.retryAttempt = 0;
+			state.lastError = void 0;
+			this.setReadSubStatus(state, "ok");
+			if (state.pendingLocal.length > 0) this.flushPendingLocal(state);
+			return true;
+		} catch (error) {
+			const classified = classifyFetchError(error);
+			this.logError("live incomplete apply recovery failed", error, {
+				streamUrl: this.streamUrl,
+				code: classified.code
+			});
+			state.lastError = toTransportError(error);
+			this.setReadSubStatus(state, classified.retriable ? "disconnected" : "error");
+			return false;
+		}
+	}
+	async appendLocalBatch(cursor, batch, pendingCount, streamCursor) {
 		const source = pendingCount == null ? "direct" : "pending";
-		const committed = await this.appendLocalBatchDurably(cursor, batch, pendingCount, source);
+		const committed = await this.appendLocalBatchDurably(cursor, batch, pendingCount, source, streamCursor);
 		this.committedPendingCount = committed.pendingCount;
+		this.committedLocalStreamCursor = committed.streamCursor;
 		return committed.cursor;
 	}
-	async appendLocalBatchDurably(cursor, batch, pendingCount, source = pendingCount == null ? "direct" : "pending") {
+	async appendLocalBatchDurably(cursor, batch, pendingCount, source = pendingCount == null ? "direct" : "pending", streamCursor) {
 		const frozen = await this.getOrCreateFrozenLocalAppend(cursor, batch, pendingCount, source);
 		const appended = await this.appendFrozenLocalBatchRemote(frozen);
-		const saved = await this.saveRemoteCursor(appended.cursor, "local");
+		const caughtUp = await this.catchupLocalAppend(frozen, streamCursor);
 		this.commitProducerAck(appended.producerAck);
 		return {
-			cursor: saved,
-			pendingCount: frozen.pendingCount
+			cursor: caughtUp.cursor,
+			pendingCount: frozen.pendingCount,
+			streamCursor: caughtUp.streamCursor
+		};
+	}
+	localAppendReadCursor(frozen) {
+		return {
+			...frozen.baseCursor,
+			serverLowerBoundVersion: this.adapter.mergeVersions(frozen.baseCursor.serverLowerBoundVersion, frozen.batch.version)
+		};
+	}
+	async catchupLocalAppend(frozen, streamCursor) {
+		const caughtUp = await this.catchupOrGone(this.localAppendReadCursor(frozen), {
+			streamCursor,
+			cursorManager: this.volatileCursorManager
+		});
+		if ("kind" in caughtUp) throw new Error("local append catch-up unexpectedly returned gone");
+		return {
+			cursor: await this.saveRemoteCursor(caughtUp.cursor, "local"),
+			streamCursor: caughtUp.streamCursor
 		};
 	}
 	async appendLocalBatchRemote(cursor, batch, pendingCount, source = pendingCount == null ? "direct" : "pending") {
@@ -2639,9 +2737,9 @@ var StreamsCrdt = class StreamsCrdt {
 		const frozen = this.frozenLocalAppend;
 		if (frozen == null || frozen.pendingCount != null) return state;
 		const appended = await this.appendFrozenLocalBatchRemote(frozen);
-		const saved = await this.saveRemoteCursor(appended.cursor, "local");
+		const caughtUp = await this.catchupLocalAppend(frozen, state.streamCursor);
 		this.commitProducerAck(appended.producerAck);
-		return await this.catchup(saved, void 0, state.streamCursor);
+		return caughtUp;
 	}
 	createCurrentProducerSession() {
 		return {
@@ -2666,6 +2764,11 @@ var StreamsCrdt = class StreamsCrdt {
 		this.committedPendingCount = void 0;
 		return count;
 	}
+	consumeCommittedLocalStreamCursor() {
+		const streamCursor = this.committedLocalStreamCursor;
+		this.committedLocalStreamCursor = void 0;
+		return streamCursor;
+	}
 	/**
 	* Ensures the target stream exists, creating it if necessary.
 	* Tolerates 409 Conflict (stream already created concurrently).
@@ -2802,6 +2905,7 @@ var StreamsCrdt = class StreamsCrdt {
 					if (state.closed) return;
 					state.retryAttempt = 0;
 					this.setReadSubStatus(state, "ok");
+					if (state.pendingLocal.length > 0) this.flushPendingLocal(state);
 					await sleep(0);
 					continue;
 				}
@@ -2810,12 +2914,13 @@ var StreamsCrdt = class StreamsCrdt {
 				let flushChain = Promise.resolve();
 				resetInactivity();
 				const sseStartedAtMs = Date.now();
-				const sseResult = await this.client.readFromOffsetSseItems(sseRequestOffset, state.streamCursor, (updates, nextOffset, _upToDate, streamCursor) => {
+				const sseResult = await this.client.readFromOffsetSseItems(sseRequestOffset, state.streamCursor, (updates, nextOffset, upToDate, streamCursor) => {
 					if (capturedController?.signal.aborted) return "stop";
 					resetInactivity();
 					pendingRemote.push({
 						updates,
 						nextOffset,
+						upToDate,
 						streamCursor
 					});
 					flushChain = flushChain.then(async () => {
@@ -2827,7 +2932,8 @@ var StreamsCrdt = class StreamsCrdt {
 							if (state.closed) return;
 							state.cursor = await this.cursorManager.applyLiveResult(state.cursor, sseRequestOffset, {
 								nextOffset: lastEvent.nextOffset,
-								updates: allUpdates
+								updates: allUpdates,
+								upToDate: lastEvent.upToDate
 							}, (previousVersion, nextVersion) => {
 								this.snapshotManager.observeRemoteVersion(state, previousVersion, nextVersion);
 							});
@@ -2837,6 +2943,7 @@ var StreamsCrdt = class StreamsCrdt {
 							}
 						});
 						this.setReadSubStatus(state, "ok");
+						if (state.pendingLocal.length > 0) this.flushPendingLocal(state);
 					}).catch((flushError) => {
 						this.logError("sse flush chain error", flushError, { streamUrl: this.streamUrl });
 						capturedController?.abort(flushError);
@@ -2880,6 +2987,11 @@ var StreamsCrdt = class StreamsCrdt {
 			} catch (error) {
 				clearInactivity();
 				if (state.closed) return;
+				if (error instanceof CrdtApplyIncompleteError) {
+					if (capturedController?.signal.aborted && state.requestController === capturedController) state.requestController = new AbortController();
+					if (await this.recoverLiveIncompleteRemoteApply(state)) continue;
+					return;
+				}
 				if (capturedController?.signal.aborted) {
 					if (inactivityTriggered) {
 						if (state.requestController === capturedController) state.requestController = new AbortController();
@@ -2906,6 +3018,11 @@ var StreamsCrdt = class StreamsCrdt {
 					}
 					const abortReason = capturedController.signal.reason;
 					const flushError = abortReason instanceof Error ? abortReason : error;
+					if (flushError instanceof CrdtApplyIncompleteError) {
+						if (state.requestController === capturedController) state.requestController = new AbortController();
+						if (await this.recoverLiveIncompleteRemoteApply(state)) continue;
+						return;
+					}
 					if (flushError instanceof Error && !(flushError instanceof DOMException && flushError.name === "AbortError")) {
 						const flushClassified = classifyFetchError(flushError);
 						if (!flushClassified.retriable || isAuthOrProtocolError(flushError)) {
@@ -2992,6 +3109,7 @@ var StreamsCrdt = class StreamsCrdt {
 	}
 	async flushPendingLocal(state) {
 		if (state.flushingLocal || state.closed) return;
+		if (!this.cursorManager.isCursorComplete(state.cursor)) return;
 		state.flushingLocal = true;
 		try {
 			while (!state.closed) {
@@ -2999,7 +3117,9 @@ var StreamsCrdt = class StreamsCrdt {
 				if (drained == null) return;
 				let attempts = 0;
 				while (!state.closed) try {
-					state.cursor = await this.enqueueExclusive(async () => this.appendLocalBatch(state.cursor, drained.batch, drained.count));
+					state.cursor = await this.enqueueExclusive(async () => this.appendLocalBatch(state.cursor, drained.batch, drained.count, state.streamCursor));
+					const committedStreamCursor = this.consumeCommittedLocalStreamCursor();
+					if (committedStreamCursor != null) state.streamCursor = committedStreamCursor;
 					const committedCount = this.consumeCommittedPendingCount() ?? drained.count;
 					for (let i = 0; i < committedCount; i += 1) state.pendingLocal.popFront();
 					this.notifySyncWaiters(state, committedCount);
@@ -3158,4 +3278,4 @@ function createStreamUrl(input) {
 //#endregion
 export { InMemoryRemoteCursorStore as a, EphemeralStreamCrdt as c, StreamsCrdt as i, PayloadProtectionError as l, isValidBucketId as n, IndexedDbRemoteCursorStore as o, isValidRillId as r, createInitialRemoteCursor as s, createStreamUrl as t };
 
-//# sourceMappingURL=stream-id-CF1egQDz.js.map
+//# sourceMappingURL=stream-id-BjmGvObf.js.map