@droponair/sdk-js 0.3.0

package/dist/core/session-manager.d.ts

@@ -0,0 +1,6 @@
+export declare class SessionManager {
+    private readonly sharedKeyCache;
+    get(peerUserId: string): CryptoKey | null;
+    set(peerUserId: string, key: CryptoKey): void;
+    clear(): void;
+}

package/dist/core/session-manager.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+class SessionManager {
+    constructor() {
+        this.sharedKeyCache = new Map();
+    }
+    get(peerUserId) {
+        return this.sharedKeyCache.get(peerUserId) ?? null;
+    }
+    set(peerUserId, key) {
+        this.sharedKeyCache.set(peerUserId, key);
+    }
+    clear() {
+        this.sharedKeyCache.clear();
+    }
+}
+exports.SessionManager = SessionManager;

package/dist/core/types.d.ts

@@ -0,0 +1,173 @@
+export type DropOnAirEventType = 'SERVER_RECEIVED' | 'DELIVERED' | 'PROCESSED' | 'LIMIT_REACHED' | 'IMPERSONATION_DETECTED' | 'ERROR' | 'CONNECTED' | 'DISCONNECTED' | 'RECONNECTING';
+export interface DropOnAirEvent {
+    type: DropOnAirEventType | string;
+    reason?: string;
+    metadata?: string;
+}
+export interface DecryptedMessage {
+    messageId: string;
+    fromUserId: string;
+    toUserId: string;
+    timestamp: number;
+    plaintext: string;
+}
+export type MessageCallback = (message: DecryptedMessage) => void;
+export type EventCallback = (event: DropOnAirEvent) => void;
+export interface BroadcastMessage {
+    broadcastId: string;
+    channelId: string;
+    publisherId: string;
+    timestamp: number;
+    plaintext: string;
+    sequenceNumber: number;
+}
+export type BroadcastCallback = (message: BroadcastMessage) => void;
+export type CallEventType = 'CALL_INVITE' | 'CALL_RINGING' | 'CALL_ACCEPTED' | 'CALL_REJECTED' | 'CALL_ENDED' | 'CALL_CANCELLED' | 'CALL_SDP_OFFER' | 'CALL_SDP_ANSWER' | 'CALL_ICE_CANDIDATE' | 'CALL_VIDEO_TOGGLE' | 'CALL_DENIED_LIMIT_REACHED';
+export interface CallEvent {
+    type: CallEventType | string;
+    callId?: string;
+    targetUserId?: string;
+    /** Opaque JSON payload: SDP, ICE candidate, or metadata. */
+    payload?: string;
+}
+export type CallEventCallback = (event: CallEvent) => void;
+export interface TurnCredentials {
+    username: string;
+    password: string;
+    uri: string;
+    ttlSeconds: number;
+}
+export interface GroupInfo {
+    groupId: string;
+    name: string;
+    createdBy: string;
+    members: GroupMemberInfo[];
+    createdAt: number;
+}
+export interface GroupMemberInfo {
+    userId: string;
+    role: 'OWNER' | 'ADMIN' | 'MEMBER';
+    joinedAt: number;
+}
+export interface DecryptedGroupMessage {
+    messageId: string;
+    groupId: string;
+    fromUserId: string;
+    timestamp: number;
+    plaintext: string;
+}
+export type GroupMessageCallback = (message: DecryptedGroupMessage) => void;
+export type GroupCallEventType = 'GROUP_CALL_INVITE' | 'GROUP_CALL_RINGING' | 'GROUP_CALL_JOIN' | 'GROUP_CALL_LEAVE' | 'GROUP_CALL_END' | 'GROUP_CALL_ENDED' | 'GROUP_CALL_PARTICIPANT_JOINED' | 'GROUP_CALL_PARTICIPANT_LEFT' | 'GROUP_CALL_ALREADY_ACTIVE' | 'GROUP_CALL_SDP_OFFER' | 'GROUP_CALL_SDP_ANSWER' | 'GROUP_CALL_ICE_CANDIDATE';
+export interface GroupCallEvent {
+    type: GroupCallEventType | string;
+    callId: string;
+    groupId: string;
+    targetUserId?: string;
+    payload?: string;
+}
+export type GroupCallEventCallback = (event: GroupCallEvent) => void;
+export interface KeyStorageAdapter {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    remove(key: string): Promise<void>;
+}
+export interface InitializeOptions {
+    appId: string;
+    publicApiKey: string;
+    getUserJwt: () => Promise<string>;
+    autoConnect?: boolean;
+    messagingWsUrl?: string;
+    messagingHttpUrl?: string;
+    tokenExchangeEndpoint?: string;
+    keyDirectoryEndpoint?: string;
+    fetchFn?: typeof fetch;
+    storage?: KeyStorageAdapter;
+    /** When true, verbose diagnostic logs are emitted to console for all SDK operations. */
+    debug?: boolean;
+    /**
+     * Platform identifier forwarded as the X-Platform header on every backend API call
+     * (e.g. 'ios' or 'android'). Some backends require this header.
+     */
+    platformHeader?: string;
+    /** API version forwarded as the X-API-Version header on every backend API call (e.g. '1.0.0'). */
+    apiVersionHeader?: string;
+    /**
+     * When true (default), SDK sends PROCESSED ack immediately after decrypting inbound messages.
+     * Set false to let app decide when a message is actually seen/read and call `ack(messageId)` manually.
+     */
+    autoAckIncomingMessages?: boolean;
+}
+export interface DropOnAirClient {
+    connect(): Promise<void>;
+    disconnect(): void;
+    sendMessage(toUserId: string, plaintextMessage: string): Promise<{
+        messageId: string;
+    }>;
+    onMessage(callback: MessageCallback): () => void;
+    onEvent(callback: EventCallback): () => void;
+    ack(messageId: string): Promise<void>;
+    /** Send a cleartext message to a user (no encryption). */
+    sendCleartextMessage(toUserId: string, plaintext: string): Promise<{
+        messageId: string;
+    }>;
+    /** Subscribe to a broadcast channel via REST. */
+    subscribeBroadcast(channelId: string): Promise<void>;
+    /** Unsubscribe from a broadcast channel via REST. */
+    unsubscribeBroadcast(channelId: string): Promise<void>;
+    /** Publish a cleartext message to a broadcast channel via WebSocket. */
+    publishBroadcast(channelId: string, plaintext: string): Promise<{
+        broadcastId: string;
+    }>;
+    /** Register a listener for broadcast notifications. Returns an unsubscribe function. */
+    onBroadcast(callback: BroadcastCallback): () => void;
+    /** Initiate an outgoing call. Resolves with the server-assigned callId once CALL_RINGING is received. */
+    startCall(targetUserId: string): Promise<string>;
+    /** Accept an incoming call identified by callId. */
+    acceptCall(callId: string): Promise<void>;
+    /** Reject an incoming call. */
+    rejectCall(callId: string): Promise<void>;
+    /** End an active call (or cancel an unanswered invite). */
+    endCall(callId: string): Promise<void>;
+    /** Toggle local video on/off for an active call. */
+    toggleVideo(callId: string, enabled: boolean): void;
+    /**
+     * Send a raw call signaling frame to the peer.
+     * Used by the application layer to relay SDP offers/answers and ICE candidates.
+     * The payload is forwarded opaquely, the server does NOT inspect or store it.
+     */
+    sendCallSignal(type: 'CALL_SDP_OFFER' | 'CALL_SDP_ANSWER' | 'CALL_ICE_CANDIDATE', callId: string, payload: string): void;
+    /** Register a listener for all incoming call events. Returns an unsubscribe function. */
+    onCallEvent(callback: CallEventCallback): () => void;
+    /** Fetch short-lived TURN credentials for ICE negotiation. */
+    fetchTurnCredentials(): Promise<TurnCredentials>;
+    /** Create a new group with optional initial members. */
+    createGroup(name: string, memberUserIds?: string[]): Promise<GroupInfo>;
+    /** List all groups the current user is a member of. */
+    listGroups(): Promise<GroupInfo[]>;
+    /** Get details of a specific group. */
+    getGroup(groupId: string): Promise<GroupInfo>;
+    /** Add members to a group (requires OWNER/ADMIN role). */
+    addGroupMembers(groupId: string, userIds: string[]): Promise<GroupInfo>;
+    /** Remove a member from a group (OWNER/ADMIN can remove others; anyone can leave). */
+    removeGroupMember(groupId: string, userId: string): Promise<GroupInfo>;
+    /** Delete a group (requires OWNER role). */
+    deleteGroup(groupId: string): Promise<void>;
+    /** Send a cleartext message to a group. */
+    sendGroupMessage(groupId: string, plaintext: string): Promise<{
+        messageId: string;
+    }>;
+    /** Register a listener for incoming group messages. Returns an unsubscribe function. */
+    onGroupMessage(callback: GroupMessageCallback): () => void;
+    /** Initiate a group call. Returns the callId. */
+    startGroupCall(groupId: string): Promise<string>;
+    /** Join an active group call. */
+    joinGroupCall(callId: string, groupId: string): Promise<void>;
+    /** Leave a group call. */
+    leaveGroupCall(callId: string): Promise<void>;
+    /** End a group call for all participants. */
+    endGroupCall(callId: string): Promise<void>;
+    /** Send a signaling frame to a specific peer in a group call. */
+    sendGroupCallSignal(type: 'GROUP_CALL_SDP_OFFER' | 'GROUP_CALL_SDP_ANSWER' | 'GROUP_CALL_ICE_CANDIDATE', callId: string, groupId: string, targetUserId: string, payload: string): void;
+    /** Register a listener for group call events. Returns an unsubscribe function. */
+    onGroupCallEvent(callback: GroupCallEventCallback): () => void;
+}

