@loro-dev/streams-crdt 0.2.1 → 0.3.0

package/dist/{stream-id-kM9JM1F7.js → stream-id-BS_IJr-Y.js}

@@ -1,3 +1,4 @@
+import { StreamsClient } from "@loro-dev/streams-client";
 //#region src/checkpoint.ts
 function composeBeforeRemoteCursorSaveHooks(...hooks) {
 	const active = hooks.filter((hook) => hook != null);
@@ -181,7 +182,7 @@ const DEFAULT_RECONNECT_CONFIG = {
 		15e3
 	],
 	jitterFraction: .2,
-	maxAttempts: 5,
+	maxAttempts: Infinity,
 	connectTimeoutMs: 1e4,
 	pollTimeoutMs: 3e4
 };
@@ -234,79 +235,6 @@ function decodeItems(payload) {
 	return out;
 }
 //#endregion
-//#region src/multipart.ts
-/**
-* Parse an RFC 2046 multipart/mixed body into its constituent parts.
-*
-* The boundary must NOT include the leading "--".
-*/
-function decodeMultipartMixed(boundary, data) {
-	const delimiter = new TextEncoder().encode(`--${boundary}`);
-	const closeDelimiter = new TextEncoder().encode(`--${boundary}--`);
-	const crlfCrlf = new TextEncoder().encode("\r\n\r\n");
-	const parts = [];
-	let pos = 0;
-	const firstDelimPos = indexOf(data, delimiter, pos);
-	if (firstDelimPos < 0) return parts;
-	pos = firstDelimPos + delimiter.byteLength;
-	if (pos < data.byteLength && data[pos] === 13) pos++;
-	if (pos < data.byteLength && data[pos] === 10) pos++;
-	while (pos < data.byteLength) {
-		if (startsWith(data.subarray(pos), closeDelimiter.subarray(delimiter.byteLength))) break;
-		const headerEnd = indexOf(data, crlfCrlf, pos);
-		if (headerEnd < 0) break;
-		const headerBytes = data.subarray(pos, headerEnd);
-		const headerText = new TextDecoder().decode(headerBytes);
-		let contentType = "application/octet-stream";
-		for (const line of headerText.split("\r\n")) {
-			const colonIdx = line.indexOf(":");
-			if (colonIdx > 0) {
-				if (line.slice(0, colonIdx).trim().toLowerCase() === "content-type") contentType = line.slice(colonIdx + 1).trim();
-			}
-		}
-		const bodyStart = headerEnd + crlfCrlf.byteLength;
-		const nextDelimPos = indexOf(data, delimiter, bodyStart);
-		if (nextDelimPos < 0) {
-			parts.push({
-				contentType,
-				body: data.subarray(bodyStart)
-			});
-			break;
-		}
-		let bodyEnd = nextDelimPos;
-		if (bodyEnd >= 2 && data[bodyEnd - 2] === 13 && data[bodyEnd - 1] === 10) bodyEnd -= 2;
-		parts.push({
-			contentType,
-			body: data.subarray(bodyStart, bodyEnd)
-		});
-		pos = nextDelimPos + delimiter.byteLength;
-		if (pos < data.byteLength && data[pos] === 45 && pos + 1 < data.byteLength && data[pos + 1] === 45) break;
-		if (pos < data.byteLength && data[pos] === 13) pos++;
-		if (pos < data.byteLength && data[pos] === 10) pos++;
-	}
-	return parts;
-}
-/**
-* Extract the boundary parameter from a Content-Type header value.
-* Returns null if not found.
-*/
-function extractBoundary(contentType) {
-	const match = /boundary=("?)([^";,\s]+)\1/i.exec(contentType);
-	return match ? match[2] : null;
-}
-function indexOf(haystack, needle, from) {
-	outer: for (let i = from; i <= haystack.byteLength - needle.byteLength; i++) {
-		for (let j = 0; j < needle.byteLength; j++) if (haystack[i + j] !== needle[j]) continue outer;
-		return i;
-	}
-	return -1;
-}
-function startsWith(data, prefix) {
-	if (data.byteLength < prefix.byteLength) return false;
-	for (let i = 0; i < prefix.byteLength; i++) if (data[i] !== prefix[i]) return false;
-	return true;
-}
-//#endregion
 //#region src/transport-internal.ts
 function createProducerId() {
 	if (typeof globalThis.crypto?.randomUUID === "function") return globalThis.crypto.randomUUID();
@@ -335,30 +263,9 @@ var ProtocolError = class extends Error {
 		this.status = status;
 	}
 };
