@elizaos/plugin-matrix 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/index.js

@@ -0,0 +1,4888 @@
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/errors.js
+var messages, setErrorCode = (error, value) => {
+  Object.defineProperty(error, "code", {
+    value,
+    writable: false,
+    enumerable: true,
+    configurable: false
+  });
+}, AbortError, ConstraintError, DataError, InvalidAccessError, InvalidStateError, NotFoundError, ReadOnlyError, SyntaxError, TransactionInactiveError, VersionError;
+var init_errors = __esm(() => {
+  messages = {
+    AbortError: "A request was aborted, for example through a call to IDBTransaction.abort.",
+    ConstraintError: "A mutation operation in the transaction failed because a constraint was not satisfied. For example, an object such as an object store or index already exists and a request attempted to create a new one.",
+    DataCloneError: "The data being stored could not be cloned by the internal structured cloning algorithm.",
+    DataError: "Data provided to an operation does not meet requirements.",
+    InvalidAccessError: "An invalid operation was performed on an object. For example transaction creation attempt was made, but an empty scope was provided.",
+    InvalidStateError: "An operation was called on an object on which it is not allowed or at a time when it is not allowed. Also occurs if a request is made on a source object that has been deleted or removed. Use TransactionInactiveError or ReadOnlyError when possible, as they are more specific variations of InvalidStateError.",
+    NotFoundError: "The operation failed because the requested database object could not be found. For example, an object store did not exist but was being opened.",
+    ReadOnlyError: 'The mutating operation was attempted in a "readonly" transaction.',
+    TransactionInactiveError: "A request was placed against a transaction which is currently not active, or which is finished.",
+    SyntaxError: "The keypath argument contains an invalid key path",
+    VersionError: "An attempt was made to open a database using a lower version than the existing version."
+  };
+  AbortError = class AbortError extends DOMException {
+    constructor(message = messages.AbortError) {
+      super(message, "AbortError");
+    }
+  };
+  ConstraintError = class ConstraintError extends DOMException {
+    constructor(message = messages.ConstraintError) {
+      super(message, "ConstraintError");
+    }
+  };
+  DataError = class DataError extends DOMException {
+    constructor(message = messages.DataError) {
+      super(message, "DataError");
+      setErrorCode(this, 0);
+    }
+  };
+  InvalidAccessError = class InvalidAccessError extends DOMException {
+    constructor(message = messages.InvalidAccessError) {
+      super(message, "InvalidAccessError");
+    }
+  };
+  InvalidStateError = class InvalidStateError extends DOMException {
+    constructor(message = messages.InvalidStateError) {
+      super(message, "InvalidStateError");
+      setErrorCode(this, 11);
+    }
+  };
+  NotFoundError = class NotFoundError extends DOMException {
+    constructor(message = messages.NotFoundError) {
+      super(message, "NotFoundError");
+    }
+  };
+  ReadOnlyError = class ReadOnlyError extends DOMException {
+    constructor(message = messages.ReadOnlyError) {
+      super(message, "ReadOnlyError");
+    }
+  };
+  SyntaxError = class SyntaxError extends DOMException {
+    constructor(message = messages.VersionError) {
+      super(message, "SyntaxError");
+      setErrorCode(this, 12);
+    }
+  };
+  TransactionInactiveError = class TransactionInactiveError extends DOMException {
+    constructor(message = messages.TransactionInactiveError) {
+      super(message, "TransactionInactiveError");
+      setErrorCode(this, 0);
+    }
+  };
+  VersionError = class VersionError extends DOMException {
+    constructor(message = messages.VersionError) {
+      super(message, "VersionError");
+    }
+  };
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/isSharedArrayBuffer.js
+function isSharedArrayBuffer(input) {
+  return typeof SharedArrayBuffer !== "undefined" && input instanceof SharedArrayBuffer;
+}
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/valueToKeyWithoutThrowing.js
+var INVALID_TYPE, INVALID_VALUE, valueToKeyWithoutThrowing = (input, seen) => {
+  if (typeof input === "number") {
+    if (isNaN(input)) {
+      return INVALID_VALUE;
+    }
+    return input;
+  } else if (Object.prototype.toString.call(input) === "[object Date]") {
+    const ms = input.valueOf();
+    if (isNaN(ms)) {
+      return INVALID_VALUE;
+    }
+    return new Date(ms);
+  } else if (typeof input === "string") {
+    return input;
+  } else if (input instanceof ArrayBuffer || isSharedArrayBuffer(input) || typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView && ArrayBuffer.isView(input)) {
+    if ("detached" in input ? input.detached : input.byteLength === 0) {
+      return INVALID_VALUE;
+    }
+    let arrayBuffer;
+    let offset = 0;
+    let length = 0;
+    if (input instanceof ArrayBuffer || isSharedArrayBuffer(input)) {
+      arrayBuffer = input;
+      length = input.byteLength;
+    } else {
+      arrayBuffer = input.buffer;
+      offset = input.byteOffset;
+      length = input.byteLength;
+    }
+    return arrayBuffer.slice(offset, offset + length);
+  } else if (Array.isArray(input)) {
+    if (seen === undefined) {
+      seen = new Set;
+    } else if (seen.has(input)) {
+      return INVALID_VALUE;
+    }
+    seen.add(input);
+    let hasInvalid = false;
+    const keys = Array.from({
+      length: input.length
+    }, (_, i) => {
+      if (hasInvalid) {
+        return;
+      }
+      const hop = Object.hasOwn(input, i);
+      if (!hop) {
+        hasInvalid = true;
+        return;
+      }
+      const entry = input[i];
+      const key = valueToKeyWithoutThrowing(entry, seen);
+      if (key === INVALID_VALUE || key === INVALID_TYPE) {
+        hasInvalid = true;
+        return;
+      }
+      return key;
+    });
+    if (hasInvalid) {
+      return INVALID_VALUE;
+    }
+    return keys;
+  } else {
+    return INVALID_TYPE;
+  }
+}, valueToKeyWithoutThrowing_default;
+var init_valueToKeyWithoutThrowing = __esm(() => {
+  INVALID_TYPE = Symbol("INVALID_TYPE");
+  INVALID_VALUE = Symbol("INVALID_VALUE");
+  valueToKeyWithoutThrowing_default = valueToKeyWithoutThrowing;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/valueToKey.js
+var valueToKey = (input, seen) => {
+  const result = valueToKeyWithoutThrowing_default(input, seen);
+  if (result === INVALID_VALUE || result === INVALID_TYPE) {
+    throw new DataError;
+  }
+  return result;
+}, valueToKey_default;
+var init_valueToKey = __esm(() => {
+  init_errors();
+  init_valueToKeyWithoutThrowing();
+  valueToKey_default = valueToKey;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/cmp.js
+var getType = (x) => {
+  if (typeof x === "number") {
+    return "Number";
+  }
+  if (Object.prototype.toString.call(x) === "[object Date]") {
+    return "Date";
+  }
+  if (Array.isArray(x)) {
+    return "Array";
+  }
+  if (typeof x === "string") {
+    return "String";
+  }
+  if (x instanceof ArrayBuffer) {
+    return "Binary";
+  }
+  throw new DataError;
+}, cmp = (first, second) => {
+  if (second === undefined) {
+    throw new TypeError;
+  }
+  first = valueToKey_default(first);
+  second = valueToKey_default(second);
+  const t1 = getType(first);
+  const t2 = getType(second);
+  if (t1 !== t2) {
+    if (t1 === "Array") {
+      return 1;
+    }
+    if (t1 === "Binary" && (t2 === "String" || t2 === "Date" || t2 === "Number")) {
+      return 1;
+    }
+    if (t1 === "String" && (t2 === "Date" || t2 === "Number")) {
+      return 1;
+    }
+    if (t1 === "Date" && t2 === "Number") {
+      return 1;
+    }
+    return -1;
+  }
+  if (t1 === "Binary") {
+    first = new Uint8Array(first);
+    second = new Uint8Array(second);
+  }
+  if (t1 === "Array" || t1 === "Binary") {
+    const length = Math.min(first.length, second.length);
+    for (let i = 0;i < length; i++) {
+      const result = cmp(first[i], second[i]);
+      if (result !== 0) {
+        return result;
+      }
+    }
+    if (first.length > second.length) {
+      return 1;
+    }
+    if (first.length < second.length) {
+      return -1;
+    }
+    return 0;
+  }
+  if (t1 === "Date") {
+    if (first.getTime() === second.getTime()) {
+      return 0;
+    }
+  } else {
+    if (first === second) {
+      return 0;
+    }
+  }
+  return first > second ? 1 : -1;
+}, cmp_default;
+var init_cmp = __esm(() => {
+  init_errors();
+  init_valueToKey();
+  cmp_default = cmp;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/FDBKeyRange.js
+var FDBKeyRange, FDBKeyRange_default;
+var init_FDBKeyRange = __esm(() => {
+  init_cmp();
+  init_errors();
+  init_valueToKey();
+  FDBKeyRange = class FDBKeyRange {
+    static only(value) {
+      if (arguments.length === 0) {
+        throw new TypeError;
+      }
+      value = valueToKey_default(value);
+      return new FDBKeyRange(value, value, false, false);
+    }
+    static lowerBound(lower, open = false) {
+      if (arguments.length === 0) {
+        throw new TypeError;
+      }
+      lower = valueToKey_default(lower);
+      return new FDBKeyRange(lower, undefined, open, true);
+    }
+    static upperBound(upper, open = false) {
+      if (arguments.length === 0) {
+        throw new TypeError;
+      }
+      upper = valueToKey_default(upper);
+      return new FDBKeyRange(undefined, upper, true, open);
+    }
+    static bound(lower, upper, lowerOpen = false, upperOpen = false) {
+      if (arguments.length < 2) {
+        throw new TypeError;
+      }
+      const cmpResult = cmp_default(lower, upper);
+      if (cmpResult === 1 || cmpResult === 0 && (lowerOpen || upperOpen)) {
+        throw new DataError;
+      }
+      lower = valueToKey_default(lower);
+      upper = valueToKey_default(upper);
+      return new FDBKeyRange(lower, upper, lowerOpen, upperOpen);
+    }
+    constructor(lower, upper, lowerOpen, upperOpen) {
+      this.lower = lower;
+      this.upper = upper;
+      this.lowerOpen = lowerOpen;
+      this.upperOpen = upperOpen;
+    }
+    includes(key) {
+      if (arguments.length === 0) {
+        throw new TypeError;
+      }
+      key = valueToKey_default(key);
+      if (this.lower !== undefined) {
+        const cmpResult = cmp_default(this.lower, key);
+        if (cmpResult === 1 || cmpResult === 0 && this.lowerOpen) {
+          return false;
+        }
+      }
+      if (this.upper !== undefined) {
+        const cmpResult = cmp_default(this.upper, key);
+        if (cmpResult === -1 || cmpResult === 0 && this.upperOpen) {
+          return false;
+        }
+      }
+      return true;
+    }
+    get [Symbol.toStringTag]() {
+      return "IDBKeyRange";
+    }
+  };
+  FDBKeyRange_default = FDBKeyRange;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/extractKey.js
+var extractKey = (keyPath, value) => {
+  if (Array.isArray(keyPath)) {
+    const result = [];
+    for (let item of keyPath) {
+      if (item !== undefined && item !== null && typeof item !== "string" && item.toString) {
+        item = item.toString();
+      }
+      const key = extractKey(item, value).key;
+      result.push(valueToKey_default(key));
+    }
+    return {
+      type: "found",
+      key: result
+    };
+  }
+  if (keyPath === "") {
+    return {
+      type: "found",
+      key: value
+    };
+  }
+  let remainingKeyPath = keyPath;
+  let object = value;
+  while (remainingKeyPath !== null) {
+    let identifier;
+    const i = remainingKeyPath.indexOf(".");
+    if (i >= 0) {
+      identifier = remainingKeyPath.slice(0, i);
+      remainingKeyPath = remainingKeyPath.slice(i + 1);
+    } else {
+      identifier = remainingKeyPath;
+      remainingKeyPath = null;
+    }
+    const isSpecialIdentifier = identifier === "length" && (typeof object === "string" || Array.isArray(object)) || (identifier === "size" || identifier === "type") && typeof Blob !== "undefined" && object instanceof Blob || (identifier === "name" || identifier === "lastModified") && typeof File !== "undefined" && object instanceof File;
+    if (!isSpecialIdentifier && (typeof object !== "object" || object === null || !Object.hasOwn(object, identifier))) {
+      return {
+        type: "notFound"
+      };
+    }
+    object = object[identifier];
+  }
+  return {
+    type: "found",
+    key: object
+  };
+}, extractKey_default;
+var init_extractKey = __esm(() => {
+  init_valueToKey();
+  extractKey_default = extractKey;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/cloneValueForInsertion.js
+function cloneValueForInsertion(value, transaction) {
+  if (transaction._state !== "active") {
+    throw new Error("Assert: transaction state is active");
+  }
+  transaction._state = "inactive";
+  try {
+    return structuredClone(value);
+  } finally {
+    transaction._state = "active";
+  }
+}
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/FDBCursor.js
+var getEffectiveObjectStore = (cursor) => {
+  if (cursor.source instanceof FDBObjectStore_default) {
+    return cursor.source;
+  }
+  return cursor.source.objectStore;
+}, makeKeyRange = (range, lowers, uppers) => {
+  let lower = range !== undefined ? range.lower : undefined;
+  let upper = range !== undefined ? range.upper : undefined;
+  for (const lowerTemp of lowers) {
+    if (lowerTemp === undefined) {
+      continue;
+    }
+    if (lower === undefined || cmp_default(lower, lowerTemp) === 1) {
+      lower = lowerTemp;
+    }
+  }
+  for (const upperTemp of uppers) {
+    if (upperTemp === undefined) {
+      continue;
+    }
+    if (upper === undefined || cmp_default(upper, upperTemp) === -1) {
+      upper = upperTemp;
+    }
+  }
+  if (lower !== undefined && upper !== undefined) {
+    return FDBKeyRange_default.bound(lower, upper);
+  }
+  if (lower !== undefined) {
+    return FDBKeyRange_default.lowerBound(lower);
+  }
+  if (upper !== undefined) {
+    return FDBKeyRange_default.upperBound(upper);
+  }
+}, FDBCursor, FDBCursor_default;
+var init_FDBCursor = __esm(() => {
+  init_FDBKeyRange();
+  init_FDBObjectStore();
+  init_cmp();
+  init_errors();
+  init_extractKey();
+  init_valueToKey();
+  FDBCursor = class FDBCursor {
+    _gotValue = false;
+    _position = undefined;
+    _objectStorePosition = undefined;
+    _keyOnly = false;
+    _key = undefined;
+    _primaryKey = undefined;
+    constructor(source, range, direction = "next", request, keyOnly = false) {
+      this._range = range;
+      this._source = source;
+      this._direction = direction;
+      this._request = request;
+      this._keyOnly = keyOnly;
+    }
+    get source() {
+      return this._source;
+    }
+    set source(val) {}
+    get request() {
+      return this._request;
+    }
+    set request(val) {}
+    get direction() {
+      return this._direction;
+    }
+    set direction(val) {}
+    get key() {
+      return this._key;
+    }
+    set key(val) {}
+    get primaryKey() {
+      return this._primaryKey;
+    }
+    set primaryKey(val) {}
+    _iterate(key, primaryKey) {
+      const sourceIsObjectStore = this.source instanceof FDBObjectStore_default;
+      const records = this.source instanceof FDBObjectStore_default ? this.source._rawObjectStore.records : this.source._rawIndex.records;
+      let foundRecord;
+      if (this.direction === "next") {
+        const range = makeKeyRange(this._range, [key, this._position], []);
+        for (const record of records.values(range)) {
+          const cmpResultKey = key !== undefined ? cmp_default(record.key, key) : undefined;
+          const cmpResultPosition = this._position !== undefined ? cmp_default(record.key, this._position) : undefined;
+          if (key !== undefined) {
+            if (cmpResultKey === -1) {
+              continue;
+            }
+          }
+          if (primaryKey !== undefined) {
+            if (cmpResultKey === -1) {
+              continue;
+            }
+            const cmpResultPrimaryKey = cmp_default(record.value, primaryKey);
+            if (cmpResultKey === 0 && cmpResultPrimaryKey === -1) {
+              continue;
+            }
+          }
+          if (this._position !== undefined && sourceIsObjectStore) {
+            if (cmpResultPosition !== 1) {
+              continue;
+            }
+          }
+          if (this._position !== undefined && !sourceIsObjectStore) {
+            if (cmpResultPosition === -1) {
+              continue;
+            }
+            if (cmpResultPosition === 0 && cmp_default(record.value, this._objectStorePosition) !== 1) {
+              continue;
+            }
+          }
+          if (this._range !== undefined) {
+            if (!this._range.includes(record.key)) {
+              continue;
+            }
+          }
+          foundRecord = record;
+          break;
+        }
+      } else if (this.direction === "nextunique") {
+        const range = makeKeyRange(this._range, [key, this._position], []);
+        for (const record of records.values(range)) {
+          if (key !== undefined) {
+            if (cmp_default(record.key, key) === -1) {
+              continue;
+            }
+          }
+          if (this._position !== undefined) {
+            if (cmp_default(record.key, this._position) !== 1) {
+              continue;
+            }
+          }
+          if (this._range !== undefined) {
+            if (!this._range.includes(record.key)) {
+              continue;
+            }
+          }
+          foundRecord = record;
+          break;
+        }
+      } else if (this.direction === "prev") {
+        const range = makeKeyRange(this._range, [], [key, this._position]);
+        for (const record of records.values(range, "prev")) {
+          const cmpResultKey = key !== undefined ? cmp_default(record.key, key) : undefined;
+          const cmpResultPosition = this._position !== undefined ? cmp_default(record.key, this._position) : undefined;
+          if (key !== undefined) {
+            if (cmpResultKey === 1) {
+              continue;
+            }
+          }
+          if (primaryKey !== undefined) {
+            if (cmpResultKey === 1) {
+              continue;
+            }
+            const cmpResultPrimaryKey = cmp_default(record.value, primaryKey);
+            if (cmpResultKey === 0 && cmpResultPrimaryKey === 1) {
+              continue;
+            }
+          }
+          if (this._position !== undefined && sourceIsObjectStore) {
+            if (cmpResultPosition !== -1) {
+              continue;
+            }
+          }
+          if (this._position !== undefined && !sourceIsObjectStore) {
+            if (cmpResultPosition === 1) {
+              continue;
+            }
+            if (cmpResultPosition === 0 && cmp_default(record.value, this._objectStorePosition) !== -1) {
+              continue;
+            }
+          }
+          if (this._range !== undefined) {
+            if (!this._range.includes(record.key)) {
+              continue;
+            }
+          }
+          foundRecord = record;
+          break;
+        }
+      } else if (this.direction === "prevunique") {
+        let tempRecord;
+        const range = makeKeyRange(this._range, [], [key, this._position]);
+        for (const record of records.values(range, "prev")) {
+          if (key !== undefined) {
+            if (cmp_default(record.key, key) === 1) {
+              continue;
+            }
+          }
+          if (this._position !== undefined) {
+            if (cmp_default(record.key, this._position) !== -1) {
+              continue;
+            }
+          }
+          if (this._range !== undefined) {
+            if (!this._range.includes(record.key)) {
+              continue;
+            }
+          }
+          tempRecord = record;
+          break;
+        }
+        if (tempRecord) {
+          foundRecord = records.get(tempRecord.key);
+        }
+      }
+      let result;
+      if (!foundRecord) {
+        this._key = undefined;
+        if (!sourceIsObjectStore) {
+          this._objectStorePosition = undefined;
+        }
+        if (!this._keyOnly && this.toString() === "[object IDBCursorWithValue]") {
+          this.value = undefined;
+        }
+        result = null;
+      } else {
+        this._position = foundRecord.key;
+        if (!sourceIsObjectStore) {
+          this._objectStorePosition = foundRecord.value;
+        }
+        this._key = foundRecord.key;
+        if (sourceIsObjectStore) {
+          this._primaryKey = structuredClone(foundRecord.key);
+          if (!this._keyOnly && this.toString() === "[object IDBCursorWithValue]") {
+            this.value = structuredClone(foundRecord.value);
+          }
+        } else {
+          this._primaryKey = structuredClone(foundRecord.value);
+          if (!this._keyOnly && this.toString() === "[object IDBCursorWithValue]") {
+            if (this.source instanceof FDBObjectStore_default) {
+              throw new Error("This should never happen");
+            }
+            const value = this.source.objectStore._rawObjectStore.getValue(foundRecord.value);
+            this.value = structuredClone(value);
+          }
+        }
+        this._gotValue = true;
+        result = this;
+      }
+      return result;
+    }
+    update(value) {
+      if (value === undefined) {
+        throw new TypeError;
+      }
+      const effectiveObjectStore = getEffectiveObjectStore(this);
+      const effectiveKey = Object.hasOwn(this.source, "_rawIndex") ? this.primaryKey : this._position;
+      const transaction = effectiveObjectStore.transaction;
+      if (transaction._state !== "active") {
+        throw new TransactionInactiveError;
+      }
+      if (transaction.mode === "readonly") {
+        throw new ReadOnlyError;
+      }
+      if (effectiveObjectStore._rawObjectStore.deleted) {
+        throw new InvalidStateError;
+      }
+      if (!(this.source instanceof FDBObjectStore_default) && this.source._rawIndex.deleted) {
+        throw new InvalidStateError;
+      }
+      if (!this._gotValue || !Object.hasOwn(this, "value")) {
+        throw new InvalidStateError;
+      }
+      const clone = cloneValueForInsertion(value, transaction);
+      if (effectiveObjectStore.keyPath !== null) {
+        let tempKey;
+        try {
+          tempKey = extractKey_default(effectiveObjectStore.keyPath, clone).key;
+        } catch (err) {}
+        if (cmp_default(tempKey, effectiveKey) !== 0) {
+          throw new DataError;
+        }
+      }
+      const record = {
+        key: effectiveKey,
+        value: clone
+      };
+      return transaction._execRequestAsync({
+        operation: effectiveObjectStore._rawObjectStore.storeRecord.bind(effectiveObjectStore._rawObjectStore, record, false, transaction._rollbackLog),
+        source: this
+      });
+    }
+    advance(count) {
+      if (!Number.isInteger(count) || count <= 0) {
+        throw new TypeError;
+      }
+      const effectiveObjectStore = getEffectiveObjectStore(this);
+      const transaction = effectiveObjectStore.transaction;
+      if (transaction._state !== "active") {
+        throw new TransactionInactiveError;
+      }
+      if (effectiveObjectStore._rawObjectStore.deleted) {
+        throw new InvalidStateError;
+      }
+      if (!(this.source instanceof FDBObjectStore_default) && this.source._rawIndex.deleted) {
+        throw new InvalidStateError;
+      }
+      if (!this._gotValue) {
+        throw new InvalidStateError;
+      }
+      if (this._request) {
+        this._request.readyState = "pending";
+      }
+      transaction._execRequestAsync({
+        operation: () => {
+          let result;
+          for (let i = 0;i < count; i++) {
+            result = this._iterate();
+            if (!result) {
+              break;
+            }
+          }
+          return result;
+        },
+        request: this._request,
+        source: this.source
+      });
+      this._gotValue = false;
+    }
+    continue(key) {
+      const effectiveObjectStore = getEffectiveObjectStore(this);
+      const transaction = effectiveObjectStore.transaction;
+      if (transaction._state !== "active") {
+        throw new TransactionInactiveError;
+      }
+      if (effectiveObjectStore._rawObjectStore.deleted) {
+        throw new InvalidStateError;
+      }
+      if (!(this.source instanceof FDBObjectStore_default) && this.source._rawIndex.deleted) {
+        throw new InvalidStateError;
+      }
+      if (!this._gotValue) {
+        throw new InvalidStateError;
+      }
+      if (key !== undefined) {
+        key = valueToKey_default(key);
+        const cmpResult = cmp_default(key, this._position);
+        if (cmpResult <= 0 && (this.direction === "next" || this.direction === "nextunique") || cmpResult >= 0 && (this.direction === "prev" || this.direction === "prevunique")) {
+          throw new DataError;
+        }
+      }
+      if (this._request) {
+        this._request.readyState = "pending";
+      }
+      transaction._execRequestAsync({
+        operation: this._iterate.bind(this, key),
+        request: this._request,
+        source: this.source
+      });
+      this._gotValue = false;
+    }
+    continuePrimaryKey(key, primaryKey) {
+      const effectiveObjectStore = getEffectiveObjectStore(this);
+      const transaction = effectiveObjectStore.transaction;
+      if (transaction._state !== "active") {
+        throw new TransactionInactiveError;
+      }
+      if (effectiveObjectStore._rawObjectStore.deleted) {
+        throw new InvalidStateError;
+      }
+      if (!(this.source instanceof FDBObjectStore_default) && this.source._rawIndex.deleted) {
+        throw new InvalidStateError;
+      }
+      if (this.source instanceof FDBObjectStore_default || this.direction !== "next" && this.direction !== "prev") {
+        throw new InvalidAccessError;
+      }
+      if (!this._gotValue) {
+        throw new InvalidStateError;
+      }
+      if (key === undefined || primaryKey === undefined) {
+        throw new DataError;
+      }
+      key = valueToKey_default(key);
+      const cmpResult = cmp_default(key, this._position);
+      if (cmpResult === -1 && this.direction === "next" || cmpResult === 1 && this.direction === "prev") {
+        throw new DataError;
+      }
+      const cmpResult2 = cmp_default(primaryKey, this._objectStorePosition);
+      if (cmpResult === 0) {
+        if (cmpResult2 <= 0 && this.direction === "next" || cmpResult2 >= 0 && this.direction === "prev") {
+          throw new DataError;
+        }
+      }
+      if (this._request) {
+        this._request.readyState = "pending";
+      }
+      transaction._execRequestAsync({
+        operation: this._iterate.bind(this, key, primaryKey),
+        request: this._request,
+        source: this.source
+      });
+      this._gotValue = false;
+    }
+    delete() {
+      const effectiveObjectStore = getEffectiveObjectStore(this);
+      const effectiveKey = Object.hasOwn(this.source, "_rawIndex") ? this.primaryKey : this._position;
+      const transaction = effectiveObjectStore.transaction;
+      if (transaction._state !== "active") {
+        throw new TransactionInactiveError;
+      }
+      if (transaction.mode === "readonly") {
+        throw new ReadOnlyError;
+      }
+      if (effectiveObjectStore._rawObjectStore.deleted) {
+        throw new InvalidStateError;
+      }
+      if (!(this.source instanceof FDBObjectStore_default) && this.source._rawIndex.deleted) {
+        throw new InvalidStateError;
+      }
+      if (!this._gotValue || !Object.hasOwn(this, "value")) {
+        throw new InvalidStateError;
+      }
+      return transaction._execRequestAsync({
+        operation: effectiveObjectStore._rawObjectStore.deleteRecord.bind(effectiveObjectStore._rawObjectStore, effectiveKey, transaction._rollbackLog),
+        source: this
+      });
+    }
+    get [Symbol.toStringTag]() {
+      return "IDBCursor";
+    }
+  };
+  FDBCursor_default = FDBCursor;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/FDBCursorWithValue.js
+var FDBCursorWithValue, FDBCursorWithValue_default;
+var init_FDBCursorWithValue = __esm(() => {
+  init_FDBCursor();
+  FDBCursorWithValue = class FDBCursorWithValue extends FDBCursor_default {
+    value = undefined;
+    constructor(source, range, direction, request) {
+      super(source, range, direction, request);
+    }
+    get [Symbol.toStringTag]() {
+      return "IDBCursorWithValue";
+    }
+  };
+  FDBCursorWithValue_default = FDBCursorWithValue;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/FakeEventTarget.js
+class FakeEventTarget {
+  listeners = [];
+  addEventListener(type, callback, options) {
+    const capture = !!(typeof options === "object" && options ? options.capture : options);
+    this.listeners.push({
+      callback,
+      capture,
+      type
+    });
+  }
+  removeEventListener(type, callback, options) {
+    const capture = !!(typeof options === "object" && options ? options.capture : options);
+    const i = this.listeners.findIndex((listener) => {
+      return listener.type === type && listener.callback === callback && listener.capture === capture;
+    });
+    this.listeners.splice(i, 1);
+  }
+  dispatchEvent(event) {
+    if (event.dispatched || !event.initialized) {
+      throw new InvalidStateError("The object is in an invalid state.");
+    }
+    event.isTrusted = false;
+    event.dispatched = true;
+    event.target = this;
+    event.eventPhase = event.CAPTURING_PHASE;
+    for (const obj of event.eventPath) {
+      if (!event.propagationStopped) {
+        invokeEventListeners(event, obj);
+      }
+    }
+    event.eventPhase = event.AT_TARGET;
+    if (!event.propagationStopped) {
+      invokeEventListeners(event, event.target);
+    }
+    if (event.bubbles) {
+      event.eventPath.reverse();
+      event.eventPhase = event.BUBBLING_PHASE;
+      for (const obj of event.eventPath) {
+        if (!event.propagationStopped) {
+          invokeEventListeners(event, obj);
+        }
+      }
+    }
+    event.dispatched = false;
+    event.eventPhase = event.NONE;
+    event.currentTarget = null;
+    if (event.canceled) {
+      return false;
+    }
+    return true;
+  }
+}
+var stopped = (event, listener) => {
+  return event.immediatePropagationStopped || event.eventPhase === event.CAPTURING_PHASE && listener.capture === false || event.eventPhase === event.BUBBLING_PHASE && listener.capture === true;
+}, invokeEventListeners = (event, obj) => {
+  event.currentTarget = obj;
+  const errors = [];
+  const invoke = (callbackOrObject) => {
+    try {
+      const callback2 = typeof callbackOrObject === "function" ? callbackOrObject : callbackOrObject.handleEvent;
+      callback2.call(event.currentTarget, event);
+    } catch (err) {
+      errors.push(err);
+    }
+  };
+  for (const listener of obj.listeners.slice()) {
+    if (event.type !== listener.type || stopped(event, listener)) {
+      continue;
+    }
+    invoke(listener.callback);
+  }
+  const typeToProp = {
+    abort: "onabort",
+    blocked: "onblocked",
+    close: "onclose",
+    complete: "oncomplete",
+    error: "onerror",
+    success: "onsuccess",
+    upgradeneeded: "onupgradeneeded",
+    versionchange: "onversionchange"
+  };
+  const prop = typeToProp[event.type];
+  if (prop === undefined) {
+    throw new Error(`Unknown event type: "${event.type}"`);
+  }
+  const callback = event.currentTarget[prop];
+  if (callback) {
+    const listener = {
+      callback,
+      capture: false,
+      type: event.type
+    };
+    if (!stopped(event, listener)) {
+      invoke(listener.callback);
+    }
+  }
+  if (errors.length) {
+    throw new AggregateError(errors);
+  }
+}, FakeEventTarget_default;
+var init_FakeEventTarget = __esm(() => {
+  init_errors();
+  FakeEventTarget_default = FakeEventTarget;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/FDBRequest.js
+var FDBRequest, FDBRequest_default;
+var init_FDBRequest = __esm(() => {
+  init_errors();
+  init_FakeEventTarget();
+  FDBRequest = class FDBRequest extends FakeEventTarget_default {
+    _result = null;
+    _error = null;
+    source = null;
+    transaction = null;
+    readyState = "pending";
+    onsuccess = null;
+    onerror = null;
+    get error() {
+      if (this.readyState === "pending") {
+        throw new InvalidStateError;
+      }
+      return this._error;
+    }
+    set error(value) {
+      this._error = value;
+    }
+    get result() {
+      if (this.readyState === "pending") {
+        throw new InvalidStateError;
+      }
+      return this._result;
+    }
+    set result(value) {
+      this._result = value;
+    }
+    get [Symbol.toStringTag]() {
+      return "IDBRequest";
+    }
+  };
+  FDBRequest_default = FDBRequest;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/FakeDOMStringList.js
+var FakeDOMStringList, FakeDOMStringList_default;
+var init_FakeDOMStringList = __esm(() => {
+  FakeDOMStringList = class FakeDOMStringList {
+    constructor(...values) {
+      this._values = values;
+      for (let i = 0;i < values.length; i++) {
+        this[i] = values[i];
+      }
+    }
+    contains(value) {
+      return this._values.includes(value);
+    }
+    item(i) {
+      if (i < 0 || i >= this._values.length) {
+        return null;
+      }
+      return this._values[i];
+    }
+    get length() {
+      return this._values.length;
+    }
+    [Symbol.iterator]() {
+      return this._values[Symbol.iterator]();
+    }
+    _push(...values) {
+      for (let i = 0;i < values.length; i++) {
+        this[this._values.length + i] = values[i];
+      }
+      this._values.push(...values);
+    }
+    _sort(...values) {
+      this._values.sort(...values);
+      for (let i = 0;i < this._values.length; i++) {
+        this[i] = this._values[i];
+      }
+      return this;
+    }
+  };
+  FakeDOMStringList_default = FakeDOMStringList;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/valueToKeyRange.js
+var valueToKeyRange = (value, nullDisallowedFlag = false) => {
+  if (value instanceof FDBKeyRange_default) {
+    return value;
+  }
+  if (value === null || value === undefined) {
+    if (nullDisallowedFlag) {
+      throw new DataError;
+    }
+    return new FDBKeyRange_default(undefined, undefined, false, false);
+  }
+  const key = valueToKey_default(value);
+  return FDBKeyRange_default.only(key);
+}, valueToKeyRange_default;
+var init_valueToKeyRange = __esm(() => {
+  init_FDBKeyRange();
+  init_errors();
+  init_valueToKey();
+  valueToKeyRange_default = valueToKeyRange;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/getKeyPath.js
+function getKeyPath(keyPath) {
+  return Array.isArray(keyPath) ? keyPath.map(convertKey) : convertKey(keyPath);
+}
+var convertKey = (key) => typeof key === "object" && key ? key + "" : key;
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/isPotentiallyValidKeyRange.js
+var isPotentiallyValidKeyRange = (value) => {
+  if (value instanceof FDBKeyRange_default) {
+    return true;
+  }
+  const key = valueToKeyWithoutThrowing_default(value);
+  return key !== INVALID_TYPE;
+}, isPotentiallyValidKeyRange_default;
+var init_isPotentiallyValidKeyRange = __esm(() => {
+  init_FDBKeyRange();
+  init_valueToKeyWithoutThrowing();
+  isPotentiallyValidKeyRange_default = isPotentiallyValidKeyRange;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/enforceRange.js
+var enforceRange = (num, type) => {
+  const min = 0;
+  const max = type === "unsigned long" ? 4294967295 : 9007199254740991;
+  if (isNaN(num) || num < min || num > max) {
+    throw new TypeError;
+  }
+  if (num >= 0) {
+    return Math.floor(num);
+  }
+}, enforceRange_default;
+var init_enforceRange = __esm(() => {
+  enforceRange_default = enforceRange;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/extractGetAllOptions.js
+var extractGetAllOptions = (queryOrOptions, count, numArguments) => {
+  let query;
+  let direction;
+  if (queryOrOptions === undefined || queryOrOptions === null || isPotentiallyValidKeyRange_default(queryOrOptions)) {
+    query = queryOrOptions;
+    if (numArguments > 1 && count !== undefined) {
+      count = enforceRange_default(count, "unsigned long");
+    }
+  } else {
+    const getAllOptions = queryOrOptions;
+    if (getAllOptions.query !== undefined) {
+      query = getAllOptions.query;
+    }
+    if (getAllOptions.count !== undefined) {
+      count = enforceRange_default(getAllOptions.count, "unsigned long");
+    }
+    if (getAllOptions.direction !== undefined) {
+      direction = getAllOptions.direction;
+    }
+  }
+  return {
+    query,
+    count,
+    direction
+  };
+}, extractGetAllOptions_default;
+var init_extractGetAllOptions = __esm(() => {
+  init_isPotentiallyValidKeyRange();
+  init_enforceRange();
+  extractGetAllOptions_default = extractGetAllOptions;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/FDBIndex.js
+var confirmActiveTransaction = (index) => {
+  if (index._rawIndex.deleted || index.objectStore._rawObjectStore.deleted) {
+    throw new InvalidStateError;
+  }
+  if (index.objectStore.transaction._state !== "active") {
+    throw new TransactionInactiveError;
+  }
+}, FDBIndex, FDBIndex_default;
+var init_FDBIndex = __esm(() => {
+  init_FDBCursor();
+  init_FDBCursorWithValue();
+  init_FDBKeyRange();
+  init_FDBRequest();
+  init_errors();
+  init_FakeDOMStringList();
+  init_valueToKey();
+  init_valueToKeyRange();
+  init_extractGetAllOptions();
+  init_enforceRange();
+  FDBIndex = class FDBIndex {
+    constructor(objectStore, rawIndex) {
+      this._rawIndex = rawIndex;
+      this._name = rawIndex.name;
+      this.objectStore = objectStore;
+      this.keyPath = getKeyPath(rawIndex.keyPath);
+      this.multiEntry = rawIndex.multiEntry;
+      this.unique = rawIndex.unique;
+    }
+    get name() {
+      return this._name;
+    }
+    set name(name) {
+      const transaction = this.objectStore.transaction;
+      if (!transaction.db._runningVersionchangeTransaction) {
+        throw transaction._state === "active" ? new InvalidStateError : new TransactionInactiveError;
+      }
+      if (transaction._state !== "active") {
+        throw new TransactionInactiveError;
+      }
+      if (this._rawIndex.deleted || this.objectStore._rawObjectStore.deleted) {
+        throw new InvalidStateError;
+      }
+      name = String(name);
+      if (name === this._name) {
+        return;
+      }
+      if (this.objectStore.indexNames.contains(name)) {
+        throw new ConstraintError;
+      }
+      const oldName = this._name;
+      const oldIndexNames = [...this.objectStore.indexNames];
+      this._name = name;
+      this._rawIndex.name = name;
+      this.objectStore._indexesCache.delete(oldName);
+      this.objectStore._indexesCache.set(name, this);
+      this.objectStore._rawObjectStore.rawIndexes.delete(oldName);
+      this.objectStore._rawObjectStore.rawIndexes.set(name, this._rawIndex);
+      this.objectStore.indexNames = new FakeDOMStringList_default(...Array.from(this.objectStore._rawObjectStore.rawIndexes.keys()).filter((indexName) => {
+        const index = this.objectStore._rawObjectStore.rawIndexes.get(indexName);
+        return index && !index.deleted;
+      }).sort());
+      if (!this.objectStore.transaction._createdIndexes.has(this._rawIndex)) {
+        transaction._rollbackLog.push(() => {
+          this._name = oldName;
+          this._rawIndex.name = oldName;
+          this.objectStore._indexesCache.delete(name);
+          this.objectStore._indexesCache.set(oldName, this);
+          this.objectStore._rawObjectStore.rawIndexes.delete(name);
+          this.objectStore._rawObjectStore.rawIndexes.set(oldName, this._rawIndex);
+          this.objectStore.indexNames = new FakeDOMStringList_default(...oldIndexNames);
+        });
+      }
+    }
+    openCursor(range, direction) {
+      confirmActiveTransaction(this);
+      if (range === null) {
+        range = undefined;
+      }
+      if (range !== undefined && !(range instanceof FDBKeyRange_default)) {
+        range = FDBKeyRange_default.only(valueToKey_default(range));
+      }
+      const request = new FDBRequest_default;
+      request.source = this;
+      request.transaction = this.objectStore.transaction;
+      const cursor = new FDBCursorWithValue_default(this, range, direction, request);
+      return this.objectStore.transaction._execRequestAsync({
+        operation: cursor._iterate.bind(cursor),
+        request,
+        source: this
+      });
+    }
+    openKeyCursor(range, direction) {
+      confirmActiveTransaction(this);
+      if (range === null) {
+        range = undefined;
+      }
+      if (range !== undefined && !(range instanceof FDBKeyRange_default)) {
+        range = FDBKeyRange_default.only(valueToKey_default(range));
+      }
+      const request = new FDBRequest_default;
+      request.source = this;
+      request.transaction = this.objectStore.transaction;
+      const cursor = new FDBCursor_default(this, range, direction, request, true);
+      return this.objectStore.transaction._execRequestAsync({
+        operation: cursor._iterate.bind(cursor),
+        request,
+        source: this
+      });
+    }
+    get(key) {
+      confirmActiveTransaction(this);
+      if (!(key instanceof FDBKeyRange_default)) {
+        key = valueToKey_default(key);
+      }
+      return this.objectStore.transaction._execRequestAsync({
+        operation: this._rawIndex.getValue.bind(this._rawIndex, key),
+        source: this
+      });
+    }
+    getAll(queryOrOptions, count) {
+      const options = extractGetAllOptions_default(queryOrOptions, count, arguments.length);
+      confirmActiveTransaction(this);
+      const range = valueToKeyRange_default(options.query);
+      return this.objectStore.transaction._execRequestAsync({
+        operation: this._rawIndex.getAllValues.bind(this._rawIndex, range, options.count, options.direction),
+        source: this
+      });
+    }
+    getKey(key) {
+      confirmActiveTransaction(this);
+      if (!(key instanceof FDBKeyRange_default)) {
+        key = valueToKey_default(key);
+      }
+      return this.objectStore.transaction._execRequestAsync({
+        operation: this._rawIndex.getKey.bind(this._rawIndex, key),
+        source: this
+      });
+    }
+    getAllKeys(queryOrOptions, count) {
+      const options = extractGetAllOptions_default(queryOrOptions, count, arguments.length);
+      confirmActiveTransaction(this);
+      const range = valueToKeyRange_default(options.query);
+      return this.objectStore.transaction._execRequestAsync({
+        operation: this._rawIndex.getAllKeys.bind(this._rawIndex, range, options.count, options.direction),
+        source: this
+      });
+    }
+    getAllRecords(options) {
+      let query;
+      let count;
+      let direction;
+      if (options !== undefined) {
+        if (options.query !== undefined) {
+          query = options.query;
+        }
+        if (options.count !== undefined) {
+          count = enforceRange_default(options.count, "unsigned long");
+        }
+        if (options.direction !== undefined) {
+          direction = options.direction;
+        }
+      }
+      confirmActiveTransaction(this);
+      const range = valueToKeyRange_default(query);
+      return this.objectStore.transaction._execRequestAsync({
+        operation: this._rawIndex.getAllRecords.bind(this._rawIndex, range, count, direction),
+        source: this
+      });
+    }
+    count(key) {
+      confirmActiveTransaction(this);
+      if (key === null) {
+        key = undefined;
+      }
+      if (key !== undefined && !(key instanceof FDBKeyRange_default)) {
+        key = FDBKeyRange_default.only(valueToKey_default(key));
+      }
+      return this.objectStore.transaction._execRequestAsync({
+        operation: () => {
+          return this._rawIndex.count(key);
+        },
+        source: this
+      });
+    }
+    get [Symbol.toStringTag]() {
+      return "IDBIndex";
+    }
+  };
+  FDBIndex_default = FDBIndex;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/canInjectKey.js
+var canInjectKey = (keyPath, value) => {
+  if (Array.isArray(keyPath)) {
+    throw new Error("The key paths used in this section are always strings and never sequences, since it is not possible to create a object store which has a key generator and also has a key path that is a sequence.");
+  }
+  const identifiers = keyPath.split(".");
+  if (identifiers.length === 0) {
+    throw new Error("Assert: identifiers is not empty");
+  }
+  identifiers.pop();
+  for (const identifier of identifiers) {
+    if (typeof value !== "object" && !Array.isArray(value)) {
+      return false;
+    }
+    const hop = Object.hasOwn(value, identifier);
+    if (!hop) {
+      return true;
+    }
+    value = value[identifier];
+  }
+  return typeof value === "object" || Array.isArray(value);
+}, canInjectKey_default;
+var init_canInjectKey = __esm(() => {
+  canInjectKey_default = canInjectKey;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/FDBRecord.js
+var FDBRecord, FDBRecord_default;
+var init_FDBRecord = __esm(() => {
+  FDBRecord = class FDBRecord {
+    constructor(key, primaryKey, value) {
+      this._key = key;
+      this._primaryKey = primaryKey;
+      this._value = value;
+    }
+    get key() {
+      return this._key;
+    }
+    set key(_) {}
+    get primaryKey() {
+      return this._primaryKey;
+    }
+    set primaryKey(_) {}
+    get value() {
+      return this._value;
+    }
+    set value(_) {}
+    get [Symbol.toStringTag]() {
+      return "IDBRecord";
+    }
+  };
+  FDBRecord_default = FDBRecord;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/binarySearchTree.js
+class BinarySearchTree {
+  _numTombstones = 0;
+  _numNodes = 0;
+  constructor(keysAreUnique) {
+    this._keysAreUnique = !!keysAreUnique;
+  }
+  size() {
+    return this._numNodes - this._numTombstones;
+  }
+  get(record) {
+    return this._getByComparator(this._root, (otherRecord) => this._compare(record, otherRecord));
+  }
+  contains(record) {
+    return !!this.get(record);
+  }
+  _compare(a, b) {
+    const keyComparison = cmp_default(a.key, b.key);
+    if (keyComparison !== 0) {
+      return keyComparison;
+    }
+    return this._keysAreUnique ? 0 : cmp_default(a.value, b.value);
+  }
+  _getByComparator(node, comparator) {
+    let current = node;
+    while (current) {
+      const comparison = comparator(current.record);
+      if (comparison < 0) {
+        current = current.left;
+      } else if (comparison > 0) {
+        current = current.right;
+      } else {
+        return current.record;
+      }
+    }
+  }
+  put(record, noOverwrite = false) {
+    if (!this._root) {
+      this._root = {
+        record,
+        left: undefined,
+        right: undefined,
+        parent: undefined,
+        deleted: false,
+        red: false
+      };
+      this._numNodes++;
+      return;
+    }
+    return this._put(this._root, record, noOverwrite);
+  }
+  _put(node, record, noOverwrite) {
+    const comparison = this._compare(record, node.record);
+    if (comparison < 0) {
+      if (node.left) {
+        return this._put(node.left, record, noOverwrite);
+      } else {
+        node.left = {
+          record,
+          left: undefined,
+          right: undefined,
+          parent: node,
+          deleted: false,
+          red: true
+        };
+        this._onNewNodeInserted(node.left);
+      }
+    } else if (comparison > 0) {
+      if (node.right) {
+        return this._put(node.right, record, noOverwrite);
+      } else {
+        node.right = {
+          record,
+          left: undefined,
+          right: undefined,
+          parent: node,
+          deleted: false,
+          red: true
+        };
+        this._onNewNodeInserted(node.right);
+      }
+    } else if (node.deleted) {
+      node.deleted = false;
+      node.record = record;
+      this._numTombstones--;
+    } else if (noOverwrite) {
+      throw new ConstraintError;
+    } else {
+      const overwrittenRecord = node.record;
+      node.record = record;
+      return overwrittenRecord;
+    }
+  }
+  delete(record) {
+    if (!this._root) {
+      return;
+    }
+    this._delete(this._root, record);
+    if (this._numTombstones > this._numNodes * MAX_TOMBSTONE_FACTOR) {
+      const records = [...this.getAllRecords()];
+      this._root = this._rebuild(records, undefined, false);
+      this._numNodes = records.length;
+      this._numTombstones = 0;
+    }
+  }
+  _delete(node, record) {
+    if (!node) {
+      return;
+    }
+    const comparison = this._compare(record, node.record);
+    if (comparison < 0) {
+      this._delete(node.left, record);
+    } else if (comparison > 0) {
+      this._delete(node.right, record);
+    } else if (!node.deleted) {
+      this._numTombstones++;
+      node.deleted = true;
+    }
+  }
+  *getAllRecords(descending = false) {
+    yield* this.getRecords(EVERYTHING_KEY_RANGE, descending);
+  }
+  *getRecords(keyRange, descending = false) {
+    yield* this._getRecordsForNode(this._root, keyRange, descending);
+  }
+  *_getRecordsForNode(node, keyRange, descending = false) {
+    if (!node) {
+      return;
+    }
+    yield* this._findRecords(node, keyRange, descending);
+  }
+  *_findRecords(node, keyRange, descending = false) {
+    const {
+      lower,
+      upper,
+      lowerOpen,
+      upperOpen
+    } = keyRange;
+    const {
+      record: {
+        key
+      }
+    } = node;
+    const lowerComparison = lower === undefined ? -1 : cmp_default(lower, key);
+    const upperComparison = upper === undefined ? 1 : cmp_default(upper, key);
+    const moreLeft = this._keysAreUnique ? lowerComparison < 0 : lowerComparison <= 0;
+    const moreRight = this._keysAreUnique ? upperComparison > 0 : upperComparison >= 0;
+    const moreStart = descending ? moreRight : moreLeft;
+    const moreEnd = descending ? moreLeft : moreRight;
+    const start = descending ? "right" : "left";
+    const end = descending ? "left" : "right";
+    const lowerMatches = lowerOpen ? lowerComparison < 0 : lowerComparison <= 0;
+    const upperMatches = upperOpen ? upperComparison > 0 : upperComparison >= 0;
+    if (moreStart && node[start]) {
+      yield* this._findRecords(node[start], keyRange, descending);
+    }
+    if (lowerMatches && upperMatches && !node.deleted) {
+      yield node.record;
+    }
+    if (moreEnd && node[end]) {
+      yield* this._findRecords(node[end], keyRange, descending);
+    }
+  }
+  _onNewNodeInserted(newNode) {
+    this._numNodes++;
+    this._rebalanceTree(newNode);
+  }
+  _rebalanceTree(node) {
+    let parent = node.parent;
+    do {
+      if (!parent.red) {
+        return;
+      }
+      const grandparent = parent.parent;
+      if (!grandparent) {
+        parent.red = false;
+        return;
+      }
+      const parentIsRightChild = parent === grandparent.right;
+      const uncle = parentIsRightChild ? grandparent.left : grandparent.right;
+      if (!uncle || !uncle.red) {
+        if (node === (parentIsRightChild ? parent.left : parent.right)) {
+          this._rotateSubtree(parent, parentIsRightChild);
+          node = parent;
+          parent = parentIsRightChild ? grandparent.right : grandparent.left;
+        }
+        this._rotateSubtree(grandparent, !parentIsRightChild);
+        parent.red = false;
+        grandparent.red = true;
+        return;
+      }
+      parent.red = false;
+      uncle.red = false;
+      grandparent.red = true;
+      node = grandparent;
+    } while (node.parent ? parent = node.parent : false);
+  }
+  _rotateSubtree(node, right) {
+    const parent = node.parent;
+    const newRoot = right ? node.left : node.right;
+    const newChild = right ? newRoot.right : newRoot.left;
+    node[right ? "left" : "right"] = newChild;
+    if (newChild) {
+      newChild.parent = node;
+    }
+    newRoot[right ? "right" : "left"] = node;
+    newRoot.parent = parent;
+    node.parent = newRoot;
+    if (parent) {
+      parent[node === parent.right ? "right" : "left"] = newRoot;
+    } else {
+      this._root = newRoot;
+    }
+    return newRoot;
+  }
+  _rebuild(records, parent, red) {
+    const {
+      length
+    } = records;
+    if (!length) {
+      return;
+    }
+    const mid = length >>> 1;
+    const node = {
+      record: records[mid],
+      left: undefined,
+      right: undefined,
+      parent,
+      deleted: false,
+      red
+    };
+    const left = this._rebuild(records.slice(0, mid), node, !red);
+    const right = this._rebuild(records.slice(mid + 1), node, !red);
+    node.left = left;
+    node.right = right;
+    return node;
+  }
+}
+var MAX_TOMBSTONE_FACTOR, EVERYTHING_KEY_RANGE;
+var init_binarySearchTree = __esm(() => {
+  init_FDBKeyRange();
+  init_cmp();
+  init_errors();
+  MAX_TOMBSTONE_FACTOR = 2 / 3;
+  EVERYTHING_KEY_RANGE = new FDBKeyRange_default(undefined, undefined, false, false);
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/RecordStore.js
+class RecordStore {
+  constructor(keysAreUnique) {
+    this.keysAreUnique = keysAreUnique;
+    this.records = new BinarySearchTree(this.keysAreUnique);
+  }
+  get(key) {
+    const range = key instanceof FDBKeyRange_default ? key : FDBKeyRange_default.only(key);
+    return this.records.getRecords(range).next().value;
+  }
+  put(newRecord, noOverwrite = false) {
+    return this.records.put(newRecord, noOverwrite);
+  }
+  delete(key) {
+    const range = key instanceof FDBKeyRange_default ? key : FDBKeyRange_default.only(key);
+    const deletedRecords = [...this.records.getRecords(range)];
+    for (const record of deletedRecords) {
+      this.records.delete(record);
+    }
+    return deletedRecords;
+  }
+  deleteByValue(key) {
+    const range = key instanceof FDBKeyRange_default ? key : FDBKeyRange_default.only(key);
+    const deletedRecords = [];
+    for (const record of this.records.getAllRecords()) {
+      if (range.includes(record.value)) {
+        this.records.delete(record);
+        deletedRecords.push(record);
+      }
+    }
+    return deletedRecords;
+  }
+  clear() {
+    const deletedRecords = [...this.records.getAllRecords()];
+    this.records = new BinarySearchTree(this.keysAreUnique);
+    return deletedRecords;
+  }
+  values(range, direction = "next") {
+    const descending = direction === "prev" || direction === "prevunique";
+    const records = range ? this.records.getRecords(range, descending) : this.records.getAllRecords(descending);
+    return {
+      [Symbol.iterator]: () => {
+        const next = () => {
+          return records.next();
+        };
+        if (direction === "next" || direction === "prev") {
+          return {
+            next
+          };
+        }
+        if (direction === "nextunique") {
+          let previousValue = undefined;
+          return {
+            next: () => {
+              let current2 = next();
+              while (!current2.done && previousValue !== undefined && cmp_default(previousValue.key, current2.value.key) === 0) {
+                current2 = next();
+              }
+              previousValue = current2.value;
+              return current2;
+            }
+          };
+        }
+        let current = next();
+        let nextResult = next();
+        return {
+          next: () => {
+            while (!nextResult.done && cmp_default(current.value.key, nextResult.value.key) === 0) {
+              current = nextResult;
+              nextResult = next();
+            }
+            const result = current;
+            current = nextResult;
+            nextResult = next();
+            return result;
+          }
+        };
+      }
+    };
+  }
+  size() {
+    return this.records.size();
+  }
+}
+var RecordStore_default;
+var init_RecordStore = __esm(() => {
+  init_FDBKeyRange();
+  init_cmp();
+  init_binarySearchTree();
+  RecordStore_default = RecordStore;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/Index.js
+class Index {
+  deleted = false;
+  initialized = false;
+  constructor(rawObjectStore, name, keyPath, multiEntry, unique) {
+    this.rawObjectStore = rawObjectStore;
+    this.name = name;
+    this.keyPath = keyPath;
+    this.multiEntry = multiEntry;
+    this.unique = unique;
+    this.records = new RecordStore_default(unique);
+  }
+  getKey(key) {
+    const record = this.records.get(key);
+    return record !== undefined ? record.value : undefined;
+  }
+  getAllKeys(range, count, direction) {
+    if (count === undefined || count === 0) {
+      count = Infinity;
+    }
+    const records = [];
+    for (const record of this.records.values(range, direction)) {
+      records.push(structuredClone(record.value));
+      if (records.length >= count) {
+        break;
+      }
+    }
+    return records;
+  }
+  getValue(key) {
+    const record = this.records.get(key);
+    return record !== undefined ? this.rawObjectStore.getValue(record.value) : undefined;
+  }
+  getAllValues(range, count, direction) {
+    if (count === undefined || count === 0) {
+      count = Infinity;
+    }
+    const records = [];
+    for (const record of this.records.values(range, direction)) {
+      records.push(this.rawObjectStore.getValue(record.value));
+      if (records.length >= count) {
+        break;
+      }
+    }
+    return records;
+  }
+  getAllRecords(range, count, direction) {
+    if (count === undefined || count === 0) {
+      count = Infinity;
+    }
+    const records = [];
+    for (const record of this.records.values(range, direction)) {
+      records.push(new FDBRecord_default(structuredClone(record.key), structuredClone(this.rawObjectStore.getKey(record.value)), this.rawObjectStore.getValue(record.value)));
+      if (records.length >= count) {
+        break;
+      }
+    }
+    return records;
+  }
+  storeRecord(newRecord) {
+    let indexKey;
+    try {
+      indexKey = extractKey_default(this.keyPath, newRecord.value).key;
+    } catch (err) {
+      if (err.name === "DataError") {
+        return;
+      }
+      throw err;
+    }
+    if (!this.multiEntry || !Array.isArray(indexKey)) {
+      try {
+        valueToKey_default(indexKey);
+      } catch (e) {
+        return;
+      }
+    } else {
+      const keep = [];
+      for (const part of indexKey) {
+        if (keep.indexOf(part) < 0) {
+          try {
+            keep.push(valueToKey_default(part));
+          } catch (err) {}
+        }
+      }
+      indexKey = keep;
+    }
+    if (!this.multiEntry || !Array.isArray(indexKey)) {
+      if (this.unique) {
+        const existingRecord = this.records.get(indexKey);
+        if (existingRecord) {
+          throw new ConstraintError;
+        }
+      }
+    } else {
+      if (this.unique) {
+        for (const individualIndexKey of indexKey) {
+          const existingRecord = this.records.get(individualIndexKey);
+          if (existingRecord) {
+            throw new ConstraintError;
+          }
+        }
+      }
+    }
+    if (!this.multiEntry || !Array.isArray(indexKey)) {
+      this.records.put({
+        key: indexKey,
+        value: newRecord.key
+      });
+    } else {
+      for (const individualIndexKey of indexKey) {
+        this.records.put({
+          key: individualIndexKey,
+          value: newRecord.key
+        });
+      }
+    }
+  }
+  initialize(transaction) {
+    if (this.initialized) {
+      throw new Error("Index already initialized");
+    }
+    transaction._execRequestAsync({
+      operation: () => {
+        try {
+          for (const record of this.rawObjectStore.records.values()) {
+            this.storeRecord(record);
+          }
+          this.initialized = true;
+        } catch (err) {
+          transaction._abort(err.name);
+        }
+      },
+      source: null
+    });
+  }
+  count(range) {
+    let count = 0;
+    for (const record of this.records.values(range)) {
+      count += 1;
+    }
+    return count;
+  }
+}
+var Index_default;
+var init_Index = __esm(() => {
+  init_FDBRecord();
+  init_errors();
+  init_extractKey();
+  init_RecordStore();
+  init_valueToKey();
+  Index_default = Index;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/validateKeyPath.js
+var validateKeyPath = (keyPath, parent) => {
+  if (keyPath !== undefined && keyPath !== null && typeof keyPath !== "string" && keyPath.toString && (parent === "array" || !Array.isArray(keyPath))) {
+    keyPath = keyPath.toString();
+  }
+  if (typeof keyPath === "string") {
+    if (keyPath === "" && parent !== "string") {
+      return;
+    }
+    try {
+      const validIdentifierRegex = /^(?:[$A-Z_a-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B2\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC])(?:[$0-9A-Z_a-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B2\u08E4-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58\u0C59\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D60-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA69D\uA69F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2D\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC])*$/;
+      if (keyPath.length >= 1 && validIdentifierRegex.test(keyPath)) {
+        return;
+      }
+    } catch (err) {
+      throw new SyntaxError(err.message);
+    }
+    if (keyPath.indexOf(" ") >= 0) {
+      throw new SyntaxError("The keypath argument contains an invalid key path (no spaces allowed).");
+    }
+  }
+  if (Array.isArray(keyPath) && keyPath.length > 0) {
+    if (parent) {
+      throw new SyntaxError("The keypath argument contains an invalid key path (nested arrays).");
+    }
+    for (const part of keyPath) {
+      validateKeyPath(part, "array");
+    }
+    return;
+  } else if (typeof keyPath === "string" && keyPath.indexOf(".") >= 0) {
+    keyPath = keyPath.split(".");
+    for (const part of keyPath) {
+      validateKeyPath(part, "string");
+    }
+    return;
+  }
+  throw new SyntaxError;
+}, validateKeyPath_default;
+var init_validateKeyPath = __esm(() => {
+  init_errors();
+  validateKeyPath_default = validateKeyPath;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/FDBObjectStore.js
+var confirmActiveTransaction2 = (objectStore) => {
+  if (objectStore._rawObjectStore.deleted) {
+    throw new InvalidStateError;
+  }
+  if (objectStore.transaction._state !== "active") {
+    throw new TransactionInactiveError;
+  }
+}, buildRecordAddPut = (objectStore, value, key) => {
+  confirmActiveTransaction2(objectStore);
+  if (objectStore.transaction.mode === "readonly") {
+    throw new ReadOnlyError;
+  }
+  if (objectStore.keyPath !== null) {
+    if (key !== undefined) {
+      throw new DataError;
+    }
+  }
+  const clone = cloneValueForInsertion(value, objectStore.transaction);
+  if (objectStore.keyPath !== null) {
+    const tempKey = extractKey_default(objectStore.keyPath, clone);
+    if (tempKey.type === "found") {
+      valueToKey_default(tempKey.key);
+    } else {
+      if (!objectStore._rawObjectStore.keyGenerator) {
+        throw new DataError;
+      } else if (!canInjectKey_default(objectStore.keyPath, clone)) {
+        throw new DataError;
+      }
+    }
+  }
+  if (objectStore.keyPath === null && objectStore._rawObjectStore.keyGenerator === null && key === undefined) {
+    throw new DataError;
+  }
+  if (key !== undefined) {
+    key = valueToKey_default(key);
+  }
+  return {
+    key,
+    value: clone
+  };
+}, FDBObjectStore, FDBObjectStore_default;
+var init_FDBObjectStore = __esm(() => {
+  init_FDBCursor();
+  init_FDBCursorWithValue();
+  init_FDBIndex();
+  init_FDBKeyRange();
+  init_FDBRequest();
+  init_canInjectKey();
+  init_errors();
+  init_extractKey();
+  init_FakeDOMStringList();
+  init_Index();
+  init_validateKeyPath();
+  init_valueToKey();
+  init_valueToKeyRange();
+  init_extractGetAllOptions();
+  init_enforceRange();
+  FDBObjectStore = class FDBObjectStore {
+    _indexesCache = new Map;
+    constructor(transaction, rawObjectStore) {
+      this._rawObjectStore = rawObjectStore;
+      this._name = rawObjectStore.name;
+      this.keyPath = getKeyPath(rawObjectStore.keyPath);
+      this.autoIncrement = rawObjectStore.autoIncrement;
+      this.transaction = transaction;
+      this.indexNames = new FakeDOMStringList_default(...Array.from(rawObjectStore.rawIndexes.keys()).sort());
+    }
+    get name() {
+      return this._name;
+    }
+    set name(name) {
+      const transaction = this.transaction;
+      if (!transaction.db._runningVersionchangeTransaction) {
+        throw transaction._state === "active" ? new InvalidStateError : new TransactionInactiveError;
+      }
+      confirmActiveTransaction2(this);
+      name = String(name);
+      if (name === this._name) {
+        return;
+      }
+      if (this._rawObjectStore.rawDatabase.rawObjectStores.has(name)) {
+        throw new ConstraintError;
+      }
+      const oldName = this._name;
+      const oldObjectStoreNames = [...transaction.db.objectStoreNames];
+      this._name = name;
+      this._rawObjectStore.name = name;
+      this.transaction._objectStoresCache.delete(oldName);
+      this.transaction._objectStoresCache.set(name, this);
+      this._rawObjectStore.rawDatabase.rawObjectStores.delete(oldName);
+      this._rawObjectStore.rawDatabase.rawObjectStores.set(name, this._rawObjectStore);
+      transaction.db.objectStoreNames = new FakeDOMStringList_default(...Array.from(this._rawObjectStore.rawDatabase.rawObjectStores.keys()).filter((objectStoreName) => {
+        const objectStore = this._rawObjectStore.rawDatabase.rawObjectStores.get(objectStoreName);
+        return objectStore && !objectStore.deleted;
+      }).sort());
+      const oldScope = new Set(transaction._scope);
+      const oldTransactionObjectStoreNames = [...transaction.objectStoreNames];
+      this.transaction._scope.delete(oldName);
+      transaction._scope.add(name);
+      transaction.objectStoreNames = new FakeDOMStringList_default(...Array.from(transaction._scope).sort());
+      if (!this.transaction._createdObjectStores.has(this._rawObjectStore)) {
+        transaction._rollbackLog.push(() => {
+          this._name = oldName;
+          this._rawObjectStore.name = oldName;
+          this.transaction._objectStoresCache.delete(name);
+          this.transaction._objectStoresCache.set(oldName, this);
+          this._rawObjectStore.rawDatabase.rawObjectStores.delete(name);
+          this._rawObjectStore.rawDatabase.rawObjectStores.set(oldName, this._rawObjectStore);
+          transaction.db.objectStoreNames = new FakeDOMStringList_default(...oldObjectStoreNames);
+          transaction._scope = oldScope;
+          transaction.objectStoreNames = new FakeDOMStringList_default(...oldTransactionObjectStoreNames);
+        });
+      }
+    }
+    put(value, key) {
+      if (arguments.length === 0) {
+        throw new TypeError;
+      }
+      const record = buildRecordAddPut(this, value, key);
+      return this.transaction._execRequestAsync({
+        operation: this._rawObjectStore.storeRecord.bind(this._rawObjectStore, record, false, this.transaction._rollbackLog),
+        source: this
+      });
+    }
+    add(value, key) {
+      if (arguments.length === 0) {
+        throw new TypeError;
+      }
+      const record = buildRecordAddPut(this, value, key);
+      return this.transaction._execRequestAsync({
+        operation: this._rawObjectStore.storeRecord.bind(this._rawObjectStore, record, true, this.transaction._rollbackLog),
+        source: this
+      });
+    }
+    delete(key) {
+      if (arguments.length === 0) {
+        throw new TypeError;
+      }
+      confirmActiveTransaction2(this);
+      if (this.transaction.mode === "readonly") {
+        throw new ReadOnlyError;
+      }
+      if (!(key instanceof FDBKeyRange_default)) {
+        key = valueToKey_default(key);
+      }
+      return this.transaction._execRequestAsync({
+        operation: this._rawObjectStore.deleteRecord.bind(this._rawObjectStore, key, this.transaction._rollbackLog),
+        source: this
+      });
+    }
+    get(key) {
+      if (arguments.length === 0) {
+        throw new TypeError;
+      }
+      confirmActiveTransaction2(this);
+      if (!(key instanceof FDBKeyRange_default)) {
+        key = valueToKey_default(key);
+      }
+      return this.transaction._execRequestAsync({
+        operation: this._rawObjectStore.getValue.bind(this._rawObjectStore, key),
+        source: this
+      });
+    }
+    getAll(queryOrOptions, count) {
+      const options = extractGetAllOptions_default(queryOrOptions, count, arguments.length);
+      confirmActiveTransaction2(this);
+      const range = valueToKeyRange_default(options.query);
+      return this.transaction._execRequestAsync({
+        operation: this._rawObjectStore.getAllValues.bind(this._rawObjectStore, range, options.count, options.direction),
+        source: this
+      });
+    }
+    getKey(key) {
+      if (arguments.length === 0) {
+        throw new TypeError;
+      }
+      confirmActiveTransaction2(this);
+      if (!(key instanceof FDBKeyRange_default)) {
+        key = valueToKey_default(key);
+      }
+      return this.transaction._execRequestAsync({
+        operation: this._rawObjectStore.getKey.bind(this._rawObjectStore, key),
+        source: this
+      });
+    }
+    getAllKeys(queryOrOptions, count) {
+      const options = extractGetAllOptions_default(queryOrOptions, count, arguments.length);
+      confirmActiveTransaction2(this);
+      const range = valueToKeyRange_default(options.query);
+      return this.transaction._execRequestAsync({
+        operation: this._rawObjectStore.getAllKeys.bind(this._rawObjectStore, range, options.count, options.direction),
+        source: this
+      });
+    }
+    getAllRecords(options) {
+      let query;
+      let count;
+      let direction;
+      if (options !== undefined) {
+        if (options.query !== undefined) {
+          query = options.query;
+        }
+        if (options.count !== undefined) {
+          count = enforceRange_default(options.count, "unsigned long");
+        }
+        if (options.direction !== undefined) {
+          direction = options.direction;
+        }
+      }
+      confirmActiveTransaction2(this);
+      const range = valueToKeyRange_default(query);
+      return this.transaction._execRequestAsync({
+        operation: this._rawObjectStore.getAllRecords.bind(this._rawObjectStore, range, count, direction),
+        source: this
+      });
+    }
+    clear() {
+      confirmActiveTransaction2(this);
+      if (this.transaction.mode === "readonly") {
+        throw new ReadOnlyError;
+      }
+      return this.transaction._execRequestAsync({
+        operation: this._rawObjectStore.clear.bind(this._rawObjectStore, this.transaction._rollbackLog),
+        source: this
+      });
+    }
+    openCursor(range, direction) {
+      confirmActiveTransaction2(this);
+      if (range === null) {
+        range = undefined;
+      }
+      if (range !== undefined && !(range instanceof FDBKeyRange_default)) {
+        range = FDBKeyRange_default.only(valueToKey_default(range));
+      }
+      const request = new FDBRequest_default;
+      request.source = this;
+      request.transaction = this.transaction;
+      const cursor = new FDBCursorWithValue_default(this, range, direction, request);
+      return this.transaction._execRequestAsync({
+        operation: cursor._iterate.bind(cursor),
+        request,
+        source: this
+      });
+    }
+    openKeyCursor(range, direction) {
+      confirmActiveTransaction2(this);
+      if (range === null) {
+        range = undefined;
+      }
+      if (range !== undefined && !(range instanceof FDBKeyRange_default)) {
+        range = FDBKeyRange_default.only(valueToKey_default(range));
+      }
+      const request = new FDBRequest_default;
+      request.source = this;
+      request.transaction = this.transaction;
+      const cursor = new FDBCursor_default(this, range, direction, request, true);
+      return this.transaction._execRequestAsync({
+        operation: cursor._iterate.bind(cursor),
+        request,
+        source: this
+      });
+    }
+    createIndex(name, keyPath, optionalParameters = {}) {
+      if (arguments.length < 2) {
+        throw new TypeError;
+      }
+      const multiEntry = optionalParameters.multiEntry !== undefined ? optionalParameters.multiEntry : false;
+      const unique = optionalParameters.unique !== undefined ? optionalParameters.unique : false;
+      if (this.transaction.mode !== "versionchange") {
+        throw new InvalidStateError;
+      }
+      confirmActiveTransaction2(this);
+      if (this.indexNames.contains(name)) {
+        throw new ConstraintError;
+      }
+      validateKeyPath_default(keyPath);
+      if (Array.isArray(keyPath) && multiEntry) {
+        throw new InvalidAccessError;
+      }
+      const indexNames = [...this.indexNames];
+      const index = new Index_default(this._rawObjectStore, name, keyPath, multiEntry, unique);
+      this.indexNames._push(name);
+      this.indexNames._sort();
+      this.transaction._createdIndexes.add(index);
+      this._rawObjectStore.rawIndexes.set(name, index);
+      index.initialize(this.transaction);
+      this.transaction._rollbackLog.push(() => {
+        index.deleted = true;
+        this.indexNames = new FakeDOMStringList_default(...indexNames);
+        this._rawObjectStore.rawIndexes.delete(index.name);
+      });
+      return new FDBIndex_default(this, index);
+    }
+    index(name) {
+      if (arguments.length === 0) {
+        throw new TypeError;
+      }
+      if (this._rawObjectStore.deleted || this.transaction._state === "finished") {
+        throw new InvalidStateError;
+      }
+      const index = this._indexesCache.get(name);
+      if (index !== undefined) {
+        return index;
+      }
+      const rawIndex = this._rawObjectStore.rawIndexes.get(name);
+      if (!this.indexNames.contains(name) || rawIndex === undefined) {
+        throw new NotFoundError;
+      }
+      const index2 = new FDBIndex_default(this, rawIndex);
+      this._indexesCache.set(name, index2);
+      return index2;
+    }
+    deleteIndex(name) {
+      if (arguments.length === 0) {
+        throw new TypeError;
+      }
+      if (this.transaction.mode !== "versionchange") {
+        throw new InvalidStateError;
+      }
+      confirmActiveTransaction2(this);
+      const rawIndex = this._rawObjectStore.rawIndexes.get(name);
+      if (rawIndex === undefined) {
+        throw new NotFoundError;
+      }
+      this.transaction._rollbackLog.push(() => {
+        rawIndex.deleted = false;
+        this._rawObjectStore.rawIndexes.set(rawIndex.name, rawIndex);
+        this.indexNames._push(rawIndex.name);
+        this.indexNames._sort();
+      });
+      this.indexNames = new FakeDOMStringList_default(...Array.from(this.indexNames).filter((indexName) => {
+        return indexName !== name;
+      }));
+      rawIndex.deleted = true;
+      this.transaction._execRequestAsync({
+        operation: () => {
+          const rawIndex2 = this._rawObjectStore.rawIndexes.get(name);
+          if (rawIndex === rawIndex2) {
+            this._rawObjectStore.rawIndexes.delete(name);
+          }
+        },
+        source: this
+      });
+    }
+    count(key) {
+      confirmActiveTransaction2(this);
+      if (key === null) {
+        key = undefined;
+      }
+      if (key !== undefined && !(key instanceof FDBKeyRange_default)) {
+        key = FDBKeyRange_default.only(valueToKey_default(key));
+      }
+      return this.transaction._execRequestAsync({
+        operation: () => {
+          return this._rawObjectStore.count(key);
+        },
+        source: this
+      });
+    }
+    get [Symbol.toStringTag]() {
+      return "IDBObjectStore";
+    }
+  };
+  FDBObjectStore_default = FDBObjectStore;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/FakeEvent.js
+class Event {
+  eventPath = [];
+  NONE = 0;
+  CAPTURING_PHASE = 1;
+  AT_TARGET = 2;
+  BUBBLING_PHASE = 3;
+  propagationStopped = false;
+  immediatePropagationStopped = false;
+  canceled = false;
+  initialized = true;
+  dispatched = false;
+  target = null;
+  currentTarget = null;
+  eventPhase = 0;
+  defaultPrevented = false;
+  isTrusted = false;
+  timeStamp = Date.now();
+  constructor(type, eventInitDict = {}) {
+    this.type = type;
+    this.bubbles = eventInitDict.bubbles !== undefined ? eventInitDict.bubbles : false;
+    this.cancelable = eventInitDict.cancelable !== undefined ? eventInitDict.cancelable : false;
+  }
+  preventDefault() {
+    if (this.cancelable) {
+      this.canceled = true;
+    }
+  }
+  stopPropagation() {
+    this.propagationStopped = true;
+  }
+  stopImmediatePropagation() {
+    this.propagationStopped = true;
+    this.immediatePropagationStopped = true;
+  }
+}
+var FakeEvent_default;
+var init_FakeEvent = __esm(() => {
+  FakeEvent_default = Event;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/scheduling.js
+function getSetImmediateFromJsdom() {
+  if (typeof navigator !== "undefined" && /jsdom/.test(navigator.userAgent)) {
+    const outerRealmFunctionConstructor = Node.constructor;
+    return new outerRealmFunctionConstructor("return setImmediate")();
+  } else {
+    return;
+  }
+}
+var schedulerPostTask, doSetTimeout = (fn) => setTimeout(fn, 0), queueTask = (fn) => {
+  const setImmediate = globalThis.setImmediate || getSetImmediateFromJsdom() || schedulerPostTask || doSetTimeout;
+  setImmediate(fn);
+};
+var init_scheduling = __esm(() => {
+  schedulerPostTask = typeof scheduler !== "undefined" && ((fn) => scheduler.postTask(fn));
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/FDBTransaction.js
+var prioritizedListenerTypes, FDBTransaction, FDBTransaction_default;
+var init_FDBTransaction = __esm(() => {
+  init_FDBObjectStore();
+  init_FDBRequest();
+  init_errors();
+  init_FakeDOMStringList();
+  init_FakeEvent();
+  init_FakeEventTarget();
+  init_scheduling();
+  prioritizedListenerTypes = ["error", "abort", "complete"];
+  FDBTransaction = class FDBTransaction extends FakeEventTarget_default {
+    _state = "active";
+    _started = false;
+    _rollbackLog = [];
+    _objectStoresCache = new Map;
+    _openRequest = null;
+    error = null;
+    onabort = null;
+    oncomplete = null;
+    onerror = null;
+    _prioritizedListeners = new Map;
+    _requests = [];
+    _createdIndexes = new Set;
+    _createdObjectStores = new Set;
+    constructor(storeNames, mode, durability, db) {
+      super();
+      this._scope = new Set(storeNames);
+      this.mode = mode;
+      this.durability = durability;
+      this.db = db;
+      this.objectStoreNames = new FakeDOMStringList_default(...Array.from(this._scope).sort());
+      for (const type of prioritizedListenerTypes) {
+        this.addEventListener(type, () => {
+          this._prioritizedListeners.get(type)?.();
+        });
+      }
+    }
+    _abort(errName) {
+      for (const f of this._rollbackLog.reverse()) {
+        f();
+      }
+      if (errName !== null) {
+        const e = new DOMException(undefined, errName);
+        this.error = e;
+      }
+      for (const {
+        request
+      } of this._requests) {
+        if (request.readyState !== "done") {
+          request.readyState = "done";
+          if (request.source) {
+            queueTask(() => {
+              request.result = undefined;
+              request.error = new AbortError;
+              const event = new FakeEvent_default("error", {
+                bubbles: true,
+                cancelable: true
+              });
+              event.eventPath = [this.db, this];
+              try {
+                request.dispatchEvent(event);
+              } catch (_err) {
+                if (this._state === "active") {
+                  this._abort("AbortError");
+                }
+              }
+            });
+          }
+        }
+      }
+      queueTask(() => {
+        const isUpgradeTransaction = this.mode === "versionchange";
+        if (isUpgradeTransaction) {
+          this.db._rawDatabase.connections = this.db._rawDatabase.connections.filter((connection) => !connection._rawDatabase.transactions.includes(this));
+        }
+        const event = new FakeEvent_default("abort", {
+          bubbles: true,
+          cancelable: false
+        });
+        event.eventPath = [this.db];
+        this.dispatchEvent(event);
+        if (isUpgradeTransaction) {
+          const request = this._openRequest;
+          request.transaction = null;
+          request.result = undefined;
+        }
+      });
+      this._state = "finished";
+    }
+    abort() {
+      if (this._state === "committing" || this._state === "finished") {
+        throw new InvalidStateError;
+      }
+      this._state = "active";
+      this._abort(null);
+    }
+    objectStore(name) {
+      if (this._state !== "active") {
+        throw new InvalidStateError;
+      }
+      const objectStore = this._objectStoresCache.get(name);
+      if (objectStore !== undefined) {
+        return objectStore;
+      }
+      const rawObjectStore = this.db._rawDatabase.rawObjectStores.get(name);
+      if (!this._scope.has(name) || rawObjectStore === undefined) {
+        throw new NotFoundError;
+      }
+      const objectStore2 = new FDBObjectStore_default(this, rawObjectStore);
+      this._objectStoresCache.set(name, objectStore2);
+      return objectStore2;
+    }
+    _execRequestAsync(obj) {
+      const source = obj.source;
+      const operation = obj.operation;
+      let request = Object.hasOwn(obj, "request") ? obj.request : null;
+      if (this._state !== "active") {
+        throw new TransactionInactiveError;
+      }
+      if (!request) {
+        if (!source) {
+          request = new FDBRequest_default;
+        } else {
+          request = new FDBRequest_default;
+          request.source = source;
+          request.transaction = source.transaction;
+        }
+      }
+      this._requests.push({
+        operation,
+        request
+      });
+      return request;
+    }
+    _start() {
+      this._started = true;
+      let operation;
+      let request;
+      while (this._requests.length > 0) {
+        const r = this._requests.shift();
+        if (r && r.request.readyState !== "done") {
+          request = r.request;
+          operation = r.operation;
+          break;
+        }
+      }
+      if (request && operation) {
+        if (!request.source) {
+          operation();
+        } else {
+          let defaultAction;
+          let event;
+          try {
+            const result = operation();
+            request.readyState = "done";
+            request.result = result;
+            request.error = undefined;
+            if (this._state === "inactive") {
+              this._state = "active";
+            }
+            event = new FakeEvent_default("success", {
+              bubbles: false,
+              cancelable: false
+            });
+          } catch (err) {
+            request.readyState = "done";
+            request.result = undefined;
+            request.error = err;
+            if (this._state === "inactive") {
+              this._state = "active";
+            }
+            event = new FakeEvent_default("error", {
+              bubbles: true,
+              cancelable: true
+            });
+            defaultAction = this._abort.bind(this, err.name);
+          }
+          try {
+            event.eventPath = [this.db, this];
+            request.dispatchEvent(event);
+          } catch (_err) {
+            if (this._state === "active") {
+              this._abort("AbortError");
+              defaultAction = undefined;
+            }
+          }
+          if (!event.canceled) {
+            if (defaultAction) {
+              defaultAction();
+            }
+          }
+        }
+        queueTask(this._start.bind(this));
+        return;
+      }
+      if (this._state !== "finished") {
+        this._state = "finished";
+        if (!this.error) {
+          const event = new FakeEvent_default("complete");
+          this.dispatchEvent(event);
+        }
+      }
+    }
+    commit() {
+      if (this._state !== "active") {
+        throw new InvalidStateError;
+      }
+      this._state = "committing";
+    }
+    get [Symbol.toStringTag]() {
+      return "IDBTransaction";
+    }
+  };
+  FDBTransaction_default = FDBTransaction;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/KeyGenerator.js
+class KeyGenerator {
+  num = 0;
+  next() {
+    if (this.num >= MAX_KEY) {
+      throw new ConstraintError;
+    }
+    this.num += 1;
+    return this.num;
+  }
+  setIfLarger(num) {
+    const value = Math.floor(Math.min(num, MAX_KEY)) - 1;
+    if (value >= this.num) {
+      this.num = value + 1;
+    }
+  }
+}
+var MAX_KEY = 9007199254740992, KeyGenerator_default;
+var init_KeyGenerator = __esm(() => {
+  init_errors();
+  KeyGenerator_default = KeyGenerator;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/ObjectStore.js
+class ObjectStore {
+  deleted = false;
+  records = new RecordStore_default(true);
+  rawIndexes = new Map;
+  constructor(rawDatabase, name, keyPath, autoIncrement) {
+    this.rawDatabase = rawDatabase;
+    this.keyGenerator = autoIncrement === true ? new KeyGenerator_default : null;
+    this.deleted = false;
+    this.name = name;
+    this.keyPath = keyPath;
+    this.autoIncrement = autoIncrement;
+  }
+  getKey(key) {
+    const record = this.records.get(key);
+    return record !== undefined ? structuredClone(record.key) : undefined;
+  }
+  getAllKeys(range, count, direction) {
+    if (count === undefined || count === 0) {
+      count = Infinity;
+    }
+    const records = [];
+    for (const record of this.records.values(range, direction)) {
+      records.push(structuredClone(record.key));
+      if (records.length >= count) {
+        break;
+      }
+    }
+    return records;
+  }
+  getValue(key) {
+    const record = this.records.get(key);
+    return record !== undefined ? structuredClone(record.value) : undefined;
+  }
+  getAllValues(range, count, direction) {
+    if (count === undefined || count === 0) {
+      count = Infinity;
+    }
+    const records = [];
+    for (const record of this.records.values(range, direction)) {
+      records.push(structuredClone(record.value));
+      if (records.length >= count) {
+        break;
+      }
+    }
+    return records;
+  }
+  getAllRecords(range, count, direction) {
+    if (count === undefined || count === 0) {
+      count = Infinity;
+    }
+    const records = [];
+    for (const record of this.records.values(range, direction)) {
+      records.push(new FDBRecord_default(structuredClone(record.key), structuredClone(record.key), structuredClone(record.value)));
+      if (records.length >= count) {
+        break;
+      }
+    }
+    return records;
+  }
+  storeRecord(newRecord, noOverwrite, rollbackLog) {
+    if (this.keyPath !== null) {
+      const key = extractKey_default(this.keyPath, newRecord.value).key;
+      if (key !== undefined) {
+        newRecord.key = key;
+      }
+    }
+    const rollbackLogForThisOperation = [];
+    if (this.keyGenerator !== null && newRecord.key === undefined) {
+      let rolledBack2 = false;
+      const keyGeneratorBefore = this.keyGenerator.num;
+      const rollbackKeyGenerator = () => {
+        if (rolledBack2) {
+          return;
+        }
+        rolledBack2 = true;
+        if (this.keyGenerator) {
+          this.keyGenerator.num = keyGeneratorBefore;
+        }
+      };
+      rollbackLogForThisOperation.push(rollbackKeyGenerator);
+      if (rollbackLog) {
+        rollbackLog.push(rollbackKeyGenerator);
+      }
+      newRecord.key = this.keyGenerator.next();
+      if (this.keyPath !== null) {
+        if (Array.isArray(this.keyPath)) {
+          throw new Error("Cannot have an array key path in an object store with a key generator");
+        }
+        let remainingKeyPath = this.keyPath;
+        let object = newRecord.value;
+        let identifier;
+        let i = 0;
+        while (i >= 0) {
+          if (typeof object !== "object") {
+            throw new DataError;
+          }
+          i = remainingKeyPath.indexOf(".");
+          if (i >= 0) {
+            identifier = remainingKeyPath.slice(0, i);
+            remainingKeyPath = remainingKeyPath.slice(i + 1);
+            if (!Object.hasOwn(object, identifier)) {
+              Object.defineProperty(object, identifier, {
+                configurable: true,
+                enumerable: true,
+                writable: true,
+                value: {}
+              });
+            }
+            object = object[identifier];
+          }
+        }
+        identifier = remainingKeyPath;
+        Object.defineProperty(object, identifier, {
+          configurable: true,
+          enumerable: true,
+          writable: true,
+          value: newRecord.key
+        });
+      }
+    } else if (this.keyGenerator !== null && typeof newRecord.key === "number") {
+      this.keyGenerator.setIfLarger(newRecord.key);
+    }
+    const existingRecord = this.records.put(newRecord, noOverwrite);
+    let rolledBack = false;
+    const rollbackStoreRecord = () => {
+      if (rolledBack) {
+        return;
+      }
+      rolledBack = true;
+      if (existingRecord) {
+        this.storeRecord(existingRecord, false);
+      } else {
+        this.deleteRecord(newRecord.key);
+      }
+    };
+    rollbackLogForThisOperation.push(rollbackStoreRecord);
+    if (rollbackLog) {
+      rollbackLog.push(rollbackStoreRecord);
+    }
+    if (existingRecord) {
+      for (const rawIndex of this.rawIndexes.values()) {
+        rawIndex.records.deleteByValue(newRecord.key);
+      }
+    }
+    try {
+      for (const rawIndex of this.rawIndexes.values()) {
+        if (rawIndex.initialized) {
+          rawIndex.storeRecord(newRecord);
+        }
+      }
+    } catch (err) {
+      if (err.name === "ConstraintError") {
+        for (const rollback of rollbackLogForThisOperation) {
+          rollback();
+        }
+      }
+      throw err;
+    }
+    return newRecord.key;
+  }
+  deleteRecord(key, rollbackLog) {
+    const deletedRecords = this.records.delete(key);
+    if (rollbackLog) {
+      for (const record of deletedRecords) {
+        rollbackLog.push(() => {
+          this.storeRecord(record, true);
+        });
+      }
+    }
+    for (const rawIndex of this.rawIndexes.values()) {
+      rawIndex.records.deleteByValue(key);
+    }
+  }
+  clear(rollbackLog) {
+    const deletedRecords = this.records.clear();
+    if (rollbackLog) {
+      for (const record of deletedRecords) {
+        rollbackLog.push(() => {
+          this.storeRecord(record, true);
+        });
+      }
+    }
+    for (const rawIndex of this.rawIndexes.values()) {
+      rawIndex.records.clear();
+    }
+  }
+  count(range) {
+    if (range === undefined || range.lower === undefined && range.upper === undefined) {
+      return this.records.size();
+    }
+    let count = 0;
+    for (const record of this.records.values(range)) {
+      count += 1;
+    }
+    return count;
+  }
+}
+var ObjectStore_default;
+var init_ObjectStore = __esm(() => {
+  init_FDBRecord();
+  init_errors();
+  init_extractKey();
+  init_KeyGenerator();
+  init_RecordStore();
+  ObjectStore_default = ObjectStore;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/closeConnection.js
+var closeConnection = (connection, forced = false) => {
+  connection._closePending = true;
+  const transactionsComplete = connection._rawDatabase.transactions.every((transaction) => {
+    return transaction._state === "finished";
+  });
+  if (transactionsComplete) {
+    connection._closed = true;
+    connection._rawDatabase.connections = connection._rawDatabase.connections.filter((otherConnection) => {
+      return connection !== otherConnection;
+    });
+    if (forced) {
+      const event = new FakeEvent_default("close", {
+        bubbles: false,
+        cancelable: false
+      });
+      event.eventPath = [];
+      connection.dispatchEvent(event);
+    }
+  } else {
+    queueTask(() => {
+      closeConnection(connection, forced);
+    });
+  }
+}, closeConnection_default;
+var init_closeConnection = __esm(() => {
+  init_FakeEvent();
+  init_scheduling();
+  closeConnection_default = closeConnection;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/FDBDatabase.js
+var confirmActiveVersionchangeTransaction = (database) => {
+  let transaction;
+  if (database._runningVersionchangeTransaction) {
+    transaction = database._rawDatabase.transactions.findLast((tx) => {
+      return tx.mode === "versionchange";
+    });
+  }
+  if (!transaction) {
+    throw new InvalidStateError;
+  }
+  if (transaction._state !== "active") {
+    throw new TransactionInactiveError;
+  }
+  return transaction;
+}, FDBDatabase, FDBDatabase_default;
+var init_FDBDatabase = __esm(() => {
+  init_FDBTransaction();
+  init_errors();
+  init_FakeDOMStringList();
+  init_FakeEventTarget();
+  init_ObjectStore();
+  init_validateKeyPath();
+  init_closeConnection();
+  FDBDatabase = class FDBDatabase extends FakeEventTarget_default {
+    _closePending = false;
+    _closed = false;
+    _runningVersionchangeTransaction = false;
+    constructor(rawDatabase) {
+      super();
+      this._rawDatabase = rawDatabase;
+      this._rawDatabase.connections.push(this);
+      this.name = rawDatabase.name;
+      this.version = rawDatabase.version;
+      this.objectStoreNames = new FakeDOMStringList_default(...Array.from(rawDatabase.rawObjectStores.keys()).sort());
+    }
+    createObjectStore(name, options = {}) {
+      if (name === undefined) {
+        throw new TypeError;
+      }
+      const transaction = confirmActiveVersionchangeTransaction(this);
+      const keyPath = options !== null && options.keyPath !== undefined ? options.keyPath : null;
+      const autoIncrement = options !== null && options.autoIncrement !== undefined ? options.autoIncrement : false;
+      if (keyPath !== null) {
+        validateKeyPath_default(keyPath);
+      }
+      if (this._rawDatabase.rawObjectStores.has(name)) {
+        throw new ConstraintError;
+      }
+      if (autoIncrement && (keyPath === "" || Array.isArray(keyPath))) {
+        throw new InvalidAccessError;
+      }
+      const objectStoreNames = [...this.objectStoreNames];
+      const transactionObjectStoreNames = [...transaction.objectStoreNames];
+      const rawObjectStore = new ObjectStore_default(this._rawDatabase, name, keyPath, autoIncrement);
+      this.objectStoreNames._push(name);
+      this.objectStoreNames._sort();
+      transaction._scope.add(name);
+      transaction._createdObjectStores.add(rawObjectStore);
+      this._rawDatabase.rawObjectStores.set(name, rawObjectStore);
+      transaction.objectStoreNames = new FakeDOMStringList_default(...this.objectStoreNames);
+      transaction._rollbackLog.push(() => {
+        rawObjectStore.deleted = true;
+        this.objectStoreNames = new FakeDOMStringList_default(...objectStoreNames);
+        transaction.objectStoreNames = new FakeDOMStringList_default(...transactionObjectStoreNames);
+        transaction._scope.delete(rawObjectStore.name);
+        this._rawDatabase.rawObjectStores.delete(rawObjectStore.name);
+      });
+      return transaction.objectStore(name);
+    }
+    deleteObjectStore(name) {
+      if (name === undefined) {
+        throw new TypeError;
+      }
+      const transaction = confirmActiveVersionchangeTransaction(this);
+      const store = this._rawDatabase.rawObjectStores.get(name);
+      if (store === undefined) {
+        throw new NotFoundError;
+      }
+      this.objectStoreNames = new FakeDOMStringList_default(...Array.from(this.objectStoreNames).filter((objectStoreName) => {
+        return objectStoreName !== name;
+      }));
+      transaction.objectStoreNames = new FakeDOMStringList_default(...this.objectStoreNames);
+      const objectStore = transaction._objectStoresCache.get(name);
+      let prevIndexNames;
+      if (objectStore) {
+        prevIndexNames = [...objectStore.indexNames];
+        objectStore.indexNames = new FakeDOMStringList_default;
+      }
+      transaction._rollbackLog.push(() => {
+        store.deleted = false;
+        this._rawDatabase.rawObjectStores.set(store.name, store);
+        this.objectStoreNames._push(store.name);
+        transaction.objectStoreNames._push(store.name);
+        this.objectStoreNames._sort();
+        if (objectStore && prevIndexNames) {
+          objectStore.indexNames = new FakeDOMStringList_default(...prevIndexNames);
+        }
+      });
+      store.deleted = true;
+      this._rawDatabase.rawObjectStores.delete(name);
+      transaction._objectStoresCache.delete(name);
+    }
+    transaction(storeNames, mode, options) {
+      mode = mode !== undefined ? mode : "readonly";
+      if (mode !== "readonly" && mode !== "readwrite" && mode !== "versionchange") {
+        throw new TypeError("Invalid mode: " + mode);
+      }
+      const hasActiveVersionchange = this._rawDatabase.transactions.some((transaction) => {
+        return transaction._state === "active" && transaction.mode === "versionchange" && transaction.db === this;
+      });
+      if (hasActiveVersionchange) {
+        throw new InvalidStateError;
+      }
+      if (this._closePending) {
+        throw new InvalidStateError;
+      }
+      if (!Array.isArray(storeNames)) {
+        storeNames = [storeNames];
+      }
+      if (storeNames.length === 0 && mode !== "versionchange") {
+        throw new InvalidAccessError;
+      }
+      for (const storeName of storeNames) {
+        if (!this.objectStoreNames.contains(storeName)) {
+          throw new NotFoundError("No objectStore named " + storeName + " in this database");
+        }
+      }
+      const durability = options?.durability ?? "default";
+      if (durability !== "default" && durability !== "strict" && durability !== "relaxed") {
+        throw new TypeError(`'${durability}' (value of 'durability' member of IDBTransactionOptions) ` + `is not a valid value for enumeration IDBTransactionDurability`);
+      }
+      const tx = new FDBTransaction_default(storeNames, mode, durability, this);
+      this._rawDatabase.transactions.push(tx);
+      this._rawDatabase.processTransactions();
+      return tx;
+    }
+    close() {
+      closeConnection_default(this);
+    }
+    get [Symbol.toStringTag]() {
+      return "IDBDatabase";
+    }
+  };
+  FDBDatabase_default = FDBDatabase;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/FDBOpenDBRequest.js
+var FDBOpenDBRequest, FDBOpenDBRequest_default;
+var init_FDBOpenDBRequest = __esm(() => {
+  init_FDBRequest();
+  FDBOpenDBRequest = class FDBOpenDBRequest extends FDBRequest_default {
+    onupgradeneeded = null;
+    onblocked = null;
+    get [Symbol.toStringTag]() {
+      return "IDBOpenDBRequest";
+    }
+  };
+  FDBOpenDBRequest_default = FDBOpenDBRequest;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/FDBVersionChangeEvent.js
+var FDBVersionChangeEvent, FDBVersionChangeEvent_default;
+var init_FDBVersionChangeEvent = __esm(() => {
+  init_FakeEvent();
+  FDBVersionChangeEvent = class FDBVersionChangeEvent extends FakeEvent_default {
+    constructor(type, parameters = {}) {
+      super(type);
+      this.newVersion = parameters.newVersion !== undefined ? parameters.newVersion : null;
+      this.oldVersion = parameters.oldVersion !== undefined ? parameters.oldVersion : 0;
+    }
+    get [Symbol.toStringTag]() {
+      return "IDBVersionChangeEvent";
+    }
+  };
+  FDBVersionChangeEvent_default = FDBVersionChangeEvent;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/intersection.js
+function intersection(set1, set2) {
+  if ("intersection" in set1) {
+    return set1.intersection(set2);
+  }
+  return new Set([...set1].filter((item) => set2.has(item)));
+}
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/Database.js
+class Database {
+  transactions = [];
+  rawObjectStores = new Map;
+  connections = [];
+  constructor(name, version) {
+    this.name = name;
+    this.version = version;
+    this.processTransactions = this.processTransactions.bind(this);
+  }
+  processTransactions() {
+    queueTask(() => {
+      const running = this.transactions.filter((transaction) => transaction._started && transaction._state !== "finished");
+      const waiting = this.transactions.filter((transaction) => !transaction._started && transaction._state !== "finished");
+      const next = waiting.find((transaction, i) => {
+        const anyRunning = running.some((other) => !(transaction.mode === "readonly" && other.mode === "readonly") && intersection(other._scope, transaction._scope).size > 0);
+        if (anyRunning) {
+          return false;
+        }
+        const anyWaiting = waiting.slice(0, i).some((other) => intersection(other._scope, transaction._scope).size > 0);
+        return !anyWaiting;
+      });
+      if (next) {
+        next.addEventListener("complete", this.processTransactions);
+        next.addEventListener("abort", this.processTransactions);
+        next._start();
+      }
+    });
+  }
+}
+var Database_default;
+var init_Database = __esm(() => {
+  init_scheduling();
+  Database_default = Database;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/lib/validateRequiredArguments.js
+function validateRequiredArguments(numArguments, expectedNumArguments, methodName) {
+  if (numArguments < expectedNumArguments) {
+    throw new TypeError(`${methodName}: At least ${expectedNumArguments} ${expectedNumArguments === 1 ? "argument" : "arguments"} ` + `required, but only ${arguments.length} passed`);
+  }
+}
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/FDBFactory.js
+var runTaskInConnectionQueue = (connectionQueues, name, task) => {
+  const queue = connectionQueues.get(name) ?? Promise.resolve();
+  connectionQueues.set(name, queue.then(task));
+}, waitForOthersClosedDelete = (databases, name, openDatabases, cb) => {
+  const anyOpen = openDatabases.some((openDatabase2) => {
+    return !openDatabase2._closed && !openDatabase2._closePending;
+  });
+  if (anyOpen) {
+    queueTask(() => waitForOthersClosedDelete(databases, name, openDatabases, cb));
+    return;
+  }
+  databases.delete(name);
+  cb(null);
+}, deleteDatabase = (databases, connectionQueues, name, request, cb) => {
+  const deleteDBTask = () => {
+    return new Promise((resolve) => {
+      const db = databases.get(name);
+      const oldVersion = db !== undefined ? db.version : 0;
+      const onComplete = (err) => {
+        try {
+          if (err) {
+            cb(err);
+          } else {
+            cb(null, oldVersion);
+          }
+        } finally {
+          resolve();
+        }
+      };
+      try {
+        const db2 = databases.get(name);
+        if (db2 === undefined) {
+          onComplete(null);
+          return;
+        }
+        const openConnections = db2.connections.filter((connection) => {
+          return !connection._closed;
+        });
+        for (const openDatabase2 of openConnections) {
+          if (!openDatabase2._closePending) {
+            queueTask(() => {
+              const event = new FDBVersionChangeEvent_default("versionchange", {
+                newVersion: null,
+                oldVersion: db2.version
+              });
+              openDatabase2.dispatchEvent(event);
+            });
+          }
+        }
+        queueTask(() => {
+          const anyOpen = openConnections.some((openDatabase3) => {
+            return !openDatabase3._closed && !openDatabase3._closePending;
+          });
+          if (anyOpen) {
+            queueTask(() => {
+              const event = new FDBVersionChangeEvent_default("blocked", {
+                newVersion: null,
+                oldVersion: db2.version
+              });
+              request.dispatchEvent(event);
+            });
+          }
+          waitForOthersClosedDelete(databases, name, openConnections, onComplete);
+        });
+      } catch (err) {
+        onComplete(err);
+      }
+    });
+  };
+  runTaskInConnectionQueue(connectionQueues, name, deleteDBTask);
+}, runVersionchangeTransaction = (connection, version, request, cb) => {
+  connection._runningVersionchangeTransaction = true;
+  const oldVersion = connection._oldVersion = connection.version;
+  const openConnections = connection._rawDatabase.connections.filter((otherDatabase) => {
+    return connection !== otherDatabase;
+  });
+  for (const openDatabase2 of openConnections) {
+    if (!openDatabase2._closed && !openDatabase2._closePending) {
+      queueTask(() => {
+        const event = new FDBVersionChangeEvent_default("versionchange", {
+          newVersion: version,
+          oldVersion
+        });
+        openDatabase2.dispatchEvent(event);
+      });
+    }
+  }
+  queueTask(() => {
+    const anyOpen = openConnections.some((openDatabase3) => {
+      return !openDatabase3._closed && !openDatabase3._closePending;
+    });
+    if (anyOpen) {
+      queueTask(() => {
+        const event = new FDBVersionChangeEvent_default("blocked", {
+          newVersion: version,
+          oldVersion
+        });
+        request.dispatchEvent(event);
+      });
+    }
+    const waitForOthersClosed = () => {
+      const anyOpen2 = openConnections.some((openDatabase2) => {
+        return !openDatabase2._closed && !openDatabase2._closePending;
+      });
+      if (anyOpen2) {
+        queueTask(waitForOthersClosed);
+        return;
+      }
+      connection._rawDatabase.version = version;
+      connection.version = version;
+      const transaction = connection.transaction(Array.from(connection.objectStoreNames), "versionchange");
+      transaction._openRequest = request;
+      request.result = connection;
+      request.readyState = "done";
+      request.transaction = transaction;
+      transaction._rollbackLog.push(() => {
+        connection._rawDatabase.version = oldVersion;
+        connection.version = oldVersion;
+      });
+      transaction._state = "active";
+      const event = new FDBVersionChangeEvent_default("upgradeneeded", {
+        newVersion: version,
+        oldVersion
+      });
+      let didThrow = false;
+      try {
+        request.dispatchEvent(event);
+      } catch (_err) {
+        didThrow = true;
+      }
+      const concludeUpgrade = () => {
+        if (transaction._state === "active") {
+          transaction._state = "inactive";
+          if (didThrow) {
+            transaction._abort("AbortError");
+          }
+        }
+      };
+      if (didThrow) {
+        concludeUpgrade();
+      } else {
+        queueTask(concludeUpgrade);
+      }
+      transaction._prioritizedListeners.set("error", () => {
+        connection._runningVersionchangeTransaction = false;
+        connection._oldVersion = undefined;
+      });
+      transaction._prioritizedListeners.set("abort", () => {
+        connection._runningVersionchangeTransaction = false;
+        connection._oldVersion = undefined;
+        queueTask(() => {
+          request.transaction = null;
+          cb(new AbortError);
+        });
+      });
+      transaction._prioritizedListeners.set("complete", () => {
+        connection._runningVersionchangeTransaction = false;
+        connection._oldVersion = undefined;
+        queueTask(() => {
+          request.transaction = null;
+          if (connection._closePending) {
+            cb(new AbortError);
+          } else {
+            cb(null);
+          }
+        });
+      });
+    };
+    waitForOthersClosed();
+  });
+}, openDatabase = (databases, connectionQueues, name, version, request, cb) => {
+  const openDBTask = () => {
+    return new Promise((resolve) => {
+      const onComplete = (err) => {
+        try {
+          if (err) {
+            cb(err);
+          } else {
+            cb(null, connection);
+          }
+        } finally {
+          resolve();
+        }
+      };
+      let db = databases.get(name);
+      if (db === undefined) {
+        db = new Database_default(name, 0);
+        databases.set(name, db);
+      }
+      if (version === undefined) {
+        version = db.version !== 0 ? db.version : 1;
+      }
+      if (db.version > version) {
+        return onComplete(new VersionError);
+      }
+      const connection = new FDBDatabase_default(db);
+      if (db.version < version) {
+        runVersionchangeTransaction(connection, version, request, (err) => {
+          onComplete(err);
+        });
+      } else {
+        onComplete(null);
+      }
+    });
+  };
+  runTaskInConnectionQueue(connectionQueues, name, openDBTask);
+}, FDBFactory, FDBFactory_default;
+var init_FDBFactory = __esm(() => {
+  init_FDBDatabase();
+  init_FDBOpenDBRequest();
+  init_FDBVersionChangeEvent();
+  init_cmp();
+  init_Database();
+  init_enforceRange();
+  init_errors();
+  init_FakeEvent();
+  init_scheduling();
+  FDBFactory = class FDBFactory {
+    _databases = new Map;
+    _connectionQueues = new Map;
+    cmp(first, second) {
+      validateRequiredArguments(arguments.length, 2, "IDBFactory.cmp");
+      return cmp_default(first, second);
+    }
+    deleteDatabase(name) {
+      validateRequiredArguments(arguments.length, 1, "IDBFactory.deleteDatabase");
+      const request = new FDBOpenDBRequest_default;
+      request.source = null;
+      queueTask(() => {
+        deleteDatabase(this._databases, this._connectionQueues, name, request, (err, oldVersion) => {
+          if (err) {
+            request.error = new DOMException(err.message, err.name);
+            request.readyState = "done";
+            const event = new FakeEvent_default("error", {
+              bubbles: true,
+              cancelable: true
+            });
+            event.eventPath = [];
+            request.dispatchEvent(event);
+            return;
+          }
+          request.result = undefined;
+          request.readyState = "done";
+          const event2 = new FDBVersionChangeEvent_default("success", {
+            newVersion: null,
+            oldVersion
+          });
+          request.dispatchEvent(event2);
+        });
+      });
+      return request;
+    }
+    open(name, version) {
+      validateRequiredArguments(arguments.length, 1, "IDBFactory.open");
+      if (arguments.length > 1 && version !== undefined) {
+        version = enforceRange_default(version, "MAX_SAFE_INTEGER");
+      }
+      if (version === 0) {
+        throw new TypeError("Database version cannot be 0");
+      }
+      const request = new FDBOpenDBRequest_default;
+      request.source = null;
+      queueTask(() => {
+        openDatabase(this._databases, this._connectionQueues, name, version, request, (err, connection) => {
+          if (err) {
+            request.result = undefined;
+            request.readyState = "done";
+            request.error = new DOMException(err.message, err.name);
+            const event = new FakeEvent_default("error", {
+              bubbles: true,
+              cancelable: true
+            });
+            event.eventPath = [];
+            request.dispatchEvent(event);
+            return;
+          }
+          request.result = connection;
+          request.readyState = "done";
+          const event2 = new FakeEvent_default("success");
+          event2.eventPath = [];
+          request.dispatchEvent(event2);
+        });
+      });
+      return request;
+    }
+    databases() {
+      return Promise.resolve(Array.from(this._databases.entries(), ([name, database]) => {
+        const activeVersionChangeConnection = database.connections.find((connection) => connection._runningVersionchangeTransaction);
+        const version = activeVersionChangeConnection ? activeVersionChangeConnection._oldVersion : database.version;
+        return {
+          name,
+          version
+        };
+      }).filter(({
+        version
+      }) => {
+        return version > 0;
+      }));
+    }
+    get [Symbol.toStringTag]() {
+      return "IDBFactory";
+    }
+  };
+  FDBFactory_default = FDBFactory;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/build/esm/fakeIndexedDB.js
+var fakeIndexedDB, fakeIndexedDB_default;
+var init_fakeIndexedDB = __esm(() => {
+  init_FDBFactory();
+  fakeIndexedDB = new FDBFactory_default;
+  fakeIndexedDB_default = fakeIndexedDB;
+});
+
+// ../../node_modules/.bun/fake-indexeddb@6.2.5/node_modules/fake-indexeddb/auto/index.mjs
+var exports_auto = {};
+var globalVar, createPropertyDescriptor = (value) => {
+  return {
+    value,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  };
+};
+var init_auto = __esm(() => {
+  init_fakeIndexedDB();
+  init_FDBCursor();
+  init_FDBCursorWithValue();
+  init_FDBDatabase();
+  init_FDBFactory();
+  init_FDBIndex();
+  init_FDBKeyRange();
+  init_FDBObjectStore();
+  init_FDBOpenDBRequest();
+  init_FDBRecord();
+  init_FDBRequest();
+  init_FDBTransaction();
+  init_FDBVersionChangeEvent();
+  globalVar = typeof window !== "undefined" ? window : typeof WorkerGlobalScope !== "undefined" ? self : typeof global !== "undefined" ? global : Function("return this;")();
+  Object.defineProperties(globalVar, {
+    indexedDB: createPropertyDescriptor(fakeIndexedDB_default),
+    IDBCursor: createPropertyDescriptor(FDBCursor_default),
+    IDBCursorWithValue: createPropertyDescriptor(FDBCursorWithValue_default),
+    IDBDatabase: createPropertyDescriptor(FDBDatabase_default),
+    IDBFactory: createPropertyDescriptor(FDBFactory_default),
+    IDBIndex: createPropertyDescriptor(FDBIndex_default),
+    IDBKeyRange: createPropertyDescriptor(FDBKeyRange_default),
+    IDBObjectStore: createPropertyDescriptor(FDBObjectStore_default),
+    IDBOpenDBRequest: createPropertyDescriptor(FDBOpenDBRequest_default),
+    IDBRecord: createPropertyDescriptor(FDBRecord_default),
+    IDBRequest: createPropertyDescriptor(FDBRequest_default),
+    IDBTransaction: createPropertyDescriptor(FDBTransaction_default),
+    IDBVersionChangeEvent: createPropertyDescriptor(FDBVersionChangeEvent_default)
+  });
+});
+
+// src/index.ts
+import { getConnectorAccountManager, logger as logger2 } from "@elizaos/core";
+
+// src/accounts.ts
+var DEFAULT_MATRIX_ACCOUNT_ID = "default";
+function stringSetting(runtime, key) {
+  const value = runtime.getSetting(key);
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function characterConfig(runtime) {
+  const settings = runtime.character?.settings;
+  const raw = settings?.matrix;
+  return raw && typeof raw === "object" ? raw : {};
+}
+function parseAccountsJson(runtime) {
+  const raw = stringSetting(runtime, "MATRIX_ACCOUNTS");
+  if (!raw)
+    return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) {
+      return Object.fromEntries(parsed.filter((item) => Boolean(item) && typeof item === "object").map((item) => [normalizeMatrixAccountId(item.accountId ?? item.id), item]));
+    }
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function allAccountConfigs(runtime) {
+  return {
+    ...characterConfig(runtime).accounts ?? {},
+    ...parseAccountsJson(runtime)
+  };
+}
+function accountConfig(runtime, accountId) {
+  const accounts = allAccountConfigs(runtime);
+  return accounts[accountId] ?? accounts[normalizeMatrixAccountId(accountId)] ?? {};
+}
+function boolValue(value, fallback = false) {
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "string")
+    return value.trim().toLowerCase() === "true";
+  return fallback;
+}
+function roomsValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((room) => String(room).trim()).filter(Boolean);
+  }
+  if (typeof value === "string") {
+    return value.split(",").map((room) => room.trim()).filter(Boolean);
+  }
+  return [];
+}
+function normalizeMatrixAccountId(accountId) {
+  if (typeof accountId !== "string")
+    return DEFAULT_MATRIX_ACCOUNT_ID;
+  const trimmed = accountId.trim();
+  return trimmed || DEFAULT_MATRIX_ACCOUNT_ID;
+}
+function listMatrixAccountIds(runtime) {
+  const ids = new Set;
+  const config = characterConfig(runtime);
+  if (stringSetting(runtime, "MATRIX_ACCESS_TOKEN") || config.homeserver && config.userId && config.accessToken) {
+    ids.add(DEFAULT_MATRIX_ACCOUNT_ID);
+  }
+  for (const id of Object.keys(allAccountConfigs(runtime))) {
+    ids.add(normalizeMatrixAccountId(id));
+  }
+  return Array.from(ids.size ? ids : new Set([DEFAULT_MATRIX_ACCOUNT_ID])).sort((a, b) => a.localeCompare(b));
+}
+function resolveDefaultMatrixAccountId(runtime) {
+  const requested = stringSetting(runtime, "MATRIX_DEFAULT_ACCOUNT_ID") ?? stringSetting(runtime, "MATRIX_ACCOUNT_ID");
+  if (requested)
+    return normalizeMatrixAccountId(requested);
+  const ids = listMatrixAccountIds(runtime);
+  return ids.includes(DEFAULT_MATRIX_ACCOUNT_ID) ? DEFAULT_MATRIX_ACCOUNT_ID : ids[0];
+}
+function readMatrixAccountId(...sources) {
+  for (const source of sources) {
+    if (!source || typeof source !== "object")
+      continue;
+    const record = source;
+    const parameters = record.parameters && typeof record.parameters === "object" ? record.parameters : {};
+    const data = record.data && typeof record.data === "object" ? record.data : {};
+    const metadata = record.metadata && typeof record.metadata === "object" ? record.metadata : {};
+    const matrix = data.matrix && typeof data.matrix === "object" ? data.matrix : {};
+    const value = record.accountId ?? parameters.accountId ?? data.accountId ?? matrix.accountId ?? metadata.accountId;
+    if (typeof value === "string" && value.trim())
+      return normalizeMatrixAccountId(value);
+  }
+  return;
+}
+function resolveMatrixAccountSettings(runtime, requestedAccountId) {
+  const accountId = normalizeMatrixAccountId(requestedAccountId ?? resolveDefaultMatrixAccountId(runtime));
+  const base = characterConfig(runtime);
+  const account = accountConfig(runtime, accountId);
+  const allowEnv = accountId === DEFAULT_MATRIX_ACCOUNT_ID;
+  return {
+    accountId,
+    homeserver: account.homeserver ?? base.homeserver ?? (allowEnv ? stringSetting(runtime, "MATRIX_HOMESERVER") : undefined) ?? "",
+    userId: account.userId ?? base.userId ?? (allowEnv ? stringSetting(runtime, "MATRIX_USER_ID") : undefined) ?? "",
+    accessToken: account.accessToken ?? base.accessToken ?? (allowEnv ? stringSetting(runtime, "MATRIX_ACCESS_TOKEN") : undefined) ?? "",
+    password: account.password ?? base.password ?? (allowEnv ? stringSetting(runtime, "MATRIX_PASSWORD") : undefined),
+    deviceId: account.deviceId ?? base.deviceId ?? (allowEnv ? stringSetting(runtime, "MATRIX_DEVICE_ID") : undefined),
+    rooms: roomsValue(account.rooms ?? base.rooms ?? (allowEnv ? stringSetting(runtime, "MATRIX_ROOMS") : undefined)),
+    verifyAllowlist: roomsValue(account.verifyAllowlist ?? base.verifyAllowlist ?? (allowEnv ? stringSetting(runtime, "MATRIX_VERIFY_ALLOWLIST") : undefined)),
+    autoJoin: boolValue(account.autoJoin ?? base.autoJoin ?? (allowEnv ? runtime.getSetting("MATRIX_AUTO_JOIN") : undefined)),
+    encryption: boolValue(account.encryption ?? base.encryption ?? (allowEnv ? runtime.getSetting("MATRIX_ENCRYPTION") : undefined)),
+    requireMention: boolValue(account.requireMention ?? base.requireMention ?? (allowEnv ? runtime.getSetting("MATRIX_REQUIRE_MENTION") : undefined)),
+    personal: boolValue(account.personal ?? base.personal ?? (allowEnv ? runtime.getSetting("MATRIX_PERSONAL") : undefined)),
+    enabled: boolValue(account.enabled ?? base.enabled, true)
+  };
+}
+// src/service.ts
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "node:crypto";
+import { existsSync } from "node:fs";
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { deserialize as v8Deserialize, serialize as v8Serialize } from "node:v8";
+import {
+  ChannelType,
+  createUniqueUuid,
+  EventType,
+  lifeOpsPassiveConnectorsEnabled,
+  logger,
+  Service
+} from "@elizaos/core";
+import * as sdk from "matrix-js-sdk";
+import {
+  CryptoEvent,
+  canAcceptVerificationRequest,
+  VerificationPhase,
+  VerificationRequestEvent,
+  VerifierEvent
+} from "matrix-js-sdk/lib/crypto-api";
+
+// src/types.ts
+var MAX_MATRIX_MESSAGE_LENGTH = 4000;
+var MATRIX_SERVICE_NAME = "matrix";
+var MatrixEventTypes;
+((MatrixEventTypes2) => {
+  MatrixEventTypes2["MESSAGE_RECEIVED"] = "MATRIX_MESSAGE_RECEIVED";
+  MatrixEventTypes2["MESSAGE_SENT"] = "MATRIX_MESSAGE_SENT";
+  MatrixEventTypes2["ROOM_JOINED"] = "MATRIX_ROOM_JOINED";
+  MatrixEventTypes2["ROOM_LEFT"] = "MATRIX_ROOM_LEFT";
+  MatrixEventTypes2["INVITE_RECEIVED"] = "MATRIX_INVITE_RECEIVED";
+  MatrixEventTypes2["REACTION_RECEIVED"] = "MATRIX_REACTION_RECEIVED";
+  MatrixEventTypes2["TYPING_RECEIVED"] = "MATRIX_TYPING_RECEIVED";
+  MatrixEventTypes2["SYNC_COMPLETE"] = "MATRIX_SYNC_COMPLETE";
+  MatrixEventTypes2["CONNECTION_READY"] = "MATRIX_CONNECTION_READY";
+  MatrixEventTypes2["CONNECTION_LOST"] = "MATRIX_CONNECTION_LOST";
+})(MatrixEventTypes ||= {});
+function isValidMatrixUserId(userId) {
+  return /^@[^:]+:.+$/.test(userId);
+}
+function isValidMatrixRoomId(roomId) {
+  return /^![^:]+:.+$/.test(roomId);
+}
+function isValidMatrixRoomAlias(alias) {
+  return /^#[^:]+:.+$/.test(alias);
+}
+function getMatrixLocalpart(matrixId) {
+  const match = matrixId.match(/^[@#!]([^:]+):/);
+  return match ? match[1] : matrixId;
+}
+function getMatrixServerpart(matrixId) {
+  const match = matrixId.match(/:(.+)$/);
+  return match ? match[1] : "";
+}
+function getMatrixUserDisplayName(user) {
+  return user.displayName || getMatrixLocalpart(user.userId);
+}
+function matrixMxcToHttp(mxcUrl, homeserver) {
+  if (!mxcUrl.startsWith("mxc://")) {
+    return;
+  }
+  const [serverName, mediaId] = mxcUrl.slice(6).split("/");
+  if (!serverName || !mediaId) {
+    return;
+  }
+  const base = homeserver.replace(/\/$/, "");
+  return `${base}/_matrix/media/v3/download/${serverName}/${mediaId}`;
+}
+
+class MatrixPluginError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MatrixPluginError";
+  }
+}
+
+class MatrixServiceNotInitializedError extends MatrixPluginError {
+  constructor(message = "Matrix service is not initialized") {
+    super(message);
+    this.name = "MatrixServiceNotInitializedError";
+  }
+}
+
+class MatrixNotConnectedError extends MatrixPluginError {
+  constructor(message = "Matrix client is not connected") {
+    super(message);
+    this.name = "MatrixNotConnectedError";
+  }
+}
+
+class MatrixConfigurationError extends MatrixPluginError {
+  settingName;
+  constructor(message, settingName) {
+    super(message);
+    this.name = "MatrixConfigurationError";
+    this.settingName = settingName;
+  }
+}
+
+class MatrixApiError extends MatrixPluginError {
+  errcode;
+  constructor(message, errcode) {
+    super(message);
+    this.name = "MatrixApiError";
+    this.errcode = errcode;
+  }
+}
+
+// src/service.ts
+function normalizeSearchQuery(query) {
+  return query.trim().toLowerCase();
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function matrixRoomSearchText(room) {
+  return [room.roomId, room.name, room.topic, room.canonicalAlias].filter((value) => typeof value === "string" && value.length > 0).join(" ").toLowerCase();
+}
+function scoreMatrixRoom(room, query) {
+  const normalized = normalizeSearchQuery(query);
+  if (!normalized) {
+    return 0.4;
+  }
+  const candidates = [room.roomId, room.canonicalAlias, room.name].filter((value) => typeof value === "string" && value.length > 0);
+  if (candidates.some((candidate) => candidate.toLowerCase() === normalized)) {
+    return 1;
+  }
+  if (candidates.some((candidate) => candidate.toLowerCase().includes(normalized))) {
+    return 0.85;
+  }
+  return matrixRoomSearchText(room).includes(normalized) ? 0.65 : 0;
+}
+function matrixRoomToConnectorTarget(room, score = 0.5, accountId = DEFAULT_MATRIX_ACCOUNT_ID) {
+  const label = room.name || room.canonicalAlias || room.roomId;
+  return {
+    target: {
+      source: MATRIX_SERVICE_NAME,
+      accountId,
+      channelId: room.roomId
+    },
+    label,
+    kind: room.isDirect ? "user" : "room",
+    description: room.topic || `${room.memberCount} Matrix member${room.memberCount === 1 ? "" : "s"}`,
+    score,
+    contexts: ["social", "connectors"],
+    metadata: {
+      accountId,
+      roomId: room.roomId,
+      canonicalAlias: room.canonicalAlias,
+      isEncrypted: room.isEncrypted,
+      isDirect: room.isDirect,
+      memberCount: room.memberCount
+    }
+  };
+}
+var DEFAULT_CRYPTO_DB_PREFIX = "matrix-js-sdk";
+function cryptoDbPrefix(accountId) {
+  if (!accountId || accountId === DEFAULT_MATRIX_ACCOUNT_ID) {
+    return DEFAULT_CRYPTO_DB_PREFIX;
+  }
+  const safeId = accountId.replace(/[^a-zA-Z0-9._-]/g, "_") || "account";
+  return `${DEFAULT_CRYPTO_DB_PREFIX}-${safeId}`;
+}
+function cryptoDbName(accountId) {
+  return `${cryptoDbPrefix(accountId)}::matrix-sdk-crypto`;
+}
+var CRYPTO_SNAPSHOT_INTERVAL_MS = 60 * 1000;
+var VERIFICATION_START_FALLBACK_MS = 4000;
+var ROOM_KEY_SCRYPT_SALT = "matrix.roomKeys.v1";
+var ROOM_KEY_BYTES = 32;
+var ROOM_KEY_NONCE_BYTES = 12;
+function resolveStateDir() {
+  return process.env.ELIZA_STATE_DIR || join(homedir(), ".local/state/eliza");
+}
+function cryptoStoreFilePath(accountId) {
+  const safeId = accountId.replace(/[^a-zA-Z0-9._-]/g, "_") || "default";
+  return join(resolveStateDir(), "matrix-keys", `${safeId}.enc`);
+}
+function encryptCryptoStore(accessToken, plaintext) {
+  const key = scryptSync(accessToken, ROOM_KEY_SCRYPT_SALT, ROOM_KEY_BYTES);
+  const nonce = randomBytes(ROOM_KEY_NONCE_BYTES);
+  const cipher = createCipheriv("aes-256-gcm", key, nonce);
+  const ct = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return `v1:${nonce.toString("base64")}:${tag.toString("base64")}:${ct.toString("base64")}`;
+}
+function decryptCryptoStore(accessToken, ciphertext) {
+  const parts = ciphertext.split(":");
+  if (parts.length !== 4 || parts[0] !== "v1") {
+    throw new Error("malformed crypto-store ciphertext");
+  }
+  const key = scryptSync(accessToken, ROOM_KEY_SCRYPT_SALT, ROOM_KEY_BYTES);
+  const nonce = Buffer.from(parts[1], "base64");
+  const tag = Buffer.from(parts[2], "base64");
+  const ct = Buffer.from(parts[3], "base64");
+  const decipher = createDecipheriv("aes-256-gcm", key, nonce);
+  decipher.setAuthTag(tag);
+  return Buffer.concat([decipher.update(ct), decipher.final()]);
+}
+function openIndexedDb(name, version, upgrade) {
+  return new Promise((resolve, reject) => {
+    const request = version ? indexedDB.open(name, version) : indexedDB.open(name);
+    if (upgrade) {
+      request.onupgradeneeded = (event) => upgrade(event.target.result);
+    }
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+function transactionDone(tx) {
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+    tx.onabort = () => reject(tx.error);
+  });
+}
+async function snapshotDb(name) {
+  const db = await openIndexedDb(name);
+  const snapshot = { version: db.version, stores: {} };
+  for (const storeName of [...db.objectStoreNames]) {
+    const store = db.transaction(storeName, "readonly").objectStore(storeName);
+    const records = [];
+    await new Promise((resolve, reject) => {
+      const cursorRequest = store.openCursor();
+      cursorRequest.onsuccess = () => {
+        const cursor = cursorRequest.result;
+        if (cursor) {
+          records.push({ key: cursor.primaryKey, value: cursor.value });
+          cursor.continue();
+        } else {
+          resolve();
+        }
+      };
+      cursorRequest.onerror = () => reject(cursorRequest.error);
+    });
+    snapshot.stores[storeName] = {
+      schema: {
+        keyPath: store.keyPath,
+        autoIncrement: store.autoIncrement,
+        indexes: [...store.indexNames].map((indexName) => {
+          const index = store.index(indexName);
+          return {
+            name: indexName,
+            keyPath: index.keyPath,
+            unique: index.unique,
+            multiEntry: index.multiEntry
+          };
+        })
+      },
+      records
+    };
+  }
+  db.close();
+  return snapshot;
+}
+async function restoreDb(name, snapshot) {
+  await new Promise((resolve) => {
+    const request = indexedDB.deleteDatabase(name);
+    request.onsuccess = () => resolve();
+    request.onerror = () => resolve();
+    request.onblocked = () => resolve();
+  });
+  const db = await openIndexedDb(name, snapshot.version, (upgradeDb) => {
+    for (const [storeName, { schema }] of Object.entries(snapshot.stores)) {
+      const store = upgradeDb.createObjectStore(storeName, {
+        keyPath: schema.keyPath ?? undefined,
+        autoIncrement: schema.autoIncrement
+      });
+      for (const index of schema.indexes) {
+        store.createIndex(index.name, index.keyPath, {
+          unique: index.unique,
+          multiEntry: index.multiEntry
+        });
+      }
+    }
+  });
+  for (const [storeName, { schema, records }] of Object.entries(snapshot.stores)) {
+    const tx = db.transaction(storeName, "readwrite");
+    const store = tx.objectStore(storeName);
+    for (const { key, value } of records) {
+      if (schema.keyPath) {
+        store.put(value);
+      } else {
+        store.put(value, key);
+      }
+    }
+    await transactionDone(tx);
+  }
+  db.close();
+}
+function normalizeConnectorLimit(limit, fallback = 50) {
+  if (!Number.isFinite(limit) || !limit || limit <= 0) {
+    return fallback;
+  }
+  return Math.min(Math.floor(limit), 200);
+}
+function buildMatrixMessage(event, room) {
+  const content = event.getContent();
+  const msgType = content.msgtype;
+  if (msgType !== "m.text")
+    return null;
+  if (typeof content.body !== "string")
+    return null;
+  const roomId = event.getRoomId();
+  if (!roomId)
+    return null;
+  const sender = event.getSender();
+  const senderMember = room.getMember(sender || "");
+  const senderInfo = {
+    userId: sender || "",
+    displayName: senderMember?.name,
+    avatarUrl: senderMember?.getMxcAvatarUrl() || undefined
+  };
+  const relatesTo = content["m.relates_to"];
+  const isEdit = relatesTo?.rel_type === "m.replace";
+  const threadId = relatesTo?.rel_type === "m.thread" ? relatesTo.event_id : undefined;
+  const replyTo = relatesTo?.["m.in_reply_to"]?.event_id;
+  return {
+    eventId: event.getId() || "",
+    roomId,
+    sender: sender || "",
+    senderInfo,
+    content: content.body,
+    msgType,
+    formattedBody: typeof content.formatted_body === "string" ? content.formatted_body : undefined,
+    timestamp: event.getTs(),
+    threadId,
+    replyTo,
+    isEdit,
+    replacesEventId: isEdit ? relatesTo?.event_id : undefined
+  };
+}
+function matrixMessageToMemory(runtime, message, channelType) {
+  const roomId = message.roomId;
+  return {
+    id: createUniqueUuid(runtime, message.eventId || `${roomId}:${message.timestamp}`),
+    entityId: createUniqueUuid(runtime, message.sender || roomId),
+    agentId: runtime.agentId,
+    roomId: createUniqueUuid(runtime, message.roomId),
+    content: {
+      text: message.content,
+      source: MATRIX_SERVICE_NAME,
+      channelType,
+      ...message.replyTo ? { inReplyTo: createUniqueUuid(runtime, message.replyTo) } : {}
+    },
+    createdAt: message.timestamp
+  };
+}
+async function readStoredMessageMemories(runtime, roomId, limit) {
+  return runtime.getMemories({
+    tableName: "messages",
+    roomId,
+    limit,
+    orderBy: "createdAt",
+    orderDirection: "desc"
+  });
+}
+async function resolveMatrixRoomId(runtime, target) {
+  return String(target?.channelId ?? (target?.roomId ? (await runtime.getRoom(target.roomId))?.channelId : "") ?? "").trim();
+}
+async function readJoinedRoomMessages(service, accountId, limit) {
+  const rooms = (await service.getJoinedRooms(accountId)).slice(0, 10);
+  const chunks = await Promise.all(rooms.map((room) => service.getRoomMessages(room.roomId, limit, accountId)));
+  return chunks.flat().sort((left, right) => (right.createdAt ?? 0) - (left.createdAt ?? 0)).slice(0, limit);
+}
+async function readMessagesForTarget(service, runtime, accountId, target, limit) {
+  const matrixRoomId = await resolveMatrixRoomId(runtime, target);
+  if (!matrixRoomId) {
+    return readJoinedRoomMessages(service, accountId, limit);
+  }
+  const live = await service.getRoomMessages(matrixRoomId, limit, accountId);
+  if (live.length > 0) {
+    return live;
+  }
+  return readStoredMessageMemories(runtime, createUniqueUuid(runtime, matrixRoomId), limit);
+}
+function filterMemoriesByQuery(memories, query, limit) {
+  const normalized = query.trim().toLowerCase();
+  if (!normalized) {
+    return memories.slice(0, limit);
+  }
+  return memories.filter((memory) => {
+    const text = typeof memory.content?.text === "string" ? memory.content.text : "";
+    return text.toLowerCase().includes(normalized);
+  }).slice(0, limit);
+}
+function extractMatrixSendOptions(content, target) {
+  const data = content.data;
+  const matrixData = data?.matrix && typeof data.matrix === "object" ? data.matrix : data;
+  return {
+    threadId: target.threadId || (typeof matrixData?.threadId === "string" ? matrixData.threadId : undefined),
+    replyTo: typeof matrixData?.replyTo === "string" ? matrixData.replyTo : undefined,
+    formatted: matrixData?.formatted === true
+  };
+}
+
+class MatrixService extends Service {
+  static serviceType = MATRIX_SERVICE_NAME;
+  capabilityDescription = "Matrix messaging service for chat communication";
+  states = new Map;
+  defaultAccountId = DEFAULT_MATRIX_ACCOUNT_ID;
+  static async start(runtime) {
+    const service = new MatrixService;
+    await service.initialize(runtime);
+    return service;
+  }
+  static async stopRuntime(runtime) {
+    const service = runtime.getService(MATRIX_SERVICE_NAME);
+    if (service) {
+      await service.stop();
+    }
+  }
+  static registerSendHandlers(runtime, service, accountId = service.getAccountId(runtime)) {
+    accountId = normalizeMatrixAccountId(accountId);
+    const sendHandler = async (handlerRuntime, target, content) => {
+      await service.handleSendMessage(handlerRuntime, target, content);
+      return;
+    };
+    if (typeof runtime.registerMessageConnector === "function") {
+      const registration = {
+        source: MATRIX_SERVICE_NAME,
+        accountId,
+        label: "Matrix",
+        capabilities: [
+          "send_message",
+          "send_thread_reply",
+          "send_formatted_message",
+          "react_to_message",
+          "list_rooms",
+          "join_room"
+        ],
+        supportedTargetKinds: ["room", "channel", "thread", "user"],
+        contexts: ["social", "connectors"],
+        description: "Send messages to joined Matrix rooms, aliases, encrypted rooms, and known direct-message rooms.",
+        metadata: {
+          accountId,
+          service: MATRIX_SERVICE_NAME
+        },
+        sendHandler,
+        resolveTargets: async (query) => {
+          const rooms = await service.getJoinedRooms(accountId);
+          return rooms.map((room) => ({ room, score: scoreMatrixRoom(room, query) })).filter(({ score }) => score > 0).sort((left, right) => right.score - left.score).slice(0, 10).map(({ room, score }) => matrixRoomToConnectorTarget(room, score, accountId));
+        },
+        listRecentTargets: async () => (await service.getJoinedRooms(accountId)).slice(0, 10).map((room) => matrixRoomToConnectorTarget(room, 0.5, accountId)),
+        listRooms: async () => (await service.getJoinedRooms(accountId)).map((room) => matrixRoomToConnectorTarget(room, 0.5, accountId)),
+        fetchMessages: async (context, params) => {
+          const limit = normalizeConnectorLimit(params?.limit);
+          const target = params?.target ?? context.target;
+          return readMessagesForTarget(service, context.runtime, accountId, target, limit);
+        },
+        searchMessages: async (context, params) => {
+          const limit = normalizeConnectorLimit(params?.limit);
+          const target = params?.target ?? context.target;
+          const messages2 = await readMessagesForTarget(service, context.runtime, accountId, target, Math.max(limit, 100));
+          return filterMemoriesByQuery(messages2, params.query, limit);
+        },
+        reactHandler: async (handlerRuntime, params) => {
+          const target = params.target ?? { source: MATRIX_SERVICE_NAME };
+          const room = target.roomId ? await handlerRuntime.getRoom(target.roomId) : null;
+          const roomId = String(target.channelId ?? room?.channelId ?? "").trim();
+          const mutationParams = params;
+          const eventId = String(mutationParams.eventId ?? params.messageId ?? "").trim();
+          const emoji = String(params.emoji ?? "").trim();
+          if (!roomId || !eventId || !emoji) {
+            throw new Error("Matrix reactHandler requires room, event id, and emoji");
+          }
+          const result = await service.sendReaction(roomId, eventId, emoji, accountId);
+          if (!result.success) {
+            throw new Error(result.error || "Matrix reaction failed");
+          }
+        },
+        joinHandler: async (_handlerRuntime, params) => {
+          const membershipParams = params;
+          const roomIdOrAlias = String(membershipParams.roomIdOrAlias ?? params.alias ?? params.invite ?? params.channelId ?? params.roomId ?? "").trim();
+          if (!roomIdOrAlias) {
+            throw new Error("Matrix joinHandler requires a room ID or alias");
+          }
+          await service.joinRoom(roomIdOrAlias, accountId);
+        },
+        leaveHandler: async (handlerRuntime, params) => {
+          const target = params.target ?? { source: MATRIX_SERVICE_NAME };
+          const room = target.roomId ? await handlerRuntime.getRoom(target.roomId) : null;
+          const roomId = String(params?.roomId ?? params?.channelId ?? target.channelId ?? room?.channelId ?? "");
+          if (!roomId) {
+            throw new Error("Matrix leaveHandler requires a room ID");
+          }
+          await service.leaveRoom(roomId, accountId);
+        },
+        getChatContext: async (target, context) => {
+          const room = target.roomId ? await context.runtime.getRoom(target.roomId) : null;
+          const channelId = String(target.channelId ?? room?.channelId ?? "").trim();
+          const joinedRoom = (await service.getJoinedRooms(accountId)).find((candidate) => candidate.roomId === channelId || candidate.canonicalAlias === channelId);
+          if (!joinedRoom) {
+            return null;
+          }
+          return {
+            target: {
+              source: MATRIX_SERVICE_NAME,
+              accountId,
+              channelId: joinedRoom.roomId,
+              roomId: target.roomId
+            },
+            label: joinedRoom.name || joinedRoom.canonicalAlias || joinedRoom.roomId,
+            summary: joinedRoom.topic,
+            metadata: {
+              accountId,
+              roomId: joinedRoom.roomId,
+              canonicalAlias: joinedRoom.canonicalAlias,
+              isEncrypted: joinedRoom.isEncrypted,
+              isDirect: joinedRoom.isDirect,
+              memberCount: joinedRoom.memberCount
+            }
+          };
+        },
+        getUserContext: async (entityId, context) => {
+          if (typeof context.runtime.getEntityById !== "function") {
+            return null;
+          }
+          const entity = await context.runtime.getEntityById(String(entityId));
+          if (!entity) {
+            return null;
+          }
+          return {
+            entityId,
+            label: entity.names?.[0],
+            aliases: entity.names,
+            handles: {},
+            metadata: entity.metadata
+          };
+        }
+      };
+      runtime.registerMessageConnector(registration);
+      return;
+    }
+    runtime.registerSendHandler(MATRIX_SERVICE_NAME, sendHandler);
+  }
+  async initialize(runtime) {
+    this.runtime = runtime;
+    this.defaultAccountId = normalizeMatrixAccountId(resolveDefaultMatrixAccountId(runtime));
+    const accountIds = listMatrixAccountIds(runtime);
+    for (const accountId of accountIds) {
+      const settings = this.loadSettings(accountId);
+      if (settings.enabled === false) {
+        continue;
+      }
+      this.validateSettings(settings);
+      const state = {
+        accountId: normalizeMatrixAccountId(settings.accountId),
+        settings,
+        client: sdk.createClient({
+          baseUrl: settings.homeserver,
+          userId: settings.userId,
+          accessToken: settings.accessToken,
+          deviceId: settings.deviceId,
+          verificationMethods: ["m.sas.v1"]
+        }),
+        connected: false,
+        syncing: false
+      };
+      this.states.set(state.accountId, state);
+      await this.initCrypto(state);
+      this.startCryptoSnapshot(state);
+      this.setupEventHandlers(state);
+      await this.connect(state);
+      MatrixService.registerSendHandlers(runtime, this, state.accountId);
+      logger.info(`Matrix service initialized for ${settings.userId} on ${settings.homeserver}`);
+    }
+    if (this.states.size === 0) {
+      const settings = this.loadSettings(this.defaultAccountId);
+      this.validateSettings(settings);
+    }
+  }
+  loadSettings(accountId) {
+    return resolveMatrixAccountSettings(this.runtime, accountId);
+  }
+  validateSettings(settings) {
+    if (!settings.homeserver) {
+      throw new MatrixConfigurationError("MATRIX_HOMESERVER is required", "MATRIX_HOMESERVER");
+    }
+    if (!settings.userId) {
+      throw new MatrixConfigurationError("MATRIX_USER_ID is required", "MATRIX_USER_ID");
+    }
+    if (!settings.accessToken) {
+      throw new MatrixConfigurationError("MATRIX_ACCESS_TOKEN is required", "MATRIX_ACCESS_TOKEN");
+    }
+  }
+  async initCrypto(state) {
+    if (!state.settings.encryption) {
+      return;
+    }
+    if (typeof state.client.initRustCrypto !== "function") {
+      logger.warn("Matrix encryption requested but initRustCrypto is unavailable in this matrix-js-sdk build; messages in encrypted rooms will be unreadable.");
+      return;
+    }
+    let cryptoUp = false;
+    try {
+      await Promise.resolve().then(() => (init_auto(), exports_auto));
+      await this.restoreCryptoStore(state);
+      await state.client.initRustCrypto({
+        useIndexedDB: true,
+        cryptoDatabasePrefix: cryptoDbPrefix(state.accountId)
+      });
+      logger.info(`Matrix E2EE initialized (persistent rust-crypto via IndexedDB) for ${state.settings.userId}`);
+      cryptoUp = true;
+    } catch (err) {
+      logger.warn(`Matrix persistent crypto init failed (${err instanceof Error ? err.message : String(err)}); falling back to in-memory crypto (device will re-key on restart).`);
+    }
+    if (!cryptoUp) {
+      try {
+        await state.client.initRustCrypto({ useIndexedDB: false });
+        logger.info(`Matrix E2EE initialized (in-memory rust-crypto) for ${state.settings.userId}`);
+        cryptoUp = true;
+      } catch (err) {
+        logger.warn(`Matrix encryption failed to initialize (${err instanceof Error ? err.message : String(err)}); encrypted rooms will be unreadable, but the Matrix connection will continue.`);
+      }
+    }
+    if (cryptoUp) {
+      await this.ensureCrossSigning(state);
+    }
+  }
+  async ensureCrossSigning(state) {
+    const crypto = typeof state.client.getCrypto === "function" ? state.client.getCrypto() : undefined;
+    if (!crypto) {
+      return;
+    }
+    try {
+      crypto.globalBlacklistUnverifiedDevices = false;
+      crypto.setTrustCrossSignedDevices(true);
+      if (await crypto.isCrossSigningReady()) {
+        return;
+      }
+      await crypto.bootstrapCrossSigning({
+        authUploadDeviceSigningKeys: async (makeRequest) => {
+          try {
+            return await makeRequest(null);
+          } catch (err) {
+            const data = err?.data;
+            if (!data?.flows) {
+              throw err;
+            }
+            if (!state.settings.password || !data.session) {
+              logger.warn(`Matrix cross-signing upload for ${state.settings.userId} needs password UIA but ${state.settings.password ? "the server returned no challenge session" : "no MATRIX_PASSWORD is set"}; device ${state.settings.deviceId ?? "?"} stays uncross-signed, so exclude-insecure-devices senders will withhold keys.`);
+              throw err;
+            }
+            return await makeRequest({
+              type: "m.login.password",
+              identifier: { type: "m.id.user", user: state.settings.userId },
+              password: state.settings.password,
+              session: data.session
+            });
+          }
+        }
+      });
+      logger.info(`Matrix cross-signing bootstrapped for ${state.settings.userId}; senders should now share megolm keys to this device.`);
+      await crypto.checkKeyBackupAndEnable().catch(() => {});
+    } catch (err) {
+      logger.warn(`Matrix cross-signing bootstrap skipped (${err instanceof Error ? err.message : String(err)}); cohort senders in exclude-insecure-devices mode may withhold keys until this device is verified once from an operator's Matrix client.`);
+    }
+  }
+  async restoreCryptoStore(state) {
+    try {
+      const filePath = cryptoStoreFilePath(state.accountId);
+      if (!existsSync(filePath)) {
+        return;
+      }
+      const ciphertext = await readFile(filePath, "utf8");
+      let snapshot;
+      try {
+        snapshot = v8Deserialize(decryptCryptoStore(state.settings.accessToken, ciphertext));
+      } catch {
+        logger.warn(`Matrix crypto-store restore skipped for ${state.accountId}: stored state could not be decrypted (token may have rotated).`);
+        return;
+      }
+      await restoreDb(cryptoDbName(state.accountId), snapshot);
+      logger.info(`Matrix restored persisted crypto store for ${state.accountId}`);
+    } catch (err) {
+      logger.warn(`Matrix crypto-store restore failed for ${state.accountId}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  async saveCryptoStore(state) {
+    if (typeof indexedDB === "undefined") {
+      return;
+    }
+    try {
+      const snapshot = await snapshotDb(cryptoDbName(state.accountId));
+      const ciphertext = encryptCryptoStore(state.settings.accessToken, v8Serialize(snapshot));
+      const filePath = cryptoStoreFilePath(state.accountId);
+      const tmpPath = `${filePath}.${randomBytes(6).toString("hex")}.tmp`;
+      await mkdir(join(resolveStateDir(), "matrix-keys"), { recursive: true, mode: 448 });
+      await writeFile(tmpPath, ciphertext, { mode: 384 });
+      await chmod(tmpPath, 384);
+      await rename(tmpPath, filePath);
+    } catch (err) {
+      logger.warn(`Matrix crypto-store save failed for ${state.accountId}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  startCryptoSnapshot(state) {
+    if (!state.settings.encryption) {
+      return;
+    }
+    const timer = setInterval(() => {
+      this.saveCryptoStore(state);
+    }, CRYPTO_SNAPSHOT_INTERVAL_MS);
+    timer.unref?.();
+    state.cryptoSnapshotTimer = timer;
+  }
+  setupEventHandlers(state) {
+    state.client.on(sdk.ClientEvent.Sync, (syncState) => {
+      if (syncState === "PREPARED") {
+        state.syncing = true;
+        logger.info("Matrix sync complete");
+        this.runtime.emitEvent("MATRIX_SYNC_COMPLETE" /* SYNC_COMPLETE */, {
+          runtime: this.runtime,
+          accountId: state.accountId
+        });
+      }
+    });
+    state.client.on(sdk.RoomEvent.Timeline, (event, room, toStartOfTimeline) => {
+      if (toStartOfTimeline)
+        return;
+      if (event.getSender() === state.settings.userId)
+        return;
+      if (event.isEncrypted() && event.getType() === "m.room.encrypted") {
+        event.once(sdk.MatrixEventEvent.Decrypted, () => {
+          if (event.getType() === "m.room.message") {
+            this.handleRoomMessage(state, event, room);
+          } else if (event.isDecryptionFailure()) {
+            logger.warn(`Matrix could not decrypt event ${event.getId()} in ${event.getRoomId()} — the sender has not shared the megolm key with this device yet.`);
+          }
+        });
+        return;
+      }
+      if (event.getType() !== "m.room.message")
+        return;
+      this.handleRoomMessage(state, event, room);
+    });
+    state.client.on(sdk.RoomMemberEvent.Membership, (event, member) => {
+      if (member.userId !== state.settings.userId)
+        return;
+      if (member.membership === "invite" && state.settings.autoJoin) {
+        const roomId = event.getRoomId();
+        if (roomId) {
+          logger.info(`Auto-joining room ${roomId}`);
+          state.client.joinRoom(roomId).catch((err) => {
+            logger.error(`Failed to auto-join room: ${err.message}`);
+          });
+        }
+      }
+    });
+    this.setupVerificationAutoAccept(state);
+  }
+  setupVerificationAutoAccept(state) {
+    const crypto = state.client.getCrypto();
+    if (!crypto || state.settings.verifyAllowlist.length === 0) {
+      return;
+    }
+    state.client.on(CryptoEvent.VerificationRequestReceived, (request) => {
+      this.handleVerificationRequest(state, request);
+    });
+  }
+  async handleVerificationRequest(state, request) {
+    const other = request.otherUserId;
+    if (!state.settings.verifyAllowlist.includes(other)) {
+      logger.warn(`Matrix rejecting verification request from non-allowlisted ${other}`);
+      await request.cancel().catch(() => {});
+      return;
+    }
+    logger.info(`Matrix auto-accepting SAS verification from ${other}`);
+    try {
+      if (canAcceptVerificationRequest(request)) {
+        await request.accept();
+      }
+      const verifier = request.verifier ?? await this.awaitVerifier(request);
+      if (!verifier) {
+        await request.cancel().catch(() => {});
+        return;
+      }
+      verifier.on(VerifierEvent.ShowSas, (callbacks) => {
+        logger.info(`Matrix auto-confirming SAS with ${other}`);
+        callbacks.confirm().catch(() => {});
+      });
+      await verifier.verify();
+      logger.info(`Matrix device verification with ${other} complete; megolm keys should now flow.`);
+    } catch (err) {
+      logger.warn(`Matrix verification with ${other} failed or was cancelled (${err instanceof Error ? err.message : String(err)}).`);
+    }
+  }
+  awaitVerifier(request) {
+    return new Promise((resolve) => {
+      let fallbackTimer;
+      const settle = (value) => {
+        if (fallbackTimer)
+          clearTimeout(fallbackTimer);
+        request.off(VerificationRequestEvent.Change, onChange);
+        resolve(value);
+      };
+      const onChange = () => {
+        if (request.verifier) {
+          settle(request.verifier);
+        } else if (request.phase === VerificationPhase.Cancelled || request.phase === VerificationPhase.Done) {
+          settle(undefined);
+        } else if (request.phase === VerificationPhase.Ready && !fallbackTimer) {
+          fallbackTimer = setTimeout(() => {
+            if (!request.verifier) {
+              request.startVerification("m.sas.v1").then(settle, () => settle(undefined));
+            }
+          }, VERIFICATION_START_FALLBACK_MS);
+        }
+      };
+      request.on(VerificationRequestEvent.Change, onChange);
+      onChange();
+    });
+  }
+  handleRoomMessage(state, event, room) {
+    if (!room)
+      return;
+    const message = buildMatrixMessage(event, room);
+    if (!message)
+      return;
+    const roomId = message.roomId;
+    const isDirectRoom = room.getJoinedMemberCount() <= 2;
+    if (state.settings.requireMention && !isDirectRoom) {
+      const localpart = getMatrixLocalpart(state.settings.userId);
+      const mentionPattern = new RegExp(`@?${escapeRegExp(localpart)}`, "i");
+      if (!mentionPattern.test(message.content)) {
+        return;
+      }
+    }
+    const matrixRoom = {
+      roomId,
+      name: room.name,
+      topic: room.currentState.getStateEvents("m.room.topic", "")?.getContent()?.topic,
+      canonicalAlias: room.getCanonicalAlias() || undefined,
+      isEncrypted: room.hasEncryptionStateEvent(),
+      isDirect: state.client.getAccountData(sdk.EventType.Direct)?.getContent()?.[message.sender || ""]?.includes(roomId) || false,
+      memberCount: room.getJoinedMemberCount()
+    };
+    logger.debug(`Matrix message from ${message.senderInfo.displayName || message.sender} in ${room.name || roomId}: ${message.content.slice(0, 50)}...`);
+    this.runtime.emitEvent("MATRIX_MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, {
+      message,
+      room: matrixRoom,
+      runtime: this.runtime,
+      accountId: state.accountId
+    });
+    this.dispatchToAgent(state, message, matrixRoom).catch((err) => logger.error(`Matrix dispatchToAgent failed: ${err instanceof Error ? err.message : String(err)}`));
+  }
+  async dispatchToAgent(state, message, room) {
+    const roomId = room.roomId;
+    const entityId = createUniqueUuid(this.runtime, message.sender || roomId);
+    const coreRoomId = createUniqueUuid(this.runtime, roomId);
+    const worldId = createUniqueUuid(this.runtime, roomId);
+    const channelType = room.memberCount <= 2 ? ChannelType.DM : ChannelType.GROUP;
+    const displayName = message.senderInfo.displayName || message.sender || "Matrix user";
+    await this.runtime.ensureConnection({
+      entityId,
+      roomId: coreRoomId,
+      roomName: room.name || roomId,
+      userName: displayName,
+      name: displayName,
+      source: MATRIX_SERVICE_NAME,
+      channelId: roomId,
+      type: channelType,
+      worldId,
+      worldName: room.name,
+      userId: message.sender || roomId,
+      metadata: { accountId: state.accountId }
+    });
+    const coreMessage = matrixMessageToMemory(this.runtime, message, channelType);
+    const autoReplyRaw = this.runtime.getSetting("MATRIX_AUTO_REPLY");
+    const autoReply = !lifeOpsPassiveConnectorsEnabled(this.runtime) && (autoReplyRaw === true || autoReplyRaw === "true");
+    if (!autoReply) {
+      try {
+        await this.runtime.createMemory(coreMessage, "messages");
+      } catch (err) {
+        logger.warn(`Matrix inbound memory persist failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      try {
+        await this.runtime.emitEvent(EventType.MESSAGE_RECEIVED, {
+          runtime: this.runtime,
+          message: coreMessage,
+          source: MATRIX_SERVICE_NAME
+        });
+      } catch (err) {
+        logger.warn(`Matrix inbound event emit failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      return;
+    }
+    if (!this.runtime.messageService) {
+      logger.error("Matrix: runtime.messageService is unavailable; cannot process inbound message");
+      return;
+    }
+    const callback = async (responseContent) => {
+      const text = typeof responseContent.text === "string" ? responseContent.text.trim() : "";
+      if (!text) {
+        return [];
+      }
+      const result = await this.sendMessage(text, {
+        accountId: state.accountId,
+        roomId,
+        threadId: message.threadId,
+        replyTo: message.eventId
+      });
+      if (!result.success) {
+        logger.warn(`Matrix reply send failed in ${roomId}: ${result.error}`);
+        return [];
+      }
+      const outbound = {
+        id: createUniqueUuid(this.runtime, result.eventId ?? `${roomId}:reply:${Date.now()}`),
+        entityId: this.runtime.agentId,
+        agentId: this.runtime.agentId,
+        roomId: coreRoomId,
+        content: {
+          text,
+          source: MATRIX_SERVICE_NAME,
+          channelType,
+          inReplyTo: coreMessage.id
+        },
+        createdAt: Date.now()
+      };
+      try {
+        await this.runtime.createMemory(outbound, "messages");
+      } catch (err) {
+        logger.warn(`Matrix outbound memory persist failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      return [outbound];
+    };
+    await this.runtime.messageService.handleMessage(this.runtime, coreMessage, callback);
+  }
+  async connect(state) {
+    await state.client.startClient({ initialSyncLimit: 10 });
+    state.connected = true;
+    await new Promise((resolve) => {
+      const listener = (syncState) => {
+        if (syncState === "PREPARED") {
+          state.client.removeListener(sdk.ClientEvent.Sync, listener);
+          resolve();
+        }
+      };
+      state.client.on(sdk.ClientEvent.Sync, listener);
+    });
+    for (const room of state.settings.rooms) {
+      try {
+        await this.joinRoom(room, state.accountId);
+      } catch (err) {
+        logger.warn(`Failed to join room ${room}: ${err}`);
+      }
+    }
+  }
+  async stop() {
+    for (const state of this.states.values()) {
+      if (state.cryptoSnapshotTimer) {
+        clearInterval(state.cryptoSnapshotTimer);
+        state.cryptoSnapshotTimer = undefined;
+      }
+      if (state.settings.encryption) {
+        await this.saveCryptoStore(state);
+      }
+      state.client.stopClient();
+      state.connected = false;
+      state.syncing = false;
+    }
+    logger.info("Matrix service stopped");
+  }
+  isConnected() {
+    const legacy = this;
+    const states = this.states ?? new Map;
+    if (states.size === 0 && typeof legacy.connected === "boolean") {
+      return legacy.connected && (legacy.syncing ?? true);
+    }
+    return Array.from(states.values()).some((state) => state.connected && state.syncing);
+  }
+  getAccountId(runtime) {
+    const legacy = this;
+    const states = this.states ?? new Map;
+    if (states.size === 0 && legacy.settings?.accountId) {
+      return normalizeMatrixAccountId(legacy.settings.accountId);
+    }
+    return normalizeMatrixAccountId(this.defaultAccountId !== DEFAULT_MATRIX_ACCOUNT_ID ? this.defaultAccountId : runtime ? resolveDefaultMatrixAccountId(runtime) : this.defaultAccountId);
+  }
+  getUserId() {
+    return this.getState().settings.userId;
+  }
+  getHomeserver() {
+    return this.getState().settings.homeserver;
+  }
+  async getJoinedRooms(accountId) {
+    const state = this.getState(accountId);
+    const rooms = state.client.getRooms();
+    return rooms.filter((room) => room.getMyMembership() === "join").map((room) => ({
+      roomId: room.roomId,
+      name: room.name,
+      topic: room.currentState.getStateEvents("m.room.topic", "")?.getContent()?.topic,
+      canonicalAlias: room.getCanonicalAlias() || undefined,
+      isEncrypted: room.hasEncryptionStateEvent(),
+      isDirect: false,
+      memberCount: room.getJoinedMemberCount()
+    }));
+  }
+  async getRoomMessages(matrixRoomId, limit, accountId) {
+    const state = this.getState(accountId);
+    const room = state.client.getRoom(matrixRoomId);
+    if (!room) {
+      return [];
+    }
+    const channelType = room.getJoinedMemberCount() <= 2 ? ChannelType.DM : ChannelType.GROUP;
+    const events = room.getLiveTimeline().getEvents();
+    const out = [];
+    for (let i = events.length - 1;i >= 0 && out.length < limit; i -= 1) {
+      const event = events[i];
+      const message = buildMatrixMessage(event, room);
+      if (message) {
+        const memory = matrixMessageToMemory(this.runtime, message, channelType);
+        memory.content.name = message.senderInfo.displayName || message.sender;
+        out.push(memory);
+        continue;
+      }
+      if (event.getType() === "m.room.encrypted" || event.isDecryptionFailure()) {
+        const sender = event.getSender() || "unknown";
+        const placeholder = matrixMessageToMemory(this.runtime, {
+          eventId: event.getId() || "",
+          roomId: matrixRoomId,
+          sender,
+          content: "\uD83D\uDD12 [end-to-end encrypted message this device can't read — its device isn't cross-signed, so senders withhold the decryption keys. This needs a one-time device verification (or the account password) to unblock; it is NOT a sync or pagination issue.]",
+          timestamp: event.getTs()
+        }, channelType);
+        placeholder.content.name = room.getMember(sender)?.name || sender;
+        out.push(placeholder);
+      }
+    }
+    return out;
+  }
+  async sendMessage(text, options) {
+    const state = this.getState(options?.accountId);
+    if (!state.connected || !state.syncing) {
+      throw new MatrixNotConnectedError;
+    }
+    const roomId = options?.roomId;
+    if (!roomId?.trim()) {
+      return { success: false, error: "Room ID is required" };
+    }
+    let resolvedRoomId = roomId.trim();
+    if (isValidMatrixRoomAlias(resolvedRoomId)) {
+      const resolved = await state.client.getRoomIdForAlias(resolvedRoomId);
+      resolvedRoomId = resolved.room_id;
+    }
+    const content = {
+      msgtype: sdk.MsgType.Text,
+      body: text
+    };
+    if (options?.formatted) {
+      content.format = "org.matrix.custom.html";
+      content.formatted_body = text;
+    }
+    if (options?.threadId || options?.replyTo) {
+      content["m.relates_to"] = {};
+      if (options.threadId) {
+        content["m.relates_to"].rel_type = sdk.RelationType.Thread;
+        content["m.relates_to"].event_id = options.threadId;
+      }
+      if (options.replyTo) {
+        content["m.relates_to"]["m.in_reply_to"] = {
+          event_id: options.replyTo
+        };
+      }
+    }
+    const response = await state.client.sendMessage(resolvedRoomId, content);
+    const eventId = response.event_id;
+    this.runtime.emitEvent("MATRIX_MESSAGE_SENT" /* MESSAGE_SENT */, {
+      roomId: resolvedRoomId,
+      eventId,
+      content: text,
+      runtime: this.runtime,
+      accountId: state.accountId
+    });
+    return {
+      success: true,
+      eventId,
+      roomId: resolvedRoomId
+    };
+  }
+  async sendReaction(roomId, eventId, emoji, accountId) {
+    const state = this.getState(accountId);
+    if (!state.connected || !state.syncing) {
+      throw new MatrixNotConnectedError;
+    }
+    const normalizedRoomId = roomId.trim();
+    const normalizedEventId = eventId.trim();
+    const normalizedEmoji = emoji.trim();
+    if (!normalizedRoomId || !normalizedEventId || !normalizedEmoji) {
+      return { success: false, error: "Room ID, event ID, and emoji are required" };
+    }
+    const content = {
+      "m.relates_to": {
+        rel_type: sdk.RelationType.Annotation,
+        event_id: normalizedEventId,
+        key: normalizedEmoji
+      }
+    };
+    const response = await state.client.sendEvent(normalizedRoomId, sdk.EventType.Reaction, content);
+    return {
+      success: true,
+      eventId: response.event_id,
+      roomId: normalizedRoomId
+    };
+  }
+  async joinRoom(roomIdOrAlias, accountId) {
+    const state = this.getState(accountId);
+    if (!state.connected || !state.syncing) {
+      throw new MatrixNotConnectedError;
+    }
+    const normalizedRoomIdOrAlias = roomIdOrAlias.trim();
+    if (!normalizedRoomIdOrAlias) {
+      throw new Error("Matrix room ID or alias is required");
+    }
+    const response = await state.client.joinRoom(normalizedRoomIdOrAlias);
+    const roomId = response.roomId;
+    logger.info(`Joined room ${roomId}`);
+    this.runtime.emitEvent("MATRIX_ROOM_JOINED" /* ROOM_JOINED */, {
+      room: { roomId },
+      runtime: this.runtime,
+      accountId: state.accountId
+    });
+    return roomId;
+  }
+  async leaveRoom(roomId, accountId) {
+    const state = this.getState(accountId);
+    if (!state.connected || !state.syncing) {
+      throw new MatrixNotConnectedError;
+    }
+    const normalizedRoomId = roomId.trim();
+    if (!normalizedRoomId) {
+      throw new Error("Matrix room ID is required");
+    }
+    await state.client.leave(normalizedRoomId);
+    logger.info(`Left room ${normalizedRoomId}`);
+    this.runtime.emitEvent("MATRIX_ROOM_LEFT" /* ROOM_LEFT */, {
+      roomId: normalizedRoomId,
+      runtime: this.runtime,
+      accountId: state.accountId
+    });
+  }
+  async sendTyping(roomId, typing, timeout = 30000, accountId) {
+    const state = this.getState(accountId);
+    if (!state.connected || !state.syncing) {
+      return;
+    }
+    await state.client.sendTyping(roomId, typing, timeout);
+  }
+  async sendReadReceipt(roomId, eventId, accountId) {
+    const state = this.getState(accountId);
+    if (!state.connected || !state.syncing) {
+      return;
+    }
+    await state.client.sendReadReceipt(new sdk.MatrixEvent({ event_id: eventId, room_id: roomId }));
+  }
+  async sendRoomMessage(roomIdOrAlias, content) {
+    const text = typeof content.text === "string" ? content.text.trim() : "";
+    if (!text) {
+      return;
+    }
+    await this.sendMessage(text, {
+      accountId: readMatrixAccountId(content) ?? this.getAccountId(),
+      roomId: roomIdOrAlias
+    });
+  }
+  async sendDirectMessage(roomIdOrAlias, content) {
+    await this.sendRoomMessage(roomIdOrAlias, content);
+  }
+  async handleSendMessage(runtime, target, content) {
+    const requestedAccountId = normalizeMatrixAccountId(target.accountId ?? readMatrixAccountId(content, target) ?? this.getAccountId());
+    this.getState(requestedAccountId);
+    const text = typeof content.text === "string" ? content.text.trim() : "";
+    if (!text) {
+      return;
+    }
+    const room = target.roomId ? await runtime.getRoom(target.roomId) : null;
+    const roomIdOrAlias = String(target.channelId || room?.channelId || (typeof target.roomId === "string" && (isValidMatrixRoomId(target.roomId) || isValidMatrixRoomAlias(target.roomId)) ? target.roomId : "")).trim();
+    if (!roomIdOrAlias) {
+      throw new Error("Matrix target is missing a room ID or alias");
+    }
+    await this.sendMessage(text, {
+      accountId: requestedAccountId,
+      roomId: roomIdOrAlias,
+      ...extractMatrixSendOptions(content, target)
+    });
+  }
+  getState(accountId = this.defaultAccountId) {
+    const normalized = normalizeMatrixAccountId(accountId);
+    const states = this.states ?? new Map;
+    const state = states.get(normalized);
+    if (state) {
+      return state;
+    }
+    const legacy = this;
+    if (legacy.settings) {
+      return {
+        accountId: normalizeMatrixAccountId(legacy.settings.accountId ?? normalized),
+        settings: legacy.settings,
+        client: legacy.client ?? {},
+        connected: legacy.connected ?? true,
+        syncing: legacy.syncing ?? true
+      };
+    }
+    throw new Error(`Matrix account '${normalized}' is not available in this service instance`);
+  }
+}
+// src/connector-account-provider.ts
+var MATRIX_PROVIDER_ID = "matrix";
+function accountKey(settings) {
+  if (settings.homeserver && settings.userId) {
+    return `${settings.homeserver}/${settings.userId}`;
+  }
+  return normalizeMatrixAccountId(settings.accountId);
+}
+function toConnectorAccount(settings) {
+  const now = Date.now();
+  const configured = Boolean(settings.homeserver && settings.userId && settings.accessToken);
+  const personal = settings.personal === true;
+  return {
+    id: normalizeMatrixAccountId(settings.accountId),
+    provider: MATRIX_PROVIDER_ID,
+    label: settings.userId || settings.accountId,
+    role: personal ? "OWNER" : "AGENT",
+    purpose: personal ? ["messaging", "reading"] : ["messaging"],
+    accessGate: personal ? "owner_binding" : "open",
+    status: settings.enabled !== false && configured ? "connected" : "disabled",
+    externalId: accountKey(settings),
+    displayHandle: settings.userId || undefined,
+    createdAt: now,
+    updatedAt: now,
+    metadata: {
+      homeserver: settings.homeserver ?? "",
+      userId: settings.userId ?? "",
+      deviceId: settings.deviceId ?? "",
+      encryption: settings.encryption ?? false,
+      autoJoin: settings.autoJoin ?? false,
+      personal
+    }
+  };
+}
+function createMatrixConnectorAccountProvider(runtime) {
+  return {
+    provider: MATRIX_PROVIDER_ID,
+    label: "Matrix",
+    listAccounts: async (_manager) => {
+      const ids = listMatrixAccountIds(runtime);
+      if (ids.length === 0) {
+        return [
+          toConnectorAccount(resolveMatrixAccountSettings(runtime, DEFAULT_MATRIX_ACCOUNT_ID))
+        ];
+      }
+      return ids.map((id) => toConnectorAccount(resolveMatrixAccountSettings(runtime, id)));
+    },
+    createAccount: async (input, _manager) => {
+      return {
+        ...input,
+        provider: MATRIX_PROVIDER_ID,
+        role: input.role ?? "AGENT",
+        purpose: input.purpose ?? ["messaging"],
+        accessGate: input.accessGate ?? "open",
+        status: input.status ?? "pending"
+      };
+    },
+    patchAccount: async (_accountId, patch, _manager) => {
+      return { ...patch, provider: MATRIX_PROVIDER_ID };
+    },
+    deleteAccount: async (_accountId, _manager) => {}
+  };
+}
+
+// src/workflow-credential-provider.ts
+import { Service as Service2 } from "@elizaos/core";
+var WORKFLOW_CREDENTIAL_PROVIDER_TYPE = "workflow_credential_provider";
+var SUPPORTED = ["matrixApi"];
+
+class MatrixWorkflowCredentialProvider extends Service2 {
+  static serviceType = WORKFLOW_CREDENTIAL_PROVIDER_TYPE;
+  capabilityDescription = "Supplies Matrix credentials to the workflow plugin.";
+  static async start(runtime) {
+    return new MatrixWorkflowCredentialProvider(runtime);
+  }
+  async stop() {}
+  async resolve(_userId, credType) {
+    if (credType !== "matrixApi")
+      return null;
+    const accessToken = this.runtime.getSetting("MATRIX_ACCESS_TOKEN");
+    const homeserver = this.runtime.getSetting("MATRIX_HOMESERVER");
+    if (!accessToken?.trim() || !homeserver?.trim())
+      return null;
+    return {
+      status: "credential_data",
+      data: { accessToken: accessToken.trim(), homeserverUrl: homeserver.trim() }
+    };
+  }
+  checkCredentialTypes(credTypes) {
+    return {
+      supported: credTypes.filter((t) => SUPPORTED.includes(t)),
+      unsupported: credTypes.filter((t) => !SUPPORTED.includes(t))
+    };
+  }
+}
+
+// src/index.ts
+var matrixPlugin = {
+  name: "matrix",
+  description: "Matrix messaging integration plugin for ElizaOS with E2EE support",
+  services: [MatrixService, MatrixWorkflowCredentialProvider],
+  actions: [],
+  providers: [],
+  tests: [],
+  autoEnable: {
+    connectorKeys: ["matrix"]
+  },
+  init: async (_config, runtime) => {
+    try {
+      const manager = getConnectorAccountManager(runtime);
+      manager.registerProvider(createMatrixConnectorAccountProvider(runtime));
+    } catch (err) {
+      logger2.warn({
+        src: "plugin:matrix",
+        err: err instanceof Error ? err.message : String(err)
+      }, "Failed to register Matrix provider with ConnectorAccountManager");
+    }
+    const homeserver = runtime.getSetting("MATRIX_HOMESERVER");
+    const userId = runtime.getSetting("MATRIX_USER_ID");
+    const accessToken = runtime.getSetting("MATRIX_ACCESS_TOKEN");
+    logger2.info("=".repeat(60));
+    logger2.info("Matrix Plugin Configuration");
+    logger2.info("=".repeat(60));
+    logger2.info(`  Homeserver: ${homeserver ? `✓ ${homeserver}` : "✗ Missing (required)"}`);
+    logger2.info(`  User ID: ${userId ? `✓ ${userId}` : "✗ Missing (required)"}`);
+    logger2.info(`  Access Token: ${accessToken ? "✓ Set" : "✗ Missing (required)"}`);
+    logger2.info("=".repeat(60));
+    const missing = [];
+    if (!homeserver)
+      missing.push("MATRIX_HOMESERVER");
+    if (!userId)
+      missing.push("MATRIX_USER_ID");
+    if (!accessToken)
+      missing.push("MATRIX_ACCESS_TOKEN");
+    if (missing.length > 0) {
+      logger2.warn(`Matrix plugin: Missing required configuration: ${missing.join(", ")}`);
+    }
+    const deviceId = runtime.getSetting("MATRIX_DEVICE_ID");
+    const rooms = runtime.getSetting("MATRIX_ROOMS");
+    const autoJoin = runtime.getSetting("MATRIX_AUTO_JOIN");
+    const encryption = runtime.getSetting("MATRIX_ENCRYPTION");
+    const requireMention = runtime.getSetting("MATRIX_REQUIRE_MENTION");
+    if (deviceId) {
+      logger2.info(`  Device ID: ${deviceId}`);
+    }
+    if (rooms) {
+      logger2.info(`  Auto-join Rooms: ${rooms}`);
+    }
+    if (autoJoin === "true") {
+      logger2.info("  Auto-join Invites: ✓ Enabled");
+    }
+    if (encryption === "true") {
+      logger2.info("  End-to-End Encryption: ✓ Enabled");
+    }
+    if (requireMention === "true") {
+      logger2.info("  Require Mention: ✓ Enabled (will only respond to mentions in rooms)");
+    }
+  },
+  async dispose(runtime) {
+    await MatrixService.stopRuntime(runtime);
+  }
+};
+var src_default = matrixPlugin;
+export {
+  resolveMatrixAccountSettings,
+  resolveDefaultMatrixAccountId,
+  readMatrixAccountId,
+  normalizeMatrixAccountId,
+  matrixMxcToHttp,
+  listMatrixAccountIds,
+  isValidMatrixUserId,
+  isValidMatrixRoomId,
+  isValidMatrixRoomAlias,
+  getMatrixUserDisplayName,
+  getMatrixServerpart,
+  getMatrixLocalpart,
+  src_default as default,
+  MatrixServiceNotInitializedError,
+  MatrixService,
+  MatrixPluginError,
+  MatrixNotConnectedError,
+  MatrixEventTypes,
+  MatrixConfigurationError,
+  MatrixApiError,
+  MAX_MATRIX_MESSAGE_LENGTH,
+  MATRIX_SERVICE_NAME,
+  DEFAULT_MATRIX_ACCOUNT_ID
+};
+
+//# debugId=FBDBF44969C9B46A64756E2164756E21