@telecrypt-io/storage 0.7.2 → 0.9.0

package/dist/TeleCryptIOStorage.js

@@ -1,4 +1,4 @@
-import { ClientEvent, createClient, EventType, MatrixEvent, MatrixError, Preset, RoomCreateTypeField, RoomType, SyncState, UNSTABLE_MSC3088_ENABLED, UNSTABLE_MSC3088_PURPOSE, UNSTABLE_MSC3089_BRANCH, UNSTABLE_MSC3089_TREE_SUBTYPE, } from "matrix-js-sdk";
+import { ClientEvent, createClient, EventType, MatrixEvent, MatrixError, MsgType, Preset, RoomCreateTypeField, RoomType, SyncState, UNSTABLE_MSC3088_ENABLED, UNSTABLE_MSC3088_PURPOSE, UNSTABLE_MSC3089_BRANCH, UNSTABLE_MSC3089_LEAF, UNSTABLE_MSC3089_TREE_SUBTYPE, } from "matrix-js-sdk";
 import { Method } from "matrix-js-sdk/lib/http-api/method.js";
 import { ClientPrefix } from "matrix-js-sdk/lib/http-api/prefix.js";
 import { encryptAttachment, decryptAttachment } from "matrix-encrypt-attachment";
@@ -9,6 +9,11 @@ import { cancelResponseBody, raceWithAbort, readMediaResponseBody, readResponseB
 import { sanitizeDiagnosticText } from "./core/oidc.js";
 import { validateName } from "./core/validation.js";
 import { isTreeDeleted } from "./deletion-markers.js";
+import { DecryptionKeySafe } from "./key-safe.js";
+const STORAGE_METADATA_EVENT_TYPE = "io.telecrypt.storage.metadata";
+const STORAGE_METADATA_MSGTYPE = "io.telecrypt.storage.metadata";
+const GENERIC_TREE_NAME = "Encrypted storage";
+const GENERIC_FILE_NAME = "Encrypted file";
 const recoveryMutationQueues = new WeakMap();
 const treeMutationQueues = new WeakMap();
 const TREE_SYNC_TIMEOUT_MS = 15000;
@@ -235,12 +240,6 @@ export function readFileEventMetadata(content) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-async function isUndecryptableFilePlaceholder(branch) {
-    // matrix-js-sdk replaces failed encrypted event content with m.bad.encrypted;
-    // its public failure flag is the authoritative state and avoids guessing
-    // from that display content (or misclassifying malformed plaintext events).
-    return (await branch.getFileEvent()).isDecryptionFailure();
-}
 function validateSecretStorageStatus(value) {
     if (!isRecord(value))
         throw new RecoverySetupAmbiguousError();
@@ -408,9 +407,18 @@ export async function withTreeMutation(client, operation, signal) {
 }
 export class TeleCryptIOStorage {
     client;
+    syncOptions;
     decoratedTreeSpaces = new WeakSet();
-    constructor(client) {
+    decoratedFileBranches = new WeakMap();
+    treeNames = new Map();
+    fileNames = new Map();
+    keySafe;
+    syncStarted = false;
+    syncInFlight;
+    constructor(client, options = {}, syncOptions = {}) {
         this.client = client;
+        this.syncOptions = syncOptions;
+        this.keySafe = new DecryptionKeySafe(client, (key, operation, signal) => this.withSecretStorageKey(key, operation, signal), options, (signal) => this.startSync(signal));
         // Advanced callers may construct a MatrixClient themselves. The SDK does
         // not mutate matrix-js-sdk internals: configure that client with the
         // supported createClient({ fetchFn, localTimeoutMs }) options, or use
@@ -420,6 +428,264 @@ export class TeleCryptIOStorage {
     getClient() {
         return this.client;
     }
+    /** Start Matrix room sync after crypto setup, for example after the current
+     * login has checked or restored its Decryption Key Safe. */
+    async startSync(signal) {
+        if (this.syncStarted)
+            return;
+        if (this.syncInFlight)
+            return this.syncInFlight;
+        const start = (async () => {
+            try {
+                TeleCryptIOStorage.throwIfAborted(signal);
+                const timeoutMs = this.syncOptions.syncTimeoutMs ?? 15000;
+                this.syncOptions.onProgress?.("Starting Matrix client…");
+                await TeleCryptIOStorage.withTimeout(this.client.startClient({ initialSyncLimit: this.syncOptions.initialSyncLimit ?? 10 }), timeoutMs, "client start", signal);
+                this.syncOptions.onProgress?.("Waiting for first sync with homeserver…");
+                await TeleCryptIOStorage.waitForFirstSync(this.client, timeoutMs, signal);
+                TeleCryptIOStorage.throwIfAborted(signal);
+                this.syncStarted = true;
+                this.syncOptions.onProgress?.("Sync complete.");
+            }
+            catch (error) {
+                try {
+                    this.client.stopClient();
+                }
+                catch (stopError) {
+                    throw new AggregateError([error, stopError], "Matrix sync startup and cleanup failed");
+                }
+                throw error;
+            }
+            finally {
+                this.syncInFlight = undefined;
+            }
+        })();
+        this.syncInFlight = start;
+        return start;
+    }
+    fileNameKey(treeId, fileId) {
+        return `${treeId}\u0000${fileId}`;
+    }
+    getStateEvent(roomId, eventType, stateKey) {
+        const state = this.client.getRoom(roomId)?.currentState;
+        const raw = state?.getStateEvents(eventType, stateKey);
+        if (Array.isArray(raw))
+            return raw[0] ?? null;
+        return raw ?? null;
+    }
+    getTreeOwnerId(roomId) {
+        const create = this.getStateEvent(roomId, EventType.RoomCreate, "");
+        const ownerId = create?.getSender();
+        if (!ownerId)
+            throw new StorageError("storage owner is unavailable");
+        return ownerId;
+    }
+    async sendEncryptedMetadataMessage(roomId, content) {
+        const response = await this.client.sendMessage(roomId, content);
+        return validateMatrixEventId(response?.event_id, "storage metadata response event ID");
+    }
+    async readEncryptedMetadataMessage(roomId, eventId, allowRedacted = false) {
+        const rawEvent = await this.client.fetchRoomEvent(roomId, eventId);
+        const event = this.client.getEventMapper()(rawEvent);
+        await this.client.decryptEventIfNeeded(event);
+        if (event.isDecryptionFailure())
+            throw new UndecryptableFileError();
+        if (allowRedacted &&
+            event.getId() === eventId &&
+            event.getRoomId() === roomId &&
+            event.getSender() === this.getTreeOwnerId(roomId) &&
+            event.isRedacted()) {
+            return event;
+        }
+        if (event.getId() !== eventId ||
+            event.getRoomId() !== roomId ||
+            event.getSender() !== this.getTreeOwnerId(roomId) ||
+            event.getWireType() !== EventType.RoomMessageEncrypted ||
+            event.getType() !== EventType.RoomMessage) {
+            throw new StorageError("encrypted storage metadata is invalid or unavailable");
+        }
+        return event;
+    }
+    async writeTreeName(roomId, name) {
+        validateName(name, "name");
+        const metadataEventId = await this.sendEncryptedMetadataMessage(roomId, {
+            msgtype: STORAGE_METADATA_MSGTYPE,
+            body: name,
+        });
+        await this.client.sendStateEvent(roomId, STORAGE_METADATA_EVENT_TYPE, { event_id: metadataEventId }, "");
+        this.treeNames.set(roomId, name);
+    }
+    /** Resolves an encrypted vault/folder name through its pointer state event. */
+    async getTreeName(roomId, options) {
+        if (options?.signal?.aborted)
+            throw new StorageError("operation cancelled");
+        await this.refreshRoomState(roomId, options);
+        const pointer = this.getStateEvent(roomId, STORAGE_METADATA_EVENT_TYPE, "");
+        const pointerContent = pointer?.getContent();
+        if (!pointer ||
+            pointer.getSender() !== this.getTreeOwnerId(roomId) ||
+            !isRecord(pointerContent) ||
+            typeof pointerContent.event_id !== "string") {
+            throw new StorageError("encrypted storage name is unavailable");
+        }
+        const metadataEventId = validateMatrixEventId(pointerContent.event_id, "storage metadata event ID");
+        let event;
+        try {
+            event = await this.readEncryptedMetadataMessage(roomId, metadataEventId);
+        }
+        catch (error) {
+            // A new device can list storage before restoring room keys. Keep the
+            // room visible with a generic label; a later call retries decryption.
+            if (error instanceof UndecryptableFileError)
+                return GENERIC_TREE_NAME;
+            throw error;
+        }
+        const content = event.getContent();
+        if (!isRecord(content) ||
+            content.msgtype !== STORAGE_METADATA_MSGTYPE ||
+            typeof content.body !== "string" ||
+            Object.hasOwn(content, "file_event_id")) {
+            throw new StorageError("encrypted storage name is invalid or unavailable");
+        }
+        validateName(content.body, "name");
+        this.treeNames.set(roomId, content.body);
+        return content.body;
+    }
+    async writeFileName(treeId, fileId, name) {
+        validateName(name, "file name");
+        validateMatrixEventId(fileId, "file event ID");
+        const metadataEventId = await this.sendEncryptedMetadataMessage(treeId, {
+            msgtype: STORAGE_METADATA_MSGTYPE,
+            body: name,
+            file_event_id: fileId,
+        });
+        await this.client.sendStateEvent(treeId, UNSTABLE_MSC3089_BRANCH.name, { active: true, metadata_event_id: metadataEventId }, fileId);
+        this.fileNames.set(this.fileNameKey(treeId, fileId), name);
+    }
+    /** Resolves an encrypted file name from the MSC3089 index pointer. */
+    async getFileName(treeId, fileId, options) {
+        if (options?.signal?.aborted)
+            throw new StorageError("operation cancelled");
+        if (options?.refreshState !== false)
+            await this.refreshRoomState(treeId, options);
+        const tree = this.getTree(treeId);
+        const branch = tree?.getFile(fileId);
+        if (!branch || branch.isActive === false)
+            throw new StorageError("file not found");
+        const indexEvent = branch.indexEvent;
+        const indexContent = indexEvent?.getContent();
+        if (!indexEvent ||
+            indexEvent.getSender() !== this.getTreeOwnerId(treeId) ||
+            !isRecord(indexContent) ||
+            indexContent.active !== true ||
+            typeof indexContent.metadata_event_id !== "string") {
+            throw new StorageError("encrypted file name is unavailable");
+        }
+        const metadataEventId = validateMatrixEventId(indexContent.metadata_event_id, "file metadata event ID");
+        let event;
+        try {
+            event = await this.readEncryptedMetadataMessage(treeId, metadataEventId);
+        }
+        catch (error) {
+            // File IDs remain listable on a fresh device while its room keys are
+            // being restored. The caller can resolve the private name on retry.
+            if (error instanceof UndecryptableFileError)
+                return GENERIC_FILE_NAME;
+            throw error;
+        }
+        const content = event.getContent();
+        if (!isRecord(content) || typeof content.body !== "string") {
+            throw new StorageError("encrypted file name is invalid or unavailable");
+        }
+        if (content.msgtype === MsgType.File) {
+            if (metadataEventId !== fileId || !isRecord(content.file)) {
+                throw new StorageError("encrypted file metadata does not match its listing");
+            }
+        }
+        else if (content.msgtype !== STORAGE_METADATA_MSGTYPE ||
+            content.file_event_id !== fileId) {
+            throw new StorageError("encrypted file metadata does not match its listing");
+        }
+        validateName(content.body, "file name");
+        this.fileNames.set(this.fileNameKey(treeId, fileId), content.body);
+        return content.body;
+    }
+    /** Returns the current file metadata pointer, including on inactive branches. */
+    async getFileMetadataEventId(treeId, fileId, options) {
+        if (options?.signal?.aborted)
+            throw new StorageError("operation cancelled");
+        await this.refreshRoomState(treeId, options);
+        const branch = this.getTree(treeId)?.getFile(fileId);
+        if (!branch)
+            throw new StorageError("file not found");
+        const indexEvent = branch.indexEvent;
+        const content = indexEvent?.getContent();
+        if (!indexEvent || indexEvent.getSender() !== this.getTreeOwnerId(treeId)) {
+            throw new StorageError("encrypted file listing is unavailable");
+        }
+        if (!isRecord(content) ||
+            typeof content.metadata_event_id !== "string") {
+            if (branch.isActive === false || indexEvent.isRedacted())
+                return null;
+            throw new StorageError("encrypted file name is unavailable");
+        }
+        return validateMatrixEventId(content.metadata_event_id, "file metadata event ID");
+    }
+    /** Fetches and validates a current encrypted rename event, allowing retries after redaction. */
+    async getFileRenameMetadataEvent(treeId, fileId, metadataEventId) {
+        const event = await this.readEncryptedMetadataMessage(treeId, metadataEventId, true);
+        if (event.isRedacted())
+            return event;
+        const content = event.getContent();
+        if (!isRecord(content) ||
+            content.msgtype !== STORAGE_METADATA_MSGTYPE ||
+            content.file_event_id !== fileId ||
+            typeof content.body !== "string") {
+            throw new StorageError("encrypted file metadata does not match its listing");
+        }
+        validateName(content.body, "file name");
+        return event;
+    }
+    /** Fetches the original encrypted file message directly by event ID. */
+    async getOriginalFileEvent(treeId, fileId, allowRedacted = false) {
+        const event = await this.readEncryptedMetadataMessage(treeId, fileId, allowRedacted);
+        if (event.isRedacted() && allowRedacted)
+            return event;
+        const content = event.getContent();
+        if (!isRecord(content) ||
+            content.msgtype !== MsgType.File ||
+            typeof content.body !== "string" ||
+            !isRecord(content.file) ||
+            typeof content.file.url !== "string") {
+            throw new StorageError("encrypted file message is invalid or unavailable");
+        }
+        return event;
+    }
+    async createEncryptedFile(treeId, name, encryptedContents, info, additionalContent) {
+        validateFileName(name);
+        const bytes = encryptedContents instanceof Uint8Array
+            ? encryptedContents
+            : new Uint8Array(encryptedContents);
+        const body = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+        const uploaded = await this.client.uploadContent(body, { includeFilename: false });
+        if (typeof uploaded.content_uri !== "string" || uploaded.content_uri.length === 0) {
+            throw new StorageError("encrypted media upload returned no content URI");
+        }
+        const fileInfo = { ...info, url: uploaded.content_uri };
+        const fileContent = {
+            ...additionalContent,
+            msgtype: MsgType.File,
+            body: name,
+            url: uploaded.content_uri,
+            file: fileInfo,
+            [UNSTABLE_MSC3089_LEAF.name]: {},
+        };
+        const sent = await this.client.sendMessage(treeId, fileContent);
+        const fileEventId = validateMatrixEventId(sent?.event_id, "file upload response event ID");
+        await this.client.sendStateEvent(treeId, UNSTABLE_MSC3089_BRANCH.name, { active: true, metadata_event_id: fileEventId }, fileEventId);
+        this.fileNames.set(this.fileNameKey(treeId, fileEventId), name);
+        return { event_id: fileEventId };
+    }
     /**
      * Refreshes a room's current state from the homeserver. The background sync
      * loop is intentionally asynchronous, so a short-lived CLI process can
@@ -523,10 +789,11 @@ export class TeleCryptIOStorage {
         return TeleCryptIOStorage.bootstrap(client, opts);
     }
     /** Shared post-construction bootstrap for `create()`/`createFromOidc()`:
-     * persistent crypto store, first sync, wrap in a `TeleCryptIOStorage`. */
+     * persistent crypto store, optional first sync, wrap in a `TeleCryptIOStorage`. */
     static async bootstrap(client, opts) {
         const progress = opts.onProgress ?? (() => { });
         const persistent = opts.persistentCryptoStore ?? true;
+        let storage;
         try {
             progress("Loading encryption engine (WASM)…");
             await TeleCryptIOStorage.withTimeout(client.initRustCrypto({
@@ -534,27 +801,35 @@ export class TeleCryptIOStorage {
                 cryptoDatabasePrefix: opts.cryptoDatabasePrefix ?? `telecrypt-io-storage::${opts.userId}::${opts.deviceId}`,
             }), opts.initTimeoutMs ?? 60000, "crypto init", opts.signal);
             progress("Encryption ready — opening secure store…");
-            progress("Starting Matrix client…");
-            // Mark this before awaiting: startClient can start its sync loop and then
-            // reject while reporting an error from the initial request.
-            await TeleCryptIOStorage.withTimeout(client.startClient({ initialSyncLimit: opts.initialSyncLimit ?? 10 }), opts.syncTimeoutMs ?? 15000, "client start", opts.signal);
-            progress("Waiting for first sync with homeserver…");
-            await TeleCryptIOStorage.waitForFirstSync(client, opts.syncTimeoutMs ?? 15000, opts.signal);
-            TeleCryptIOStorage.throwIfAborted(opts.signal);
-            progress("Sync complete.");
-            return new TeleCryptIOStorage(client);
+            storage = new TeleCryptIOStorage(client, opts, opts);
+            if (opts.startClient === false) {
+                // Rust Crypto starts checking server-side backup state during init. A
+                // short-lived caller (the CLI login transaction) may close this
+                // client before that background check finishes, so drain it before
+                // returning the sync-deferred client.
+                const crypto = client.getCrypto();
+                if (crypto) {
+                    await TeleCryptIOStorage.withTimeout(crypto.checkKeyBackupAndEnable(), opts.syncTimeoutMs ?? 15000, "crypto backup check", opts.signal);
+                }
+            }
+            else {
+                await storage.startSync(opts.signal);
+            }
+            return storage;
         }
         catch (error) {
             // stopClient is idempotent in matrix-js-sdk and is also required after
             // init/timeout failures: crypto startup can have installed listeners or
             // a sync task before the awaited operation rejects.
-            try {
-                client.stopClient();
-            }
-            catch (cleanupError) {
-                throw new AggregateError([error, cleanupError], "storage bootstrap and client cleanup failed", {
-                    cause: error,
-                });
+            if (!storage) {
+                try {
+                    client.stopClient();
+                }
+                catch (cleanupError) {
+                    throw new AggregateError([error, cleanupError], "storage bootstrap and client cleanup failed", {
+                        cause: error,
+                    });
+                }
             }
             throw error;
         }
@@ -768,12 +1043,7 @@ export class TeleCryptIOStorage {
         if (signal?.aborted)
             throw new StorageError("operation cancelled");
         try {
-            await withRecoveryCryptoDeadline(() => crypto.bootstrapCrossSigning({
-                // No existing verified device to interactively re-authenticate against
-                // for this account, so there is nothing to feed into `makeRequest`;
-                // matches the working pattern already proven in keys.test.ts.
-                authUploadDeviceSigningKeys: async () => undefined,
-            }), signal, "cross-signing bootstrap");
+            await withRecoveryCryptoDeadline(() => crypto.bootstrapCrossSigning({}), signal, "cross-signing bootstrap");
         }
         catch (error) {
             // Cross-signing setup can commit server-side state before a transport
@@ -1030,7 +1300,7 @@ export class TeleCryptIOStorage {
         if (!userId)
             throw new Error("createTree: Matrix client has no user ID");
         return {
-            name,
+            name: GENERIC_TREE_NAME,
             preset: Preset.PrivateChat,
             power_level_content_override: {
                 invite: 100,
@@ -1052,6 +1322,7 @@ export class TeleCryptIOStorage {
                     [EventType.SpaceChild]: 100,
                     [EventType.SpaceParent]: 100,
                     [UNSTABLE_MSC3089_BRANCH.name]: 100,
+                    [STORAGE_METADATA_EVENT_TYPE]: 100,
                 },
                 users: { [userId]: 100 },
             },
@@ -1119,10 +1390,46 @@ export class TeleCryptIOStorage {
             return tree;
         this.decoratedTreeSpaces.add(tree);
         const originalGetDirectories = tree.getDirectories.bind(tree);
+        const originalListFiles = typeof tree.listFiles === "function"
+            ? tree.listFiles.bind(tree)
+            : () => [];
+        const originalGetFile = typeof tree.getFile === "function"
+            ? tree.getFile.bind(tree)
+            : () => null;
         tree.getDirectories = () => originalGetDirectories().map((child) => this.decorateTreeSpace(child));
         tree.createDirectory = (name) => this.createSubtree(tree, name);
+        tree.setName = (name) => this.writeTreeName(tree.id, name);
+        tree.listFiles = () => originalListFiles().map((branch) => this.decorateFileBranch(tree.id, branch));
+        tree.getFile = (fileId) => {
+            const branch = originalGetFile(fileId);
+            return branch ? this.decorateFileBranch(tree.id, branch) : null;
+        };
+        tree.createFile = (name, encryptedContents, info, additionalContent) => this.createEncryptedFile(tree.id, name, encryptedContents, info, additionalContent);
         return tree;
     }
+    decorateFileBranch(treeId, branch) {
+        const existing = this.decoratedFileBranches.get(branch);
+        if (existing)
+            return existing;
+        const decorated = Object.create(branch);
+        const nameKey = this.fileNameKey(treeId, branch.id);
+        Object.defineProperties(decorated, {
+            getName: {
+                value: () => this.fileNames.get(nameKey) ?? GENERIC_FILE_NAME,
+            },
+            setName: {
+                value: (name) => this.writeFileName(treeId, branch.id, name),
+            },
+            delete: {
+                value: async () => {
+                    const { deleteFile } = await import("./core/operations.js");
+                    await deleteFile(this, treeId, branch.id);
+                },
+            },
+        });
+        this.decoratedFileBranches.set(branch, decorated);
+        return decorated;
+    }
     /** Cleans up only a room created by this operation and reports incomplete cleanup. */
     async cleanupCreatedRoom(roomId) {
         // Cleanup is compensating work. It must not inherit the caller's already
@@ -1203,9 +1510,26 @@ export class TeleCryptIOStorage {
             throw new RoomCreationAmbiguousError(operation, error);
         }
         try {
-            return await this.waitForTreeSpace(roomId, operation, signal);
+            const tree = await this.waitForTreeSpace(roomId, operation, signal);
+            try {
+                await this.writeTreeName(roomId, name);
+            }
+            catch (error) {
+                try {
+                    await this.cleanupCreatedRoom(roomId);
+                }
+                catch (cleanupError) {
+                    throwWithCleanupDetail(error, roomId, cleanupError);
+                }
+                throw new StorageError(`${operation}: encrypted name initialization failed`, { cause: error });
+            }
+            return tree;
         }
         catch (error) {
+            if (error instanceof StorageError &&
+                error.message === `${operation}: encrypted name initialization failed`) {
+                throw error;
+            }
             try {
                 await this.cleanupCreatedRoom(roomId);
             }
@@ -1409,7 +1733,9 @@ export class TeleCryptIOStorage {
         const members = parseMatrixMembersResponse(membersBody);
         const pls = parseMatrixPowerLevels(plsRaw);
         const viewLevel = pls.users_default ?? 0;
-        const editLevel = pls.events_default ?? 50;
+        // Match matrix-js-sdk's MSC3089TreeSpace.getPermissions() default. An
+        // explicit zero still means regular users lack the editor threshold.
+        const editLevel = pls.events_default || 50;
         const adminLevel = pls.events?.["m.room.power_levels"] ?? 100;
         const roleFor = (userId) => {
             const userLevel = pls.users?.[userId] ?? viewLevel;
@@ -1479,27 +1805,17 @@ export class TeleCryptIOStorage {
         if (signal?.aborted)
             throw new StorageError("operation cancelled");
         let info;
+        let fileEvent;
         try {
-            ({ info } = await branch.getFileInfo());
+            fileEvent = await this.getOriginalFileEvent(branch.roomId, branch.id);
+            const content = fileEvent.getContent();
+            info = isRecord(content) && isRecord(content.file) ? content.file : undefined;
         }
         catch (error) {
             if (signal?.aborted)
                 throw new StorageError("operation cancelled");
             if (error instanceof StorageError || error instanceof MatrixError)
                 throw error;
-            // matrix-js-sdk's file-info accessor reads an attachment absent from
-            // failed-decryption events. Use its explicit decryption status, not a
-            // guessed content shape; preserve other SDK/transport failures.
-            let isPlaceholder = false;
-            try {
-                isPlaceholder = await isUndecryptableFilePlaceholder(branch);
-            }
-            catch (placeholderError) {
-                throw new AggregateError([error, placeholderError], "file metadata lookup and placeholder inspection both failed", { cause: error });
-            }
-            if (isPlaceholder) {
-                throw new UndecryptableFileError();
-            }
             throw error;
         }
         // Missing metadata alone does not establish a decryption failure.
@@ -1509,7 +1825,7 @@ export class TeleCryptIOStorage {
         // `info` is the encrypted attachment descriptor. Its shape is owned by
         // matrix-encrypt-attachment and does not carry the plaintext size. The
         // event's `info` block is the sole source of user-facing file metadata.
-        const eventMetadata = readFileEventMetadata((await branch.getFileEvent()).getContent());
+        const eventMetadata = readFileEventMetadata(fileEvent.getContent());
         if (signal?.aborted)
             throw new StorageError("operation cancelled");
         const declaredSize = eventMetadata.size;