@kodelyth/matrix 2026.5.42 → 2026.6.2

package/src/matrix/client/create-client.ts

@@ -1,105 +0,0 @@
-import fs from "node:fs";
-import type { PinnedDispatcherPolicy } from "klaw/plugin-sdk/ssrf-dispatcher";
-import {
-  ssrfPolicyFromDangerouslyAllowPrivateNetwork,
-  type SsrFPolicy,
-} from "klaw/plugin-sdk/ssrf-runtime";
-import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
-import type { MatrixClient } from "../sdk.js";
-import { resolveValidatedMatrixHomeserverUrl } from "./config.js";
-import {
-  maybeMigrateLegacyStorage,
-  resolveMatrixStoragePaths,
-  writeStorageMeta,
-} from "./storage.js";
-
-type MatrixCreateClientRuntimeDeps = {
-  MatrixClient: typeof import("../sdk.js").MatrixClient;
-  ensureMatrixSdkLoggingConfigured: typeof import("./logging.js").ensureMatrixSdkLoggingConfigured;
-};
-
-let matrixCreateClientRuntimeDepsPromise: Promise<MatrixCreateClientRuntimeDeps> | undefined;
-
-async function loadMatrixCreateClientRuntimeDeps(): Promise<MatrixCreateClientRuntimeDeps> {
-  matrixCreateClientRuntimeDepsPromise ??= Promise.all([
-    import("../sdk.js"),
-    import("./logging.js"),
-  ]).then(([sdkModule, loggingModule]) => ({
-    MatrixClient: sdkModule.MatrixClient,
-    ensureMatrixSdkLoggingConfigured: loggingModule.ensureMatrixSdkLoggingConfigured,
-  }));
-  return await matrixCreateClientRuntimeDepsPromise;
-}
-
-export async function createMatrixClient(params: {
-  homeserver: string;
-  userId?: string;
-  accessToken: string;
-  password?: string;
-  deviceId?: string;
-  persistStorage?: boolean;
-  encryption?: boolean;
-  localTimeoutMs?: number;
-  initialSyncLimit?: number;
-  accountId?: string | null;
-  autoBootstrapCrypto?: boolean;
-  allowPrivateNetwork?: boolean;
-  ssrfPolicy?: SsrFPolicy;
-  dispatcherPolicy?: PinnedDispatcherPolicy;
-}): Promise<MatrixClient> {
-  const { MatrixClient, ensureMatrixSdkLoggingConfigured } =
-    await loadMatrixCreateClientRuntimeDeps();
-  ensureMatrixSdkLoggingConfigured();
-  const homeserver = await resolveValidatedMatrixHomeserverUrl(params.homeserver, {
-    dangerouslyAllowPrivateNetwork: params.allowPrivateNetwork,
-  });
-  const matrixClientUserId = normalizeOptionalString(params.userId);
-  const userId = matrixClientUserId ?? "unknown";
-  const persistStorage = params.persistStorage !== false;
-  const storagePaths = persistStorage
-    ? resolveMatrixStoragePaths({
-        homeserver,
-        userId,
-        accessToken: params.accessToken,
-        accountId: params.accountId,
-        deviceId: params.deviceId,
-        env: process.env,
-      })
-    : null;
-
-  if (storagePaths) {
-    await maybeMigrateLegacyStorage({
-      storagePaths,
-      env: process.env,
-    });
-    fs.mkdirSync(storagePaths.rootDir, { recursive: true });
-    writeStorageMeta({
-      storagePaths,
-      homeserver,
-      userId,
-      accountId: params.accountId,
-      deviceId: params.deviceId,
-    });
-  }
-
-  const cryptoDatabasePrefix = storagePaths
-    ? `klaw-matrix-${storagePaths.accountKey}-${storagePaths.tokenHash}`
-    : undefined;
-
-  return new MatrixClient(homeserver, params.accessToken, {
-    userId: matrixClientUserId,
-    password: params.password,
-    deviceId: params.deviceId,
-    encryption: params.encryption,
-    localTimeoutMs: params.localTimeoutMs,
-    initialSyncLimit: params.initialSyncLimit,
-    storagePath: storagePaths?.storagePath,
-    recoveryKeyPath: storagePaths?.recoveryKeyPath,
-    idbSnapshotPath: storagePaths?.idbSnapshotPath,
-    cryptoDatabasePrefix,
-    autoBootstrapCrypto: params.autoBootstrapCrypto,
-    ssrfPolicy:
-      params.ssrfPolicy ?? ssrfPolicyFromDangerouslyAllowPrivateNetwork(params.allowPrivateNetwork),
-    dispatcherPolicy: params.dispatcherPolicy,
-  });
-}

