@loro-dev/streams-crdt 0.14.0 → 0.15.0

package/dist/{stream-id-CEp4zEQJ.js → stream-id-CggbAC6b.js}

@@ -208,59 +208,51 @@ const MAGIC = new Uint8Array([
 	67,
 	69
 ]);
-const ENVELOPE_VERSION = 1;
-const SUITE_AES_256_GCM = 1;
+const PROVIDER_ENVELOPE_VERSION = 2;
+const PAYLOAD_PROTECTION_PROTOCOL = "loro-streams-crdt-payload-protection";
 const UPDATE_BATCH_KIND = 1;
 const SNAPSHOT_KIND = 2;
-const AES_GCM_NONCE_BYTES = 12;
-const HEADER_BYTES = 10;
-const AES_GCM_TAG_BITS = 128;
-const RAW_AES_256_KEY_BYTES = 32;
-const textEncoder$1 = new TextEncoder();
-const textDecoder = new TextDecoder();
+const PROVIDER_PREFIX_BYTES = 10;
+const MAX_PROVIDER_HEADER_BYTES = 512;
+const MAX_PROVIDER_SEAL_OVERHEAD_BYTES = 4 * 1024;
+const providerAadDomain = new TextEncoder().encode(`${PAYLOAD_PROTECTION_PROTOCOL}/v2\0`);
 var PayloadProtectionError = class extends Error {
 	reason;
-	keyId;
-	constructor(reason, message, options = {}) {
-		super(message, options.cause == null ? void 0 : { cause: options.cause });
+	constructor(reason, message = payloadProtectionFailureMessage(reason)) {
+		super(message);
 		this.name = "PayloadProtectionError";
 		this.reason = reason;
-		this.keyId = options.keyId;
+	}
+};
+var ProviderSealContractError = class extends PayloadProtectionError {
+	constructor(message) {
+		super("encrypt_failed", message);
+		this.name = "ProviderSealContractError";
 	}
 };
 var PayloadProtectionRuntime = class {
 	readPolicy;
 	writePolicy;
-	scope;
-	writeKey;
-	readKeys;
-	importedWriteKey;
-	importedReadKeys = /* @__PURE__ */ new Map();
+	provider;
 	constructor(options) {
 		this.readPolicy = options.readPolicy;
 		this.writePolicy = options.writePolicy;
-		this.scope = options.scope;
-		this.writeKey = options.writeKey;
-		this.readKeys = options.readKeys;
+		this.provider = options.provider;
 	}
 	async encodeUpdateItems(clearUpdates) {
 		if (this.writePolicy === "plaintext") return clearUpdates;
-		return [await this.encryptPayload("update_batch", encodeItems(clearUpdates))];
+		return [await this.sealPayload("update_batch", encodeItems(clearUpdates))];
 	}
 	measureEncodedUpdateItemsByteLength(clearUpdates) {
 		if (this.writePolicy === "plaintext") return encodedItemsByteLength(clearUpdates);
-		const writeKey = this.writeKey;
-		if (writeKey == null || this.scope == null) throw new PayloadProtectionError("encrypt_failed", "E2EE write encryption requires encryption.writeKey and encryption.scope");
-		const clearBatchBytes = encodedItemsByteLength(clearUpdates);
-		const keyIdBytes = textEncoder$1.encode(writeKey.id);
-		if (keyIdBytes.byteLength === 0 || keyIdBytes.byteLength > 255) throw new PayloadProtectionError("encrypt_failed", "E2EE key id must be 1..255 UTF-8 bytes", { keyId: writeKey.id });
-		return 4 + (HEADER_BYTES + keyIdBytes.byteLength + AES_GCM_NONCE_BYTES + clearBatchBytes + AES_GCM_TAG_BITS / 8);
+		if (this.provider == null) throw new PayloadProtectionError("encrypt_failed", "provider-backed E2EE writes require a provider");
+		return 4 + PROVIDER_PREFIX_BYTES + encodedItemsByteLength(clearUpdates) + this.provider.maxSealOverheadBytes;
 	}
 	async decodeUpdateItems(wireItems) {
 		const out = [];
 		for (const item of wireItems) {
 			if (isEncryptedEnvelope(item)) {
-				const clearBatch = await this.decryptPayload("update_batch", item);
+				const clearBatch = await this.openPayload("update_batch", item);
 				out.push(...decodeItems(clearBatch));
 				continue;
 			}
@@ -271,75 +263,76 @@ var PayloadProtectionRuntime = class {
 	}
 	async encodeSnapshot(snapshot) {
 		if (this.writePolicy === "plaintext") return snapshot;
-		return await this.encryptPayload("snapshot", snapshot);
+		return await this.sealPayload("snapshot", snapshot);
 	}
 	async decodeSnapshot(snapshot) {
-		if (isEncryptedEnvelope(snapshot)) return await this.decryptPayload("snapshot", snapshot);
+		if (isEncryptedEnvelope(snapshot)) return await this.openPayload("snapshot", snapshot);
 		this.assertPlaintextAllowed("snapshot");
 		return snapshot;
 	}
-	async encryptPayload(kind, plaintext) {
-		const writeKey = this.writeKey;
-		if (writeKey == null || this.scope == null) throw new PayloadProtectionError("encrypt_failed", "E2EE write encryption requires encryption.writeKey and encryption.scope");
+	async sealPayload(kind, plaintext) {
+		return await this.sealProviderPayload(kind, plaintext);
+	}
+	async openPayload(expectedKind, envelope) {
+		const version = envelope[4];
+		if (version === PROVIDER_ENVELOPE_VERSION) return await this.openProviderPayload(expectedKind, envelope);
+		throw new PayloadProtectionError("invalid_envelope", `unsupported streams-crdt protected payload envelope version '${String(version)}'`);
+	}
+	async sealProviderPayload(kind, plaintext) {
+		const provider = this.provider;
+		if (provider == null) throw new PayloadProtectionError("encrypt_failed", "provider-backed E2EE writes require a provider");
+		const context = createProviderContext(kind);
+		let authenticatedHeader;
+		let additionalDataCalls = 0;
+		let result;
 		try {
-			const key = await (this.importedWriteKey ??= importAesGcmKey(writeKey.key));
-			const nonce = createNonce();
-			return concatBytes(createEnvelopeHeader(kind, writeKey.id, nonce), new Uint8Array(await getSubtleCrypto().encrypt({
-				name: "AES-GCM",
-				iv: toArrayBuffer(nonce),
-				tagLength: AES_GCM_TAG_BITS,
-				additionalData: toArrayBuffer(createAad({
-					kind,
-					keyId: writeKey.id,
-					scope: this.scope
-				}))
-			}, key, toArrayBuffer(plaintext))));
-		} catch (error) {
-			if (error instanceof PayloadProtectionError) throw error;
-			throw new PayloadProtectionError("encrypt_failed", "failed to encrypt streams-crdt payload", {
-				keyId: writeKey.id,
-				cause: error
+			result = await provider.seal({
+				plaintext,
+				context,
+				additionalData: (header) => {
+					additionalDataCalls += 1;
+					if (additionalDataCalls !== 1) throw new ProviderSealContractError("payload protection provider must request additionalData exactly once");
+					authenticatedHeader = normalizeProviderHeader(header).slice();
+					return createProviderAad(createProviderEnvelopeHeader(kind, authenticatedHeader));
+				}
 			});
+		} catch (error) {
+			if (error instanceof ProviderSealContractError) throw error;
+			const reason = error instanceof PayloadProtectionError ? error.reason : "encrypt_failed";
+			throw new PayloadProtectionError(reason, payloadProtectionFailureMessage(reason));
 		}
-	}
-	async decryptPayload(expectedKind, envelope) {
-		const parsed = parseEnvelope(envelope);
-		if (parsed.kind !== expectedKind) throw new PayloadProtectionError("wrong_payload_kind", `expected ${expectedKind} payload, got ${parsed.kind}`, { keyId: parsed.keyId });
-		if (this.scope == null) throw new PayloadProtectionError("missing_read_key", "E2EE read decryption requires encryption.scope", { keyId: parsed.keyId });
-		const key = await this.getReadKey(parsed.keyId);
 		try {
-			return new Uint8Array(await getSubtleCrypto().decrypt({
-				name: "AES-GCM",
-				iv: toArrayBuffer(parsed.nonce),
-				tagLength: AES_GCM_TAG_BITS,
-				additionalData: toArrayBuffer(createAad({
-					kind: parsed.kind,
-					keyId: parsed.keyId,
-					scope: this.scope
-				}))
-			}, key, toArrayBuffer(parsed.ciphertext)));
+			const returnedHeader = normalizeProviderHeader(result.header);
+			if (additionalDataCalls !== 1) throw new ProviderSealContractError("payload protection provider must request additionalData exactly once");
+			if (authenticatedHeader == null || !equalBytes(authenticatedHeader, returnedHeader)) throw new ProviderSealContractError("payload protection provider must authenticate the exact header it returns");
+			if (!(result.sealed instanceof Uint8Array) || result.sealed.byteLength === 0) throw new ProviderSealContractError("payload protection provider returned empty or invalid sealed bytes");
+			if (returnedHeader.byteLength + result.sealed.byteLength - plaintext.byteLength > provider.maxSealOverheadBytes) throw new ProviderSealContractError("payload protection provider exceeded maxSealOverheadBytes");
+			return concatBytes(createProviderEnvelopeHeader(kind, returnedHeader), result.sealed);
 		} catch (error) {
-			throw new PayloadProtectionError("decrypt_failed", "failed to decrypt streams-crdt payload", {
-				keyId: parsed.keyId,
-				cause: error
-			});
+			if (error instanceof ProviderSealContractError) throw error;
+			const reason = error instanceof PayloadProtectionError ? error.reason : "encrypt_failed";
+			throw new PayloadProtectionError(reason, payloadProtectionFailureMessage(reason));
 		}
 	}
-	async getReadKey(keyId) {
-		const cached = this.importedReadKeys.get(keyId);
-		if (cached != null) return await cached;
-		const imported = importAesGcmKey((await this.resolveReadKey(keyId)).key);
-		this.importedReadKeys.set(keyId, imported);
-		return await imported;
-	}
-	async resolveReadKey(keyId) {
-		for (const key of await this.resolveReadKeys()) if (key.id === keyId) return key;
-		throw new PayloadProtectionError("missing_read_key", `missing read key for protected streams-crdt payload '${keyId}'`, { keyId });
-	}
-	async resolveReadKeys() {
-		const readKeys = typeof this.readKeys === "function" ? await this.readKeys() : this.readKeys;
-		if (readKeys != null) return readKeys;
-		return this.writeKey == null ? [] : [this.writeKey];
+	async openProviderPayload(expectedKind, envelope) {
+		const parsed = parseProviderEnvelope(envelope);
+		if (parsed.kind !== expectedKind) throw new PayloadProtectionError("wrong_payload_kind", `expected ${expectedKind} payload, got ${parsed.kind}`);
+		const provider = this.provider;
+		if (provider == null) throw new PayloadProtectionError("missing_read_key", "provider-backed E2EE reads require a provider");
+		const context = createProviderContext(parsed.kind);
+		try {
+			const plaintext = await provider.open({
+				sealed: parsed.sealed,
+				header: parsed.header,
+				context,
+				additionalData: createProviderAad(parsed.authenticatedHeader)
+			});
+			if (!(plaintext instanceof Uint8Array)) throw new PayloadProtectionError("decrypt_failed", "payload protection provider returned invalid plaintext bytes");
+			return plaintext;
+		} catch (error) {
+			const reason = error instanceof PayloadProtectionError ? error.reason : "decrypt_failed";
+			throw new PayloadProtectionError(reason, payloadProtectionFailureMessage(reason));
+		}
 	}
 	assertPlaintextAllowed(label) {
 		if (this.readPolicy === "allow-plaintext") return;
@@ -352,62 +345,74 @@ function normalizePayloadProtection(options, label = "payloadProtection") {
 	const writePolicy = options.writePolicy ?? "encrypt";
 	if (readPolicy !== "encrypted-only" && readPolicy !== "allow-plaintext") throw new Error(`${label}.readPolicy must be encrypted-only or allow-plaintext`);
 	if (writePolicy !== "encrypt" && writePolicy !== "plaintext") throw new Error(`${label}.writePolicy must be encrypt or plaintext`);
-	const encryption = options.encryption;
-	if (encryption != null && encryption.scope == null) throw new Error(`${label}.encryption.scope is required when encryption is configured`);
-	if (writePolicy === "encrypt" && encryption?.writeKey == null) throw new Error(`${label}.encryption.writeKey is required when writePolicy is encrypt`);
-	if (writePolicy === "encrypt" && encryption?.scope == null) throw new Error(`${label}.encryption.scope is required when writePolicy is encrypt`);
-	validateKey(encryption?.writeKey, `${label}.encryption.writeKey`);
-	const readKeys = normalizeReadKeys(encryption?.readKeys, `${label}.encryption.readKeys`);
+	const provider = options.provider;
+	if (provider != null && (typeof provider.seal !== "function" || typeof provider.open !== "function" || !Number.isSafeInteger(provider.maxSealOverheadBytes) || provider.maxSealOverheadBytes < 0 || provider.maxSealOverheadBytes > MAX_PROVIDER_SEAL_OVERHEAD_BYTES)) throw new Error(`${label}.provider must implement seal()/open() and declare maxSealOverheadBytes as a safe integer from 0 through ${MAX_PROVIDER_SEAL_OVERHEAD_BYTES}`);
+	if (writePolicy === "encrypt" && provider == null) throw new Error(`${label}.provider is required when writePolicy is encrypt`);
 	return new PayloadProtectionRuntime({
 		readPolicy,
 		writePolicy,
-		scope: encryption?.scope,
-		writeKey: encryption?.writeKey,
-		readKeys
+		provider
 	});
 }
 function isPayloadProtectionError(error) {
 	return error instanceof PayloadProtectionError;
 }
+function payloadProtectionFailureMessage(reason) {
+	switch (reason) {
+		case "plaintext_forbidden": return "plaintext payload rejected by protected-read policy";
+		case "missing_read_key": return "protected payload key is unavailable";
+		case "decrypt_failed": return "protected payload authentication failed";
+		case "invalid_envelope": return "invalid protected payload envelope";
+		case "wrong_payload_kind": return "protected payload kind mismatch";
+		case "encrypt_failed": return "protected payload sealing failed";
+	}
+}
 function isEncryptedEnvelope(payload) {
 	return payload.byteLength >= MAGIC.byteLength && MAGIC.every((byte, index) => payload[index] === byte);
 }
-function createEnvelopeHeader(kind, keyId, nonce) {
-	const keyIdBytes = textEncoder$1.encode(keyId);
-	if (keyIdBytes.byteLength === 0 || keyIdBytes.byteLength > 255) throw new PayloadProtectionError("encrypt_failed", "E2EE key id must be 1..255 UTF-8 bytes", { keyId });
-	if (nonce.byteLength !== AES_GCM_NONCE_BYTES) throw new PayloadProtectionError("encrypt_failed", `AES-GCM nonce must be ${AES_GCM_NONCE_BYTES} bytes`, { keyId });
-	const header = new Uint8Array(HEADER_BYTES + keyIdBytes.byteLength + nonce.byteLength);
+function createProviderContext(kind) {
+	return {
+		protocol: PAYLOAD_PROTECTION_PROTOCOL,
+		version: PROVIDER_ENVELOPE_VERSION,
+		kind
+	};
+}
+function createProviderEnvelopeHeader(kind, providerHeader) {
+	const normalizedHeader = normalizeProviderHeader(providerHeader);
+	const header = new Uint8Array(PROVIDER_PREFIX_BYTES + normalizedHeader.byteLength);
+	const view = new DataView(header.buffer);
 	header.set(MAGIC, 0);
-	header[4] = ENVELOPE_VERSION;
+	header[4] = PROVIDER_ENVELOPE_VERSION;
 	header[5] = encodeKind(kind);
-	header[6] = SUITE_AES_256_GCM;
-	header[7] = keyIdBytes.byteLength;
-	header[8] = nonce.byteLength;
+	view.setUint16(6, normalizedHeader.byteLength, false);
+	header[8] = 0;
 	header[9] = 0;
-	header.set(keyIdBytes, HEADER_BYTES);
-	header.set(nonce, HEADER_BYTES + keyIdBytes.byteLength);
+	header.set(normalizedHeader, PROVIDER_PREFIX_BYTES);
 	return header;
 }
-function parseEnvelope(payload) {
-	if (!isEncryptedEnvelope(payload) || payload.byteLength < HEADER_BYTES) throw new PayloadProtectionError("invalid_envelope", "invalid streams-crdt encrypted payload envelope");
-	const version = payload[4];
-	const suite = payload[6];
-	const keyIdLen = payload[7] ?? 0;
-	const nonceLen = payload[8] ?? 0;
-	const reserved = payload[9];
-	if (version !== ENVELOPE_VERSION || suite !== SUITE_AES_256_GCM || nonceLen !== AES_GCM_NONCE_BYTES || reserved !== 0) throw new PayloadProtectionError("invalid_envelope", "unsupported streams-crdt encrypted payload envelope");
-	const kind = decodeKind(payload[5]);
-	const keyIdStart = HEADER_BYTES;
-	const nonceStart = keyIdStart + keyIdLen;
-	const ciphertextStart = nonceStart + nonceLen;
-	if (keyIdLen === 0 || payload.byteLength <= ciphertextStart) throw new PayloadProtectionError("invalid_envelope", "truncated streams-crdt encrypted payload envelope");
+function parseProviderEnvelope(payload) {
+	if (!isEncryptedEnvelope(payload) || payload.byteLength < PROVIDER_PREFIX_BYTES) throw new PayloadProtectionError("invalid_envelope", "invalid streams-crdt provider payload envelope");
+	const providerHeaderLength = new DataView(payload.buffer, payload.byteOffset, payload.byteLength).getUint16(6, false);
+	if (payload[4] !== PROVIDER_ENVELOPE_VERSION || providerHeaderLength === 0 || providerHeaderLength > MAX_PROVIDER_HEADER_BYTES || payload[8] !== 0 || payload[9] !== 0) throw new PayloadProtectionError("invalid_envelope", "unsupported streams-crdt provider payload envelope");
+	const headerEnd = PROVIDER_PREFIX_BYTES + providerHeaderLength;
+	if (payload.byteLength <= headerEnd) throw new PayloadProtectionError("invalid_envelope", "truncated streams-crdt provider payload envelope");
 	return {
-		kind,
-		keyId: textDecoder.decode(payload.slice(keyIdStart, nonceStart)),
-		nonce: payload.slice(nonceStart, ciphertextStart),
-		ciphertext: payload.slice(ciphertextStart)
+		kind: decodeKind(payload[5]),
+		header: payload.slice(PROVIDER_PREFIX_BYTES, headerEnd),
+		authenticatedHeader: payload.slice(0, headerEnd),
+		sealed: payload.slice(headerEnd)
 	};
 }
+function normalizeProviderHeader(header) {
+	if (!(header instanceof Uint8Array) || header.byteLength === 0 || header.byteLength > MAX_PROVIDER_HEADER_BYTES) throw new ProviderSealContractError(`payload protection provider header must be 1..${MAX_PROVIDER_HEADER_BYTES} bytes`);
+	return header;
+}
+function equalBytes(left, right) {
+	return left.byteLength === right.byteLength && left.every((byte, index) => byte === right[index]);
+}
+function createProviderAad(authenticatedHeader) {
+	return concatBytes(providerAadDomain, authenticatedHeader);
+}
 function encodeKind(kind) {
 	return kind === "update_batch" ? UPDATE_BATCH_KIND : SNAPSHOT_KIND;
 }
@@ -416,74 +421,18 @@ function decodeKind(encoded) {
 	if (encoded === SNAPSHOT_KIND) return "snapshot";
 	throw new PayloadProtectionError("invalid_envelope", "unsupported streams-crdt encrypted payload kind");
 }
-function createNonce() {
-	const nonce = new Uint8Array(AES_GCM_NONCE_BYTES);
-	getCrypto().getRandomValues(nonce);
-	return nonce;
-}
-function createAad(input) {
-	return textEncoder$1.encode(JSON.stringify({
-		keyId: input.keyId,
-		kind: input.kind,
-		protocol: "loro-streams-crdt-payload-protection",
-		scope: normalizeScope(input.scope),
-		suite: "aes_256_gcm",
-		version: ENVELOPE_VERSION
-	}));
-}
-function normalizeScope(scope) {
-	return typeof scope === "string" ? scope : `bucket:${scope.bucketId}\nstream:${scope.streamId}`;
-}
-function concatBytes(left, right) {
-	const out = new Uint8Array(left.byteLength + right.byteLength);
-	out.set(left);
-	out.set(right, left.byteLength);
+function concatBytes(...parts) {
+	const out = new Uint8Array(parts.reduce((length, part) => length + part.byteLength, 0));
+	let cursor = 0;
+	for (const part of parts) {
+		out.set(part, cursor);
+		cursor += part.byteLength;
+	}
 	return out;
 }
 function encodedItemsByteLength(items) {
 	return items.reduce((sum, item) => sum + 4 + item.byteLength, 0);
 }
-async function importAesGcmKey(key) {
-	if (isCryptoKey(key)) return key;
-	validateRawKey(key);
-	return await getSubtleCrypto().importKey("raw", toArrayBuffer(key), "AES-GCM", false, ["encrypt", "decrypt"]);
-}
-function toArrayBuffer(bytes) {
-	return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-}
-function validateKey(key, label) {
-	if (key == null) return;
-	if (key.id.trim().length === 0) throw new Error(`${label}.id must be non-empty`);
-	if (key.key instanceof Uint8Array) validateRawKey(key.key);
-}
-function normalizeReadKeys(readKeys, label) {
-	if (readKeys == null) return;
-	if (typeof readKeys === "function") return async () => {
-		const resolved = await readKeys();
-		validateKeys(resolved, label);
-		return resolved;
-	};
-	validateKeys(readKeys, label);
-	return readKeys;
-}
-function validateKeys(keys, label) {
-	for (const [index, key] of keys.entries()) validateKey(key, `${label}[${index}]`);
-}
-function isCryptoKey(key) {
-	return typeof CryptoKey !== "undefined" && key instanceof CryptoKey;
-}
-function validateRawKey(key) {
-	if (key.byteLength !== RAW_AES_256_KEY_BYTES) throw new Error(`E2EE raw AES-GCM keys must be ${RAW_AES_256_KEY_BYTES} bytes`);
-}
-function getCrypto() {
-	if (globalThis.crypto == null) throw new PayloadProtectionError("encrypt_failed", "Web Crypto is unavailable in this runtime");
-	return globalThis.crypto;
-}
-function getSubtleCrypto() {
-	const subtle = getCrypto().subtle;
-	if (subtle == null) throw new PayloadProtectionError("encrypt_failed", "SubtleCrypto is unavailable in this runtime");
-	return subtle;
-}
 //#endregion
 //#region src/transport-internal.ts
 function createProducerId() {
@@ -844,8 +793,7 @@ function toTransportError(error) {
 		code: "payload_protection_error",
 		retryable: false,
 		reason: error.reason,
-		keyId: error.keyId,
-		message: error.message
+		message: payloadProtectionFailureMessage(error.reason)
 	};
 	if (error instanceof TypeError) return {
 		code: "network_error",
@@ -2480,11 +2428,9 @@ var StreamsCrdt = class StreamsCrdt {
 		this.debug = options.debug ?? false;
 		this.beforeRemoteCursorSave = composeBeforeRemoteCursorSaveHooks(options.beforeRemoteCursorSave, ...options.beforeRemoteCursorSaveHooks ?? []);
 		const snapshotCodec = normalizeSnapshotCodec(options.snapshotCodec);
-		if (options.e2ee != null && options.payloadProtection != null) throw new Error("Specify only one of e2ee or payloadProtection");
-		const payloadProtectionOption = options.e2ee ?? options.payloadProtection;
-		const payloadProtectionLabel = options.e2ee != null ? "e2ee" : "payloadProtection";
-		const payloadProtection = normalizePayloadProtection(payloadProtectionOption, payloadProtectionLabel);
-		if (payloadProtection?.writePolicy === "plaintext" && options.snapshotUpload != null && options.snapshotUpload.enabled !== false) throw new Error(`snapshotUpload is not supported when ${payloadProtectionLabel}.writePolicy is plaintext`);
+		if (options.payloadProtectionRequired === true && options.e2ee == null) throw new Error("payloadProtectionRequired is true but this room has no e2ee config");
+		const payloadProtection = normalizePayloadProtection(options.e2ee, "e2ee");
+		if (payloadProtection?.writePolicy === "plaintext" && options.snapshotUpload != null && options.snapshotUpload.enabled !== false) throw new Error("snapshotUpload is not supported when e2ee.writePolicy is plaintext");
 		const snapshotUploadConfig = normalizeSnapshotUploadConfig(options.snapshotUpload);
 		this.decodeSnapshot = this.composeSnapshotDecoder(payloadProtection, snapshotCodec?.decompress);
 		this.encodeSnapshot = this.composeSnapshotEncoder(payloadProtection, snapshotCodec?.compress);
@@ -3987,33 +3933,16 @@ var StreamsCrdt = class StreamsCrdt {
 //#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()`.
+* Validates a Durable Streams stream id.
 */
 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)}`;
+	return id.length > 0 && utf8ByteLength(id) <= MAX_STREAM_ID_BYTES && id !== "." && !id.includes("/") && !id.includes("\0") && !id.includes("..");
 }
 //#endregion
-export { InMemoryRemoteCursorStore as a, EphemeralStreamCrdt as c, StreamsCrdt as i, LocalAppendFailedError as l, isValidBucketId as n, IndexedDbRemoteCursorStore as o, isValidRillId as r, createInitialRemoteCursor as s, createStreamUrl as t, PayloadProtectionError as u };
+export { createInitialRemoteCursor as a, PayloadProtectionError as c, IndexedDbRemoteCursorStore as i, StreamsCrdt as n, EphemeralStreamCrdt as o, InMemoryRemoteCursorStore as r, LocalAppendFailedError as s, isValidRillId as t };
 
-//# sourceMappingURL=stream-id-CEp4zEQJ.js.map
+//# sourceMappingURL=stream-id-CggbAC6b.js.map