@arbidocs/cli 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -2,111 +2,3353 @@
 'use strict';
 
 var commander = require('commander');
-var fs = require('fs');
-var path = require('path');
-var os = require('os');
-require('fake-indexeddb/auto');
+var core = require('@arbidocs/core');
 var sdk = require('@arbidocs/sdk');
 var prompts = require('@inquirer/prompts');
+var fs = require('fs');
+var path2 = require('path');
+var child_process = require('child_process');
+var module$1 = require('module');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var fs__default = /*#__PURE__*/_interopDefault(fs);
-var path__default = /*#__PURE__*/_interopDefault(path);
-var os__default = /*#__PURE__*/_interopDefault(os);
+var path2__default = /*#__PURE__*/_interopDefault(path2);
+
+var store = new core.FileConfigStore();
+function getConfig() {
+  return store.getConfig();
+}
+function updateConfig(updates) {
+  store.updateConfig(updates);
+}
+function requireConfig() {
+  try {
+    return store.requireConfig();
+  } catch (err) {
+    if (err instanceof core.ArbiError) {
+      console.error(err.message);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+function getCredentials() {
+  return store.getCredentials();
+}
+function saveCredentials(creds) {
+  store.saveCredentials(creds);
+}
+function deleteCredentials() {
+  store.deleteCredentials();
+}
+function getChatSession() {
+  return store.getChatSession();
+}
+function updateChatSession(updates) {
+  store.updateChatSession(updates);
+}
+function clearChatSession() {
+  store.clearChatSession();
+}
+
+// src/commands/config-cmd.ts
+function registerConfigCommand(program2) {
+  const config = program2.command("config").description("Manage CLI configuration");
+  config.command("set-url <url>").description("Set the ARBI server URL").action((url) => {
+    try {
+      const parsed = new URL(url);
+      const deploymentDomain = parsed.hostname;
+      updateConfig({ baseUrl: url.replace(/\/+$/, ""), deploymentDomain });
+      console.log(`Server URL: ${url}`);
+      console.log(`Domain:     ${deploymentDomain}`);
+    } catch {
+      console.error(`Invalid URL: ${url}`);
+      process.exit(1);
+    }
+  });
+}
+
+// ../../node_modules/fake-indexeddb/build/esm/lib/errors.js
+var 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.",
+  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.",
+  VersionError: "An attempt was made to open a database using a lower version than the existing version."
+};
+var setErrorCode = (error, value) => {
+  Object.defineProperty(error, "code", {
+    value,
+    writable: false,
+    enumerable: true,
+    configurable: false
+  });
+};
+var AbortError = class extends DOMException {
+  constructor(message = messages.AbortError) {
+    super(message, "AbortError");
+  }
+};
+var ConstraintError = class extends DOMException {
+  constructor(message = messages.ConstraintError) {
+    super(message, "ConstraintError");
+  }
+};
+var DataError = class extends DOMException {
+  constructor(message = messages.DataError) {
+    super(message, "DataError");
+    setErrorCode(this, 0);
+  }
+};
+var InvalidAccessError = class extends DOMException {
+  constructor(message = messages.InvalidAccessError) {
+    super(message, "InvalidAccessError");
+  }
+};
+var InvalidStateError = class extends DOMException {
+  constructor(message = messages.InvalidStateError) {
+    super(message, "InvalidStateError");
+    setErrorCode(this, 11);
+  }
+};
+var NotFoundError = class extends DOMException {
+  constructor(message = messages.NotFoundError) {
+    super(message, "NotFoundError");
+  }
+};
+var ReadOnlyError = class extends DOMException {
+  constructor(message = messages.ReadOnlyError) {
+    super(message, "ReadOnlyError");
+  }
+};
+var SyntaxError = class extends DOMException {
+  constructor(message = messages.VersionError) {
+    super(message, "SyntaxError");
+    setErrorCode(this, 12);
+  }
+};
+var TransactionInactiveError = class extends DOMException {
+  constructor(message = messages.TransactionInactiveError) {
+    super(message, "TransactionInactiveError");
+    setErrorCode(this, 0);
+  }
+};
+var VersionError = class extends DOMException {
+  constructor(message = messages.VersionError) {
+    super(message, "VersionError");
+  }
+};
+
+// ../../node_modules/fake-indexeddb/build/esm/lib/isSharedArrayBuffer.js
+function isSharedArrayBuffer(input2) {
+  return typeof SharedArrayBuffer !== "undefined" && input2 instanceof SharedArrayBuffer;
+}
+
+// ../../node_modules/fake-indexeddb/build/esm/lib/valueToKeyWithoutThrowing.js
+var INVALID_TYPE = /* @__PURE__ */ Symbol("INVALID_TYPE");
+var INVALID_VALUE = /* @__PURE__ */ Symbol("INVALID_VALUE");
+var valueToKeyWithoutThrowing = (input2, seen) => {
+  if (typeof input2 === "number") {
+    if (isNaN(input2)) {
+      return INVALID_VALUE;
+    }
+    return input2;
+  } else if (Object.prototype.toString.call(input2) === "[object Date]") {
+    const ms = input2.valueOf();
+    if (isNaN(ms)) {
+      return INVALID_VALUE;
+    }
+    return new Date(ms);
+  } else if (typeof input2 === "string") {
+    return input2;
+  } else if (
+    // https://w3c.github.io/IndexedDB/#ref-for-dfn-buffer-source-type
+    input2 instanceof ArrayBuffer || isSharedArrayBuffer(input2) || typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView && ArrayBuffer.isView(input2)
+  ) {
+    if ("detached" in input2 ? input2.detached : input2.byteLength === 0) {
+      return INVALID_VALUE;
+    }
+    let arrayBuffer;
+    let offset = 0;
+    let length = 0;
+    if (input2 instanceof ArrayBuffer || isSharedArrayBuffer(input2)) {
+      arrayBuffer = input2;
+      length = input2.byteLength;
+    } else {
+      arrayBuffer = input2.buffer;
+      offset = input2.byteOffset;
+      length = input2.byteLength;
+    }
+    return arrayBuffer.slice(offset, offset + length);
+  } else if (Array.isArray(input2)) {
+    if (seen === void 0) {
+      seen = /* @__PURE__ */ new Set();
+    } else if (seen.has(input2)) {
+      return INVALID_VALUE;
+    }
+    seen.add(input2);
+    let hasInvalid = false;
+    const keys = Array.from({
+      length: input2.length
+    }, (_, i) => {
+      if (hasInvalid) {
+        return;
+      }
+      const hop = Object.hasOwn(input2, i);
+      if (!hop) {
+        hasInvalid = true;
+        return;
+      }
+      const entry = input2[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;
+  }
+};
+var valueToKeyWithoutThrowing_default = valueToKeyWithoutThrowing;
+
+// ../../node_modules/fake-indexeddb/build/esm/lib/valueToKey.js
+var valueToKey = (input2, seen) => {
+  const result = valueToKeyWithoutThrowing_default(input2, seen);
+  if (result === INVALID_VALUE || result === INVALID_TYPE) {
+    throw new DataError();
+  }
+  return result;
+};
+var valueToKey_default = valueToKey;
+
+// ../../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();
+};
+var cmp = (first, second) => {
+  if (second === void 0) {
+    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;
+};
+var cmp_default = cmp;
+
+// ../../node_modules/fake-indexeddb/build/esm/FDBKeyRange.js
+var 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, void 0, open, true);
+  }
+  static upperBound(upper, open = false) {
+    if (arguments.length === 0) {
+      throw new TypeError();
+    }
+    upper = valueToKey_default(upper);
+    return new _FDBKeyRange(void 0, 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;
+  }
+  // https://w3c.github.io/IndexedDB/#dom-idbkeyrange-includes
+  includes(key) {
+    if (arguments.length === 0) {
+      throw new TypeError();
+    }
+    key = valueToKey_default(key);
+    if (this.lower !== void 0) {
+      const cmpResult = cmp_default(this.lower, key);
+      if (cmpResult === 1 || cmpResult === 0 && this.lowerOpen) {
+        return false;
+      }
+    }
+    if (this.upper !== void 0) {
+      const cmpResult = cmp_default(this.upper, key);
+      if (cmpResult === -1 || cmpResult === 0 && this.upperOpen) {
+        return false;
+      }
+    }
+    return true;
+  }
+  get [Symbol.toStringTag]() {
+    return "IDBKeyRange";
+  }
+};
+var FDBKeyRange_default = FDBKeyRange;
+
+// ../../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 !== void 0 && 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
+  };
+};
+var extractKey_default = extractKey;
+
+// ../../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";
+  }
+}
 