package/src/matrix/client/env-auth.ts

@@ -1,95 +0,0 @@
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "klaw/plugin-sdk/account-id";
-import { getMatrixScopedEnvVarNames } from "../../env-vars.js";
-
-type MatrixEnvConfig = {
-  homeserver: string;
-  userId: string;
-  accessToken?: string;
-  password?: string;
-  deviceId?: string;
-  deviceName?: string;
-};
-
-function cleanEnv(value: unknown): string {
-  return typeof value === "string" ? value.trim() : "";
-}
-
-export function resolveGlobalMatrixEnvConfig(env: NodeJS.ProcessEnv): MatrixEnvConfig {
-  return {
-    homeserver: cleanEnv(env.MATRIX_HOMESERVER),
-    userId: cleanEnv(env.MATRIX_USER_ID),
-    accessToken: cleanEnv(env.MATRIX_ACCESS_TOKEN) || undefined,
-    password: cleanEnv(env.MATRIX_PASSWORD) || undefined,
-    deviceId: cleanEnv(env.MATRIX_DEVICE_ID) || undefined,
-    deviceName: cleanEnv(env.MATRIX_DEVICE_NAME) || undefined,
-  };
-}
-
-export function hasReadyMatrixEnvAuth(config: {
-  homeserver?: string;
-  userId?: string;
-  accessToken?: string;
-  password?: string;
-}): boolean {
-  const homeserver = cleanEnv(config.homeserver);
-  const userId = cleanEnv(config.userId);
-  const accessToken = cleanEnv(config.accessToken);
-  const password = cleanEnv(config.password);
-  return Boolean(homeserver && (accessToken || (userId && password)));
-}
-
-export function resolveScopedMatrixEnvConfig(
-  accountId: string,
-  env: NodeJS.ProcessEnv = process.env,
-): MatrixEnvConfig {
-  const keys = getMatrixScopedEnvVarNames(accountId);
-  return {
-    homeserver: cleanEnv(env[keys.homeserver]),
-    userId: cleanEnv(env[keys.userId]),
-    accessToken: cleanEnv(env[keys.accessToken]) || undefined,
-    password: cleanEnv(env[keys.password]) || undefined,
-    deviceId: cleanEnv(env[keys.deviceId]) || undefined,
-    deviceName: cleanEnv(env[keys.deviceName]) || undefined,
-  };
-}
-
-export function resolveMatrixEnvAuthReadiness(
-  accountId: string,
-  env: NodeJS.ProcessEnv = process.env,
-): {
-  ready: boolean;
-  homeserver?: string;
-  userId?: string;
-  sourceHint: string;
-  missingMessage: string;
-} {
-  const normalizedAccountId = normalizeAccountId(accountId);
-  const scoped = resolveScopedMatrixEnvConfig(normalizedAccountId, env);
-  const scopedReady = hasReadyMatrixEnvAuth(scoped);
-  if (normalizedAccountId !== DEFAULT_ACCOUNT_ID) {
-    const keys = getMatrixScopedEnvVarNames(normalizedAccountId);
-    return {
-      ready: scopedReady,
-      homeserver: scoped.homeserver || undefined,
-      userId: scoped.userId || undefined,
-      sourceHint: `${keys.homeserver} (+ auth vars)`,
-      missingMessage: `Set per-account env vars for "${normalizedAccountId}" (for example ${keys.homeserver} + ${keys.accessToken} or ${keys.userId} + ${keys.password}).`,
-    };
-  }
-
-  const defaultScoped = resolveScopedMatrixEnvConfig(DEFAULT_ACCOUNT_ID, env);
-  const global = resolveGlobalMatrixEnvConfig(env);
-  const defaultScopedReady = hasReadyMatrixEnvAuth(defaultScoped);
-  const globalReady = hasReadyMatrixEnvAuth(global);
-  const defaultKeys = getMatrixScopedEnvVarNames(DEFAULT_ACCOUNT_ID);
-  return {
-    ready: defaultScopedReady || globalReady,
-    homeserver: defaultScoped.homeserver || global.homeserver || undefined,
-    userId: defaultScoped.userId || global.userId || undefined,
-    sourceHint: "MATRIX_* or MATRIX_DEFAULT_*",
-    missingMessage:
-      `Set Matrix env vars for the default account ` +
-      `(for example MATRIX_HOMESERVER + MATRIX_ACCESS_TOKEN, MATRIX_USER_ID + MATRIX_PASSWORD, ` +
-      `or ${defaultKeys.homeserver} + ${defaultKeys.accessToken}).`,
-  };
-}

