@loro-dev/streams-crdt 0.6.1 → 0.7.0

package/README.md

@@ -20,7 +20,7 @@ Transport layer for synchronizing CRDT state over
 | `deleteStream()` | Deletes the stream. Closes any active `join()` first. |
 | `sync()` | One-shot bootstrap/catch-up cycle. Syncs remote state into local CRDT and pushes any local changes to the server. Does **not** enter live mode. |
 | `join()` | Initial sync **plus** live subscription. Internally performs the same sync as `sync()`, then enters a persistent SSE/long-poll read loop and starts forwarding local writes. No need to call `sync()` before `join()`. |
-| `close()` | Closes any active join and releases resources. |
+| `close()` | Closes any active join and releases resources. If this instance was using `appendWriteOnly()`, that write-only path is also torn down and cannot be used again on the same instance. |
 
 > **`join()` includes an initial sync.** You do not need to call `sync()` before
 > `join()`. When `join()` resolves, the local CRDT is already caught up with
@@ -210,6 +210,303 @@ const transport = new StreamsCrdt({
 If your callback already returns a fresh token every time, you can ignore the
 `context` argument.
 
+## End-to-End Encryption (E2EE)
+
+`e2ee` enables end-to-end encryption for CRDT update batches and snapshots
+before their bytes are appended to Durable Streams. Auth stays separate:
+gateway tokens authorize HTTP requests, while document keys protect document
+bytes from the server and unauthorized readers.
+
+`payloadProtection` remains available as a deprecated alias for compatibility.
+Do not pass both `e2ee` and `payloadProtection` on the same `StreamsCrdt`
+instance.
+
+When `e2ee` is omitted, streams-crdt keeps the current plaintext
+wire format. When it is present, the transport still uses
+`application/octet-stream`, but update batches and snapshots may carry an
+encrypted envelope inside the existing length-prefixed framing.
+
+For the design rationale and wire format, see
+[`docs/plans/2026-04-09-streams-crdt-payload-protection-design.md`](../../docs/plans/2026-04-09-streams-crdt-payload-protection-design.md).
+
+```ts
+const roomKey = new Uint8Array(32); // Load this from your own key store.
+crypto.getRandomValues(roomKey);
+
+const transport = new StreamsCrdt({
+  streamUrl,
+  adapter: createLoroDocAdapter(doc),
+  e2ee: {
+    // Defaults when e2ee is present:
+    readPolicy: "encrypted-only",
+    writePolicy: "encrypt",
+    encryption: {
+      // Stable application identity. Prefer bucket/stream identity over a full
+      // gateway URL so proxy/host changes do not break decryption.
+      scope: { bucketId: "my-bucket", streamId: "doc-1" },
+      writeKey: { id: "room-key-v1", key: roomKey },
+      // Optional. When omitted, writeKey is also the only read key.
+      readKeys: async () => [{ id: "room-key-v1", key: roomKey }],
+    },
+  },
+});
+```
+
+Encrypted streams still use `application/octet-stream`. The transport keeps a
+plaintext length-prefix frame around each encrypted envelope, so catch-up reads
+can concatenate several appends and clients can still recover payload
+boundaries.
+
+### E2EE Protocol Summary
+
+E2EE wraps the existing transport framing; it does not replace it.
+
+Encrypted update appends use this pipeline:
+
+```text
+adapter.exportUpdates()
+  -> encodeItems(clearUpdates)
+  -> encrypt(kind = "update_batch")
+  -> encodeItems([encryptedEnvelope])
+  -> POST body
+```
+
+Encrypted snapshots use:
+
+```text
+exportSnapshot -> snapshotCodec.compress -> encrypt(kind = "snapshot")
+decrypt(kind = "snapshot") -> snapshotCodec.decompress -> applySnapshot
+```
+
+Envelope v1 is:
+
+```text
+magic               4 bytes   "LSCE"
+version             1 byte    0x01
+kind                1 byte    0x01 update_batch, 0x02 snapshot
+suite               1 byte    0x01 aes_256_gcm
+key_id_len          1 byte
+nonce_len           1 byte    expected 12
+reserved            1 byte    0
+key_id              key_id_len bytes, UTF-8
+nonce               nonce_len bytes
+ciphertext_and_tag  remaining bytes
+```
+
+AEAD additional authenticated data (AAD) is constructed from stable local
+context:
+
+```json
+{
+  "protocol": "loro-streams-crdt-payload-protection",
+  "version": 1,
+  "kind": "update_batch",
+  "suite": "aes_256_gcm",
+  "keyId": "room-key-v1",
+  "scope": { "bucketId": "my-bucket", "streamId": "doc-1" }
+}
+```
+
+AAD is not stored as a separate field on the wire. Parts of it live in the
+envelope header; `scope` comes from the local `e2ee.encryption.scope`
+config. Keep `scope` stable and avoid full gateway URLs, otherwise old encrypted
+history may become unreadable after host or proxy changes.
+
+### Mode Matrix
+
+`e2ee` supports a few distinct shapes. Choose one explicitly:
+
+| Use case | `readPolicy` | `writePolicy` | Required encryption config | Remote plaintext accepted? | Local writes sent as |
+| --- | --- | --- | --- | --- | --- |
+| Existing plaintext stream | omitted | omitted | none | Yes | plaintext |
+| Private reader/writer | `encrypted-only` (default) | `encrypt` (default) | `scope` + `writeKey` | No | encrypted |
+| Mixed private reader/writer | `allow-plaintext` | `encrypt` | `scope` + `writeKey` | Yes | encrypted |
+| Public write-only writer | `allow-plaintext` | `plaintext` | none | Yes | plaintext via `appendWriteOnly()` |
+| Encrypted reader without a write key | `encrypted-only` | `plaintext` | `scope` + `readKeys` | No | plaintext if local writes are exported |
+
+There is no separate transport-level "read-only mode" in v1. The last row is
+only appropriate when the local CRDT is treated as read-only or the caller's
+auth rejects writes. `writePolicy: "plaintext"` avoids requiring a write key; it
+does not suppress local export attempts by itself.
+
+### Adapter Compatibility: Loro and Flock
+
+`e2ee` is adapter-agnostic at the transport layer: the same
+options shape works with `createLoroDocAdapter(doc)` and `createFlockAdapter(flock)`.
+Encryption wraps the CRDT payload bytes that the adapter already exports.
+
+That also means one stream must use exactly one CRDT family:
+
+- A stream written with the Loro adapter must be read with the Loro adapter.
+- A stream written with the Flock adapter must be read with the Flock adapter.
+- Do not mix Loro and Flock replicas against the same stream, whether payload
+  protection is enabled or not. The decrypted inner update bytes and snapshots
+  are CRDT-specific and are not cross-compatible.
+
+Protected Loro room:
+
+```ts
+import { LoroDoc } from "loro-crdt";
+import {
+  createLoroDocAdapter,
+  StreamsCrdt,
+} from "@loro-dev/streams-crdt/loro";
+
+const doc = new LoroDoc();
+const loroTransport = new StreamsCrdt({
+  streamUrl,
+  adapter: createLoroDocAdapter(doc),
+  e2ee: {
+    encryption: {
+      scope: { bucketId: "my-bucket", streamId: "doc-1" },
+      writeKey: { id: "room-key-v1", key: roomKey },
+    },
+  },
+});
+```
+
+Protected Flock room:
+
+```ts
+import { Flock } from "@loro-dev/flock-wasm";
+import {
+  createFlockAdapter,
+  StreamsCrdt,
+} from "@loro-dev/streams-crdt/flock";
+
+const flock = new Flock();
+const flockTransport = new StreamsCrdt({
+  streamUrl,
+  adapter: createFlockAdapter(flock),
+  e2ee: {
+    encryption: {
+      scope: { bucketId: "my-bucket", streamId: "room-1" },
+      writeKey: { id: "room-key-v1", key: roomKey },
+    },
+  },
+});
+```
+
+If one application stack uses Loro and another uses Flock, give them separate
+streams. Reusing the same key material across those streams is an application
+decision; it does not make the CRDT payloads interoperable.
+
+### Private E2EE Room
+
+This is the default protected mode: all retained updates and snapshots are
+encrypted, and readers reject any plaintext payload that appears in the stream.
+
+```ts
+const privateReaderWriter = new StreamsCrdt({
+  streamUrl,
+  adapter: createLoroDocAdapter(doc),
+  e2ee: {
+    encryption: {
+      scope: { bucketId: "my-bucket", streamId: "doc-1" },
+      writeKey: { id: "private-v1", key: roomKey },
+      // Optional. Keep old keys here during rotation.
+      readKeys: async () => [{ id: "private-v1", key: roomKey }],
+    },
+  },
+});
+```
+
+### Mixed Plaintext and Encrypted Updates
+
+Some applications intentionally allow public writers to append CRDT updates but
+not read private history. Configure readers explicitly before accepting those
+plaintext updates:
+
+```ts
+const privateReaderWriter = new StreamsCrdt({
+  streamUrl,
+  adapter: createLoroDocAdapter(doc),
+  e2ee: {
+    readPolicy: "allow-plaintext",
+    writePolicy: "encrypt",
+    encryption: {
+      scope: { bucketId: "my-bucket", streamId: "doc-1" },
+      writeKey: { id: "private-v1", key: roomKey },
+    },
+  },
+});
+```
+
+Plaintext writers should opt in just as explicitly:
+
+```ts
+const publicWriter = new StreamsCrdt({
+  streamUrl,
+  adapter: createLoroDocAdapter(publicDoc),
+  auth: async () => getWriteOnlyToken(),
+  e2ee: {
+    readPolicy: "allow-plaintext",
+    writePolicy: "plaintext",
+  },
+});
+
+publicDoc.getText("comments").insert(0, "public note");
+const appended = await publicWriter.appendWriteOnly();
+```
+
+### Behavior and Validation Rules
+
+- If `e2ee` is present and no policies are specified, the defaults
+  are `readPolicy: "encrypted-only"` and `writePolicy: "encrypt"`.
+- `writePolicy: "encrypt"` requires `e2ee.encryption.scope` and
+  `e2ee.encryption.writeKey`.
+- Any client that needs to decrypt encrypted payloads must provide
+  `e2ee.encryption.scope` plus at least one read key. If
+  `readKeys` is omitted, the current `writeKey` is also used as the only read
+  key.
+- `payloadProtection` is a deprecated alias for `e2ee`. Passing both is an
+  error.
+- `appendWriteOnly()` is the write-only path. It only posts local CRDT batches
+  that this transport observed after construction. It does not bootstrap, catch
+  up, join SSE, upload snapshots, apply remote updates, or persist a remote
+  cursor.
+- `appendWriteOnly()` must not be mixed with `sync()` or `join()` on the same
+  transport instance.
+- After `close()`, `appendWriteOnly()` is permanently unavailable on that
+  instance because the write-only subscription has been released. Create a new
+  `StreamsCrdt` instance for later write-only use.
+- Snapshot uploads are encrypted when `writePolicy` is `"encrypt"`. Snapshot
+  upload is rejected when `writePolicy` is `"plaintext"`; a public writer that
+  cannot read private state should not publish full-document snapshots.
+- Protected read failures stop before `applySnapshot()`,
+  `applyRemoteUpdates()`, local durability hooks, or remote cursor persistence.
+- Writers always encrypt with the current `writeKey`. Keep old keys in
+  `readKeys` until retained encrypted history and encrypted snapshots no longer
+  reference them.
+- Encryption adds envelope overhead. The transport enforces the 256 KB batch
+  cap against the encoded on-wire bytes, so a batch near the limit may split
+  earlier under encryption than it would in plaintext mode.
+
+If `e2ee` is configured and `readPolicy` is left at the default
+`"encrypted-only"`, remote plaintext updates fail with
+`code: "payload_protection_error"` and `reason: "plaintext_forbidden"`.
+
+### E2EE Errors
+
+E2EE-related transport failures surface as
+`code: "payload_protection_error"` with one of these reasons:
+
+| Reason | Meaning |
+| --- | --- |
+| `plaintext_forbidden` | A reader configured as `encrypted-only` saw plaintext data in the stream. |
+| `missing_read_key` | The envelope `keyId` does not exist in the configured `readKeys`. |
+| `decrypt_failed` | AES-GCM authentication failed. This usually means the wrong key, wrong scope, or tampered/corrupted bytes. |
+| `invalid_envelope` | The payload was not a supported streams-crdt encrypted envelope. |
+| `wrong_payload_kind` | An encrypted snapshot was used where an update batch was expected, or the reverse. |
+| `encrypt_failed` | Local write-side encryption could not proceed because the key/config/input was invalid. |
+
+Callers usually treat these as operator or configuration errors, not transient
+network failures. They are always returned as `retryable: false`.
+
+E2EE does **not** hide stream URLs, offsets, payload sizes, timing
+or auth metadata, and it does not detect a malicious server rolling back or
+forking history.
+
 ## Remote Cursor Store
 
 The `RemoteCursorStore` persists **replay progress metadata only** — it does
@@ -473,6 +770,13 @@ const transport = new StreamsCrdt({
 - `TransportSubscription` — active live subscription handle
 - `TransportRoomStatus` — `"joined" | "reconnecting" | "disconnected" | "error"`
 - `SnapshotCodec`, `SnapshotTransformHook` — full snapshot encode/decode hooks
+- `WriteOnlyAppendResult` — result returned by `appendWriteOnly()`
+- `E2eeError` — local error class thrown by low-level E2EE helpers before
+  conversion into `TransportError`
+- `E2eeOptions`, `E2eeKey`, `E2eeScope`, `E2eeEncryptionOptions`
+  — E2EE configuration types
+- `PayloadProtectionError`, `PayloadProtectionOptions`, `PayloadProtectionKey`,
+  `PayloadProtectionScope` — deprecated compatibility aliases
 - `SnapshotUploadOptions` — snapshot upload configuration
 - `RemoteCursor` — replay progress metadata
 - `RemoteCursorStore` — abstract cursor storage interface

package/dist/flock.d.ts

@@ -1,4 +1,4 @@
-import { A as RemoteCursorSaveSource, C as TransportSyncSuccess, D as IndexedDbRemoteCursorStore, E as InMemoryRemoteCursorStore, M as createInitialRemoteCursor, O as IndexedDbRemoteCursorStoreOptions, S as TransportSubscription, T as BeforeRemoteCursorSaveHook, _ as TransportCreateStreamSuccess, a as CrdtAdapter, b as TransportJoinParams, c as JsonObject, d as SnapshotCodec, f as SnapshotTransformHook, g as StreamsCrdtOptions, h as StreamsAuthProvider, i as StreamsCrdt, j as RemoteCursorStore, k as RemoteCursor, l as JsonValue, m as StreamsAuthContext, n as isValidBucketId, o as CrdtUpdateBatch, p as SnapshotUploadOptions, r as isValidRillId, s as IsolatedCrdtAdapter, t as createStreamUrl, u as Result, v as TransportDeleteStreamSuccess, w as BeforeRemoteCursorSaveContext, x as TransportRoomStatus, y as TransportError } from "./stream-id-Dr8ZBpUQ.js";
+import { A as StreamsAuthProvider, B as WriteOnlyAppendResult, C as PayloadProtectionScope, D as SnapshotTransformHook, E as SnapshotCodec, F as TransportJoinParams, G as IndexedDbRemoteCursorStoreOptions, H as BeforeRemoteCursorSaveHook, I as TransportRoomStatus, J as RemoteCursorStore, K as RemoteCursor, L as TransportSnapshotUploadSuccess, M as TransportCreateStreamSuccess, N as TransportDeleteStreamSuccess, O as SnapshotUploadOptions, P as TransportError, R as TransportSubscription, S as PayloadProtectionReadPolicy, T as Result, U as InMemoryRemoteCursorStore, V as BeforeRemoteCursorSaveContext, W as IndexedDbRemoteCursorStore, Y as createInitialRemoteCursor, _ as JsonValue, a as StreamsCrdt, b as PayloadProtectionKeyProvider, c as E2eeEncryptionOptions, d as E2eeOptions, f as E2eeReadPolicy, g as JsonObject, h as IsolatedCrdtAdapter, i as PayloadProtectionError, j as StreamsCrdtOptions, k as StreamsAuthContext, l as E2eeKey, m as E2eeWritePolicy, n as isValidBucketId, o as CrdtAdapter, p as E2eeScope, q as RemoteCursorSaveSource, r as isValidRillId, s as CrdtUpdateBatch, t as createStreamUrl, u as E2eeKeyProvider, v as PayloadProtectionEncryptionOptions, w as PayloadProtectionWritePolicy, x as PayloadProtectionOptions, y as PayloadProtectionKey, z as TransportSyncSuccess } from "./stream-id-CS7SzuLW.js";
 import { ExportBundle, Flock, VersionVector, VersionVector as VersionVector$1 } from "@loro-dev/flock-wasm";
 
 //#region src/flock.d.ts
@@ -7,5 +7,5 @@ import { ExportBundle, Flock, VersionVector, VersionVector as VersionVector$1 }
  */
 declare function createFlockAdapter(flock: Flock): CrdtAdapter<VersionVector$1>;
 //#endregion
-export { BeforeRemoteCursorSaveContext, BeforeRemoteCursorSaveHook, CrdtAdapter, CrdtUpdateBatch, type ExportBundle, InMemoryRemoteCursorStore, IndexedDbRemoteCursorStore, IndexedDbRemoteCursorStoreOptions, IsolatedCrdtAdapter, JsonObject, JsonValue, RemoteCursor, RemoteCursorSaveSource, RemoteCursorStore, Result, SnapshotCodec, SnapshotTransformHook, SnapshotUploadOptions, StreamsAuthContext, StreamsAuthProvider, StreamsCrdt, StreamsCrdtOptions, TransportCreateStreamSuccess, TransportDeleteStreamSuccess, TransportError, TransportJoinParams, TransportRoomStatus, TransportSubscription, TransportSyncSuccess, type VersionVector, createFlockAdapter, createInitialRemoteCursor, createStreamUrl, isValidBucketId, isValidRillId };
+export { BeforeRemoteCursorSaveContext, BeforeRemoteCursorSaveHook, CrdtAdapter, CrdtUpdateBatch, E2eeEncryptionOptions, PayloadProtectionError as E2eeError, PayloadProtectionError, E2eeKey, E2eeKeyProvider, E2eeOptions, E2eeReadPolicy, E2eeScope, E2eeWritePolicy, type ExportBundle, InMemoryRemoteCursorStore, IndexedDbRemoteCursorStore, IndexedDbRemoteCursorStoreOptions, IsolatedCrdtAdapter, JsonObject, JsonValue, PayloadProtectionEncryptionOptions, PayloadProtectionKey, PayloadProtectionKeyProvider, PayloadProtectionOptions, PayloadProtectionReadPolicy, PayloadProtectionScope, PayloadProtectionWritePolicy, RemoteCursor, RemoteCursorSaveSource, RemoteCursorStore, Result, SnapshotCodec, SnapshotTransformHook, SnapshotUploadOptions, StreamsAuthContext, StreamsAuthProvider, StreamsCrdt, StreamsCrdtOptions, TransportCreateStreamSuccess, TransportDeleteStreamSuccess, TransportError, TransportJoinParams, TransportRoomStatus, TransportSnapshotUploadSuccess, TransportSubscription, TransportSyncSuccess, type VersionVector, WriteOnlyAppendResult, createFlockAdapter, createInitialRemoteCursor, createStreamUrl, isValidBucketId, isValidRillId };
 //# sourceMappingURL=flock.d.ts.map

package/dist/flock.js

@@ -1,4 +1,4 @@
-import { a as InMemoryRemoteCursorStore, i as StreamsCrdt, n as isValidBucketId, o as IndexedDbRemoteCursorStore, r as isValidRillId, s as createInitialRemoteCursor, t as createStreamUrl } from "./stream-id-0dTFsiaO.js";
+import { a as PayloadProtectionError, c as createInitialRemoteCursor, i as StreamsCrdt, n as isValidBucketId, o as InMemoryRemoteCursorStore, r as isValidRillId, s as IndexedDbRemoteCursorStore, t as createStreamUrl } from "./stream-id-CbVwCS3g.js";
 import { Flock } from "@loro-dev/flock-wasm";
 //#region src/flock.ts
 function isAfter(entry, current) {
@@ -149,6 +149,6 @@ function createFlockAdapter(flock) {
 	};
 }
 //#endregion
-export { InMemoryRemoteCursorStore, IndexedDbRemoteCursorStore, StreamsCrdt, createFlockAdapter, createInitialRemoteCursor, createStreamUrl, isValidBucketId, isValidRillId };
+export { PayloadProtectionError as E2eeError, PayloadProtectionError, InMemoryRemoteCursorStore, IndexedDbRemoteCursorStore, StreamsCrdt, createFlockAdapter, createInitialRemoteCursor, createStreamUrl, isValidBucketId, isValidRillId };
 
 //# sourceMappingURL=flock.js.map

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { A as RemoteCursorSaveSource, C as TransportSyncSuccess, D as IndexedDbRemoteCursorStore, E as InMemoryRemoteCursorStore, M as createInitialRemoteCursor, O as IndexedDbRemoteCursorStoreOptions, S as TransportSubscription, T as BeforeRemoteCursorSaveHook, _ as TransportCreateStreamSuccess, a as CrdtAdapter, b as TransportJoinParams, c as JsonObject, d as SnapshotCodec, f as SnapshotTransformHook, g as StreamsCrdtOptions, h as StreamsAuthProvider, i as StreamsCrdt, j as RemoteCursorStore, k as RemoteCursor, l as JsonValue, m as StreamsAuthContext, n as isValidBucketId, o as CrdtUpdateBatch, p as SnapshotUploadOptions, r as isValidRillId, s as IsolatedCrdtAdapter, t as createStreamUrl, u as Result, v as TransportDeleteStreamSuccess, w as BeforeRemoteCursorSaveContext, x as TransportRoomStatus, y as TransportError } from "./stream-id-Dr8ZBpUQ.js";
-export { BeforeRemoteCursorSaveContext, BeforeRemoteCursorSaveHook, CrdtAdapter, CrdtUpdateBatch, InMemoryRemoteCursorStore, IndexedDbRemoteCursorStore, IndexedDbRemoteCursorStoreOptions, IsolatedCrdtAdapter, JsonObject, JsonValue, RemoteCursor, RemoteCursorSaveSource, RemoteCursorStore, Result, SnapshotCodec, SnapshotTransformHook, SnapshotUploadOptions, StreamsAuthContext, StreamsAuthProvider, StreamsCrdt, StreamsCrdtOptions, TransportCreateStreamSuccess, TransportDeleteStreamSuccess, TransportError, TransportJoinParams, TransportRoomStatus, TransportSubscription, TransportSyncSuccess, createInitialRemoteCursor, createStreamUrl, isValidBucketId, isValidRillId };
+import { A as StreamsAuthProvider, B as WriteOnlyAppendResult, C as PayloadProtectionScope, D as SnapshotTransformHook, E as SnapshotCodec, F as TransportJoinParams, G as IndexedDbRemoteCursorStoreOptions, H as BeforeRemoteCursorSaveHook, I as TransportRoomStatus, J as RemoteCursorStore, K as RemoteCursor, L as TransportSnapshotUploadSuccess, M as TransportCreateStreamSuccess, N as TransportDeleteStreamSuccess, O as SnapshotUploadOptions, P as TransportError, R as TransportSubscription, S as PayloadProtectionReadPolicy, T as Result, U as InMemoryRemoteCursorStore, V as BeforeRemoteCursorSaveContext, W as IndexedDbRemoteCursorStore, Y as createInitialRemoteCursor, _ as JsonValue, a as StreamsCrdt, b as PayloadProtectionKeyProvider, c as E2eeEncryptionOptions, d as E2eeOptions, f as E2eeReadPolicy, g as JsonObject, h as IsolatedCrdtAdapter, i as PayloadProtectionError, j as StreamsCrdtOptions, k as StreamsAuthContext, l as E2eeKey, m as E2eeWritePolicy, n as isValidBucketId, o as CrdtAdapter, p as E2eeScope, q as RemoteCursorSaveSource, r as isValidRillId, s as CrdtUpdateBatch, t as createStreamUrl, u as E2eeKeyProvider, v as PayloadProtectionEncryptionOptions, w as PayloadProtectionWritePolicy, x as PayloadProtectionOptions, y as PayloadProtectionKey, z as TransportSyncSuccess } from "./stream-id-CS7SzuLW.js";
+export { BeforeRemoteCursorSaveContext, BeforeRemoteCursorSaveHook, CrdtAdapter, CrdtUpdateBatch, E2eeEncryptionOptions, PayloadProtectionError as E2eeError, PayloadProtectionError, E2eeKey, E2eeKeyProvider, E2eeOptions, E2eeReadPolicy, E2eeScope, E2eeWritePolicy, InMemoryRemoteCursorStore, IndexedDbRemoteCursorStore, IndexedDbRemoteCursorStoreOptions, IsolatedCrdtAdapter, JsonObject, JsonValue, PayloadProtectionEncryptionOptions, PayloadProtectionKey, PayloadProtectionKeyProvider, PayloadProtectionOptions, PayloadProtectionReadPolicy, PayloadProtectionScope, PayloadProtectionWritePolicy, RemoteCursor, RemoteCursorSaveSource, RemoteCursorStore, Result, SnapshotCodec, SnapshotTransformHook, SnapshotUploadOptions, StreamsAuthContext, StreamsAuthProvider, StreamsCrdt, StreamsCrdtOptions, TransportCreateStreamSuccess, TransportDeleteStreamSuccess, TransportError, TransportJoinParams, TransportRoomStatus, TransportSnapshotUploadSuccess, TransportSubscription, TransportSyncSuccess, WriteOnlyAppendResult, createInitialRemoteCursor, createStreamUrl, isValidBucketId, isValidRillId };

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as InMemoryRemoteCursorStore, i as StreamsCrdt, n as isValidBucketId, o as IndexedDbRemoteCursorStore, r as isValidRillId, s as createInitialRemoteCursor, t as createStreamUrl } from "./stream-id-0dTFsiaO.js";
-export { InMemoryRemoteCursorStore, IndexedDbRemoteCursorStore, StreamsCrdt, createInitialRemoteCursor, createStreamUrl, isValidBucketId, isValidRillId };
+import { a as PayloadProtectionError, c as createInitialRemoteCursor, i as StreamsCrdt, n as isValidBucketId, o as InMemoryRemoteCursorStore, r as isValidRillId, s as IndexedDbRemoteCursorStore, t as createStreamUrl } from "./stream-id-CbVwCS3g.js";
+export { PayloadProtectionError as E2eeError, PayloadProtectionError, InMemoryRemoteCursorStore, IndexedDbRemoteCursorStore, StreamsCrdt, createInitialRemoteCursor, createStreamUrl, isValidBucketId, isValidRillId };

package/dist/loro.d.ts

@@ -1,4 +1,4 @@
-import { A as RemoteCursorSaveSource, C as TransportSyncSuccess, D as IndexedDbRemoteCursorStore, E as InMemoryRemoteCursorStore, M as createInitialRemoteCursor, O as IndexedDbRemoteCursorStoreOptions, S as TransportSubscription, T as BeforeRemoteCursorSaveHook, _ as TransportCreateStreamSuccess, a as CrdtAdapter, b as TransportJoinParams, c as JsonObject, d as SnapshotCodec, f as SnapshotTransformHook, g as StreamsCrdtOptions, h as StreamsAuthProvider, i as StreamsCrdt, j as RemoteCursorStore, k as RemoteCursor, l as JsonValue, m as StreamsAuthContext, n as isValidBucketId, o as CrdtUpdateBatch, p as SnapshotUploadOptions, r as isValidRillId, s as IsolatedCrdtAdapter, t as createStreamUrl, u as Result, v as TransportDeleteStreamSuccess, w as BeforeRemoteCursorSaveContext, x as TransportRoomStatus, y as TransportError } from "./stream-id-Dr8ZBpUQ.js";
+import { A as StreamsAuthProvider, B as WriteOnlyAppendResult, C as PayloadProtectionScope, D as SnapshotTransformHook, E as SnapshotCodec, F as TransportJoinParams, G as IndexedDbRemoteCursorStoreOptions, H as BeforeRemoteCursorSaveHook, I as TransportRoomStatus, J as RemoteCursorStore, K as RemoteCursor, L as TransportSnapshotUploadSuccess, M as TransportCreateStreamSuccess, N as TransportDeleteStreamSuccess, O as SnapshotUploadOptions, P as TransportError, R as TransportSubscription, S as PayloadProtectionReadPolicy, T as Result, U as InMemoryRemoteCursorStore, V as BeforeRemoteCursorSaveContext, W as IndexedDbRemoteCursorStore, Y as createInitialRemoteCursor, _ as JsonValue, a as StreamsCrdt, b as PayloadProtectionKeyProvider, c as E2eeEncryptionOptions, d as E2eeOptions, f as E2eeReadPolicy, g as JsonObject, h as IsolatedCrdtAdapter, i as PayloadProtectionError, j as StreamsCrdtOptions, k as StreamsAuthContext, l as E2eeKey, m as E2eeWritePolicy, n as isValidBucketId, o as CrdtAdapter, p as E2eeScope, q as RemoteCursorSaveSource, r as isValidRillId, s as CrdtUpdateBatch, t as createStreamUrl, u as E2eeKeyProvider, v as PayloadProtectionEncryptionOptions, w as PayloadProtectionWritePolicy, x as PayloadProtectionOptions, y as PayloadProtectionKey, z as TransportSyncSuccess } from "./stream-id-CS7SzuLW.js";
 import { LoroDoc } from "loro-crdt";
 
 //#region src/loro.d.ts
@@ -18,5 +18,5 @@ import { LoroDoc } from "loro-crdt";
  */
 declare function createLoroDocAdapter(doc: LoroDoc): CrdtAdapter<JsonObject>;
 //#endregion
-export { BeforeRemoteCursorSaveContext, BeforeRemoteCursorSaveHook, CrdtAdapter, CrdtUpdateBatch, InMemoryRemoteCursorStore, IndexedDbRemoteCursorStore, IndexedDbRemoteCursorStoreOptions, IsolatedCrdtAdapter, JsonObject, JsonValue, RemoteCursor, RemoteCursorSaveSource, RemoteCursorStore, Result, SnapshotCodec, SnapshotTransformHook, SnapshotUploadOptions, StreamsAuthContext, StreamsAuthProvider, StreamsCrdt, StreamsCrdtOptions, TransportCreateStreamSuccess, TransportDeleteStreamSuccess, TransportError, TransportJoinParams, TransportRoomStatus, TransportSubscription, TransportSyncSuccess, createInitialRemoteCursor, createLoroDocAdapter, createStreamUrl, isValidBucketId, isValidRillId };
+export { BeforeRemoteCursorSaveContext, BeforeRemoteCursorSaveHook, CrdtAdapter, CrdtUpdateBatch, E2eeEncryptionOptions, PayloadProtectionError as E2eeError, PayloadProtectionError, E2eeKey, E2eeKeyProvider, E2eeOptions, E2eeReadPolicy, E2eeScope, E2eeWritePolicy, InMemoryRemoteCursorStore, IndexedDbRemoteCursorStore, IndexedDbRemoteCursorStoreOptions, IsolatedCrdtAdapter, JsonObject, JsonValue, PayloadProtectionEncryptionOptions, PayloadProtectionKey, PayloadProtectionKeyProvider, PayloadProtectionOptions, PayloadProtectionReadPolicy, PayloadProtectionScope, PayloadProtectionWritePolicy, RemoteCursor, RemoteCursorSaveSource, RemoteCursorStore, Result, SnapshotCodec, SnapshotTransformHook, SnapshotUploadOptions, StreamsAuthContext, StreamsAuthProvider, StreamsCrdt, StreamsCrdtOptions, TransportCreateStreamSuccess, TransportDeleteStreamSuccess, TransportError, TransportJoinParams, TransportRoomStatus, TransportSnapshotUploadSuccess, TransportSubscription, TransportSyncSuccess, WriteOnlyAppendResult, createInitialRemoteCursor, createLoroDocAdapter, createStreamUrl, isValidBucketId, isValidRillId };
 //# sourceMappingURL=loro.d.ts.map

package/dist/loro.js

@@ -1,4 +1,4 @@
-import { a as InMemoryRemoteCursorStore, i as StreamsCrdt, n as isValidBucketId, o as IndexedDbRemoteCursorStore, r as isValidRillId, s as createInitialRemoteCursor, t as createStreamUrl } from "./stream-id-0dTFsiaO.js";
+import { a as PayloadProtectionError, c as createInitialRemoteCursor, i as StreamsCrdt, n as isValidBucketId, o as InMemoryRemoteCursorStore, r as isValidRillId, s as IndexedDbRemoteCursorStore, t as createStreamUrl } from "./stream-id-CbVwCS3g.js";
 import { LoroDoc, VersionVector, decodeImportBlobMeta } from "loro-crdt";
 //#region src/loro.ts
 function batchImportUpdates(doc, updates) {
@@ -126,6 +126,6 @@ function createLoroDocAdapter(doc) {
 	};
 }
 //#endregion
-export { InMemoryRemoteCursorStore, IndexedDbRemoteCursorStore, StreamsCrdt, createInitialRemoteCursor, createLoroDocAdapter, createStreamUrl, isValidBucketId, isValidRillId };
+export { PayloadProtectionError as E2eeError, PayloadProtectionError, InMemoryRemoteCursorStore, IndexedDbRemoteCursorStore, StreamsCrdt, createInitialRemoteCursor, createLoroDocAdapter, createStreamUrl, isValidBucketId, isValidRillId };
 
 //# sourceMappingURL=loro.js.map