@liveblocks/core 3.21.0-rc1 → 3.22.0-file1

package/dist/index.js

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "3.21.0-rc1";
+var PKG_VERSION = "3.22.0-file1";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -1309,6 +1309,7 @@ var nanoid = (t = 21) => crypto.getRandomValues(new Uint8Array(t)).reduce(
 var THREAD_ID_PREFIX = "th";
 var COMMENT_ID_PREFIX = "cm";
 var COMMENT_ATTACHMENT_ID_PREFIX = "at";
+var STORAGE_FILE_ID_PREFIX = "fl";
 var INBOX_NOTIFICATION_ID_PREFIX = "in";
 function createOptimisticId(prefix) {
   return `${prefix}_${nanoid()}`;
@@ -1322,6 +1323,9 @@ function createCommentId() {
 function createCommentAttachmentId() {
   return createOptimisticId(COMMENT_ATTACHMENT_ID_PREFIX);
 }
+function createStorageFileId() {
+  return createOptimisticId(STORAGE_FILE_ID_PREFIX);
+}
 function createInboxNotificationId() {
   return createOptimisticId(INBOX_NOTIFICATION_ID_PREFIX);
 }
@@ -1567,6 +1571,120 @@ function isUrl(string) {
 }
 
 // src/api-client.ts
+var ROOM_FILE_PART_SIZE = 5 * 1024 * 1024;
+var ROOM_FILE_RETRY_ATTEMPTS = 10;
+var ROOM_FILE_RETRY_DELAYS = [
+  2e3,
+  2e3,
+  2e3,
+  2e3,
+  2e3,
+  2e3,
+  2e3,
+  2e3,
+  2e3,
+  2e3
+];
+async function uploadRoomFile({
+  file,
+  signal,
+  abortErrorMessage,
+  uploadSingle,
+  createMultipartUpload,
+  uploadMultipartPart,
+  completeMultipartUpload,
+  abortMultipartUpload
+}) {
+  const abortError = createAbortError(abortErrorMessage);
+  if (signal?.aborted) {
+    throw abortError;
+  }
+  const handleRetryError = (err) => {
+    if (signal?.aborted) {
+      throw abortError;
+    }
+    if (err instanceof HttpError && err.status === 413) {
+      throw err;
+    }
+    return false;
+  };
+  if (file.size <= ROOM_FILE_PART_SIZE) {
+    return autoRetry(
+      uploadSingle,
+      ROOM_FILE_RETRY_ATTEMPTS,
+      ROOM_FILE_RETRY_DELAYS,
+      handleRetryError
+    );
+  }
+  let uploadId;
+  const uploadedParts = [];
+  const multipartUpload = await autoRetry(
+    createMultipartUpload,
+    ROOM_FILE_RETRY_ATTEMPTS,
+    ROOM_FILE_RETRY_DELAYS,
+    handleRetryError
+  );
+  try {
+    uploadId = multipartUpload.uploadId;
+    if (signal?.aborted) {
+      throw abortError;
+    }
+    const batches = chunk(splitFileIntoParts(file), 5);
+    for (const parts of batches) {
+      const uploadedPartsPromises = [];
+      for (const { part, partNumber } of parts) {
+        uploadedPartsPromises.push(
+          autoRetry(
+            () => uploadMultipartPart(multipartUpload.uploadId, partNumber, part),
+            ROOM_FILE_RETRY_ATTEMPTS,
+            ROOM_FILE_RETRY_DELAYS,
+            handleRetryError
+          )
+        );
+      }
+      uploadedParts.push(...await Promise.all(uploadedPartsPromises));
+    }
+    if (signal?.aborted) {
+      throw abortError;
+    }
+    return completeMultipartUpload(
+      uploadId,
+      uploadedParts.sort((a, b) => a.partNumber - b.partNumber)
+    );
+  } catch (error3) {
+    if (uploadId && isAbortOrTimeoutError(error3)) {
+      try {
+        await abortMultipartUpload(uploadId);
+      } catch {
+      }
+    }
+    throw error3;
+  }
+}
+function splitFileIntoParts(file) {
+  const parts = [];
+  let start = 0;
+  while (start < file.size) {
+    const end = Math.min(start + ROOM_FILE_PART_SIZE, file.size);
+    parts.push({
+      partNumber: parts.length + 1,
+      part: file.slice(start, end)
+    });
+    start = end;
+  }
+  return parts;
+}
+function isAbortOrTimeoutError(error3) {
+  return error3 instanceof Error && (error3.name === "AbortError" || error3.name === "TimeoutError");
+}
+function createAbortError(message) {
+  if (typeof DOMException === "function") {
+    return new DOMException(message, "AbortError");
+  }
+  const error3 = new Error(message);
+  error3.name = "AbortError";
+  return error3;
+}
 function commentsResourceForVisibility(visibility) {
   if (visibility === "private") {
     return "comments:private";
@@ -1882,151 +2000,128 @@ function createApiClient({
   }
   async function uploadAttachment(options) {
     const roomId = options.roomId;
-    const abortSignal = options.signal;
     const attachment = options.attachment;
-    const abortError = abortSignal ? new DOMException(
-      `Upload of attachment ${options.attachment.id} was aborted.`,
-      "AbortError"
-    ) : void 0;
-    if (abortSignal?.aborted) {
-      throw abortError;
-    }
-    const handleRetryError = (err) => {
-      if (abortSignal?.aborted) {
-        throw abortError;
-      }
-      if (err instanceof HttpError && err.status === 413) {
-        throw err;
-      }
-      return false;
-    };
-    const ATTACHMENT_PART_SIZE = 5 * 1024 * 1024;
-    const RETRY_ATTEMPTS = 10;
-    const RETRY_DELAYS = [
-      2e3,
-      2e3,
-      2e3,
-      2e3,
-      2e3,
-      2e3,
-      2e3,
-      2e3,
-      2e3,
-      2e3
-    ];
-    function splitFileIntoParts(file) {
-      const parts = [];
-      let start = 0;
-      while (start < file.size) {
-        const end = Math.min(start + ATTACHMENT_PART_SIZE, file.size);
-        parts.push({
-          partNumber: parts.length + 1,
-          part: file.slice(start, end)
-        });
-        start = end;
-      }
-      return parts;
-    }
-    if (attachment.size <= ATTACHMENT_PART_SIZE) {
-      return autoRetry(
-        async () => httpClient.putBlob(
-          url`/v2/c/rooms/${roomId}/attachments/${attachment.id}/upload/${encodeURIComponent(attachment.name)}`,
-          await authManager.getAuthValue({
-            roomId,
-            resource: "comments",
-            access: "write"
-          }),
-          attachment.file,
-          { fileSize: attachment.size },
-          { signal: abortSignal }
-        ),
-        RETRY_ATTEMPTS,
-        RETRY_DELAYS,
-        handleRetryError
-      );
-    } else {
-      let uploadId;
-      const uploadedParts = [];
-      const createMultiPartUpload = await autoRetry(
-        async () => httpClient.post(
-          url`/v2/c/rooms/${roomId}/attachments/${attachment.id}/multipart/${encodeURIComponent(attachment.name)}`,
+    return uploadRoomFile({
+      file: attachment.file,
+      signal: options.signal,
+      abortErrorMessage: `Upload of attachment ${attachment.id} was aborted.`,
+      uploadSingle: async () => httpClient.putBlob(
+        url`/v2/c/rooms/${roomId}/attachments/${attachment.id}/upload/${encodeURIComponent(attachment.name)}`,
+        await authManager.getAuthValue({
+          roomId,
+          resource: "comments",
+          access: "write"
+        }),
+        attachment.file,
+        { fileSize: attachment.size },
+        { signal: options.signal }
+      ),
+      createMultipartUpload: async () => httpClient.post(
+        url`/v2/c/rooms/${roomId}/attachments/${attachment.id}/multipart/${encodeURIComponent(attachment.name)}`,
+        await authManager.getAuthValue({
+          roomId,
+          resource: "comments",
+          access: "write"
+        }),
+        void 0,
+        { signal: options.signal },
+        { fileSize: attachment.size }
+      ),
+      uploadMultipartPart: async (uploadId, partNumber, part) => httpClient.putBlob(
+        url`/v2/c/rooms/${roomId}/attachments/${attachment.id}/multipart/${uploadId}/${String(partNumber)}`,
+        await authManager.getAuthValue({
+          roomId,
+          resource: "comments",
+          access: "write"
+        }),
+        part,
+        void 0,
+        { signal: options.signal }
+      ),
+      completeMultipartUpload: async (uploadId, parts) => httpClient.post(
+        url`/v2/c/rooms/${roomId}/attachments/${attachment.id}/multipart/${uploadId}/complete`,
+        await authManager.getAuthValue({
+          roomId,
+          resource: "comments",
+          access: "write"
+        }),
+        { parts },
+        { signal: options.signal }
+      ),
+      abortMultipartUpload: async (uploadId) => {
+        await httpClient.rawDelete(
+          url`/v2/c/rooms/${roomId}/attachments/${attachment.id}/multipart/${uploadId}`,
           await authManager.getAuthValue({
             roomId,
             resource: "comments",
             access: "write"
-          }),
-          void 0,
-          { signal: abortSignal },
-          { fileSize: attachment.size }
-        ),
-        RETRY_ATTEMPTS,
-        RETRY_DELAYS,
-        handleRetryError
-      );
-      try {
-        uploadId = createMultiPartUpload.uploadId;
-        const parts = splitFileIntoParts(attachment.file);
-        if (abortSignal?.aborted) {
-          throw abortError;
-        }
-        const batches = chunk(parts, 5);
-        for (const parts2 of batches) {
-          const uploadedPartsPromises = [];
-          for (const { part, partNumber } of parts2) {
-            uploadedPartsPromises.push(
-              autoRetry(
-                async () => httpClient.putBlob(
-                  url`/v2/c/rooms/${roomId}/attachments/${attachment.id}/multipart/${createMultiPartUpload.uploadId}/${String(partNumber)}`,
-                  await authManager.getAuthValue({
-                    roomId,
-                    resource: "comments",
-                    access: "write"
-                  }),
-                  part,
-                  void 0,
-                  { signal: abortSignal }
-                ),
-                RETRY_ATTEMPTS,
-                RETRY_DELAYS,
-                handleRetryError
-              )
-            );
-          }
-          uploadedParts.push(...await Promise.all(uploadedPartsPromises));
-        }
-        if (abortSignal?.aborted) {
-          throw abortError;
-        }
-        const sortedUploadedParts = uploadedParts.sort(
-          (a, b) => a.partNumber - b.partNumber
+          })
         );
-        return httpClient.post(
-          url`/v2/c/rooms/${roomId}/attachments/${attachment.id}/multipart/${uploadId}/complete`,
+      }
+    });
+  }
+  async function uploadFile(options) {
+    const roomId = options.roomId;
+    const file = options.file;
+    const fileId = createStorageFileId();
+    return uploadRoomFile({
+      file,
+      signal: options.signal,
+      abortErrorMessage: `Upload of file ${fileId} was aborted.`,
+      uploadSingle: async () => httpClient.putBlob(
+        url`/v2/c/rooms/${roomId}/storage-files/${fileId}/upload/${encodeURIComponent(file.name)}`,
+        await authManager.getAuthValue({
+          roomId,
+          resource: "storage",
+          access: "write"
+        }),
+        file,
+        { fileSize: file.size },
+        { signal: options.signal }
+      ),
+      createMultipartUpload: async () => httpClient.post(
+        url`/v2/c/rooms/${roomId}/storage-files/${fileId}/multipart/${encodeURIComponent(file.name)}`,
+        await authManager.getAuthValue({
+          roomId,
+          resource: "storage",
+          access: "write"
+        }),
+        void 0,
+        { signal: options.signal },
+        { fileSize: file.size }
+      ),
+      uploadMultipartPart: async (uploadId, partNumber, part) => httpClient.putBlob(
+        url`/v2/c/rooms/${roomId}/storage-files/${fileId}/multipart/${uploadId}/${String(partNumber)}`,
+        await authManager.getAuthValue({
+          roomId,
+          resource: "storage",
+          access: "write"
+        }),
+        part,
+        void 0,
+        { signal: options.signal }
+      ),
+      completeMultipartUpload: async (uploadId, parts) => httpClient.post(
+        url`/v2/c/rooms/${roomId}/storage-files/${fileId}/multipart/${uploadId}/complete`,
+        await authManager.getAuthValue({
+          roomId,
+          resource: "storage",
+          access: "write"
+        }),
+        { parts },
+        { signal: options.signal }
+      ),
+      abortMultipartUpload: async (uploadId) => {
+        await httpClient.rawDelete(
+          url`/v2/c/rooms/${roomId}/storage-files/${fileId}/multipart/${uploadId}`,
           await authManager.getAuthValue({
             roomId,
-            resource: "comments",
+            resource: "storage",
             access: "write"
-          }),
-          { parts: sortedUploadedParts },
-          { signal: abortSignal }
+          })
         );
-      } catch (error3) {
-        if (uploadId && error3?.name && (error3.name === "AbortError" || error3.name === "TimeoutError")) {
-          try {
-            await httpClient.rawDelete(
-              url`/v2/c/rooms/${roomId}/attachments/${attachment.id}/multipart/${uploadId}`,
-              await authManager.getAuthValue({
-                roomId,
-                resource: "comments",
-                access: "write"
-              })
-            );
-          } catch {
-          }
-        }
-        throw error3;
       }
-    }
+    });
   }
   const attachmentUrlsBatchStoresByRoom = new DefaultMap((roomId) => {
     const batch2 = new Batch(
@@ -2056,6 +2151,34 @@ function createApiClient({
     const batch2 = getOrCreateAttachmentUrlsStore(options.roomId).batch;
     return batch2.get(options.attachmentId);
   }
+  const fileUrlsBatchStoresByRoom = new DefaultMap((roomId) => {
+    const batch2 = new Batch(
+      async (batchedFileIds) => {
+        const fileIds = batchedFileIds.flat();
+        const { urls } = await httpClient.post(
+          url`/v2/c/rooms/${roomId}/storage-files/presigned-urls`,
+          await authManager.getAuthValue({
+            roomId,
+            resource: "storage",
+            access: "read"
+          }),
+          { fileIds }
+        );
+        return urls.map(
+          (url2) => url2 ?? new Error("There was an error while getting this file's URL")
+        );
+      },
+      { delay: 50 }
+    );
+    return createBatchStore(batch2);
+  });
+  function getOrCreateFileUrlsStore(roomId) {
+    return fileUrlsBatchStoresByRoom.getOrCreate(roomId);
+  }
+  function getFileUrl(options) {
+    const batch2 = getOrCreateFileUrlsStore(options.roomId).batch;
+    return batch2.get(options.fileId);
+  }
   async function getSubscriptionSettings(options) {
     return httpClient.get(
       url`/v2/c/rooms/${options.roomId}/subscription-settings`,
@@ -2132,9 +2255,9 @@ function createApiClient({
       })
     );
   }
-  async function getTextVersion(options) {
+  async function getYjsHistoryVersion(options) {
     return httpClient.rawGet(
-      url`/v2/c/rooms/${options.roomId}/y-version/${options.versionId}`,
+      url`/v2/c/rooms/${options.roomId}/versions/${options.versionId}/yjs`,
       await authManager.getAuthValue({
         roomId: options.roomId,
         resource: "storage",
@@ -2142,9 +2265,9 @@ function createApiClient({
       })
     );
   }
-  async function createTextVersion(options) {
+  async function createVersionHistorySnapshot(options) {
     await httpClient.rawPost(
-      url`/v2/c/rooms/${options.roomId}/version`,
+      url`/v2/c/rooms/${options.roomId}/versions`,
       await authManager.getAuthValue({
         roomId: options.roomId,
         resource: "storage",
@@ -2190,7 +2313,7 @@ function createApiClient({
     }
     return result.content[0].text;
   }
-  async function listTextVersions(options) {
+  async function listHistoryVersions(options) {
     const result = await httpClient.get(
       url`/v2/c/rooms/${options.roomId}/versions`,
       await authManager.getAuthValue({
@@ -2209,7 +2332,7 @@ function createApiClient({
       requestedAt: new Date(result.meta.requestedAt)
     };
   }
-  async function listTextVersionsSince(options) {
+  async function listHistoryVersionsSince(options) {
     const result = await httpClient.get(
       url`/v2/c/rooms/${options.roomId}/versions/delta`,
       await authManager.getAuthValue({
@@ -2475,15 +2598,19 @@ function createApiClient({
     // Room text editor
     createTextMention,
     deleteTextMention,
-    getTextVersion,
-    createTextVersion,
+    getYjsHistoryVersion,
+    createVersionHistorySnapshot,
     reportTextEditor,
-    listTextVersions,
-    listTextVersionsSince,
+    listHistoryVersions,
+    listHistoryVersionsSince,
     // Room attachments
     getAttachmentUrl,
     uploadAttachment,
     getOrCreateAttachmentUrlsStore,
+    // Room storage files
+    getFileUrl,
+    uploadFile,
+    getOrCreateFileUrlsStore,
     // Room storage
     streamStorage,
     // Notifications
@@ -5815,13 +5942,15 @@ var OpCode = Object.freeze({
   DELETE_CRDT: 5,
   DELETE_OBJECT_KEY: 6,
   CREATE_MAP: 7,
-  CREATE_REGISTER: 8
+  CREATE_REGISTER: 8,
+  // 9 and 10 are reserved for the parallel LiveText work.
+  CREATE_FILE: 11
 });
 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;
+  return op.type === OpCode.CREATE_OBJECT || op.type === OpCode.CREATE_REGISTER || op.type === OpCode.CREATE_FILE || op.type === OpCode.CREATE_MAP || op.type === OpCode.CREATE_LIST;
 }
 
 // src/protocol/StorageNode.ts
@@ -5829,7 +5958,9 @@ var CrdtType = Object.freeze({
   OBJECT: 0,
   LIST: 1,
   MAP: 2,
-  REGISTER: 3
+  REGISTER: 3,
+  // 4 is reserved for the parallel LiveText work.
+  FILE: 5
 });
 function isRootStorageNode(node) {
   return node[0] === "root";
@@ -5846,6 +5977,9 @@ function isMapStorageNode(node) {
 function isRegisterStorageNode(node) {
   return node[1].type === CrdtType.REGISTER;
 }
+function isFileStorageNode(node) {
+  return node[1].type === CrdtType.FILE;
+}
 function isCompactRootNode(node) {
   return node[0] === "root";
 }
@@ -5868,6 +6002,9 @@ function* compactNodesToNodeStream(compactNodes) {
       case CrdtType.REGISTER:
         yield [cnode[0], { type: CrdtType.REGISTER, parentId: cnode[2], parentKey: cnode[3], data: cnode[4] }];
         break;
+      case CrdtType.FILE:
+        yield [cnode[0], { type: CrdtType.FILE, parentId: cnode[2], parentKey: cnode[3], data: cnode[4] }];
+        break;
       default:
     }
   }
@@ -5896,6 +6033,10 @@ function* nodeStreamToCompactNodes(nodes) {
       const id = node[0];
       const crdt = node[1];
       yield [id, CrdtType.REGISTER, crdt.parentId, crdt.parentKey, crdt.data];
+    } else if (isFileStorageNode(node)) {
+      const id = node[0];
+      const crdt = node[1];
+      yield [id, CrdtType.FILE, crdt.parentId, crdt.parentKey, crdt.data];
     } else {
     }
   }
@@ -6408,6 +6549,91 @@ var AbstractCrdt = class {
   }
 };
 
+// src/crdts/LiveFile.ts
+var LiveFile = class _LiveFile extends AbstractCrdt {
+  #data;
+  constructor(data) {
+    super();
+    this.#data = Object.freeze({ ...data });
+  }
+  get data() {
+    return this.#data;
+  }
+  get id() {
+    return this.#data.id;
+  }
+  get name() {
+    return this.#data.name;
+  }
+  get size() {
+    return this.#data.size;
+  }
+  get mimeType() {
+    return this.#data.mimeType;
+  }
+  /** @internal */
+  static _deserialize([id, item], _parentToChildren, pool) {
+    const file = new _LiveFile(item.data);
+    file._attach(id, pool);
+    return file;
+  }
+  /** @internal */
+  _toOps(parentId, parentKey) {
+    if (this._id === void 0) {
+      throw new Error("Cannot serialize LiveFile if parent is missing");
+    }
+    return [
+      {
+        type: OpCode.CREATE_FILE,
+        id: this._id,
+        parentId,
+        parentKey,
+        data: this.#data
+      }
+    ];
+  }
+  /** @internal */
+  _serialize() {
+    if (this.parent.type !== "HasParent") {
+      throw new Error("Cannot serialize LiveFile if parent is missing");
+    }
+    return {
+      type: CrdtType.FILE,
+      parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
+      parentKey: this.parent.key,
+      data: this.#data
+    };
+  }
+  /** @internal */
+  _attachChild(_op) {
+    throw new Error("Method not implemented.");
+  }
+  /** @internal */
+  _detachChild(_crdt) {
+    throw new Error("Method not implemented.");
+  }
+  /** @internal */
+  _apply(op, isLocal) {
+    return super._apply(op, isLocal);
+  }
+  /** @internal */
+  _toTreeNode(key) {
+    return {
+      type: "Json",
+      id: this._id ?? nanoid(),
+      key,
+      payload: this.#data
+    };
+  }
+  /** @internal */
+  _toJSON() {
+    return this.#data;
+  }
+  clone() {
+    return new _LiveFile(this.#data);
+  }
+};
+
 // src/crdts/LiveRegister.ts
 var LiveRegister = class _LiveRegister extends AbstractCrdt {
   #data;
@@ -8764,6 +8990,8 @@ function creationOpToLiveNode(op) {
 }
 function creationOpToLson(op) {
   switch (op.type) {
+    case OpCode.CREATE_FILE:
+      return new LiveFile(op.data);
     case OpCode.CREATE_REGISTER:
       return op.data;
     case OpCode.CREATE_OBJECT:
@@ -8794,6 +9022,8 @@ function deserialize(node, parentToChildren, pool) {
     return LiveMap._deserialize(node, parentToChildren, pool);
   } else if (isRegisterStorageNode(node)) {
     return LiveRegister._deserialize(node, parentToChildren, pool);
+  } else if (isFileStorageNode(node)) {
+    return LiveFile._deserialize(node, parentToChildren, pool);
   } else {
     throw new Error("Unexpected CRDT type");
   }
@@ -8807,12 +9037,14 @@ function deserializeToLson(node, parentToChildren, pool) {
     return LiveMap._deserialize(node, parentToChildren, pool);
   } else if (isRegisterStorageNode(node)) {
     return node[1].data;
+  } else if (isFileStorageNode(node)) {
+    return LiveFile._deserialize(node, parentToChildren, pool);
   } else {
     throw new Error("Unexpected CRDT type");
   }
 }
 function isLiveStructure(value) {
-  return isLiveList(value) || isLiveMap(value) || isLiveObject(value);
+  return isLiveList(value) || isLiveMap(value) || isLiveObject(value) || isLiveFile(value);
 }
 function isLiveNode(value) {
   return isLiveStructure(value) || isLiveRegister(value);
@@ -8826,6 +9058,9 @@ function isLiveMap(value) {
 function isLiveObject(value) {
   return value instanceof LiveObject;
 }
+function isLiveFile(value) {
+  return value instanceof LiveFile;
+}
 function isLiveRegister(value) {
   return value instanceof LiveRegister;
 }
@@ -8835,14 +9070,14 @@ function cloneLson(value) {
 function liveNodeToLson(obj) {
   if (obj instanceof LiveRegister) {
     return obj.data;
-  } else if (obj instanceof LiveList || obj instanceof LiveMap || obj instanceof LiveObject) {
+  } else if (obj instanceof LiveList || obj instanceof LiveMap || obj instanceof LiveObject || obj instanceof LiveFile) {
     return obj;
   } else {
     return assertNever(obj, "Unknown AbstractCrdt");
   }
 }
 function lsonToLiveNode(value) {
-  if (value instanceof LiveObject || value instanceof LiveMap || value instanceof LiveList) {
+  if (value instanceof LiveObject || value instanceof LiveMap || value instanceof LiveList || value instanceof LiveFile) {
     return value;
   } else {
     return new LiveRegister(value);
@@ -8859,6 +9094,8 @@ function dumpPool(pool) {
       value = "<LiveList>";
     } else if (node instanceof LiveMap) {
       value = "<LiveMap>";
+    } else if (node instanceof LiveFile) {
+      value = stringifyOrLog(node.data);
     } else {
       value = "<LiveObject>";
     }
@@ -8955,6 +9192,15 @@ function diffNodeMap(prev, next) {
             data: crdt.data
           });
           break;
+        case CrdtType.FILE:
+          ops.push({
+            type: OpCode.CREATE_FILE,
+            id,
+            parentId: crdt.parentId,
+            parentKey: crdt.parentKey,
+            data: crdt.data
+          });
+          break;
         case CrdtType.LIST:
           ops.push({
             type: OpCode.CREATE_LIST,
@@ -9852,6 +10098,9 @@ function defaultMessageFromContext(context) {
 
 // src/room.ts
 var FEEDS_TIMEOUT = 5e3;
+function getLiveFileId(file) {
+  return typeof file === "string" ? file : file.id;
+}
 function connectionAccessFromScopes(scopes) {
   const roomPermissions = normalizeRoomPermissions(scopes);
   const matrix = permissionMatrixFromScopes(roomPermissions);
@@ -9911,6 +10160,19 @@ function makeNodeMapBuffer() {
     }
   };
 }
+function topLevelKeysOf(nodes) {
+  const keys2 = /* @__PURE__ */ new Set();
+  const root = nodes.get("root");
+  for (const key in root?.data) {
+    keys2.add(key);
+  }
+  for (const node of nodes.values()) {
+    if (node.parentId === "root") {
+      keys2.add(node.parentKey);
+    }
+  }
+  return keys2;
+}
 function createRoom(options, config) {
   const roomId = config.roomId;
   const initialPresence = options.initialPresence;
@@ -10113,21 +10375,21 @@ function createRoom(options, config) {
   async function reportTextEditor(type, rootKey) {
     await httpClient.reportTextEditor({ roomId, type, rootKey });
   }
-  async function listTextVersions() {
-    return httpClient.listTextVersions({ roomId });
+  async function listHistoryVersions() {
+    return httpClient.listHistoryVersions({ roomId });
   }
-  async function listTextVersionsSince(options2) {
-    return httpClient.listTextVersionsSince({
+  async function listHistoryVersionsSince(options2) {
+    return httpClient.listHistoryVersionsSince({
       roomId,
       since: options2.since,
       signal: options2.signal
     });
   }
-  async function getTextVersion(versionId) {
-    return httpClient.getTextVersion({ roomId, versionId });
+  async function getYjsHistoryVersion(versionId) {
+    return httpClient.getYjsHistoryVersion({ roomId, versionId });
   }
-  async function createTextVersion() {
-    return httpClient.createTextVersion({ roomId });
+  async function createVersionHistorySnapshot() {
+    return httpClient.createVersionHistorySnapshot({ roomId });
   }
   async function executeContextualPrompt(options2) {
     return httpClient.executeContextualPrompt({
@@ -10197,10 +10459,11 @@ function createRoom(options, config) {
       );
     }
     const canWrite = self.get()?.canWrite ?? true;
+    const serverTopLevelKeys = topLevelKeysOf(nodes);
     const root = context.root;
     disableHistory(() => {
       for (const key in context.initialStorage) {
-        if (root.get(key) === void 0) {
+        if (!serverTopLevelKeys.has(key)) {
           if (canWrite) {
             root.set(key, cloneLson(context.initialStorage[key]));
           } else {
@@ -10327,7 +10590,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) {
+        if (op.type === OpCode.CREATE_LIST || op.type === OpCode.CREATE_MAP || op.type === OpCode.CREATE_OBJECT || op.type === OpCode.CREATE_FILE) {
           createdNodeIds.add(op.id);
         }
       }
@@ -10371,6 +10634,7 @@ function createRoom(options, config) {
       case OpCode.CREATE_OBJECT:
       case OpCode.CREATE_LIST:
       case OpCode.CREATE_MAP:
+      case OpCode.CREATE_FILE:
       case OpCode.CREATE_REGISTER: {
         if (op.parentId === void 0) {
           return { modified: false };
@@ -11474,6 +11738,17 @@ function createRoom(options, config) {
   function getAttachmentUrl(attachmentId) {
     return httpClient.getAttachmentUrl({ roomId, attachmentId });
   }
+  async function uploadFile(file, options2 = {}) {
+    const data = await httpClient.uploadFile({
+      roomId,
+      file,
+      signal: options2.signal
+    });
+    return new LiveFile(data);
+  }
+  function getFileUrl(file) {
+    return httpClient.getFileUrl({ roomId, fileId: getLiveFileId(file) });
+  }
   function getSubscriptionSettings(options2) {
     return httpClient.getSubscriptionSettings({
       roomId,
@@ -11528,13 +11803,13 @@ function createRoom(options, config) {
         // delete a text mention when using a text editor
         deleteTextMention,
         // list versions of the document
-        listTextVersions,
+        listHistoryVersions,
         // List versions of the document since the specified date
-        listTextVersionsSince,
+        listHistoryVersionsSince,
         // get a specific version
-        getTextVersion,
+        getYjsHistoryVersion,
         // create a version
-        createTextVersion,
+        createVersionHistorySnapshot,
         // execute a contextual prompt
         executeContextualPrompt,
         // Support for the Liveblocks browser extension
@@ -11547,7 +11822,8 @@ function createRoom(options, config) {
           rawSend: (data) => managedSocket.send(data),
           incomingMessage: (data) => handleServerMessage(new MessageEvent("message", { data }))
         },
-        attachmentUrlsStore: httpClient.getOrCreateAttachmentUrlsStore(roomId)
+        attachmentUrlsStore: httpClient.getOrCreateAttachmentUrlsStore(roomId),
+        fileUrlsStore: httpClient.getOrCreateFileUrlsStore(roomId)
       },
       id: roomId,
       subscribe: makeClassicSubscribeFn(
@@ -11645,6 +11921,8 @@ ${dumpPool(
       prepareAttachment,
       uploadAttachment,
       getAttachmentUrl,
+      uploadFile,
+      getFileUrl,
       // Notifications
       getNotificationSettings: getSubscriptionSettings,
       getSubscriptionSettings,
@@ -12530,6 +12808,11 @@ function toPlainLson(lson) {
       liveblocksType: "LiveList",
       data: [...lson].map((item) => toPlainLson(item))
     };
+  } else if (lson instanceof LiveFile) {
+    return {
+      liveblocksType: "LiveFile",
+      data: lson.data
+    };
   } else {
     return lson;
   }
@@ -12708,6 +12991,7 @@ export {
   DerivedSignal,
   FeedRequestErrorCode,
   HttpError,
+  LiveFile,
   LiveList,
   LiveMap,
   LiveObject,
@@ -12747,6 +13031,7 @@ export {
   createInboxNotificationId,
   createManagedPool,
   createNotificationSettings,
+  createStorageFileId,
   createThreadId,
   deepLiveify,
   defineAiTool,
@@ -12766,6 +13051,7 @@ export {
   isCommentBodyLink,
   isCommentBodyMention,
   isCommentBodyText,
+  isFileStorageNode,
   isJsonArray,
   isJsonObject,
   isJsonScalar,