-var CONFIG_DIR = path__default.default.join(os__default.default.homedir(), ".arbi");
-var CONFIG_FILE = path__default.default.join(CONFIG_DIR, "config.json");
-var CREDENTIALS_FILE = path__default.default.join(CONFIG_DIR, "credentials.json");
-function ensureConfigDir() {
-  if (!fs__default.default.existsSync(CONFIG_DIR)) {
-    fs__default.default.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+// ../../node_modules/fake-indexeddb/build/esm/FDBCursor.js
+var getEffectiveObjectStore = (cursor) => {
+  if (cursor.source instanceof FDBObjectStore_default) {
+    return cursor.source;
+  }
+  return cursor.source.objectStore;
+};
+var makeKeyRange = (range, lowers, uppers) => {
+  let lower = range !== void 0 ? range.lower : void 0;
+  let upper = range !== void 0 ? range.upper : void 0;
+  for (const lowerTemp of lowers) {
+    if (lowerTemp === void 0) {
+      continue;
+    }
+    if (lower === void 0 || cmp_default(lower, lowerTemp) === 1) {
+      lower = lowerTemp;
+    }
+  }
+  for (const upperTemp of uppers) {
+    if (upperTemp === void 0) {
+      continue;
+    }
+    if (upper === void 0 || cmp_default(upper, upperTemp) === -1) {
+      upper = upperTemp;
+    }
+  }
+  if (lower !== void 0 && upper !== void 0) {
+    return FDBKeyRange_default.bound(lower, upper);
+  }
+  if (lower !== void 0) {
+    return FDBKeyRange_default.lowerBound(lower);
+  }
+  if (upper !== void 0) {
+    return FDBKeyRange_default.upperBound(upper);
+  }
+};
+var FDBCursor = class {
+  _gotValue = false;
+  _position = void 0;
+  // Key of previously returned record
+  _objectStorePosition = void 0;
+  _keyOnly = false;
+  _key = void 0;
+  _primaryKey = void 0;
+  constructor(source, range, direction = "next", request, keyOnly = false) {
+    this._range = range;
+    this._source = source;
+    this._direction = direction;
+    this._request = request;
+    this._keyOnly = keyOnly;
+  }
+  // Read only properties
+  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) {
+  }
+  // https://w3c.github.io/IndexedDB/#iterate-a-cursor
+  _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 !== void 0 ? cmp_default(record.key, key) : void 0;
+        const cmpResultPosition = this._position !== void 0 ? cmp_default(record.key, this._position) : void 0;
+        if (key !== void 0) {
+          if (cmpResultKey === -1) {
+            continue;
+          }
+        }
+        if (primaryKey !== void 0) {
+          if (cmpResultKey === -1) {
+            continue;
+          }
+          const cmpResultPrimaryKey = cmp_default(record.value, primaryKey);
+          if (cmpResultKey === 0 && cmpResultPrimaryKey === -1) {
+            continue;
+          }
+        }
+        if (this._position !== void 0 && sourceIsObjectStore) {
+          if (cmpResultPosition !== 1) {
+            continue;
+          }
+        }
+        if (this._position !== void 0 && !sourceIsObjectStore) {
+          if (cmpResultPosition === -1) {
+            continue;
+          }
+          if (cmpResultPosition === 0 && cmp_default(record.value, this._objectStorePosition) !== 1) {
+            continue;
+          }
+        }
+        if (this._range !== void 0) {
+          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 !== void 0) {
+          if (cmp_default(record.key, key) === -1) {
+            continue;
+          }
+        }
+        if (this._position !== void 0) {
+          if (cmp_default(record.key, this._position) !== 1) {
+            continue;
+          }
+        }
+        if (this._range !== void 0) {
+          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 !== void 0 ? cmp_default(record.key, key) : void 0;
+        const cmpResultPosition = this._position !== void 0 ? cmp_default(record.key, this._position) : void 0;
+        if (key !== void 0) {
+          if (cmpResultKey === 1) {
+            continue;
+          }
+        }
+        if (primaryKey !== void 0) {
+          if (cmpResultKey === 1) {
+            continue;
+          }
+          const cmpResultPrimaryKey = cmp_default(record.value, primaryKey);
+          if (cmpResultKey === 0 && cmpResultPrimaryKey === 1) {
+            continue;
+          }
+        }
+        if (this._position !== void 0 && sourceIsObjectStore) {
+          if (cmpResultPosition !== -1) {
+            continue;
+          }
+        }
+        if (this._position !== void 0 && !sourceIsObjectStore) {
+          if (cmpResultPosition === 1) {
+            continue;
+          }
+          if (cmpResultPosition === 0 && cmp_default(record.value, this._objectStorePosition) !== -1) {
+            continue;
+          }
+        }
+        if (this._range !== void 0) {
+          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 !== void 0) {
+          if (cmp_default(record.key, key) === 1) {
+            continue;
+          }
+        }
+        if (this._position !== void 0) {
+          if (cmp_default(record.key, this._position) !== -1) {
+            continue;
+          }
+        }
+        if (this._range !== void 0) {
+          if (!this._range.includes(record.key)) {
+            continue;
+          }
+        }
+        tempRecord = record;
+        break;
+      }
+      if (tempRecord) {
+        foundRecord = records.get(tempRecord.key);
+      }
+    }
+    let result;
+    if (!foundRecord) {
+      this._key = void 0;
+      if (!sourceIsObjectStore) {
+        this._objectStorePosition = void 0;
+      }
+      if (!this._keyOnly && this.toString() === "[object IDBCursorWithValue]") {
+        this.value = void 0;
+      }
+      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;
+  }
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBCursor-update-IDBRequest-any-value
+  update(value) {
+    if (value === void 0) {
+      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
+    });
+  }
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBCursor-advance-void-unsigned-long-count
+  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;
+  }
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBCursor-continue-void-any-key
+  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 !== void 0) {
+      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;
+  }
+  // hthttps://w3c.github.io/IndexedDB/#dom-idbcursor-continueprimarykey
+  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 === void 0 || primaryKey === void 0) {
+      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";
+  }
+};
+var FDBCursor_default = FDBCursor;
+
+// ../../node_modules/fake-indexeddb/build/esm/FDBCursorWithValue.js
+var FDBCursorWithValue = class extends FDBCursor_default {
+  value = void 0;
+  constructor(source, range, direction, request) {
+    super(source, range, direction, request);
+  }
+  get [Symbol.toStringTag]() {
+    return "IDBCursorWithValue";
+  }
+};
+var FDBCursorWithValue_default = FDBCursorWithValue;
+
+// ../../node_modules/fake-indexeddb/build/esm/lib/FakeEventTarget.js
+var stopped = (event, listener) => {
+  return event.immediatePropagationStopped || event.eventPhase === event.CAPTURING_PHASE && listener.capture === false || event.eventPhase === event.BUBBLING_PHASE && listener.capture === true;
+};
+var 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 === void 0) {
+    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);
+  }
+};
+var FakeEventTarget = class {
+  listeners = [];
+  // These will be overridden in individual subclasses and made not readonly
+  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);
+  }
+  // http://www.w3.org/TR/dom/#dispatching-events
+  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 FakeEventTarget_default = FakeEventTarget;
+
+// ../../node_modules/fake-indexeddb/build/esm/FDBRequest.js
+var FDBRequest = class 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";
+  }
+};
+var FDBRequest_default = FDBRequest;
+
+// ../../node_modules/fake-indexeddb/build/esm/lib/FakeDOMStringList.js
+var FakeDOMStringList = class {
+  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]();
+  }
+  // Handled by proxy
+  // Used internally, should not be used by others. I could maybe get rid of these and replace rather than mutate, but too lazy to check the spec.
+  _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;
+  }
+};
+var FakeDOMStringList_default = FakeDOMStringList;
+
+// ../../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 === void 0) {
+    if (nullDisallowedFlag) {
+      throw new DataError();
+    }
+    return new FDBKeyRange_default(void 0, void 0, false, false);
+  }
+  const key = valueToKey_default(value);
+  return FDBKeyRange_default.only(key);
+};
+var valueToKeyRange_default = valueToKeyRange;
+
+// ../../node_modules/fake-indexeddb/build/esm/lib/getKeyPath.js
+var convertKey = (key) => typeof key === "object" && key ? key + "" : key;
+function getKeyPath(keyPath) {
+  return Array.isArray(keyPath) ? keyPath.map(convertKey) : convertKey(keyPath);
+}
+
+// ../../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;
+};
+var isPotentiallyValidKeyRange_default = isPotentiallyValidKeyRange;
+
+// ../../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);
+  }
+};
+var enforceRange_default = enforceRange;
+
+// ../../node_modules/fake-indexeddb/build/esm/lib/extractGetAllOptions.js
+var extractGetAllOptions = (queryOrOptions, count, numArguments) => {
+  let query;
+  let direction;
+  if (queryOrOptions === void 0 || queryOrOptions === null || isPotentiallyValidKeyRange_default(queryOrOptions)) {
+    query = queryOrOptions;
+    if (numArguments > 1 && count !== void 0) {
+      count = enforceRange_default(count, "unsigned long");
+    }
+  } else {
+    const getAllOptions = queryOrOptions;
+    if (getAllOptions.query !== void 0) {
+      query = getAllOptions.query;
+    }
+    if (getAllOptions.count !== void 0) {
+      count = enforceRange_default(getAllOptions.count, "unsigned long");
+    }
+    if (getAllOptions.direction !== void 0) {
+      direction = getAllOptions.direction;
+    }
+  }
+  return {
+    query,
+    count,
+    direction
+  };
+};
+var extractGetAllOptions_default = extractGetAllOptions;
+
+// ../../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();
+  }
+};
+var FDBIndex = class {
+  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;
+  }
+  // https://w3c.github.io/IndexedDB/#dom-idbindex-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);
+      });
+    }
+  }
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBIndex-openCursor-IDBRequest-any-range-IDBCursorDirection-direction
+  openCursor(range, direction) {
+    confirmActiveTransaction(this);
+    if (range === null) {
+      range = void 0;
+    }
+    if (range !== void 0 && !(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
+    });
+  }
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBIndex-openKeyCursor-IDBRequest-any-range-IDBCursorDirection-direction
+  openKeyCursor(range, direction) {
+    confirmActiveTransaction(this);
+    if (range === null) {
+      range = void 0;
+    }
+    if (range !== void 0 && !(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
+    });
+  }
+  // http://w3c.github.io/IndexedDB/#dom-idbindex-getall
+  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
+    });
+  }
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBIndex-getKey-IDBRequest-any-key
+  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
+    });
+  }
+  // http://w3c.github.io/IndexedDB/#dom-idbindex-getallkeys
+  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
+    });
+  }
+  // https://www.w3.org/TR/IndexedDB/#dom-idbobjectstore-getallrecords
+  getAllRecords(options) {
+    let query;
+    let count;
+    let direction;
+    if (options !== void 0) {
+      if (options.query !== void 0) {
+        query = options.query;
+      }
+      if (options.count !== void 0) {
+        count = enforceRange_default(options.count, "unsigned long");
+      }
+      if (options.direction !== void 0) {
+        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
+    });
+  }
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBIndex-count-IDBRequest-any-key
+  count(key) {
+    confirmActiveTransaction(this);
+    if (key === null) {
+      key = void 0;
+    }
+    if (key !== void 0 && !(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";
+  }
+};
+var FDBIndex_default = FDBIndex;
+
+// ../../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);
+};
+var canInjectKey_default = canInjectKey;
+
+// ../../node_modules/fake-indexeddb/build/esm/FDBRecord.js
+var FDBRecord = class {
+  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";
+  }
+};
+var FDBRecord_default = FDBRecord;
+
+// ../../node_modules/fake-indexeddb/build/esm/lib/binarySearchTree.js
+var MAX_TOMBSTONE_FACTOR = 2 / 3;
+var EVERYTHING_KEY_RANGE = new FDBKeyRange_default(void 0, void 0, false, false);
+var BinarySearchTree = class {
+  _numTombstones = 0;
+  _numNodes = 0;
+  /**
+   *
+   * @param keysAreUnique - whether keys can be unique, and thus whether we cn skip checking `record.value` when
+   * comparing. This is basically used to distinguish ObjectStores (where the value is the entire object, not used
+   * as a key) from non-unique Indexes (where both the key and the value are meaningful keys used for sorting)
+   */
+  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 a new record, and return the overwritten record if an overwrite occurred.
+   * @param record
+   * @param noOverwrite - throw a ConstraintError in case of overwrite
+   */
+  put(record, noOverwrite = false) {
+    if (!this._root) {
+      this._root = {
+        record,
+        left: void 0,
+        right: void 0,
+        parent: void 0,
+        deleted: false,
+        // the root is always black in a red-black tree
+        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: void 0,
+          right: void 0,
+          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: void 0,
+          right: void 0,
+          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, void 0, 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 === void 0 ? -1 : cmp_default(lower, key);
+    const upperComparison = upper === void 0 ? 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);
+  }
+  // based on https://en.wikipedia.org/wiki/Red%E2%80%93black_tree#Insertion
+  _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);
+  }
+  // based on https://en.wikipedia.org/wiki/Red%E2%80%93black_tree#Implementation
+  _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 the whole tree from scratch, used to avoid too many deletion tombstones accumulating
+  _rebuild(records, parent, red) {
+    const {
+      length
+    } = records;
+    if (!length) {
+      return void 0;
+    }
+    const mid = length >>> 1;
+    const node = {
+      record: records[mid],
+      left: void 0,
+      right: void 0,
+      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;
+  }
+};
+
+// ../../node_modules/fake-indexeddb/build/esm/lib/RecordStore.js
+var RecordStore = class {
+  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 a new record, and return the overwritten record if an overwrite occurred.
+   * @param newRecord
+   * @param noOverwrite - throw a ConstraintError in case of overwrite
+   */
+  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 = void 0;
+          return {
+            next: () => {
+              let current2 = next();
+              while (!current2.done && previousValue !== void 0 && 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 = RecordStore;
+
+// ../../node_modules/fake-indexeddb/build/esm/lib/Index.js
+var Index = class {
+  deleted = false;
+  // Initialized should be used to decide whether to throw an error or abort the versionchange transaction when there is a
+  // constraint
+  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);
+  }
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-retrieving-a-value-from-an-index
+  getKey(key) {
+    const record = this.records.get(key);
+    return record !== void 0 ? record.value : void 0;
+  }
+  // http://w3c.github.io/IndexedDB/#retrieve-multiple-referenced-values-from-an-index
+  getAllKeys(range, count, direction) {
+    if (count === void 0 || 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;
+  }
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#index-referenced-value-retrieval-operation
+  getValue(key) {
+    const record = this.records.get(key);
+    return record !== void 0 ? this.rawObjectStore.getValue(record.value) : void 0;
+  }
+  // http://w3c.github.io/IndexedDB/#retrieve-multiple-referenced-values-from-an-index
+  getAllValues(range, count, direction) {
+    if (count === void 0 || 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;
+  }
+  // https://www.w3.org/TR/IndexedDB/#dom-idbindex-getallrecords
+  getAllRecords(range, count, direction) {
+    if (count === void 0 || 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;
+  }
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-storing-a-record-into-an-object-store (step 7)
+  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 = Index;
+
+// ../../node_modules/fake-indexeddb/build/esm/lib/validateKeyPath.js
+var validateKeyPath = (keyPath, parent) => {
+  if (keyPath !== void 0 && 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 = (
+        // eslint-disable-next-line no-misleading-character-class
+        /^(?:[$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();
+};
+var validateKeyPath_default = validateKeyPath;
+
+// ../../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();
+  }
+};
+var buildRecordAddPut = (objectStore, value, key) => {
+  confirmActiveTransaction2(objectStore);
+  if (objectStore.transaction.mode === "readonly") {
+    throw new ReadOnlyError();
+  }
+  if (objectStore.keyPath !== null) {
+    if (key !== void 0) {
+      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 === void 0) {
+    throw new DataError();
+  }
+  if (key !== void 0) {
+    key = valueToKey_default(key);
+  }
+  return {
+    key,
+    value: clone
+  };
+};
+var FDBObjectStore = class {
+  _indexesCache = /* @__PURE__ */ 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;
+  }
+  // http://w3c.github.io/IndexedDB/#dom-idbobjectstore-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
+    });
+  }
+  // http://w3c.github.io/IndexedDB/#dom-idbobjectstore-getall
+  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
+    });
+  }
+  // http://w3c.github.io/IndexedDB/#dom-idbobjectstore-getkey
+  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
+    });
+  }
+  // http://w3c.github.io/IndexedDB/#dom-idbobjectstore-getallkeys
+  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
+    });
+  }
+  // https://www.w3.org/TR/IndexedDB/#dom-idbobjectstore-getallrecords
+  getAllRecords(options) {
+    let query;
+    let count;
+    let direction;
+    if (options !== void 0) {
+      if (options.query !== void 0) {
+        query = options.query;
+      }
+      if (options.count !== void 0) {
+        count = enforceRange_default(options.count, "unsigned long");
+      }
+      if (options.direction !== void 0) {
+        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 = void 0;
+    }
+    if (range !== void 0 && !(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 = void 0;
+    }
+    if (range !== void 0 && !(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
+    });
+  }
+  // tslint:-next-line max-line-length
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBObjectStore-createIndex-IDBIndex-DOMString-name-DOMString-sequence-DOMString--keyPath-IDBIndexParameters-optionalParameters
+  createIndex(name, keyPath, optionalParameters = {}) {
+    if (arguments.length < 2) {
+      throw new TypeError();
+    }
+    const multiEntry = optionalParameters.multiEntry !== void 0 ? optionalParameters.multiEntry : false;
+    const unique = optionalParameters.unique !== void 0 ? 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);
+  }
+  // https://w3c.github.io/IndexedDB/#dom-idbobjectstore-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 !== void 0) {
+      return index;
+    }
+    const rawIndex = this._rawObjectStore.rawIndexes.get(name);
+    if (!this.indexNames.contains(name) || rawIndex === void 0) {
+      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 === void 0) {
+      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
+    });
+  }
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBObjectStore-count-IDBRequest-any-key
+  count(key) {
+    confirmActiveTransaction2(this);
+    if (key === null) {
+      key = void 0;
+    }
+    if (key !== void 0 && !(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";
+  }
+};
+var FDBObjectStore_default = FDBObjectStore;
+
+// ../../node_modules/fake-indexeddb/build/esm/lib/FakeEvent.js
+var Event = class {
+  eventPath = [];
+  NONE = 0;
+  CAPTURING_PHASE = 1;
+  AT_TARGET = 2;
+  BUBBLING_PHASE = 3;
+  // Flags
+  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 !== void 0 ? eventInitDict.bubbles : false;
+    this.cancelable = eventInitDict.cancelable !== void 0 ? eventInitDict.cancelable : false;
+  }
+  preventDefault() {
+    if (this.cancelable) {
+      this.canceled = true;
+    }
+  }
+  stopPropagation() {
+    this.propagationStopped = true;
+  }
+  stopImmediatePropagation() {
+    this.propagationStopped = true;
+    this.immediatePropagationStopped = true;
+  }
+};
+var FakeEvent_default = Event;
+
+// ../../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 void 0;
+  }
+}
+var schedulerPostTask = typeof scheduler !== "undefined" && ((fn) => scheduler.postTask(fn));
+var doSetTimeout = (fn) => setTimeout(fn, 0);
+var queueTask = (fn) => {
+  const setImmediate = globalThis.setImmediate || getSetImmediateFromJsdom() || schedulerPostTask || doSetTimeout;
+  setImmediate(fn);
+};
+
+// ../../node_modules/fake-indexeddb/build/esm/FDBTransaction.js
+var prioritizedListenerTypes = ["error", "abort", "complete"];
+var FDBTransaction = class extends FakeEventTarget_default {
+  _state = "active";
+  _started = false;
+  _rollbackLog = [];
+  _objectStoresCache = /* @__PURE__ */ new Map();
+  _openRequest = null;
+  error = null;
+  onabort = null;
+  oncomplete = null;
+  onerror = null;
+  _prioritizedListeners = /* @__PURE__ */ new Map();
+  _requests = [];
+  _createdIndexes = /* @__PURE__ */ new Set();
+  _createdObjectStores = /* @__PURE__ */ 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)?.();
+      });
+    }
+  }
+  // https://w3c.github.io/IndexedDB/#abort-transaction
+  _abort(errName) {
+    for (const f of this._rollbackLog.reverse()) {
+      f();
+    }
+    if (errName !== null) {
+      const e = new DOMException(void 0, errName);
+      this.error = e;
+    }
+    for (const {
+      request
+    } of this._requests) {
+      if (request.readyState !== "done") {
+        request.readyState = "done";
+        if (request.source) {
+          queueTask(() => {
+            request.result = void 0;
+            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 = void 0;
+      }
+    });
+    this._state = "finished";
+  }
+  abort() {
+    if (this._state === "committing" || this._state === "finished") {
+      throw new InvalidStateError();
+    }
+    this._state = "active";
+    this._abort(null);
+  }
+  // http://w3c.github.io/IndexedDB/#dom-idbtransaction-objectstore
+  objectStore(name) {
+    if (this._state !== "active") {
+      throw new InvalidStateError();
+    }
+    const objectStore = this._objectStoresCache.get(name);
+    if (objectStore !== void 0) {
+      return objectStore;
+    }
+    const rawObjectStore = this.db._rawDatabase.rawObjectStores.get(name);
+    if (!this._scope.has(name) || rawObjectStore === void 0) {
+      throw new NotFoundError();
+    }
+    const objectStore2 = new FDBObjectStore_default(this, rawObjectStore);
+    this._objectStoresCache.set(name, objectStore2);
+    return objectStore2;
+  }
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-asynchronously-executing-a-request
+  _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 = void 0;
+          if (this._state === "inactive") {
+            this._state = "active";
+          }
+          event = new FakeEvent_default("success", {
+            bubbles: false,
+            cancelable: false
+          });
+        } catch (err) {
+          request.readyState = "done";
+          request.result = void 0;
+          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 = void 0;
+          }
+        }
+        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";
+  }
+};
+var FDBTransaction_default = FDBTransaction;
+
+// ../../node_modules/fake-indexeddb/build/esm/lib/KeyGenerator.js
+var MAX_KEY = 9007199254740992;
+var KeyGenerator = class {
+  // This is kind of wrong. Should start at 1 and increment only after record is saved
+  num = 0;
+  next() {
+    if (this.num >= MAX_KEY) {
+      throw new ConstraintError();
+    }
+    this.num += 1;
+    return this.num;
+  }
+  // https://w3c.github.io/IndexedDB/#possibly-update-the-key-generator
+  setIfLarger(num) {
+    const value = Math.floor(Math.min(num, MAX_KEY)) - 1;
+    if (value >= this.num) {
+      this.num = value + 1;
+    }
+  }
+};
+var KeyGenerator_default = KeyGenerator;
+
+// ../../node_modules/fake-indexeddb/build/esm/lib/ObjectStore.js
+var ObjectStore = class {
+  deleted = false;
+  records = new RecordStore_default(true);
+  rawIndexes = /* @__PURE__ */ 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;
+  }
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-retrieving-a-value-from-an-object-store
+  getKey(key) {
+    const record = this.records.get(key);
+    return record !== void 0 ? structuredClone(record.key) : void 0;
+  }
+  // http://w3c.github.io/IndexedDB/#retrieve-multiple-keys-from-an-object-store
+  getAllKeys(range, count, direction) {
+    if (count === void 0 || 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;
+  }
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-retrieving-a-value-from-an-object-store
+  getValue(key) {
+    const record = this.records.get(key);
+    return record !== void 0 ? structuredClone(record.value) : void 0;
+  }
+  // http://w3c.github.io/IndexedDB/#retrieve-multiple-values-from-an-object-store
+  getAllValues(range, count, direction) {
+    if (count === void 0 || 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;
+  }
+  // https://www.w3.org/TR/IndexedDB/#dom-idbobjectstore-getallrecords
+  getAllRecords(range, count, direction) {
+    if (count === void 0 || 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;
+  }
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-storing-a-record-into-an-object-store
+  storeRecord(newRecord, noOverwrite, rollbackLog) {
+    if (this.keyPath !== null) {
+      const key = extractKey_default(this.keyPath, newRecord.value).key;
+      if (key !== void 0) {
+        newRecord.key = key;
+      }
+    }
+    const rollbackLogForThisOperation = [];
+    if (this.keyGenerator !== null && newRecord.key === void 0) {
+      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;
+  }
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-deleting-records-from-an-object-store
+  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);
+    }
+  }
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-clearing-an-object-store
+  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 === void 0 || range.lower === void 0 && range.upper === void 0) {
+      return this.records.size();
+    }
+    let count = 0;
+    for (const record of this.records.values(range)) {
+      count += 1;
+    }
+    return count;
+  }
+};
+var ObjectStore_default = ObjectStore;
+
+// ../../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);
+    });
+  }
+};
+var closeConnection_default = closeConnection;
+
+// ../../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;
+};
+var FDBDatabase = class 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());
+  }
+  // http://w3c.github.io/IndexedDB/#dom-idbdatabase-createobjectstore
+  createObjectStore(name, options = {}) {
+    if (name === void 0) {
+      throw new TypeError();
+    }
+    const transaction = confirmActiveVersionchangeTransaction(this);
+    const keyPath = options !== null && options.keyPath !== void 0 ? options.keyPath : null;
+    const autoIncrement = options !== null && options.autoIncrement !== void 0 ? 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);
+  }
+  // https://www.w3.org/TR/IndexedDB/#dom-idbdatabase-deleteobjectstore
+  deleteObjectStore(name) {
+    if (name === void 0) {
+      throw new TypeError();
+    }
+    const transaction = confirmActiveVersionchangeTransaction(this);
+    const store2 = this._rawDatabase.rawObjectStores.get(name);
+    if (store2 === void 0) {
+      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(() => {
+      store2.deleted = false;
+      this._rawDatabase.rawObjectStores.set(store2.name, store2);
+      this.objectStoreNames._push(store2.name);
+      transaction.objectStoreNames._push(store2.name);
+      this.objectStoreNames._sort();
+      if (objectStore && prevIndexNames) {
+        objectStore.indexNames = new FakeDOMStringList_default(...prevIndexNames);
+      }
+    });
+    store2.deleted = true;
+    this._rawDatabase.rawObjectStores.delete(name);
+    transaction._objectStoresCache.delete(name);
+  }
+  transaction(storeNames, mode, options) {
+    mode = mode !== void 0 ? 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(
+        // based on Firefox's error message
+        `'${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";
+  }
+};
+var FDBDatabase_default = FDBDatabase;
+
+// ../../node_modules/fake-indexeddb/build/esm/FDBOpenDBRequest.js
+var FDBOpenDBRequest = class extends FDBRequest_default {
+  onupgradeneeded = null;
+  onblocked = null;
+  get [Symbol.toStringTag]() {
+    return "IDBOpenDBRequest";
+  }
+};
+var FDBOpenDBRequest_default = FDBOpenDBRequest;
+
+// ../../node_modules/fake-indexeddb/build/esm/FDBVersionChangeEvent.js
+var FDBVersionChangeEvent = class extends FakeEvent_default {
+  constructor(type, parameters = {}) {
+    super(type);
+    this.newVersion = parameters.newVersion !== void 0 ? parameters.newVersion : null;
+    this.oldVersion = parameters.oldVersion !== void 0 ? parameters.oldVersion : 0;
+  }
+  get [Symbol.toStringTag]() {
+    return "IDBVersionChangeEvent";
+  }
+};
+var FDBVersionChangeEvent_default = FDBVersionChangeEvent;
+
+// ../../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/fake-indexeddb/build/esm/lib/Database.js
+var Database = class {
+  transactions = [];
+  rawObjectStores = /* @__PURE__ */ 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 = Database;
+
+// ../../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/fake-indexeddb/build/esm/FDBFactory.js
+var runTaskInConnectionQueue = (connectionQueues, name, task) => {
+  const queue = connectionQueues.get(name) ?? Promise.resolve();
+  connectionQueues.set(name, queue.then(task));
+};
+var 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);
+};
+var deleteDatabase = (databases, connectionQueues, name, request, cb) => {
+  const deleteDBTask = () => {
+    return new Promise((resolve) => {
+      const db = databases.get(name);
+      const oldVersion = db !== void 0 ? 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 === void 0) {
+          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);
+};
+var 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 = void 0;
+      });
+      transaction._prioritizedListeners.set("abort", () => {
+        connection._runningVersionchangeTransaction = false;
+        connection._oldVersion = void 0;
+        queueTask(() => {
+          request.transaction = null;
+          cb(new AbortError());
+        });
+      });
+      transaction._prioritizedListeners.set("complete", () => {
+        connection._runningVersionchangeTransaction = false;
+        connection._oldVersion = void 0;
+        queueTask(() => {
+          request.transaction = null;
+          if (connection._closePending) {
+            cb(new AbortError());
+          } else {
+            cb(null);
+          }
+        });
+      });
+    };
+    waitForOthersClosed();
+  });
+};
+var 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 === void 0) {
+        db = new Database_default(name, 0);
+        databases.set(name, db);
+      }
+      if (version === void 0) {
+        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);
+};
+var FDBFactory = class {
+  _databases = /* @__PURE__ */ new Map();
+  // https://w3c.github.io/IndexedDB/#connection-queue
+  _connectionQueues = /* @__PURE__ */ new Map();
+  // promise chain as lightweight FIFO task queue
+  // https://w3c.github.io/IndexedDB/#dom-idbfactory-cmp
+  cmp(first, second) {
+    validateRequiredArguments(arguments.length, 2, "IDBFactory.cmp");
+    return cmp_default(first, second);
   }
-}
-function writeSecureFile(filePath, data) {
-  ensureConfigDir();
-  fs__default.default.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", { mode: 384 });
-}
-function readJsonFile(filePath) {
-  try {
-    const content = fs__default.default.readFileSync(filePath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
+  // https://w3c.github.io/IndexedDB/#dom-idbfactory-deletedatabase
+  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 = void 0;
+        request.readyState = "done";
+        const event2 = new FDBVersionChangeEvent_default("success", {
+          newVersion: null,
+          oldVersion
+        });
+        request.dispatchEvent(event2);
+      });
+    });
+    return request;
   }
-}
-function getConfig() {
-  return readJsonFile(CONFIG_FILE);
-}
-function saveConfig(config) {
-  writeSecureFile(CONFIG_FILE, config);
-}
-function updateConfig(updates) {
-  const existing = getConfig() || {};
-  saveConfig({ ...existing, ...updates });
-}
-function requireConfig() {
-  const config = getConfig();
-  if (!config?.baseUrl) {
-    console.error("Not configured. Run: arbi config set-url <url>");
-    process.exit(1);
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBFactory-open-IDBOpenDBRequest-DOMString-name-unsigned-long-long-version
+  open(name, version) {
+    validateRequiredArguments(arguments.length, 1, "IDBFactory.open");
+    if (arguments.length > 1 && version !== void 0) {
+      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 = void 0;
+          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;
   }
-  return config;
-}
-function getCredentials() {
-  return readJsonFile(CREDENTIALS_FILE);
-}
-function saveCredentials(creds) {
-  writeSecureFile(CREDENTIALS_FILE, creds);
-}
-function deleteCredentials() {
-  try {
-    fs__default.default.unlinkSync(CREDENTIALS_FILE);
-  } catch {
+  // https://w3c.github.io/IndexedDB/#dom-idbfactory-databases
+  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;
+    }));
   }
-}
-function requireCredentials() {
-  const creds = getCredentials();
-  if (!creds) {
-    console.error("Not logged in. Run: arbi login");
-    process.exit(1);
+  get [Symbol.toStringTag]() {
+    return "IDBFactory";
   }
-  return creds;
-}
-var SESSION_FILE = path__default.default.join(CONFIG_DIR, "session.json");
-var DEFAULT_SESSION = {
-  lastMessageExtId: null
 };
-function getChatSession() {
-  return readJsonFile(SESSION_FILE) || { ...DEFAULT_SESSION };
-}
-function saveChatSession(session) {
-  writeSecureFile(SESSION_FILE, session);
-}
-function updateChatSession(updates) {
-  const existing = getChatSession();
-  saveChatSession({ ...existing, ...updates });
-}
-function clearChatSession() {
-  saveChatSession({ ...DEFAULT_SESSION });
-}
+var FDBFactory_default = FDBFactory;
 
-// src/commands/config-cmd.ts
-function registerConfigCommand(program2) {
-  const config = program2.command("config").description("Manage CLI configuration");
-  config.command("set-url <url>").description("Set the ARBI server URL").action((url) => {
-    try {
-      const parsed = new URL(url);
-      const deploymentDomain = parsed.hostname;
-      updateConfig({ baseUrl: url.replace(/\/+$/, ""), deploymentDomain });
-      console.log(`Server URL: ${url}`);
-      console.log(`Domain:     ${deploymentDomain}`);
-    } catch {
-      console.error(`Invalid URL: ${url}`);
-      process.exit(1);
-    }
-  });
-}
+// ../../node_modules/fake-indexeddb/build/esm/fakeIndexedDB.js
+var fakeIndexedDB = new FDBFactory_default();
+var fakeIndexedDB_default = fakeIndexedDB;
+
+// ../../node_modules/fake-indexeddb/auto/index.mjs
+var globalVar = typeof window !== "undefined" ? window : typeof WorkerGlobalScope !== "undefined" ? self : typeof global !== "undefined" ? global : Function("return this;")();
+var createPropertyDescriptor = (value) => {
+  return {
+    value,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  };
+};
+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)
+});
 async function promptSelect(message, choices) {
   return prompts.select({ message, choices });
 }
@@ -159,8 +3401,8 @@ function registerLoginCommand(program2) {
         signingPrivateKeyBase64: arbi.crypto.bytesToBase64(result.signingPrivateKey),
         serverSessionKeyBase64: arbi.crypto.bytesToBase64(result.serverSessionKey)
       });
-      const { data: workspaces } = await arbi.fetch.GET("/api/user/workspaces");
-      const wsList = workspaces || [];
+      const { data: workspaces2 } = await arbi.fetch.GET("/api/user/workspaces");
+      const wsList = workspaces2 || [];
       console.log(`Logged in as ${email}`);
       if (wsList.length === 0) {
         console.log("No workspaces found.");
@@ -287,8 +3529,8 @@ Registered successfully as ${email}`);
         signingPrivateKeyBase64: arbi.crypto.bytesToBase64(loginResult.signingPrivateKey),
         serverSessionKeyBase64: arbi.crypto.bytesToBase64(loginResult.serverSessionKey)
       });