package/dist/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/crypto/crypto-service.d.ts

@@ -0,0 +1,28 @@
+import { SessionManager } from '../core/session-manager';
+import { KeyStorageAdapter } from '../core/types';
+export declare class CryptoService {
+    private readonly storage;
+    private readonly sessionManager;
+    constructor(storage: KeyStorageAdapter, sessionManager: SessionManager);
+    generateIdentity(): Promise<{
+        publicKey: string;
+    }>;
+    getOrCreateIdentity(): Promise<{
+        publicKey: string;
+    }>;
+    deriveSharedSecret(peerUserId: string, peerPublicKeyBase64: string, localUserId: string): Promise<CryptoKey>;
+    encrypt(plaintext: string, symmetricKey: CryptoKey, aadContext: {
+        messageId: string;
+        senderId: string;
+        recipientId: string;
+        timestamp: number;
+    }): Promise<Uint8Array>;
+    decrypt(encryptedPayload: Uint8Array, symmetricKey: CryptoKey, aadContext: {
+        messageId: string;
+        senderId: string;
+        recipientId: string;
+        timestamp: number;
+    }): Promise<string>;
+    private deriveAesKey;
+    private buildAad;
+}

package/dist/crypto/crypto-service.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoService = void 0;
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const bytes_1 = require("../core/bytes");
+const payload_format_1 = require("./payload-format");
+const STORAGE_PRIVATE = 'droponair.identity.privateKey.v1';
+const STORAGE_PUBLIC = 'droponair.identity.publicKey.v1';
+function asBufferSource(data) {
+    return new Uint8Array(data);
+}
+class CryptoService {
+    constructor(storage, sessionManager) {
+        this.storage = storage;
+        this.sessionManager = sessionManager;
+    }
+    async generateIdentity() {
+        const keyPair = tweetnacl_1.default.box.keyPair();
+        await this.storage.set(STORAGE_PRIVATE, (0, bytes_1.toBase64)(keyPair.secretKey));
+        await this.storage.set(STORAGE_PUBLIC, (0, bytes_1.toBase64)(keyPair.publicKey));
+        return { publicKey: (0, bytes_1.toBase64)(keyPair.publicKey) };
+    }
+    async getOrCreateIdentity() {
+        const existingPublic = await this.storage.get(STORAGE_PUBLIC);
+        const existingPrivate = await this.storage.get(STORAGE_PRIVATE);
+        if (existingPublic && existingPrivate) {
+            return { publicKey: existingPublic };
+        }
+        return this.generateIdentity();
+    }
+    async deriveSharedSecret(peerUserId, peerPublicKeyBase64, localUserId) {
+        // Cache by public key (not userId) to support multi-device, same user may have
+        // different public keys on different devices, each producing a different shared secret.
+        const cacheKey = peerPublicKeyBase64;
+        const cached = this.sessionManager.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        const privateBase64 = await this.storage.get(STORAGE_PRIVATE);
+        if (!privateBase64) {
+            throw new Error('Local identity keypair is missing');
+        }
+        const privateKey = (0, bytes_1.fromBase64)(privateBase64);
+        const peerPublicKey = (0, bytes_1.fromBase64)(peerPublicKeyBase64);
+        if (peerPublicKey.length !== 32 || privateKey.length !== 32) {
+            throw new Error('Invalid X25519 key length');
+        }
+        const sharedSecret = tweetnacl_1.default.scalarMult(privateKey, peerPublicKey);
+        const symmetricKey = await this.deriveAesKey(sharedSecret, localUserId, peerUserId);
+        this.sessionManager.set(cacheKey, symmetricKey);
+        return symmetricKey;
+    }
+    async encrypt(plaintext, symmetricKey, aadContext) {
+        const nonce = (0, bytes_1.randomBytes)(12);
+        const aad = this.buildAad(aadContext);
+        const cipherBuffer = await crypto.subtle.encrypt({
+            name: 'AES-GCM',
+            iv: asBufferSource(nonce),
+            additionalData: asBufferSource(aad),
+            tagLength: 128
+        }, symmetricKey, asBufferSource((0, bytes_1.utf8Encode)(plaintext)));
+        return (0, payload_format_1.packEncryptedPayload)({
+            nonce,
+            ciphertext: new Uint8Array(cipherBuffer)
+        });
+    }
+    async decrypt(encryptedPayload, symmetricKey, aadContext) {
+        const unpacked = (0, payload_format_1.unpackEncryptedPayload)(encryptedPayload);
+        const aad = this.buildAad(aadContext);
+        const plainBuffer = await crypto.subtle.decrypt({
+            name: 'AES-GCM',
+            iv: asBufferSource(unpacked.nonce),
+            additionalData: asBufferSource(aad),
+            tagLength: 128
+        }, symmetricKey, asBufferSource(unpacked.ciphertext));
+        return (0, bytes_1.utf8Decode)(new Uint8Array(plainBuffer));
+    }
+    async deriveAesKey(sharedSecret, localUserId, peerUserId) {
+        const ordering = [localUserId, peerUserId].sort().join(':');
+        const info = (0, bytes_1.utf8Encode)(`droponair-e2ee-v1:${ordering}`);
+        const salt = (0, bytes_1.utf8Encode)('droponair-e2ee-hkdf-salt-v1');
+        const ikm = await crypto.subtle.importKey('raw', asBufferSource(sharedSecret), 'HKDF', false, ['deriveKey']);
+        return crypto.subtle.deriveKey({
+            name: 'HKDF',
+            hash: 'SHA-256',
+            salt: asBufferSource(salt),
+            info: asBufferSource(info)
+        }, ikm, {
+            name: 'AES-GCM',
+            length: 256
+        }, false, ['encrypt', 'decrypt']);
+    }
+    buildAad(context) {
+        return (0, bytes_1.utf8Encode)(`${context.messageId}|${context.senderId}|${context.recipientId}|${context.timestamp}`);
+    }
+}
+exports.CryptoService = CryptoService;

