@loro-dev/streams-crdt 0.1.0

package/dist/stream-id-CIhmveJD.js

@@ -0,0 +1,2151 @@
+//#region src/checkpoint.ts
+function composeBeforeRemoteCursorSaveHooks(...hooks) {
+	const active = hooks.filter((hook) => hook != null);
+	if (active.length === 0) return;
+	return async (context) => {
+		for (const hook of active) await hook(context);
+	};
+}
+async function persistRemoteCursor(input) {
+	const next = {
+		...input.cursor,
+		updatedAtMs: (input.now ?? Date.now)()
+	};
+	if (input.beforeRemoteCursorSave != null) await input.beforeRemoteCursorSave({
+		cursor: next,
+		source: input.source
+	});
+	await input.remoteCursorStore.save(next);
+	return next;
+}
+function key(streamUrl) {
+	return streamUrl;
+}
+function isJsonObject(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value);
+}
+function cloneJsonValue(value) {
+	return structuredClone(value);
+}
+function cloneRemoteCursor(cursor) {
+	return {
+		...cursor,
+		serverLowerBoundVersion: cloneJsonValue(cursor.serverLowerBoundVersion)
+	};
+}
+function fromStoredRemoteCursor(record) {
+	if (!isJsonObject(record.serverLowerBoundVersion)) throw new Error("invalid remote cursor record: serverLowerBoundVersion is not a JSON object");
+	return {
+		streamUrl: record.streamUrl,
+		nextOffset: record.nextOffset,
+		serverLowerBoundVersion: cloneJsonValue(record.serverLowerBoundVersion),
+		updatedAtMs: record.updatedAtMs
+	};
+}
+function toStoredRemoteCursor(cursor) {
+	return {
+		streamUrl: cursor.streamUrl,
+		nextOffset: cursor.nextOffset,
+		serverLowerBoundVersion: cloneJsonValue(cursor.serverLowerBoundVersion),
+		updatedAtMs: cursor.updatedAtMs
+	};
+}
+/**
+* In-memory cursor store useful for tests or ephemeral runtimes.
+*/
+var InMemoryRemoteCursorStore = class {
+	data = /* @__PURE__ */ new Map();
+	async load(streamUrl) {
+		const value = this.data.get(key(streamUrl));
+		return value == null ? null : cloneRemoteCursor(value);
+	}
+	async save(cursor) {
+		this.data.set(key(cursor.streamUrl), cloneRemoteCursor(cursor));
+	}
+	async delete(streamUrl) {
+		this.data.delete(key(streamUrl));
+	}
+};
+const DEFAULT_DB_NAME = "streams-crdt";
+const DEFAULT_STORE_NAME = "remote-cursors";
+const DEFAULT_DB_VERSION = 1;
+/**
+* IndexedDB-backed cursor store for browser clients that need replay progress persistence.
+*
+* This store only persists `RemoteCursor` metadata. It does not persist CRDT
+* payloads. Use it only when the application also persists the corresponding
+* local document state and restores that state before calling `sync()` or
+* `join()` after a reload.
+*/
+var IndexedDbRemoteCursorStore = class {
+	dbName;
+	storeName;
+	dbVersion;
+	indexedDb;
+	db = null;
+	initPromise = null;
+	constructor(options) {
+		this.dbName = options?.dbName ?? DEFAULT_DB_NAME;
+		this.storeName = options?.storeName ?? DEFAULT_STORE_NAME;
+		this.dbVersion = options?.dbVersion ?? DEFAULT_DB_VERSION;
+		this.indexedDb = options?.indexedDb ?? globalThis.indexedDB;
+	}
+	async load(streamUrl) {
+		const db = await this.ensureDb();
+		const record = await new Promise((resolve, reject) => {
+			const request = db.transaction([this.storeName], "readonly").objectStore(this.storeName).get(key(streamUrl));
+			request.onsuccess = () => {
+				resolve(request.result ?? null);
+			};
+			request.onerror = () => {
+				reject(request.error ?? /* @__PURE__ */ new Error("indexeddb load failed"));
+			};
+		});
+		return record == null ? null : fromStoredRemoteCursor(record);
+	}
+	async save(cursor) {
+		const db = await this.ensureDb();
+		const record = toStoredRemoteCursor(cursor);
+		await new Promise((resolve, reject) => {
+			const tx = db.transaction([this.storeName], "readwrite");
+			const request = tx.objectStore(this.storeName).put(record, key(cursor.streamUrl));
+			tx.oncomplete = () => resolve();
+			tx.onerror = () => reject(tx.error ?? request.error ?? /* @__PURE__ */ new Error("indexeddb save failed"));
+			tx.onabort = () => reject(tx.error ?? request.error ?? /* @__PURE__ */ new Error("indexeddb save transaction aborted"));
+			request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("indexeddb save failed"));
+		});
+	}
+	async delete(streamUrl) {
+		const db = await this.ensureDb();
+		await new Promise((resolve, reject) => {
+			const tx = db.transaction([this.storeName], "readwrite");
+			const request = tx.objectStore(this.storeName).delete(key(streamUrl));
+			tx.oncomplete = () => resolve();
+			tx.onerror = () => reject(tx.error ?? request.error ?? /* @__PURE__ */ new Error("indexeddb delete failed"));
+			tx.onabort = () => reject(tx.error ?? request.error ?? /* @__PURE__ */ new Error("indexeddb delete transaction aborted"));
+			request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("indexeddb delete failed"));
+		});
+	}
+	async ensureDb() {
+		if (this.db != null) return this.db;
+		if (this.initPromise != null) {
+			await this.initPromise;
+			if (this.db == null) throw new Error("indexeddb is not available");
+			return this.db;
+		}
+		if (this.indexedDb == null) throw new Error("indexeddb is not available in this environment");
+		this.initPromise = new Promise((resolve, reject) => {
+			const request = this.indexedDb.open(this.dbName, this.dbVersion);
+			request.onupgradeneeded = () => {
+				const db = request.result;
+				if (!db.objectStoreNames.contains(this.storeName)) db.createObjectStore(this.storeName);
+			};
+			request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("indexeddb open failed"));
+			request.onsuccess = () => {
+				this.db = request.result;
+				this.db.onversionchange = () => {
+					this.db?.close();
+					this.db = null;
+				};
+				resolve();
+			};
+		}).finally(() => {
+			this.initPromise = null;
+		});
+		await this.initPromise;
+		if (this.db == null) throw new Error("indexeddb open succeeded without a database handle");
+		return this.db;
+	}
+};
+/**
+* Creates a cursor value suitable for seeding a `RemoteCursorStore`.
+*/
+function createInitialRemoteCursor(input) {
+	return {
+		streamUrl: input.streamUrl,
+		nextOffset: input.nextOffset,
+		serverLowerBoundVersion: cloneJsonValue(input.serverLowerBoundVersion),
+		updatedAtMs: Date.now()
+	};
+}
+//#endregion
+//#region src/reconnect.ts
+const DEFAULT_RECONNECT_CONFIG = {
+	delays: [
+		0,
+		500,
+		1e3,
+		2e3,
+		4e3,
+		8e3,
+		15e3
+	],
+	jitterFraction: .2,
+	maxAttempts: 5,
+	connectTimeoutMs: 1e4,
+	pollTimeoutMs: 3e4
+};
+/**
+* Apply jitter of +/- fraction to a base delay.
+* E.g. applyJitter(1000, 0.2) returns a value in [800, 1200].
+*/
+function applyJitter(baseMs, fraction) {
+	if (baseMs === 0) return 0;
+	const jitter = baseMs * fraction * (2 * Math.random() - 1);
+	return Math.max(0, Math.round(baseMs + jitter));
+}
+/**
+* Compute the retry delay for a given attempt number.
+* Uses the delays table from config, clamping at the last entry.
+*/
+function computeRetryDelay(attempt, config = DEFAULT_RECONNECT_CONFIG) {
+	const { delays, jitterFraction } = config;
+	const base = delays[Math.min(attempt, delays.length - 1)];
+	return applyJitter(base, jitterFraction);
+}
+//#endregion
+//#region src/items.ts
+const BINARY_CONTENT_TYPE = "application/octet-stream";
+function encodeItems(items) {
+	const total = items.reduce((sum, item) => sum + 4 + item.byteLength, 0);
+	const out = new Uint8Array(total);
+	const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+	let cursor = 0;
+	for (const item of items) {
+		view.setUint32(cursor, item.byteLength, false);
+		cursor += 4;
+		out.set(item, cursor);
+		cursor += item.byteLength;
+	}
+	return out;
+}
+function decodeItems(payload) {
+	const out = [];
+	const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+	let cursor = 0;
+	while (cursor < payload.byteLength) {
+		if (cursor + 4 > payload.byteLength) throw new Error("corrupted items payload: truncated length prefix");
+		const len = view.getUint32(cursor, false);
+		cursor += 4;
+		if (cursor + len > payload.byteLength) throw new Error("corrupted items payload: truncated item payload");
+		out.push(payload.slice(cursor, cursor + len));
+		cursor += len;
+	}
+	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();
+	return `${Math.random().toString(36).slice(2)}${Math.random().toString(36).slice(2)}`;
+}
+var HttpError = class extends Error {
+	status;
+	constructor(message, status) {
+		super(message);
+		this.status = status;
+	}
+};
+var TimeoutError = class extends Error {
+	timeoutType;
+	timeoutMs;
+	constructor(timeoutType, timeoutMs) {
+		super(`TIMEOUT: ${timeoutType} request exceeded ${timeoutMs}ms`);
+		this.timeoutType = timeoutType;
+		this.timeoutMs = timeoutMs;
+	}
+};
+var ProtocolError = class extends Error {
+	status;
+	constructor(message, status) {
+		super(message);
+		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) {
+	if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(encoded, "base64"));
+	if (typeof atob === "function") {
+		const binary = atob(encoded);
+		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 {}
+	return new TextEncoder().encode(data);
+}
+function decodeSseItemPayloads(data) {
+	const payload = decodeSseRawPayload(data);
+	if (payload.byteLength === 0) return [payload];
+	try {
+		return decodeItems(payload);
+	} catch {
+		return [payload];
+	}
+}
+/**
+* Decode a single multipart part body. If the payload contains
+* length-prefixed binary framed items, decode them. Otherwise
+* return the raw bytes as a single-element array. This mirrors the
+* try/fallback approach used by {@link decodeSseItemPayloads}.
+*/
+function decodeMultipartPartItems(payload) {
+	if (payload.byteLength === 0) return [payload];
+	try {
+		return decodeItems(payload);
+	} catch {
+		return [payload];
+	}
+}
+function parseSseControlData(data) {
+	let parsed;
+	try {
+		parsed = JSON.parse(data);
+	} catch {
+		throw new ProtocolError("invalid sse control event JSON");
+	}
+	if (!isObject(parsed) || typeof parsed.streamNextOffset !== "string") throw new ProtocolError("sse control event missing streamNextOffset");
+	const streamCursor = typeof parsed.streamCursor === "string" ? parsed.streamCursor : void 0;
+	return {
+		nextOffset: parsed.streamNextOffset,
+		upToDate: parsed.upToDate === true,
+		streamCursor
+	};
+}
+function isSseUnsupportedErrorText(message) {
+	const normalized = message.trim().toLowerCase();
+	if (normalized.length === 0) return false;
+	const mentionsSse = normalized.includes("sse") || normalized.includes("text/event-stream");
+	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);
+		}, { once: true });
+	}
+	return controller.signal;
+}
+function classifyFetchError(err) {
+	const message = err instanceof Error ? err.message : String(err);
+	const status = err instanceof HttpError ? err.status : void 0;
+	if (status === 401 || status === 403) return {
+		code: "auth_failed",
+		message,
+		retriable: false,
+		atMs: Date.now()
+	};
+	if (status === 410) return {
+		code: "gone_410",
+		message,
+		retriable: true,
+		atMs: Date.now()
+	};
+	if (status === 400 || status === 405 || status === 409) return {
+		code: "protocol",
+		message,
+		retriable: false,
+		atMs: Date.now()
+	};
+	if (err instanceof ProtocolError) return {
+		code: "protocol",
+		message,
+		retriable: false,
+		atMs: Date.now()
+	};
+	if (err instanceof TimeoutError) return {
+		code: "timeout",
+		message,
+		retriable: true,
+		atMs: Date.now()
+	};
+	if (err instanceof TypeError) return {
+		code: "network",
+		message,
+		retriable: true,
+		atMs: Date.now()
+	};
+	return {
+		code: "internal",
+		message,
+		retriable: false,
+		atMs: Date.now()
+	};
+}
+function isStreamNotFoundError(error) {
+	return error instanceof HttpError && error.status === 404;
+}
+function toTransportError(error) {
+	if (isStreamNotFoundError(error)) return {
+		code: "stream_not_found",
+		retryable: false
+	};
+	if (error instanceof HttpError && (error.status === 401 || error.status === 403)) return {
+		code: "auth_failed",
+		retryable: false,
+		status: error.status,
+		message: error.message
+	};
+	if (error instanceof HttpError && [
+		400,
+		405,
+		409
+	].includes(error.status)) return {
+		code: "protocol_error",
+		retryable: false,
+		status: error.status,
+		message: error.message
+	};
+	if (error instanceof ProtocolError) return {
+		code: "protocol_error",
+		retryable: false,
+		status: error.status,
+		message: error.message
+	};
+	if (error instanceof TimeoutError) return {
+		code: "timeout",
+		retryable: true,
+		phase: error.timeoutType,
+		message: error.message
+	};
+	if (error instanceof HttpError && error.status === 410) return {
+		code: "gone",
+		retryable: true,
+		message: error.message
+	};
+	if (error instanceof TypeError) return {
+		code: "network_error",
+		retryable: true,
+		message: error.message
+	};
+	if (error instanceof Error) return {
+		code: "internal_error",
+		retryable: false,
+		message: error.message
+	};
+	return {
+		code: "unknown",
+		retryable: false,
+		message: String(error)
+	};
+}
+function isReadNoProgress(requestOffset, result) {
+	return !result.upToDate && result.updates.length === 0 && result.nextOffset === requestOffset;
+}
+function isAuthOrProtocolError(error) {
+	return error instanceof ProtocolError || error instanceof HttpError && [
+		400,
+		401,
+		403,
+		405,
+		409
+	].includes(error.status);
+}
+function normalizeAuthProvider(auth) {
+	if (auth == null) return;
+	if (typeof auth === "string") {
+		const token = auth.trim();
+		return async () => token.length === 0 ? void 0 : token;
+	}
+	return async () => {
+		const token = (await auth())?.trim() ?? "";
+		return token.length === 0 ? void 0 : token;
+	};
+}
+function normalizeSnapshotUploadConfig(config) {
+	if (config == null || config.enabled === false) return;
+	if (!Number.isFinite(config.debounceMs ?? 1e4)) throw new Error("snapshotUpload.debounceMs must be a finite number");
+	if (!Number.isFinite(config.minBytesSinceRemoteSnapshot ?? 100 * 1024)) throw new Error("snapshotUpload.minBytesSinceRemoteSnapshot must be a finite number");
+	const debounceMs = Math.max(0, Math.floor(config.debounceMs ?? 1e4));
+	const minBytes = config.minBytesSinceRemoteSnapshot ?? 100 * 1024;
+	if (minBytes < 0) throw new Error("snapshotUpload.minBytesSinceRemoteSnapshot must be non-negative");
+	return {
+		canUpload: async () => Boolean(await config.canUpload()),
+		debounceMs,
+		minBytesSinceRemoteSnapshot: BigInt(Math.floor(minBytes))
+	};
+}
+function jsonValueEquals(a, b) {
+	if (a === b) return true;
+	if (typeof a !== typeof b || a == null || b == null) return false;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i += 1) if (!jsonValueEquals(a[i], b[i])) return false;
+		return true;
+	}
+	if (typeof a !== "object" || typeof b !== "object") return false;
+	const aEntries = Object.entries(a).sort(([left], [right]) => left.localeCompare(right));
+	const bEntries = Object.entries(b).sort(([left], [right]) => left.localeCompare(right));
+	if (aEntries.length !== bEntries.length) return false;
+	for (let i = 0; i < aEntries.length; i += 1) {
+		const [aKey, aValue] = aEntries[i];
+		const [bKey, bValue] = bEntries[i];
+		if (aKey !== bKey || !jsonValueEquals(aValue, bValue)) return false;
+	}
+	return true;
+}
+function jsonObjectEquals(a, b) {
+	return jsonValueEquals(a, b);
+}
+function parseSnapshotByteOffset(offset) {
+	if (offset == null || offset.length === 0 || offset === "-1") return 0n;
+	if (!/^\d+$/.test(offset)) return null;
+	return BigInt(offset);
+}
+function resolveNextOffsetAfterConcurrentAdvance(requestOffset, currentOffset, responseNextOffset) {
+	if (currentOffset === requestOffset) return responseNextOffset;
+	if (currentOffset === responseNextOffset) return currentOffset;
+	const current = parseSnapshotByteOffset(currentOffset);
+	const incoming = parseSnapshotByteOffset(responseNextOffset);
+	if (current != null && incoming != null) return incoming > current ? responseNextOffset : currentOffset;
+	return currentOffset;
+}
+//#endregion
+//#region src/transport-client.ts
+/**
+* Low-level HTTP and SSE client for one stream.
+*
+* This layer owns request headers, timeouts, and response parsing. Higher-level
+* join/sync state transitions stay in `transport-runtime.ts`.
+*/
+var StreamsTransportClient = class {
+	streamUrl;
+	adapter;
+	authProvider;
+	fetchImpl;
+	reconnectConfig;
+	constructor(options) {
+		this.streamUrl = options.streamUrl;
+		this.adapter = options.adapter;
+		this.authProvider = options.authProvider;
+		this.fetchImpl = options.fetchImpl;
+		this.reconnectConfig = options.reconnectConfig;
+	}
+	async createStreamRequest() {
+		const adapterHeaders = this.adapter.getCreateStreamHeaders ? await this.adapter.getCreateStreamHeaders() : void 0;
+		const response = await this.fetchWithTimeout(this.streamUrl, {
+			method: "PUT",
+			headers: await this.resolveHeaders({
+				"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");
+		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);
+	}
+	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);
+	}
+	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()}`, {
+			method: "GET",
+			headers: await this.resolveHeaders(),
+			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());
+		return {
+			kind: "ok",
+			value: {
+				nextOffset,
+				upToDate,
+				updates: body.byteLength === 0 ? [] : decodeItems(body),
+				streamCursor
+			}
+		};
+	}
+	async bootstrap() {
+		const response = await this.fetchWithTimeout(`${this.streamUrl}/bootstrap`, {
+			method: "GET",
+			headers: await this.resolveHeaders()
+		}, 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");
+		return {
+			nextOffset,
+			upToDate,
+			snapshot: new Uint8Array(),
+			updates: [],
+			streamCursor
+		};
+	}
+	async readSnapshotOffsetValue() {
+		const response = await this.fetchWithTimeout(this.streamUrl, {
+			method: "HEAD",
+			headers: await this.resolveHeaders()
+		}, 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)}`, {
+			method: "PUT",
+			headers: await this.resolveHeaders({ "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, {
+			method: "POST",
+			headers: await this.resolveHeaders({
+				"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");
+		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 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}`);
+		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);
+		}
+	}
+	async readItemsSse(url, initialOffset, onControl, onOpen, signal) {
+		const opened = await this.openItemsSseSession(url, initialOffset, 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
+		};
+	}
+	async openItemsSseSession(url, initialOffset, onOpen, signal) {
+		const response = await this.fetchWithTimeout(url, {
+			method: "GET",
+			headers: await this.resolveHeaders(),
+			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 (!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");
+		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 exhausted = false;
+		return {
+			kind: "ok",
+			session: {
+				continue: async (nextOnControl) => {
+					if (exhausted) return {
+						kind: "ok",
+						latestOffset,
+						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;
+						}
+						if (eventType !== "control") return;
+						const control = parseSseControlData(data);
+						const updates = [];
+						for (const eventData of pendingDataEvents) for (const payload of decodeSseItemPayloads(eventData)) updates.push(payload);
+						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;
+						}
+						if (handlerResult === "pause") pauseRequested = true;
+					};
+					while (true) {
+						if (stopRequested || pauseRequested) 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
+						};
+					}
+				},
+				cancel: async () => {
+					if (exhausted) return;
+					exhausted = true;
+					try {
+						await reader.cancel();
+					} catch {}
+				}
+			}
+		};
+	}
+};
+//#endregion
+//#region src/transport-cursor.ts
+var TransportCursorManager = class {
+	adapter;
+	saveRemoteCursor;
+	constructor(options) {
+		this.adapter = options.adapter;
+		this.saveRemoteCursor = options.saveRemoteCursor;
+	}
+	async applyBootstrapPayload(cursor, snapshot, updates, nextOffset) {
+		let nextVersion = cursor.serverLowerBoundVersion;
+		if (snapshot.byteLength > 0) nextVersion = await this.adapter.applySnapshot(snapshot);
+		if (updates.length > 0) nextVersion = await this.adapter.applyRemoteUpdates([...updates], nextVersion);
+		return await this.saveRemoteCursor({
+			...cursor,
+			nextOffset,
+			serverLowerBoundVersion: nextVersion
+		}, "bootstrap");
+	}
+	async applyBootstrapItems(cursor, items, nextOffset) {
+		const snapshot = items[0] ?? new Uint8Array();
+		return await this.applyBootstrapPayload(cursor, snapshot, items.slice(1), nextOffset);
+	}
+	async applyRemoteItems(cursor, items, nextOffset) {
+		return await this.applyRemotePayload(cursor, [...items], nextOffset, "remote");
+	}
+	async applyCatchupResult(cursor, result, onRemoteVersionApplied) {
+		return await this.applyRemotePayload(cursor, result.updates, result.nextOffset, "remote", onRemoteVersionApplied);
+	}
+	async applyLiveResult(cursor, requestOffset, result, onRemoteVersionApplied) {
+		const previousVersion = cursor.serverLowerBoundVersion;
+		let nextVersion = previousVersion;
+		if (result.updates.length > 0) {
+			nextVersion = await this.adapter.applyRemoteUpdates([...result.updates], nextVersion);
+			await onRemoteVersionApplied?.(previousVersion, nextVersion);
+		}
+		return await this.saveRemoteCursor({
+			...cursor,
+			nextOffset: resolveNextOffsetAfterConcurrentAdvance(requestOffset, cursor.nextOffset, result.nextOffset),
+			serverLowerBoundVersion: nextVersion
+		}, "remote");
+	}
+	async applyRemotePayload(cursor, updates, nextOffset, source, onRemoteVersionApplied) {
+		const previousVersion = cursor.serverLowerBoundVersion;
+		let nextVersion = previousVersion;
+		if (updates.length > 0) {
+			nextVersion = await this.adapter.applyRemoteUpdates([...updates], nextVersion);
+			await onRemoteVersionApplied?.(previousVersion, nextVersion);
+		}
+		return await this.saveRemoteCursor({
+			...cursor,
+			nextOffset,
+			serverLowerBoundVersion: nextVersion
+		}, source);
+	}
+};
+//#endregion
+//#region src/deque.ts
+const DEFAULT_COMPACT_THRESHOLD = 64;
+const DEFAULT_MIN_CAPACITY = 16;
+var Deque = class {
+	buffer;
+	head = 0;
+	tail = 0;
+	compactThreshold;
+	minCapacity;
+	constructor(values, options = {}) {
+		this.compactThreshold = Math.max(1, options.compactThreshold ?? DEFAULT_COMPACT_THRESHOLD);
+		this.minCapacity = Math.max(1, options.minCapacity ?? DEFAULT_MIN_CAPACITY);
+		const seed = values == null ? [] : Array.from(values);
+		this.buffer = seed.slice();
+		this.tail = seed.length;
+	}
+	get length() {
+		return this.tail - this.head;
+	}
+	isEmpty() {
+		return this.length === 0;
+	}
+	clear() {
+		this.buffer = [];
+		this.head = 0;
+		this.tail = 0;
+	}
+	peekFront() {
+		if (this.length === 0) return;
+		const value = this.buffer[this.head];
+		return value == null ? void 0 : value;
+	}
+	peekBack() {
+		if (this.length === 0) return;
+		const value = this.buffer[this.tail - 1];
+		return value == null ? void 0 : value;
+	}
+	at(index) {
+		const length = this.length;
+		if (length === 0) return;
+		let offset = index;
+		if (offset < 0) offset += length;
+		if (offset < 0 || offset >= length) return;
+		const value = this.buffer[this.head + offset];
+		return value == null ? void 0 : value;
+	}
+	pushBack(value) {
+		this.ensureBackCapacity();
+		this.buffer[this.tail] = value;
+		this.tail += 1;
+		return this.length;
+	}
+	pushFront(value) {
+		if (this.head === 0) this.recenter(1, 0);
+		this.head -= 1;
+		this.buffer[this.head] = value;
+		return this.length;
+	}
+	popFront() {
+		if (this.length === 0) return;
+		const value = this.buffer[this.head];
+		this.buffer[this.head] = null;
+		this.head += 1;
+		this.compactIfNeeded();
+		return value == null ? void 0 : value;
+	}
+	popBack() {
+		if (this.length === 0) return;
+		this.tail -= 1;
+		const value = this.buffer[this.tail];
+		this.buffer[this.tail] = null;
+		this.compactIfNeeded();
+		return value == null ? void 0 : value;
+	}
+	toArray() {
+		const out = [];
+		for (let i = this.head; i < this.tail; i += 1) out.push(this.buffer[i]);
+		return out;
+	}
+	*[Symbol.iterator]() {
+		for (let i = this.head; i < this.tail; i += 1) yield this.buffer[i];
+	}
+	ensureBackCapacity() {
+		if (this.tail < this.buffer.length) return;
+		if (this.head > 0) {
+			this.compactToFront();
+			if (this.tail < this.buffer.length) return;
+		}
+		this.recenter(0, 1);
+	}
+	recenter(extraFront, extraBack) {
+		const length = this.length;
+		const needed = length + extraFront + extraBack;
+		const currentCapacity = this.buffer.length;
+		let nextCapacity = Math.max(currentCapacity, this.minCapacity);
+		if (nextCapacity < needed) nextCapacity = Math.max(nextCapacity * 2, needed, this.minCapacity);
+		const free = nextCapacity - length;
+		const nextHead = Math.max(extraFront, Math.floor(free / 2));
+		const next = new Array(nextCapacity);
+		for (let i = 0; i < length; i += 1) next[nextHead + i] = this.buffer[this.head + i];
+		this.buffer = next;
+		this.head = nextHead;
+		this.tail = nextHead + length;
+	}
+	compactIfNeeded() {
+		const length = this.length;
+		if (length === 0) {
+			this.clear();
+			return;
+		}
+		if (this.head < this.compactThreshold || this.head < length) return;
+		this.compactToFront();
+	}
+	compactToFront() {
+		const length = this.length;
+		this.buffer = this.buffer.slice(this.head, this.tail);
+		this.head = 0;
+		this.tail = length;
+	}
+};
+//#endregion
+//#region src/transport-snapshot.ts
+function createTransportSnapshotState() {
+	return {
+		observedForeignWriter: false,
+		taskScheduled: false,
+		taskNeedsRerun: false
+	};
+}
+/**
+* Manages debounce and upload gating for remote snapshots.
+*
+* All "is this state still current / closed / reconnecting / blocked by a
+* foreign writer?" checks live here so the runtime does not duplicate them.
+*/
+var TransportSnapshotManager = class {
+	adapter;
+	config;
+	readSnapshotOffsetValue;
+	putSnapshotAt;
+	enqueueExclusive;
+	logDebug;
+	logError;
+	isCurrentState;
+	constructor(options) {
+		this.adapter = options.adapter;
+		this.config = options.config;
+		this.readSnapshotOffsetValue = options.readSnapshotOffsetValue;
+		this.putSnapshotAt = options.putSnapshotAt;
+		this.enqueueExclusive = options.enqueueExclusive;
+		this.logDebug = options.logDebug;
+		this.logError = options.logError;
+		this.isCurrentState = options.isCurrentState;
+	}
+	dispose(state) {
+		this.clearDebounceTimer(state.snapshot);
+	}
+	observeRemoteVersion(state, previousVersion, nextVersion) {
+		const snapshot = state.snapshot;
+		if (snapshot.debounceTimer == null) return;
+		if (!jsonObjectEquals(previousVersion, nextVersion)) snapshot.observedForeignWriter = true;
+	}
+	schedule(state) {
+		const config = this.config;
+		if (config == null || state.closed) return;
+		const snapshot = state.snapshot;
+		this.clearDebounceTimer(snapshot);
+		snapshot.observedForeignWriter = false;
+		snapshot.debounceTimer = setTimeout(() => {
+			this.handleDebounceExpiry(state);
+		}, config.debounceMs);
+	}
+	clearDebounceTimer(snapshot) {
+		if (snapshot.debounceTimer != null) {
+			clearTimeout(snapshot.debounceTimer);
+			snapshot.debounceTimer = void 0;
+		}
+	}
+	async handleDebounceExpiry(state) {
+		const snapshot = state.snapshot;
+		snapshot.debounceTimer = void 0;
+		if (this.getRunnableConfig(state) == null) return;
+		if (snapshot.taskScheduled) {
+			snapshot.taskNeedsRerun = true;
+			return;
+		}
+		snapshot.taskScheduled = true;
+		this.enqueueExclusive(async () => {
+			await this.maybeUpload(state);
+		}).catch((error) => {
+			this.logError("snapshot upload task failed", error);
+		}).finally(() => {
+			snapshot.taskScheduled = false;
+			if (snapshot.taskNeedsRerun && !state.closed) {
+				snapshot.taskNeedsRerun = false;
+				this.handleDebounceExpiry(state);
+			}
+		});
+	}
+	async maybeUpload(state) {
+		const config = await this.resolveUploadConfig(state);
+		if (config == null) return;
+		const tailBytes = parseSnapshotByteOffset(state.cursor.nextOffset);
+		if (tailBytes == null) {
+			this.logDebug("skip snapshot upload: non-numeric offset token", { offset: state.cursor.nextOffset });
+			return;
+		}
+		try {
+			const remoteSnapshotOffset = await this.readSnapshotOffsetValue();
+			const snapshotBytes = parseSnapshotByteOffset(remoteSnapshotOffset);
+			if (snapshotBytes == null) {
+				this.logDebug("skip snapshot upload: non-numeric snapshot offset", { offset: remoteSnapshotOffset });
+				return;
+			}
+			if (tailBytes <= snapshotBytes) return;
+			if (tailBytes - snapshotBytes < config.minBytesSinceRemoteSnapshot) return;
+			const snapshot = this.adapter.exportSnapshot();
+			await this.putSnapshotAt(state.cursor.nextOffset, snapshot);
+		} catch (error) {
+			this.logError("snapshot upload failed", error);
+		}
+	}
+	getRunnableConfig(state) {
+		const config = this.config;
+		if (config == null || state.closed || !this.isCurrentState(state)) return;
+		if (state.snapshot.observedForeignWriter || state.status === "reconnecting" || state.status === "disconnected" || state.status === "error") return;
+		return config;
+	}
+	async resolveUploadConfig(state) {
+		const config = this.getRunnableConfig(state);
+		if (config == null) return;
+		if (!await this.canUpload(config)) return;
+		return config;
+	}
+	async canUpload(config) {
+		try {
+			return Boolean(await config.canUpload());
+		} catch (error) {
+			this.logError("snapshot upload permission check failed", error);
+			return false;
+		}
+	}
+};
+//#endregion
+//#region src/transport-room.ts
+function createJoinState(cursor, liveMode = "sse") {
+	return {
+		refCount: 0,
+		closed: false,
+		status: "connecting",
+		statusListeners: /* @__PURE__ */ new Set(),
+		pendingLocal: new Deque(),
+		flushingLocal: false,
+		retryAttempt: 0,
+		cursor,
+		liveMode,
+		snapshot: createTransportSnapshotState(),
+		started: Promise.resolve()
+	};
+}
+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;
+	state.unsubscribeLocal = void 0;
+	requestController?.abort();
+	unsubscribeLocal?.();
+	options.onDisposed?.();
+	await liveSseSession?.cancel();
+}
+//#endregion
+//#region src/transport-runtime.ts
+/**
+* Durable Streams transport runtime bound to one stream URL and one local CRDT adapter.
+*/
+var StreamsCrdt = class StreamsCrdt {
+	streamUrl;
+	adapter;
+	remoteCursorStore;
+	createStreamIfMissing;
+	client;
+	cursorManager;
+	reconnectConfig;
+	debug;
+	beforeRemoteCursorSave;
+	snapshotManager;
+	producerId = createProducerId();
+	producerEpoch = 0;
+	nextProducerSeq = 0;
+	joinState;
+	opQueue = Promise.resolve();
+	/**
+	* Creates a transport for one stream URL and one local adapter instance.
+	*/
+	constructor(options) {
+		this.streamUrl = options.streamUrl;
+		this.adapter = options.adapter;
+		const authProvider = normalizeAuthProvider(options.auth);
+		this.createStreamIfMissing = options.createStreamIfMissing ?? false;
+		const fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+		this.remoteCursorStore = options.remoteCursorStore ?? new InMemoryRemoteCursorStore();
+		this.reconnectConfig = {
+			...DEFAULT_RECONNECT_CONFIG,
+			...options.reconnectConfig
+		};
+		this.debug = options.debug ?? false;
+		this.beforeRemoteCursorSave = composeBeforeRemoteCursorSaveHooks(options.beforeRemoteCursorSave, ...options.beforeRemoteCursorSaveHooks ?? []);
+		const snapshotUploadConfig = normalizeSnapshotUploadConfig(options.snapshotUpload);
+		this.client = new StreamsTransportClient({
+			streamUrl: this.streamUrl,
+			adapter: this.adapter,
+			authProvider,
+			fetchImpl,
+			reconnectConfig: this.reconnectConfig
+		});
+		this.cursorManager = new TransportCursorManager({
+			adapter: this.adapter,
+			saveRemoteCursor: (cursor, source) => this.saveRemoteCursor(cursor, source)
+		});
+		this.snapshotManager = new TransportSnapshotManager({
+			adapter: this.adapter,
+			config: snapshotUploadConfig,
+			readSnapshotOffsetValue: () => this.readSnapshotOffsetValue(),
+			putSnapshotAt: (snapshotOffset, snapshot) => this.putSnapshotAt(snapshotOffset, snapshot),
+			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
+		});
+	}
+	/**
+	* Stops any active live join and releases transport-owned state.
+	*/
+	async close() {
+		const state = this.joinState;
+		if (state != null) await this.disposeJoinState(state);
+	}
+	/**
+	* Reads the latest remote snapshot offset, if the server exposes one.
+	*/
+	async getSnapshotOffset() {
+		try {
+			return {
+				ok: true,
+				value: await this.readSnapshotOffsetValue()
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error: toTransportError(error)
+			};
+		}
+	}
+	/**
+	* Explicitly creates the target stream.
+	*/
+	async createStream() {
+		try {
+			return {
+				ok: true,
+				value: { created: await this.createStreamRequest() }
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error: toTransportError(error)
+			};
+		}
+	}
+	/**
+	* Deletes the target stream and clears persisted replay state when supported by the cursor store.
+	*/
+	async deleteStream() {
+		try {
+			await this.close();
+			return {
+				ok: true,
+				value: { deleted: await this.enqueueExclusive(async () => {
+					const deleted = await this.deleteStreamRequest();
+					await this.remoteCursorStore.delete?.(this.streamUrl);
+					this.producerEpoch = 0;
+					this.nextProducerSeq = 0;
+					return deleted;
+				}) }
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error: toTransportError(error)
+			};
+		}
+	}
+	/**
+	* Runs one bootstrap/catch-up cycle without entering live mode.
+	*/
+	async sync() {
+		try {
+			return {
+				ok: true,
+				value: { cursor: await this.syncOnce() }
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error: toTransportError(error)
+			};
+		}
+	}
+	/**
+	* Replays remote state, flushes queued local updates, then enters live read mode.
+	*/
+	async join(params) {
+		const existing = this.joinState;
+		if (existing != null) try {
+			await existing.started;
+			return {
+				ok: true,
+				value: this.createSubscription(existing, params)
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error: toTransportError(error)
+			};
+		}
+		const state = createJoinState(createInitialRemoteCursor({
+			streamUrl: this.streamUrl,
+			nextOffset: "-1",
+			serverLowerBoundVersion: this.adapter.emptyVersion()
+		}));
+		state.started = this.startJoin(state);
+		this.joinState = state;
+		try {
+			await state.started;
+			return {
+				ok: true,
+				value: this.createSubscription(state, params)
+			};
+		} catch (error) {
+			await this.disposeJoinState(state);
+			return {
+				ok: false,
+				error: toTransportError(error)
+			};
+		}
+	}
+	createSubscription(state, params) {
+		state.refCount += 1;
+		const statusListener = params?.onStatusChange;
+		if (statusListener != null) {
+			state.statusListeners.add(statusListener);
+			statusListener(state.status);
+		}
+		let unsubscribed = false;
+		return {
+			unsubscribe: () => {
+				if (unsubscribed) return;
+				unsubscribed = true;
+				if (statusListener != null) state.statusListeners.delete(statusListener);
+				state.refCount = Math.max(0, state.refCount - 1);
+				if (state.refCount !== 0 || state.closed) return;
+				this.disposeJoinState(state);
+			},
+			get connected() {
+				return state.status === "joined";
+			},
+			get status() {
+				return state.status;
+			},
+			onStatusChange: (listener) => {
+				state.statusListeners.add(listener);
+				listener(state.status);
+				return () => {
+					state.statusListeners.delete(listener);
+				};
+			}
+		};
+	}
+	async disposeJoinState(state) {
+		await disposeJoinState(state, {
+			snapshotManager: this.snapshotManager,
+			onDisposed: () => {
+				if (this.joinState === state) this.joinState = void 0;
+			}
+		});
+	}
+	async startJoin(state) {
+		try {
+			state.requestController ??= new AbortController();
+			const joined = await this.performInitialJoinSync(state.liveMode, state.requestController.signal);
+			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);
+			if (state.closed) return;
+			state.unsubscribeLocal = this.adapter.subscribeLocalUpdates((batch) => {
+				state.pendingLocal.pushBack(batch);
+				this.flushPendingLocal(state);
+			});
+			if (hasQueuedPreSubscribeBatch) {
+				await this.flushPendingLocal(state);
+				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.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");
+			throw error;
+		}
+	}
+	async syncOnce() {
+		const loaded = await this.remoteCursorStore.load(this.streamUrl);
+		let cursor = loaded ?? createInitialRemoteCursor({
+			streamUrl: this.streamUrl,
+			nextOffset: "-1",
+			serverLowerBoundVersion: this.adapter.emptyVersion()
+		});
+		try {
+			if (loaded == null) cursor = await this.bootstrapIntoState(cursor);
+			else cursor = (await this.catchup(cursor)).cursor;
+		} catch (error) {
+			if (!isStreamNotFoundError(error) || !this.createStreamIfMissing) throw error;
+			await this.createStreamRequest();
+			cursor = await this.bootstrapIntoState({
+				...cursor,
+				nextOffset: "-1",
+				serverLowerBoundVersion: this.adapter.emptyVersion()
+			});
+		}
+		const localBatch = this.exportUpdates(cursor.serverLowerBoundVersion);
+		if (localBatch.batch != null) {
+			cursor = await this.appendLocalBatch(cursor, localBatch.batch);
+			cursor = (await this.catchup(cursor)).cursor;
+		}
+		return cursor;
+	}
+	async performInitialJoinSync(preferredLiveMode, signal) {
+		const loaded = await this.remoteCursorStore.load(this.streamUrl);
+		let cursor = loaded ?? createInitialRemoteCursor({
+			streamUrl: this.streamUrl,
+			nextOffset: "-1",
+			serverLowerBoundVersion: this.adapter.emptyVersion()
+		});
+		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 {
+				const caughtUp = await this.catchup(cursor);
+				cursor = caughtUp.cursor;
+				streamCursor = caughtUp.streamCursor;
+			}
+		} catch (error) {
+			if (!isStreamNotFoundError(error) || !this.createStreamIfMissing) throw error;
+			await this.createStreamRequest();
+			const joined = await this.bootstrapIntoJoinedState({
+				...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;
+			}
+		}
+		localExportRefVersion = cursor.serverLowerBoundVersion;
+		return {
+			cursor,
+			streamCursor,
+			liveMode,
+			liveSseSession,
+			localExportRefVersion
+		};
+	}
+	async bootstrapIntoState(cursor) {
+		const result = await this.bootstrap(this.streamUrl);
+		const saved = await this.cursorManager.applyBootstrapPayload(cursor, result.snapshot, result.updates, result.nextOffset);
+		if (!result.upToDate) return (await this.catchup(saved)).cursor;
+		return saved;
+	}
+	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;
+		while (true) {
+			const requestOffset = current.nextOffset;
+			const response = await this.readFromOffset(this.streamUrl, requestOffset, currentStreamCursor, live);
+			if (response.kind === "gone") return { cursor: await this.bootstrapIntoState({
+				...current,
+				nextOffset: "-1",
+				serverLowerBoundVersion: this.adapter.emptyVersion()
+			}) };
+			const result = response.value;
+			if (isReadNoProgress(requestOffset, result)) throw new Error(`catch-up made no progress at offset ${requestOffset}; server returned empty updates and unchanged next offset with up_to_date=false`);
+			current = await this.cursorManager.applyCatchupResult(current, result, onRemoteVersionApplied);
+			currentStreamCursor = result.streamCursor;
+			if (result.upToDate) return {
+				cursor: current,
+				streamCursor: currentStreamCursor
+			};
+		}
+	}
+	async appendLocalBatch(cursor, batch) {
+		let producerSession = {
+			producerId: this.producerId,
+			producerEpoch: this.producerEpoch,
+			nextProducerSeq: this.nextProducerSeq
+		};
+		for (let attempt = 0; attempt < 3; attempt += 1) {
+			const result = await this.appendUpdates(this.streamUrl, batch.updates, producerSession);
+			if (result.kind === "ok") {
+				this.producerEpoch = result.ackEpoch;
+				this.nextProducerSeq = result.ackSeq + 1;
+				const next = {
+					...cursor,
+					nextOffset: result.nextOffset,
+					serverLowerBoundVersion: this.adapter.mergeVersions(cursor.serverLowerBoundVersion, batch.version)
+				};
+				return await this.saveRemoteCursor(next, "local");
+			}
+			if (result.kind === "seq-gap") {
+				producerSession = {
+					...producerSession,
+					nextProducerSeq: result.expectedSeq
+				};
+				continue;
+			}
+			producerSession = {
+				...producerSession,
+				producerEpoch: result.serverEpoch + 1,
+				nextProducerSeq: 0
+			};
+		}
+		throw new Error("append retry budget exhausted");
+	}
+	exportUpdates(fromVersion) {
+		const exported = this.adapter.exportUpdates(fromVersion);
+		if (exported == null) return { nextRefVersion: fromVersion };
+		const nextRefVersion = this.adapter.mergeVersions(fromVersion, exported.version);
+		if (exported.updates.length === 0) return { nextRefVersion };
+		return {
+			batch: exported,
+			nextRefVersion
+		};
+	}
+	async applyBootstrapItems(cursor, items, nextOffset) {
+		return await this.cursorManager.applyBootstrapItems(cursor, items, nextOffset);
+	}
+	async applyRemoteItems(cursor, items, nextOffset) {
+		return await this.cursorManager.applyRemoteItems(cursor, items, nextOffset);
+	}
+	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") {
+					state.cursor = await this.bootstrapIntoState({
+						...state.cursor,
+						nextOffset: "-1",
+						serverLowerBoundVersion: this.adapter.emptyVersion()
+					});
+					state.streamCursor = void 0;
+					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;
+				});
+				if (state.closed) return;
+				state.retryAttempt = 0;
+				this.setJoinStatus(state, "joined");
+				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 () => {
+					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");
+			}, () => {
+				this.setJoinStatus(state, "joined");
+			}, state.requestController?.signal);
+			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, "error");
+				return;
+			}
+			state.cursor = await this.bootstrapIntoState({
+				...state.cursor,
+				nextOffset: "-1",
+				serverLowerBoundVersion: this.adapter.emptyVersion()
+			});
+			state.streamCursor = void 0;
+			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, {
+					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;
+			}
+			const delay = computeRetryDelay(state.retryAttempt, this.reconnectConfig);
+			state.retryAttempt += 1;
+			await sleep(delay);
+		}
+	}
+	/** Maximum encoded size (bytes) for a single batched append. */
+	static MAX_BATCH_BYTES = 256 * 1024;
+	/**
+	* Drain up to `MAX_BATCH_BYTES` worth of queued batches from the front of
+	* `pendingLocal` and merge them into a single `CrdtUpdateBatch`.
+	*
+	* Returns `undefined` when the queue is empty.
+	*/
+	drainPendingBatch(state) {
+		const first = state.pendingLocal.peekFront();
+		if (first == null) return;
+		const maxBytes = StreamsCrdt.MAX_BATCH_BYTES;
+		let totalBytes = first.updates.reduce((sum, u) => sum + 4 + u.byteLength, 0);
+		let mergedVersion = first.version;
+		const allUpdates = Array.from(first.updates);
+		let count = 1;
+		while (count < state.pendingLocal.length) {
+			const next = state.pendingLocal.at(count);
+			const nextBytes = next.updates.reduce((sum, u) => sum + 4 + u.byteLength, 0);
+			if (totalBytes + nextBytes > maxBytes) break;
+			allUpdates.push(...next.updates);
+			totalBytes += nextBytes;
+			mergedVersion = this.adapter.mergeVersions(mergedVersion, next.version);
+			count += 1;
+		}
+		if (count === 1) return {
+			batch: first,
+			count: 1
+		};
+		return {
+			batch: {
+				updates: allUpdates,
+				version: mergedVersion
+			},
+			count
+		};
+	}
+	async flushPendingLocal(state) {
+		if (state.flushingLocal || state.closed) return;
+		state.flushingLocal = true;
+		try {
+			while (!state.closed) {
+				const drained = this.drainPendingBatch(state);
+				if (drained == null) return;
+				let attempts = 0;
+				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.snapshotManager.schedule(state);
+					break;
+				} catch (error) {
+					const classified = classifyFetchError(error);
+					if (!classified.retriable || isAuthOrProtocolError(error)) {
+						this.logError("local append failed", error, {
+							streamUrl: this.streamUrl,
+							code: classified.code
+						});
+						this.setJoinStatus(state, "error");
+						return;
+					}
+					const maxAttempts = this.reconnectConfig.maxAttempts;
+					if (attempts >= maxAttempts) {
+						this.setJoinStatus(state, "error");
+						return;
+					}
+					this.setJoinStatus(state, "reconnecting");
+					const delay = computeRetryDelay(attempts, this.reconnectConfig);
+					attempts += 1;
+					await sleep(delay);
+				}
+			}
+		} finally {
+			state.flushingLocal = false;
+		}
+	}
+	async saveRemoteCursor(cursor, source) {
+		return await persistRemoteCursor({
+			remoteCursorStore: this.remoteCursorStore,
+			cursor,
+			source,
+			beforeRemoteCursorSave: this.beforeRemoteCursorSave
+		});
+	}
+	setJoinStatus(state, status) {
+		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 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);
+	}
+	async bootstrap(_streamUrl) {
+		return await this.client.bootstrap();
+	}
+	async readSnapshotOffsetValue() {
+		return await this.client.readSnapshotOffsetValue();
+	}
+	async putSnapshotAt(snapshotOffset, snapshot) {
+		await this.client.putSnapshotAt(snapshotOffset, snapshot);
+	}
+	async appendUpdates(_streamUrl, updates, producerSession) {
+		return await this.client.appendUpdates(updates, producerSession);
+	}
+	enqueueExclusive(task) {
+		const run = this.opQueue.then(task, task);
+		this.opQueue = run.then(() => void 0, () => void 0);
+		return run;
+	}
+	logDebug(message, detail) {
+		if (!this.debug) return;
+		if (detail == null) {
+			console.debug(`[streams-crdt] ${message}`);
+			return;
+		}
+		console.debug(`[streams-crdt] ${message}`, detail);
+	}
+	logError(message, error, detail) {
+		const payload = error == null ? detail : {
+			...detail,
+			error: error instanceof Error ? error.message : String(error)
+		};
+		if (payload == null) {
+			console.error(`[streams-crdt] ${message}`);
+			return;
+		}
+		console.error(`[streams-crdt] ${message}`, payload);
+	}
+};
+//#endregion
+//#region src/stream-id.ts
+const MAX_STREAM_ID_BYTES = 512;
+const textEncoder = new TextEncoder();
+const DEFAULT_BASE_URL = "https://streams-api.loro.dev";
+function utf8ByteLength(value) {
+	return textEncoder.encode(value).byteLength;
+}
+/**
+* Validates a stream id accepted by `createStreamUrl()`.
+*/
+function isValidRillId(id) {
+	return id.length > 0 && utf8ByteLength(id) <= MAX_STREAM_ID_BYTES && !id.includes("/") && !id.includes("\0") && !id.includes("..");
+}
+/**
+* Validates a bucket id accepted by `createStreamUrl()`.
+*/
+function isValidBucketId(id) {
+	return isValidRillId(id);
+}
+/**
+* Builds a Durable Streams HTTP URL for one `(bucketId, streamId)` pair.
+*/
+function createStreamUrl(input) {
+	const baseUrl = (input.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/g, "");
+	if (!isValidBucketId(input.bucketId)) throw new Error(`invalid bucketId: ${JSON.stringify(input.bucketId)} (must be non-empty UTF-8, <= ${MAX_STREAM_ID_BYTES} bytes, and exclude "/", "\\0", "..")`);
+	if (!isValidRillId(input.streamId)) throw new Error(`invalid streamId: ${JSON.stringify(input.streamId)} (must be non-empty UTF-8, <= ${MAX_STREAM_ID_BYTES} bytes, and exclude "/", "\\0", "..")`);
+	const streamId = input.streamId;
+	return `${baseUrl}/ds/${encodeURIComponent(input.bucketId)}/${encodeURIComponent(streamId)}`;
+}
+//#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-CIhmveJD.js.map