-function getHeader(headers, lowerCaseName, titleCaseName) {
-	return headers.get(lowerCaseName) ?? headers.get(titleCaseName);
-}
-function visibleHeaderNames(headers) {
-	const names = [];
-	headers.forEach((_value, name) => {
-		names.push(name);
-	});
-	if (names.length === 0) return "(none)";
-	names.sort();
-	return names.join(", ");
-}
-function missingRequiredHeaderError(context, requiredHeader, headers) {
-	return new ProtocolError(`${context} response missing ${requiredHeader}. If this is cross-origin, expose it via Access-Control-Expose-Headers (${requiredHeader.toLowerCase()}). Visible headers: ${visibleHeaderNames(headers)}`);
-}
 function isObject(value) {
 	return typeof value === "object" && value != null;
 }
-function parseHeaderU64(value) {
-	if (value == null) return null;
-	const parsed = Number.parseInt(value, 10);
-	if (!Number.isFinite(parsed) || parsed < 0) return null;
-	return parsed;
-}
 function decodeBase64Bytes(encoded) {
 	const normalized = encoded.replace(/[\r\n]/g, "");
 	if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(normalized, "base64"));
@@ -425,34 +332,15 @@ function isSseUnsupportedErrorText(message) {
 	const mentionsCompatibility = normalized.includes("unsupported") || normalized.includes("not support") || normalized.includes("incompatible") || normalized.includes("content type");
 	return mentionsSse && mentionsCompatibility;
 }