package/dist/crypto/payload-format.d.ts

@@ -0,0 +1,8 @@
+interface PackedEncryptedPayload {
+    nonce: Uint8Array;
+    ciphertext: Uint8Array;
+    signature?: Uint8Array;
+}
+export declare function packEncryptedPayload(payload: PackedEncryptedPayload): Uint8Array;
+export declare function unpackEncryptedPayload(bytes: Uint8Array): PackedEncryptedPayload;
+export {};

package/dist/crypto/payload-format.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packEncryptedPayload = packEncryptedPayload;
+exports.unpackEncryptedPayload = unpackEncryptedPayload;
+const bytes_1 = require("../core/bytes");
+const version_1 = require("../version");
+const VERSION = version_1.PAYLOAD_FORMAT_VERSION;
+const ALGORITHM_AES_256_GCM = 1;
+function uint32Bytes(value) {
+    const out = new Uint8Array(4);
+    const view = new DataView(out.buffer);
+    view.setUint32(0, value, false);
+    return out;
+}
+function readUint32(source, offset) {
+    const view = new DataView(source.buffer, source.byteOffset + offset, 4);
+    return view.getUint32(0, false);
+}
+function packEncryptedPayload(payload) {
+    const signature = payload.signature ?? new Uint8Array(0);
+    const flags = signature.length > 0 ? 1 : 0;
+    const header = new Uint8Array([
+        VERSION,
+        ALGORITHM_AES_256_GCM,
+        payload.nonce.length,
+        flags
+    ]);
+    return (0, bytes_1.concatBytes)(header, uint32Bytes(payload.ciphertext.length), uint32Bytes(signature.length), payload.nonce, payload.ciphertext, signature);
+}
+function unpackEncryptedPayload(bytes) {
+    if (bytes.length < 12) {
+        throw new Error('Invalid encrypted payload frame');
+    }
+    const version = bytes[0];
+    const algorithm = bytes[1];
+    const nonceLength = bytes[2];
+    const flags = bytes[3];
+    if (version !== VERSION) {
+        throw new Error('Unsupported encrypted payload version');
+    }
+    if (algorithm !== ALGORITHM_AES_256_GCM) {
+        throw new Error('Unsupported encrypted payload algorithm');
+    }
+    const cipherLength = readUint32(bytes, 4);
+    const signatureLength = readUint32(bytes, 8);
+    const nonceStart = 12;
+    const cipherStart = nonceStart + nonceLength;
+    const signatureStart = cipherStart + cipherLength;
+    const end = signatureStart + signatureLength;
+    if (bytes.length < end) {
+        throw new Error('Encrypted payload truncated');
+    }
+    const nonce = bytes.slice(nonceStart, cipherStart);
+    const ciphertext = bytes.slice(cipherStart, signatureStart);
+    if ((flags & 1) === 1) {
+        return {
+            nonce,
+            ciphertext,
+            signature: bytes.slice(signatureStart, end)
+        };
+    }
+    return { nonce, ciphertext };
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { InitializeOptions, DropOnAirClient } from './core/types';
+export { SDK_VERSION, PROTOCOL_VERSION, PAYLOAD_FORMAT_VERSION } from './version';
+export declare function initialize(options: InitializeOptions): Promise<DropOnAirClient>;
+export type { InitializeOptions, DropOnAirClient, DropOnAirEvent, MessageCallback, EventCallback, DecryptedMessage, KeyStorageAdapter, CallEvent, CallEventType, CallEventCallback, TurnCredentials, BroadcastMessage, BroadcastCallback, GroupInfo, GroupMemberInfo, DecryptedGroupMessage, GroupMessageCallback, GroupCallEvent, GroupCallEventType, GroupCallEventCallback, } from './core/types';
+declare const _default: {
+    initialize: typeof initialize;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PAYLOAD_FORMAT_VERSION = exports.PROTOCOL_VERSION = exports.SDK_VERSION = void 0;
+exports.initialize = initialize;
+const messaging_client_1 = require("./core/messaging-client");
+const session_manager_1 = require("./core/session-manager");
+const crypto_service_1 = require("./crypto/crypto-service");
+const indexeddb_key_storage_1 = require("./storage/indexeddb-key-storage");
+var version_1 = require("./version");
+Object.defineProperty(exports, "SDK_VERSION", { enumerable: true, get: function () { return version_1.SDK_VERSION; } });
+Object.defineProperty(exports, "PROTOCOL_VERSION", { enumerable: true, get: function () { return version_1.PROTOCOL_VERSION; } });
+Object.defineProperty(exports, "PAYLOAD_FORMAT_VERSION", { enumerable: true, get: function () { return version_1.PAYLOAD_FORMAT_VERSION; } });
+function resolveStorage(adapter) {
+    if (adapter) {
+        return adapter;
+    }
+    return new indexeddb_key_storage_1.IndexedDbKeyStorage();
+}
+async function initialize(options) {
+    const storage = resolveStorage(options.storage);
+    const sessionManager = new session_manager_1.SessionManager();
+    const cryptoService = new crypto_service_1.CryptoService(storage, sessionManager);
+    const client = new messaging_client_1.MessagingClient(options, cryptoService, sessionManager, storage);
+    if (options.autoConnect !== false) {
+        await client.connect();
+    }
+    return client;
+}
+exports.default = { initialize };

package/dist/storage/indexeddb-key-storage.d.ts

@@ -0,0 +1,9 @@
+import { KeyStorageAdapter } from '../core/types';
+export declare class IndexedDbKeyStorage implements KeyStorageAdapter {
+    private readonly fallback;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    remove(key: string): Promise<void>;
+    private isIndexedDbAvailable;
+    private openDb;
+}

package/dist/storage/indexeddb-key-storage.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedDbKeyStorage = void 0;
+const memory_key_storage_1 = require("./memory-key-storage");
+const DB_NAME = 'droponair_sdk';
+const STORE_NAME = 'secure_keys';
+const DB_VERSION = 1;
+class IndexedDbKeyStorage {
+    constructor() {
+        this.fallback = new memory_key_storage_1.MemoryKeyStorage();
+    }
+    async get(key) {
+        if (!this.isIndexedDbAvailable()) {
+            return this.fallback.get(key);
+        }
+        const db = await this.openDb();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, 'readonly');
+            const store = tx.objectStore(STORE_NAME);
+            const req = store.get(key);
+            req.onsuccess = () => {
+                resolve(req.result ?? null);
+            };
+            req.onerror = () => reject(req.error);
+        });
+    }
+    async set(key, value) {
+        if (!this.isIndexedDbAvailable()) {
+            await this.fallback.set(key, value);
+            return;
+        }
+        const db = await this.openDb();
+        await new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, 'readwrite');
+            tx.objectStore(STORE_NAME).put(value, key);
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async remove(key) {
+        if (!this.isIndexedDbAvailable()) {
+            await this.fallback.remove(key);
+            return;
+        }
+        const db = await this.openDb();
+        await new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, 'readwrite');
+            tx.objectStore(STORE_NAME).delete(key);
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    isIndexedDbAvailable() {
+        return typeof indexedDB !== 'undefined';
+    }
+    async openDb() {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(DB_NAME, DB_VERSION);
+            request.onupgradeneeded = () => {
+                const db = request.result;
+                if (!db.objectStoreNames.contains(STORE_NAME)) {
+                    db.createObjectStore(STORE_NAME);
+                }
+            };
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () => reject(request.error);
+        });
+    }
+}
+exports.IndexedDbKeyStorage = IndexedDbKeyStorage;

package/dist/storage/memory-key-storage.d.ts

@@ -0,0 +1,7 @@
+import { KeyStorageAdapter } from '../core/types';
+export declare class MemoryKeyStorage implements KeyStorageAdapter {
+    private readonly state;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    remove(key: string): Promise<void>;
+}

package/dist/storage/memory-key-storage.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryKeyStorage = void 0;
+class MemoryKeyStorage {
+    constructor() {
+        this.state = new Map();
+    }
+    async get(key) {
+        return this.state.get(key) ?? null;
+    }
+    async set(key, value) {
+        this.state.set(key, value);
+    }
+    async remove(key) {
+        this.state.delete(key);
+    }
+}
+exports.MemoryKeyStorage = MemoryKeyStorage;