@liveblocks/core 3.20.0-exp6 → 3.20.0-perm1

package/dist/index.js

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "3.20.0-exp6";
+var PKG_VERSION = "3.20.0-perm1";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -701,20 +701,6 @@ var SortedList = class _SortedList {
   get length() {
     return this.#data.length;
   }
-  /**
-   * Whether the given value is present, by identity. O(log n) plus the length
-   * of any run of items that share its sort key (normally 1). Bisects on the
-   * value's own key, so it only finds values sitting at their sorted position,
-   * which is true for any item currently in the list.
-   */
-  includes(value) {
-    for (let i = bisectRight(this.#data, value, this.#lt) - 1; i >= 0 && !this.#lt(this.#data[i], value); i--) {
-      if (this.#data[i] === value) {
-        return true;
-      }
-    }
-    return false;
-  }
   *filter(predicate) {
     for (const item of this.#data) {
       if (predicate(item)) {
@@ -1570,7 +1556,6 @@ function isUrl(string) {
 function createApiClient({
   baseUrl,
   authManager,
-  currentUserId,
   fetchPolyfill
 }) {
   const httpClient = new HttpClient(baseUrl, fetchPolyfill);
@@ -1578,8 +1563,9 @@ function createApiClient({
     const result = await httpClient.get(
       url`/v2/c/rooms/${options.roomId}/threads/delta`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "read"
       }),
       {
         since: options.since.toISOString()
@@ -1617,8 +1603,9 @@ function createApiClient({
       const result = await httpClient.get(
         url`/v2/c/rooms/${options.roomId}/threads`,
         await authManager.getAuthValue({
-          requestedScope: "comments:read",
-          roomId: options.roomId
+          roomId: options.roomId,
+          resource: "comments",
+          access: "read"
         }),
         {
           cursor: options.cursor,
@@ -1662,8 +1649,9 @@ function createApiClient({
     const result = await httpClient.get(
       url`/v2/c/rooms/${options.roomId}/threads/comments/search`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "read"
       }),
       {
         text: options.query.text,
@@ -1684,8 +1672,9 @@ function createApiClient({
     const thread = await httpClient.post(
       url`/v2/c/rooms/${options.roomId}/threads`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "write"
       }),
       {
         id: threadId,
@@ -1704,8 +1693,9 @@ function createApiClient({
     await httpClient.delete(
       url`/v2/c/rooms/${options.roomId}/threads/${options.threadId}`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "write"
       })
     );
   }
@@ -1713,8 +1703,9 @@ function createApiClient({
     const response = await httpClient.rawGet(
       url`/v2/c/rooms/${options.roomId}/thread-with-notification/${options.threadId}`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "read"
       })
     );
     if (response.ok) {
@@ -1740,8 +1731,9 @@ function createApiClient({
     return await httpClient.post(
       url`/v2/c/rooms/${options.roomId}/threads/${options.threadId}/metadata`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "write"
       }),
       options.metadata
     );
@@ -1750,8 +1742,9 @@ function createApiClient({
     return await httpClient.post(
       url`/v2/c/rooms/${options.roomId}/threads/${options.threadId}/comments/${options.commentId}/metadata`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "write"
       }),
       options.metadata
     );
@@ -1761,8 +1754,9 @@ function createApiClient({
     const comment = await httpClient.post(
       url`/v2/c/rooms/${options.roomId}/threads/${options.threadId}/comments`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "write"
       }),
       {
         id: commentId,
@@ -1777,8 +1771,9 @@ function createApiClient({
     const comment = await httpClient.post(
       url`/v2/c/rooms/${options.roomId}/threads/${options.threadId}/comments/${options.commentId}`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "write"
       }),
       {
         body: options.body,
@@ -1792,8 +1787,9 @@ function createApiClient({
     await httpClient.delete(
       url`/v2/c/rooms/${options.roomId}/threads/${options.threadId}/comments/${options.commentId}`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "write"
       })
     );
   }
@@ -1801,8 +1797,9 @@ function createApiClient({
     const reaction = await httpClient.post(
       url`/v2/c/rooms/${options.roomId}/threads/${options.threadId}/comments/${options.commentId}/reactions`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "write"
       }),
       { emoji: options.emoji }
     );
@@ -1812,8 +1809,9 @@ function createApiClient({
     await httpClient.delete(
       url`/v2/c/rooms/${options.roomId}/threads/${options.threadId}/comments/${options.commentId}/reactions/${options.emoji}`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "write"
       })
     );
   }
@@ -1821,8 +1819,9 @@ function createApiClient({
     await httpClient.post(
       url`/v2/c/rooms/${options.roomId}/threads/${options.threadId}/mark-as-resolved`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "write"
       })
     );
   }
@@ -1830,8 +1829,9 @@ function createApiClient({
     await httpClient.post(
       url`/v2/c/rooms/${options.roomId}/threads/${options.threadId}/mark-as-unresolved`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "write"
       })
     );
   }
@@ -1839,8 +1839,9 @@ function createApiClient({
     const subscription = await httpClient.post(
       url`/v2/c/rooms/${options.roomId}/threads/${options.threadId}/subscribe`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "read"
       })
     );
     return convertToSubscriptionData(subscription);
@@ -1849,8 +1850,9 @@ function createApiClient({
     await httpClient.post(
       url`/v2/c/rooms/${options.roomId}/threads/${options.threadId}/unsubscribe`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "read"
       })
     );
   }
@@ -1906,8 +1908,9 @@ function createApiClient({
         async () => httpClient.putBlob(
           url`/v2/c/rooms/${roomId}/attachments/${attachment.id}/upload/${encodeURIComponent(attachment.name)}`,
           await authManager.getAuthValue({
-            requestedScope: "comments:read",
-            roomId
+            roomId,
+            resource: "comments",
+            access: "write"
           }),
           attachment.file,
           { fileSize: attachment.size },
@@ -1924,8 +1927,9 @@ function createApiClient({
         async () => httpClient.post(
           url`/v2/c/rooms/${roomId}/attachments/${attachment.id}/multipart/${encodeURIComponent(attachment.name)}`,
           await authManager.getAuthValue({
-            requestedScope: "comments:read",
-            roomId
+            roomId,
+            resource: "comments",
+            access: "write"
           }),
           void 0,
           { signal: abortSignal },
@@ -1950,8 +1954,9 @@ function createApiClient({
                 async () => httpClient.putBlob(
                   url`/v2/c/rooms/${roomId}/attachments/${attachment.id}/multipart/${createMultiPartUpload.uploadId}/${String(partNumber)}`,
                   await authManager.getAuthValue({
-                    requestedScope: "comments:read",
-                    roomId
+                    roomId,
+                    resource: "comments",
+                    access: "write"
                   }),
                   part,
                   void 0,
@@ -1974,8 +1979,9 @@ function createApiClient({
         return httpClient.post(
           url`/v2/c/rooms/${roomId}/attachments/${attachment.id}/multipart/${uploadId}/complete`,
           await authManager.getAuthValue({
-            requestedScope: "comments:read",
-            roomId
+            roomId,
+            resource: "comments",
+            access: "write"
           }),
           { parts: sortedUploadedParts },
           { signal: abortSignal }
@@ -1986,8 +1992,9 @@ function createApiClient({
             await httpClient.rawDelete(
               url`/v2/c/rooms/${roomId}/attachments/${attachment.id}/multipart/${uploadId}`,
               await authManager.getAuthValue({
-                requestedScope: "comments:read",
-                roomId
+                roomId,
+                resource: "comments",
+                access: "write"
               })
             );
           } catch {
@@ -2004,8 +2011,9 @@ function createApiClient({
         const { urls } = await httpClient.post(
           url`/v2/c/rooms/${roomId}/attachments/presigned-urls`,
           await authManager.getAuthValue({
-            requestedScope: "comments:read",
-            roomId
+            roomId,
+            resource: "comments",
+            access: "read"
           }),
           { attachmentIds }
         );
@@ -2024,109 +2032,13 @@ function createApiClient({
     const batch2 = getOrCreateAttachmentUrlsStore(options.roomId).batch;
     return batch2.get(options.attachmentId);
   }
-  async function uploadChatAttachment(options) {
-    const { chatId, attachment, signal } = options;
-    const userId = currentUserId.get();
-    if (userId === void 0) {
-      throw new Error("Attachment upload requires an authenticated user.");
-    }
-    const ATTACHMENT_PART_SIZE = 5 * 1024 * 1024;
-    if (options.attachment.file.size <= ATTACHMENT_PART_SIZE) {
-      await httpClient.putBlob(
-        url`/v2/c/chats/${chatId}/attachments/${attachment.id}/upload/${encodeURIComponent(attachment.file.name)}`,
-        await authManager.getAuthValue({ requestedScope: "comments:read" }),
-        attachment.file,
-        { fileSize: attachment.file.size },
-        { signal }
-      );
-    } else {
-      const multipartUpload = await httpClient.post(
-        url`/v2/c/chats/${chatId}/attachments/${attachment.id}/multipart/${encodeURIComponent(attachment.file.name)}`,
-        await authManager.getAuthValue({ requestedScope: "comments:read" }),
-        void 0,
-        { signal },
-        { fileSize: attachment.file.size }
-      );
-      try {
-        const uploadedParts = [];
-        const parts = [];
-        let start = 0;
-        while (start < attachment.file.size) {
-          const end = Math.min(
-            start + ATTACHMENT_PART_SIZE,
-            attachment.file.size
-          );
-          parts.push({
-            number: parts.length + 1,
-            part: attachment.file.slice(start, end)
-          });
-          start = end;
-        }
-        uploadedParts.push(
-          ...await Promise.all(
-            parts.map(async ({ number, part }) => {
-              return await httpClient.putBlob(
-                url`/v2/c/chats/${chatId}/attachments/${attachment.id}/multipart/${multipartUpload.uploadId}/${String(number)}`,
-                await authManager.getAuthValue({
-                  requestedScope: "comments:read"
-                }),
-                part,
-                void 0,
-                { signal }
-              );
-            })
-          )
-        );
-        await httpClient.post(
-          url`/v2/c/chats/${chatId}/attachments/${attachment.id}/multipart/${multipartUpload.uploadId}/complete`,
-          await authManager.getAuthValue({ requestedScope: "comments:read" }),
-          { parts: uploadedParts.sort((a, b) => a.number - b.number) },
-          { signal }
-        );
-      } catch (err) {
-        try {
-          await httpClient.delete(
-            url`/v2/c/chats/${chatId}/attachments/${attachment.id}/multipart/${multipartUpload.uploadId}`,
-            await authManager.getAuthValue({ requestedScope: "comments:read" })
-          );
-        } catch {
-        }
-        throw err;
-      }
-    }
-  }
-  const attachmentUrlsBatchStoresByChat = new DefaultMap((chatId) => {
-    const batch2 = new Batch(
-      async (batchedAttachmentIds) => {
-        const attachmentIds = batchedAttachmentIds.flat();
-        const { urls } = await httpClient.post(
-          url`/v2/c/chats/${chatId}/attachments/presigned-urls`,
-          await authManager.getAuthValue({
-            requestedScope: "comments:read"
-          }),
-          { attachmentIds }
-        );
-        return urls.map(
-          (url2) => url2 ?? new Error("There was an error while getting this attachment's URL")
-        );
-      },
-      { delay: 50 }
-    );
-    return createBatchStore(batch2);
-  });
-  function getOrCreateChatAttachmentUrlsStore(chatId) {
-    return attachmentUrlsBatchStoresByChat.getOrCreate(chatId);
-  }
-  function getChatAttachmentUrl(options) {
-    const batch2 = getOrCreateChatAttachmentUrlsStore(options.chatId).batch;
-    return batch2.get(options.attachmentId);
-  }
   async function getSubscriptionSettings(options) {
     return httpClient.get(
       url`/v2/c/rooms/${options.roomId}/subscription-settings`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "read"
       }),
       void 0,
       {
@@ -2138,8 +2050,9 @@ function createApiClient({
     return httpClient.post(
       url`/v2/c/rooms/${options.roomId}/subscription-settings`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "comments",
+        access: "read"
       }),
       options.settings
     );
@@ -2151,8 +2064,9 @@ function createApiClient({
         await httpClient.post(
           url`/v2/c/rooms/${roomId}/inbox-notifications/read`,
           await authManager.getAuthValue({
-            requestedScope: "comments:read",
-            roomId
+            roomId,
+            resource: "comments",
+            access: "read"
           }),
           { inboxNotificationIds }
         );
@@ -2172,8 +2086,9 @@ function createApiClient({
     await httpClient.rawPost(
       url`/v2/c/rooms/${options.roomId}/text-mentions`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "storage",
+        access: "write"
       }),
       {
         userId: options.mention.kind === "user" ? options.mention.id : void 0,
@@ -2187,8 +2102,9 @@ function createApiClient({
     await httpClient.rawDelete(
       url`/v2/c/rooms/${options.roomId}/text-mentions/${options.mentionId}`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "storage",
+        access: "write"
       })
     );
   }
@@ -2196,8 +2112,9 @@ function createApiClient({
     return httpClient.rawGet(
       url`/v2/c/rooms/${options.roomId}/y-version/${options.versionId}`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "storage",
+        access: "read"
       })
     );
   }
@@ -2205,8 +2122,9 @@ function createApiClient({
     await httpClient.rawPost(
       url`/v2/c/rooms/${options.roomId}/version`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "storage",
+        access: "write"
       })
     );
   }
@@ -2214,8 +2132,9 @@ function createApiClient({
     await httpClient.rawPost(
       url`/v2/c/rooms/${options.roomId}/text-metadata`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "storage",
+        access: "read"
       }),
       {
         type: options.type,
@@ -2227,8 +2146,9 @@ function createApiClient({
     const result = await httpClient.post(
       url`/v2/c/rooms/${options.roomId}/ai/contextual-prompt`,
       await authManager.getAuthValue({
-        requestedScope: "room:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "storage",
+        access: "read"
       }),
       {
         prompt: options.prompt,
@@ -2250,8 +2170,9 @@ function createApiClient({
     const result = await httpClient.get(
       url`/v2/c/rooms/${options.roomId}/versions`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "storage",
+        access: "read"
       })
     );
     return {
@@ -2268,8 +2189,9 @@ function createApiClient({
     const result = await httpClient.get(
       url`/v2/c/rooms/${options.roomId}/versions/delta`,
       await authManager.getAuthValue({
-        requestedScope: "comments:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "storage",
+        access: "read"
       }),
       { since: options.since.toISOString() },
       { signal: options.signal }
@@ -2288,8 +2210,9 @@ function createApiClient({
     const result = await httpClient.rawGet(
       url`/v2/c/rooms/${options.roomId}/storage`,
       await authManager.getAuthValue({
-        requestedScope: "room:read",
-        roomId: options.roomId
+        roomId: options.roomId,
+        resource: "storage",
+        access: "read"
       })
     );
     return await result.json();
@@ -2302,7 +2225,7 @@ function createApiClient({
     }
     const json = await httpClient.get(
       url`/v2/c/inbox-notifications`,
-      await authManager.getAuthValue({ requestedScope: "comments:read" }),
+      await authManager.getAuthValue({ resource: "personal", access: "write" }),
       {
         cursor: options?.cursor,
         limit: PAGE_SIZE,
@@ -2328,7 +2251,7 @@ function createApiClient({
     }
     const json = await httpClient.get(
       url`/v2/c/inbox-notifications/delta`,
-      await authManager.getAuthValue({ requestedScope: "comments:read" }),
+      await authManager.getAuthValue({ resource: "personal", access: "write" }),
       { since: options.since.toISOString(), query },
       { signal: options.signal }
     );
@@ -2357,7 +2280,7 @@ function createApiClient({
     }
     const { count } = await httpClient.get(
       url`/v2/c/inbox-notifications/count`,
-      await authManager.getAuthValue({ requestedScope: "comments:read" }),
+      await authManager.getAuthValue({ resource: "personal", access: "write" }),
       { query },
       { signal: options?.signal }
     );
@@ -2366,7 +2289,7 @@ function createApiClient({
   async function markAllInboxNotificationsAsRead() {
     await httpClient.post(
       url`/v2/c/inbox-notifications/read`,
-      await authManager.getAuthValue({ requestedScope: "comments:read" }),
+      await authManager.getAuthValue({ resource: "personal", access: "write" }),
       {
         inboxNotificationIds: "all"
       }
@@ -2375,7 +2298,7 @@ function createApiClient({
   async function markInboxNotificationsAsRead(inboxNotificationIds) {
     await httpClient.post(
       url`/v2/c/inbox-notifications/read`,
-      await authManager.getAuthValue({ requestedScope: "comments:read" }),
+      await authManager.getAuthValue({ resource: "personal", access: "write" }),
       {
         inboxNotificationIds
       }
@@ -2395,19 +2318,19 @@ function createApiClient({
   async function deleteAllInboxNotifications() {
     await httpClient.delete(
       url`/v2/c/inbox-notifications`,
-      await authManager.getAuthValue({ requestedScope: "comments:read" })
+      await authManager.getAuthValue({ resource: "personal", access: "write" })
     );
   }
   async function deleteInboxNotification(inboxNotificationId) {
     await httpClient.delete(
       url`/v2/c/inbox-notifications/${inboxNotificationId}`,
-      await authManager.getAuthValue({ requestedScope: "comments:read" })
+      await authManager.getAuthValue({ resource: "personal", access: "write" })
     );
   }
   async function getNotificationSettings(options) {
     return httpClient.get(
       url`/v2/c/notification-settings`,
-      await authManager.getAuthValue({ requestedScope: "comments:read" }),
+      await authManager.getAuthValue({ resource: "personal", access: "write" }),
       void 0,
       { signal: options?.signal }
     );
@@ -2415,7 +2338,7 @@ function createApiClient({
   async function updateNotificationSettings(settings) {
     return httpClient.post(
       url`/v2/c/notification-settings`,
-      await authManager.getAuthValue({ requestedScope: "comments:read" }),
+      await authManager.getAuthValue({ resource: "personal", access: "write" }),
       settings
     );
   }
@@ -2427,7 +2350,7 @@ function createApiClient({
     const PAGE_SIZE = 50;
     const json = await httpClient.get(
       url`/v2/c/threads`,
-      await authManager.getAuthValue({ requestedScope: "comments:read" }),
+      await authManager.getAuthValue({ resource: "personal", access: "write" }),
       {
         cursor: options?.cursor,
         query,
@@ -2448,7 +2371,7 @@ function createApiClient({
   async function getUserThreadsSince_experimental(options) {
     const json = await httpClient.get(
       url`/v2/c/threads/delta`,
-      await authManager.getAuthValue({ requestedScope: "comments:read" }),
+      await authManager.getAuthValue({ resource: "personal", access: "write" }),
       { since: options.since.toISOString() },
       { signal: options.signal }
     );
@@ -2477,7 +2400,8 @@ function createApiClient({
       const { groups: plainGroups } = await httpClient.post(
         url`/v2/c/groups/find`,
         await authManager.getAuthValue({
-          requestedScope: "comments:read"
+          resource: "personal",
+          access: "write"
         }),
         { groupIds }
       );
@@ -2496,7 +2420,7 @@ function createApiClient({
   async function getUrlMetadata(_url) {
     const { metadata } = await httpClient.get(
       url`/v2/c/urls/metadata`,
-      await authManager.getAuthValue({ requestedScope: "comments:read" }),
+      await authManager.getAuthValue({ resource: "personal", access: "write" }),
       { url: _url }
     );
     return metadata;
@@ -2536,10 +2460,6 @@ function createApiClient({
     getAttachmentUrl,
     uploadAttachment,
     getOrCreateAttachmentUrlsStore,
-    // User attachments
-    uploadChatAttachment,
-    getOrCreateChatAttachmentUrlsStore,
-    getChatAttachmentUrl,
     // Room storage
     streamStorage,
     // Notifications
@@ -5233,22 +5153,291 @@ function createReceivingToolInvocation(invocationId, name, partialArgsText = "")
   };
 }
 
-// src/protocol/AuthToken.ts
-var Permission = /* @__PURE__ */ ((Permission2) => {
-  Permission2["Read"] = "room:read";
-  Permission2["Write"] = "room:write";
-  Permission2["PresenceWrite"] = "room:presence:write";
-  Permission2["CommentsWrite"] = "comments:write";
-  Permission2["CommentsRead"] = "comments:read";
-  Permission2["FeedsWrite"] = "feeds:write";
-  return Permission2;
-})(Permission || {});
-function canWriteStorage(scopes) {
-  return scopes.includes("room:write" /* Write */);
-}
-function canComment(scopes) {
-  return scopes.includes("comments:write" /* CommentsWrite */) || scopes.includes("room:write" /* Write */);
+// src/protocol/Permissions.ts
+var Permission = {
+  /**
+   * Default permission for a room
+   */
+  RoomWrite: "room:write",
+  RoomRead: "room:read",
+  /**
+   * Presence (LiveRoom Websocket access)
+   */
+  RoomPresenceRead: "room:presence:read",
+  RoomPresenceNone: "room:presence:none",
+  /**
+   * Storage
+   */
+  RoomStorageRead: "room:storage:read",
+  RoomStorageWrite: "room:storage:write",
+  RoomStorageNone: "room:storage:none",
+  /**
+   * Comments
+   */
+  RoomCommentsWrite: "room:comments:write",
+  RoomCommentsRead: "room:comments:read",
+  RoomCommentsNone: "room:comments:none",
+  /**
+   * Feeds
+   */
+  RoomFeedsRead: "room:feeds:read",
+  RoomFeedsWrite: "room:feeds:write",
+  RoomFeedsNone: "room:feeds:none",
+  /**
+   * Legacy
+   */
+  LegacyRoomPresenceWrite: "room:presence:write",
+  LegacyCommentsWrite: "comments:write",
+  LegacyCommentsRead: "comments:read",
+  LegacyFeedsWrite: "feeds:write"
+};
+var ACCESS_LEVELS = [
+  "none",
+  "read",
+  "write"
+];
+var ACCESS_RANKS = {
+  none: 0,
+  read: 1,
+  write: 2
+};
+var NO_PERMISSION_CAPABILITIES = {
+  creation: "none",
+  presence: "none",
+  storage: "none",
+  comments: "none",
+  feeds: "none",
+  personal: "write"
+};
+var RESOURCE_PERMISSIONS = {
+  creation: {
+    read: [Permission.RoomRead],
+    write: [Permission.RoomWrite]
+  },
+  personal: {
+    write: []
+  },
+  presence: {
+    write: [Permission.LegacyRoomPresenceWrite],
+    read: [Permission.RoomPresenceRead],
+    none: [Permission.RoomPresenceNone]
+  },
+  storage: {
+    write: [Permission.RoomStorageWrite],
+    read: [Permission.RoomStorageRead],
+    none: [Permission.RoomStorageNone]
+  },
+  comments: {
+    write: [Permission.RoomCommentsWrite, Permission.LegacyCommentsWrite],
+    read: [Permission.RoomCommentsRead, Permission.LegacyCommentsRead],
+    none: [Permission.RoomCommentsNone]
+  },
+  feeds: {
+    write: [Permission.RoomFeedsWrite, Permission.LegacyFeedsWrite],
+    read: [Permission.RoomFeedsRead],
+    none: [Permission.RoomFeedsNone]
+  }
+};
+var DEFAULT_PERMISSION_RESOURCE = "creation";
+var ROOM_PERMISSION_RESOURCES = [
+  "presence",
+  "storage",
+  "comments",
+  "feeds"
+];
+function resolveResourceAccess(scopes, resource) {
+  const permissions = RESOURCE_PERMISSIONS[resource];
+  let resourceAccess;
+  for (const access of ACCESS_LEVELS) {
+    const scopedPermissions = permissions[access];
+    if (scopedPermissions !== void 0 && scopedPermissions.some((permission) => scopes.includes(permission))) {
+      resourceAccess = access;
+    }
+  }
+  return resourceAccess;
+}
+function resolveFullPermissionCapabilities(resolved) {
+  if (!resolved.hasDefaultPermission) {
+    return { ...NO_PERMISSION_CAPABILITIES, ...resolved.capabilities };
+  }
+  const capabilities = {
+    ...NO_PERMISSION_CAPABILITIES,
+    [DEFAULT_PERMISSION_RESOURCE]: resolved.baseAccess
+  };
+  for (const resource of ROOM_PERMISSION_RESOURCES) {
+    capabilities[resource] = resolved.capabilities[resource] ?? resolved.baseAccess;
+  }
+  return capabilities;
+}
+function permissionCapabilitiesFromScopes(scopes) {
+  return resolveFullPermissionCapabilities(
+    resolvePermissionCapabilities(scopes)
+  );
+}
+function resolvePermissionCapabilities(scopes) {
+  const hasDefaultPermission = scopes.includes(Permission.RoomWrite) || scopes.includes(Permission.RoomRead);
+  const baseAccess = scopes.includes(Permission.RoomWrite) ? "write" : scopes.includes(Permission.RoomRead) ? "read" : "none";
+  const capabilities = {};
+  for (const resource of ROOM_PERMISSION_RESOURCES) {
+    const access = resolveResourceAccess(scopes, resource);
+    if (access !== void 0) {
+      capabilities[resource] = access;
+    }
+  }
+  return { hasDefaultPermission, baseAccess, capabilities };
+}
+function hasPermissionCapability(scopes, resource, requiredAccess) {
+  const access = permissionCapabilitiesFromScopes(scopes)[resource];
+  return ACCESS_RANKS[access] >= ACCESS_RANKS[requiredAccess];
+}
+function hasPermissionCapabilityAccess(capabilities, resource, requiredAccess) {
+  const access = capabilities[resource] ?? "none";
+  return ACCESS_RANKS[access] >= ACCESS_RANKS[requiredAccess];
+}
+
+// src/permissions.ts
+var VALID_PERMISSIONS = new Set(Object.values(Permission));
+var DEFAULT_PERMISSIONS = [
+  Permission.RoomRead,
+  Permission.RoomWrite
+];
+var ROOM_PERMISSION_OBJECT_KEYS = /* @__PURE__ */ new Set([
+  "default",
+  ...ROOM_PERMISSION_RESOURCES
+]);
+var RESOURCE_SPECIFIC_PERMISSIONS_BY_RESOURCE = {
+  presence: Object.values(RESOURCE_PERMISSIONS.presence).flat(),
+  storage: Object.values(RESOURCE_PERMISSIONS.storage).flat(),
+  comments: Object.values(RESOURCE_PERMISSIONS.comments).flat(),
+  feeds: Object.values(RESOURCE_PERMISSIONS.feeds).flat()
+};
+var RESOURCE_SPECIFIC_PERMISSIONS = ROOM_PERMISSION_RESOURCES.flatMap(
+  (resource) => RESOURCE_SPECIFIC_PERMISSIONS_BY_RESOURCE[resource]
+);
+function permissionForAccessLevel(resource, access) {
+  const levels = RESOURCE_PERMISSIONS[resource];
+  const permissions = levels[access];
+  if (permissions === void 0 || permissions.length === 0) {
+    throw new Error(
+      `Invalid permission level for ${resource}: ${String(access)}`
+    );
+  }
+  return permissions[0];
+}
+function resolveRoomPermissionCapabilities(permissions, roomId) {
+  const matchedPermissions = permissions.filter(
+    (permission) => resourceMatchesRoomId(permission.resource, roomId)
+  );
+  if (matchedPermissions.length === 0) {
+    return void 0;
+  }
+  let hasDefaultPermission = false;
+  let baseAccess = "none";
+  const explicitCapabilities = {};
+  for (const permission of matchedPermissions) {
+    const resolved = resolvePermissionCapabilities(permission.scopes);
+    if (resolved.hasDefaultPermission) {
+      hasDefaultPermission = true;
+      baseAccess = strongestAccess(baseAccess, resolved.baseAccess);
+    }
+    for (const resource of ROOM_PERMISSION_RESOURCES) {
+      const access = resolved.capabilities[resource];
+      if (access !== void 0) {
+        explicitCapabilities[resource] = strongestAccess(
+          explicitCapabilities[resource] ?? "none",
+          access
+        );
+      }
+    }
+  }
+  return resolveFullPermissionCapabilities({
+    hasDefaultPermission,
+    baseAccess,
+    capabilities: explicitCapabilities
+  });
+}
+function isRoomPermissionArray(input) {
+  return Array.isArray(input);
+}
+function normalizeRoomPermissionInput(input) {
+  if (isRoomPermissionArray(input)) {
+    return input.map((permission) => {
+      if (!VALID_PERMISSIONS.has(permission)) {
+        throw new Error(`Not a valid permission: ${permission}`);
+      }
+      return permission;
+    });
+  }
+  return normalizeRoomPermissionObject(input);
+}
+function normalizeRoomPermissionObject(objectInput) {
+  for (const key of Object.keys(objectInput)) {
+    if (!ROOM_PERMISSION_OBJECT_KEYS.has(key)) {
+      throw new Error(`Unknown permission field: ${key}`);
+    }
+  }
+  const permissions = [];
+  if (objectInput.default !== void 0) {
+    permissions.push(
+      permissionForAccessLevel(DEFAULT_PERMISSION_RESOURCE, objectInput.default)
+    );
+  }
+  for (const resource of ROOM_PERMISSION_RESOURCES) {
+    const access = objectInput[resource];
+    if (access !== void 0) {
+      permissions.push(permissionForAccessLevel(resource, access));
+    }
+  }
+  if (permissions.length === 0) {
+    throw new Error("Permission object cannot be empty");
+  }
+  return permissions;
+}
+function normalizeRoomAccessesInput(input) {
+  if (input === void 0) {
+    return void 0;
+  }
+  return Object.fromEntries(
+    Object.entries(input).map(([id, permissions]) => [
+      id,
+      normalizeRoomPermissionInput(permissions)
+    ])
+  );
+}
+function normalizeRoomAccessesUpdateInput(input) {
+  if (input === void 0) {
+    return void 0;
+  }
+  return Object.fromEntries(
+    Object.entries(input).map(([id, permissions]) => [
+      id,
+      permissions === null ? null : normalizeRoomPermissionInput(permissions)
+    ])
+  );
 }
+function getRoomPermissionConflicts(permission) {
+  if (DEFAULT_PERMISSIONS.includes(permission)) {
+    return [...DEFAULT_PERMISSIONS, ...RESOURCE_SPECIFIC_PERMISSIONS];
+  }
+  for (const resource of ROOM_PERMISSION_RESOURCES) {
+    const permissions = RESOURCE_SPECIFIC_PERMISSIONS_BY_RESOURCE[resource];
+    if (permissions.includes(permission)) {
+      return permissions;
+    }
+  }
+  return [];
+}
+function strongestAccess(left, right) {
+  return ACCESS_RANKS[right] > ACCESS_RANKS[left] ? right : left;
+}
+function resourceMatchesRoomId(resource, roomId) {
+  if (resource.includes("*")) {
+    return roomId.startsWith(resource.replace("*", ""));
+  }
+  return resource === roomId;
+}
+
+// src/protocol/AuthToken.ts
 function isValidAuthTokenPayload(data) {
   return isPlainObject(data) && (data.k === "acc" /* ACCESS_TOKEN */ || data.k === "id" /* ID_TOKEN */);
 }
@@ -5287,47 +5476,22 @@ function createAuthManager(authOptions, onAuthenticate) {
   const authentication = prepareAuthentication(authOptions);
   const seenTokens = /* @__PURE__ */ new Set();
   const tokens = [];
-  const expiryTimes = [];
   const requestPromises = /* @__PURE__ */ new Map();
   function reset() {
     seenTokens.clear();
     tokens.length = 0;
-    expiryTimes.length = 0;
     requestPromises.clear();
   }
-  function hasCorrespondingScopes(requestedScope, scopes) {
-    if (requestedScope === "comments:read") {
-      return scopes.includes("comments:read" /* CommentsRead */) || scopes.includes("comments:write" /* CommentsWrite */) || scopes.includes("room:read" /* Read */) || scopes.includes("room:write" /* Write */);
-    } else if (requestedScope === "room:read") {
-      return scopes.includes("room:read" /* Read */) || scopes.includes("room:write" /* Write */);
-    }
-    return false;
-  }
   function getCachedToken(requestOptions) {
     const now2 = Math.ceil(Date.now() / 1e3);
     for (let i = tokens.length - 1; i >= 0; i--) {
-      const token = tokens[i];
-      const expiresAt = expiryTimes[i];
-      if (expiresAt <= now2) {
+      const cachedToken = tokens[i];
+      if (cachedToken.expiresAt <= now2) {
         tokens.splice(i, 1);
-        expiryTimes.splice(i, 1);
         continue;
       }
-      if (token.parsed.k === "id" /* ID_TOKEN */) {
-        return token;
-      } else if (token.parsed.k === "acc" /* ACCESS_TOKEN */) {
-        if (!requestOptions.roomId && Object.entries(token.parsed.perms).length === 0) {
-          return token;
-        }
-        for (const [resource, scopes] of Object.entries(token.parsed.perms)) {
-          if (!requestOptions.roomId) {
-            if (resource.includes("*") && hasCorrespondingScopes(requestOptions.requestedScope, scopes)) {
-              return token;
-            }
-          } else if (resource.includes("*") && requestOptions.roomId.startsWith(resource.replace("*", "")) || requestOptions.roomId === resource && hasCorrespondingScopes(requestOptions.requestedScope, scopes)) {
-            return token;
-          }
-        }
+      if (cachedTokenSatisfiesRequest(cachedToken, requestOptions)) {
+        return cachedToken.token;
       }
     }
     return void 0;
@@ -5385,11 +5549,12 @@ function createAuthManager(authOptions, onAuthenticate) {
       return { type: "secret", token: cachedToken };
     }
     let currentPromise;
-    if (requestOptions.roomId) {
-      currentPromise = requestPromises.get(requestOptions.roomId);
+    const requestKey = getAuthRequestKey(requestOptions);
+    if (requestKey !== void 0) {
+      currentPromise = requestPromises.get(requestKey);
       if (currentPromise === void 0) {
         currentPromise = makeAuthRequest(requestOptions);
-        requestPromises.set(requestOptions.roomId, currentPromise);
+        requestPromises.set(requestKey, currentPromise);
       }
     } else {
       currentPromise = requestPromises.get("liveblocks-user-token");
@@ -5403,12 +5568,12 @@ function createAuthManager(authOptions, onAuthenticate) {
       const BUFFER = 30;
       const expiresAt = Math.floor(Date.now() / 1e3) + (token.parsed.exp - token.parsed.iat) - BUFFER;
       seenTokens.add(token.raw);
-      tokens.push(token);
-      expiryTimes.push(expiresAt);
+      const cachedToken2 = makeCachedToken(token, expiresAt);
+      tokens.push(cachedToken2);
       return { type: "secret", token };
     } finally {
-      if (requestOptions.roomId) {
-        requestPromises.delete(requestOptions.roomId);
+      if (requestKey !== void 0) {
+        requestPromises.delete(requestKey);
       } else {
         requestPromises.delete("liveblocks-user-token");
       }
@@ -5419,6 +5584,48 @@ function createAuthManager(authOptions, onAuthenticate) {
     getAuthValue
   };
 }
+function getAuthRequestKey(request) {
+  if (request.roomId === void 0) {
+    return void 0;
+  }
+  return `${request.roomId}:${request.resource}:${request.access}`;
+}
+function makeCachedToken(token, expiresAt) {
+  if (token.parsed.k === "acc" /* ACCESS_TOKEN */) {
+    return {
+      token,
+      expiresAt,
+      permissions: getAuthTokenPermissionScopes(token.parsed.perms)
+    };
+  }
+  return { token, expiresAt };
+}
+function getAuthTokenPermissionScopes(permissions) {
+  return Object.entries(permissions).map(([resource, scopes]) => ({
+    resource,
+    scopes
+  }));
+}
+function cachedTokenSatisfiesRequest(cachedToken, request) {
+  if (cachedToken.token.parsed.k === "id" /* ID_TOKEN */) {
+    return true;
+  }
+  if (request.resource === "personal") {
+    return true;
+  }
+  if (request.roomId === void 0) {
+    return false;
+  }
+  const capabilities = resolveRoomPermissionCapabilities(
+    cachedToken.permissions ?? [],
+    request.roomId
+  );
+  return capabilities !== void 0 && hasPermissionCapabilityAccess(
+    capabilities,
+    request.resource,
+    request.access
+  );
+}
 function prepareAuthentication(authOptions) {
   const { publicApiKey, authEndpoint } = authOptions;
   if (authEndpoint !== void 0 && publicApiKey !== void 0) {
@@ -5511,24 +5718,18 @@ var OpCode = Object.freeze({
   DELETE_CRDT: 5,
   DELETE_OBJECT_KEY: 6,
   CREATE_MAP: 7,
-  CREATE_REGISTER: 8,
-  CREATE_TEXT: 9,
-  UPDATE_TEXT: 10
+  CREATE_REGISTER: 8
 });
 function isIgnoredOp(op) {
   return op.type === OpCode.DELETE_CRDT && op.id === "ACK";
 }
-function isCreateOp(op) {
-  return op.type === OpCode.CREATE_OBJECT || op.type === OpCode.CREATE_REGISTER || op.type === OpCode.CREATE_MAP || op.type === OpCode.CREATE_LIST;
-}
 
 // src/protocol/StorageNode.ts
 var CrdtType = Object.freeze({
   OBJECT: 0,
   LIST: 1,
   MAP: 2,
-  REGISTER: 3,
-  TEXT: 4
+  REGISTER: 3
 });
 function isRootStorageNode(node) {
   return node[0] === "root";
@@ -5545,9 +5746,6 @@ function isMapStorageNode(node) {
 function isRegisterStorageNode(node) {
   return node[1].type === CrdtType.REGISTER;
 }
-function isTextStorageNode(node) {
-  return node[1].type === CrdtType.TEXT;
-}
 function isCompactRootNode(node) {
   return node[0] === "root";
 }
@@ -5570,9 +5768,6 @@ function* compactNodesToNodeStream(compactNodes) {
       case CrdtType.REGISTER:
         yield [cnode[0], { type: CrdtType.REGISTER, parentId: cnode[2], parentKey: cnode[3], data: cnode[4] }];
         break;
-      case CrdtType.TEXT:
-        yield [cnode[0], { type: CrdtType.TEXT, parentId: cnode[2], parentKey: cnode[3], data: cnode[4], version: cnode[5] }];
-        break;
       default:
     }
   }
@@ -5601,17 +5796,6 @@ function* nodeStreamToCompactNodes(nodes) {
       const id = node[0];
       const crdt = node[1];
       yield [id, CrdtType.REGISTER, crdt.parentId, crdt.parentKey, crdt.data];
-    } else if (isTextStorageNode(node)) {
-      const id = node[0];
-      const crdt = node[1];
-      yield [
-        id,
-        CrdtType.TEXT,
-        crdt.parentId,
-        crdt.parentKey,
-        crdt.data,
-        crdt.version
-      ];
     } else {
     }
   }
@@ -5796,112 +5980,12 @@ function asPos(str) {
   return isPos(str) ? str : convertToPos(str);
 }
 
-// src/crdts/UnacknowledgedOps.ts
-var UnacknowledgedOps = class {
-  // opId -> op
-  #byOpId = /* @__PURE__ */ new Map();
-  // position -> (opId -> Create op)
-  #createOpsByPosition = /* @__PURE__ */ new Map();
-  // parentId -> (opId -> Create op)
-  #createOpsByParent = /* @__PURE__ */ new Map();
-  // opIds of pending ops that were in flight when a connection died, so the
-  // server may already have processed them. See isPossiblyStored().
-  #possiblyStoredOpIds = /* @__PURE__ */ new Set();
-  #posKey(parentId, parentKey) {
-    return `${parentId}
-${parentKey}`;
-  }
-  get size() {
-    return this.#byOpId.size;
-  }
-  /**
-   * Mark the given Op as still unacknowledged.
-   */
-  add(op) {
-    this.#byOpId.set(op.opId, op);
-    if (isCreateOp(op)) {
-      const posKey = this.#posKey(op.parentId, op.parentKey);
-      let atPosition = this.#createOpsByPosition.get(posKey);
-      if (atPosition === void 0) {
-        atPosition = /* @__PURE__ */ new Map();
-        this.#createOpsByPosition.set(posKey, atPosition);
-      }
-      atPosition.set(op.opId, op);
-      let inParent = this.#createOpsByParent.get(op.parentId);
-      if (inParent === void 0) {
-        inParent = /* @__PURE__ */ new Map();
-        this.#createOpsByParent.set(op.parentId, inParent);
-      }
-      inParent.set(op.opId, op);
-    }
-  }
-  /**
-   * Drop the op with the given opId from the set, because the server has
-   * acknowledged it (confirmed our own op, or signalled it was seen but
-   * ignored).
-   */
-  delete(opId) {
-    const op = this.#byOpId.get(opId);
-    if (op === void 0) {
-      return;
-    }
-    this.#byOpId.delete(opId);
-    this.#possiblyStoredOpIds.delete(opId);
-    if (isCreateOp(op)) {
-      const posKey = this.#posKey(op.parentId, op.parentKey);
-      const atPosition = this.#createOpsByPosition.get(posKey);
-      atPosition?.delete(opId);
-      if (atPosition !== void 0 && atPosition.size === 0) {
-        this.#createOpsByPosition.delete(posKey);
-      }
-      const inParent = this.#createOpsByParent.get(op.parentId);
-      inParent?.delete(opId);
-      if (inParent !== void 0 && inParent.size === 0) {
-        this.#createOpsByParent.delete(op.parentId);
-      }
-    }
-  }
-  /**
-   * The still-unacknowledged Create ops with the given `parentId` and
-   * `parentKey` (targeting one exact position), in dispatch order. O(1) lookup.
-   * Empty if none.
-   */
-  getByParentIdAndKey(parentId, parentKey) {
-    return this.#createOpsByPosition.get(this.#posKey(parentId, parentKey))?.values() ?? [];
-  }
-  /**
-   * The still-unacknowledged Create ops with the given `parentId` (across all
-   * positions), in dispatch order. O(1) lookup. Empty if none.
-   */
-  getByParentId(parentId) {
-    return this.#createOpsByParent.get(parentId)?.values() ?? [];
-  }
-  /** All still-unacknowledged ops, in dispatch order. */
-  values() {
-    return this.#byOpId.values();
-  }
-  isPossiblyStored(opId) {
-    return this.#possiblyStoredOpIds.has(opId);
-  }
-  /**
-   * Mark every currently pending op as possibly stored on the server. Called
-   * when the connection dies: all of these ops were in flight, and their
-   * (possibly lost) acks would have been the only way to know their fate.
-   */
-  markAllAsPossiblyStored() {
-    for (const opId of this.#byOpId.keys()) {
-      this.#possiblyStoredOpIds.add(opId);
-    }
-  }
-};
-
 // src/crdts/AbstractCrdt.ts
 function createManagedPool(roomId, options) {
   const {
     getCurrentConnectionId,
     onDispatch,
-    isStorageWritable = () => true,
-    unacknowledgedOps = new UnacknowledgedOps()
+    isStorageWritable = () => true
   } = options;
   let clock = 0;
   let opClock = 0;
@@ -5923,8 +6007,7 @@ function createManagedPool(roomId, options) {
           "Cannot write to storage with a read only user, please ensure the user has write permissions"
         );
       }
-    },
-    unacknowledgedOps
+    }
   };
 }
 function crdtAsLiveNode(value) {
@@ -6206,9 +6289,11 @@ function childNodeLt(a, b) {
 var LiveList = class _LiveList extends AbstractCrdt {
   #items;
   #implicitlyDeletedItems;
+  #unacknowledgedSets;
   constructor(items) {
     super();
     this.#implicitlyDeletedItems = /* @__PURE__ */ new WeakSet();
+    this.#unacknowledgedSets = /* @__PURE__ */ new Map();
     const nodes = [];
     let lastPos;
     for (const item of items) {
@@ -6238,13 +6323,12 @@ var LiveList = class _LiveList extends AbstractCrdt {
   }
   /**
    * @internal
-   * Serializes this list (and its children) into Create ops. Each child's
-   * create is tagged with the "set" intent (in the loop below) so that a list
-   * created and immediately mutated doesn't transiently re-show its initial
-   * items (flicker, https://github.com/liveblocks/liveblocks/pull/1177).
+   * This function assumes that the resulting ops will be sent to the server if they have an 'opId'
+   * so we mutate _unacknowledgedSets to avoid potential flickering
+   * https://github.com/liveblocks/liveblocks/pull/1177
    *
-   * This is quite unintuitive and should disappear as soon as we introduce an
-   * explicit LiveList.Set operation.
+   * This is quite unintuitive and should disappear as soon as
+   * we introduce an explicit LiveList.Set operation
    */
   _toOps(parentId, parentKey) {
     if (this._id === void 0) {
@@ -6260,9 +6344,9 @@ var LiveList = class _LiveList extends AbstractCrdt {
     ops.push(op);
     for (const item of this.#items) {
       const parentKey2 = item._getParentKeyOrThrow();
-      const childOps = addIntentToRootOp(
+      const childOps = HACK_addIntentAndDeletedIdToOperation(
         item._toOps(this._id, parentKey2),
-        "set"
+        void 0
       );
       for (const childOp of childOps) {
         ops.push(childOp);
@@ -6304,28 +6388,6 @@ var LiveList = class _LiveList extends AbstractCrdt {
       (item) => item._getParentKeyOrThrow() === position
     );
   }
-  /**
-   * The opId of this list's still-unacknowledged "set" op at the given position,
-   * or undefined if none. Derived from the room's unacknowledgedOps (the single
-   * source of truth) rather than tracked in a per-instance map. The pool's
-   * position index already scopes to this list's (parentId, position); the last
-   * match wins, matching the original last-write-wins map semantics.
-   */
-  #unacknowledgedSetOpIdAt(position) {
-    if (this._pool === void 0 || this._id === void 0) {
-      return void 0;
-    }
-    let opId;
-    for (const op of this._pool.unacknowledgedOps.getByParentIdAndKey(
-      this._id,
-      position
-    )) {
-      if (op.intent === "set") {
-        opId = op.opId;
-      }
-    }
-    return opId;
-  }
   /** @internal */
   _attach(id, pool) {
     super._attach(id, pool);
@@ -6406,9 +6468,13 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (deletedDelta) {
       delta.push(deletedDelta);
     }
-    const unacknowledgedOpId = this.#unacknowledgedSetOpIdAt(op.parentKey);
-    if (unacknowledgedOpId !== void 0 && unacknowledgedOpId !== op.opId) {
-      return delta.length === 0 ? { modified: false } : { modified: makeUpdate(this, delta), reverse: [] };
+    const unacknowledgedOpId = this.#unacknowledgedSets.get(op.parentKey);
+    if (unacknowledgedOpId !== void 0) {
+      if (unacknowledgedOpId !== op.opId) {
+        return delta.length === 0 ? { modified: false } : { modified: makeUpdate(this, delta), reverse: [] };
+      } else {
+        this.#unacknowledgedSets.delete(op.parentKey);
+      }
     }
     const indexOfItemWithSamePosition = this._indexOfPosition(op.parentKey);
     const existingItem = this.#items.find((item) => item._id === op.id);
@@ -6499,92 +6565,11 @@ var LiveList = class _LiveList extends AbstractCrdt {
       this.#shiftItemPosition(existingItemIndex, key);
     }
     const { newItem, newIndex } = this.#createAttachItemAndSort(op, key);
-    const bumpDeltas = this.#bumpUnackedPushesAbove(key);
     return {
-      modified: makeUpdate(this, [
-        insertDelta(newIndex, newItem),
-        ...bumpDeltas
-      ]),
+      modified: makeUpdate(this, [insertDelta(newIndex, newItem)]),
       reverse: []
     };
   }
-  /**
-   * This list's own still-unacknowledged pushed items (their `intent: "push"`
-   * Create op is still pending in the room's unacknowledgedOps). Derived from
-   * the single source of truth, so an item drops out the instant its op is
-   * acked, with no per-instance membership to leak. Yielded in push order.
-   *
-   * Excludes ops that may already be stored on the server (they were in
-   * flight when a connection died, so their fate is unknown): the bump
-   * prediction assumes the server has not processed the op yet, which is only
-   * guaranteed for ops sent on the current connection. For these excluded
-   * ops, the server's (re-)ack states the authoritative position; predicting
-   * locally could produce a wrong position that no ack would correct.
-   *
-   * Restricted to items currently in `#items`: a pushed node whose op is still
-   * pending may have been pulled out of the list (e.g. implicitly deleted by a
-   * remote set, or removed by an undo) while still living in the pool, and such
-   * a node must not be repositioned.
-   */
-  *#unackedPushNodes() {
-    if (this._pool === void 0 || this._id === void 0) {
-      return;
-    }
-    for (const op of this._pool.unacknowledgedOps.getByParentId(this._id)) {
-      if (op.intent !== "push") {
-        continue;
-      }
-      if (this._pool.unacknowledgedOps.isPossiblyStored(op.opId)) {
-        continue;
-      }
-      const node = this._pool.getNode(op.id);
-      if (node !== void 0 && this.#items.includes(node)) {
-        yield node;
-      }
-    }
-  }
-  /**
-   * Optimistic no-flip for pushed items. When a remote op lands at or below my
-   * still-unacked pushed items, those items must end up *after* it: FIFO plus
-   * the room's serial processing guarantee the remote was processed first, so
-   * my unacked pushes belong behind it. Re-chain the whole unacked-push block,
-   * in push order, to sit after the highest confirmed sibling, so it keeps
-   * rendering as a contiguous tail instead of getting interleaved. Local-only;
-   * the real acks overwrite these keys with the (identical) server keys.
-   */
-  #bumpUnackedPushesAbove(remoteKey) {
-    const pending = new Set(this.#unackedPushNodes());
-    if (pending.size === 0) {
-      return [];
-    }
-    let minPending;
-    for (const node of pending) {
-      const pos = node._parentPos;
-      if (minPending === void 0 || pos < minPending) {
-        minPending = pos;
-      }
-    }
-    if (remoteKey < nn(minPending)) {
-      return [];
-    }
-    let base;
-    for (const item of this.#items) {
-      if (!pending.has(item)) {
-        base = item._parentPos;
-      }
-    }
-    const deltas = [];
-    for (const node of pending) {
-      const previousIndex = this.#items.findIndex((item) => item === node);
-      base = makePosition(base);
-      this.#updateItemPosition(node, base);
-      const index = this.#items.findIndex((item) => item === node);
-      if (index !== previousIndex) {
-        deltas.push(moveDelta(previousIndex, index, node));
-      }
-    }
-    return deltas;
-  }
   #applyInsertAck(op) {
     const existingItem = this.#items.find((item) => item._id === op.id);
     const key = asPos(op.parentKey);
@@ -6665,6 +6650,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (this._pool?.getNode(id) !== void 0) {
       return { modified: false };
     }
+    this.#unacknowledgedSets.set(key, nn(op.opId));
     const indexOfItemWithSameKey = this._indexOfPosition(key);
     child._attach(id, nn(this._pool));
     child._setParentLink(this, key);
@@ -6674,9 +6660,8 @@ var LiveList = class _LiveList extends AbstractCrdt {
       existingItem._detach();
       this.#items.remove(existingItem);
       this.#items.add(child);
-      const reverse = addIntentToRootOp(
+      const reverse = HACK_addIntentAndDeletedIdToOperation(
         existingItem._toOps(nn(this._id), key),
-        "set",
         op.id
       );
       const delta = [setDelta(indexOfItemWithSameKey, child)];
@@ -6919,7 +6904,8 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param element The element to add to the end of the LiveList.
    */
   push(element) {
-    return this.#injectAt(element, this.length, "push");
+    this._pool?.assertStorageIsWritable();
+    return this.insert(element, this.length);
   }
   /**
    * Inserts one element at a specified index.
@@ -6927,15 +6913,6 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param index The index at which you want to insert the element.
    */
   insert(element, index) {
-    return this.#injectAt(element, index, "insert");
-  }
-  /**
-   * Shared implementation of `insert` and `push`. A `"push"` intent leaves the
-   * client-computed position untouched (so optimistic rendering is unchanged),
-   * but tags the Op so the server appends it to the true end of the list
-   * instead of resolving its position against the client's stale view.
-   */
-  #injectAt(element, index, intent) {
     this._pool?.assertStorageIsWritable();
     if (index < 0 || index > this.#items.length) {
       throw new Error(
@@ -6951,9 +6928,8 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (this._pool && this._id) {
       const id = this._pool.generateId();
       value._attach(id, this._pool);
-      const ops = value._toOpsWithOpId(this._id, position, this._pool);
       this._pool.dispatch(
-        intent === "push" ? addIntentToRootOp(ops, "push") : ops,
+        value._toOpsWithOpId(this._id, position, this._pool),
         [{ type: OpCode.DELETE_CRDT, id }],
         /* @__PURE__ */ new Map([
           [this._id, makeUpdate(this, [insertDelta(index, value)])]
@@ -7111,14 +7087,13 @@ var LiveList = class _LiveList extends AbstractCrdt {
       value._attach(id, this._pool);
       const storageUpdates = /* @__PURE__ */ new Map();
       storageUpdates.set(this._id, makeUpdate(this, [setDelta(index, value)]));
-      const ops = addIntentToRootOp(
+      const ops = HACK_addIntentAndDeletedIdToOperation(
         value._toOpsWithOpId(this._id, position, this._pool),
-        "set",
         existingId
       );
-      const reverseOps = addIntentToRootOp(
+      this.#unacknowledgedSets.set(position, nn(ops[0].opId));
+      const reverseOps = HACK_addIntentAndDeletedIdToOperation(
         existingItem._toOps(this._id, position),
-        "set",
         id
       );
       this._pool.dispatch(ops, reverseOps, storageUpdates);
@@ -7319,11 +7294,15 @@ function moveDelta(previousIndex, index, item) {
     previousIndex
   };
 }
-function addIntentToRootOp(ops, intent, deletedId) {
+function HACK_addIntentAndDeletedIdToOperation(ops, deletedId) {
   return ops.map((op, index) => {
     if (index === 0) {
       const firstOp = op;
-      return { ...firstOp, intent, deletedId };
+      return {
+        ...firstOp,
+        intent: "set",
+        deletedId
+      };
     } else {
       return op;
     }
@@ -7975,7 +7954,6 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
       const id = nn(this._id);
       const parentKey = nn(child._parentKey);
       const reverse = child._toOps(id, parentKey);
-      const deletedItem = liveNodeToLson(child);
       for (const [key, value] of this.#synced) {
         if (value === child) {
           this.#synced.delete(key);
@@ -7987,7 +7965,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
         node: this,
         type: "LiveObject",
         updates: {
-          [parentKey]: { type: "delete", deletedItem }
+          [parentKey]: { type: "delete" }
         }
       };
       return { modified: storageUpdate, reverse };
@@ -8474,580 +8452,6 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
   }
 };
 
-// src/crdts/liveTextOps.ts
-function attributesEqual(left, right) {
-  if (left === right) {
-    return true;
-  }
-  if (left === void 0 || right === void 0) {
-    return false;
-  }
-  const leftKeys = Object.keys(left);
-  const rightKeys = Object.keys(right);
-  if (leftKeys.length !== rightKeys.length) {
-    return false;
-  }
-  for (const key of leftKeys) {
-    if (left[key] !== right[key]) {
-      return false;
-    }
-  }
-  return true;
-}
-function cloneAttributes(attributes) {
-  return attributes === void 0 ? void 0 : freeze({ ...attributes });
-}
-function normalizeSegments(segments) {
-  const normalized = [];
-  for (const segment of segments) {
-    if (segment.text.length === 0) {
-      continue;
-    }
-    const last = normalized.at(-1);
-    const attributes = cloneAttributes(segment.attributes);
-    if (last !== void 0 && attributesEqual(last.attributes, attributes)) {
-      last.text += segment.text;
-    } else {
-      normalized.push({ text: segment.text, attributes });
-    }
-  }
-  return normalized;
-}
-function dataToSegments(data) {
-  return normalizeSegments(
-    data.map(([text, attributes]) => ({
-      text,
-      attributes
-    }))
-  );
-}
-function segmentsToData(segments) {
-  return segments.map(
-    (segment) => segment.attributes === void 0 ? [segment.text] : [segment.text, { ...segment.attributes }]
-  );
-}
-function textLength(segments) {
-  return segments.reduce((sum, segment) => sum + segment.text.length, 0);
-}
-function splitSegmentsAt(segments, index) {
-  const result = [];
-  let offset = 0;
-  for (const segment of segments) {
-    const end = offset + segment.text.length;
-    if (index > offset && index < end) {
-      const before2 = segment.text.slice(0, index - offset);
-      const after2 = segment.text.slice(index - offset);
-      result.push({ text: before2, attributes: segment.attributes });
-      result.push({ text: after2, attributes: segment.attributes });
-    } else {
-      result.push({ text: segment.text, attributes: segment.attributes });
-    }
-    offset = end;
-  }
-  return result;
-}
-function clipRange(index, length, contentLength) {
-  const clippedIndex = Math.max(0, Math.min(index, contentLength));
-  const clippedEnd = Math.max(
-    clippedIndex,
-    Math.min(index + length, contentLength)
-  );
-  return { index: clippedIndex, length: clippedEnd - clippedIndex };
-}
-function applyInsert(segments, index, text, attributes) {
-  if (text.length === 0) {
-    return normalizeSegments(segments);
-  }
-  const split = splitSegmentsAt(segments, index);
-  const result = [];
-  let offset = 0;
-  let inserted = false;
-  for (const segment of split) {
-    if (!inserted && offset === index) {
-      result.push({ text, attributes });
-      inserted = true;
-    }
-    result.push(segment);
-    offset += segment.text.length;
-  }
-  if (!inserted) {
-    result.push({ text, attributes });
-  }
-  return normalizeSegments(result);
-}
-function extractDeletedSegments(segments, index, length) {
-  const split = splitSegmentsAt(
-    splitSegmentsAt(segments, index),
-    index + length
-  );
-  const deleted = [];
-  let offset = 0;
-  for (const segment of split) {
-    const end = offset + segment.text.length;
-    if (offset >= index && end <= index + length) {
-      deleted.push({
-        text: segment.text,
-        attributes: segment.attributes
-      });
-    }
-    offset = end;
-  }
-  return normalizeSegments(deleted);
-}
-function applyDelete(segments, index, length) {
-  const deletedSegments = extractDeletedSegments(segments, index, length);
-  const split = splitSegmentsAt(
-    splitSegmentsAt(segments, index),
-    index + length
-  );
-  const result = [];
-  let offset = 0;
-  let deletedText = "";
-  for (const segment of split) {
-    const end = offset + segment.text.length;
-    if (offset >= index && end <= index + length) {
-      deletedText += segment.text;
-    } else {
-      result.push(segment);
-    }
-    offset = end;
-  }
-  return {
-    segments: normalizeSegments(result),
-    deletedText,
-    deletedSegments
-  };
-}
-function applyFormat(segments, index, length, attributes) {
-  const split = splitSegmentsAt(
-    splitSegmentsAt(segments, index),
-    index + length
-  );
-  const result = [];
-  let offset = 0;
-  for (const segment of split) {
-    const end = offset + segment.text.length;
-    if (offset >= index && end <= index + length) {
-      const nextAttributes = {
-        ...segment.attributes ?? {}
-      };
-      for (const [key, value] of Object.entries(attributes)) {
-        if (value === null) {
-          delete nextAttributes[key];
-        } else {
-          nextAttributes[key] = value;
-        }
-      }
-      result.push({
-        text: segment.text,
-        attributes: Object.keys(nextAttributes).length === 0 ? void 0 : freeze(nextAttributes)
-      });
-    } else {
-      result.push(segment);
-    }
-    offset = end;
-  }
-  return normalizeSegments(result);
-}
-function formatReverseOperations(segments, index, length, patch) {
-  const split = splitSegmentsAt(
-    splitSegmentsAt(segments, index),
-    index + length
-  );
-  const result = [];
-  let offset = 0;
-  for (const segment of split) {
-    const end = offset + segment.text.length;
-    if (offset >= index && end <= index + length) {
-      const attributes = {};
-      for (const key of Object.keys(patch)) {
-        attributes[key] = segment.attributes?.[key] ?? null;
-      }
-      result.push({
-        type: "format",
-        index: offset,
-        length: segment.text.length,
-        attributes
-      });
-    }
-    offset = end;
-  }
-  return result;
-}
-function mapIndexThroughOperation(index, op) {
-  if (op.type === "insert") {
-    return op.index <= index ? index + op.text.length : index;
-  } else if (op.type === "delete") {
-    if (op.index >= index) {
-      return index;
-    }
-    return Math.max(op.index, index - op.length);
-  } else {
-    return index;
-  }
-}
-function mapTextIndexThroughOperations(index, ops) {
-  let mapped = index;
-  for (const op of ops) {
-    mapped = mapIndexThroughOperation(mapped, op);
-  }
-  return mapped;
-}
-function rebaseTextOperations(ops, acceptedOps) {
-  return ops.map((op) => {
-    if (op.type === "insert") {
-      return {
-        ...op,
-        index: mapTextIndexThroughOperations(op.index, acceptedOps)
-      };
-    } else if (op.type === "delete" || op.type === "format") {
-      const start = mapTextIndexThroughOperations(op.index, acceptedOps);
-      const end = mapTextIndexThroughOperations(
-        op.index + op.length,
-        acceptedOps
-      );
-      return { ...op, index: start, length: Math.max(0, end - start) };
-    } else {
-      return op;
-    }
-  });
-}
-function applyTextOperationsToSegments(segments, ops) {
-  let next = [...segments];
-  for (const op of ops) {
-    if (op.type === "insert") {
-      const index = Math.max(0, Math.min(op.index, textLength(next)));
-      next = applyInsert(next, index, op.text, op.attributes);
-    } else if (op.type === "delete") {
-      const index = Math.max(0, Math.min(op.index, textLength(next)));
-      const clipped = clipRange(index, op.length, textLength(next));
-      next = applyDelete(next, clipped.index, clipped.length).segments;
-    } else {
-      const index = Math.max(0, Math.min(op.index, textLength(next)));
-      const clipped = clipRange(index, op.length, textLength(next));
-      next = applyFormat(next, clipped.index, clipped.length, op.attributes);
-    }
-  }
-  return next;
-}
-function applyLiveTextOperations(data, ops) {
-  return segmentsToData(
-    applyTextOperationsToSegments(dataToSegments(data), ops)
-  );
-}
-function invertTextOperations(segments, ops) {
-  let shadow = [...segments];
-  const reverse = [];
-  for (const op of ops) {
-    if (op.type === "insert") {
-      shadow = applyInsert(shadow, op.index, op.text, op.attributes);
-      reverse.unshift({
-        type: "delete",
-        index: op.index,
-        length: op.text.length
-      });
-    } else if (op.type === "delete") {
-      const deletedSegments = extractDeletedSegments(
-        shadow,
-        op.index,
-        op.length
-      );
-      shadow = applyDelete(shadow, op.index, op.length).segments;
-      const inserts = [];
-      let insertIndex = op.index;
-      for (const segment of deletedSegments) {
-        inserts.push({
-          type: "insert",
-          index: insertIndex,
-          text: segment.text,
-          attributes: segment.attributes
-        });
-        insertIndex += segment.text.length;
-      }
-      for (let index = inserts.length - 1; index >= 0; index--) {
-        reverse.unshift(inserts[index]);
-      }
-    } else {
-      const inverse = formatReverseOperations(
-        shadow,
-        op.index,
-        op.length,
-        op.attributes
-      );
-      shadow = applyFormat(shadow, op.index, op.length, op.attributes);
-      reverse.unshift(...inverse.reverse());
-    }
-  }
-  return reverse;
-}
-
-// src/crdts/LiveText.ts
-var LiveText = class _LiveText extends AbstractCrdt {
-  #segments;
-  #version;
-  #pendingOps;
-  constructor(textOrData = "", version = 0) {
-    super();
-    this.#segments = typeof textOrData === "string" ? textOrData.length === 0 ? [] : [{ text: textOrData }] : dataToSegments(textOrData);
-    this.#version = version;
-    this.#pendingOps = /* @__PURE__ */ new Map();
-  }
-  get version() {
-    return this.#version;
-  }
-  get length() {
-    return this.toString().length;
-  }
-  /** @internal */
-  static _deserialize([id, item], _parentToChildren, pool) {
-    const text = new _LiveText(item.data, item.version);
-    text._attach(id, pool);
-    return text;
-  }
-  /** @internal */
-  _toOps(parentId, parentKey) {
-    if (this._id === void 0) {
-      throw new Error("Cannot serialize LiveText if it is not attached");
-    }
-    return [
-      {
-        type: OpCode.CREATE_TEXT,
-        id: this._id,
-        parentId,
-        parentKey,
-        data: this.toJSON(),
-        version: this.#version
-      }
-    ];
-  }
-  /** @internal */
-  _serialize() {
-    if (this.parent.type !== "HasParent") {
-      throw new Error("Cannot serialize LiveText if parent is missing");
-    }
-    return {
-      type: CrdtType.TEXT,
-      parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
-      parentKey: this.parent.key,
-      data: this.toJSON(),
-      version: this.#version
-    };
-  }
-  /** @internal */
-  _attachChild(_op) {
-    throw new Error("LiveText cannot contain child nodes");
-  }
-  /** @internal */
-  _detachChild(_crdt) {
-    throw new Error("LiveText cannot contain child nodes");
-  }
-  /** @internal */
-  _apply(op, isLocal) {
-    if (op.type !== OpCode.UPDATE_TEXT) {
-      return super._apply(op, isLocal);
-    }
-    if (isLocal) {
-      this.#pendingOps.set(nn(op.opId), op.ops);
-      return this.#applyOperations(op.ops, op.version ?? this.#version);
-    }
-    if (op.opId !== void 0) {
-      const pending2 = this.#pendingOps.get(op.opId);
-      this.#pendingOps.delete(op.opId);
-      const otherPending = Array.from(this.#pendingOps.values()).flat();
-      if (pending2 !== void 0 && otherPending.length > 0) {
-        this.#segments = applyTextOperationsToSegments(
-          this.#segments,
-          invertTextOperations(this.#segments, pending2)
-        );
-        const ops2 = rebaseTextOperations(op.ops, otherPending);
-        return this.#applyOperations(
-          ops2,
-          op.version ?? Math.max(this.#version, op.baseVersion + 1)
-        );
-      }
-      this.#version = op.version ?? Math.max(this.#version, op.baseVersion + 1);
-      return { modified: false };
-    }
-    const pending = Array.from(this.#pendingOps.values()).flat();
-    const ops = pending.length > 0 ? rebaseTextOperations(op.ops, pending) : op.ops;
-    return this.#applyOperations(ops, op.version ?? this.#version + 1);
-  }
-  insert(index, text, attributes) {
-    const clippedIndex = Math.max(0, Math.min(index, this.length));
-    this.#dispatch([{ type: "insert", index: clippedIndex, text, attributes }]);
-  }
-  delete(index, length) {
-    const clipped = clipRange(index, length, this.length);
-    if (clipped.length === 0) {
-      return;
-    }
-    this.#dispatch([
-      { type: "delete", index: clipped.index, length: clipped.length }
-    ]);
-  }
-  replace(index, length, text, attributes) {
-    const clipped = clipRange(index, length, this.length);
-    const ops = [];
-    if (clipped.length > 0) {
-      ops.push({
-        type: "delete",
-        index: clipped.index,
-        length: clipped.length
-      });
-    }
-    if (text.length > 0) {
-      ops.push({ type: "insert", index: clipped.index, text, attributes });
-    }
-    this.#dispatch(ops);
-  }
-  format(index, length, attributes) {
-    const clipped = clipRange(index, length, this.length);
-    if (clipped.length === 0) {
-      return;
-    }
-    this.#dispatch([
-      {
-        type: "format",
-        index: clipped.index,
-        length: clipped.length,
-        attributes
-      }
-    ]);
-  }
-  #dispatch(ops) {
-    if (ops.length === 0) {
-      return;
-    }
-    this._pool?.assertStorageIsWritable();
-    const baseVersion = this.#version;
-    const reverse = this._pool !== void 0 && this._id !== void 0 ? this.#invertOperations(ops) : [];
-    const changes = this.#applyOperationsLocally(ops);
-    if (this._pool !== void 0 && this._id !== void 0) {
-      const opId = this._pool.generateOpId();
-      this.#pendingOps.set(opId, ops);
-      this._pool.dispatch(
-        [
-          {
-            type: OpCode.UPDATE_TEXT,
-            id: this._id,
-            opId,
-            baseVersion,
-            ops: [...ops]
-          }
-        ],
-        reverse,
-        /* @__PURE__ */ new Map([
-          [
-            this._id,
-            {
-              type: "LiveText",
-              node: this,
-              version: this.#version,
-              updates: changes
-            }
-          ]
-        ])
-      );
-    }
-  }
-  #applyOperations(ops, version) {
-    const reverse = this.#invertOperations(ops);
-    const changes = this.#applyOperationsLocally(ops);
-    this.#version = Math.max(this.#version, version);
-    return {
-      reverse,
-      modified: {
-        type: "LiveText",
-        node: this,
-        version: this.#version,
-        updates: changes
-      }
-    };
-  }
-  #applyOperationsLocally(ops) {
-    const changes = [];
-    for (const op of ops) {
-      if (op.type === "insert") {
-        this.#segments = applyInsert(
-          this.#segments,
-          op.index,
-          op.text,
-          op.attributes
-        );
-        changes.push({
-          type: "insert",
-          index: op.index,
-          text: op.text,
-          attributes: op.attributes
-        });
-      } else if (op.type === "delete") {
-        const result = applyDelete(this.#segments, op.index, op.length);
-        this.#segments = result.segments;
-        changes.push({
-          type: "delete",
-          index: op.index,
-          length: op.length,
-          deletedText: result.deletedText
-        });
-      } else {
-        this.#segments = applyFormat(
-          this.#segments,
-          op.index,
-          op.length,
-          op.attributes
-        );
-        changes.push({
-          type: "format",
-          index: op.index,
-          length: op.length,
-          attributes: op.attributes
-        });
-      }
-    }
-    this.invalidate();
-    return changes;
-  }
-  #invertOperations(ops) {
-    return [
-      {
-        type: OpCode.UPDATE_TEXT,
-        id: nn(this._id),
-        baseVersion: this.#version,
-        ops: invertTextOperations(this.#segments, ops)
-      }
-    ];
-  }
-  toString() {
-    return this.#segments.map((segment) => segment.text).join("");
-  }
-  toJSON() {
-    return super.toJSON();
-  }
-  /** @internal */
-  _toJSON() {
-    return segmentsToData(this.#segments);
-  }
-  /** @internal */
-  _toTreeNode(key) {
-    return {
-      type: "LiveText",
-      id: this._id ?? nanoid(),
-      key,
-      payload: [
-        {
-          type: "Json",
-          id: `${this._id ?? nanoid()}:text`,
-          key: "text",
-          payload: this.toString()
-        }
-      ]
-    };
-  }
-  clone() {
-    return new _LiveText(this.toJSON(), this.#version);
-  }
-};
-
 // src/crdts/liveblocks-helpers.ts
 function creationOpToLiveNode(op) {
   return lsonToLiveNode(creationOpToLson(op));
@@ -9062,8 +8466,6 @@ function creationOpToLson(op) {
       return new LiveMap();
     case OpCode.CREATE_LIST:
       return new LiveList([]);
-    case OpCode.CREATE_TEXT:
-      return new LiveText(op.data, op.version);
     default:
       return assertNever(op, "Unknown creation Op");
   }
@@ -9086,8 +8488,6 @@ function deserialize(node, parentToChildren, pool) {
     return LiveMap._deserialize(node, parentToChildren, pool);
   } else if (isRegisterStorageNode(node)) {
     return LiveRegister._deserialize(node, parentToChildren, pool);
-  } else if (isTextStorageNode(node)) {
-    return LiveText._deserialize(node, parentToChildren, pool);
   } else {
     throw new Error("Unexpected CRDT type");
   }
@@ -9101,14 +8501,12 @@ function deserializeToLson(node, parentToChildren, pool) {
     return LiveMap._deserialize(node, parentToChildren, pool);
   } else if (isRegisterStorageNode(node)) {
     return node[1].data;
-  } else if (isTextStorageNode(node)) {
-    return LiveText._deserialize(node, parentToChildren, pool);
   } else {
     throw new Error("Unexpected CRDT type");
   }
 }
 function isLiveStructure(value) {
-  return isLiveList(value) || isLiveMap(value) || isLiveObject(value) || isLiveText(value);
+  return isLiveList(value) || isLiveMap(value) || isLiveObject(value);
 }
 function isLiveNode(value) {
   return isLiveStructure(value) || isLiveRegister(value);
@@ -9122,9 +8520,6 @@ function isLiveMap(value) {
 function isLiveObject(value) {
   return value instanceof LiveObject;
 }
-function isLiveText(value) {
-  return value instanceof LiveText;
-}
 function isLiveRegister(value) {
   return value instanceof LiveRegister;
 }
@@ -9134,73 +8529,19 @@ function cloneLson(value) {
 function liveNodeToLson(obj) {
   if (obj instanceof LiveRegister) {
     return obj.data;
-  } else if (obj instanceof LiveList || obj instanceof LiveMap || obj instanceof LiveObject || obj instanceof LiveText) {
+  } else if (obj instanceof LiveList || obj instanceof LiveMap || obj instanceof LiveObject) {
     return obj;
   } else {
     return assertNever(obj, "Unknown AbstractCrdt");
   }
 }
 function lsonToLiveNode(value) {
-  if (value instanceof LiveObject || value instanceof LiveMap || value instanceof LiveList || value instanceof LiveText) {
+  if (value instanceof LiveObject || value instanceof LiveMap || value instanceof LiveList) {
     return value;
   } else {
     return new LiveRegister(value);
   }
 }
-function dumpPool(pool) {
-  const rows = Array.from(pool.nodes.values(), (node) => {
-    const parent = node.parent;
-    const parentId = parent.type === "HasParent" ? parent.node._id ?? "?" : parent.type === "Orphaned" ? "<orphaned>" : "-";
-    let value;
-    if (node instanceof LiveRegister) {
-      value = stringifyOrLog(node.data);
-    } else if (node instanceof LiveList) {
-      value = "<LiveList>";
-    } else if (node instanceof LiveMap) {
-      value = "<LiveMap>";
-    } else {
-      value = "<LiveObject>";
-    }
-    return { id: nn(node._id), parentId, key: node._parentKey ?? "", value };
-  });
-  rows.sort((a, b) => {
-    if (a.parentId !== b.parentId) return a.parentId < b.parentId ? -1 : 1;
-    if (a.key !== b.key) return a.key < b.key ? -1 : 1;
-    return 0;
-  });
-  return rows.map(
-    (r) => `  ${r.id}  parent=${r.parentId}  key=${r.key || "\u2014"}  ${r.value}`
-  ).join("\n");
-}
-function isJsonEq(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (typeof a !== "object" || a === null || typeof b !== "object" || 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++) {
-      if (!isJsonEq(a[i], b[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  const aKeys = Object.keys(a);
-  if (aKeys.length !== Object.keys(b).length) {
-    return false;
-  }
-  for (const key of aKeys) {
-    if (!isJsonEq(a[key], b[key])) {
-      return false;
-    }
-  }
-  return true;
-}
 function getTreesDiffOperations(currentItems, newItems) {
   const ops = [];
   currentItems.forEach((_, id) => {
@@ -9212,61 +8553,11 @@ function getTreesDiffOperations(currentItems, newItems) {
     const currentCrdt = currentItems.get(id);
     if (currentCrdt) {
       if (crdt.type === CrdtType.OBJECT) {
-        if (currentCrdt.type !== CrdtType.OBJECT) {
-          ops.push({ type: OpCode.UPDATE_OBJECT, id, data: crdt.data });
-        } else {
-          const changed = /* @__PURE__ */ new Map();
-          for (const key of Object.keys(crdt.data)) {
-            const value = crdt.data[key];
-            if (value !== void 0 && !isJsonEq(value, currentCrdt.data[key])) {
-              changed.set(key, value);
-            }
-          }
-          if (changed.size > 0) {
-            ops.push({
-              type: OpCode.UPDATE_OBJECT,
-              id,
-              data: Object.fromEntries(changed)
-            });
-          }
-          for (const key of Object.keys(currentCrdt.data)) {
-            if (!(key in crdt.data)) {
-              ops.push({ type: OpCode.DELETE_OBJECT_KEY, id, key });
-            }
-          }
-        }
-      }
-      if (crdt.type === CrdtType.TEXT) {
-        if (currentCrdt.type !== CrdtType.TEXT || stringifyOrLog(crdt.data) !== stringifyOrLog(currentCrdt.data) || crdt.version !== currentCrdt.version) {
+        if (currentCrdt.type !== CrdtType.OBJECT || stringifyOrLog(crdt.data) !== stringifyOrLog(currentCrdt.data)) {
           ops.push({
-            type: OpCode.UPDATE_TEXT,
+            type: OpCode.UPDATE_OBJECT,
             id,
-            baseVersion: currentCrdt.type === CrdtType.TEXT ? currentCrdt.version : 0,
-            version: crdt.version,
-            ops: [
-              {
-                type: "delete",
-                index: 0,
-                length: currentCrdt.type === CrdtType.TEXT ? currentCrdt.data.reduce(
-                  (sum, segment) => sum + segment[0].length,
-                  0
-                ) : 0
-              },
-              ...crdt.data.map((segment, index, items) => {
-                const [text, attributes] = segment;
-                const insertIndex = items.slice(0, index).reduce((sum, item) => sum + item[0].length, 0);
-                return attributes === void 0 ? {
-                  type: "insert",
-                  index: insertIndex,
-                  text
-                } : {
-                  type: "insert",
-                  index: insertIndex,
-                  text,
-                  attributes
-                };
-              })
-            ]
+            data: crdt.data
           });
         }
       }
@@ -9318,16 +8609,6 @@ function getTreesDiffOperations(currentItems, newItems) {
             parentKey: crdt.parentKey
           });
           break;
-        case CrdtType.TEXT:
-          ops.push({
-            type: OpCode.CREATE_TEXT,
-            id,
-            parentId: crdt.parentId,
-            parentKey: crdt.parentKey,
-            data: crdt.data,
-            version: crdt.version
-          });
-          break;
       }
     }
   });
@@ -9360,12 +8641,6 @@ function mergeListStorageUpdates(first, second) {
     updates: updates.concat(second.updates)
   };
 }
-function mergeTextStorageUpdates(first, second) {
-  return {
-    ...second,
-    updates: first.updates.concat(second.updates)
-  };
-}
 function mergeStorageUpdates(first, second) {
   if (first === void 0) {
     return second;
@@ -9376,8 +8651,6 @@ function mergeStorageUpdates(first, second) {
     return mergeMapStorageUpdates(first, second);
   } else if (first.type === "LiveList" && second.type === "LiveList") {
     return mergeListStorageUpdates(first, second);
-  } else if (first.type === "LiveText" && second.type === "LiveText") {
-    return mergeTextStorageUpdates(first, second);
   } else {
   }
   return second;
@@ -9964,14 +9237,14 @@ var ClientMsgCode = Object.freeze({
 // src/refs/ManagedOthers.ts
 function makeUser(conn, presence) {
   const { connectionId, id, info } = conn;
-  const canWrite = canWriteStorage(conn.scopes);
+  const canWrite = hasPermissionCapability(conn.scopes, "storage", "write");
   return freeze(
     compactObject({
       connectionId,
       id,
       info,
       canWrite,
-      canComment: canComment(conn.scopes),
+      canComment: hasPermissionCapability(conn.scopes, "comments", "write"),
       isReadOnly: !canWrite,
       // Deprecated, kept for backward-compatibility
       presence
@@ -10278,7 +9551,6 @@ function createRoom(options, config) {
     delegates,
     config.enableDebugLogging
   );
-  const unacknowledgedOps = new UnacknowledgedOps();
   const context = {
     buffer: {
       flushTimerID: void 0,
@@ -10306,15 +9578,14 @@ function createRoom(options, config) {
     pool: createManagedPool(roomId, {
       getCurrentConnectionId,
       onDispatch,
-      isStorageWritable,
-      unacknowledgedOps
+      isStorageWritable
     }),
     root: void 0,
     undoStack: [],
     redoStack: [],
     pausedHistory: null,
     activeBatch: null,
-    unacknowledgedOps
+    unacknowledgedOps: /* @__PURE__ */ new Map()
   };
   const nodeMapBuffer = makeNodeMapBuffer();
   const stopwatch = config.enableDebugLogging ? makeStopWatch() : void 0;
@@ -10381,7 +9652,6 @@ function createRoom(options, config) {
   }
   function onDidDisconnect() {
     clearTimeout(context.buffer.flushTimerID);
-    context.unacknowledgedOps.markAllAsPossiblyStored();
   }
   managedSocket.events.onMessage.subscribe(handleServerMessage);
   managedSocket.events.statusDidChange.subscribe(onStatusDidChange);
@@ -10428,7 +9698,7 @@ function createRoom(options, config) {
   }
   function isStorageWritable() {
     const scopes = context.dynamicSessionInfoSig.get()?.scopes;
-    return scopes !== void 0 ? canWriteStorage(scopes) : true;
+    return scopes !== void 0 ? hasPermissionCapability(scopes, "storage", "write") : true;
   }
   const eventHub = {
     status: makeEventSource(),
@@ -10489,14 +9759,22 @@ function createRoom(options, config) {
       if (staticSession === null || dynamicSession === null) {
         return null;
       } else {
-        const canWrite = canWriteStorage(dynamicSession.scopes);
+        const canWrite = hasPermissionCapability(
+          dynamicSession.scopes,
+          "storage",
+          "write"
+        );
         return {
           connectionId: dynamicSession.actor,
           id: staticSession.userId,
           info: staticSession.userInfo,
           presence: myPresence,
           canWrite,
-          canComment: canComment(dynamicSession.scopes)
+          canComment: hasPermissionCapability(
+            dynamicSession.scopes,
+            "comments",
+            "write"
+          )
         };
       }
     }
@@ -10662,7 +9940,7 @@ function createRoom(options, config) {
           );
           output.reverse.pushLeft(applyOpResult.reverse);
         }
-        if (op.type === OpCode.CREATE_LIST || op.type === OpCode.CREATE_MAP || op.type === OpCode.CREATE_OBJECT || op.type === OpCode.CREATE_TEXT) {
+        if (op.type === OpCode.CREATE_LIST || op.type === OpCode.CREATE_MAP || op.type === OpCode.CREATE_OBJECT) {
           createdNodeIds.add(op.id);
         }
       }
@@ -10682,7 +9960,6 @@ function createRoom(options, config) {
     switch (op.type) {
       case OpCode.DELETE_OBJECT_KEY:
       case OpCode.UPDATE_OBJECT:
-      case OpCode.UPDATE_TEXT:
       case OpCode.DELETE_CRDT: {
         const node = context.pool.nodes.get(op.id);
         if (node === void 0) {
@@ -10707,7 +9984,6 @@ function createRoom(options, config) {
       case OpCode.CREATE_OBJECT:
       case OpCode.CREATE_LIST:
       case OpCode.CREATE_MAP:
-      case OpCode.CREATE_TEXT:
       case OpCode.CREATE_REGISTER: {
         if (op.parentId === void 0) {
           return { modified: false };
@@ -10856,11 +10132,12 @@ function createRoom(options, config) {
     }
   }
   function applyAndSendOfflineOps(unackedOps) {
-    if (unackedOps.length === 0) {
+    if (unackedOps.size === 0) {
       return;
     }
     const messages = [];
-    const result = applyLocalOps(unackedOps);
+    const inOps = Array.from(unackedOps.values());
+    const result = applyLocalOps(inOps);
     messages.push({
       type: ClientMsgCode.UPDATE_STORAGE,
       ops: result.opsToEmit
@@ -11084,7 +10361,7 @@ function createRoom(options, config) {
     const storageOps = context.buffer.storageOperations;
     if (storageOps.length > 0) {
       for (const op of storageOps) {
-        context.unacknowledgedOps.add(op);
+        context.unacknowledgedOps.set(op.opId, op);
       }
       notifyStorageStatus();
     }
@@ -11311,9 +10588,9 @@ function createRoom(options, config) {
     }
   }
   function processInitialStorage(nodes) {
-    const unacknowledgedOps2 = [...context.unacknowledgedOps.values()];
+    const unacknowledgedOps = new Map(context.unacknowledgedOps);
     createOrUpdateRootFromMessage(nodes);
-    applyAndSendOfflineOps(unacknowledgedOps2);
+    applyAndSendOfflineOps(unacknowledgedOps);
     _resolveStoragePromise?.();
     notifyStorageStatus();
     eventHub.storageDidLoad.notify();
@@ -11902,11 +11179,6 @@ function createRoom(options, config) {
       connect: () => managedSocket.connect(),
       reconnect: () => managedSocket.reconnect(),
       disconnect: () => managedSocket.disconnect(),
-      _dump: () => {
-        const n = context.pool.nodes.size;
-        return `Room "${roomId}" (${n} node${n === 1 ? "" : "s"}):
-${dumpPool(context.pool)}`;
-      },
       destroy: () => {
         pendingFeedsRequests.forEach(
           (request) => request.reject(new Error("Room destroyed"))
@@ -12098,7 +11370,11 @@ function isRoomEventName(value) {
 }
 function makeAuthDelegateForRoom(roomId, authManager) {
   return async () => {
-    return authManager.getAuthValue({ requestedScope: "room:read", roomId });
+    return authManager.getAuthValue({
+      roomId,
+      resource: "presence",
+      access: "read"
+    });
   };
 }
 function makeCreateSocketDelegateForRoom(roomId, baseUrl, WebSocketPolyfill) {
@@ -12188,7 +11464,9 @@ function createClient(options) {
       ),
       authenticate: async () => {
         const resp = await authManager.getAuthValue({
-          requestedScope: "room:read"
+          // TODO: Should we have permissions for AI Copilots?
+          resource: "personal",
+          access: "write"
         });
         if (resp.type === "public") {
           throw new StopRetrying(
@@ -12414,7 +11692,6 @@ function createClient(options) {
     {
       enterRoom,
       getRoom,
-      _dump: () => Array.from(roomsById.values(), ({ room }) => room._dump()).join("\n\n"),
       logout,
       // Public inbox notifications API
       getInboxNotifications: httpClient.getInboxNotifications,
@@ -12867,12 +12144,6 @@ function toPlainLson(lson) {
       liveblocksType: "LiveList",
       data: [...lson].map((item) => toPlainLson(item))
     };
-  } else if (lson instanceof LiveText) {
-    return {
-      liveblocksType: "LiveText",
-      data: lson.toJSON(),
-      version: lson.version
-    };
   } else {
     return lson;
   }
@@ -13054,7 +12325,6 @@ export {
   LiveList,
   LiveMap,
   LiveObject,
-  LiveText,
   LiveblocksError,
   MENTION_CHARACTER,
   MutableSignal,
@@ -13066,7 +12336,6 @@ export {
   SortedList,
   TextEditorType,
   WebsocketCloseCodes,
-  applyLiveTextOperations,
   asPos,
   assert,
   assertNever,
@@ -13093,7 +12362,6 @@ export {
   createManagedPool,
   createNotificationSettings,
   createThreadId,
-  deepLiveify,
   defineAiTool,
   deprecate,
   deprecateIf,
@@ -13104,7 +12372,10 @@ export {
   freeze,
   generateUrl,
   getMentionsFromCommentBody,
+  getRoomPermissionConflicts,
   getSubscriptionKey,
+  hasPermissionCapability,
+  hasPermissionCapabilityAccess,
   html,
   htmlSafe,
   isCommentBodyLink,
@@ -13123,7 +12394,6 @@ export {
   isRegisterStorageNode,
   isRootStorageNode,
   isStartsWithOperator,
-  isTextStorageNode,
   isUrl,
   kInternal,
   keys,
@@ -13136,8 +12406,12 @@ export {
   nanoid,
   nn,
   nodeStreamToCompactNodes,
+  normalizeRoomAccessesInput,
+  normalizeRoomAccessesUpdateInput,
+  normalizeRoomPermissionInput,
   objectToQuery,
   patchNotificationSettings,
+  permissionCapabilitiesFromScopes,
   raise,
   resolveMentionsInCommentBody,
   sanitizeUrl,