@msssystems/mss-link-sdk 0.1.12 → 0.2.1

package/dist/modules/media/media-crypto.client.js

@@ -0,0 +1,90 @@
+import { normalizeLocalCryptoError } from '../../errors/decryption-errors';
+import { buildMediaMessageMetadataPayload, extractMediaAssetIds, serializeMediaMessageMetadata, } from './media-message-metadata';
+export class MediaCryptoClient {
+    engine;
+    constructor(engine) {
+        this.engine = engine;
+    }
+    async sendMediaMessage(params) {
+        try {
+            await this.engine.ensureReady();
+            const payload = buildMediaMessageMetadataPayload(params.attachments, params.caption);
+            const metadataJson = serializeMediaMessageMetadata(payload);
+            const mediaAssetIds = extractMediaAssetIds(params.attachments);
+            return this.engine.runWithClient((client) => client.sendMediaMessage(params.chatId, params.targetUserId, metadataJson, mediaAssetIds));
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+    async encryptMediaBlob(input) {
+        try {
+            const plaintext = new Uint8Array(await input.blob.arrayBuffer());
+            const encrypted = await this.engine.queue.run(async () => {
+                const module = await this.engine.loadWasmModule();
+                return module.encryptMediaBytes(plaintext);
+            });
+            const encryptedBytes = new Uint8Array(encrypted.ciphertext);
+            return {
+                encryptedBlob: new Blob([encryptedBytes], {
+                    type: 'application/octet-stream',
+                }),
+                encryption: {
+                    schema: 'mss.link.media-encryption.v1',
+                    algorithm: 'AES-256-GCM',
+                    keyId: input.assetId,
+                    nonce: encrypted.nonce,
+                    wrappedKey: encrypted.key,
+                },
+                attachment: {
+                    assetId: input.assetId,
+                    mimeType: input.mimeType,
+                    size: input.size,
+                    ...(input.originalName ? { originalName: input.originalName } : {}),
+                    ...(input.uploadedAt ? { uploadedAt: input.uploadedAt } : {}),
+                    encryption: {
+                        schema: 'mss.link.media-encryption.v1',
+                        algorithm: 'AES-256-GCM',
+                        keyId: input.assetId,
+                        nonce: encrypted.nonce,
+                        wrappedKey: encrypted.key,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+    async decryptMediaBlob(input) {
+        const encryption = input.metadata.encryption;
+        if (!encryption) {
+            return {
+                blob: input.encryptedBlob,
+                mimeType: input.metadata.mimeType,
+                ...(input.metadata.originalName
+                    ? { fileName: input.metadata.originalName }
+                    : {}),
+            };
+        }
+        try {
+            const ciphertext = new Uint8Array(await input.encryptedBlob.arrayBuffer());
+            const plaintext = await this.engine.queue.run(async () => {
+                const module = await this.engine.loadWasmModule();
+                return module.decryptMediaBytes(ciphertext, encryption.wrappedKey, encryption.nonce);
+            });
+            return {
+                blob: new Blob([new Uint8Array(plaintext)], {
+                    type: input.metadata.mimeType,
+                }),
+                mimeType: input.metadata.mimeType,
+                ...(input.metadata.originalName
+                    ? { fileName: input.metadata.originalName }
+                    : {}),
+            };
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+}

package/dist/{client → modules/messages}/message-decryption-state.js

@@ -1,4 +1,4 @@
-import { normalizeLocalCryptoError } from './decryption-errors';
+import { normalizeLocalCryptoError } from '../../errors/decryption-errors';
 export function createMessageDecryptionStateIndex({ messages, decryptedMessages, isDecrypting, decryptError, }) {
     const decryptedById = createDecryptedMessageIndex(decryptedMessages);
     const index = new Map();

package/dist/{client → modules/messages}/message-decryption.contracts.d.ts

@@ -1,4 +1,4 @@
-import type { LocalCryptoErrorCode } from './decryption-errors';
+import type { LocalCryptoErrorCode } from '../../errors/decryption-errors';
 import type { DecryptedMessage } from './message.contracts';
 export type MessageDecryptStatus = 'decrypted' | 'pending' | 'failed' | 'recovery_required';
 export type MessageDecryptReason = 'local_sync_in_progress' | 'local_message_missing' | 'local_crypto_error';

package/dist/modules/messages/messages-crypto.client.d.ts

@@ -0,0 +1,14 @@
+import { WasmCryptoEngine } from '../../core/wasm-crypto-engine';
+import type { DecryptedMessage } from './message.contracts';
+export declare class MessagesCryptoClient {
+    private readonly engine;
+    constructor(engine: WasmCryptoEngine);
+    sendMessage(params: {
+        chatId: string;
+        targetUserId: string;
+        text: string;
+        kind?: string;
+    }): Promise<string>;
+    syncMessages(): Promise<void>;
+    getLocalMessages(chatId: string): Promise<DecryptedMessage[]>;
+}

package/dist/modules/messages/messages-crypto.client.js

@@ -0,0 +1,34 @@
+import { normalizeLocalCryptoError } from '../../errors/decryption-errors';
+import { mapLocalSdkMessage } from './message.mapper';
+export class MessagesCryptoClient {
+    engine;
+    constructor(engine) {
+        this.engine = engine;
+    }
+    async sendMessage(params) {
+        try {
+            await this.engine.ensureReady();
+            return this.engine.runWithClient((client) => client.sendMessage(params.chatId, params.targetUserId, params.text, params.kind ?? 'TEXT'));
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+    async syncMessages() {
+        try {
+            await this.engine.runWithClient((client) => client.syncMessages());
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+    async getLocalMessages(chatId) {
+        try {
+            const rawMessages = await this.engine.runWithClient((client) => client.getLocalMessages(chatId));
+            return rawMessages.map((message) => mapLocalSdkMessage(message));
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+}

package/dist/modules/messages/messages.client.d.ts

@@ -0,0 +1,8 @@
+import { HttpClient } from '../../core/http-client';
+export declare class MessagesClient {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(chatId: string, limit?: number, before?: string, after?: string): Promise<any>;
+    markDelivered(chatId: string, throughMessageId: string, limit?: number): Promise<any>;
+    markRead(chatId: string, throughMessageId: string, limit?: number): Promise<any>;
+}

package/dist/modules/messages/messages.client.js

@@ -0,0 +1,24 @@
+// TODO: Import proper types from contracts
+export class MessagesClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list(chatId, limit = 30, before, after) {
+        return this.http.get(`/link/v1/chats/${chatId}/messages`, {
+            params: { limit, before, after }
+        });
+    }
+    async markDelivered(chatId, throughMessageId, limit) {
+        return this.http.post(`/link/v1/chats/${chatId}/messages/delivered`, {
+            throughMessageId,
+            limit
+        });
+    }
+    async markRead(chatId, throughMessageId, limit) {
+        return this.http.post(`/link/v1/chats/${chatId}/messages/read`, {
+            throughMessageId,
+            limit
+        });
+    }
+}

package/dist/{client → modules/storage}/drive-file-runtime.contracts.d.ts

@@ -1,5 +1,5 @@
-import type { DecryptedMediaBlobResult } from './media-crypto.contracts';
-import type { MediaMessageAttachmentMetadata } from './media-message.contracts';
+import type { DecryptedMediaBlobResult } from '../media/media-crypto.contracts';
+import type { MediaMessageAttachmentMetadata } from '../media/media-message.contracts';
 export type DriveFilePreviewKind = 'image' | 'pdf' | 'text' | 'unsupported' | 'video';
 export interface DriveFileContentEnvelope {
     algorithm?: 'AES-256-GCM' | string | null;

package/dist/{client → modules/storage}/drive-file-runtime.d.ts

@@ -1,4 +1,4 @@
-import type { DecryptedMediaBlobResult } from './media-crypto.contracts';
+import type { DecryptedMediaBlobResult } from '../media/media-crypto.contracts';
 import type { DriveFileAttachmentInput, DriveFileMediaMetadata, DriveFilePreviewInput, DriveFilePreviewKind, DriveFileRuntimeMetadataInput, PreparedDriveFileAttachment, PreparedDriveFilePreview } from './drive-file-runtime.contracts';
 export declare function buildDriveFileMediaMetadata(input: DriveFileRuntimeMetadataInput): DriveFileMediaMetadata;
 export declare function getDriveFilePreviewKind(mimeType: string): DriveFilePreviewKind;

package/dist/modules/storage/drive-sharing.contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/modules/storage/storage-crypto.client.d.ts

@@ -0,0 +1,13 @@
+import { WasmCryptoEngine } from '../../core/wasm-crypto-engine';
+import type { DecryptDriveFileMetadataInput, DecryptDriveFolderMetadataInput, DecryptedDriveFileMetadata, DecryptedDriveFolderMetadata, EncryptedDriveFileMetadata, EncryptedDriveFolderMetadata, EncryptDriveFileMetadataInput, EncryptDriveFolderMetadataInput } from './storage-metadata-crypto.contracts';
+import type { CreateDriveWrappedFolderKeyForRecipientInput, CreateDriveWrappedItemKeyForRecipientInput, DriveWrappedItemKeyForRecipientResult } from './drive-key-wrapping.contracts';
+export declare class StorageCryptoClient {
+    private readonly engine;
+    constructor(engine: WasmCryptoEngine);
+    encryptDriveFolderMetadata(input: EncryptDriveFolderMetadataInput): Promise<EncryptedDriveFolderMetadata>;
+    decryptDriveFolderMetadata(input: DecryptDriveFolderMetadataInput): Promise<DecryptedDriveFolderMetadata>;
+    encryptDriveFileMetadata(input: EncryptDriveFileMetadataInput): Promise<EncryptedDriveFileMetadata>;
+    decryptDriveFileMetadata(input: DecryptDriveFileMetadataInput): Promise<DecryptedDriveFileMetadata>;
+    createDriveWrappedItemKeyForRecipient(input: CreateDriveWrappedItemKeyForRecipientInput): Promise<DriveWrappedItemKeyForRecipientResult>;
+    createDriveWrappedFolderKeyForRecipient(input: CreateDriveWrappedFolderKeyForRecipientInput): Promise<DriveWrappedItemKeyForRecipientResult>;
+}

package/dist/modules/storage/storage-crypto.client.js

@@ -0,0 +1,73 @@
+import { normalizeLocalCryptoError } from '../../errors/decryption-errors';
+import { buildDecryptedDriveFileMetadata, buildDecryptedDriveFolderMetadata, buildEncryptedDriveFileMetadata, buildEncryptedDriveFolderMetadata, normalizeDriveFileMetadataInput, normalizeDriveFolderMetadataInput, normalizeEncryptedDriveFileMetadataInput, normalizeEncryptedDriveFolderMetadataInput, } from './storage-metadata-crypto';
+import { createDriveWrappedFolderKeyForRecipient, createDriveWrappedItemKeyForRecipient, } from './drive-key-wrapping';
+export class StorageCryptoClient {
+    engine;
+    constructor(engine) {
+        this.engine = engine;
+    }
+    async encryptDriveFolderMetadata(input) {
+        try {
+            const metadata = normalizeDriveFolderMetadataInput(input);
+            const encryptedName = await this.engine.queue.run(async () => {
+                const module = await this.engine.loadWasmModule();
+                return module.encryptStorageMetadata(metadata.name);
+            });
+            return buildEncryptedDriveFolderMetadata(encryptedName);
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+    async decryptDriveFolderMetadata(input) {
+        try {
+            const metadata = normalizeEncryptedDriveFolderMetadataInput(input);
+            const name = await this.engine.queue.run(async () => {
+                const module = await this.engine.loadWasmModule();
+                return module.decryptStorageMetadata(metadata.encryptedName);
+            });
+            return buildDecryptedDriveFolderMetadata(name);
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+    async encryptDriveFileMetadata(input) {
+        try {
+            const metadata = normalizeDriveFileMetadataInput(input);
+            const [encryptedName, encryptedMimeType] = await this.engine.queue.run(async () => {
+                const module = await this.engine.loadWasmModule();
+                return [
+                    module.encryptStorageMetadata(metadata.name),
+                    module.encryptStorageMetadata(metadata.mimeType),
+                ];
+            });
+            return buildEncryptedDriveFileMetadata(encryptedName, encryptedMimeType);
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+    async decryptDriveFileMetadata(input) {
+        try {
+            const metadata = normalizeEncryptedDriveFileMetadataInput(input);
+            const [name, mimeType] = await this.engine.queue.run(async () => {
+                const module = await this.engine.loadWasmModule();
+                return [
+                    module.decryptStorageMetadata(metadata.encryptedName),
+                    module.decryptStorageMetadata(metadata.encryptedMimeType),
+                ];
+            });
+            return buildDecryptedDriveFileMetadata(name, mimeType);
+        }
+        catch (error) {
+            throw normalizeLocalCryptoError(error);
+        }
+    }
+    createDriveWrappedItemKeyForRecipient(input) {
+        return createDriveWrappedItemKeyForRecipient(input);
+    }
+    createDriveWrappedFolderKeyForRecipient(input) {
+        return createDriveWrappedFolderKeyForRecipient(input);
+    }
+}

package/dist/modules/storage/storage-metadata-crypto.contracts.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@msssystems/mss-link-sdk",
-  "version": "0.1.12",
+  "version": "0.2.1",
   "description": "Official managed application SDK for MSS ecosystem",
   "type": "module",
   "main": "./dist/index.js",

package/dist/client/mss-link-browser-client.d.ts

@@ -1,46 +0,0 @@
-import type { MssLinkBrowserClientOptions } from './client-options';
-import type { LocalCryptoHealth } from './local-crypto-health.contracts';
-import type { DecryptMediaBlobInput, DecryptedMediaBlobResult, EncryptedMediaBlobResult, EncryptMediaBlobInput } from './media-crypto.contracts';
-import type { SendMediaMessageParams } from './media-message.contracts';
-import type { DecryptedMessage } from './message.contracts';
-import type { DecryptDriveFileMetadataInput, DecryptDriveFolderMetadataInput, DecryptedDriveFileMetadata, DecryptedDriveFolderMetadata, EncryptedDriveFileMetadata, EncryptedDriveFolderMetadata, EncryptDriveFileMetadataInput, EncryptDriveFolderMetadataInput } from './storage-metadata-crypto.contracts';
-import type { CreateDriveWrappedFolderKeyForRecipientInput, CreateDriveWrappedItemKeyForRecipientInput, DriveWrappedItemKeyForRecipientResult } from './drive-key-wrapping.contracts';
-export declare class MssLinkBrowserClient {
-    private readonly userId;
-    private readonly apiBaseUrl;
-    private readonly deviceId;
-    private readonly registrationId;
-    private readonly signedPrekeyId;
-    private readonly initialOneTimePrekeyCount;
-    private readonly minOneTimePrekeys;
-    private readonly replenishOneTimePrekeys;
-    private readonly queue;
-    private wasmClient;
-    private wasmModulePromise;
-    private accessToken;
-    constructor(options: MssLinkBrowserClientOptions);
-    setAccessToken(accessToken: string | null): void;
-    ensureReady(): Promise<void>;
-    getLocalCryptoHealth(): Promise<LocalCryptoHealth>;
-    sendMessage(params: {
-        chatId: string;
-        targetUserId: string;
-        text: string;
-        kind?: string;
-    }): Promise<string>;
-    sendMediaMessage(params: SendMediaMessageParams): Promise<string>;
-    encryptMediaBlob(input: EncryptMediaBlobInput): Promise<EncryptedMediaBlobResult>;
-    decryptMediaBlob(input: DecryptMediaBlobInput): Promise<DecryptedMediaBlobResult>;
-    encryptDriveFolderMetadata(input: EncryptDriveFolderMetadataInput): Promise<EncryptedDriveFolderMetadata>;
-    decryptDriveFolderMetadata(input: DecryptDriveFolderMetadataInput): Promise<DecryptedDriveFolderMetadata>;
-    encryptDriveFileMetadata(input: EncryptDriveFileMetadataInput): Promise<EncryptedDriveFileMetadata>;
-    decryptDriveFileMetadata(input: DecryptDriveFileMetadataInput): Promise<DecryptedDriveFileMetadata>;
-    createDriveWrappedItemKeyForRecipient(input: CreateDriveWrappedItemKeyForRecipientInput): Promise<DriveWrappedItemKeyForRecipientResult>;
-    createDriveWrappedFolderKeyForRecipient(input: CreateDriveWrappedFolderKeyForRecipientInput): Promise<DriveWrappedItemKeyForRecipientResult>;
-    syncMessages(): Promise<void>;
-    getLocalMessages(chatId: string): Promise<DecryptedMessage[]>;
-    reset(): void;
-    private runWithClient;
-    private getClient;
-    private loadWasmModule;
-}

package/dist/client/mss-link-browser-client.js

@@ -1,259 +0,0 @@
-import { normalizeProductApiBaseUrl } from './api-base-url';
-import { normalizeLocalCryptoError } from './decryption-errors';
-import { checkLocalCryptoHealth } from './local-crypto-health';
-import { buildMediaMessageMetadataPayload, extractMediaAssetIds, serializeMediaMessageMetadata, } from './media-message-metadata';
-import { mapLocalSdkMessage } from './message.mapper';
-import { buildDecryptedDriveFileMetadata, buildDecryptedDriveFolderMetadata, buildEncryptedDriveFileMetadata, buildEncryptedDriveFolderMetadata, normalizeDriveFileMetadataInput, normalizeDriveFolderMetadataInput, normalizeEncryptedDriveFileMetadataInput, normalizeEncryptedDriveFolderMetadataInput, } from './storage-metadata-crypto';
-import { createDriveWrappedFolderKeyForRecipient, createDriveWrappedItemKeyForRecipient, } from './drive-key-wrapping';
-import { WasmCallQueue } from './wasm-call-queue';
-const DEFAULT_DEVICE_ID = 1;
-const DEFAULT_REGISTRATION_ID = 1;
-const DEFAULT_SIGNED_PREKEY_ID = 1;
-const DEFAULT_ONE_TIME_PREKEY_COUNT = 10;
-const DEFAULT_MIN_ONE_TIME_PREKEYS = 5;
-const DEFAULT_REPLENISH_ONE_TIME_PREKEYS = 10;
-export class MssLinkBrowserClient {
-    userId;
-    apiBaseUrl;
-    deviceId;
-    registrationId;
-    signedPrekeyId;
-    initialOneTimePrekeyCount;
-    minOneTimePrekeys;
-    replenishOneTimePrekeys;
-    queue = new WasmCallQueue();
-    wasmClient = null;
-    wasmModulePromise = null;
-    accessToken;
-    constructor(options) {
-        this.userId = options.userId;
-        this.apiBaseUrl = normalizeProductApiBaseUrl(options.apiBaseUrl);
-        this.accessToken = options.accessToken ?? null;
-        this.deviceId = options.deviceId ?? DEFAULT_DEVICE_ID;
-        this.registrationId =
-            options.registrationId ?? DEFAULT_REGISTRATION_ID;
-        this.signedPrekeyId =
-            options.signedPrekeyId ?? DEFAULT_SIGNED_PREKEY_ID;
-        this.initialOneTimePrekeyCount =
-            options.initialOneTimePrekeyCount ??
-                DEFAULT_ONE_TIME_PREKEY_COUNT;
-        this.minOneTimePrekeys =
-            options.minOneTimePrekeys ?? DEFAULT_MIN_ONE_TIME_PREKEYS;
-        this.replenishOneTimePrekeys =
-            options.replenishOneTimePrekeys ??
-                DEFAULT_REPLENISH_ONE_TIME_PREKEYS;
-    }
-    setAccessToken(accessToken) {
-        this.accessToken = accessToken;
-        this.wasmClient?.setAccessToken(accessToken);
-    }
-    async ensureReady() {
-        try {
-            await this.runWithClient(async (client) => {
-                await client.ensureDeviceRegistered(this.registrationId, this.signedPrekeyId, this.initialOneTimePrekeyCount);
-                await client.replenishOneTimePreKeys(this.minOneTimePrekeys, this.replenishOneTimePrekeys);
-            });
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async getLocalCryptoHealth() {
-        return checkLocalCryptoHealth(() => this.ensureReady());
-    }
-    async sendMessage(params) {
-        try {
-            await this.ensureReady();
-            return this.runWithClient((client) => client.sendMessage(params.chatId, params.targetUserId, params.text, params.kind ?? 'TEXT'));
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async sendMediaMessage(params) {
-        try {
-            await this.ensureReady();
-            const payload = buildMediaMessageMetadataPayload(params.attachments, params.caption);
-            const metadataJson = serializeMediaMessageMetadata(payload);
-            const mediaAssetIds = extractMediaAssetIds(params.attachments);
-            return this.runWithClient((client) => client.sendMediaMessage(params.chatId, params.targetUserId, metadataJson, mediaAssetIds));
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async encryptMediaBlob(input) {
-        try {
-            const plaintext = new Uint8Array(await input.blob.arrayBuffer());
-            const encrypted = await this.queue.run(async () => {
-                const module = await this.loadWasmModule();
-                return module.encryptMediaBytes(plaintext);
-            });
-            const encryptedBytes = new Uint8Array(encrypted.ciphertext);
-            return {
-                encryptedBlob: new Blob([encryptedBytes], {
-                    type: 'application/octet-stream',
-                }),
-                encryption: {
-                    schema: 'mss.link.media-encryption.v1',
-                    algorithm: 'AES-256-GCM',
-                    keyId: input.assetId,
-                    nonce: encrypted.nonce,
-                    wrappedKey: encrypted.key,
-                },
-                attachment: {
-                    assetId: input.assetId,
-                    mimeType: input.mimeType,
-                    size: input.size,
-                    ...(input.originalName ? { originalName: input.originalName } : {}),
-                    ...(input.uploadedAt ? { uploadedAt: input.uploadedAt } : {}),
-                    encryption: {
-                        schema: 'mss.link.media-encryption.v1',
-                        algorithm: 'AES-256-GCM',
-                        keyId: input.assetId,
-                        nonce: encrypted.nonce,
-                        wrappedKey: encrypted.key,
-                    },
-                },
-            };
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async decryptMediaBlob(input) {
-        const encryption = input.metadata.encryption;
-        if (!encryption) {
-            return {
-                blob: input.encryptedBlob,
-                mimeType: input.metadata.mimeType,
-                ...(input.metadata.originalName
-                    ? { fileName: input.metadata.originalName }
-                    : {}),
-            };
-        }
-        try {
-            const ciphertext = new Uint8Array(await input.encryptedBlob.arrayBuffer());
-            const plaintext = await this.queue.run(async () => {
-                const module = await this.loadWasmModule();
-                return module.decryptMediaBytes(ciphertext, encryption.wrappedKey, encryption.nonce);
-            });
-            return {
-                blob: new Blob([new Uint8Array(plaintext)], {
-                    type: input.metadata.mimeType,
-                }),
-                mimeType: input.metadata.mimeType,
-                ...(input.metadata.originalName
-                    ? { fileName: input.metadata.originalName }
-                    : {}),
-            };
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async encryptDriveFolderMetadata(input) {
-        try {
-            const metadata = normalizeDriveFolderMetadataInput(input);
-            const encryptedName = await this.queue.run(async () => {
-                const module = await this.loadWasmModule();
-                return module.encryptStorageMetadata(metadata.name);
-            });
-            return buildEncryptedDriveFolderMetadata(encryptedName);
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async decryptDriveFolderMetadata(input) {
-        try {
-            const metadata = normalizeEncryptedDriveFolderMetadataInput(input);
-            const name = await this.queue.run(async () => {
-                const module = await this.loadWasmModule();
-                return module.decryptStorageMetadata(metadata.encryptedName);
-            });
-            return buildDecryptedDriveFolderMetadata(name);
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async encryptDriveFileMetadata(input) {
-        try {
-            const metadata = normalizeDriveFileMetadataInput(input);
-            const [encryptedName, encryptedMimeType] = await this.queue.run(async () => {
-                const module = await this.loadWasmModule();
-                return [
-                    module.encryptStorageMetadata(metadata.name),
-                    module.encryptStorageMetadata(metadata.mimeType),
-                ];
-            });
-            return buildEncryptedDriveFileMetadata(encryptedName, encryptedMimeType);
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async decryptDriveFileMetadata(input) {
-        try {
-            const metadata = normalizeEncryptedDriveFileMetadataInput(input);
-            const [name, mimeType] = await this.queue.run(async () => {
-                const module = await this.loadWasmModule();
-                return [
-                    module.decryptStorageMetadata(metadata.encryptedName),
-                    module.decryptStorageMetadata(metadata.encryptedMimeType),
-                ];
-            });
-            return buildDecryptedDriveFileMetadata(name, mimeType);
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    createDriveWrappedItemKeyForRecipient(input) {
-        return createDriveWrappedItemKeyForRecipient(input);
-    }
-    createDriveWrappedFolderKeyForRecipient(input) {
-        return createDriveWrappedFolderKeyForRecipient(input);
-    }
-    async syncMessages() {
-        try {
-            await this.runWithClient((client) => client.syncMessages());
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async getLocalMessages(chatId) {
-        try {
-            const rawMessages = await this.runWithClient((client) => client.getLocalMessages(chatId));
-            return rawMessages.map((message) => mapLocalSdkMessage(message));
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    reset() {
-        this.wasmClient?.free();
-        this.wasmClient = null;
-        this.wasmModulePromise = null;
-    }
-    async runWithClient(callback) {
-        return this.queue.run(async () => callback(await this.getClient()));
-    }
-    async getClient() {
-        if (typeof window === 'undefined') {
-            throw new Error('MSS Link browser client is available only in browser context.');
-        }
-        if (!this.wasmClient) {
-            const sdkModule = await this.loadWasmModule();
-            this.wasmClient = new sdkModule.WasmMssClient(this.userId, this.deviceId, this.apiBaseUrl);
-            this.wasmClient.setAccessToken(this.accessToken);
-        }
-        return this.wasmClient;
-    }
-    loadWasmModule() {
-        this.wasmModulePromise ??= import('@msssystems/mss-crypto-wasm').then((module) => module);
-        return this.wasmModulePromise;
-    }
-}