-      const { data: workspaces } = await arbi.fetch.GET("/api/user/workspaces");
-      const wsList = workspaces || [];
+      const { data: workspaces2 } = await arbi.fetch.GET("/api/user/workspaces");
+      const wsList = workspaces2 || [];
       console.log(`Logged in as ${email}`);
       if (wsList.length === 1) {
         updateConfig({ selectedWorkspaceId: wsList[0].external_id });
@@ -391,53 +3633,6 @@ function registerStatusCommand(program2) {
     }
   });
 }
-async function createAuthenticatedClient() {
-  const config = requireConfig();
-  const creds = requireCredentials();
-  const arbi = sdk.createArbiClient({
-    baseUrl: config.baseUrl,
-    deploymentDomain: config.deploymentDomain,
-    credentials: "omit"
-  });
-  await arbi.crypto.initSodium();
-  const signingPrivateKey = sdk.base64ToBytes(creds.signingPrivateKeyBase64);
-  const loginResult = await arbi.auth.loginWithKey({
-    email: creds.email,
-    signingPrivateKey
-  });
-  saveCredentials({
-    ...creds,
-    serverSessionKeyBase64: arbi.crypto.bytesToBase64(loginResult.serverSessionKey)
-  });
-  return { arbi, loginResult };
-}
-async function selectWorkspace(arbi, workspaceId, wrappedKey, serverSessionKey) {
-  const creds = requireCredentials();
-  const signingPrivateKey = sdk.base64ToBytes(creds.signingPrivateKeyBase64);
-  const ed25519PublicKey = signingPrivateKey.slice(32, 64);
-  const encryptionKeyPair = sdk.deriveEncryptionKeypairFromSigning({
-    publicKey: ed25519PublicKey,
-    secretKey: signingPrivateKey
-  });
-  const workspaceKey = sdk.sealedBoxDecrypt(wrappedKey, encryptionKeyPair.secretKey);
-  const header = await sdk.createWorkspaceKeyHeader(workspaceKey, serverSessionKey);
-  arbi.session.setSelectedWorkspace(workspaceId);
-  arbi.session.setCachedWorkspaceHeader(workspaceId, header);
-}
-async function selectWorkspaceById(arbi, workspaceId, serverSessionKey) {
-  const { data: workspaces, error } = await arbi.fetch.GET("/api/user/workspaces");
-  if (error || !workspaces) {
-    throw new Error("Failed to fetch workspaces");
-  }
-  const ws = workspaces.find((w) => w.external_id === workspaceId);
-  if (!ws || !ws.wrapped_key) {
-    throw new Error(`Workspace ${workspaceId} not found or has no encryption key`);
-  }
-  await selectWorkspace(arbi, ws.external_id, ws.wrapped_key, serverSessionKey);
-  return { external_id: ws.external_id, name: ws.name, wrapped_key: ws.wrapped_key };
-}
-
-// src/helpers.ts
 function runAction(fn) {
   return async () => {
     try {
@@ -449,40 +3644,27 @@ function runAction(fn) {
     }
   };
 }
-function requireData(result, message) {
-  if (result.error || !result.data) {
-    console.error(message);
-    process.exit(1);
-  }
-  return result.data;
-}
-function requireOk(result, message) {
-  if (result.error) {
-    console.error(message);
-    process.exit(1);
-  }
-}
 async function resolveAuth() {
-  const config = requireConfig();
-  const { arbi, loginResult } = await createAuthenticatedClient();
-  return { arbi, loginResult, config };
+  try {
+    return await core.resolveAuth(store);
+  } catch (err) {
+    if (err instanceof core.ArbiError) {
+      console.error(err.message);
+      process.exit(1);
+    }
+    throw err;
+  }
 }
 async function resolveWorkspace(workspaceOpt) {
-  const config = requireConfig();
-  const workspaceId = workspaceOpt || config.selectedWorkspaceId;
-  if (!workspaceId) {
-    console.error("No workspace selected. Run: arbi workspace select <id>");
-    process.exit(1);
-  }
-  const { arbi, loginResult } = await createAuthenticatedClient();
-  await selectWorkspaceById(arbi, workspaceId, loginResult.serverSessionKey);
-  const accessToken = arbi.session.getState().accessToken;
-  const workspaceKeyHeader = arbi.session.getWorkspaceKeyHeader();
-  if (!accessToken || !workspaceKeyHeader) {
-    console.error("Authentication error \u2014 missing token or workspace key");
-    process.exit(1);
+  try {
+    return await core.resolveWorkspace(store, workspaceOpt);
+  } catch (err) {
+    if (err instanceof core.ArbiError) {
+      console.error(err.message);
+      process.exit(1);
+    }
+    throw err;
   }
-  return { arbi, loginResult, config, workspaceId, accessToken, workspaceKeyHeader };
 }
 function printTable(columns, rows) {
   console.log(columns.map((c) => c.header.padEnd(c.width)).join(""));
@@ -509,10 +3691,7 @@ function registerWorkspacesCommand(program2) {
   program2.command("workspaces").description("List workspaces").action(
     runAction(async () => {
       const { arbi } = await resolveAuth();
-      const data = requireData(
-        await arbi.fetch.GET("/api/user/workspaces"),
-        "Failed to fetch workspaces"
-      );
+      const data = await core.workspaces.listWorkspaces(arbi);
       if (data.length === 0) {
         console.log("No workspaces found.");
         return;
@@ -540,10 +3719,7 @@ function registerWorkspacesCommand(program2) {
   workspace.command("select [id]").description("Select active workspace (interactive picker if no ID given)").action(
     (id) => runAction(async () => {
       const { arbi } = await resolveAuth();
-      const data = requireData(
-        await arbi.fetch.GET("/api/user/workspaces"),
-        "Failed to fetch workspaces"
-      );
+      const data = await core.workspaces.listWorkspaces(arbi);
       if (data.length === 0) {
         console.log("No workspaces found.");
         return;
@@ -577,11 +3753,11 @@ function registerWorkspacesCommand(program2) {
   workspace.command("create <name>").description("Create a new workspace").option("-d, --description <text>", "Workspace description").option("--public", "Make workspace public", false).action(
     (name, opts) => runAction(async () => {
       const { arbi } = await resolveAuth();
-      const data = requireData(
-        await arbi.fetch.POST("/api/workspace/create_protected", {
-          body: { name, description: opts.description ?? null, is_public: opts.public ?? false }
-        }),
-        "Failed to create workspace"
+      const data = await core.workspaces.createWorkspace(
+        arbi,
+        name,
+        opts.description,
+        opts.public ?? false
       );
       console.log(`Created: ${data.name} (${data.external_id})`);
     })()
@@ -589,12 +3765,7 @@ function registerWorkspacesCommand(program2) {
   workspace.command("delete <id>").description("Delete a workspace").action(
     (id) => runAction(async () => {
       const { arbi } = await resolveAuth();
-      const data = requireData(
-        await arbi.fetch.DELETE("/api/workspace/{workspace_ext_id}", {
-          params: { path: { workspace_ext_id: id } }
-        }),
-        "Failed to delete workspace"
-      );
+      const data = await core.workspaces.deleteWorkspace(arbi, id);
       console.log(data?.detail ?? `Deleted workspace ${id}`);
     })()
   );
@@ -602,25 +3773,14 @@ function registerWorkspacesCommand(program2) {
     (id, json) => runAction(async () => {
       const body = parseJsonArg(json, `arbi workspace update wrk-123 '{"name": "New Name"}'`);
       const { arbi } = await resolveWorkspace(id);
-      const data = requireData(
-        await arbi.fetch.PATCH("/api/workspace/{workspace_ext_id}", {
-          params: { path: { workspace_ext_id: id } },
-          body
-        }),
-        "Failed to update workspace"
-      );
+      const data = await core.workspaces.updateWorkspace(arbi, id, body);
       console.log(`Updated: ${data.name} (${data.external_id})`);
     })()
   );
   workspace.command("users").description("List users in the active workspace").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").action(
     (opts) => runAction(async () => {
       const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
-      const data = requireData(
-        await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/users", {
-          params: { path: { workspace_ext_id: workspaceId } }
-        }),
-        "Failed to fetch workspace users"
-      );
+      const data = await core.workspaces.listWorkspaceUsers(arbi, workspaceId);
       if (data.length === 0) {
         console.log("No users found.");
         return;
@@ -657,38 +3817,25 @@ function registerWorkspacesCommand(program2) {
     (emails, opts) => runAction(async () => {
       const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
       const role = opts.role ?? "collaborator";
-      const data = requireData(
-        await arbi.fetch.POST("/api/workspace/{workspace_ext_id}/users", {
-          params: { path: { workspace_ext_id: workspaceId } },
-          body: { emails, role }
-        }),
-        "Failed to add users"
-      );
+      const data = await core.workspaces.addWorkspaceUsers(arbi, workspaceId, emails, role);
       for (const u of data) console.log(`Added: ${u.user.email} as ${u.role}`);
     })()
   );
   workspace.command("remove-user <user-ids...>").description("Remove users from the active workspace").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").action(
     (userIds, opts) => runAction(async () => {
       const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
-      requireOk(
-        await arbi.fetch.DELETE("/api/workspace/{workspace_ext_id}/users", {
-          params: { path: { workspace_ext_id: workspaceId } },
-          body: { users: userIds.map((id) => ({ user_ext_id: id })) }
-        }),
-        "Failed to remove users"
-      );
+      await core.workspaces.removeWorkspaceUsers(arbi, workspaceId, userIds);
       console.log(`Removed ${userIds.length} user(s).`);
     })()
   );
   workspace.command("set-role <role> <user-ids...>").description("Update user roles (owner, collaborator, guest)").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").action(
     (role, userIds, opts) => runAction(async () => {
       const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
-      const data = requireData(
-        await arbi.fetch.PATCH("/api/workspace/{workspace_ext_id}/users", {
-          params: { path: { workspace_ext_id: workspaceId } },
-          body: { user_ext_ids: userIds, role }
-        }),
-        "Failed to update roles"
+      const data = await core.workspaces.setUserRole(
+        arbi,
+        workspaceId,
+        userIds,
+        role
       );
       for (const u of data) console.log(`Updated: ${u.user.email} \u2192 ${u.role}`);
     })()
@@ -696,19 +3843,11 @@ function registerWorkspacesCommand(program2) {
   workspace.command("copy <target-workspace-id> <doc-ids...>").description("Copy documents to another workspace").option("-w, --workspace <id>", "Source workspace ID (defaults to selected workspace)").action(
     (targetId, docIds, opts) => runAction(async () => {
       const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
-      const data = requireData(
-        await arbi.fetch.POST("/api/workspace/{workspace_ext_id}/copy", {
-          params: { path: { workspace_ext_id: workspaceId } },
-          body: { target_workspace_ext_id: targetId, items: docIds }
-        }),
-        "Failed to copy documents"
-      );
+      const data = await core.workspaces.copyDocuments(arbi, workspaceId, targetId, docIds);
       console.log(`${data.detail} (${data.documents_copied} document(s) copied)`);
     })()
   );
 }
-
-// src/commands/docs.ts
 function formatSize(bytes) {
   if (!bytes) return "-";
   if (bytes < 1024) return `${bytes} B`;
@@ -716,12 +3855,7 @@ function formatSize(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
 async function fetchDocChoices(arbi, workspaceId) {
-  const data = requireData(
-    await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/documents", {
-      params: { path: { workspace_ext_id: workspaceId } }
-    }),
-    "Failed to fetch documents"
-  );
+  const data = await core.documents.listDocuments(arbi, workspaceId);
   if (data.length === 0) {
     console.log("No documents found.");
     process.exit(0);
@@ -736,12 +3870,7 @@ function registerDocsCommand(program2) {
   program2.command("docs").description("List documents in the active workspace").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").action(
     (opts) => runAction(async () => {
       const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
-      const data = requireData(
-        await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/documents", {
-          params: { path: { workspace_ext_id: workspaceId } }
-        }),
-        "Failed to fetch documents"
-      );
+      const data = await core.documents.listDocuments(arbi, workspaceId);
       if (data.length === 0) {
         console.log("No documents found.");
         return;
@@ -768,10 +3897,7 @@ function registerDocsCommand(program2) {
         if (selected.length === 0) return;
         docIds = selected;
       }
-      const data = requireData(
-        await arbi.fetch.GET("/api/document/", { params: { query: { external_ids: docIds } } }),
-        "Failed to fetch documents"
-      );
+      const data = await core.documents.getDocuments(arbi, docIds);
       console.log(JSON.stringify(data, null, 2));
     })()
   );
@@ -785,10 +3911,7 @@ function registerDocsCommand(program2) {
         if (selected.length === 0) return;
         docIds = selected;
       }
-      requireOk(
-        await arbi.fetch.DELETE("/api/document/", { body: { external_ids: docIds } }),
-        "Failed to delete documents"
-      );
+      await core.documents.deleteDocuments(arbi, docIds);
       console.log(`Deleted ${docIds.length} document(s).`);
     })()
   );
@@ -796,12 +3919,9 @@ function registerDocsCommand(program2) {
     (json) => runAction(async () => {
       if (json) {
         const parsed = parseJsonArg(json, `arbi doc update '[{"external_id": "doc-123", "shared": true}]'`);
-        const body = Array.isArray(parsed) ? { documents: parsed } : parsed;
+        const docs = Array.isArray(parsed) ? parsed : parsed.documents;
         const { arbi } = await resolveWorkspace();
-        const data = requireData(
-          await arbi.fetch.PATCH("/api/document/", { body }),
-          "Failed to update documents"
-        );
+        const data = await core.documents.updateDocuments(arbi, docs);
         console.log(`Updated ${data.length} document(s).`);
       } else {
         const { arbi, workspaceId } = await resolveWorkspace();
@@ -825,12 +3945,9 @@ function registerDocsCommand(program2) {
         } else {
           value = await promptInput(`${field.charAt(0).toUpperCase() + field.slice(1)}`);
         }
-        const data = requireData(
-          await arbi.fetch.PATCH("/api/document/", {
-            body: { documents: [{ external_id: docId, [field]: value }] }
-          }),
-          "Failed to update document"
-        );
+        const data = await core.documents.updateDocuments(arbi, [
+          { external_id: docId, [field]: value }
+        ]);
         console.log(`Updated ${data.length} document(s).`);
       }
     })()
@@ -838,14 +3955,7 @@ function registerDocsCommand(program2) {
   doc.command("upload-url <urls...>").description("Upload documents from URLs").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").option("--shared", "Make documents shared", false).action(
     (urls, opts) => runAction(async () => {
       const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
-      const data = requireData(
-        await arbi.fetch.POST("/api/document/upload-url", {
-          params: {
-            query: { urls, workspace_ext_id: workspaceId, shared: opts.shared ?? false }
-          }
-        }),
-        "Failed to upload from URLs"
-      );
+      const data = await core.documents.uploadUrl(arbi, urls, workspaceId, opts.shared ?? false);
       console.log(`Uploaded: ${data.doc_ext_ids.join(", ")}`);
       if (data.duplicates && data.duplicates.length > 0) {
         console.log(`Duplicates: ${data.duplicates.join(", ")}`);
@@ -854,7 +3964,7 @@ function registerDocsCommand(program2) {
   );
   doc.command("parsed [doc-id] [stage]").description("Get parsed document content (stage: marker, subchunk, final)").action(
     (docId, stage) => runAction(async () => {
-      const { arbi, config, accessToken, workspaceKeyHeader, workspaceId } = await resolveWorkspace();
+      const { arbi, accessToken, workspaceKeyHeader, workspaceId, config } = await resolveWorkspace();
       if (!docId) {
         const choices = await fetchDocChoices(arbi, workspaceId);
         docId = await promptSearch("Select document", choices);
@@ -870,67 +3980,17 @@ function registerDocsCommand(program2) {
         console.error(`Invalid stage: ${stage}. Must be one of: ${validStages.join(", ")}`);
         process.exit(1);
       }
-      const res = await fetch(`${config.baseUrl}/api/document/${docId}/parsed-${stage}`, {
-        headers: { Authorization: `Bearer ${accessToken}`, "workspace-key": workspaceKeyHeader }
-      });
-      if (!res.ok) {
-        const body = await res.text().catch(() => "");
-        console.error(`Failed: ${res.status} ${body}`);
-        process.exit(1);
-      }
-      console.log(JSON.stringify(await res.json(), null, 2));
+      const data = await core.documents.getParsedContent(
+        config.baseUrl,
+        accessToken,
+        workspaceKeyHeader,
+        docId,
+        stage
+      );
+      console.log(JSON.stringify(data, null, 2));
     })()
   );
 }
-var AUTH_TIMEOUT_MS = 1e4;
-function connectWebSocket(options) {
-  const { baseUrl, accessToken, onMessage, onClose } = options;
-  const url = sdk.buildWebSocketUrl(baseUrl);
-  return new Promise((resolve, reject) => {
-    const ws = new WebSocket(url);
-    let authenticated = false;
-    const timeout = setTimeout(() => {
-      if (!authenticated) {
-        ws.close();
-        reject(new Error("WebSocket auth timed out"));
-      }
-    }, AUTH_TIMEOUT_MS);
-    ws.addEventListener("open", () => {
-      ws.send(sdk.createAuthMessage(accessToken));
-    });
-    ws.addEventListener("message", (event) => {
-      const data = typeof event.data === "string" ? event.data : String(event.data);
-      const msg = sdk.parseServerMessage(data);
-      if (!msg) return;
-      if (!authenticated) {
-        if (sdk.isMessageType(msg, "auth_result")) {
-          clearTimeout(timeout);
-          if (msg.success) {
-            authenticated = true;
-            resolve({ close: () => ws.close() });
-          } else {
-            ws.close();
-            reject(new Error(`WebSocket auth failed: ${msg.reason || "unknown"}`));
-          }
-        }
-        return;
-      }
-      onMessage(msg);
-    });
-    ws.addEventListener("close", (event) => {
-      clearTimeout(timeout);
-      if (!authenticated) {
-        reject(new Error(`WebSocket closed before auth (code ${event.code})`));
-        return;
-      }
-      onClose?.(event.code, event.reason);
-    });
-    ws.addEventListener("error", () => {
-    });
-  });
-}
-
-// src/commands/upload.ts
 function registerUploadCommand(program2) {
   program2.command("upload <files...>").description("Upload documents to the active workspace").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").option("-W, --watch", "Watch document processing progress after upload").action(
     (files, opts) => runAction(async () => {
@@ -946,26 +4006,15 @@ function registerUploadCommand(program2) {
       const uploadedDocs = /* @__PURE__ */ new Map();
       for (const filePath of files) {
         const fileBuffer = fs__default.default.readFileSync(filePath);
-        const fileName = path__default.default.basename(filePath);
-        const formData = new FormData();
-        formData.append("files", new Blob([fileBuffer]), fileName);
-        const res = await fetch(
-          `${config.baseUrl}/api/document/upload?workspace_ext_id=${workspaceId}`,
-          {
-            method: "POST",
-            headers: {
-              Authorization: `Bearer ${accessToken}`,
-              "workspace-key": workspaceKeyHeader
-            },
-            body: formData
-          }
+        const fileName = path2__default.default.basename(filePath);
+        const result = await core.documents.uploadFile(
+          config.baseUrl,
+          accessToken,
+          workspaceKeyHeader,
+          workspaceId,
+          new Blob([fileBuffer]),
+          fileName
         );
-        if (!res.ok) {
-          const body = await res.text().catch(() => "");
-          console.error(`Upload failed for ${fileName}: ${res.status} ${body}`);
-          process.exit(1);
-        }
-        const result = await res.json();
         console.log(`Uploaded: ${fileName} (${result.doc_ext_ids.join(", ")})`);
         if (result.duplicates && result.duplicates.length > 0) {
           console.log(`  Duplicates: ${result.duplicates.join(", ")}`);
@@ -976,7 +4025,7 @@ function registerUploadCommand(program2) {
         const pending = new Set(uploadedDocs.keys());
         console.log(`
 Watching ${pending.size} document(s)...`);
-        const conn = await connectWebSocket({
+        const conn = await core.connectWebSocket({
           baseUrl: config.baseUrl,
           accessToken,
           onMessage: (msg) => {
@@ -1009,12 +4058,7 @@ function registerDownloadCommand(program2) {
     (docId, opts) => runAction(async () => {
       const { arbi, config, accessToken, workspaceKeyHeader, workspaceId } = await resolveWorkspace(opts.workspace);
       if (!docId) {
-        const data = requireData(
-          await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/documents", {
-            params: { path: { workspace_ext_id: workspaceId } }
-          }),
-          "Failed to fetch documents"
-        );
+        const data = await core.documents.listDocuments(arbi, workspaceId);
         if (data.length === 0) {
           console.log("No documents found.");
           return;
@@ -1026,155 +4070,60 @@ function registerDownloadCommand(program2) {
         }));
         docId = await promptSearch("Select document to download", choices);
       }
-      const res = await fetch(`${config.baseUrl}/api/document/${docId}/download`, {
-        headers: { Authorization: `Bearer ${accessToken}`, "workspace-key": workspaceKeyHeader }
-      });
-      if (!res.ok) {
-        const body = await res.text().catch(() => "");
-        console.error(`Download failed: ${res.status} ${body}`);
-        process.exit(1);
-      }
+      const res = await core.documents.downloadDocument(
+        config.baseUrl,
+        accessToken,
+        workspaceKeyHeader,
+        docId
+      );
       let filename = `${docId}`;
       const disposition = res.headers.get("content-disposition");
       if (disposition) {
         const match = disposition.match(/filename[*]?=(?:UTF-8''|"?)([^";]+)/i);
         if (match) filename = decodeURIComponent(match[1].replace(/"/g, ""));
       }
-      const outputPath = opts.output || path__default.default.join(process.cwd(), filename);
+      const outputPath = opts.output || path2__default.default.join(process.cwd(), filename);
       const buffer = Buffer.from(await res.arrayBuffer());
       fs__default.default.writeFileSync(outputPath, buffer);
       console.log(
-        `Downloaded: ${path__default.default.basename(outputPath)} (${(buffer.length / (1024 * 1024)).toFixed(1)} MB)`
+        `Downloaded: ${path2__default.default.basename(outputPath)} (${(buffer.length / (1024 * 1024)).toFixed(1)} MB)`
       );
     })()
   );
 }
-
-// src/commands/ask.ts
-function parseSSEEvents(chunk, buffer) {
-  const combined = buffer + chunk;
-  const events = [];
-  const parts = combined.split("\n\n");
-  const remaining = parts.pop() || "";
-  for (const part of parts) {
-    if (!part.trim()) continue;
-    let eventType = "";
-    let eventData = "";
-    for (const line of part.split("\n")) {
-      if (line.startsWith("event: ")) eventType = line.slice(7).trim();
-      else if (line.startsWith("data: ")) eventData = line.slice(6);
-    }
-    if (eventType && eventData) events.push({ event: eventType, data: eventData });
-  }
-  return { events, remaining };
-}
 function registerAskCommand(program2) {
   program2.command("ask <question>").description("Ask the RAG assistant a question").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").option("-c, --config <id>", "Config ext_id to use (e.g. cfg-xxx)").option("-n, --new", "Start a new conversation (ignore previous context)").option("-v, --verbose", "Show agent steps and tool calls").action(
     (question, opts) => runAction(async () => {
-      const { arbi, config, accessToken, workspaceKeyHeader, workspaceId } = await resolveWorkspace(opts.workspace);
+      const { arbi, accessToken, workspaceKeyHeader, workspaceId, config } = await resolveWorkspace(opts.workspace);
       const session = getChatSession();
       if (opts.new) {
         clearChatSession();
         session.lastMessageExtId = null;
       }
-      const docs = requireData(
-        await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/documents", {
-          params: { path: { workspace_ext_id: workspaceId } }
-        }),
-        "Failed to fetch workspace documents"
-      );
+      const docs = await core.documents.listDocuments(arbi, workspaceId);
       const docIds = docs.map((d) => d.external_id);
-      const body = {
-        content: question,
-        workspace_ext_id: workspaceId,
-        tools: {
-          retrieval_chunk: {
-            name: "retrieval_chunk",
-            description: "retrieval chunk",
-            tool_args: { doc_ext_ids: docIds },
-            tool_responses: {}
-          },
-          retrieval_full_context: {
-            name: "retrieval_full_context",
-            description: "retrieval full_context",
-            tool_args: { doc_ext_ids: [] },
-            tool_responses: {}
-          }
-        }
-      };
-      if (session.lastMessageExtId) {
-        body.parent_message_ext_id = session.lastMessageExtId;
-      }
-      if (opts.config) {
-        body.config_ext_id = opts.config;
-      }
-      const res = await fetch(`${config.baseUrl}/api/assistant/query`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          "workspace-key": workspaceKeyHeader,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(body)
+      const res = await core.assistant.queryAssistant({
+        baseUrl: config.baseUrl,
+        accessToken,
+        workspaceKeyHeader,
+        workspaceId,
+        question,
+        docIds,
+        parentMessageExtId: session.lastMessageExtId,
+        configExtId: opts.config
       });
-      if (!res.ok) {
-        if (res.status === 503)
-          console.error(
-            "The selected LLM is not responding. Please retry or select another model."
-          );
-        else if (res.status === 401) console.error("Token has expired. Please run: arbi login");
-        else console.error(`Query failed: ${res.status} ${await res.text().catch(() => "")}`);
-        process.exit(1);
-      }
-      if (!res.body) {
-        console.error("No response body");
-        process.exit(1);
-      }
-      const reader = res.body.getReader();
-      const decoder = new TextDecoder("utf-8");
-      let sseBuffer = "";
-      let assistantMessageExtId = null;
-      const processEvents = (events) => {
-        for (const { event, data } of events) {
-          try {
-            if (event === "stream_start") {
-              const parsed = JSON.parse(data);
-              if (parsed.assistant_message_ext_id) {
-                assistantMessageExtId = parsed.assistant_message_ext_id;
-              }
-            } else if (event === "agent_step") {
-              if (opts.verbose) {
-                const parsed = JSON.parse(data);
-                const focus = parsed.focus || parsed.status || "";
-                console.error(`
+      const { assistantMessageExtId } = await core.streamSSE(res, {
+        onToken: (content) => process.stdout.write(content),
+        onAgentStep: (data) => {
+          if (opts.verbose) {
+            const focus = data.focus || data.status || "";
+            console.error(`
 [agent] ${focus}`);
-              }
-            } else if (event === "token") {
-              const parsed = JSON.parse(data);
-              if (parsed.content) process.stdout.write(parsed.content);
-            } else if (event === "error") {
-              const parsed = JSON.parse(data);
-              console.error(`
-Error: ${parsed.message || "Unknown streaming error"}`);
-            }
-          } catch {
           }
-        }
-      };
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        const { events, remaining } = parseSSEEvents(
-          decoder.decode(value, { stream: true }),
-          sseBuffer
-        );
-        sseBuffer = remaining;
-        processEvents(events);
-      }
-      if (sseBuffer.trim()) {
-        const { events } = parseSSEEvents(sseBuffer + "\n\n", "");
-        processEvents(events);
-      }
+        },
+        onError: (message) => console.error(`
+Error: ${message}`)
+      });
       process.stdout.write("\n");
       if (assistantMessageExtId) {
         updateChatSession({ lastMessageExtId: assistantMessageExtId });
@@ -1190,7 +4139,7 @@ function registerWatchCommand(program2) {
     (opts) => runAction(async () => {
       const { config, accessToken, workspaceId } = await resolveWorkspace(opts.workspace);
       console.log(`Watching workspace ${workspaceId}... (Ctrl+C to stop)`);
-      await connectWebSocket({
+      await core.connectWebSocket({
         baseUrl: config.baseUrl,
         accessToken,
         onMessage: (msg) => {
@@ -1216,17 +4165,12 @@ Connection closed (code ${code}${reason ? ": " + reason : ""})`);
     })()
   );
 }
-
-// src/commands/contacts.ts
 function registerContactsCommand(program2) {
   const contacts = program2.command("contacts").description("Manage contacts");
   contacts.command("list").description("List all contacts").action(
     runAction(async () => {
       const { arbi } = await resolveAuth();
-      const data = requireData(
-        await arbi.fetch.GET("/api/user/contacts"),
-        "Failed to fetch contacts"
-      );
+      const data = await core.contacts.listContacts(arbi);
       if (data.length === 0) {
         console.log("No contacts found.");
         return;
@@ -1257,10 +4201,7 @@ function registerContactsCommand(program2) {
         emails = input2.split(",").map((e) => e.trim()).filter(Boolean);
         if (emails.length === 0) return;
       }
-      const data = requireData(
-        await arbi.fetch.POST("/api/user/contacts", { body: { emails } }),
-        "Failed to add contacts"
-      );
+      const data = await core.contacts.addContacts(arbi, emails);
       for (const c of data) {
         console.log(`Added: ${c.email} (${c.external_id}) \u2014 ${c.status}`);
       }
@@ -1271,10 +4212,7 @@ function registerContactsCommand(program2) {
       const { arbi } = await resolveAuth();
       let contactIds = ids && ids.length > 0 ? ids : void 0;
       if (!contactIds) {
-        const data = requireData(
-          await arbi.fetch.GET("/api/user/contacts"),
-          "Failed to fetch contacts"
-        );
+        const data = await core.contacts.listContacts(arbi);
         if (data.length === 0) {
           console.log("No contacts found.");
           return;
@@ -1292,10 +4230,7 @@ function registerContactsCommand(program2) {
         );
         if (contactIds.length === 0) return;
       }
-      requireOk(
-        await arbi.fetch.DELETE("/api/user/contacts", { body: { contact_ids: contactIds } }),
-        "Failed to remove contacts"
-      );
+      await core.contacts.removeContacts(arbi, contactIds);
       console.log(`Removed ${contactIds.length} contact(s).`);
     })()
   );
@@ -1303,17 +4238,12 @@ function registerContactsCommand(program2) {
     await contacts.commands.find((c) => c.name() === "list").parseAsync([], { from: "user" });
   });
 }
-
-// src/commands/dm.ts
 function registerDmCommand(program2) {
   const dm = program2.command("dm").description("Direct messages");
   dm.command("list").description("List all DMs and notifications").action(
     runAction(async () => {
       const { arbi } = await resolveAuth();
-      const data = requireData(
-        await arbi.fetch.GET("/api/notifications/"),
-        "Failed to fetch messages"
-      );
+      const data = await core.dm.listDMs(arbi);
       if (data.length === 0) {
         console.log("No messages found.");
         return;
@@ -1343,10 +4273,7 @@ function registerDmCommand(program2) {
     (recipient, content) => runAction(async () => {
       const { arbi } = await resolveAuth();
       if (!recipient) {
-        const contacts = requireData(
-          await arbi.fetch.GET("/api/user/contacts"),
-          "Failed to fetch contacts"
-        );
+        const contacts = await core.contacts.listContacts(arbi);
         if (contacts.length === 0) {
           console.error("No contacts found. Add contacts first: arbi contacts add <email>");
           process.exit(1);
@@ -1369,10 +4296,7 @@ function registerDmCommand(program2) {
       }
       let recipientExtId = recipient;
       if (recipient.includes("@")) {
-        const contacts = requireData(
-          await arbi.fetch.GET("/api/user/contacts"),
-          "Failed to fetch contacts"
-        );
+        const contacts = await core.contacts.listContacts(arbi);
         const match = contacts.find((c) => c.email === recipient);
         if (!match) {
           console.error(`No contact found with email: ${recipient}`);
@@ -1381,12 +4305,7 @@ function registerDmCommand(program2) {
         }
         recipientExtId = match.user?.external_id ?? match.external_id;
       }
-      const data = requireData(
-        await arbi.fetch.POST("/api/notifications/", {
-          body: { messages: [{ recipient_ext_id: recipientExtId, content }] }
-        }),
-        "Failed to send message"
-      );
+      const data = await core.dm.sendDM(arbi, [{ recipient_ext_id: recipientExtId, content }]);
       for (const n of data) {
         console.log(`Sent: ${n.external_id} \u2192 ${n.recipient.email}`);
       }
@@ -1397,10 +4316,7 @@ function registerDmCommand(program2) {
       const { arbi } = await resolveAuth();
       let msgIds = ids && ids.length > 0 ? ids : void 0;
       if (!msgIds) {
-        const data2 = requireData(
-          await arbi.fetch.GET("/api/notifications/"),
-          "Failed to fetch messages"
-        );
+        const data2 = await core.dm.listDMs(arbi);
         const unread = data2.filter((m) => !m.read);
         if (unread.length === 0) {
           console.log("No unread messages.");
@@ -1419,12 +4335,7 @@ function registerDmCommand(program2) {
         );
         if (msgIds.length === 0) return;
       }
-      const data = requireData(
-        await arbi.fetch.PATCH("/api/notifications/", {
-          body: { updates: msgIds.map((id) => ({ external_id: id, read: true })) }
-        }),
-        "Failed to update messages"
-      );
+      const data = await core.dm.markRead(arbi, msgIds);
       console.log(`Marked ${data.length} message(s) as read.`);
     })()
   );
@@ -1433,10 +4344,7 @@ function registerDmCommand(program2) {
       const { arbi } = await resolveAuth();
       let msgIds = ids && ids.length > 0 ? ids : void 0;
       if (!msgIds) {
-        const data = requireData(
-          await arbi.fetch.GET("/api/notifications/"),
-          "Failed to fetch messages"
-        );
+        const data = await core.dm.listDMs(arbi);
         if (data.length === 0) {
           console.log("No messages found.");
           return;
@@ -1454,10 +4362,7 @@ function registerDmCommand(program2) {
         );
         if (msgIds.length === 0) return;
       }
-      requireOk(
-        await arbi.fetch.DELETE("/api/notifications/", { body: { external_ids: msgIds } }),
-        "Failed to delete messages"
-      );
+      await core.dm.deleteDMs(arbi, msgIds);
       console.log(`Deleted ${msgIds.length} message(s).`);
     })()
   );
@@ -1465,15 +4370,8 @@ function registerDmCommand(program2) {
     await dm.commands.find((c) => c.name() === "list").parseAsync([], { from: "user" });
   });
 }
-
-// src/commands/tags.ts
 async function fetchTagChoices(arbi, workspaceId) {
-  const data = requireData(
-    await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/tags", {
-      params: { path: { workspace_ext_id: workspaceId } }
-    }),
-    "Failed to fetch tags"
-  );
+  const data = await core.tags.listTags(arbi, workspaceId);
   if (data.length === 0) {
     console.log("No tags found.");
     process.exit(0);
@@ -1492,12 +4390,7 @@ function registerTagsCommand(program2) {
   tags.command("list").description("List tags in the active workspace").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").action(
     (opts) => runAction(async () => {
       const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
-      const data = requireData(
-        await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/tags", {
-          params: { path: { workspace_ext_id: workspaceId } }
-        }),
-        "Failed to fetch tags"
-      );
+      const data = await core.tags.listTags(arbi, workspaceId);
       if (data.length === 0) {
         console.log("No tags found.");
         return;
@@ -1541,18 +4434,13 @@ function registerTagsCommand(program2) {
       ]);
       const instruction = interactive ? opts.instruction ?? (await promptInput("Instruction (optional)", false) || null) : opts.instruction ?? null;
       const shared = interactive ? opts.shared || await promptConfirm("Shared?", false) : opts.shared ?? false;
-      const data = requireData(
-        await arbi.fetch.POST("/api/tag/", {
-          body: {
-            name,
-            workspace_ext_id: workspaceId,
-            tag_type: { type: tagType, options: [] },
-            instruction,
-            shared
-          }
-        }),
-        "Failed to create tag"
-      );
+      const data = await core.tags.createTag(arbi, {
+        name,
+        workspaceId,
+        tagType: { type: tagType, options: [] },
+        instruction,
+        shared
+      });
       console.log(`Created: ${data.name} (${data.external_id})`);
     })()
   );
@@ -1563,12 +4451,7 @@ function registerTagsCommand(program2) {
         const { choices } = await fetchTagChoices(arbi, workspaceId);
         id = await promptSelect("Select tag to delete", choices);
       }
-      const data = requireData(
-        await arbi.fetch.DELETE("/api/tag/{tag_ext_id}", {
-          params: { path: { tag_ext_id: id } }
-        }),
-        "Failed to delete tag"
-      );
+      const data = await core.tags.deleteTag(arbi, id);
       console.log(data?.detail ?? `Deleted tag ${id}`);
     })()
   );
@@ -1594,13 +4477,7 @@ function registerTagsCommand(program2) {
           body = { [field]: await promptInput(field.charAt(0).toUpperCase() + field.slice(1)) };
         }
       }
-      const data = requireData(
-        await arbi.fetch.PATCH("/api/tag/{tag_ext_id}", {
-          params: { path: { tag_ext_id: id } },
-          body
-        }),
-        "Failed to update tag"
-      );
+      const data = await core.tags.updateTag(arbi, id, body);
       console.log(`Updated: ${data.name} (${data.external_id})`);
     })()
   );
@@ -1608,15 +4485,8 @@ function registerTagsCommand(program2) {
     await cmd.commands.find((c) => c.name() === "list").parseAsync([], { from: "user" });
   });
 }
-
-// src/commands/doctags.ts
 async function pickTag(arbi, workspaceId, message = "Select tag") {
-  const data = requireData(
-    await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/tags", {
-      params: { path: { workspace_ext_id: workspaceId } }
-    }),
-    "Failed to fetch tags"
-  );
+  const data = await core.tags.listTags(arbi, workspaceId);
   if (data.length === 0) {
     console.log("No tags found.");
     process.exit(0);
@@ -1631,12 +4501,7 @@ async function pickTag(arbi, workspaceId, message = "Select tag") {
   );
 }
 async function pickDocs(arbi, workspaceId, message = "Select documents") {
-  const data = requireData(
-    await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/documents", {
-      params: { path: { workspace_ext_id: workspaceId } }
-    }),
-    "Failed to fetch documents"
-  );
+  const data = await core.documents.listDocuments(arbi, workspaceId);
   if (data.length === 0) {
     console.log("No documents found.");
     process.exit(0);
@@ -1650,52 +4515,37 @@ async function pickDocs(arbi, workspaceId, message = "Select documents") {
   );
 }
 function registerDoctagsCommand(program2) {
-  const doctags = program2.command("doctags").description("Manage document tags (doctags)");
-  doctags.command("create [tag-id] [doc-ids...]").description("Assign a tag to documents (interactive pickers if no args)").option("-n, --note <text>", "Note for the doctag").action(
+  const doctagsCmd = program2.command("doctags").description("Manage document tags (doctags)");
+  doctagsCmd.command("create [tag-id] [doc-ids...]").description("Assign a tag to documents (interactive pickers if no args)").option("-n, --note <text>", "Note for the doctag").action(
     (tagId, docIds, opts) => runAction(async () => {
       const { arbi, workspaceId } = await resolveWorkspace();
       if (!tagId) tagId = await pickTag(arbi, workspaceId, "Select tag to assign");
       if (!docIds || docIds.length === 0)
         docIds = await pickDocs(arbi, workspaceId, "Select documents to tag");
       if (docIds.length === 0) return;
-      const data = requireData(
-        await arbi.fetch.POST("/api/document/doctag", {
-          body: { tag_ext_id: tagId, doc_ext_ids: docIds, note: opts?.note ?? null }
-        }),
-        "Failed to create doctags"
-      );
+      const data = await core.doctags.assignDocTags(arbi, tagId, docIds, opts?.note);
       console.log(`Created ${data.length} doctag(s) for tag ${tagId}.`);
     })()
   );
-  doctags.command("delete [tag-id] [doc-ids...]").description("Remove a tag from documents (interactive pickers if no args)").action(
+  doctagsCmd.command("delete [tag-id] [doc-ids...]").description("Remove a tag from documents (interactive pickers if no args)").action(
     (tagId, docIds) => runAction(async () => {
       const { arbi, workspaceId } = await resolveWorkspace();
       if (!tagId) tagId = await pickTag(arbi, workspaceId, "Select tag to remove");
       if (!docIds || docIds.length === 0)
         docIds = await pickDocs(arbi, workspaceId, "Select documents to untag");
       if (docIds.length === 0) return;
-      requireOk(
-        await arbi.fetch.DELETE("/api/document/doctag", {
-          body: { tag_ext_id: tagId, doc_ext_ids: docIds }
-        }),
-        "Failed to delete doctags"
-      );
+      await core.doctags.removeDocTags(arbi, tagId, docIds);
       console.log(`Removed tag ${tagId} from ${docIds.length} document(s).`);
     })()
   );
-  doctags.command("generate").description("AI-generate doctags (interactive pickers if no flags)").option("--tags <ids>", "Comma-separated tag IDs").option("--docs <ids>", "Comma-separated document IDs").action(
+  doctagsCmd.command("generate").description("AI-generate doctags (interactive pickers if no flags)").option("--tags <ids>", "Comma-separated tag IDs").option("--docs <ids>", "Comma-separated document IDs").action(
     (opts) => runAction(async () => {
       const { arbi, workspaceId } = await resolveWorkspace();
       let tagIds;
       if (opts.tags) {
         tagIds = opts.tags.split(",").map((s) => s.trim());
       } else {
-        const data2 = requireData(
-          await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/tags", {
-            params: { path: { workspace_ext_id: workspaceId } }
-          }),
-          "Failed to fetch tags"
-        );
+        const data2 = await core.tags.listTags(arbi, workspaceId);
         if (data2.length === 0) {
           console.log("No tags found.");
           return;
@@ -1716,27 +4566,15 @@ function registerDoctagsCommand(program2) {
         docIds = await pickDocs(arbi, workspaceId, "Select documents for AI tagging");
         if (docIds.length === 0) return;
       }
-      const data = requireData(
-        await arbi.fetch.POST("/api/document/doctag/generate", {
-          body: { tag_ext_ids: tagIds, doc_ext_ids: docIds }
-        }),
-        "Failed to generate doctags"
-      );
+      const data = await core.doctags.generateDocTags(arbi, tagIds, docIds);
       console.log(
         `Generating doctags for ${data.doc_ext_ids.length} doc(s) with ${data.tag_ext_ids.length} tag(s).`
       );
     })()
   );
 }
-
-// src/commands/conversations.ts
 async function pickConversation(arbi, workspaceId, message = "Select conversation") {
-  const data = requireData(
-    await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/conversations", {
-      params: { path: { workspace_ext_id: workspaceId } }
-    }),
-    "Failed to fetch conversations"
-  );
+  const data = await core.conversations.listConversations(arbi, workspaceId);
   if (data.length === 0) {
     console.log("No conversations found.");
     process.exit(0);
@@ -1755,12 +4593,7 @@ function registerConversationsCommand(program2) {
   conv.command("list").description("List conversations in the active workspace").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").action(
     (opts) => runAction(async () => {
       const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
-      const data = requireData(
-        await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/conversations", {
-          params: { path: { workspace_ext_id: workspaceId } }
-        }),
-        "Failed to fetch conversations"
-      );
+      const data = await core.conversations.listConversations(arbi, workspaceId);
       if (data.length === 0) {
         console.log("No conversations found.");
         return;
@@ -1780,12 +4613,7 @@ function registerConversationsCommand(program2) {
     (conversationId) => runAction(async () => {
       const { arbi, workspaceId } = await resolveWorkspace();
       if (!conversationId) conversationId = await pickConversation(arbi, workspaceId);
-      const data = requireData(
-        await arbi.fetch.GET("/api/conversation/{conversation_ext_id}/threads", {
-          params: { path: { conversation_ext_id: conversationId } }
-        }),
-        "Failed to fetch threads"
-      );
+      const data = await core.conversations.getConversationThreads(arbi, conversationId);
       console.log(JSON.stringify(data, null, 2));
     })()
   );
@@ -1798,12 +4626,7 @@ function registerConversationsCommand(program2) {
           workspaceId,
           "Select conversation to delete"
         );
-      const data = requireData(
-        await arbi.fetch.DELETE("/api/conversation/{conversation_ext_id}", {
-          params: { path: { conversation_ext_id: conversationId } }
-        }),
-        "Failed to delete conversation"
-      );
+      const data = await core.conversations.deleteConversation(arbi, conversationId);
       console.log(data?.detail ?? `Deleted conversation ${conversationId}`);
     })()
   );
@@ -1812,12 +4635,7 @@ function registerConversationsCommand(program2) {
       const { arbi, workspaceId } = await resolveWorkspace();
       if (!conversationId)
         conversationId = await pickConversation(arbi, workspaceId, "Select conversation to share");
-      const data = requireData(
-        await arbi.fetch.POST("/api/conversation/{conversation_ext_id}/share", {
-          params: { path: { conversation_ext_id: conversationId } }
-        }),
-        "Failed to share conversation"
-      );
+      const data = await core.conversations.shareConversation(arbi, conversationId);
       console.log(data?.detail ?? `Shared conversation ${conversationId}`);
     })()
   );
@@ -1826,13 +4644,7 @@ function registerConversationsCommand(program2) {
       const { arbi, workspaceId } = await resolveWorkspace();
       if (!conversationId) conversationId = await pickConversation(arbi, workspaceId);
       if (!title) title = await promptInput("New title");
-      const data = requireData(
-        await arbi.fetch.PATCH("/api/conversation/{conversation_ext_id}/title", {
-          params: { path: { conversation_ext_id: conversationId } },
-          body: { title }
-        }),
-        "Failed to update title"
-      );
+      const data = await core.conversations.updateConversationTitle(arbi, conversationId, title);
       console.log(data?.detail ?? `Updated title to: ${title}`);
     })()
   );
@@ -1841,13 +4653,7 @@ function registerConversationsCommand(program2) {
       const { arbi, workspaceId } = await resolveWorkspace();
       if (!conversationId) conversationId = await pickConversation(arbi, workspaceId);
       if (!userId) userId = await promptInput("User ext_id or email");
-      const data = requireData(
-        await arbi.fetch.POST("/api/conversation/{conversation_ext_id}/user", {
-          params: { path: { conversation_ext_id: conversationId } },
-          body: { user_ext_id: userId }
-        }),
-        "Failed to add user to conversation"
-      );
+      const data = await core.conversations.addConversationUser(arbi, conversationId, userId);
       console.log(data?.detail ?? `Added user ${userId} to conversation`);
     })()
   );
@@ -1856,37 +4662,21 @@ function registerConversationsCommand(program2) {
       const { arbi, workspaceId } = await resolveWorkspace();
       if (!conversationId) conversationId = await pickConversation(arbi, workspaceId);
       if (!userId) userId = await promptInput("User ext_id");
-      const data = requireData(
-        await arbi.fetch.DELETE("/api/conversation/{conversation_ext_id}/user", {
-          params: { path: { conversation_ext_id: conversationId } },
-          body: { user_ext_id: userId }
-        }),
-        "Failed to remove user from conversation"
-      );
+      const data = await core.conversations.removeConversationUser(arbi, conversationId, userId);
       console.log(data?.detail ?? `Removed user ${userId} from conversation`);
     })()
   );
   conv.command("message <message-id>").description("Get message details").action(
     (messageId) => runAction(async () => {
       const { arbi } = await resolveWorkspace();
-      const data = requireData(
-        await arbi.fetch.GET("/api/conversation/message/{message_ext_id}", {
-          params: { path: { message_ext_id: messageId } }
-        }),
-        "Failed to fetch message"
-      );
+      const data = await core.conversations.getMessage(arbi, messageId);
       console.log(JSON.stringify(data, null, 2));
     })()
   );
   conv.command("delete-message <message-id>").description("Delete a message and its descendants").action(
     (messageId) => runAction(async () => {
       const { arbi } = await resolveAuth();
-      const data = requireData(
-        await arbi.fetch.DELETE("/api/conversation/message/{message_ext_id}", {
-          params: { path: { message_ext_id: messageId } }
-        }),
-        "Failed to delete message"
-      );
+      const data = await core.conversations.deleteMessage(arbi, messageId);
       console.log(data?.detail ?? `Deleted message ${messageId}`);
     })()
   );
@@ -1894,17 +4684,12 @@ function registerConversationsCommand(program2) {
     await cmd.commands.find((c) => c.name() === "list").parseAsync([], { from: "user" });
   });
 }
-
-// src/commands/settings.ts
 function registerSettingsCommand(program2) {
   const settings = program2.command("settings").description("Manage user settings");
   settings.command("get").description("Show current user settings").action(
     runAction(async () => {
       const { arbi } = await resolveAuth();
-      const data = requireData(
-        await arbi.fetch.GET("/api/user/settings"),
-        "Failed to fetch settings"
-      );
+      const data = await core.settings.getSettings(arbi);
       console.log(JSON.stringify(data, null, 2));
     })
   );
@@ -1912,10 +4697,7 @@ function registerSettingsCommand(program2) {
     (json) => runAction(async () => {
       const body = parseJsonArg(json, `arbi settings set '{"hide_online_status": true}'`);
       const { arbi } = await resolveAuth();
-      requireOk(
-        await arbi.fetch.PATCH("/api/user/settings", { body }),
-        "Failed to update settings"
-      );
+      await core.settings.updateSettings(arbi, body);
       console.log("Settings updated.");
     })()
   );
@@ -1923,8 +4705,6 @@ function registerSettingsCommand(program2) {
     await settings.commands.find((c) => c.name() === "get").parseAsync([], { from: "user" });
   });
 }
-
-// src/commands/agentconfig.ts
 var MODEL_SECTIONS = [
   "Agents",
   "QueryLLM",
@@ -1935,10 +4715,7 @@ var MODEL_SECTIONS = [
   "ArtifactLLM"
 ];
 async function pickConfig(arbi, message = "Select configuration") {
-  const data = requireData(
-    await arbi.fetch.GET("/api/configs/versions"),
-    "Failed to fetch config versions"
-  );
+  const data = await core.agentconfig.listConfigs(arbi);
   if (data.versions.length === 0) {
     console.log("No saved configurations found.");
     process.exit(0);
@@ -1953,7 +4730,7 @@ async function pickConfig(arbi, message = "Select configuration") {
   );
 }
 async function fetchModels(arbi) {
-  const data = requireData(await arbi.fetch.GET("/api/health/models"), "Failed to fetch models");
+  const data = await core.agentconfig.getModels(arbi);
   return data.models.map((m) => ({
     name: `${m.model_name} (${m.provider ?? m.api_type})`,
     value: m.model_name,
@@ -2075,10 +4852,7 @@ function registerAgentconfigCommand(program2) {
   ac.command("list").description("List saved configuration versions").action(
     runAction(async () => {
       const { arbi } = await resolveAuth();
-      const data = requireData(
-        await arbi.fetch.GET("/api/configs/versions"),
-        "Failed to fetch config versions"
-      );
+      const data = await core.agentconfig.listConfigs(arbi);
       if (data.versions.length === 0) {
         console.log("No saved configurations.");
         return;
@@ -2109,12 +4883,7 @@ function registerAgentconfigCommand(program2) {
           configId = await pickConfig(arbi);
         }
       }
-      const data = requireData(
-        await arbi.fetch.GET("/api/configs/{config_ext_id}", {
-          params: { path: { config_ext_id: configId } }
-        }),
-        "Failed to fetch configuration"
-      );
+      const data = await core.agentconfig.getConfig(arbi, configId);
       console.log(JSON.stringify(data, null, 2));
     })()
   );
@@ -2133,10 +4902,7 @@ function registerAgentconfigCommand(program2) {
       }
       if (opts?.tag) body.tag_ext_id = opts.tag;
       if (opts?.message) body.parent_message_ext_id = opts.message;
-      const data = requireData(
-        await arbi.fetch.POST("/api/configs/", { body }),
-        "Failed to save configuration"
-      );
+      const data = await core.agentconfig.saveConfig(arbi, body);
       console.log(`Saved: ${data.title || "(untitled)"} (${data.external_id})`);
     })()
   );
@@ -2144,22 +4910,14 @@ function registerAgentconfigCommand(program2) {
     (configId) => runAction(async () => {
       const { arbi } = await resolveAuth();
       if (!configId) configId = await pickConfig(arbi, "Select configuration to delete");
-      const data = requireData(
-        await arbi.fetch.DELETE("/api/configs/{config_ext_id}", {
-          params: { path: { config_ext_id: configId } }
-        }),
-        "Failed to delete configuration"
-      );
+      const data = await core.agentconfig.deleteConfig(arbi, configId);
       console.log(data.detail);
     })()
   );
   ac.command("schema").description("Show JSON schema for all configuration models").action(
     runAction(async () => {
       const { arbi } = await resolveAuth();
-      const data = requireData(
-        await arbi.fetch.GET("/api/configs/schema"),
-        "Failed to fetch config schema"
-      );
+      const data = await core.agentconfig.getSchema(arbi);
       console.log(JSON.stringify(data, null, 2));
     })
   );
@@ -2167,16 +4925,11 @@ function registerAgentconfigCommand(program2) {
     await ac.commands.find((c) => c.name() === "list").parseAsync([], { from: "user" });
   });
 }
-
-// src/commands/health.ts
 function registerHealthCommand(program2) {
   program2.command("health").description("Show server health status").action(
     runAction(async () => {
       const { arbi } = await resolveAuth();
-      const data = requireData(
-        await arbi.fetch.GET("/api/health/"),
-        "Failed to fetch health status"
-      );
+      const data = await core.health.getHealth(arbi);
       console.log(`Status: ${data.status}`);
       if (data.backend_git_hash) console.log(`Backend: ${data.backend_git_hash}`);
       if (data.frontend_docker_version) console.log(`Frontend: ${data.frontend_docker_version}`);
@@ -2198,10 +4951,7 @@ Models (${data.models_health.application}):`);
   program2.command("models").description("List available AI models").action(
     runAction(async () => {
       const { arbi } = await resolveAuth();
-      const data = requireData(
-        await arbi.fetch.GET("/api/health/models"),
-        "Failed to fetch models"
-      );
+      const data = await core.health.getHealthModels(arbi);
       if (data.models.length === 0) {
         console.log("No models available.");
         return;
@@ -2217,6 +4967,43 @@ Models (${data.models_health.application}):`);
     })
   );
 }
+function findTuiEntryPoint() {
+  const require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+  try {
+    return require2.resolve("@arbidocs/tui");
+  } catch {
+  }
+  try {
+    const resolved = child_process.execFileSync("which", ["arbi-tui"], { encoding: "utf-8" }).trim();
+    if (resolved) return resolved;
+  } catch {
+  }
+  return null;
+}
+function registerTuiCommand(program2) {
+  program2.command("tui").description("Launch interactive terminal UI").option("-w, --workspace <id>", "Workspace ID to use").allowUnknownOption(true).action((opts, cmd) => {
+    const args = [];
+    if (opts.workspace) {
+      args.push("-w", opts.workspace);
+    }
+    args.push(...cmd.args);
+    const entryPoint = findTuiEntryPoint();
+    if (entryPoint) {
+      const child = child_process.spawn(process.execPath, [entryPoint, ...args], {
+        stdio: "inherit",
+        env: process.env
+      });
+      child.on("exit", (code) => process.exit(code ?? 0));
+    } else {
+      console.log("arbi-tui not installed locally. Launching via npx...\n");
+      const child = child_process.spawn("npx", ["--yes", "@arbidocs/tui", ...args], {
+        stdio: "inherit",
+        env: process.env
+      });
+      child.on("exit", (code) => process.exit(code ?? 0));
+    }
+  });
+}
 
 // src/index.ts
 console.debug = () => {
@@ -2247,6 +5034,7 @@ registerConversationsCommand(program);
 registerSettingsCommand(program);
 registerAgentconfigCommand(program);
 registerHealthCommand(program);
+registerTuiCommand(program);
 program.parse();
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map