@loro-dev/streams-crdt 0.1.2 → 0.2.1

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

@@ -360,24 +360,28 @@ function parseHeaderU64(value) {
 	return parsed;
 }
 function decodeBase64Bytes(encoded) {
-	if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(encoded, "base64"));
+	const normalized = encoded.replace(/[\r\n]/g, "");
+	if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(normalized, "base64"));
 	if (typeof atob === "function") {
-		const binary = atob(encoded);
+		const binary = atob(normalized);
 		const out = new Uint8Array(binary.length);
 		for (let i = 0; i < binary.length; i += 1) out[i] = binary.charCodeAt(i);
 		return out;
 	}
 	throw new Error("base64 decoding is unavailable");
 }
-function decodeSseRawPayload(data) {
-	try {
-		const parsed = JSON.parse(data);
-		if (isObject(parsed) && parsed.encoding === "base64" && typeof parsed.payload === "string") return decodeBase64Bytes(parsed.payload);
-	} catch {}
+function normalizeSseDataEncoding(dataEncoding) {
+	const normalized = dataEncoding?.trim().toLowerCase();
+	if (normalized == null || normalized.length === 0) return;
+	if (normalized === "base64") return "base64";
+	throw new ProtocolError(`unsupported stream-sse-data-encoding '${dataEncoding}'`);
+}
+function decodeSseRawPayload(data, dataEncoding) {
+	if (dataEncoding === "base64") return decodeBase64Bytes(data);
 	return new TextEncoder().encode(data);
 }
-function decodeSseItemPayloads(data) {
-	const payload = decodeSseRawPayload(data);
+function decodeSseItemPayloads(data, dataEncoding) {
+	const payload = decodeSseRawPayload(data, normalizeSseDataEncoding(dataEncoding));
 	if (payload.byteLength === 0) return [payload];
 	try {
 		return decodeItems(payload);
@@ -571,8 +575,8 @@ function normalizeAuthProvider(auth) {
 		const token = auth.trim();
 		return async () => token.length === 0 ? void 0 : token;
 	}
-	return async () => {
-		const token = (await auth())?.trim() ?? "";
+	return async (context) => {
+		const token = (await auth(context))?.trim() ?? "";
 		return token.length === 0 ? void 0 : token;
 	};
 }
@@ -650,6 +654,7 @@ var StreamsTransportClient = class {
 	authProvider;
 	fetchImpl;
 	reconnectConfig;
+	authRefreshInFlight;
 	constructor(options) {
 		this.streamUrl = options.streamUrl;
 		this.adapter = options.adapter;
@@ -659,21 +664,18 @@ var StreamsTransportClient = class {
 	}
 	async createStreamRequest() {
 		const adapterHeaders = this.adapter.getCreateStreamHeaders ? await this.adapter.getCreateStreamHeaders() : void 0;
-		const response = await this.fetchWithTimeout(this.streamUrl, {
+		const response = await this.fetchAuthorized(this.streamUrl, {
 			method: "PUT",
-			headers: await this.resolveHeaders({
+			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);
 	}
 	async deleteStreamRequest() {
-		const response = await this.fetchWithTimeout(this.streamUrl, {
-			method: "DELETE",
-			headers: await this.resolveHeaders()
-		}, this.reconnectConfig.connectTimeoutMs, "connect");
+		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);
@@ -685,49 +687,14 @@ var StreamsTransportClient = class {
 		});
 		return this.readItemsSse(withCursorQuery(`${this.streamUrl}?${query.toString()}`, cursor), offset, onControl, onOpen, signal);
 	}
-	async openBootstrapSseSession(signal) {
-		const query = new URLSearchParams({ live: "sse" });
-		return await this.openItemsSseSession(`${this.streamUrl}/bootstrap?${query.toString()}`, "-1", void 0, signal);
-	}
-	async readBootstrapLongPoll(cursor, signal) {
-		const query = new URLSearchParams({ live: "long-poll" });
-		if (cursor != null && cursor.length > 0) query.set("cursor", cursor);
-		const response = await this.fetchWithTimeout(`${this.streamUrl}/bootstrap?${query.toString()}`, {
-			method: "GET",
-			headers: await this.resolveHeaders(),
-			signal
-		}, this.reconnectConfig.pollTimeoutMs, "poll");
-		if (response.status === 410) return { kind: "gone" };
-		if (!response.ok) throw new HttpError(`bootstrap long-poll 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") ?? "");
-		let items;
-		if (boundary != null && body.byteLength > 0) items = decodeMultipartMixed(boundary, body).flatMap((part) => decodeMultipartPartItems(part.body));
-		else if (body.byteLength === 0) items = [];
-		else throw new ProtocolError("bootstrap long-poll returned a non-multipart body");
-		return {
-			kind: "ok",
-			value: {
-				nextOffset,
-				upToDate,
-				items,
-				streamCursor
-			}
-		};
-	}
 	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.fetchWithTimeout(`${this.streamUrl}?${query.toString()}`, {
+		const response = await this.fetchAuthorized(`${this.streamUrl}?${query.toString()}`, {
 			method: "GET",
-			headers: await this.resolveHeaders(),
 			signal
 		}, timeoutMs, timeoutType);
 		if (response.status === 410) return { kind: "gone" };
@@ -748,10 +715,7 @@ var StreamsTransportClient = class {
 		};
 	}
 	async bootstrap() {
-		const response = await this.fetchWithTimeout(`${this.streamUrl}/bootstrap`, {
-			method: "GET",
-			headers: await this.resolveHeaders()
-		}, this.reconnectConfig.connectTimeoutMs, "connect");
+		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);
@@ -779,35 +743,32 @@ var StreamsTransportClient = class {
 		};
 	}
 	async readSnapshotOffsetValue() {
-		const response = await this.fetchWithTimeout(this.streamUrl, {
-			method: "HEAD",
-			headers: await this.resolveHeaders()
-		}, this.reconnectConfig.connectTimeoutMs, "connect");
+		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");
 		return snapshotOffset == null || snapshotOffset.length === 0 ? null : snapshotOffset;
 	}
 	async putSnapshotAt(snapshotOffset, snapshot) {
-		const response = await this.fetchWithTimeout(`${this.streamUrl}/snapshot/${encodeURIComponent(snapshotOffset)}`, {
+		const response = await this.fetchAuthorized(`${this.streamUrl}/snapshot/${encodeURIComponent(snapshotOffset)}`, {
 			method: "PUT",
-			headers: await this.resolveHeaders({ "Content-Type": "application/octet-stream" }),
+			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);
 	}
 	async appendUpdates(updates, producerSession) {
-		const response = await this.fetchWithTimeout(this.streamUrl, {
+		const response = await this.fetchAuthorized(this.streamUrl, {
 			method: "POST",
-			headers: await this.resolveHeaders({
+			headers: {
 				"Content-Type": BINARY_CONTENT_TYPE,
 				"Producer-Id": producerSession.producerId,
 				"Producer-Epoch": producerSession.producerEpoch.toString(),
 				"Producer-Seq": producerSession.nextProducerSeq.toString()
-			}),
+			},
 			body: bytesToArrayBuffer(encodeItems(updates))
-		}, this.reconnectConfig.connectTimeoutMs, "connect");
+		}, 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);
@@ -834,10 +795,42 @@ var StreamsTransportClient = class {
 		}
 		throw new HttpError(`append failed with status ${response.status}`, response.status);
 	}
-	async resolveHeaders(extra) {
-		const headers = new Headers(extra);
-		const token = this.authProvider == null ? void 0 : await this.authProvider();
-		if (token != null && token.length > 0) headers.set("Authorization", `Bearer ${token}`);
+	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;
+		});
+		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) {
@@ -871,9 +864,8 @@ var StreamsTransportClient = class {
 		};
 	}
 	async openItemsSseSession(url, initialOffset, onOpen, signal) {
-		const response = await this.fetchWithTimeout(url, {
+		const response = await this.fetchAuthorized(url, {
 			method: "GET",
-			headers: await this.resolveHeaders(),
 			signal
 		}, this.reconnectConfig.connectTimeoutMs, "connect");
 		if (response.status === 410) return { kind: "gone" };
@@ -885,6 +877,7 @@ var StreamsTransportClient = class {
 		}
 		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");
 		onOpen?.();
 		if (response.body == null) return {
 			kind: "ok",
@@ -934,7 +927,7 @@ var StreamsTransportClient = class {
 						if (eventType !== "control") return;
 						const control = parseSseControlData(data);
 						const updates = [];
-						for (const eventData of pendingDataEvents) for (const payload of decodeSseItemPayloads(eventData)) updates.push(payload);
+						for (const eventData of pendingDataEvents) for (const payload of decodeSseItemPayloads(eventData, sseDataEncoding)) updates.push(payload);
 						pendingDataEvents = [];
 						const handlerResult = await nextOnControl(updates, control.nextOffset, control.upToDate, control.streamCursor);
 						latestOffset = control.nextOffset;
@@ -1335,8 +1328,6 @@ function createJoinState(cursor, liveMode = "sse") {
 async function disposeJoinState(state, options) {
 	state.closed = true;
 	options.snapshotManager.dispose(state);
-	const liveSseSession = state.liveSseSession;
-	state.liveSseSession = void 0;
 	const requestController = state.requestController;
 	state.requestController = void 0;
 	const unsubscribeLocal = state.unsubscribeLocal;
@@ -1344,7 +1335,6 @@ async function disposeJoinState(state, options) {
 	requestController?.abort();
 	unsubscribeLocal?.();
 	options.onDisposed?.();
-	await liveSseSession?.cancel();
 }
 //#endregion
 //#region src/transport-runtime.ts
@@ -1568,11 +1558,10 @@ var StreamsCrdt = class StreamsCrdt {
 	async startJoin(state) {
 		try {
 			state.requestController ??= new AbortController();
-			const joined = await this.performInitialJoinSync(state.liveMode, state.requestController.signal);
+			const joined = await this.performInitialJoinSync(state.liveMode);
 			state.cursor = joined.cursor;
 			state.streamCursor = joined.streamCursor;
 			state.liveMode = joined.liveMode;
-			state.liveSseSession = joined.liveSseSession;
 			const pendingLocal = this.exportUpdates(joined.localExportRefVersion);
 			const hasQueuedPreSubscribeBatch = pendingLocal.batch != null;
 			if (pendingLocal.batch != null) state.pendingLocal.pushBack(pendingLocal.batch);
@@ -1622,7 +1611,7 @@ var StreamsCrdt = class StreamsCrdt {
 		}
 		return cursor;
 	}
-	async performInitialJoinSync(preferredLiveMode, signal) {
+	async performInitialJoinSync(preferredLiveMode) {
 		const loaded = await this.remoteCursorStore.load(this.streamUrl);
 		let cursor = loaded ?? createInitialRemoteCursor({
 			streamUrl: this.streamUrl,
@@ -1632,15 +1621,9 @@ var StreamsCrdt = class StreamsCrdt {
 		let localExportRefVersion = cursor.serverLowerBoundVersion;
 		let streamCursor;
 		let liveMode = preferredLiveMode;
-		let liveSseSession;
 		try {
-			if (loaded == null) {
-				const joined = await this.bootstrapIntoJoinedState(cursor, liveMode, signal);
-				cursor = joined.cursor;
-				streamCursor = joined.streamCursor;
-				liveMode = joined.liveMode;
-				liveSseSession = joined.liveSseSession;
-			} else {
+			if (loaded == null) cursor = await this.bootstrapIntoState(cursor);
+			else {
 				const caughtUp = await this.catchup(cursor);
 				cursor = caughtUp.cursor;
 				streamCursor = caughtUp.streamCursor;
@@ -1648,38 +1631,26 @@ var StreamsCrdt = class StreamsCrdt {
 		} catch (error) {
 			if (!isStreamNotFoundError(error) || !this.createStreamIfMissing) throw error;
 			await this.createStreamRequest();
-			const joined = await this.bootstrapIntoJoinedState({
+			cursor = await this.bootstrapIntoState({
 				...cursor,
 				nextOffset: "-1",
 				serverLowerBoundVersion: this.adapter.emptyVersion()
-			}, liveMode, signal);
-			cursor = joined.cursor;
-			streamCursor = joined.streamCursor;
-			liveMode = joined.liveMode;
-			liveSseSession = joined.liveSseSession;
+			});
 		}
 		localExportRefVersion = cursor.serverLowerBoundVersion;
 		const exportedLocal = this.exportUpdates(localExportRefVersion);
 		localExportRefVersion = exportedLocal.nextRefVersion;
 		if (exportedLocal.batch != null) {
 			cursor = await this.appendLocalBatch(cursor, exportedLocal.batch);
-			if (liveSseSession != null) {
-				const continued = await this.continueJoinedSseSessionUntilCaughtUp(liveSseSession, cursor);
-				cursor = continued.cursor;
-				streamCursor = continued.streamCursor;
-				liveSseSession = continued.liveSseSession;
-			} else {
-				const caughtUp = await this.catchup(cursor);
-				cursor = caughtUp.cursor;
-				streamCursor = caughtUp.streamCursor;
-			}
+			const caughtUp = await this.catchup(cursor);
+			cursor = caughtUp.cursor;
+			streamCursor = caughtUp.streamCursor;
 		}
 		localExportRefVersion = cursor.serverLowerBoundVersion;
 		return {
 			cursor,
 			streamCursor,
 			liveMode,
-			liveSseSession,
 			localExportRefVersion
 		};
 	}
@@ -1689,111 +1660,6 @@ var StreamsCrdt = class StreamsCrdt {
 		if (!result.upToDate) return (await this.catchup(saved)).cursor;
 		return saved;
 	}
-	async bootstrapIntoJoinedState(cursor, preferredLiveMode, signal) {
-		if (preferredLiveMode === "sse") {
-			const sseResult = await this.bootstrapIntoJoinedStateViaSse(cursor, signal);
-			if (sseResult.kind === "ok") return {
-				...sseResult,
-				liveMode: "sse"
-			};
-		}
-		return {
-			...await this.bootstrapIntoJoinedStateViaLongPoll(cursor),
-			liveMode: "long-poll"
-		};
-	}
-	async bootstrapIntoJoinedStateViaSse(cursor, signal) {
-		let current = cursor;
-		let currentStreamCursor;
-		let expectBootstrapFrame = true;
-		let caughtUp = false;
-		const opened = await this.openBootstrapSseSession(this.streamUrl, signal);
-		if (opened.kind === "unsupported") return { kind: "unsupported" };
-		if (opened.kind === "not-found") throw new HttpError("bootstrap live sse failed with status 404", 404);
-		if (opened.kind === "gone") return {
-			kind: "ok",
-			cursor: await this.bootstrapIntoState({
-				...current,
-				nextOffset: "-1",
-				serverLowerBoundVersion: this.adapter.emptyVersion()
-			})
-		};
-		const result = await opened.session.continue(async (items, nextOffset, upToDate, streamCursor) => {
-			if (expectBootstrapFrame) {
-				current = await this.applyBootstrapItems(current, items, nextOffset);
-				expectBootstrapFrame = false;
-			} else current = await this.applyRemoteItems(current, items, nextOffset);
-			if (streamCursor != null) currentStreamCursor = streamCursor;
-			if (upToDate) {
-				caughtUp = true;
-				return "pause";
-			}
-		});
-		if (!caughtUp || !result.paused) {
-			const resumed = await this.catchup(current, void 0, currentStreamCursor);
-			await opened.session.cancel();
-			return {
-				kind: "ok",
-				cursor: resumed.cursor,
-				streamCursor: resumed.streamCursor
-			};
-		}
-		return {
-			kind: "ok",
-			cursor: current,
-			streamCursor: currentStreamCursor,
-			liveSseSession: opened.session
-		};
-	}
-	async continueJoinedSseSessionUntilCaughtUp(session, cursor) {
-		let current = cursor;
-		let currentStreamCursor;
-		let caughtUp = false;
-		const result = await session.continue(async (items, nextOffset, upToDate, streamCursor) => {
-			current = await this.applyRemoteItems(current, items, nextOffset);
-			if (streamCursor != null) currentStreamCursor = streamCursor;
-			if (upToDate) {
-				caughtUp = true;
-				return "pause";
-			}
-		});
-		if (!caughtUp || !result.paused) {
-			const resumed = await this.catchup(current, void 0, currentStreamCursor);
-			await session.cancel();
-			return {
-				cursor: resumed.cursor,
-				streamCursor: resumed.streamCursor
-			};
-		}
-		return {
-			cursor: current,
-			streamCursor: currentStreamCursor,
-			liveSseSession: session
-		};
-	}
-	async bootstrapIntoJoinedStateViaLongPoll(cursor) {
-		let current = cursor;
-		let currentStreamCursor;
-		let expectBootstrapFrame = true;
-		while (true) {
-			const response = await this.readBootstrapLongPoll(this.streamUrl, currentStreamCursor);
-			if (response.kind === "gone") return { cursor: await this.bootstrapIntoState({
-				...current,
-				nextOffset: "-1",
-				serverLowerBoundVersion: this.adapter.emptyVersion()
-			}) };
-			const result = response.value;
-			if (expectBootstrapFrame) {
-				current = await this.applyBootstrapItems(current, result.items, result.nextOffset);
-				expectBootstrapFrame = false;
-			} else current = await this.applyRemoteItems(current, result.items, result.nextOffset);
-			currentStreamCursor = result.streamCursor;
-			if (result.upToDate) return {
-				cursor: current,
-				streamCursor: currentStreamCursor
-			};
-		}
-	}
 	async catchup(cursor, live, streamCursor, onRemoteVersionApplied) {
 		let current = cursor;
 		let currentStreamCursor = streamCursor;
@@ -1895,29 +1761,6 @@ var StreamsCrdt = class StreamsCrdt {
 				await sleep(0);
 				continue;
 			}
-			if (state.liveSseSession != null) {
-				const session = state.liveSseSession;
-				const sseRequestOffset = state.cursor.nextOffset;
-				const sseResult = await session.continue(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);
-						});
-						if (streamCursor != null) state.streamCursor = streamCursor;
-					});
-					this.setJoinStatus(state, "joined");
-				});
-				if (state.closed) return;
-				state.liveSseSession = void 0;
-				state.retryAttempt = 0;
-				state.streamCursor = sseResult.latestCursor;
-				await sleep(0);
-				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 () => {
@@ -1963,9 +1806,6 @@ var StreamsCrdt = class StreamsCrdt {
 			state.retryAttempt = 0;
 		} catch (error) {
 			if (state.closed) return;
-			const liveSseSession = state.liveSseSession;
-			state.liveSseSession = void 0;
-			await liveSseSession?.cancel();
 			const classified = classifyFetchError(error);
 			if (!classified.retriable || isAuthOrProtocolError(error)) {
 				this.logError("live read failed", error, {
@@ -2088,12 +1928,6 @@ var StreamsCrdt = class StreamsCrdt {
 	async readFromOffsetSseItems(_streamUrl, offset, cursor, onControl, onOpen, signal) {
 		return await this.client.readFromOffsetSseItems(offset, cursor, onControl, onOpen, signal);
 	}
-	async openBootstrapSseSession(_streamUrl, signal) {
-		return await this.client.openBootstrapSseSession(signal);
-	}
-	async readBootstrapLongPoll(_streamUrl, cursor, signal) {
-		return await this.client.readBootstrapLongPoll(cursor, signal);
-	}
 	async readFromOffset(_streamUrl, offset, cursor, live, signal) {
 		return await this.client.readFromOffset(offset, cursor, live, signal);
 	}
@@ -2167,4 +2001,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-YOFZ4I6Y.js.map
+//# sourceMappingURL=stream-id-kM9JM1F7.js.map