@archipelagolab/lobi 1.0.5 → 1.0.7

package/dist/src/matrix/sdk.js

@@ -1,1375 +0,0 @@
-import {
-  VerificationMethod
-} from "../../chunk-6NO5VEVV.js";
-import {
-  MatrixRecoveryKeyStore,
-  isRepairableSecretStorageAccessError
-} from "../../chunk-FQTLJO4W.js";
-import {
-  MATRIX_IDB_PERSIST_INTERVAL_MS
-} from "../../chunk-CY6WHUCW.js";
-import {
-  isMatrixReadySyncState,
-  isMatrixTerminalSyncState
-} from "../../chunk-MISZB5QJ.js";
-import {
-  FileBackedMatrixSyncStore,
-  createClient
-} from "../../chunk-OFWMLQMU.js";
-import {
-  ClientEvent,
-  Preset
-} from "../../chunk-YFTE4H54.js";
-import "../../chunk-MAF6PSCJ.js";
-import "../../chunk-4O3BEYYM.js";
-import "../../chunk-FQ4R7IOX.js";
-import "../../chunk-PSL2AHIA.js";
-import {
-  createMatrixJsSdkClientLogger
-} from "../../chunk-MJ27XQYG.js";
-import "../../chunk-CGBWMONK.js";
-import {
-  resolveMatrixRoomKeyBackupReadinessError
-} from "../../chunk-HQSHS6IB.js";
-import {
-  formatMatrixErrorMessage,
-  formatMatrixErrorReason,
-  isMatrixNotFoundError
-} from "../../chunk-UWPHOAOC.js";
-import "../../chunk-D7Q6Z74D.js";
-import {
-  MatrixAuthedHttpClient
-} from "../../chunk-SAOUP24A.js";
-import {
-  createMatrixGuardedFetch
-} from "../../chunk-XQYIIPOJ.js";
-import "../../chunk-FYRKBNTI.js";
-import {
-  matrixEventToRaw,
-  parseMxc
-} from "../../chunk-YUPBD27Z.js";
-import "../../chunk-Z6IVJ6ZW.js";
-import {
-  createMatrixStartupAbortError,
-  throwIfMatrixStartupAborted
-} from "../../chunk-UXDDOSJC.js";
-import {
-  ConsoleLogger,
-  LogService,
-  noop
-} from "../../chunk-BMFZL2P4.js";
-import "../../chunk-L5OUVMHK.js";
-import "../../chunk-3UFTTK7C.js";
-import "../../chunk-FHNEN6IR.js";
-import "../../chunk-UU5PSBSI.js";
-import "../../chunk-AQQGAE7N.js";
-import "../../chunk-SSEX66OL.js";
-import "../../chunk-BWA3D22L.js";
-import "../../chunk-MH74AJ3A.js";
-import {
-  init_shims
-} from "../../chunk-7FLQSTPG.js";
-
-// src/matrix/sdk.ts
-init_shims();
-import { EventEmitter } from "node:events";
-import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
-import { normalizeNullableString } from "openclaw/plugin-sdk/text-runtime";
-var MATRIX_INITIAL_CRYPTO_BOOTSTRAP_OPTIONS = {
-  allowAutomaticCrossSigningReset: false
-};
-var MATRIX_AUTOMATIC_REPAIR_BOOTSTRAP_OPTIONS = {
-  forceResetCrossSigning: true,
-  allowSecretStorageRecreateWithoutRecoveryKey: true,
-  strict: true
-};
-function createMatrixExplicitBootstrapOptions(params) {
-  return {
-    forceResetCrossSigning: params?.forceResetCrossSigning === true,
-    allowSecretStorageRecreateWithoutRecoveryKey: true,
-    strict: true
-  };
-}
-var loadedMatrixCryptoRuntime = null;
-var matrixCryptoRuntimePromise = null;
-async function loadMatrixCryptoRuntime() {
-  matrixCryptoRuntimePromise ??= import("./sdk/crypto-runtime.js").then((runtime) => {
-    loadedMatrixCryptoRuntime = runtime;
-    return runtime;
-  });
-  return await matrixCryptoRuntimePromise;
-}
-var normalizeOptionalString = normalizeNullableString;
-function isUnsupportedAuthenticatedMediaEndpointError(err) {
-  const statusCode = err?.statusCode;
-  if (statusCode === 404 || statusCode === 405 || statusCode === 501) {
-    return true;
-  }
-  const message = formatMatrixErrorReason(err);
-  return message.includes("m_unrecognized") || message.includes("unrecognized request") || message.includes("method not allowed") || message.includes("not implemented");
-}
-var MatrixClient = class {
-  constructor(homeserver, accessToken, opts = {}) {
-    this.emitter = new EventEmitter();
-    this.bridgeRegistered = false;
-    this.started = false;
-    this.cryptoBootstrapped = false;
-    this.dmRoomIds = /* @__PURE__ */ new Set();
-    this.cryptoInitialized = false;
-    this.sendQueue = new KeyedAsyncQueue();
-    this.stopPersistPromise = null;
-    this.verificationSummaryListenerBound = false;
-    this.currentSyncState = null;
-    this.dms = {
-      update: async () => {
-        return await this.refreshDmCache();
-      },
-      isDm: (roomId) => this.dmRoomIds.has(roomId)
-    };
-    this.idbPersistTimer = null;
-    this.httpClient = new MatrixAuthedHttpClient({
-      homeserver,
-      accessToken,
-      ssrfPolicy: opts.ssrfPolicy,
-      dispatcherPolicy: opts.dispatcherPolicy
-    });
-    this.localTimeoutMs = Math.max(1, opts.localTimeoutMs ?? 6e4);
-    this.initialSyncLimit = opts.initialSyncLimit;
-    this.encryptionEnabled = opts.encryption === true;
-    this.password = opts.password;
-    this.syncStore = opts.storagePath ? new FileBackedMatrixSyncStore(opts.storagePath) : void 0;
-    this.idbSnapshotPath = opts.idbSnapshotPath;
-    this.cryptoDatabasePrefix = opts.cryptoDatabasePrefix;
-    this.selfUserId = opts.userId?.trim() || null;
-    this.autoBootstrapCrypto = opts.autoBootstrapCrypto !== false;
-    this.recoveryKeyStore = new MatrixRecoveryKeyStore(opts.recoveryKeyPath);
-    const cryptoCallbacks = this.encryptionEnabled ? this.recoveryKeyStore.buildCryptoCallbacks() : void 0;
-    this.client = createClient({
-      baseUrl: homeserver,
-      accessToken,
-      userId: opts.userId,
-      deviceId: opts.deviceId,
-      logger: createMatrixJsSdkClientLogger("MatrixClient"),
-      localTimeoutMs: this.localTimeoutMs,
-      fetchFn: createMatrixGuardedFetch({
-        ssrfPolicy: opts.ssrfPolicy,
-        dispatcherPolicy: opts.dispatcherPolicy
-      }),
-      store: this.syncStore,
-      cryptoCallbacks,
-      verificationMethods: [
-        VerificationMethod.Sas,
-        VerificationMethod.ShowQrCode,
-        VerificationMethod.ScanQrCode,
-        VerificationMethod.Reciprocate
-      ]
-    });
-  }
-  on(eventName, listener) {
-    this.emitter.on(eventName, listener);
-    return this;
-  }
-  off(eventName, listener) {
-    this.emitter.off(eventName, listener);
-    return this;
-  }
-  async ensureCryptoSupportInitialized() {
-    if (this.decryptBridge && (!this.encryptionEnabled || this.verificationManager && this.cryptoBootstrapper && this.crypto)) {
-      return;
-    }
-    const runtime = await loadMatrixCryptoRuntime();
-    this.decryptBridge ??= new runtime.MatrixDecryptBridge({
-      client: this.client,
-      toRaw: (event) => matrixEventToRaw(event),
-      emitDecryptedEvent: (roomId, event) => {
-        this.emitter.emit("room.decrypted_event", roomId, event);
-      },
-      emitMessage: (roomId, event) => {
-        this.emitter.emit("room.message", roomId, event);
-      },
-      emitFailedDecryption: (roomId, event, error) => {
-        this.emitter.emit("room.failed_decryption", roomId, event, error);
-      }
-    });
-    if (!this.encryptionEnabled) {
-      return;
-    }
-    this.verificationManager ??= new runtime.MatrixVerificationManager();
-    this.cryptoBootstrapper ??= new runtime.MatrixCryptoBootstrapper({
-      getUserId: () => this.getUserId(),
-      getPassword: () => this.password,
-      getDeviceId: () => this.client.getDeviceId(),
-      verificationManager: this.verificationManager,
-      recoveryKeyStore: this.recoveryKeyStore,
-      decryptBridge: this.decryptBridge
-    });
-    if (!this.crypto) {
-      this.crypto = runtime.createMatrixCryptoFacade({
-        client: this.client,
-        verificationManager: this.verificationManager,
-        recoveryKeyStore: this.recoveryKeyStore,
-        getRoomStateEvent: (roomId, eventType, stateKey = "") => this.getRoomStateEvent(roomId, eventType, stateKey),
-        downloadContent: (mxcUrl) => this.downloadContent(mxcUrl)
-      });
-    }
-    if (!this.verificationSummaryListenerBound) {
-      this.verificationSummaryListenerBound = true;
-      this.verificationManager.onSummaryChanged((summary) => {
-        this.emitter.emit("verification.summary", summary);
-      });
-    }
-  }
-  async start(opts = {}) {
-    await this.startSyncSession({
-      bootstrapCrypto: true,
-      abortSignal: opts.abortSignal,
-      readyTimeoutMs: opts.readyTimeoutMs
-    });
-  }
-  async waitForInitialSyncReady(params = {}) {
-    const timeoutMs = params.timeoutMs ?? 3e4;
-    if (isMatrixReadySyncState(this.currentSyncState)) {
-      return;
-    }
-    if (isMatrixTerminalSyncState(this.currentSyncState)) {
-      throw new Error(`Matrix sync entered ${this.currentSyncState} during startup`);
-    }
-    await new Promise((resolve, reject) => {
-      let settled = false;
-      let timeoutId;
-      const abortSignal = params.abortSignal;
-      const cleanup = () => {
-        this.off("sync.state", onSyncState);
-        this.off("sync.unexpected_error", onUnexpectedError);
-        abortSignal?.removeEventListener("abort", onAbort);
-        if (timeoutId) {
-          clearTimeout(timeoutId);
-          timeoutId = void 0;
-        }
-      };
-      const settleResolve = () => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        cleanup();
-        resolve();
-      };
-      const settleReject = (error) => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        cleanup();
-        reject(error);
-      };
-      const onSyncState = (state, _prevState, error) => {
-        if (isMatrixReadySyncState(state)) {
-          settleResolve();
-          return;
-        }
-        if (isMatrixTerminalSyncState(state)) {
-          settleReject(
-            new Error(
-              error instanceof Error && error.message ? error.message : `Matrix sync entered ${state} during startup`
-            )
-          );
-        }
-      };
-      const onUnexpectedError = (error) => {
-        settleReject(error);
-      };
-      const onAbort = () => {
-        settleReject(createMatrixStartupAbortError());
-      };
-      this.on("sync.state", onSyncState);
-      this.on("sync.unexpected_error", onUnexpectedError);
-      if (abortSignal?.aborted) {
-        onAbort();
-        return;
-      }
-      abortSignal?.addEventListener("abort", onAbort, { once: true });
-      timeoutId = setTimeout(() => {
-        settleReject(
-          new Error(`Matrix client did not reach a ready sync state within ${timeoutMs}ms`)
-        );
-      }, timeoutMs);
-      timeoutId.unref?.();
-    });
-  }
-  async startSyncSession(opts) {
-    if (this.started) {
-      return;
-    }
-    throwIfMatrixStartupAborted(opts.abortSignal);
-    await this.ensureCryptoSupportInitialized();
-    throwIfMatrixStartupAborted(opts.abortSignal);
-    this.registerBridge();
-    await this.initializeCryptoIfNeeded(opts.abortSignal);
-    await this.client.startClient({
-      initialSyncLimit: this.initialSyncLimit
-    });
-    await this.waitForInitialSyncReady({
-      abortSignal: opts.abortSignal,
-      timeoutMs: opts.readyTimeoutMs
-    });
-    throwIfMatrixStartupAborted(opts.abortSignal);
-    if (opts.bootstrapCrypto && this.autoBootstrapCrypto) {
-      await this.bootstrapCryptoIfNeeded(opts.abortSignal);
-    }
-    throwIfMatrixStartupAborted(opts.abortSignal);
-    this.started = true;
-    this.emitOutstandingInviteEvents();
-    await this.refreshDmCache().catch(noop);
-  }
-  async prepareForOneOff() {
-    if (!this.encryptionEnabled) {
-      return;
-    }
-    await this.ensureCryptoSupportInitialized();
-    await this.initializeCryptoIfNeeded();
-    if (!this.crypto) {
-      return;
-    }
-    try {
-      const joinedRooms = await this.getJoinedRooms();
-      await this.crypto.prepare(joinedRooms);
-    } catch {
-    }
-  }
-  hasPersistedSyncState() {
-    return this.syncStore?.hasSavedSyncFromCleanShutdown() === true;
-  }
-  async ensureStartedForCryptoControlPlane() {
-    if (this.started) {
-      return;
-    }
-    await this.startSyncSession({ bootstrapCrypto: false });
-  }
-  stopSyncWithoutPersist() {
-    if (this.idbPersistTimer) {
-      clearInterval(this.idbPersistTimer);
-      this.idbPersistTimer = null;
-    }
-    this.currentSyncState = null;
-    this.client.stopClient();
-    this.started = false;
-  }
-  async drainPendingDecryptions(reason = "matrix client shutdown") {
-    await this.decryptBridge?.drainPendingDecryptions(reason);
-  }
-  stop() {
-    this.stopSyncWithoutPersist();
-    this.decryptBridge?.stop();
-    this.syncStore?.markCleanShutdown();
-    if (loadedMatrixCryptoRuntime) {
-      const { persistIdbToDisk } = loadedMatrixCryptoRuntime;
-      this.stopPersistPromise = Promise.all([
-        persistIdbToDisk({
-          snapshotPath: this.idbSnapshotPath,
-          databasePrefix: this.cryptoDatabasePrefix
-        }).catch(noop),
-        this.syncStore?.flush().catch(noop)
-      ]).then(() => void 0);
-      return;
-    }
-    this.stopPersistPromise = loadMatrixCryptoRuntime().then(async ({ persistIdbToDisk }) => {
-      await Promise.all([
-        persistIdbToDisk({
-          snapshotPath: this.idbSnapshotPath,
-          databasePrefix: this.cryptoDatabasePrefix
-        }).catch(noop),
-        this.syncStore?.flush().catch(noop)
-      ]);
-    }).catch(noop).then(() => void 0);
-  }
-  async stopAndPersist() {
-    this.stop();
-    await this.stopPersistPromise;
-  }
-  async bootstrapCryptoIfNeeded(abortSignal) {
-    if (!this.encryptionEnabled || !this.cryptoInitialized || this.cryptoBootstrapped) {
-      return;
-    }
-    throwIfMatrixStartupAborted(abortSignal);
-    await this.ensureCryptoSupportInitialized();
-    const crypto = this.client.getCrypto();
-    if (!crypto) {
-      return;
-    }
-    const cryptoBootstrapper = this.cryptoBootstrapper;
-    if (!cryptoBootstrapper) {
-      return;
-    }
-    const initial = await cryptoBootstrapper.bootstrap(
-      crypto,
-      MATRIX_INITIAL_CRYPTO_BOOTSTRAP_OPTIONS
-    );
-    throwIfMatrixStartupAborted(abortSignal);
-    if (!initial.crossSigningPublished || initial.ownDeviceVerified === false) {
-      const status = await this.getOwnDeviceVerificationStatus();
-      if (status.signedByOwner) {
-        LogService.warn(
-          "MatrixClientLite",
-          "Cross-signing/bootstrap is incomplete for an already owner-signed device; skipping automatic reset and preserving the current identity. Restore the recovery key or run an explicit verification bootstrap if repair is needed."
-        );
-      } else if (this.password?.trim()) {
-        try {
-          const repaired = await cryptoBootstrapper.bootstrap(
-            crypto,
-            MATRIX_AUTOMATIC_REPAIR_BOOTSTRAP_OPTIONS
-          );
-          throwIfMatrixStartupAborted(abortSignal);
-          if (repaired.crossSigningPublished && repaired.ownDeviceVerified !== false) {
-            LogService.info(
-              "MatrixClientLite",
-              "Cross-signing/bootstrap recovered after forced reset"
-            );
-          }
-        } catch (err) {
-          LogService.warn(
-            "MatrixClientLite",
-            "Failed to recover cross-signing/bootstrap with forced reset:",
-            err
-          );
-        }
-      } else {
-        LogService.warn(
-          "MatrixClientLite",
-          "Cross-signing/bootstrap incomplete and no password is configured for UIA fallback"
-        );
-      }
-    }
-    this.cryptoBootstrapped = true;
-  }
-  async initializeCryptoIfNeeded(abortSignal) {
-    if (!this.encryptionEnabled || this.cryptoInitialized) {
-      return;
-    }
-    throwIfMatrixStartupAborted(abortSignal);
-    const { persistIdbToDisk, restoreIdbFromDisk } = await loadMatrixCryptoRuntime();
-    await restoreIdbFromDisk(this.idbSnapshotPath);
-    throwIfMatrixStartupAborted(abortSignal);
-    try {
-      await this.client.initRustCrypto({
-        cryptoDatabasePrefix: this.cryptoDatabasePrefix
-      });
-      this.cryptoInitialized = true;
-      throwIfMatrixStartupAborted(abortSignal);
-      await persistIdbToDisk({
-        snapshotPath: this.idbSnapshotPath,
-        databasePrefix: this.cryptoDatabasePrefix
-      });
-      throwIfMatrixStartupAborted(abortSignal);
-      this.idbPersistTimer = setInterval(() => {
-        persistIdbToDisk({
-          snapshotPath: this.idbSnapshotPath,
-          databasePrefix: this.cryptoDatabasePrefix
-        }).catch(noop);
-      }, MATRIX_IDB_PERSIST_INTERVAL_MS);
-    } catch (err) {
-      LogService.warn("MatrixClientLite", "Failed to initialize rust crypto:", err);
-    }
-  }
-  async getUserId() {
-    const fromClient = this.client.getUserId();
-    if (fromClient) {
-      this.selfUserId = fromClient;
-      return fromClient;
-    }
-    if (this.selfUserId) {
-      return this.selfUserId;
-    }
-    const whoami = await this.doRequest("GET", "/_lobi/client/v3/account/whoami");
-    const resolved = whoami.user_id?.trim();
-    if (!resolved) {
-      throw new Error("Matrix whoami did not return user_id");
-    }
-    this.selfUserId = resolved;
-    return resolved;
-  }
-  async getJoinedRooms() {
-    const joined = await this.client.getJoinedRooms();
-    return Array.isArray(joined.joined_rooms) ? joined.joined_rooms : [];
-  }
-  async getJoinedRoomMembers(roomId) {
-    const members = await this.client.getJoinedRoomMembers(roomId);
-    const joined = members?.joined;
-    if (!joined || typeof joined !== "object") {
-      return [];
-    }
-    return Object.keys(joined);
-  }
-  async getRoomStateEvent(roomId, eventType, stateKey = "") {
-    const state = await this.client.getStateEvent(roomId, eventType, stateKey);
-    return state ?? {};
-  }
-  async getAccountData(eventType) {
-    const event = this.client.getAccountData(eventType);
-    return event?.getContent() ?? void 0;
-  }
-  async setAccountData(eventType, content) {
-    await this.client.setAccountData(eventType, content);
-    await this.refreshDmCache().catch(noop);
-  }
-  async resolveRoom(aliasOrRoomId) {
-    if (aliasOrRoomId.startsWith("!")) {
-      return aliasOrRoomId;
-    }
-    if (!aliasOrRoomId.startsWith("#")) {
-      return aliasOrRoomId;
-    }
-    try {
-      const resolved = await this.client.getRoomIdForAlias(aliasOrRoomId);
-      return resolved.room_id ?? null;
-    } catch {
-      return null;
-    }
-  }
-  async createDirectRoom(remoteUserId, opts = {}) {
-    const initialState = opts.encrypted ? [
-      {
-        type: "m.room.encryption",
-        state_key: "",
-        content: {
-          algorithm: "m.megolm.v1.aes-sha2"
-        }
-      }
-    ] : void 0;
-    const result = await this.client.createRoom({
-      invite: [remoteUserId],
-      is_direct: true,
-      preset: Preset.TrustedPrivateChat,
-      initial_state: initialState
-    });
-    return result.room_id;
-  }
-  async sendMessage(roomId, content) {
-    return await this.runSerializedRoomSend(roomId, async () => {
-      const sent = await this.client.sendMessage(roomId, content);
-      return sent.event_id;
-    });
-  }
-  async sendEvent(roomId, eventType, content) {
-    return await this.runSerializedRoomSend(roomId, async () => {
-      const sent = await this.client.sendEvent(roomId, eventType, content);
-      return sent.event_id;
-    });
-  }
-  // Keep outbound room events ordered when multiple plugin paths emit
-  // messages/reactions/polls into the same Matrix room concurrently.
-  async runSerializedRoomSend(roomId, task) {
-    return await this.sendQueue.enqueue(roomId, task);
-  }
-  async sendStateEvent(roomId, eventType, stateKey, content) {
-    const sent = await this.client.sendStateEvent(
-      roomId,
-      eventType,
-      content,
-      stateKey
-    );
-    return sent.event_id;
-  }
-  async redactEvent(roomId, eventId, reason) {
-    const sent = await this.client.redactEvent(
-      roomId,
-      eventId,
-      void 0,
-      reason?.trim() ? { reason } : void 0
-    );
-    return sent.event_id;
-  }
-  async doRequest(method, endpoint, qs, body, opts) {
-    return await this.httpClient.requestJson({
-      method,
-      endpoint,
-      qs,
-      body,
-      timeoutMs: this.localTimeoutMs,
-      allowAbsoluteEndpoint: opts?.allowAbsoluteEndpoint
-    });
-  }
-  async getUserProfile(userId) {
-    return await this.client.getProfileInfo(userId);
-  }
-  async setDisplayName(displayName) {
-    await this.client.setDisplayName(displayName);
-  }
-  async setAvatarUrl(avatarUrl) {
-    await this.client.setAvatarUrl(avatarUrl);
-  }
-  async joinRoom(roomId) {
-    await this.client.joinRoom(roomId);
-  }
-  mxcToHttp(mxcUrl) {
-    return this.client.mxcUrlToHttp(mxcUrl, void 0, void 0, void 0, true, false, true);
-  }
-  async downloadContent(mxcUrl, opts = {}) {
-    const parsed = parseMxc(mxcUrl);
-    if (!parsed) {
-      throw new Error(`Invalid Matrix content URI: ${mxcUrl}`);
-    }
-    const encodedServer = encodeURIComponent(parsed.server);
-    const encodedMediaId = encodeURIComponent(parsed.mediaId);
-    const request = async (endpoint) => await this.httpClient.requestRaw({
-      method: "GET",
-      endpoint,
-      qs: { allow_remote: opts.allowRemote ?? true },
-      timeoutMs: this.localTimeoutMs,
-      maxBytes: opts.maxBytes,
-      readIdleTimeoutMs: opts.readIdleTimeoutMs
-    });
-    const authenticatedEndpoint = `/_lobi/client/v1/media/download/${encodedServer}/${encodedMediaId}`;
-    try {
-      return await request(authenticatedEndpoint);
-    } catch (err) {
-      if (!isUnsupportedAuthenticatedMediaEndpointError(err)) {
-        throw err;
-      }
-    }
-    const legacyEndpoint = `/_lobi/media/v3/download/${encodedServer}/${encodedMediaId}`;
-    return await request(legacyEndpoint);
-  }
-  async uploadContent(file, contentType, filename) {
-    const uploaded = await this.client.uploadContent(new Uint8Array(file), {
-      type: contentType || "application/octet-stream",
-      name: filename,
-      includeFilename: Boolean(filename)
-    });
-    return uploaded.content_uri;
-  }
-  async getEvent(roomId, eventId) {
-    const rawEvent = await this.client.fetchRoomEvent(roomId, eventId);
-    if (rawEvent.type !== "m.room.encrypted") {
-      return rawEvent;
-    }
-    const mapper = this.client.getEventMapper();
-    const event = mapper(rawEvent);
-    let decryptedEvent;
-    const onDecrypted = (candidate) => {
-      decryptedEvent = candidate;
-    };
-    event.once("Event.decrypted", onDecrypted);
-    try {
-      await this.client.decryptEventIfNeeded(event);
-    } finally {
-      event.off("Event.decrypted", onDecrypted);
-    }
-    return matrixEventToRaw(decryptedEvent ?? event);
-  }
-  async getRelations(roomId, eventId, relationType, eventType, opts = {}) {
-    const result = await this.client.relations(roomId, eventId, relationType, eventType, opts);
-    return {
-      originalEvent: result.originalEvent ? matrixEventToRaw(result.originalEvent) : null,
-      events: result.events.map((event) => matrixEventToRaw(event)),
-      nextBatch: result.nextBatch ?? null,
-      prevBatch: result.prevBatch ?? null
-    };
-  }
-  async hydrateEvents(roomId, events) {
-    if (events.length === 0) {
-      return [];
-    }
-    const mapper = this.client.getEventMapper();
-    const mappedEvents = events.map(
-      (event) => mapper({
-        room_id: roomId,
-        ...event
-      })
-    );
-    await Promise.all(mappedEvents.map((event) => this.client.decryptEventIfNeeded(event)));
-    return mappedEvents.map((event) => matrixEventToRaw(event));
-  }
-  async setTyping(roomId, typing, timeoutMs) {
-    await this.client.sendTyping(roomId, typing, timeoutMs);
-  }
-  async sendReadReceipt(roomId, eventId) {
-    await this.httpClient.requestJson({
-      method: "POST",
-      endpoint: `/_lobi/client/v3/rooms/${encodeURIComponent(roomId)}/receipt/m.read/${encodeURIComponent(
-        eventId
-      )}`,
-      body: {},
-      timeoutMs: this.localTimeoutMs
-    });
-  }
-  async getRoomKeyBackupStatus() {
-    if (!this.encryptionEnabled) {
-      return {
-        serverVersion: null,
-        activeVersion: null,
-        trusted: null,
-        matchesDecryptionKey: null,
-        decryptionKeyCached: null,
-        keyLoadAttempted: false,
-        keyLoadError: null
-      };
-    }
-    const crypto = this.client.getCrypto();
-    const serverVersionFallback = await this.resolveRoomKeyBackupVersion();
-    if (!crypto) {
-      return {
-        serverVersion: serverVersionFallback,
-        activeVersion: null,
-        trusted: null,
-        matchesDecryptionKey: null,
-        decryptionKeyCached: null,
-        keyLoadAttempted: false,
-        keyLoadError: null
-      };
-    }
-    let { activeVersion, decryptionKeyCached } = await this.resolveRoomKeyBackupLocalState(crypto);
-    let { serverVersion, trusted, matchesDecryptionKey } = await this.resolveRoomKeyBackupTrustState(crypto, serverVersionFallback);
-    const shouldLoadBackupKey = Boolean(serverVersion) && (decryptionKeyCached === false || matchesDecryptionKey === false);
-    const shouldActivateBackup = Boolean(serverVersion) && !activeVersion;
-    let keyLoadAttempted = false;
-    let keyLoadError = null;
-    if (serverVersion && (shouldLoadBackupKey || shouldActivateBackup)) {
-      if (shouldLoadBackupKey) {
-        if (typeof crypto.loadSessionBackupPrivateKeyFromSecretStorage === "function") {
-          keyLoadAttempted = true;
-          try {
-            await crypto.loadSessionBackupPrivateKeyFromSecretStorage();
-          } catch (err) {
-            keyLoadError = formatMatrixErrorMessage(err);
-          }
-        } else {
-          keyLoadError = "Matrix crypto backend does not support loading backup keys from secret storage";
-        }
-      }
-      if (!keyLoadError) {
-        await this.enableTrustedRoomKeyBackupIfPossible(crypto);
-      }
-      ({ activeVersion, decryptionKeyCached } = await this.resolveRoomKeyBackupLocalState(crypto));
-      ({ serverVersion, trusted, matchesDecryptionKey } = await this.resolveRoomKeyBackupTrustState(
-        crypto,
-        serverVersion
-      ));
-    }
-    return {
-      serverVersion,
-      activeVersion,
-      trusted,
-      matchesDecryptionKey,
-      decryptionKeyCached,
-      keyLoadAttempted,
-      keyLoadError
-    };
-  }
-  async getOwnDeviceVerificationStatus() {
-    const recoveryKey = this.recoveryKeyStore.getRecoveryKeySummary();
-    const userId = this.client.getUserId() ?? this.selfUserId ?? null;
-    const deviceId = this.client.getDeviceId()?.trim() || null;
-    const backup = await this.getRoomKeyBackupStatus();
-    if (!this.encryptionEnabled) {
-      return {
-        encryptionEnabled: false,
-        userId,
-        deviceId,
-        verified: false,
-        localVerified: false,
-        crossSigningVerified: false,
-        signedByOwner: false,
-        recoveryKeyStored: Boolean(recoveryKey),
-        recoveryKeyCreatedAt: recoveryKey?.createdAt ?? null,
-        recoveryKeyId: recoveryKey?.keyId ?? null,
-        backupVersion: backup.serverVersion,
-        backup
-      };
-    }
-    const crypto = this.client.getCrypto();
-    let deviceStatus = null;
-    if (crypto && userId && deviceId && typeof crypto.getDeviceVerificationStatus === "function") {
-      deviceStatus = await crypto.getDeviceVerificationStatus(userId, deviceId).catch(() => null);
-    }
-    const { isMatrixDeviceOwnerVerified } = await loadMatrixCryptoRuntime();
-    return {
-      encryptionEnabled: true,
-      userId,
-      deviceId,
-      verified: isMatrixDeviceOwnerVerified(deviceStatus),
-      localVerified: deviceStatus?.localVerified === true,
-      crossSigningVerified: deviceStatus?.crossSigningVerified === true,
-      signedByOwner: deviceStatus?.signedByOwner === true,
-      recoveryKeyStored: Boolean(recoveryKey),
-      recoveryKeyCreatedAt: recoveryKey?.createdAt ?? null,
-      recoveryKeyId: recoveryKey?.keyId ?? null,
-      backupVersion: backup.serverVersion,
-      backup
-    };
-  }
-  async verifyWithRecoveryKey(rawRecoveryKey) {
-    const fail = async (error) => ({
-      success: false,
-      error,
-      ...await this.getOwnDeviceVerificationStatus()
-    });
-    if (!this.encryptionEnabled) {
-      return await fail("Matrix encryption is disabled for this client");
-    }
-    await this.ensureStartedForCryptoControlPlane();
-    await this.ensureCryptoSupportInitialized();
-    const crypto = this.client.getCrypto();
-    if (!crypto) {
-      return await fail("Matrix crypto is not available (start client with encryption enabled)");
-    }
-    const trimmedRecoveryKey = rawRecoveryKey.trim();
-    if (!trimmedRecoveryKey) {
-      return await fail("Matrix recovery key is required");
-    }
-    try {
-      this.recoveryKeyStore.stageEncodedRecoveryKey({
-        encodedPrivateKey: trimmedRecoveryKey,
-        keyId: await this.resolveDefaultSecretStorageKeyId(crypto)
-      });
-    } catch (err) {
-      return await fail(formatMatrixErrorMessage(err));
-    }
-    try {
-      const cryptoBootstrapper = this.cryptoBootstrapper;
-      if (!cryptoBootstrapper) {
-        return await fail("Matrix crypto bootstrapper is not available");
-      }
-      await cryptoBootstrapper.bootstrap(crypto, {
-        allowAutomaticCrossSigningReset: false
-      });
-      await this.enableTrustedRoomKeyBackupIfPossible(crypto);
-      const status = await this.getOwnDeviceVerificationStatus();
-      if (!status.verified) {
-        this.recoveryKeyStore.discardStagedRecoveryKey();
-        return {
-          success: false,
-          error: "Matrix device is still not verified by its owner after applying the recovery key. Ensure cross-signing is available and the device is signed.",
-          ...status
-        };
-      }
-      const backupError = resolveMatrixRoomKeyBackupReadinessError(status.backup, {
-        requireServerBackup: false
-      });
-      if (backupError) {
-        this.recoveryKeyStore.discardStagedRecoveryKey();
-        return {
-          success: false,
-          error: backupError,
-          ...status
-        };
-      }
-      this.recoveryKeyStore.commitStagedRecoveryKey({
-        keyId: await this.resolveDefaultSecretStorageKeyId(crypto)
-      });
-      const committedStatus = await this.getOwnDeviceVerificationStatus();
-      return {
-        success: true,
-        verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        ...committedStatus
-      };
-    } catch (err) {
-      this.recoveryKeyStore.discardStagedRecoveryKey();
-      return await fail(formatMatrixErrorMessage(err));
-    }
-  }
-  async restoreRoomKeyBackup(params = {}) {
-    let loadedFromSecretStorage = false;
-    const fail = async (error) => {
-      const backup = await this.getRoomKeyBackupStatus();
-      return {
-        success: false,
-        error,
-        backupVersion: backup.serverVersion,
-        imported: 0,
-        total: 0,
-        loadedFromSecretStorage,
-        backup
-      };
-    };
-    if (!this.encryptionEnabled) {
-      return await fail("Matrix encryption is disabled for this client");
-    }
-    await this.ensureStartedForCryptoControlPlane();
-    const crypto = this.client.getCrypto();
-    if (!crypto) {
-      return await fail("Matrix crypto is not available (start client with encryption enabled)");
-    }
-    try {
-      const rawRecoveryKey = params.recoveryKey?.trim();
-      if (rawRecoveryKey) {
-        this.recoveryKeyStore.stageEncodedRecoveryKey({
-          encodedPrivateKey: rawRecoveryKey,
-          keyId: await this.resolveDefaultSecretStorageKeyId(crypto)
-        });
-      }
-      const backup = await this.getRoomKeyBackupStatus();
-      loadedFromSecretStorage = backup.keyLoadAttempted && !backup.keyLoadError;
-      const backupError = resolveMatrixRoomKeyBackupReadinessError(backup, {
-        requireServerBackup: true
-      });
-      if (backupError) {
-        this.recoveryKeyStore.discardStagedRecoveryKey();
-        return await fail(backupError);
-      }
-      if (typeof crypto.restoreKeyBackup !== "function") {
-        this.recoveryKeyStore.discardStagedRecoveryKey();
-        return await fail("Matrix crypto backend does not support full key backup restore");
-      }
-      const restore = await crypto.restoreKeyBackup();
-      if (rawRecoveryKey) {
-        this.recoveryKeyStore.commitStagedRecoveryKey({
-          keyId: await this.resolveDefaultSecretStorageKeyId(crypto)
-        });
-      }
-      const finalBackup = await this.getRoomKeyBackupStatus();
-      return {
-        success: true,
-        backupVersion: backup.serverVersion,
-        imported: typeof restore.imported === "number" ? restore.imported : 0,
-        total: typeof restore.total === "number" ? restore.total : 0,
-        loadedFromSecretStorage,
-        restoredAt: (/* @__PURE__ */ new Date()).toISOString(),
-        backup: finalBackup
-      };
-    } catch (err) {
-      this.recoveryKeyStore.discardStagedRecoveryKey();
-      return await fail(formatMatrixErrorMessage(err));
-    }
-  }
-  async resetRoomKeyBackup() {
-    let previousVersion = null;
-    let deletedVersion = null;
-    const fail = async (error) => {
-      const backup = await this.getRoomKeyBackupStatus();
-      return {
-        success: false,
-        error,
-        previousVersion,
-        deletedVersion,
-        createdVersion: backup.serverVersion,
-        backup
-      };
-    };
-    if (!this.encryptionEnabled) {
-      return await fail("Matrix encryption is disabled for this client");
-    }
-    await this.ensureStartedForCryptoControlPlane();
-    const crypto = this.client.getCrypto();
-    if (!crypto) {
-      return await fail("Matrix crypto is not available (start client with encryption enabled)");
-    }
-    previousVersion = await this.resolveRoomKeyBackupVersion();
-    const forceNewSecretStorage = await this.shouldForceSecretStorageRecreationForBackupReset(crypto);
-    try {
-      if (previousVersion) {
-        try {
-          await this.doRequest(
-            "DELETE",
-            `/_lobi/client/v3/room_keys/version/${encodeURIComponent(previousVersion)}`
-          );
-        } catch (err) {
-          if (!isMatrixNotFoundError(err)) {
-            throw err;
-          }
-        }
-        deletedVersion = previousVersion;
-      }
-      await this.recoveryKeyStore.bootstrapSecretStorageWithRecoveryKey(crypto, {
-        setupNewKeyBackup: true,
-        // Force SSSS recreation when the existing SSSS key is broken (bad MAC), so
-        // the new backup key is written into a fresh SSSS consistent with recovery_key.json.
-        forceNewSecretStorage,
-        // Also allow recreation if bootstrapSecretStorage itself surfaces a repairable
-        // error (e.g. bad MAC from a different SSSS entry).
-        allowSecretStorageRecreateWithoutRecoveryKey: true
-      });
-      await this.enableTrustedRoomKeyBackupIfPossible(crypto);
-      const backup = await this.getRoomKeyBackupStatus();
-      const createdVersion = backup.serverVersion;
-      if (!createdVersion) {
-        return await fail("Matrix room key backup is still missing after reset.");
-      }
-      if (backup.activeVersion !== createdVersion) {
-        return await fail(
-          "Matrix room key backup was recreated on the server but is not active on this device."
-        );
-      }
-      if (backup.decryptionKeyCached === false) {
-        return await fail(
-          "Matrix room key backup was recreated but its decryption key is not cached on this device."
-        );
-      }
-      if (backup.matchesDecryptionKey === false) {
-        return await fail(
-          "Matrix room key backup was recreated but this device does not have the matching backup decryption key."
-        );
-      }
-      if (backup.trusted === false) {
-        return await fail(
-          "Matrix room key backup was recreated but is not trusted on this device."
-        );
-      }
-      return {
-        success: true,
-        previousVersion,
-        deletedVersion,
-        createdVersion,
-        resetAt: (/* @__PURE__ */ new Date()).toISOString(),
-        backup
-      };
-    } catch (err) {
-      return await fail(formatMatrixErrorMessage(err));
-    }
-  }
-  async getOwnCrossSigningPublicationStatus() {
-    const userId = this.client.getUserId() ?? this.selfUserId ?? null;
-    if (!userId) {
-      return {
-        userId: null,
-        masterKeyPublished: false,
-        selfSigningKeyPublished: false,
-        userSigningKeyPublished: false,
-        published: false
-      };
-    }
-    try {
-      const response = await this.doRequest("POST", "/_lobi/client/v3/keys/query", void 0, {
-        device_keys: { [userId]: [] }
-      });
-      const masterKeyPublished = Boolean(response.master_keys?.[userId]);
-      const selfSigningKeyPublished = Boolean(response.self_signing_keys?.[userId]);
-      const userSigningKeyPublished = Boolean(response.user_signing_keys?.[userId]);
-      return {
-        userId,
-        masterKeyPublished,
-        selfSigningKeyPublished,
-        userSigningKeyPublished,
-        published: masterKeyPublished && selfSigningKeyPublished && userSigningKeyPublished
-      };
-    } catch {
-      return {
-        userId,
-        masterKeyPublished: false,
-        selfSigningKeyPublished: false,
-        userSigningKeyPublished: false,
-        published: false
-      };
-    }
-  }
-  async bootstrapOwnDeviceVerification(params) {
-    const pendingVerifications = async () => this.crypto ? (await this.crypto.listVerifications()).length : 0;
-    if (!this.encryptionEnabled) {
-      return {
-        success: false,
-        error: "Matrix encryption is disabled for this client",
-        verification: await this.getOwnDeviceVerificationStatus(),
-        crossSigning: await this.getOwnCrossSigningPublicationStatus(),
-        pendingVerifications: await pendingVerifications(),
-        cryptoBootstrap: null
-      };
-    }
-    let bootstrapError;
-    let bootstrapSummary = null;
-    try {
-      await this.ensureStartedForCryptoControlPlane();
-      await this.ensureCryptoSupportInitialized();
-      const crypto = this.client.getCrypto();
-      if (!crypto) {
-        throw new Error("Matrix crypto is not available (start client with encryption enabled)");
-      }
-      const rawRecoveryKey = params?.recoveryKey?.trim();
-      if (rawRecoveryKey) {
-        this.recoveryKeyStore.stageEncodedRecoveryKey({
-          encodedPrivateKey: rawRecoveryKey,
-          keyId: await this.resolveDefaultSecretStorageKeyId(crypto)
-        });
-      }
-      const cryptoBootstrapper = this.cryptoBootstrapper;
-      if (!cryptoBootstrapper) {
-        throw new Error("Matrix crypto bootstrapper is not available");
-      }
-      bootstrapSummary = await cryptoBootstrapper.bootstrap(
-        crypto,
-        createMatrixExplicitBootstrapOptions(params)
-      );
-      await this.ensureRoomKeyBackupEnabled(crypto);
-    } catch (err) {
-      this.recoveryKeyStore.discardStagedRecoveryKey();
-      bootstrapError = formatMatrixErrorMessage(err);
-    }
-    const verification = await this.getOwnDeviceVerificationStatus();
-    const crossSigning = await this.getOwnCrossSigningPublicationStatus();
-    const verificationError = verification.verified && crossSigning.published ? null : bootstrapError ?? "Matrix verification bootstrap did not produce a device verified by its owner with published cross-signing keys";
-    const backupError = verificationError === null ? resolveMatrixRoomKeyBackupReadinessError(verification.backup, {
-      requireServerBackup: true
-    }) : null;
-    const success = verificationError === null && backupError === null;
-    if (success) {
-      this.recoveryKeyStore.commitStagedRecoveryKey({
-        keyId: await this.resolveDefaultSecretStorageKeyId(
-          this.client.getCrypto()
-        )
-      });
-    } else {
-      this.recoveryKeyStore.discardStagedRecoveryKey();
-    }
-    const error = success ? void 0 : backupError ?? verificationError ?? void 0;
-    return {
-      success,
-      error,
-      verification: success ? await this.getOwnDeviceVerificationStatus() : verification,
-      crossSigning,
-      pendingVerifications: await pendingVerifications(),
-      cryptoBootstrap: bootstrapSummary
-    };
-  }
-  async listOwnDevices() {
-    const currentDeviceId = this.client.getDeviceId()?.trim() || null;
-    const devices = await this.client.getDevices();
-    const entries = Array.isArray(devices?.devices) ? devices.devices : [];
-    return entries.map((device) => ({
-      deviceId: device.device_id,
-      displayName: device.display_name?.trim() || null,
-      lastSeenIp: device.last_seen_ip?.trim() || null,
-      lastSeenTs: typeof device.last_seen_ts === "number" && Number.isFinite(device.last_seen_ts) ? device.last_seen_ts : null,
-      current: currentDeviceId !== null && device.device_id === currentDeviceId
-    }));
-  }
-  async deleteOwnDevices(deviceIds) {
-    const uniqueDeviceIds = [...new Set(deviceIds.map((value) => value.trim()).filter(Boolean))];
-    const currentDeviceId = this.client.getDeviceId()?.trim() || null;
-    const protectedDeviceIds = uniqueDeviceIds.filter((deviceId) => deviceId === currentDeviceId);
-    if (protectedDeviceIds.length > 0) {
-      throw new Error(`Refusing to delete the current Matrix device: ${protectedDeviceIds[0]}`);
-    }
-    const deleteWithAuth = async (authData) => {
-      await this.client.deleteMultipleDevices(uniqueDeviceIds, authData);
-    };
-    if (uniqueDeviceIds.length > 0) {
-      try {
-        await deleteWithAuth();
-      } catch (err) {
-        const session = err && typeof err === "object" && "data" in err && err.data && typeof err.data === "object" && "session" in err.data && typeof err.data.session === "string" ? err.data.session : null;
-        const userId = await this.getUserId().catch(() => this.selfUserId);
-        if (!session || !userId || !this.password?.trim()) {
-          throw err;
-        }
-        await deleteWithAuth({
-          type: "m.login.password",
-          session,
-          identifier: { type: "m.id.user", user: userId },
-          password: this.password
-        });
-      }
-    }
-    return {
-      currentDeviceId,
-      deletedDeviceIds: uniqueDeviceIds,
-      remainingDevices: await this.listOwnDevices()
-    };
-  }
-  async resolveActiveRoomKeyBackupVersion(crypto) {
-    if (typeof crypto.getActiveSessionBackupVersion !== "function") {
-      return null;
-    }
-    const version = await crypto.getActiveSessionBackupVersion().catch(() => null);
-    return normalizeOptionalString(version);
-  }
-  async resolveCachedRoomKeyBackupDecryptionKey(crypto) {
-    const getSessionBackupPrivateKey = crypto.getSessionBackupPrivateKey;
-    if (typeof getSessionBackupPrivateKey !== "function") {
-      return null;
-    }
-    const key = await getSessionBackupPrivateKey.call(crypto).catch(() => null);
-    return key ? key.length > 0 : false;
-  }
-  async resolveRoomKeyBackupLocalState(crypto) {
-    const [activeVersion, decryptionKeyCached] = await Promise.all([
-      this.resolveActiveRoomKeyBackupVersion(crypto),
-      this.resolveCachedRoomKeyBackupDecryptionKey(crypto)
-    ]);
-    return { activeVersion, decryptionKeyCached };
-  }
-  async shouldForceSecretStorageRecreationForBackupReset(crypto) {
-    const decryptionKeyCached = await this.resolveCachedRoomKeyBackupDecryptionKey(crypto);
-    if (decryptionKeyCached !== false) {
-      return false;
-    }
-    const loadSessionBackupPrivateKeyFromSecretStorage = crypto.loadSessionBackupPrivateKeyFromSecretStorage;
-    if (typeof loadSessionBackupPrivateKeyFromSecretStorage !== "function") {
-      return false;
-    }
-    try {
-      await loadSessionBackupPrivateKeyFromSecretStorage.call(crypto);
-      return false;
-    } catch (err) {
-      return isRepairableSecretStorageAccessError(err);
-    }
-  }
-  async resolveRoomKeyBackupTrustState(crypto, fallbackVersion) {
-    let serverVersion = fallbackVersion;
-    let trusted = null;
-    let matchesDecryptionKey = null;
-    if (typeof crypto.getKeyBackupInfo === "function") {
-      const info = await crypto.getKeyBackupInfo().catch(() => null);
-      serverVersion = normalizeOptionalString(info?.version) ?? serverVersion;
-      if (info && typeof crypto.isKeyBackupTrusted === "function") {
-        const trustInfo = await crypto.isKeyBackupTrusted(info).catch(() => null);
-        trusted = typeof trustInfo?.trusted === "boolean" ? trustInfo.trusted : null;
-        matchesDecryptionKey = typeof trustInfo?.matchesDecryptionKey === "boolean" ? trustInfo.matchesDecryptionKey : null;
-      }
-    }
-    return { serverVersion, trusted, matchesDecryptionKey };
-  }
-  async resolveDefaultSecretStorageKeyId(crypto) {
-    const getSecretStorageStatus = crypto?.getSecretStorageStatus;
-    if (typeof getSecretStorageStatus !== "function") {
-      return void 0;
-    }
-    const status = await getSecretStorageStatus.call(crypto).catch(() => null);
-    return status?.defaultKeyId;
-  }
-  async resolveRoomKeyBackupVersion() {
-    try {
-      const response = await this.doRequest("GET", "/_lobi/client/v3/room_keys/version");
-      return normalizeOptionalString(response.version);
-    } catch {
-      return null;
-    }
-  }
-  async enableTrustedRoomKeyBackupIfPossible(crypto) {
-    if (typeof crypto.checkKeyBackupAndEnable !== "function") {
-      return;
-    }
-    await crypto.checkKeyBackupAndEnable();
-  }
-  async ensureRoomKeyBackupEnabled(crypto) {
-    const existingVersion = await this.resolveRoomKeyBackupVersion();
-    if (existingVersion) {
-      return;
-    }
-    LogService.info(
-      "MatrixClientLite",
-      "No room key backup version found on server, creating one via secret storage bootstrap"
-    );
-    await this.recoveryKeyStore.bootstrapSecretStorageWithRecoveryKey(crypto, {
-      setupNewKeyBackup: true
-    });
-    const createdVersion = await this.resolveRoomKeyBackupVersion();
-    if (!createdVersion) {
-      throw new Error("Matrix room key backup is still missing after bootstrap");
-    }
-    LogService.info("MatrixClientLite", `Room key backup enabled (version ${createdVersion})`);
-  }
-  registerBridge() {
-    if (this.bridgeRegistered || !this.decryptBridge) {
-      return;
-    }
-    this.bridgeRegistered = true;
-    const decryptBridge = this.decryptBridge;
-    this.client.on(ClientEvent.Event, (event) => {
-      const roomId = event.getRoomId();
-      if (!roomId) {
-        return;
-      }
-      const raw = matrixEventToRaw(event);
-      const isEncryptedEvent = raw.type === "m.room.encrypted";
-      this.emitter.emit("room.event", roomId, raw);
-      if (isEncryptedEvent) {
-        this.emitter.emit("room.encrypted_event", roomId, raw);
-      } else {
-        if (decryptBridge.shouldEmitUnencryptedMessage(roomId, raw.event_id)) {
-          this.emitter.emit("room.message", roomId, raw);
-        }
-      }
-      const stateKey = raw.state_key ?? "";
-      const selfUserId = this.client.getUserId() ?? this.selfUserId ?? "";
-      const membership = raw.type === "m.room.member" ? raw.content.membership : void 0;
-      if (stateKey && selfUserId && stateKey === selfUserId) {
-        if (membership === "invite") {
-          this.emitter.emit("room.invite", roomId, raw);
-        } else if (membership === "join") {
-          this.emitter.emit("room.join", roomId, raw);
-        }
-      }
-      if (isEncryptedEvent) {
-        decryptBridge.attachEncryptedEvent(event, roomId);
-      }
-    });
-    this.client.on(ClientEvent.Room, (room) => {
-      this.emitMembershipForRoom(room);
-    });
-    this.client.on(
-      ClientEvent.Sync,
-      (state, prevState, data) => {
-        this.currentSyncState = state;
-        const error = data && typeof data === "object" && "error" in data ? data.error : void 0;
-        this.emitter.emit("sync.state", state, prevState, error);
-      }
-    );
-    this.client.on(ClientEvent.SyncUnexpectedError, (error) => {
-      this.emitter.emit("sync.unexpected_error", error);
-    });
-  }
-  emitMembershipForRoom(room) {
-    const roomObj = room;
-    const roomId = roomObj.roomId?.trim();
-    if (!roomId) {
-      return;
-    }
-    const membership = roomObj.getMyMembership?.() ?? roomObj.selfMembership ?? void 0;
-    const selfUserId = this.client.getUserId() ?? this.selfUserId ?? "";
-    if (!selfUserId) {
-      return;
-    }
-    const raw = {
-      event_id: `$membership-${roomId}-${Date.now()}`,
-      type: "m.room.member",
-      sender: selfUserId,
-      state_key: selfUserId,
-      content: { membership },
-      origin_server_ts: Date.now(),
-      unsigned: { age: 0 }
-    };
-    if (membership === "invite") {
-      this.emitter.emit("room.invite", roomId, raw);
-      return;
-    }
-    if (membership === "join") {
-      this.emitter.emit("room.join", roomId, raw);
-    }
-  }
-  emitOutstandingInviteEvents() {
-    const listRooms = this.client.getRooms;
-    if (typeof listRooms !== "function") {
-      return;
-    }
-    const rooms = listRooms.call(this.client);
-    if (!Array.isArray(rooms)) {
-      return;
-    }
-    for (const room of rooms) {
-      this.emitMembershipForRoom(room);
-    }
-  }
-  async refreshDmCache() {
-    const direct = await this.getAccountData("m.direct");
-    this.dmRoomIds.clear();
-    if (!direct || typeof direct !== "object") {
-      return false;
-    }
-    for (const value of Object.values(direct)) {
-      if (!Array.isArray(value)) {
-        continue;
-      }
-      for (const roomId of value) {
-        if (typeof roomId === "string" && roomId.trim()) {
-          this.dmRoomIds.add(roomId);
-        }
-      }
-    }
-    return true;
-  }
-};
-export {
-  ConsoleLogger,
-  LogService,
-  MatrixClient
-};
-//# sourceMappingURL=sdk.js.map