-function withCursorQuery(url, cursor) {
-	if (cursor == null || cursor.length === 0) return url;
-	const target = new URL(url);
-	target.searchParams.set("cursor", cursor);
-	return target.toString();
-}
-function bytesToArrayBuffer(bytes) {
-	return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-}
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function mergeAbortSignals(...signals) {
-	const active = signals.filter((signal) => signal != null);
-	if (active.length === 0) return;
-	if (active.length === 1) return active[0];
-	if (typeof AbortSignal.any === "function") return AbortSignal.any(active);
-	const controller = new AbortController();
-	for (const signal of active) {
-		if (signal.aborted) {
-			controller.abort(signal.reason);
-			break;
-		}
-		signal.addEventListener("abort", () => {
-			controller.abort(signal.reason);
+function sleep(ms, signal) {
+	if (signal?.aborted) return Promise.resolve();
+	return new Promise((resolve) => {
+		const timer = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timer);
+			resolve();
 		}, { once: true });
-	}
-	return controller.signal;
+	});
 }
 function classifyFetchError(err) {
 	const message = err instanceof Error ? err.message : String(err);
@@ -651,209 +539,143 @@ function resolveNextOffsetAfterConcurrentAdvance(requestOffset, currentOffset, r
 var StreamsTransportClient = class {
 	streamUrl;
 	adapter;
-	authProvider;
-	fetchImpl;
+	client;
 	reconnectConfig;
-	authRefreshInFlight;
 	constructor(options) {
 		this.streamUrl = options.streamUrl;
 		this.adapter = options.adapter;
-		this.authProvider = options.authProvider;
-		this.fetchImpl = options.fetchImpl;
+		this.client = new StreamsClient({
+			url: options.streamUrl,
+			auth: options.authProvider,
+			fetch: options.fetchImpl,
+			retry: { maxAttempts: 0 },
+			timeout: {
+				connectTimeoutMs: options.reconnectConfig.connectTimeoutMs,
+				pollTimeoutMs: options.reconnectConfig.pollTimeoutMs
+			}
+		});
 		this.reconnectConfig = options.reconnectConfig;
 	}
 	async createStreamRequest() {
 		const adapterHeaders = this.adapter.getCreateStreamHeaders ? await this.adapter.getCreateStreamHeaders() : void 0;
-		const response = await this.fetchAuthorized(this.streamUrl, {
-			method: "PUT",
-			headers: {
-				"Content-Type": BINARY_CONTENT_TYPE,
-				...adapterHeaders
-			}
-		}, this.reconnectConfig.connectTimeoutMs, "connect");
-		if (response.status === 200 || response.status === 201) return response.status === 201;
-		throw new HttpError(`create stream failed with status ${response.status}`, response.status);
+		const result = await this.client.create({ headers: adapterHeaders });
+		if (result.ok) return result.result.created;
+		throw this.toTransportFailure(result.result);
 	}
 	async deleteStreamRequest() {
-		const response = await this.fetchAuthorized(this.streamUrl, { method: "DELETE" }, this.reconnectConfig.connectTimeoutMs, "connect");
-		if (response.status === 200 || response.status === 204) return true;
-		if (response.status === 404) return false;
-		throw new HttpError(`delete stream failed with status ${response.status}`, response.status);
+		const result = await this.client.delete();
+		if (result.ok) return result.result.deleted;
+		throw this.toTransportFailure(result.result);
 	}
 	async readFromOffsetSseItems(offset, cursor, onControl, onOpen, signal) {
-		const query = new URLSearchParams({
-			offset,
-			live: "sse"
-		});
-		return this.readItemsSse(withCursorQuery(`${this.streamUrl}?${query.toString()}`, cursor), offset, onControl, onOpen, signal);
+		return this.readItemsSse(offset, cursor, onControl, onOpen, signal);
 	}
 	async readFromOffset(offset, cursor, live, signal) {
-		const query = new URLSearchParams({ offset });
-		if (live != null) query.set("live", live);
-		if (cursor != null && cursor.length > 0) query.set("cursor", cursor);
-		const timeoutMs = live === "long-poll" ? this.reconnectConfig.pollTimeoutMs : this.reconnectConfig.connectTimeoutMs;
-		const timeoutType = live === "long-poll" ? "poll" : "connect";
-		const response = await this.fetchAuthorized(`${this.streamUrl}?${query.toString()}`, {
-			method: "GET",
+		const result = await this.client.readOnce({
+			offset,
+			cursor,
+			live,
 			signal
-		}, timeoutMs, timeoutType);
-		if (response.status === 410) return { kind: "gone" };
-		if (!response.ok) throw new HttpError(`read failed with status ${response.status}`, response.status);
-		const nextOffset = getHeader(response.headers, "stream-next-offset", "Stream-Next-Offset");
-		if (nextOffset == null) throw missingRequiredHeaderError("read", "Stream-Next-Offset", response.headers);
-		const upToDate = getHeader(response.headers, "stream-up-to-date", "Stream-Up-To-Date") === "true";
-		const streamCursor = getHeader(response.headers, "stream-cursor", "Stream-Cursor") ?? void 0;
-		const body = new Uint8Array(await response.arrayBuffer());
+		});
+		if (!result.ok) {
+			if (result.result.code === "gone") return { kind: "gone" };
+			throw this.toTransportFailure(result.result);
+		}
+		const payload = result.result.payload?.body ?? new Uint8Array();
 		return {
 			kind: "ok",
 			value: {
-				nextOffset,
-				upToDate,
-				updates: body.byteLength === 0 ? [] : decodeItems(body),
-				streamCursor
+				nextOffset: result.result.nextOffset,
+				upToDate: result.result.upToDate,
+				updates: payload.byteLength === 0 ? [] : decodeItems(payload),
+				streamCursor: result.result.cursor
 			}
 		};
 	}
 	async bootstrap() {
-		const response = await this.fetchAuthorized(`${this.streamUrl}/bootstrap`, { method: "GET" }, this.reconnectConfig.connectTimeoutMs, "connect");
-		if (!response.ok) throw new HttpError(`bootstrap failed with status ${response.status}`, response.status);
-		const nextOffset = getHeader(response.headers, "stream-next-offset", "Stream-Next-Offset");
-		if (nextOffset == null) throw missingRequiredHeaderError("bootstrap", "Stream-Next-Offset", response.headers);
-		const upToDate = getHeader(response.headers, "stream-up-to-date", "Stream-Up-To-Date") === "true";
-		const streamCursor = getHeader(response.headers, "stream-cursor", "Stream-Cursor") ?? void 0;
-		const body = new Uint8Array(await response.arrayBuffer());
-		const boundary = extractBoundary(response.headers.get("Content-Type") ?? "");
-		if (boundary != null && body.byteLength > 0) {
-			const parts = decodeMultipartMixed(boundary, body);
-			return {
-				nextOffset,
-				upToDate,
-				snapshot: parts.length > 0 ? parts[0].body : new Uint8Array(),
-				updates: parts.slice(1).flatMap((part) => decodeMultipartPartItems(part.body)),
-				streamCursor
-			};
-		}
-		if (body.byteLength > 0) throw new ProtocolError("bootstrap returned a non-multipart body");
+		const result = await this.client.bootstrap();
+		if (!result.ok) throw this.toTransportFailure(result.result);
 		return {
-			nextOffset,
-			upToDate,
-			snapshot: new Uint8Array(),
-			updates: [],
-			streamCursor
+			nextOffset: result.result.nextOffset,
+			upToDate: result.result.upToDate,
+			snapshot: result.result.snapshot?.body ?? new Uint8Array(),
+			updates: result.result.updates.flatMap((part) => decodeMultipartPartItems(part.body)),
+			streamCursor: result.result.cursor
 		};
 	}
 	async readSnapshotOffsetValue() {
-		const response = await this.fetchAuthorized(this.streamUrl, { method: "HEAD" }, this.reconnectConfig.connectTimeoutMs, "connect");
-		if (response.status === 404) return null;
-		if (!response.ok) throw new HttpError(`head snapshot offset failed with status ${response.status}`, response.status);
-		const snapshotOffset = getHeader(response.headers, "stream-snapshot-offset", "Stream-Snapshot-Offset");
+		const result = await this.client.head();
+		if (!result.ok) {
+			if (result.result.code === "not_found") return null;
+			throw this.toTransportFailure(result.result);
+		}
+		const snapshotOffset = result.result.snapshotOffset;
 		return snapshotOffset == null || snapshotOffset.length === 0 ? null : snapshotOffset;
 	}
 	async putSnapshotAt(snapshotOffset, snapshot) {
-		const response = await this.fetchAuthorized(`${this.streamUrl}/snapshot/${encodeURIComponent(snapshotOffset)}`, {
-			method: "PUT",
-			headers: { "Content-Type": "application/octet-stream" },
-			body: bytesToArrayBuffer(snapshot)
-		}, this.reconnectConfig.connectTimeoutMs, "connect");
-		if (response.status === 200 || response.status === 204) return;
-		throw new HttpError(`snapshot upload failed with status ${response.status}`, response.status);
+		const result = await this.client.putSnapshot({
+			offset: snapshotOffset,
+			part: {
+				contentType: "application/octet-stream",
+				body: snapshot
+			}
+		});
+		if (!result.ok) throw this.toTransportFailure(result.result);
 	}
 	async appendUpdates(updates, producerSession) {
-		const response = await this.fetchAuthorized(this.streamUrl, {
-			method: "POST",
-			headers: {
-				"Content-Type": BINARY_CONTENT_TYPE,
-				"Producer-Id": producerSession.producerId,
-				"Producer-Epoch": producerSession.producerEpoch.toString(),
-				"Producer-Seq": producerSession.nextProducerSeq.toString()
+		const result = await this.client.append({
+			part: {
+				contentType: BINARY_CONTENT_TYPE,
+				body: encodeItems(updates)
 			},
-			body: bytesToArrayBuffer(encodeItems(updates))
-		}, this.reconnectConfig.connectTimeoutMs, "connect", { shouldRetryAuthFailure: (response) => response.status === 401 || response.status === 403 && parseHeaderU64(getHeader(response.headers, "producer-epoch", "Producer-Epoch")) == null });
-		if (response.status === 200 || response.status === 204) {
-			const nextOffset = getHeader(response.headers, "stream-next-offset", "Stream-Next-Offset");
-			if (nextOffset == null) throw missingRequiredHeaderError("append", "Stream-Next-Offset", response.headers);
-			return {
-				kind: "ok",
-				ackEpoch: parseHeaderU64(getHeader(response.headers, "producer-epoch", "Producer-Epoch")) ?? producerSession.producerEpoch,
-				ackSeq: parseHeaderU64(getHeader(response.headers, "producer-seq", "Producer-Seq")) ?? producerSession.nextProducerSeq,
-				nextOffset
-			};
-		}
-		if (response.status === 403) {
-			const serverEpoch = parseHeaderU64(getHeader(response.headers, "producer-epoch", "Producer-Epoch"));
-			if (serverEpoch != null) return {
-				kind: "stale-epoch",
-				serverEpoch
-			};
-		}
-		if (response.status === 409) {
-			const expectedSeq = parseHeaderU64(getHeader(response.headers, "producer-expected-seq", "Producer-Expected-Seq"));
-			if (expectedSeq != null) return {
-				kind: "seq-gap",
-				expectedSeq
-			};
-		}
-		throw new HttpError(`append failed with status ${response.status}`, response.status);
-	}
-	async resolveToken(context) {
-		if (this.authProvider == null) return;
-		return await this.authProvider(context);
-	}
-	async refreshTokenAfterAuthFailure(status, previousToken) {
-		if (this.authProvider == null) return;
-		if (this.authRefreshInFlight == null) this.authRefreshInFlight = this.resolveToken({
-			reason: "unauthorized",
-			status,
-			previousToken
-		}).finally(() => {
-			this.authRefreshInFlight = void 0;
+			producer: {
+				producerId: producerSession.producerId,
+				epoch: producerSession.producerEpoch,
+				seq: producerSession.nextProducerSeq
+			}
 		});
-		return await this.authRefreshInFlight;
-	}
-	async fetchAuthorized(input, init, timeoutMs, timeoutType, options) {
-		const firstToken = await this.resolveToken({ reason: "request" });
-		const firstResponse = await this.fetchWithTimeout(input, {
-			...init,
-			headers: this.attachAuthorizationHeader(init.headers, firstToken)
-		}, timeoutMs, timeoutType);
-		const shouldRetryAuthFailure = options?.shouldRetryAuthFailure ?? ((response) => response.status === 401 || response.status === 403);
-		if (this.authProvider == null || !shouldRetryAuthFailure(firstResponse)) return firstResponse;
-		const refreshedToken = await this.refreshTokenAfterAuthFailure(firstResponse.status, firstToken);
-		return await this.fetchWithTimeout(input, {
-			...init,
-			headers: this.attachAuthorizationHeader(init.headers, refreshedToken)
-		}, timeoutMs, timeoutType);
-	}
-	attachAuthorizationHeader(base, token) {
-		const headers = new Headers(base);
-		if (token == null || token.length === 0) {
-			headers.delete("Authorization");
-			return headers;
-		}
-		headers.set("Authorization", `Bearer ${token}`);
-		return headers;
-	}
-	async fetchWithTimeout(input, init, timeoutMs, timeoutType) {
-		if (!(timeoutMs > 0)) return this.fetchImpl(input, init);
-		const controller = new AbortController();
-		const signal = mergeAbortSignals(init.signal, controller.signal);
-		const timer = setTimeout(() => {
-			controller.abort(new TimeoutError(timeoutType, timeoutMs));
-		}, timeoutMs);
-		try {
-			return await this.fetchImpl(input, {
-				...init,
-				signal
-			});
-		} catch (error) {
-			if (controller.signal.aborted && controller.signal.reason instanceof TimeoutError) throw controller.signal.reason;
-			throw error;
-		} finally {
-			clearTimeout(timer);
+		if (result.ok) return {
+			kind: "ok",
+			ackEpoch: result.result.producer?.epoch ?? producerSession.producerEpoch,
+			ackSeq: result.result.producer?.seq ?? producerSession.nextProducerSeq,
+			nextOffset: result.result.nextOffset
+		};
+		const error = result.result;
+		if (error.code === "conflict" && error.detail?.kind === "producer_seq_gap") return {
+			kind: "seq-gap",
+			expectedSeq: error.detail.expectedSeq
+		};
+		if (error.code === "forbidden" && error.detail?.kind === "stale_producer_epoch") return {
+			kind: "stale-epoch",
+			serverEpoch: error.detail.serverEpoch
+		};
+		throw this.toTransportFailure(error);
+	}
+	toTransportFailure(error) {
+		switch (error.code) {
+			case "bad_request":
+			case "unauthorized":
+			case "forbidden":
+			case "not_found":
+			case "conflict":
+			case "gone":
+			case "rate_limited": return new HttpError(error.message, error.status);
+			case "timeout": return new TimeoutError(error.phase, error.phase === "poll" ? this.reconnectConfig.pollTimeoutMs : this.reconnectConfig.connectTimeoutMs);
+			case "network_error": return error.cause instanceof TypeError ? error.cause : new TypeError(error.message);
+			case "protocol_error": return new ProtocolError(error.message, error.status);
+			case "unknown":
+				if (typeof error.status === "number") return new HttpError(error.message, error.status);
+				if (error.cause instanceof TypeError) return error.cause;
+				if (error.cause instanceof Error) return error.cause;
+				return new Error(error.message);
+			default: {
+				const exhaustive = error;
+				return new Error(String(exhaustive));
+			}
 		}
 	}
-	async readItemsSse(url, initialOffset, onControl, onOpen, signal) {
-		const opened = await this.openItemsSseSession(url, initialOffset, onOpen, signal);
+	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();
@@ -863,41 +685,23 @@ var StreamsTransportClient = class {
 			latestCursor: result.latestCursor
 		};
 	}
-	async openItemsSseSession(url, initialOffset, onOpen, signal) {
-		const response = await this.fetchAuthorized(url, {
-			method: "GET",
+	async openItemsSseSession(initialOffset, cursor, onOpen, signal) {
+		const result = await this.client.openSseSession({
+			offset: initialOffset,
+			cursor,
 			signal
-		}, this.reconnectConfig.connectTimeoutMs, "connect");
-		if (response.status === 410) return { kind: "gone" };
-		if (response.status === 404) return { kind: "not-found" };
-		if (response.status === 400) {
-			const errorText = await response.text();
-			if (isSseUnsupportedErrorText(errorText)) return { kind: "unsupported" };
-			throw new HttpError(errorText.length > 0 ? `sse read failed with status 400: ${errorText}` : "sse read failed with status 400", response.status);
+		});
+		if (!result.ok) {
+			if (result.result.code === "gone") return { kind: "gone" };
+			if (result.result.code === "not_found") return { kind: "not-found" };
+			if (result.result.code === "bad_request" && isSseUnsupportedErrorText(result.result.message)) return { kind: "unsupported" };
+			throw this.toTransportFailure(result.result);
 		}
-		if (!response.ok) throw new HttpError(`sse read failed with status ${response.status}`, response.status);
-		if (!(response.headers.get("Content-Type") ?? "").toLowerCase().includes("text/event-stream")) throw new ProtocolError("sse read response must use text/event-stream");
-		const sseDataEncoding = response.headers.get("stream-sse-data-encoding");
+		const session = result.result;
 		onOpen?.();
-		if (response.body == null) return {
-			kind: "ok",
-			session: {
-				continue: async () => ({
-					kind: "ok",
-					latestOffset: initialOffset,
-					paused: false
-				}),
-				cancel: async () => {}
-			}
-		};
-		const reader = response.body.getReader();
-		const decoder = new TextDecoder();
-		let pendingText = "";
-		let currentEvent = "";
-		let dataLines = [];
 		let pendingDataEvents = [];
-		let latestOffset = initialOffset;
-		let latestCursor;
+		let latestOffset = session.nextOffset ?? initialOffset;
+		let latestCursor = session.cursor;
 		let exhausted = false;
 		return {
 			kind: "ok",
@@ -909,96 +713,48 @@ var StreamsTransportClient = class {
 						latestCursor,
 						paused: false
 					};
-					let stopRequested = false;
-					let pauseRequested = false;
-					const processEvent = async () => {
-						if (dataLines.length === 0) {
-							currentEvent = "";
-							return;
-						}
-						const eventType = currentEvent.length === 0 ? "message" : currentEvent;
-						const data = dataLines.join("\n");
-						currentEvent = "";
-						dataLines = [];
-						if (eventType === "data") {
-							pendingDataEvents.push(data);
-							return;
+					for await (const event of session.events) {
+						if (event.event === "data") {
+							pendingDataEvents.push(event.data);
+							continue;
 						}
-						if (eventType !== "control") return;
-						const control = parseSseControlData(data);
+						if (event.event !== "control") continue;
+						const control = parseSseControlData(event.data);
 						const updates = [];
-						for (const eventData of pendingDataEvents) for (const payload of decodeSseItemPayloads(eventData, sseDataEncoding)) updates.push(payload);
+						for (const eventData of pendingDataEvents) updates.push(...decodeSseItemPayloads(eventData, session.dataEncoding));
 						pendingDataEvents = [];
 						const handlerResult = await nextOnControl(updates, control.nextOffset, control.upToDate, control.streamCursor);
 						latestOffset = control.nextOffset;
 						if (control.streamCursor != null) latestCursor = control.streamCursor;
 						if (handlerResult === "stop") {
-							stopRequested = true;
 							exhausted = true;
-							try {
-								await reader.cancel();
-							} catch {}
-							return;
+							await session.cancel();
+							return {
+								kind: "ok",
+								latestOffset,
+								latestCursor,
+								paused: false
+							};
 						}
-						if (handlerResult === "pause") pauseRequested = true;
-					};
-					while (true) {
-						if (stopRequested || pauseRequested) return {
+						if (handlerResult === "pause") return {
 							kind: "ok",
 							latestOffset,
 							latestCursor,
-							paused: pauseRequested
-						};
-						const { done, value } = await reader.read();
-						if (value != null) {
-							pendingText += decoder.decode(value, { stream: true });
-							while (true) {
-								const newline = pendingText.indexOf("\n");
-								if (newline < 0) break;
-								const rawLine = pendingText.slice(0, newline);
-								pendingText = pendingText.slice(newline + 1);
-								const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
-								if (line.length === 0) {
-									await processEvent();
-									if (stopRequested || pauseRequested) break;
-									continue;
-								}
-								if (line.startsWith(":")) continue;
-								if (line.startsWith("event:")) {
-									currentEvent = line.slice(6).trim();
-									continue;
-								}
-								if (line.startsWith("data:")) dataLines.push(line.slice(5).replace(/^ /, ""));
-							}
-						}
-						if (stopRequested || pauseRequested) return {
-							kind: "ok",
-							latestOffset,
-							latestCursor,
-							paused: pauseRequested
-						};
-						if (!done) continue;
-						exhausted = true;
-						pendingText += decoder.decode();
-						if (pendingText.length > 0) {
-							const line = pendingText.endsWith("\r") ? pendingText.slice(0, -1) : pendingText;
-							if (line.length > 0 && line.startsWith("data:")) dataLines.push(line.slice(5).replace(/^ /, ""));
-						}
-						await processEvent();
-						return {
-							kind: "ok",
-							latestOffset,
-							latestCursor,
-							paused: pauseRequested
+							paused: true
 						};
 					}
+					exhausted = true;
+					return {
+						kind: "ok",
+						latestOffset,
+						latestCursor,
+						paused: false
+					};
 				},
 				cancel: async () => {
 					if (exhausted) return;
 					exhausted = true;
-					try {
-						await reader.cancel();
-					} catch {}
+					await session.cancel();
 				}
 			}
 		};
@@ -1319,6 +1075,7 @@ function createJoinState(cursor, liveMode = "sse") {
 		pendingLocal: new Deque(),
 		flushingLocal: false,
 		retryAttempt: 0,
+		retrySleepController: new AbortController(),
 		cursor,
 		liveMode,
 		snapshot: createTransportSnapshotState(),
@@ -1407,6 +1164,27 @@ var StreamsCrdt = class StreamsCrdt {
 		if (state != null) await this.disposeJoinState(state);
 	}
 	/**
+	* 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.
+	*
+	* If the room reached `"disconnected"` status (only possible with a finite
+	* `maxAttempts` config), this restarts the read loop.
+	*/
+	rejoin() {
+		const state = this.joinState;
+		if (state == null || state.closed || state.status === "joined") return;
+		const wasDisconnected = state.status === "disconnected";
+		state.retryAttempt = 0;
+		state.retrySleepController.abort();
+		state.retrySleepController = new AbortController();
+		if (wasDisconnected) {
+			this.setJoinStatus(state, "reconnecting");
+			this.runReadLoop(state);
+		}
+	}
+	/**
 	* Reads the latest remote snapshot offset, if the server exposes one.
 	*/
 	async getSnapshotOffset() {
@@ -1827,7 +1605,7 @@ var StreamsCrdt = class StreamsCrdt {
 			}
 			const delay = computeRetryDelay(state.retryAttempt, this.reconnectConfig);
 			state.retryAttempt += 1;
-			await sleep(delay);
+			await sleep(delay, state.retrySleepController.signal);
 		}
 	}
 	/** Maximum encoded size (bytes) for a single batched append. */
@@ -1899,7 +1677,7 @@ var StreamsCrdt = class StreamsCrdt {
 					this.setJoinStatus(state, "reconnecting");
 					const delay = computeRetryDelay(attempts, this.reconnectConfig);
 					attempts += 1;
-					await sleep(delay);
+					await sleep(delay, state.retrySleepController.signal);
 				}
 			}
 		} finally {
@@ -2001,4 +1779,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-kM9JM1F7.js.map
+//# sourceMappingURL=stream-id-BS_IJr-Y.js.map