package/src/matrix/client/file-sync-store.ts

@@ -1,289 +0,0 @@
-import { readFileSync } from "node:fs";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { writeJsonFileAtomically } from "klaw/plugin-sdk/json-store";
-import {
-  Category,
-  MemoryStore,
-  SyncAccumulator,
-  type ISyncData,
-  type IRooms,
-  type ISyncResponse,
-  type IStoredClientOpts,
-} from "matrix-js-sdk/lib/matrix.js";
-import { isRecord } from "../../record-shared.js";
-import { createAsyncLock } from "../async-lock.js";
-import { LogService } from "../sdk/logger.js";
-import { claimCurrentTokenStorageState } from "./storage.js";
-
-const STORE_VERSION = 1;
-const PERSIST_DEBOUNCE_MS = 250;
-
-type PersistedMatrixSyncStore = {
-  version: number;
-  savedSync: ISyncData | null;
-  clientOptions?: IStoredClientOpts;
-  cleanShutdown?: boolean;
-};
-
-function normalizeRoomsData(value: unknown): IRooms | null {
-  if (!isRecord(value)) {
-    return null;
-  }
-  return {
-    [Category.Join]: isRecord(value[Category.Join]) ? (value[Category.Join] as IRooms["join"]) : {},
-    [Category.Invite]: isRecord(value[Category.Invite])
-      ? (value[Category.Invite] as IRooms["invite"])
-      : {},
-    [Category.Leave]: isRecord(value[Category.Leave])
-      ? (value[Category.Leave] as IRooms["leave"])
-      : {},
-    [Category.Knock]: isRecord(value[Category.Knock])
-      ? (value[Category.Knock] as IRooms["knock"])
-      : {},
-  };
-}
-
-function toPersistedSyncData(value: unknown): ISyncData | null {
-  if (!isRecord(value)) {
-    return null;
-  }
-  if (typeof value.nextBatch === "string" && value.nextBatch.trim()) {
-    const roomsData = normalizeRoomsData(value.roomsData);
-    if (!Array.isArray(value.accountData) || !roomsData) {
-      return null;
-    }
-    return {
-      nextBatch: value.nextBatch,
-      accountData: value.accountData,
-      roomsData,
-    };
-  }
-
-  // Older Matrix state files stored the raw /sync-shaped payload directly.
-  if (typeof value.next_batch === "string" && value.next_batch.trim()) {
-    const roomsData = normalizeRoomsData(value.rooms);
-    if (!roomsData) {
-      return null;
-    }
-    return {
-      nextBatch: value.next_batch,
-      accountData:
-        isRecord(value.account_data) && Array.isArray(value.account_data.events)
-          ? value.account_data.events
-          : [],
-      roomsData,
-    };
-  }
-
-  return null;
-}
-
-function readPersistedStore(raw: string): PersistedMatrixSyncStore | null {
-  try {
-    const parsed = JSON.parse(raw) as {
-      version?: unknown;
-      savedSync?: unknown;
-      clientOptions?: unknown;
-      cleanShutdown?: unknown;
-    };
-    const savedSync = toPersistedSyncData(parsed.savedSync);
-    if (parsed.version === STORE_VERSION) {
-      return {
-        version: STORE_VERSION,
-        savedSync,
-        clientOptions: isRecord(parsed.clientOptions)
-          ? (parsed.clientOptions as IStoredClientOpts)
-          : undefined,
-        cleanShutdown: parsed.cleanShutdown === true,
-      };
-    }
-
-    // Backward-compat: prior Matrix state files stored the raw sync blob at the
-    // top level without versioning or wrapped metadata.
-    return {
-      version: STORE_VERSION,
-      savedSync: toPersistedSyncData(parsed),
-      cleanShutdown: false,
-    };
-  } catch {
-    return null;
-  }
-}
-
-function cloneJson<T>(value: T): T {
-  return structuredClone(value);
-}
-
-function syncDataToSyncResponse(syncData: ISyncData): ISyncResponse {
-  return {
-    next_batch: syncData.nextBatch,
-    rooms: syncData.roomsData,
-    account_data: {
-      events: syncData.accountData,
-    },
-  };
-}
-
-export class FileBackedMatrixSyncStore extends MemoryStore {
-  private readonly persistLock = createAsyncLock();
-  private readonly accumulator = new SyncAccumulator();
-  private savedSync: ISyncData | null = null;
-  private savedClientOptions: IStoredClientOpts | undefined;
-  private readonly hadSavedSyncOnLoad: boolean;
-  private readonly hadCleanShutdownOnLoad: boolean;
-  private cleanShutdown = false;
-  private dirty = false;
-  private persistTimer: NodeJS.Timeout | null = null;
-  private persistPromise: Promise<void> | null = null;
-
-  constructor(private readonly storagePath: string) {
-    super();
-
-    let restoredSavedSync: ISyncData | null = null;
-    let restoredClientOptions: IStoredClientOpts | undefined;
-    let restoredCleanShutdown = false;
-    try {
-      const raw = readFileSync(this.storagePath, "utf8");
-      const persisted = readPersistedStore(raw);
-      restoredSavedSync = persisted?.savedSync ?? null;
-      restoredClientOptions = persisted?.clientOptions;
-      restoredCleanShutdown = persisted?.cleanShutdown === true;
-    } catch {
-      // Missing or unreadable sync cache should not block startup.
-    }
-
-    this.savedSync = restoredSavedSync;
-    this.savedClientOptions = restoredClientOptions;
-    this.hadSavedSyncOnLoad = restoredSavedSync !== null;
-    this.hadCleanShutdownOnLoad = this.hadSavedSyncOnLoad && restoredCleanShutdown;
-    this.cleanShutdown = this.hadCleanShutdownOnLoad;
-
-    if (this.savedSync) {
-      this.accumulator.accumulate(syncDataToSyncResponse(this.savedSync), true);
-      super.setSyncToken(this.savedSync.nextBatch);
-    }
-    if (this.savedClientOptions) {
-      void super.storeClientOptions(this.savedClientOptions);
-    }
-  }
-
-  hasSavedSync(): boolean {
-    return this.hadSavedSyncOnLoad;
-  }
-
-  hasSavedSyncFromCleanShutdown(): boolean {
-    return this.hadCleanShutdownOnLoad;
-  }
-
-  override getSavedSync(): Promise<ISyncData | null> {
-    return Promise.resolve(this.savedSync ? cloneJson(this.savedSync) : null);
-  }
-
-  override getSavedSyncToken(): Promise<string | null> {
-    return Promise.resolve(this.savedSync?.nextBatch ?? null);
-  }
-
-  override setSyncData(syncData: ISyncResponse): Promise<void> {
-    this.accumulator.accumulate(syncData);
-    this.savedSync = this.accumulator.getJSON();
-    this.markDirtyAndSchedulePersist();
-    return Promise.resolve();
-  }
-
-  override getClientOptions() {
-    return Promise.resolve(
-      this.savedClientOptions ? cloneJson(this.savedClientOptions) : undefined,
-    );
-  }
-
-  override storeClientOptions(options: IStoredClientOpts) {
-    this.savedClientOptions = cloneJson(options);
-    void super.storeClientOptions(options);
-    this.markDirtyAndSchedulePersist();
-    return Promise.resolve();
-  }
-
-  override save(force = false) {
-    if (force) {
-      return this.flush();
-    }
-    return Promise.resolve();
-  }
-
-  override wantsSave(): boolean {
-    // We persist directly from setSyncData/storeClientOptions so the SDK's
-    // periodic save hook stays disabled. Shutdown uses flush() for a final sync.
-    return false;
-  }
-
-  override async deleteAllData(): Promise<void> {
-    if (this.persistTimer) {
-      clearTimeout(this.persistTimer);
-      this.persistTimer = null;
-    }
-    this.dirty = false;
-    await this.persistPromise?.catch(() => undefined);
-    await super.deleteAllData();
-    this.savedSync = null;
-    this.savedClientOptions = undefined;
-    this.cleanShutdown = false;
-    await fs.rm(this.storagePath, { force: true }).catch(() => undefined);
-  }
-
-  markCleanShutdown(): void {
-    this.cleanShutdown = true;
-    this.dirty = true;
-  }
-
-  async flush(): Promise<void> {
-    if (this.persistTimer) {
-      clearTimeout(this.persistTimer);
-      this.persistTimer = null;
-    }
-    while (this.dirty || this.persistPromise) {
-      if (this.dirty && !this.persistPromise) {
-        this.persistPromise = this.persist().finally(() => {
-          this.persistPromise = null;
-        });
-      }
-      await this.persistPromise;
-    }
-  }
-
-  private markDirtyAndSchedulePersist(): void {
-    this.cleanShutdown = false;
-    this.dirty = true;
-    if (this.persistTimer) {
-      return;
-    }
-    this.persistTimer = setTimeout(() => {
-      this.persistTimer = null;
-      void this.flush().catch((err) => {
-        LogService.warn("MatrixFileSyncStore", "Failed to persist Matrix sync store:", err);
-      });
-    }, PERSIST_DEBOUNCE_MS);
-    this.persistTimer.unref?.();
-  }
-
-  private async persist(): Promise<void> {
-    this.dirty = false;
-    const payload: PersistedMatrixSyncStore = {
-      version: STORE_VERSION,
-      savedSync: this.savedSync ? cloneJson(this.savedSync) : null,
-      cleanShutdown: this.cleanShutdown,
-      ...(this.savedClientOptions ? { clientOptions: cloneJson(this.savedClientOptions) } : {}),
-    };
-    try {
-      await this.persistLock(async () => {
-        await writeJsonFileAtomically(this.storagePath, payload);
-        claimCurrentTokenStorageState({
-          rootDir: path.dirname(this.storagePath),
-        });
-      });
-    } catch (err) {
-      this.dirty = true;
-      throw err;
-    }
-  }
-}

package/src/matrix/client/logging.ts

@@ -1,140 +0,0 @@
-import { logger as matrixJsSdkRootLogger } from "matrix-js-sdk/lib/logger.js";
-import { ConsoleLogger, LogService, setMatrixConsoleLogging } from "../sdk/logger.js";
-
-let matrixSdkLoggingConfigured = false;
-let matrixSdkLogMode: "default" | "quiet" = "default";
-const matrixSdkBaseLogger = new ConsoleLogger();
-let matrixJsSdkRootLoggerSnapshot: MatrixJsSdkRootLoggerSnapshot | null = null;
-
-type MatrixJsSdkLogger = {
-  trace: (...messageOrObject: unknown[]) => void;
-  debug: (...messageOrObject: unknown[]) => void;
-  info: (...messageOrObject: unknown[]) => void;
-  warn: (...messageOrObject: unknown[]) => void;
-  error: (...messageOrObject: unknown[]) => void;
-  getChild: (namespace: string) => MatrixJsSdkLogger;
-};
-
-type MatrixJsSdkLoglevelLogger = {
-  getLevel?: () => number | string;
-  methodFactory?: unknown;
-  rebuild?: () => void;
-  setLevel?: (level: number | string, persist?: boolean) => void;
-};
-
-type MatrixJsSdkRootLoggerSnapshot = {
-  level?: number | string;
-  methodFactory?: unknown;
-};
-
-function shouldSuppressMatrixHttpNotFound(module: string, messageOrObject: unknown[]): boolean {
-  if (!module.includes("MatrixHttpClient")) {
-    return false;
-  }
-  return messageOrObject.some((entry) => {
-    if (!entry || typeof entry !== "object") {
-      return false;
-    }
-    return (entry as { errcode?: string }).errcode === "M_NOT_FOUND";
-  });
-}
-
-export function ensureMatrixSdkLoggingConfigured(): void {
-  if (!matrixSdkLoggingConfigured) {
-    matrixSdkLoggingConfigured = true;
-  }
-  applyMatrixSdkLogger();
-}
-
-export function setMatrixSdkLogMode(mode: "default" | "quiet"): void {
-  matrixSdkLogMode = mode;
-  if (!matrixSdkLoggingConfigured) {
-    return;
-  }
-  applyMatrixSdkLogger();
-}
-
-export function setMatrixSdkConsoleLogging(enabled: boolean): void {
-  setMatrixConsoleLogging(enabled);
-}
-
-export function createMatrixJsSdkClientLogger(prefix = "matrix"): MatrixJsSdkLogger {
-  return createMatrixJsSdkLoggerInstance(prefix);
-}
-
-function applyMatrixSdkLogger(): void {
-  if (matrixSdkLogMode === "quiet") {
-    setMatrixJsSdkRootLoggerLevel("silent");
-    LogService.setLogger({
-      trace: () => {},
-      debug: () => {},
-      info: () => {},
-      warn: () => {},
-      error: () => {},
-    });
-    return;
-  }
-
-  setMatrixJsSdkRootLoggerLevel("debug");
-  LogService.setLogger({
-    trace: (module, ...messageOrObject) => matrixSdkBaseLogger.trace(module, ...messageOrObject),
-    debug: (module, ...messageOrObject) => matrixSdkBaseLogger.debug(module, ...messageOrObject),
-    info: (module, ...messageOrObject) => matrixSdkBaseLogger.info(module, ...messageOrObject),
-    warn: (module, ...messageOrObject) => matrixSdkBaseLogger.warn(module, ...messageOrObject),
-    error: (module, ...messageOrObject) => {
-      if (shouldSuppressMatrixHttpNotFound(module, messageOrObject)) {
-        return;
-      }
-      matrixSdkBaseLogger.error(module, ...messageOrObject);
-    },
-  });
-}
-
-function setMatrixJsSdkRootLoggerLevel(level: "debug" | "silent"): void {
-  const logger = matrixJsSdkRootLogger as unknown as MatrixJsSdkLoglevelLogger;
-  matrixJsSdkRootLoggerSnapshot ??= {
-    level: logger.getLevel?.(),
-    methodFactory: logger.methodFactory,
-  };
-  if (level === "silent") {
-    logger.methodFactory = () => () => undefined;
-    logger.setLevel?.("silent", false);
-    logger.rebuild?.();
-    return;
-  }
-  logger.methodFactory = matrixJsSdkRootLoggerSnapshot.methodFactory;
-  const previousLevel = matrixJsSdkRootLoggerSnapshot.level;
-  if (typeof previousLevel === "string" || typeof previousLevel === "number") {
-    logger.setLevel?.(previousLevel, false);
-  }
-  logger.rebuild?.();
-}
-
-function createMatrixJsSdkLoggerInstance(prefix: string): MatrixJsSdkLogger {
-  const log = (method: keyof ConsoleLogger, ...messageOrObject: unknown[]): void => {
-    if (matrixSdkLogMode === "quiet") {
-      return;
-    }
-    (matrixSdkBaseLogger[method] as (module: string, ...args: unknown[]) => void)(
-      prefix,
-      ...messageOrObject,
-    );
-  };
-
-  return {
-    trace: (...messageOrObject) => log("trace", ...messageOrObject),
-    debug: (...messageOrObject) => log("debug", ...messageOrObject),
-    info: (...messageOrObject) => log("info", ...messageOrObject),
-    warn: (...messageOrObject) => log("warn", ...messageOrObject),
-    error: (...messageOrObject) => {
-      if (shouldSuppressMatrixHttpNotFound(prefix, messageOrObject)) {
-        return;
-      }
-      log("error", ...messageOrObject);
-    },
-    getChild: (namespace: string) => {
-      const nextNamespace = namespace.trim();
-      return createMatrixJsSdkLoggerInstance(nextNamespace ? `${prefix}.${nextNamespace}` : prefix);
-    },
-  };
-}

package/src/matrix/client/migration-snapshot.runtime.ts

@@ -1 +0,0 @@
-export { maybeCreateMatrixMigrationSnapshot } from "../../migration-snapshot-backup.js";

package/src/matrix/client/private-network-host.ts

@@ -1 +0,0 @@
-export { isPrivateOrLoopbackHost } from "klaw/plugin-sdk/ssrf-runtime";

package/src/matrix/client/runtime.ts

@@ -1,4 +0,0 @@
-export function isBunRuntime(): boolean {
-  const versions = process.versions as { bun?: string };
-  return typeof versions.bun === "string";
-}