@arcote.tech/arc-adapter-db-sqlite 0.3.2 → 0.4.1

package/dist/index.js

@@ -0,0 +1,4782 @@
+// src/bun-sqlite.ts
+import { Database } from "bun:sqlite";
+
+// ../../../../node_modules/mutative/dist/mutative.esm.mjs
+var Operation = {
+  Remove: "remove",
+  Replace: "replace",
+  Add: "add"
+};
+var PROXY_DRAFT = Symbol.for("__MUTATIVE_PROXY_DRAFT__");
+var RAW_RETURN_SYMBOL = Symbol("__MUTATIVE_RAW_RETURN_SYMBOL__");
+var iteratorSymbol = Symbol.iterator;
+var dataTypes = {
+  mutable: "mutable",
+  immutable: "immutable"
+};
+var internal = {};
+function has(target, key) {
+  return target instanceof Map ? target.has(key) : Object.prototype.hasOwnProperty.call(target, key);
+}
+function getDescriptor(target, key) {
+  if (key in target) {
+    let prototype = Reflect.getPrototypeOf(target);
+    while (prototype) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(prototype, key);
+      if (descriptor)
+        return descriptor;
+      prototype = Reflect.getPrototypeOf(prototype);
+    }
+  }
+  return;
+}
+function isBaseSetInstance(obj) {
+  return Object.getPrototypeOf(obj) === Set.prototype;
+}
+function isBaseMapInstance(obj) {
+  return Object.getPrototypeOf(obj) === Map.prototype;
+}
+function latest(proxyDraft) {
+  var _a;
+  return (_a = proxyDraft.copy) !== null && _a !== undefined ? _a : proxyDraft.original;
+}
+function isDraft(target) {
+  return !!getProxyDraft(target);
+}
+function getProxyDraft(value) {
+  if (typeof value !== "object")
+    return null;
+  return value === null || value === undefined ? undefined : value[PROXY_DRAFT];
+}
+function getValue(value) {
+  var _a;
+  const proxyDraft = getProxyDraft(value);
+  return proxyDraft ? (_a = proxyDraft.copy) !== null && _a !== undefined ? _a : proxyDraft.original : value;
+}
+function isDraftable(value, options) {
+  if (!value || typeof value !== "object")
+    return false;
+  let markResult;
+  return Object.getPrototypeOf(value) === Object.prototype || Array.isArray(value) || value instanceof Map || value instanceof Set || !!(options === null || options === undefined ? undefined : options.mark) && ((markResult = options.mark(value, dataTypes)) === dataTypes.immutable || typeof markResult === "function");
+}
+function getPath(target, path = []) {
+  if (Object.hasOwnProperty.call(target, "key")) {
+    const parentCopy = target.parent.copy;
+    const proxyDraft = getProxyDraft(get(parentCopy, target.key));
+    if (proxyDraft !== null && (proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.original) !== target.original) {
+      return null;
+    }
+    const isSet = target.parent.type === 3;
+    const key = isSet ? Array.from(target.parent.setMap.keys()).indexOf(target.key) : target.key;
+    if (!(isSet && parentCopy.size > key || has(parentCopy, key)))
+      return null;
+    path.push(key);
+  }
+  if (target.parent) {
+    return getPath(target.parent, path);
+  }
+  path.reverse();
+  try {
+    resolvePath(target.copy, path);
+  } catch (e) {
+    return null;
+  }
+  return path;
+}
+function getType(target) {
+  if (Array.isArray(target))
+    return 1;
+  if (target instanceof Map)
+    return 2;
+  if (target instanceof Set)
+    return 3;
+  return 0;
+}
+function get(target, key) {
+  return getType(target) === 2 ? target.get(key) : target[key];
+}
+function set(target, key, value) {
+  const type = getType(target);
+  if (type === 2) {
+    target.set(key, value);
+  } else {
+    target[key] = value;
+  }
+}
+function peek(target, key) {
+  const state = getProxyDraft(target);
+  const source = state ? latest(state) : target;
+  return source[key];
+}
+function isEqual(x, y) {
+  if (x === y) {
+    return x !== 0 || 1 / x === 1 / y;
+  } else {
+    return x !== x && y !== y;
+  }
+}
+function revokeProxy(proxyDraft) {
+  if (!proxyDraft)
+    return;
+  while (proxyDraft.finalities.revoke.length > 0) {
+    const revoke = proxyDraft.finalities.revoke.pop();
+    revoke();
+  }
+}
+function escapePath(path, pathAsArray) {
+  return pathAsArray ? path : [""].concat(path).map((_item) => {
+    const item = `${_item}`;
+    if (item.indexOf("/") === -1 && item.indexOf("~") === -1)
+      return item;
+    return item.replace(/~/g, "~0").replace(/\//g, "~1");
+  }).join("/");
+}
+function unescapePath(path) {
+  if (Array.isArray(path))
+    return path;
+  return path.split("/").map((_item) => _item.replace(/~1/g, "/").replace(/~0/g, "~")).slice(1);
+}
+function resolvePath(base, path) {
+  for (let index = 0;index < path.length - 1; index += 1) {
+    const key = path[index];
+    base = get(getType(base) === 3 ? Array.from(base) : base, key);
+    if (typeof base !== "object") {
+      throw new Error(`Cannot resolve patch at '${path.join("/")}'.`);
+    }
+  }
+  return base;
+}
+function strictCopy(target) {
+  const copy = Object.create(Object.getPrototypeOf(target));
+  Reflect.ownKeys(target).forEach((key) => {
+    let desc = Reflect.getOwnPropertyDescriptor(target, key);
+    if (desc.enumerable && desc.configurable && desc.writable) {
+      copy[key] = target[key];
+      return;
+    }
+    if (!desc.writable) {
+      desc.writable = true;
+      desc.configurable = true;
+    }
+    if (desc.get || desc.set)
+      desc = {
+        configurable: true,
+        writable: true,
+        enumerable: desc.enumerable,
+        value: target[key]
+      };
+    Reflect.defineProperty(copy, key, desc);
+  });
+  return copy;
+}
+var propIsEnum = Object.prototype.propertyIsEnumerable;
+function shallowCopy(original, options) {
+  let markResult;
+  if (Array.isArray(original)) {
+    return Array.prototype.concat.call(original);
+  } else if (original instanceof Set) {
+    if (!isBaseSetInstance(original)) {
+      const SubClass = Object.getPrototypeOf(original).constructor;
+      return new SubClass(original.values());
+    }
+    return Set.prototype.difference ? Set.prototype.difference.call(original, new Set) : new Set(original.values());
+  } else if (original instanceof Map) {
+    if (!isBaseMapInstance(original)) {
+      const SubClass = Object.getPrototypeOf(original).constructor;
+      return new SubClass(original);
+    }
+    return new Map(original);
+  } else if ((options === null || options === undefined ? undefined : options.mark) && (markResult = options.mark(original, dataTypes), markResult !== undefined) && markResult !== dataTypes.mutable) {
+    if (markResult === dataTypes.immutable) {
+      return strictCopy(original);
+    } else if (typeof markResult === "function") {
+      if (options.enablePatches || options.enableAutoFreeze) {
+        throw new Error(`You can't use mark and patches or auto freeze together.`);
+      }
+      return markResult();
+    }
+    throw new Error(`Unsupported mark result: ${markResult}`);
+  } else if (typeof original === "object" && Object.getPrototypeOf(original) === Object.prototype) {
+    const copy = {};
+    Object.keys(original).forEach((key) => {
+      copy[key] = original[key];
+    });
+    Object.getOwnPropertySymbols(original).forEach((key) => {
+      if (propIsEnum.call(original, key)) {
+        copy[key] = original[key];
+      }
+    });
+    return copy;
+  } else {
+    throw new Error(`Please check mark() to ensure that it is a stable marker draftable function.`);
+  }
+}
+function ensureShallowCopy(target) {
+  if (target.copy)
+    return;
+  target.copy = shallowCopy(target.original, target.options);
+}
+function deepClone(target) {
+  if (!isDraftable(target))
+    return getValue(target);
+  if (Array.isArray(target))
+    return target.map(deepClone);
+  if (target instanceof Map) {
+    const iterable = Array.from(target.entries()).map(([k, v]) => [
+      k,
+      deepClone(v)
+    ]);
+    if (!isBaseMapInstance(target)) {
+      const SubClass = Object.getPrototypeOf(target).constructor;
+      return new SubClass(iterable);
+    }
+    return new Map(iterable);
+  }
+  if (target instanceof Set) {
+    const iterable = Array.from(target).map(deepClone);
+    if (!isBaseSetInstance(target)) {
+      const SubClass = Object.getPrototypeOf(target).constructor;
+      return new SubClass(iterable);
+    }
+    return new Set(iterable);
+  }
+  const copy = Object.create(Object.getPrototypeOf(target));
+  for (const key in target)
+    copy[key] = deepClone(target[key]);
+  return copy;
+}
+function cloneIfNeeded(target) {
+  return isDraft(target) ? deepClone(target) : target;
+}
+function markChanged(proxyDraft) {
+  var _a;
+  proxyDraft.assignedMap = (_a = proxyDraft.assignedMap) !== null && _a !== undefined ? _a : new Map;
+  if (!proxyDraft.operated) {
+    proxyDraft.operated = true;
+    if (proxyDraft.parent) {
+      markChanged(proxyDraft.parent);
+    }
+  }
+}
+function throwFrozenError() {
+  throw new Error("Cannot modify frozen object");
+}
+function deepFreeze(target, subKey, updatedValues, stack, keys) {
+  {
+    updatedValues = updatedValues !== null && updatedValues !== undefined ? updatedValues : new WeakMap;
+    stack = stack !== null && stack !== undefined ? stack : [];
+    keys = keys !== null && keys !== undefined ? keys : [];
+    const value = updatedValues.has(target) ? updatedValues.get(target) : target;
+    if (stack.length > 0) {
+      const index = stack.indexOf(value);
+      if (value && typeof value === "object" && index !== -1) {
+        if (stack[0] === value) {
+          throw new Error(`Forbids circular reference`);
+        }
+        throw new Error(`Forbids circular reference: ~/${keys.slice(0, index).map((key, index2) => {
+          if (typeof key === "symbol")
+            return `[${key.toString()}]`;
+          const parent = stack[index2];
+          if (typeof key === "object" && (parent instanceof Map || parent instanceof Set))
+            return Array.from(parent.keys()).indexOf(key);
+          return key;
+        }).join("/")}`);
+      }
+      stack.push(value);
+      keys.push(subKey);
+    } else {
+      stack.push(value);
+    }
+  }
+  if (Object.isFrozen(target) || isDraft(target)) {
+    {
+      stack.pop();
+      keys.pop();
+    }
+    return;
+  }
+  const type = getType(target);
+  switch (type) {
+    case 2:
+      for (const [key, value] of target) {
+        deepFreeze(key, key, updatedValues, stack, keys);
+        deepFreeze(value, key, updatedValues, stack, keys);
+      }
+      target.set = target.clear = target.delete = throwFrozenError;
+      break;
+    case 3:
+      for (const value of target) {
+        deepFreeze(value, value, updatedValues, stack, keys);
+      }
+      target.add = target.clear = target.delete = throwFrozenError;
+      break;
+    case 1:
+      Object.freeze(target);
+      let index = 0;
+      for (const value of target) {
+        deepFreeze(value, index, updatedValues, stack, keys);
+        index += 1;
+      }
+      break;
+    default:
+      Object.freeze(target);
+      Object.keys(target).forEach((name) => {
+        const value = target[name];
+        deepFreeze(value, name, updatedValues, stack, keys);
+      });
+  }
+  {
+    stack.pop();
+    keys.pop();
+  }
+}
+function forEach(target, iter) {
+  const type = getType(target);
+  if (type === 0) {
+    Reflect.ownKeys(target).forEach((key) => {
+      iter(key, target[key], target);
+    });
+  } else if (type === 1) {
+    let index = 0;
+    for (const entry of target) {
+      iter(index, entry, target);
+      index += 1;
+    }
+  } else {
+    target.forEach((entry, index) => iter(index, entry, target));
+  }
+}
+function handleValue(target, handledSet, options) {
+  if (isDraft(target) || !isDraftable(target, options) || handledSet.has(target) || Object.isFrozen(target))
+    return;
+  const isSet = target instanceof Set;
+  const setMap = isSet ? new Map : undefined;
+  handledSet.add(target);
+  forEach(target, (key, value) => {
+    var _a;
+    if (isDraft(value)) {
+      const proxyDraft = getProxyDraft(value);
+      ensureShallowCopy(proxyDraft);
+      const updatedValue = ((_a = proxyDraft.assignedMap) === null || _a === undefined ? undefined : _a.size) || proxyDraft.operated ? proxyDraft.copy : proxyDraft.original;
+      set(isSet ? setMap : target, key, updatedValue);
+    } else {
+      handleValue(value, handledSet, options);
+    }
+  });
+  if (setMap) {
+    const set2 = target;
+    const values = Array.from(set2);
+    set2.clear();
+    values.forEach((value) => {
+      set2.add(setMap.has(value) ? setMap.get(value) : value);
+    });
+  }
+}
+function finalizeAssigned(proxyDraft, key) {
+  const copy = proxyDraft.type === 3 ? proxyDraft.setMap : proxyDraft.copy;
+  if (proxyDraft.finalities.revoke.length > 1 && proxyDraft.assignedMap.get(key) && copy) {
+    handleValue(get(copy, key), proxyDraft.finalities.handledSet, proxyDraft.options);
+  }
+}
+function finalizeSetValue(target) {
+  if (target.type === 3 && target.copy) {
+    target.copy.clear();
+    target.setMap.forEach((value) => {
+      target.copy.add(getValue(value));
+    });
+  }
+}
+function finalizePatches(target, generatePatches, patches, inversePatches) {
+  const shouldFinalize = target.operated && target.assignedMap && target.assignedMap.size > 0 && !target.finalized;
+  if (shouldFinalize) {
+    if (patches && inversePatches) {
+      const basePath = getPath(target);
+      if (basePath) {
+        generatePatches(target, basePath, patches, inversePatches);
+      }
+    }
+    target.finalized = true;
+  }
+}
+function markFinalization(target, key, value, generatePatches) {
+  const proxyDraft = getProxyDraft(value);
+  if (proxyDraft) {
+    if (!proxyDraft.callbacks) {
+      proxyDraft.callbacks = [];
+    }
+    proxyDraft.callbacks.push((patches, inversePatches) => {
+      var _a;
+      const copy = target.type === 3 ? target.setMap : target.copy;
+      if (isEqual(get(copy, key), value)) {
+        let updatedValue = proxyDraft.original;
+        if (proxyDraft.copy) {
+          updatedValue = proxyDraft.copy;
+        }
+        finalizeSetValue(target);
+        finalizePatches(target, generatePatches, patches, inversePatches);
+        if (target.options.enableAutoFreeze) {
+          target.options.updatedValues = (_a = target.options.updatedValues) !== null && _a !== undefined ? _a : new WeakMap;
+          target.options.updatedValues.set(updatedValue, proxyDraft.original);
+        }
+        set(copy, key, updatedValue);
+      }
+    });
+    if (target.options.enableAutoFreeze) {
+      if (proxyDraft.finalities !== target.finalities) {
+        target.options.enableAutoFreeze = false;
+      }
+    }
+  }
+  if (isDraftable(value, target.options)) {
+    target.finalities.draft.push(() => {
+      const copy = target.type === 3 ? target.setMap : target.copy;
+      if (isEqual(get(copy, key), value)) {
+        finalizeAssigned(target, key);
+      }
+    });
+  }
+}
+function generateArrayPatches(proxyState, basePath, patches, inversePatches, pathAsArray) {
+  let { original, assignedMap, options } = proxyState;
+  let copy = proxyState.copy;
+  if (copy.length < original.length) {
+    [original, copy] = [copy, original];
+    [patches, inversePatches] = [inversePatches, patches];
+  }
+  for (let index = 0;index < original.length; index += 1) {
+    if (assignedMap.get(index.toString()) && copy[index] !== original[index]) {
+      const _path = basePath.concat([index]);
+      const path = escapePath(_path, pathAsArray);
+      patches.push({
+        op: Operation.Replace,
+        path,
+        value: cloneIfNeeded(copy[index])
+      });
+      inversePatches.push({
+        op: Operation.Replace,
+        path,
+        value: cloneIfNeeded(original[index])
+      });
+    }
+  }
+  for (let index = original.length;index < copy.length; index += 1) {
+    const _path = basePath.concat([index]);
+    const path = escapePath(_path, pathAsArray);
+    patches.push({
+      op: Operation.Add,
+      path,
+      value: cloneIfNeeded(copy[index])
+    });
+  }
+  if (original.length < copy.length) {
+    const { arrayLengthAssignment = true } = options.enablePatches;
+    if (arrayLengthAssignment) {
+      const _path = basePath.concat(["length"]);
+      const path = escapePath(_path, pathAsArray);
+      inversePatches.push({
+        op: Operation.Replace,
+        path,
+        value: original.length
+      });
+    } else {
+      for (let index = copy.length;original.length < index; index -= 1) {
+        const _path = basePath.concat([index - 1]);
+        const path = escapePath(_path, pathAsArray);
+        inversePatches.push({
+          op: Operation.Remove,
+          path
+        });
+      }
+    }
+  }
+}
+function generatePatchesFromAssigned({ original, copy, assignedMap }, basePath, patches, inversePatches, pathAsArray) {
+  assignedMap.forEach((assignedValue, key) => {
+    const originalValue = get(original, key);
+    const value = cloneIfNeeded(get(copy, key));
+    const op = !assignedValue ? Operation.Remove : has(original, key) ? Operation.Replace : Operation.Add;
+    if (isEqual(originalValue, value) && op === Operation.Replace)
+      return;
+    const _path = basePath.concat(key);
+    const path = escapePath(_path, pathAsArray);
+    patches.push(op === Operation.Remove ? { op, path } : { op, path, value });
+    inversePatches.push(op === Operation.Add ? { op: Operation.Remove, path } : op === Operation.Remove ? { op: Operation.Add, path, value: originalValue } : { op: Operation.Replace, path, value: originalValue });
+  });
+}
+function generateSetPatches({ original, copy }, basePath, patches, inversePatches, pathAsArray) {
+  let index = 0;
+  original.forEach((value) => {
+    if (!copy.has(value)) {
+      const _path = basePath.concat([index]);
+      const path = escapePath(_path, pathAsArray);
+      patches.push({
+        op: Operation.Remove,
+        path,
+        value
+      });
+      inversePatches.unshift({
+        op: Operation.Add,
+        path,
+        value
+      });
+    }
+    index += 1;
+  });
+  index = 0;
+  copy.forEach((value) => {
+    if (!original.has(value)) {
+      const _path = basePath.concat([index]);
+      const path = escapePath(_path, pathAsArray);
+      patches.push({
+        op: Operation.Add,
+        path,
+        value
+      });
+      inversePatches.unshift({
+        op: Operation.Remove,
+        path,
+        value
+      });
+    }
+    index += 1;
+  });
+}
+function generatePatches(proxyState, basePath, patches, inversePatches) {
+  const { pathAsArray = true } = proxyState.options.enablePatches;
+  switch (proxyState.type) {
+    case 0:
+    case 2:
+      return generatePatchesFromAssigned(proxyState, basePath, patches, inversePatches, pathAsArray);
+    case 1:
+      return generateArrayPatches(proxyState, basePath, patches, inversePatches, pathAsArray);
+    case 3:
+      return generateSetPatches(proxyState, basePath, patches, inversePatches, pathAsArray);
+  }
+}
+var readable = false;
+var checkReadable = (value, options, ignoreCheckDraftable = false) => {
+  if (typeof value === "object" && value !== null && (!isDraftable(value, options) || ignoreCheckDraftable) && !readable) {
+    throw new Error(`Strict mode: Mutable data cannot be accessed directly, please use 'unsafe(callback)' wrap.`);
+  }
+};
+var mapHandler = {
+  get size() {
+    const current = latest(getProxyDraft(this));
+    return current.size;
+  },
+  has(key) {
+    return latest(getProxyDraft(this)).has(key);
+  },
+  set(key, value) {
+    const target = getProxyDraft(this);
+    const source = latest(target);
+    if (!source.has(key) || !isEqual(source.get(key), value)) {
+      ensureShallowCopy(target);
+      markChanged(target);
+      target.assignedMap.set(key, true);
+      target.copy.set(key, value);
+      markFinalization(target, key, value, generatePatches);
+    }
+    return this;
+  },
+  delete(key) {
+    if (!this.has(key)) {
+      return false;
+    }
+    const target = getProxyDraft(this);
+    ensureShallowCopy(target);
+    markChanged(target);
+    if (target.original.has(key)) {
+      target.assignedMap.set(key, false);
+    } else {
+      target.assignedMap.delete(key);
+    }
+    target.copy.delete(key);
+    return true;
+  },
+  clear() {
+    const target = getProxyDraft(this);
+    if (!this.size)
+      return;
+    ensureShallowCopy(target);
+    markChanged(target);
+    target.assignedMap = new Map;
+    for (const [key] of target.original) {
+      target.assignedMap.set(key, false);
+    }
+    target.copy.clear();
+  },
+  forEach(callback, thisArg) {
+    const target = getProxyDraft(this);
+    latest(target).forEach((_value, _key) => {
+      callback.call(thisArg, this.get(_key), _key, this);
+    });
+  },
+  get(key) {
+    var _a, _b;
+    const target = getProxyDraft(this);
+    const value = latest(target).get(key);
+    const mutable = ((_b = (_a = target.options).mark) === null || _b === undefined ? undefined : _b.call(_a, value, dataTypes)) === dataTypes.mutable;
+    if (target.options.strict) {
+      checkReadable(value, target.options, mutable);
+    }
+    if (mutable) {
+      return value;
+    }
+    if (target.finalized || !isDraftable(value, target.options)) {
+      return value;
+    }
+    if (value !== target.original.get(key)) {
+      return value;
+    }
+    const draft = internal.createDraft({
+      original: value,
+      parentDraft: target,
+      key,
+      finalities: target.finalities,
+      options: target.options
+    });
+    ensureShallowCopy(target);
+    target.copy.set(key, draft);
+    return draft;
+  },
+  keys() {
+    return latest(getProxyDraft(this)).keys();
+  },
+  values() {
+    const iterator = this.keys();
+    return {
+      [iteratorSymbol]: () => this.values(),
+      next: () => {
+        const result = iterator.next();
+        if (result.done)
+          return result;
+        const value = this.get(result.value);
+        return {
+          done: false,
+          value
+        };
+      }
+    };
+  },
+  entries() {
+    const iterator = this.keys();
+    return {
+      [iteratorSymbol]: () => this.entries(),
+      next: () => {
+        const result = iterator.next();
+        if (result.done)
+          return result;
+        const value = this.get(result.value);
+        return {
+          done: false,
+          value: [result.value, value]
+        };
+      }
+    };
+  },
+  [iteratorSymbol]() {
+    return this.entries();
+  }
+};
+var mapHandlerKeys = Reflect.ownKeys(mapHandler);
+var getNextIterator = (target, iterator, { isValuesIterator }) => () => {
+  var _a, _b;
+  const result = iterator.next();
+  if (result.done)
+    return result;
+  const key = result.value;
+  let value = target.setMap.get(key);
+  const currentDraft = getProxyDraft(value);
+  const mutable = ((_b = (_a = target.options).mark) === null || _b === undefined ? undefined : _b.call(_a, value, dataTypes)) === dataTypes.mutable;
+  if (target.options.strict) {
+    checkReadable(key, target.options, mutable);
+  }
+  if (!mutable && !currentDraft && isDraftable(key, target.options) && !target.finalized && target.original.has(key)) {
+    const proxy = internal.createDraft({
+      original: key,
+      parentDraft: target,
+      key,
+      finalities: target.finalities,
+      options: target.options
+    });
+    target.setMap.set(key, proxy);
+    value = proxy;
+  } else if (currentDraft) {
+    value = currentDraft.proxy;
+  }
+  return {
+    done: false,
+    value: isValuesIterator ? value : [value, value]
+  };
+};
+var setHandler = {
+  get size() {
+    const target = getProxyDraft(this);
+    return target.setMap.size;
+  },
+  has(value) {
+    const target = getProxyDraft(this);
+    if (target.setMap.has(value))
+      return true;
+    ensureShallowCopy(target);
+    const valueProxyDraft = getProxyDraft(value);
+    if (valueProxyDraft && target.setMap.has(valueProxyDraft.original))
+      return true;
+    return false;
+  },
+  add(value) {
+    const target = getProxyDraft(this);
+    if (!this.has(value)) {
+      ensureShallowCopy(target);
+      markChanged(target);
+      target.assignedMap.set(value, true);
+      target.setMap.set(value, value);
+      markFinalization(target, value, value, generatePatches);
+    }
+    return this;
+  },
+  delete(value) {
+    if (!this.has(value)) {
+      return false;
+    }
+    const target = getProxyDraft(this);
+    ensureShallowCopy(target);
+    markChanged(target);
+    const valueProxyDraft = getProxyDraft(value);
+    if (valueProxyDraft && target.setMap.has(valueProxyDraft.original)) {
+      target.assignedMap.set(valueProxyDraft.original, false);
+      return target.setMap.delete(valueProxyDraft.original);
+    }
+    if (!valueProxyDraft && target.setMap.has(value)) {
+      target.assignedMap.set(value, false);
+    } else {
+      target.assignedMap.delete(value);
+    }
+    return target.setMap.delete(value);
+  },
+  clear() {
+    if (!this.size)
+      return;
+    const target = getProxyDraft(this);
+    ensureShallowCopy(target);
+    markChanged(target);
+    for (const value of target.original) {
+      target.assignedMap.set(value, false);
+    }
+    target.setMap.clear();
+  },
+  values() {
+    const target = getProxyDraft(this);
+    ensureShallowCopy(target);
+    const iterator = target.setMap.keys();
+    return {
+      [Symbol.iterator]: () => this.values(),
+      next: getNextIterator(target, iterator, { isValuesIterator: true })
+    };
+  },
+  entries() {
+    const target = getProxyDraft(this);
+    ensureShallowCopy(target);
+    const iterator = target.setMap.keys();
+    return {
+      [Symbol.iterator]: () => this.entries(),
+      next: getNextIterator(target, iterator, {
+        isValuesIterator: false
+      })
+    };
+  },
+  keys() {
+    return this.values();
+  },
+  [iteratorSymbol]() {
+    return this.values();
+  },
+  forEach(callback, thisArg) {
+    const iterator = this.values();
+    let result = iterator.next();
+    while (!result.done) {
+      callback.call(thisArg, result.value, result.value, this);
+      result = iterator.next();
+    }
+  }
+};
+if (Set.prototype.difference) {
+  Object.assign(setHandler, {
+    intersection(other) {
+      return Set.prototype.intersection.call(new Set(this.values()), other);
+    },
+    union(other) {
+      return Set.prototype.union.call(new Set(this.values()), other);
+    },
+    difference(other) {
+      return Set.prototype.difference.call(new Set(this.values()), other);
+    },
+    symmetricDifference(other) {
+      return Set.prototype.symmetricDifference.call(new Set(this.values()), other);
+    },
+    isSubsetOf(other) {
+      return Set.prototype.isSubsetOf.call(new Set(this.values()), other);
+    },
+    isSupersetOf(other) {
+      return Set.prototype.isSupersetOf.call(new Set(this.values()), other);
+    },
+    isDisjointFrom(other) {
+      return Set.prototype.isDisjointFrom.call(new Set(this.values()), other);
+    }
+  });
+}
+var setHandlerKeys = Reflect.ownKeys(setHandler);
+var proxyHandler = {
+  get(target, key, receiver) {
+    var _a, _b;
+    const copy = (_a = target.copy) === null || _a === undefined ? undefined : _a[key];
+    if (copy && target.finalities.draftsCache.has(copy)) {
+      return copy;
+    }
+    if (key === PROXY_DRAFT)
+      return target;
+    let markResult;
+    if (target.options.mark) {
+      const value2 = key === "size" && (target.original instanceof Map || target.original instanceof Set) ? Reflect.get(target.original, key) : Reflect.get(target.original, key, receiver);
+      markResult = target.options.mark(value2, dataTypes);
+      if (markResult === dataTypes.mutable) {
+        if (target.options.strict) {
+          checkReadable(value2, target.options, true);
+        }
+        return value2;
+      }
+    }
+    const source = latest(target);
+    if (source instanceof Map && mapHandlerKeys.includes(key)) {
+      if (key === "size") {
+        return Object.getOwnPropertyDescriptor(mapHandler, "size").get.call(target.proxy);
+      }
+      const handle = mapHandler[key];
+      return handle.bind(target.proxy);
+    }
+    if (source instanceof Set && setHandlerKeys.includes(key)) {
+      if (key === "size") {
+        return Object.getOwnPropertyDescriptor(setHandler, "size").get.call(target.proxy);
+      }
+      const handle = setHandler[key];
+      return handle.bind(target.proxy);
+    }
+    if (!has(source, key)) {
+      const desc = getDescriptor(source, key);
+      return desc ? `value` in desc ? desc.value : (_b = desc.get) === null || _b === undefined ? undefined : _b.call(target.proxy) : undefined;
+    }
+    const value = source[key];
+    if (target.options.strict) {
+      checkReadable(value, target.options);
+    }
+    if (target.finalized || !isDraftable(value, target.options)) {
+      return value;
+    }
+    if (value === peek(target.original, key)) {
+      ensureShallowCopy(target);
+      target.copy[key] = createDraft({
+        original: target.original[key],
+        parentDraft: target,
+        key: target.type === 1 ? Number(key) : key,
+        finalities: target.finalities,
+        options: target.options
+      });
+      if (typeof markResult === "function") {
+        const subProxyDraft = getProxyDraft(target.copy[key]);
+        ensureShallowCopy(subProxyDraft);
+        markChanged(subProxyDraft);
+        return subProxyDraft.copy;
+      }
+      return target.copy[key];
+    }
+    if (isDraft(value)) {
+      target.finalities.draftsCache.add(value);
+    }
+    return value;
+  },
+  set(target, key, value) {
+    var _a;
+    if (target.type === 3 || target.type === 2) {
+      throw new Error(`Map/Set draft does not support any property assignment.`);
+    }
+    let _key;
+    if (target.type === 1 && key !== "length" && !(Number.isInteger(_key = Number(key)) && _key >= 0 && (key === 0 || _key === 0 || String(_key) === String(key)))) {
+      throw new Error(`Only supports setting array indices and the 'length' property.`);
+    }
+    const desc = getDescriptor(latest(target), key);
+    if (desc === null || desc === undefined ? undefined : desc.set) {
+      desc.set.call(target.proxy, value);
+      return true;
+    }
+    const current = peek(latest(target), key);
+    const currentProxyDraft = getProxyDraft(current);
+    if (currentProxyDraft && isEqual(currentProxyDraft.original, value)) {
+      target.copy[key] = value;
+      target.assignedMap = (_a = target.assignedMap) !== null && _a !== undefined ? _a : new Map;
+      target.assignedMap.set(key, false);
+      return true;
+    }
+    if (isEqual(value, current) && (value !== undefined || has(target.original, key)))
+      return true;
+    ensureShallowCopy(target);
+    markChanged(target);
+    if (has(target.original, key) && isEqual(value, target.original[key])) {
+      target.assignedMap.delete(key);
+    } else {
+      target.assignedMap.set(key, true);
+    }
+    target.copy[key] = value;
+    markFinalization(target, key, value, generatePatches);
+    return true;
+  },
+  has(target, key) {
+    return key in latest(target);
+  },
+  ownKeys(target) {
+    return Reflect.ownKeys(latest(target));
+  },
+  getOwnPropertyDescriptor(target, key) {
+    const source = latest(target);
+    const descriptor = Reflect.getOwnPropertyDescriptor(source, key);
+    if (!descriptor)
+      return descriptor;
+    return {
+      writable: true,
+      configurable: target.type !== 1 || key !== "length",
+      enumerable: descriptor.enumerable,
+      value: source[key]
+    };
+  },
+  getPrototypeOf(target) {
+    return Reflect.getPrototypeOf(target.original);
+  },
+  setPrototypeOf() {
+    throw new Error(`Cannot call 'setPrototypeOf()' on drafts`);
+  },
+  defineProperty() {
+    throw new Error(`Cannot call 'defineProperty()' on drafts`);
+  },
+  deleteProperty(target, key) {
+    var _a;
+    if (target.type === 1) {
+      return proxyHandler.set.call(this, target, key, undefined, target.proxy);
+    }
+    if (peek(target.original, key) !== undefined || key in target.original) {
+      ensureShallowCopy(target);
+      markChanged(target);
+      target.assignedMap.set(key, false);
+    } else {
+      target.assignedMap = (_a = target.assignedMap) !== null && _a !== undefined ? _a : new Map;
+      target.assignedMap.delete(key);
+    }
+    if (target.copy)
+      delete target.copy[key];
+    return true;
+  }
+};
+function createDraft(createDraftOptions) {
+  const { original, parentDraft, key, finalities, options } = createDraftOptions;
+  const type = getType(original);
+  const proxyDraft = {
+    type,
+    finalized: false,
+    parent: parentDraft,
+    original,
+    copy: null,
+    proxy: null,
+    finalities,
+    options,
+    setMap: type === 3 ? new Map(original.entries()) : undefined
+  };
+  if (key || "key" in createDraftOptions) {
+    proxyDraft.key = key;
+  }
+  const { proxy, revoke } = Proxy.revocable(type === 1 ? Object.assign([], proxyDraft) : proxyDraft, proxyHandler);
+  finalities.revoke.push(revoke);
+  proxyDraft.proxy = proxy;
+  if (parentDraft) {
+    const target = parentDraft;
+    target.finalities.draft.push((patches, inversePatches) => {
+      var _a, _b;
+      const oldProxyDraft = getProxyDraft(proxy);
+      let copy = target.type === 3 ? target.setMap : target.copy;
+      const draft = get(copy, key);
+      const proxyDraft2 = getProxyDraft(draft);
+      if (proxyDraft2) {
+        let updatedValue = proxyDraft2.original;
+        if (proxyDraft2.operated) {
+          updatedValue = getValue(draft);
+        }
+        finalizeSetValue(proxyDraft2);
+        finalizePatches(proxyDraft2, generatePatches, patches, inversePatches);
+        if (target.options.enableAutoFreeze) {
+          target.options.updatedValues = (_a = target.options.updatedValues) !== null && _a !== undefined ? _a : new WeakMap;
+          target.options.updatedValues.set(updatedValue, proxyDraft2.original);
+        }
+        set(copy, key, updatedValue);
+      }
+      (_b = oldProxyDraft.callbacks) === null || _b === undefined || _b.forEach((callback) => {
+        callback(patches, inversePatches);
+      });
+    });
+  } else {
+    const target = getProxyDraft(proxy);
+    target.finalities.draft.push((patches, inversePatches) => {
+      finalizeSetValue(target);
+      finalizePatches(target, generatePatches, patches, inversePatches);
+    });
+  }
+  return proxy;
+}
+internal.createDraft = createDraft;
+function finalizeDraft(result, returnedValue, patches, inversePatches, enableAutoFreeze) {
+  var _a;
+  const proxyDraft = getProxyDraft(result);
+  const original = (_a = proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.original) !== null && _a !== undefined ? _a : result;
+  const hasReturnedValue = !!returnedValue.length;
+  if (proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.operated) {
+    while (proxyDraft.finalities.draft.length > 0) {
+      const finalize = proxyDraft.finalities.draft.pop();
+      finalize(patches, inversePatches);
+    }
+  }
+  const state = hasReturnedValue ? returnedValue[0] : proxyDraft ? proxyDraft.operated ? proxyDraft.copy : proxyDraft.original : result;
+  if (proxyDraft)
+    revokeProxy(proxyDraft);
+  if (enableAutoFreeze) {
+    deepFreeze(state, state, proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.options.updatedValues);
+  }
+  return [
+    state,
+    patches && hasReturnedValue ? [{ op: Operation.Replace, path: [], value: returnedValue[0] }] : patches,
+    inversePatches && hasReturnedValue ? [{ op: Operation.Replace, path: [], value: original }] : inversePatches
+  ];
+}
+function draftify(baseState, options) {
+  var _a;
+  const finalities = {
+    draft: [],
+    revoke: [],
+    handledSet: new WeakSet,
+    draftsCache: new WeakSet
+  };
+  let patches;
+  let inversePatches;
+  if (options.enablePatches) {
+    patches = [];
+    inversePatches = [];
+  }
+  const isMutable = ((_a = options.mark) === null || _a === undefined ? undefined : _a.call(options, baseState, dataTypes)) === dataTypes.mutable || !isDraftable(baseState, options);
+  const draft = isMutable ? baseState : createDraft({
+    original: baseState,
+    parentDraft: null,
+    finalities,
+    options
+  });
+  return [
+    draft,
+    (returnedValue = []) => {
+      const [finalizedState, finalizedPatches, finalizedInversePatches] = finalizeDraft(draft, returnedValue, patches, inversePatches, options.enableAutoFreeze);
+      return options.enablePatches ? [finalizedState, finalizedPatches, finalizedInversePatches] : finalizedState;
+    }
+  ];
+}
+function handleReturnValue(options) {
+  const { rootDraft, value, useRawReturn = false, isRoot = true } = options;
+  forEach(value, (key, item, source) => {
+    const proxyDraft = getProxyDraft(item);
+    if (proxyDraft && rootDraft && proxyDraft.finalities === rootDraft.finalities) {
+      options.isContainDraft = true;
+      const currentValue = proxyDraft.original;
+      if (source instanceof Set) {
+        const arr = Array.from(source);
+        source.clear();
+        arr.forEach((_item) => source.add(key === _item ? currentValue : _item));
+      } else {
+        set(source, key, currentValue);
+      }
+    } else if (typeof item === "object" && item !== null) {
+      options.value = item;
+      options.isRoot = false;
+      handleReturnValue(options);
+    }
+  });
+  if (isRoot) {
+    if (!options.isContainDraft)
+      console.warn(`The return value does not contain any draft, please use 'rawReturn()' to wrap the return value to improve performance.`);
+    if (useRawReturn) {
+      console.warn(`The return value contains drafts, please don't use 'rawReturn()' to wrap the return value.`);
+    }
+  }
+}
+function getCurrent(target) {
+  var _a;
+  const proxyDraft = getProxyDraft(target);
+  if (!isDraftable(target, proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.options))
+    return target;
+  const type = getType(target);
+  if (proxyDraft && !proxyDraft.operated)
+    return proxyDraft.original;
+  let currentValue;
+  function ensureShallowCopy2() {
+    currentValue = type === 2 ? !isBaseMapInstance(target) ? new (Object.getPrototypeOf(target)).constructor(target) : new Map(target) : type === 3 ? Array.from(proxyDraft.setMap.values()) : shallowCopy(target, proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.options);
+  }
+  if (proxyDraft) {
+    proxyDraft.finalized = true;
+    try {
+      ensureShallowCopy2();
+    } finally {
+      proxyDraft.finalized = false;
+    }
+  } else {
+    currentValue = target;
+  }
+  forEach(currentValue, (key, value) => {
+    if (proxyDraft && isEqual(get(proxyDraft.original, key), value))
+      return;
+    const newValue = getCurrent(value);
+    if (newValue !== value) {
+      if (currentValue === target)
+        ensureShallowCopy2();
+      set(currentValue, key, newValue);
+    }
+  });
+  if (type === 3) {
+    const value = (_a = proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.original) !== null && _a !== undefined ? _a : currentValue;
+    return !isBaseSetInstance(value) ? new (Object.getPrototypeOf(value)).constructor(currentValue) : new Set(currentValue);
+  }
+  return currentValue;
+}
+function current(target) {
+  if (!isDraft(target)) {
+    throw new Error(`current() is only used for Draft, parameter: ${target}`);
+  }
+  return getCurrent(target);
+}
+var makeCreator = (arg) => {
+  if (arg !== undefined && Object.prototype.toString.call(arg) !== "[object Object]") {
+    throw new Error(`Invalid options: ${String(arg)}, 'options' should be an object.`);
+  }
+  return function create(arg0, arg1, arg2) {
+    var _a, _b, _c;
+    if (typeof arg0 === "function" && typeof arg1 !== "function") {
+      return function(base2, ...args) {
+        return create(base2, (draft2) => arg0.call(this, draft2, ...args), arg1);
+      };
+    }
+    const base = arg0;
+    const mutate = arg1;
+    let options = arg2;
+    if (typeof arg1 !== "function") {
+      options = arg1;
+    }
+    if (options !== undefined && Object.prototype.toString.call(options) !== "[object Object]") {
+      throw new Error(`Invalid options: ${options}, 'options' should be an object.`);
+    }
+    options = Object.assign(Object.assign({}, arg), options);
+    const state = isDraft(base) ? current(base) : base;
+    const mark = Array.isArray(options.mark) ? (value, types) => {
+      for (const mark2 of options.mark) {
+        if (typeof mark2 !== "function") {
+          throw new Error(`Invalid mark: ${mark2}, 'mark' should be a function.`);
+        }
+        const result2 = mark2(value, types);
+        if (result2) {
+          return result2;
+        }
+      }
+      return;
+    } : options.mark;
+    const enablePatches = (_a = options.enablePatches) !== null && _a !== undefined ? _a : false;
+    const strict = (_b = options.strict) !== null && _b !== undefined ? _b : false;
+    const enableAutoFreeze = (_c = options.enableAutoFreeze) !== null && _c !== undefined ? _c : false;
+    const _options = {
+      enableAutoFreeze,
+      mark,
+      strict,
+      enablePatches
+    };
+    if (!isDraftable(state, _options) && typeof state === "object" && state !== null) {
+      throw new Error(`Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.`);
+    }
+    const [draft, finalize] = draftify(state, _options);
+    if (typeof arg1 !== "function") {
+      if (!isDraftable(state, _options)) {
+        throw new Error(`Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.`);
+      }
+      return [draft, finalize];
+    }
+    let result;
+    try {
+      result = mutate(draft);
+    } catch (error) {
+      revokeProxy(getProxyDraft(draft));
+      throw error;
+    }
+    const returnValue = (value) => {
+      const proxyDraft = getProxyDraft(draft);
+      if (!isDraft(value)) {
+        if (value !== undefined && !isEqual(value, draft) && (proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.operated)) {
+          throw new Error(`Either the value is returned as a new non-draft value, or only the draft is modified without returning any value.`);
+        }
+        const rawReturnValue = value === null || value === undefined ? undefined : value[RAW_RETURN_SYMBOL];
+        if (rawReturnValue) {
+          const _value = rawReturnValue[0];
+          if (_options.strict && typeof value === "object" && value !== null) {
+            handleReturnValue({
+              rootDraft: proxyDraft,
+              value,
+              useRawReturn: true
+            });
+          }
+          return finalize([_value]);
+        }
+        if (value !== undefined) {
+          if (typeof value === "object" && value !== null) {
+            handleReturnValue({ rootDraft: proxyDraft, value });
+          }
+          return finalize([value]);
+        }
+      }
+      if (value === draft || value === undefined) {
+        return finalize([]);
+      }
+      const returnedProxyDraft = getProxyDraft(value);
+      if (_options === returnedProxyDraft.options) {
+        if (returnedProxyDraft.operated) {
+          throw new Error(`Cannot return a modified child draft.`);
+        }
+        return finalize([current(value)]);
+      }
+      return finalize([value]);
+    };
+    if (result instanceof Promise) {
+      return result.then(returnValue, (error) => {
+        revokeProxy(getProxyDraft(draft));
+        throw error;
+      });
+    }
+    return returnValue(result);
+  };
+};
+var create = makeCreator();
+function apply(state, patches, applyOptions) {
+  let i;
+  for (i = patches.length - 1;i >= 0; i -= 1) {
+    const { value, op, path } = patches[i];
+    if (!path.length && op === Operation.Replace || path === "" && op === Operation.Add) {
+      state = value;
+      break;
+    }
+  }
+  if (i > -1) {
+    patches = patches.slice(i + 1);
+  }
+  const mutate = (draft) => {
+    patches.forEach((patch) => {
+      const { path: _path, op } = patch;
+      const path = unescapePath(_path);
+      let base = draft;
+      for (let index = 0;index < path.length - 1; index += 1) {
+        const parentType = getType(base);
+        let key2 = path[index];
+        if (typeof key2 !== "string" && typeof key2 !== "number") {
+          key2 = String(key2);
+        }
+        if ((parentType === 0 || parentType === 1) && (key2 === "__proto__" || key2 === "constructor") || typeof base === "function" && key2 === "prototype") {
+          throw new Error(`Patching reserved attributes like __proto__ and constructor is not allowed.`);
+        }
+        base = get(parentType === 3 ? Array.from(base) : base, key2);
+        if (typeof base !== "object") {
+          throw new Error(`Cannot apply patch at '${path.join("/")}'.`);
+        }
+      }
+      const type = getType(base);
+      const value = deepClone(patch.value);
+      const key = path[path.length - 1];
+      switch (op) {
+        case Operation.Replace:
+          switch (type) {
+            case 2:
+              return base.set(key, value);
+            case 3:
+              throw new Error(`Cannot apply replace patch to set.`);
+            default:
+              return base[key] = value;
+          }
+        case Operation.Add:
+          switch (type) {
+            case 1:
+              return key === "-" ? base.push(value) : base.splice(key, 0, value);
+            case 2:
+              return base.set(key, value);
+            case 3:
+              return base.add(value);
+            default:
+              return base[key] = value;
+          }
+        case Operation.Remove:
+          switch (type) {
+            case 1:
+              return base.splice(key, 1);
+            case 2:
+              return base.delete(key);
+            case 3:
+              return base.delete(patch.value);
+            default:
+              return delete base[key];
+          }
+        default:
+          throw new Error(`Unsupported patch operation: ${op}.`);
+      }
+    });
+  };
+  if (applyOptions === null || applyOptions === undefined ? undefined : applyOptions.mutable) {
+    {
+      if (Object.keys(applyOptions).filter((key) => key !== "mutable").length) {
+        console.warn('The "mutable" option is not allowed to be used with other options.');
+      }
+    }
+    mutate(state);
+    return;
+  }
+  if (isDraft(state)) {
+    if (applyOptions !== undefined) {
+      throw new Error(`Cannot apply patches with options to a draft.`);
+    }
+    mutate(state);
+    return state;
+  }
+  return create(state, mutate, Object.assign(Object.assign({}, applyOptions), { enablePatches: false }));
+}
+var constructorString = Object.prototype.constructor.toString();
+
+// ../../../core/dist/index.js
+var TOKEN_PREFIX = "arc:token:";
+function hasLocalStorage() {
+  return typeof localStorage !== "undefined";
+}
+
+class AuthAdapter {
+  scopes = new Map;
+  setToken(token, scope = "default") {
+    if (!token) {
+      this.scopes.delete(scope);
+      if (hasLocalStorage())
+        localStorage.removeItem(TOKEN_PREFIX + scope);
+      return;
+    }
+    try {
+      const parts = token.split(".");
+      if (parts.length !== 3) {
+        this.scopes.delete(scope);
+        if (hasLocalStorage())
+          localStorage.removeItem(TOKEN_PREFIX + scope);
+        return;
+      }
+      const payload = JSON.parse(atob(parts[1]));
+      this.scopes.set(scope, {
+        raw: token,
+        decoded: {
+          tokenName: payload.tokenName,
+          params: payload.params || {},
+          iat: payload.iat,
+          exp: payload.exp
+        }
+      });
+      if (hasLocalStorage())
+        localStorage.setItem(TOKEN_PREFIX + scope, token);
+    } catch {
+      this.scopes.delete(scope);
+      if (hasLocalStorage())
+        localStorage.removeItem(TOKEN_PREFIX + scope);
+    }
+  }
+  loadPersisted() {
+    if (!hasLocalStorage())
+      return;
+    for (let i = 0;i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith(TOKEN_PREFIX)) {
+        const scope = key.slice(TOKEN_PREFIX.length);
+        const raw = localStorage.getItem(key);
+        if (raw) {
+          try {
+            const parts = raw.split(".");
+            if (parts.length !== 3)
+              continue;
+            const payload = JSON.parse(atob(parts[1]));
+            this.scopes.set(scope, {
+              raw,
+              decoded: {
+                tokenName: payload.tokenName,
+                params: payload.params || {},
+                iat: payload.iat,
+                exp: payload.exp
+              }
+            });
+          } catch {
+            localStorage.removeItem(key);
+          }
+        }
+      }
+    }
+  }
+  getToken(scope = "default") {
+    return this.scopes.get(scope)?.raw ?? null;
+  }
+  getDecoded(scope = "default") {
+    return this.scopes.get(scope)?.decoded ?? null;
+  }
+  getParams(scope = "default") {
+    return this.scopes.get(scope)?.decoded?.params ?? null;
+  }
+  getTokenName(scope = "default") {
+    return this.scopes.get(scope)?.decoded?.tokenName ?? null;
+  }
+  isAuthenticated(scope) {
+    if (scope !== undefined) {
+      return this.scopes.has(scope);
+    }
+    return this.scopes.size > 0;
+  }
+  isExpired(scope = "default") {
+    const entry = this.scopes.get(scope);
+    if (!entry?.decoded?.exp)
+      return false;
+    return Date.now() > entry.decoded.exp;
+  }
+  getAllScopes() {
+    return Array.from(this.scopes.keys());
+  }
+  clear() {
+    if (hasLocalStorage()) {
+      for (const scope of this.scopes.keys()) {
+        localStorage.removeItem(TOKEN_PREFIX + scope);
+      }
+    }
+    this.scopes.clear();
+  }
+}
+var eventWireInstanceCounter = 0;
+
+class EventWire {
+  baseUrl;
+  instanceId;
+  ws = null;
+  state = "disconnected";
+  scopeTokens = new Map;
+  lastHostEventId = null;
+  pendingEvents = [];
+  onEventCallback;
+  onSyncedCallback;
+  reconnectTimeout;
+  syncRequested = false;
+  viewSubscriptions = new Map;
+  viewSubCounter = 0;
+  pendingViewSubs = [];
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+    this.instanceId = ++eventWireInstanceCounter;
+  }
+  setScopeToken(scope, token) {
+    if (token === null) {
+      this.scopeTokens.delete(scope);
+    } else {
+      this.scopeTokens.set(scope, token);
+    }
+    if (this.state === "connected" && this.ws) {
+      if (token !== null) {
+        this.ws.send(JSON.stringify({
+          type: "scope:auth",
+          scope,
+          token
+        }));
+      }
+    }
+  }
+  hasScopeTokens() {
+    return this.scopeTokens.size > 0;
+  }
+  setLastHostEventId(id) {
+    this.lastHostEventId = id;
+  }
+  getLastHostEventId() {
+    return this.lastHostEventId;
+  }
+  connect() {
+    if (this.state !== "disconnected")
+      return;
+    this.state = "connecting";
+    let wsUrl;
+    if (this.baseUrl.startsWith("http://") || this.baseUrl.startsWith("https://")) {
+      wsUrl = this.baseUrl.replace(/^http/, "ws");
+    } else {
+      const protocol = typeof window !== "undefined" && window.location.protocol === "https:" ? "wss:" : "ws:";
+      const host = typeof window !== "undefined" ? window.location.host : "localhost";
+      wsUrl = `${protocol}//${host}${this.baseUrl}`;
+    }
+    const url = `${wsUrl}/ws`;
+    try {
+      this.ws = new WebSocket(url);
+      this.ws.onopen = () => {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+          this.state = "connected";
+          this.sendAllScopeTokens();
+          this.requestSync();
+          this.flushPendingEvents();
+          this.flushPendingViewSubs();
+        } else {
+          console.log(`[EventWire] onopen called but ws is not OPEN, readyState:`, this.ws?.readyState);
+        }
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const message = JSON.parse(event.data);
+          this.handleMessage(message);
+        } catch (err) {
+          console.error("EventWire: Failed to parse message", err);
+        }
+      };
+      this.ws.onclose = (event) => {
+        this.state = "disconnected";
+        this.ws = null;
+        console.log("EventWire disconnected");
+        this.scheduleReconnect();
+      };
+      this.ws.onerror = (err) => {
+        console.error("EventWire error:", err);
+        if (this.state === "connecting") {
+          this.state = "disconnected";
+          this.ws = null;
+        }
+      };
+    } catch (err) {
+      this.state = "disconnected";
+      this.ws = null;
+      console.error("EventWire: Failed to connect", err);
+      this.scheduleReconnect();
+    }
+  }
+  disconnect() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = undefined;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.state = "disconnected";
+    this.syncRequested = false;
+  }
+  syncEvents(events) {
+    const isActuallyConnected = this.ws && this.ws.readyState === WebSocket.OPEN;
+    if (!isActuallyConnected) {
+      if (this.state === "connected" && !this.ws) {
+        this.state = "disconnected";
+      }
+      this.pendingEvents.push(...events);
+      if (this.state === "disconnected") {
+        this.connect();
+      }
+      return;
+    }
+    if (this.ws) {
+      this.ws.send(JSON.stringify({
+        type: "sync-events",
+        events: events.map((e) => ({
+          localId: e.localId,
+          type: e.type,
+          payload: e.payload,
+          createdAt: e.createdAt
+        }))
+      }));
+    }
+  }
+  onEvent(callback) {
+    this.onEventCallback = callback;
+  }
+  onSynced(callback) {
+    this.onSyncedCallback = callback;
+  }
+  subscribeQuery(descriptor, callback, scope) {
+    const subscriptionId = `qs_${++this.viewSubCounter}_${Date.now()}`;
+    this.viewSubscriptions.set(subscriptionId, callback);
+    if (this.state === "connected" && this.ws) {
+      this.ws.send(JSON.stringify({
+        type: "subscribe-query",
+        subscriptionId,
+        descriptor,
+        scope
+      }));
+    } else {
+      this.pendingViewSubs.push({ subscriptionId, descriptor, scope });
+    }
+    return subscriptionId;
+  }
+  unsubscribeQuery(subscriptionId) {
+    this.viewSubscriptions.delete(subscriptionId);
+    if (this.state === "connected" && this.ws) {
+      this.ws.send(JSON.stringify({
+        type: "unsubscribe-query",
+        subscriptionId
+      }));
+    }
+    this.pendingViewSubs = this.pendingViewSubs.filter((s) => s.subscriptionId !== subscriptionId);
+  }
+  getState() {
+    return this.state;
+  }
+  sendAllScopeTokens() {
+    if (!this.ws || this.state !== "connected")
+      return;
+    for (const [scope, token] of this.scopeTokens) {
+      this.ws.send(JSON.stringify({
+        type: "scope:auth",
+        scope,
+        token
+      }));
+    }
+  }
+  handleMessage(message) {
+    switch (message.type) {
+      case "events":
+        if (message.events && Array.isArray(message.events)) {
+          for (const event of message.events) {
+            if (this.onEventCallback) {
+              this.onEventCallback(event);
+            }
+          }
+        }
+        break;
+      case "sync-complete":
+        this.syncRequested = false;
+        if (message.lastHostEventId) {
+          this.lastHostEventId = message.lastHostEventId;
+        }
+        break;
+      case "query-data": {
+        const cb = this.viewSubscriptions.get(message.subscriptionId);
+        if (cb) {
+          cb(message.data);
+        }
+        break;
+      }
+      case "command-result":
+        break;
+      case "error":
+        console.error("EventWire error from host:", message.message);
+        break;
+    }
+  }
+  requestSync() {
+    if (!this.ws || this.state !== "connected")
+      return;
+    if (this.syncRequested)
+      return;
+    this.syncRequested = true;
+    this.ws.send(JSON.stringify({
+      type: "request-sync",
+      lastHostEventId: this.lastHostEventId
+    }));
+  }
+  flushPendingEvents() {
+    if (this.pendingEvents.length > 0) {
+      this.syncEvents(this.pendingEvents);
+      this.pendingEvents = [];
+    }
+  }
+  flushPendingViewSubs() {
+    if (!this.ws || this.state !== "connected")
+      return;
+    for (const sub of this.pendingViewSubs) {
+      this.ws.send(JSON.stringify({
+        type: "subscribe-query",
+        subscriptionId: sub.subscriptionId,
+        descriptor: sub.descriptor,
+        scope: sub.scope
+      }));
+    }
+    this.pendingViewSubs = [];
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimeout)
+      return;
+    this.reconnectTimeout = setTimeout(() => {
+      this.reconnectTimeout = undefined;
+      this.connect();
+    }, 3000);
+  }
+}
+var EVENT_TABLES = {
+  events: "events",
+  tags: "event_tags",
+  syncStatus: "event_sync_status"
+};
+
+class LocalEventPublisher {
+  dataStorage;
+  views = [];
+  syncCallback;
+  subscribers = new Map;
+  constructor(dataStorage) {
+    this.dataStorage = dataStorage;
+  }
+  onPublish(callback) {
+    this.syncCallback = callback;
+  }
+  registerViews(views) {
+    this.views = views;
+  }
+  subscribe(eventType, callback) {
+    if (!this.subscribers.has(eventType)) {
+      this.subscribers.set(eventType, new Set);
+    }
+    this.subscribers.get(eventType).add(callback);
+    return () => {
+      const subs = this.subscribers.get(eventType);
+      if (subs) {
+        subs.delete(callback);
+        if (subs.size === 0) {
+          this.subscribers.delete(eventType);
+        }
+      }
+    };
+  }
+  async publish(event) {
+    const allChanges = [];
+    const storedEvent = {
+      _id: event.id,
+      type: event.type,
+      payload: JSON.stringify(event.payload),
+      createdAt: event.createdAt.toISOString()
+    };
+    allChanges.push({
+      store: EVENT_TABLES.events,
+      changes: [{ type: "set", data: storedEvent }]
+    });
+    if (event.payload && typeof event.payload === "object") {
+      const tagChanges = [];
+      for (const [key, value] of Object.entries(event.payload)) {
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+          tagChanges.push({
+            type: "set",
+            data: {
+              _id: `${event.id}_${key}`,
+              eventId: event.id,
+              tagKey: key,
+              tagValue: String(value)
+            }
+          });
+        }
+      }
+      if (tagChanges.length > 0) {
+        allChanges.push({
+          store: EVENT_TABLES.tags,
+          changes: tagChanges
+        });
+      }
+    }
+    const syncStatus = {
+      _id: event.id,
+      eventId: event.id,
+      synced: false,
+      timestamp: Date.now(),
+      retryCount: 0
+    };
+    allChanges.push({
+      store: EVENT_TABLES.syncStatus,
+      changes: [{ type: "set", data: syncStatus }]
+    });
+    const viewChanges = await this.collectViewChanges(event);
+    allChanges.push(...viewChanges);
+    await this.dataStorage.commitChanges(allChanges);
+    await this.notifySubscribers(event);
+    if (this.syncCallback) {
+      this.syncCallback(event);
+    }
+  }
+  async notifySubscribers(event) {
+    const wildcardSubs = this.subscribers.get("*");
+    if (wildcardSubs) {
+      for (const callback of wildcardSubs) {
+        try {
+          const result = callback(event);
+          if (result instanceof Promise)
+            await result;
+        } catch (error) {
+          console.error(`[EventPublisher] Wildcard subscriber error:`, error);
+        }
+      }
+    }
+    const subs = this.subscribers.get(event.type);
+    if (!subs || subs.size === 0)
+      return;
+    const promises = [];
+    for (const callback of subs) {
+      try {
+        const result = callback(event);
+        if (result instanceof Promise) {
+          promises.push(result);
+        }
+      } catch (error) {
+        console.error(`Listener error for event "${event.type}":`, error);
+      }
+    }
+    if (promises.length > 0) {
+      await Promise.all(promises.map((p) => p.catch((e) => console.error(e))));
+    }
+  }
+  async markSynced(eventIds) {
+    const syncStatusStore = this.dataStorage.getStore(EVENT_TABLES.syncStatus);
+    const changes = eventIds.map((eventId) => ({
+      type: "modify",
+      id: eventId,
+      data: { synced: true }
+    }));
+    await syncStatusStore.applyChanges(changes);
+  }
+  async getUnsyncedEvents(eventType) {
+    const syncStatusStore = this.dataStorage.getStore(EVENT_TABLES.syncStatus);
+    const eventsStore = this.dataStorage.getStore(EVENT_TABLES.events);
+    const tagsStore = this.dataStorage.getStore(EVENT_TABLES.tags);
+    const unsyncedStatuses = await syncStatusStore.find({
+      where: { synced: false }
+    });
+    const results = [];
+    for (const syncStatus of unsyncedStatuses) {
+      const whereClause = { _id: syncStatus.eventId };
+      if (eventType) {
+        whereClause.type = eventType;
+      }
+      const events = await eventsStore.find({
+        where: whereClause
+      });
+      if (events.length === 0)
+        continue;
+      const tags = await tagsStore.find({
+        where: { eventId: syncStatus.eventId }
+      });
+      results.push({
+        event: events[0],
+        syncStatus,
+        tags
+      });
+    }
+    return results;
+  }
+  async collectViewChanges(event) {
+    const allViewChanges = [];
+    for (const view of this.views) {
+      const handlers = view.getHandlers();
+      const handler = handlers[event.type];
+      if (!handler)
+        continue;
+      const viewChanges = [];
+      const ctx = {
+        set: async (id, data) => {
+          viewChanges.push({
+            type: "set",
+            data: { _id: String(id), ...data }
+          });
+        },
+        modify: async (id, data) => {
+          viewChanges.push({
+            type: "modify",
+            id: String(id),
+            data
+          });
+        },
+        remove: async (id) => {
+          viewChanges.push({
+            type: "delete",
+            id: String(id)
+          });
+        },
+        find: async (options) => {
+          const viewStore = this.dataStorage.getStore(view.name);
+          return viewStore.find(options);
+        },
+        findOne: async (where) => {
+          const viewStore = this.dataStorage.getStore(view.name);
+          const results = await viewStore.find({ where });
+          return results[0];
+        },
+        $auth: {}
+      };
+      await handler(ctx, event);
+      if (viewChanges.length > 0) {
+        allViewChanges.push({
+          store: view.name,
+          changes: viewChanges
+        });
+      }
+    }
+    return allViewChanges;
+  }
+}
+class ArcOptional {
+  parent;
+  constructor(parent) {
+    this.parent = parent;
+  }
+  parse(value) {
+    if (!value)
+      return null;
+    return this.parent.parse(value);
+  }
+  serialize(value) {
+    if (value)
+      return this.parent.serialize(value);
+    return null;
+  }
+  deserialize(value) {
+    if (value == null)
+      return;
+    return this.parent.deserialize(value);
+  }
+  validate(value) {
+    if (!value)
+      return false;
+    return this.parent.validate(value);
+  }
+  toJsonSchema() {
+    const parentSchema = this.parent.toJsonSchema?.() ?? {};
+    return {
+      anyOf: [parentSchema, { type: "null" }]
+    };
+  }
+  getColumnData() {
+    const parentColumnData = this.parent.getColumnData?.();
+    if (!parentColumnData) {
+      throw new Error(`Parent element does not implement getColumnData()`);
+    }
+    return {
+      ...parentColumnData,
+      storeData: {
+        ...parentColumnData.storeData,
+        isNullable: true
+      }
+    };
+  }
+}
+
+class ArcBranded {
+  parent;
+  brand;
+  constructor(parent, brand) {
+    this.parent = parent;
+    this.brand = brand;
+  }
+  get name() {
+    return this.brand;
+  }
+  serialize(value) {
+    return this.parent.serialize(value);
+  }
+  deserialize(value) {
+    return this.parent.deserialize(value);
+  }
+  parse(value) {
+    return this.parent.parse(value);
+  }
+  optional() {
+    return new ArcOptional(this);
+  }
+  validate(value) {
+    return this.parent.validate(value);
+  }
+  toJsonSchema() {
+    return this.parent.toJsonSchema?.() ?? {};
+  }
+  getColumnData() {
+    const parentColumnData = this.parent.getColumnData?.();
+    if (!parentColumnData) {
+      throw new Error(`Parent element does not implement getColumnData()`);
+    }
+    return parentColumnData;
+  }
+}
+
+class ArcDefault {
+  parent;
+  defaultValueOrCallback;
+  constructor(parent, defaultValueOrCallback) {
+    this.parent = parent;
+    this.defaultValueOrCallback = defaultValueOrCallback;
+  }
+  validate(value) {
+    throw new Error("Method not implemented.");
+  }
+  parse(value) {
+    if (value)
+      return this.parent.parse(value);
+    if (typeof this.defaultValueOrCallback === "function") {
+      return this.defaultValueOrCallback();
+    } else
+      return this.defaultValueOrCallback;
+  }
+  serialize(value) {
+    return this.parent.serialize(value);
+  }
+  deserialize(value) {
+    if (value)
+      return this.parent.deserialize(value);
+    if (typeof this.defaultValueOrCallback === "function") {
+      return this.defaultValueOrCallback();
+    } else
+      return this.defaultValueOrCallback;
+  }
+  toJsonSchema() {
+    const schema = this.parent.toJsonSchema?.() ?? {};
+    const defaultValue = typeof this.defaultValueOrCallback === "function" ? this.defaultValueOrCallback() : this.defaultValueOrCallback;
+    return {
+      ...schema,
+      default: defaultValue
+    };
+  }
+  getColumnData() {
+    const parentColumnData = this.parent.getColumnData?.();
+    if (!parentColumnData) {
+      throw new Error(`Parent element does not implement getColumnData()`);
+    }
+    const defaultValue = typeof this.defaultValueOrCallback === "function" ? this.defaultValueOrCallback() : this.defaultValueOrCallback;
+    return {
+      ...parentColumnData,
+      defaultValue
+    };
+  }
+}
+
+class ArcAbstract {
+  validations;
+  _description;
+  _storeData;
+  constructor(validations = []) {
+    this.validations = validations;
+  }
+  description(description) {
+    const clone = this.clone();
+    clone._description = description;
+    return clone;
+  }
+  default(defaultValueOrCallback) {
+    return new ArcDefault(this, defaultValueOrCallback);
+  }
+  optional() {
+    return new ArcOptional(this);
+  }
+  branded(name) {
+    return new ArcBranded(this, name);
+  }
+  clone() {
+    const Constructor = this.constructor;
+    const newInstance = Object.assign(new Constructor, this);
+    newInstance._description = this._description;
+    newInstance._storeData = this._storeData ? { ...this._storeData } : undefined;
+    return newInstance;
+  }
+  validate(value) {
+    const errors = this.validations.reduce((acc, { name, validator }) => {
+      try {
+        acc[name] = validator(value);
+      } catch (error) {
+        acc[name] = error;
+      }
+      return acc;
+    }, {});
+    if (Object.values(errors).some((result) => !!result)) {
+      return errors;
+    }
+    return false;
+  }
+  pipeValidation(name, validator) {
+    const newInstance = this.clone();
+    newInstance.validations = [...this.validations, { name, validator }];
+    return newInstance;
+  }
+  toJsonSchema() {
+    const schema = {};
+    if (this._description) {
+      schema.description = this._description;
+    }
+    return schema;
+  }
+  getValidations() {
+    return this.validations;
+  }
+  primaryKey() {
+    const clone = this.clone();
+    clone._storeData = { ...clone._storeData, isPrimaryKey: true };
+    return clone;
+  }
+  autoIncrement() {
+    const clone = this.clone();
+    clone._storeData = { ...clone._storeData, isAutoIncrement: true };
+    return clone;
+  }
+  unique() {
+    const clone = this.clone();
+    clone._storeData = { ...clone._storeData, isUnique: true };
+    return clone;
+  }
+  index() {
+    const clone = this.clone();
+    clone._storeData = { ...clone._storeData, hasIndex: true };
+    return clone;
+  }
+  foreignKey(table, column, options) {
+    const clone = this.clone();
+    clone._storeData = {
+      ...clone._storeData,
+      foreignKey: { table, column, ...options }
+    };
+    return clone;
+  }
+  databaseType(overrides) {
+    const clone = this.clone();
+    clone._storeData = {
+      ...clone._storeData,
+      databaseType: { ...clone._storeData?.databaseType, ...overrides }
+    };
+    return clone;
+  }
+  columnOptions(options) {
+    const clone = this.clone();
+    clone._storeData = {
+      ...clone._storeData,
+      columnOptions: { ...clone._storeData?.columnOptions, ...options }
+    };
+    return clone;
+  }
+  getStoreData() {
+    return this._storeData;
+  }
+}
+function primitiveTypeComparatorStrategyFactory(type) {
+  return (value) => typeof value === type;
+}
+function typeValidatorBuilder(typeName, comparatorStrategy) {
+  const comparator = comparatorStrategy || primitiveTypeComparatorStrategyFactory(typeName);
+  return {
+    name: "type",
+    validator: (value) => {
+      const valueType = typeof value;
+      if (!comparator(value))
+        return { current: valueType, expected: typeName };
+      return false;
+    }
+  };
+}
+var arrayValidator = typeValidatorBuilder("array", Array.isArray);
+
+class ArcArray extends ArcAbstract {
+  parent;
+  constructor(parent) {
+    super([
+      arrayValidator,
+      {
+        name: "schema",
+        validator: (values) => {
+          const errors = values.reduce((acc, value, index) => {
+            const error = parent.validate(value);
+            if (error)
+              acc[index] = error;
+            return acc;
+          }, {});
+          if (Object.values(errors).some((result) => !!result)) {
+            return errors;
+          }
+          return false;
+        }
+      }
+    ]);
+    this.parent = parent;
+  }
+  minLength(min) {
+    return this.validation("minLength", (value) => {
+      if (value.length < min)
+        return {
+          currentLength: value.length,
+          minLength: min
+        };
+    });
+  }
+  maxLength(max) {
+    return this.validation("maxLength", (value) => {
+      if (value.length > max)
+        return {
+          currentLength: value.length,
+          maxLength: max
+        };
+    });
+  }
+  length(number) {
+    return this.validation("length", (value) => {
+      if (value.length !== number) {
+        return {
+          currentLength: value.length,
+          length: number
+        };
+      }
+    });
+  }
+  nonEmpty() {
+    return this.validation("nonEmpty", (value) => {
+      if (value.length === 0)
+        return { msg: "array is empty" };
+    });
+  }
+  parse(value) {
+    return value.map((v) => this.parent.parse(v));
+  }
+  serialize(value) {
+    return value.map((v) => this.parent.serialize(v));
+  }
+  deserialize(value) {
+    if (!Array.isArray(value))
+      return [];
+    return value.map((v) => this.parent.deserialize(v));
+  }
+  deserializePath(path, value) {
+    if (path.length === 0) {
+      return this.deserialize(value);
+    }
+    if (this.parent instanceof ArcObject || this.parent instanceof ArcArray) {
+      return this.parent.deserializePath(path, value);
+    }
+    return this.parent.deserialize(value);
+  }
+  validation(name, validator) {
+    const instance = this.pipeValidation(name, validator);
+    return instance;
+  }
+  toJsonSchema() {
+    const schema = {
+      type: "array",
+      items: this.parent.toJsonSchema?.() ?? {}
+    };
+    if (this._description) {
+      schema.description = this._description;
+    }
+    return schema;
+  }
+  getColumnData() {
+    const storeData = this.getStoreData();
+    return {
+      type: "array",
+      storeData: {
+        ...storeData,
+        isNullable: false
+      }
+    };
+  }
+}
+var objectValidator = typeValidatorBuilder("object");
+
+class ArcObject extends ArcAbstract {
+  rawShape;
+  constructor(rawShape) {
+    super([
+      objectValidator,
+      {
+        name: "schema",
+        validator: (value) => {
+          const errors = Object.entries(this.rawShape).reduce((acc, [key, element]) => {
+            if (!element.validate) {
+              return acc;
+            }
+            acc[key] = element.validate(value[key]);
+            return acc;
+          }, {});
+          if (Object.values(errors).some((result) => !!result)) {
+            return errors;
+          }
+          return false;
+        }
+      }
+    ]);
+    this.rawShape = rawShape;
+  }
+  parse(value) {
+    return Object.entries(this.rawShape).reduce((acc, [key, element]) => {
+      acc[key] = element.parse(value[key]);
+      return acc;
+    }, {});
+  }
+  serialize(value) {
+    return Object.entries(value).reduce((acc, [key, value2]) => {
+      if (!this.rawShape[key]) {
+        acc[key] = value2;
+      } else {
+        acc[key] = this.rawShape[key].serialize(value2);
+      }
+      return acc;
+    }, {});
+  }
+  deserialize(value) {
+    return Object.fromEntries(Object.entries(this.rawShape).map(([key, element]) => [
+      key,
+      element.deserialize(value[key])
+    ]));
+  }
+  deserializePath(path, value) {
+    if (path.length === 0) {
+      return this.deserialize(value);
+    }
+    const [key, ...restPath] = path;
+    const element = this.rawShape[key];
+    if (!element) {
+      console.warn(`No element found for key: ${key}`);
+      return value;
+    }
+    if (element instanceof ArcObject || element instanceof ArcArray) {
+      return element.deserializePath(restPath, value);
+    }
+    return element.deserialize(value);
+  }
+  parsePartial(value) {
+    return Object.entries(value).reduce((acc, [key, value2]) => {
+      acc[key] = this.rawShape[key].parse(value2);
+      return acc;
+    }, {});
+  }
+  deserializePartial(value) {
+    return Object.entries(value).reduce((acc, [key, value2]) => {
+      acc[key] = this.rawShape[key].deserialize(value2);
+      return acc;
+    }, {});
+  }
+  serializePartial(value) {
+    return Object.entries(value).reduce((acc, [key, value2]) => {
+      if (!this.rawShape[key]) {
+        console.warn(`No element found for key: ${key}`);
+        return acc;
+      }
+      acc[key] = this.rawShape[key].serialize(value2);
+      return acc;
+    }, {});
+  }
+  validatePartial(value) {
+    const errors = Object.entries(value).reduce((acc, [key, val]) => {
+      if (!this.rawShape[key]) {
+        return acc;
+      }
+      const result = this.rawShape[key].validate(val);
+      if (result) {
+        acc[key] = result;
+      }
+      return acc;
+    }, {});
+    if (Object.keys(errors).length > 0) {
+      return { schema: errors };
+    }
+    return false;
+  }
+  pick(...keys) {
+    return new ArcObject(Object.fromEntries(keys.map((key) => [key, this.rawShape[key]])));
+  }
+  omit(...keys) {
+    return new ArcObject(Object.fromEntries(Object.entries(this.rawShape).filter(([key]) => !keys.includes(key))));
+  }
+  entries() {
+    return Object.entries(this.rawShape);
+  }
+  keys() {
+    return Object.keys(this.rawShape);
+  }
+  toJsonSchema() {
+    const properties = {};
+    const required = [];
+    for (const [key, element] of Object.entries(this.rawShape)) {
+      if (element instanceof ArcOptional) {
+        properties[key] = element.parent.toJsonSchema?.() ?? {};
+      } else {
+        properties[key] = element.toJsonSchema?.() ?? {};
+        required.push(key);
+      }
+    }
+    const schema = {
+      type: "object",
+      properties
+    };
+    if (required.length)
+      schema.required = required;
+    if (this._description) {
+      schema.description = this._description;
+    }
+    return schema;
+  }
+  getColumnData() {
+    const storeData = this.getStoreData();
+    return {
+      type: "object",
+      storeData: {
+        ...storeData,
+        isNullable: false
+      }
+    };
+  }
+  merge(otherShape) {
+    const mergedShape = { ...this.rawShape, ...otherShape };
+    return new ArcObject(mergedShape);
+  }
+  partial() {
+    const partialShape = Object.fromEntries(Object.entries(this.rawShape).map(([key, element]) => [
+      key,
+      element instanceof ArcOptional ? element : new ArcOptional(element)
+    ]));
+    return new ArcObject(partialShape);
+  }
+}
+class ArcPrimitive extends ArcAbstract {
+  serialize(value) {
+    return value;
+  }
+  parse(value) {
+    return value;
+  }
+  deserialize(value) {
+    return value;
+  }
+}
+
+class ArcBoolean extends ArcPrimitive {
+  hasToBeTrue() {
+    return this.validation("hasToBeTrue", (value) => {
+      if (!value)
+        return {
+          current: value
+        };
+    });
+  }
+  validation(name, validator) {
+    const instance = this.pipeValidation(name, validator);
+    return instance;
+  }
+  toJsonSchema() {
+    const schema = { type: "boolean" };
+    if (this._description) {
+      schema.description = this._description;
+    }
+    return schema;
+  }
+  getColumnData() {
+    const storeData = this.getStoreData();
+    return {
+      type: "boolean",
+      storeData: {
+        ...storeData,
+        isNullable: false
+      }
+    };
+  }
+}
+var stringValidator = typeValidatorBuilder("string");
+
+class ArcString extends ArcPrimitive {
+  constructor() {
+    super([stringValidator]);
+  }
+  minLength(min) {
+    return this.validation("minLength", (value) => {
+      if (value.length < min)
+        return {
+          currentLength: value.length,
+          minLength: min
+        };
+    });
+  }
+  maxLength(max) {
+    return this.validation("maxLength", (value) => {
+      if (value.length > max)
+        return {
+          currentLength: value.length,
+          maxLength: max
+        };
+    });
+  }
+  length(number) {
+    return this.validation("length", (value) => {
+      if (value.length !== number) {
+        return {
+          currentLength: value.length,
+          length: number
+        };
+      }
+    });
+  }
+  includes(str) {
+    return this.validation("includes", (value) => {
+      if (!value.includes(str)) {
+        return {
+          currentValue: value,
+          includes: str
+        };
+      }
+    });
+  }
+  startsWith(str) {
+    return this.validation("startsWith", (value) => {
+      if (!value.startsWith(str)) {
+        return {
+          currentValue: value,
+          startsWith: str
+        };
+      }
+    });
+  }
+  endsWith(str) {
+    return this.validation("endsWith", (value) => {
+      if (!value.endsWith(str)) {
+        return {
+          currentValue: value,
+          endsWith: str
+        };
+      }
+    });
+  }
+  regex(regex) {
+    return this.validation("regex", (value) => {
+      if (!regex.test(value)) {
+        return {
+          currentValue: value,
+          regex
+        };
+      }
+    });
+  }
+  email() {
+    const regex = /^(?:(?:[a-zA-Z0-9!#$%&'*+/=?^_`{|}~.-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~.-]+)*)|(?:"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f])*"))@(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$|(?:\[(?:\d{1,3}\.){3}\d{1,3}\])$/;
+    return this.validation("email", (value) => {
+      if (!regex.test(value)) {
+        return {
+          currentEmail: value
+        };
+      }
+    });
+  }
+  toJsonSchema() {
+    const schema = { type: "string" };
+    if (this._description) {
+      schema.description = this._description;
+    }
+    return schema;
+  }
+  url() {
+    const regex = /^(https?):\/\/(?![-0-9])(?!www\.[0-9])(?:[a-zA-Z0-9-]+(?::[a-zA-Z0-9-]+)?@)?(?:localhost|\b(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b|[a-zA-Z0-9-]+\.)?[a-zA-Z0-9-]+\.(?:[a-zA-Z]{2,}|[a-zA-Z]{2}\.[a-zA-Z]{2})(?::\d{1,5})?(?!\/\/)(?:\/[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(?!\/{2})(?:;[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(\?(?!=)[a-zA-Z0-9&=;]*)?(\#[a-zA-Z0-9-]*)?$|^(https?):\/\/(localhost|\b(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b)(?::\d{1,5})?(?!\/\/)(?:\/[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(?!\/{2})(?:;[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(\?(?!=)[a-zA-Z0-9&=;]*)?(\#[a-zA-Z0-9-]*)?$/;
+    return this.validation("url", (value) => {
+      if (!regex.test(value)) {
+        return {
+          currentUrl: value
+        };
+      }
+    });
+  }
+  ip() {
+    const IPv4regex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+    const IPv6regex = /^(?:([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|:(:[0-9a-fA-F]{1,4}){1,7}|([0-9a-fA-F]{1,4}:){1,6}:([0-9a-fA-F]{1,4}:){1,6}[0-9a-fA-F]{1,4})$/;
+    return this.validation("ip", (value) => {
+      if (!(IPv4regex.test(value) || IPv6regex.test(value))) {
+        return {
+          currentIP: value
+        };
+      }
+    });
+  }
+  validation(name, validator) {
+    const instance = this.pipeValidation(name, validator);
+    return instance;
+  }
+  getColumnData() {
+    const storeData = this.getStoreData();
+    const validationInfo = {};
+    for (const validation of this.validations) {
+      switch (validation.name) {
+        case "minLength":
+          break;
+        case "maxLength":
+          break;
+        case "regex":
+          break;
+        case "email":
+          validationInfo.pattern = "email";
+          break;
+        case "url":
+          validationInfo.pattern = "url";
+          break;
+        case "ip":
+          validationInfo.pattern = "ip";
+          break;
+      }
+    }
+    return {
+      type: "string",
+      storeData: {
+        ...storeData,
+        isNullable: false
+      },
+      validationInfo
+    };
+  }
+}
+function string() {
+  return new ArcString;
+}
+class ArcId extends ArcBranded {
+  generateFn;
+  constructor(name, generateFn) {
+    super(string(), name);
+    this.generateFn = generateFn;
+  }
+  generate() {
+    if (this.generateFn) {
+      return this.generateFn();
+    }
+    var timestamp = (new Date().getTime() / 1000 | 0).toString(16);
+    return timestamp + "xxxxxxxxxxxxxxxx".replace(/[x]/g, function() {
+      return (Math.random() * 16 | 0).toString(16);
+    }).toLowerCase();
+  }
+}
+function id(name, generateFn) {
+  return new ArcId(name, generateFn);
+}
+var numberValidator = typeValidatorBuilder("number");
+
+class ArcNumber extends ArcPrimitive {
+  constructor() {
+    super([numberValidator]);
+  }
+  min(min) {
+    return this.validation("min", (value) => {
+      if (value < min)
+        return { current: value, min };
+    });
+  }
+  max(max) {
+    return this.validation("max", (value) => {
+      if (value > max)
+        return { current: value, max };
+    });
+  }
+  validation(name, validator) {
+    const instance = this.pipeValidation(name, validator);
+    return instance;
+  }
+  toJsonSchema() {
+    const schema = { type: "number" };
+    if (this._description) {
+      schema.description = this._description;
+    }
+    return schema;
+  }
+  getColumnData() {
+    const storeData = this.getStoreData();
+    const validationInfo = {};
+    for (const validation of this.validations) {
+      switch (validation.name) {
+        case "min":
+          break;
+        case "max":
+          break;
+      }
+    }
+    return {
+      type: "number",
+      storeData: {
+        ...storeData,
+        isNullable: false
+      },
+      validationInfo
+    };
+  }
+}
+class ArcFragmentBase {
+  is(type) {
+    return this.types.includes(type);
+  }
+}
+
+class ArcContextElement extends ArcFragmentBase {
+  name;
+  types = ["context-element"];
+  get id() {
+    return this.name;
+  }
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+}
+
+class ArcEvent extends ArcContextElement {
+  data;
+  eventId = id("event");
+  constructor(data) {
+    super(data.name);
+    this.data = data;
+  }
+  get payload() {
+    return this.data.payload;
+  }
+  description(description) {
+    return new ArcEvent({
+      ...this.data,
+      description
+    });
+  }
+  mutateContext(adapters) {
+    return {
+      emit: async (payload) => {
+        if (!adapters.eventPublisher) {
+          throw new Error(`Event "${this.data.name}" cannot be emitted: no eventPublisher adapter available`);
+        }
+        const event = {
+          type: this.data.name,
+          payload,
+          id: this.eventId.generate(),
+          createdAt: new Date
+        };
+        await adapters.eventPublisher.publish(event);
+      }
+    };
+  }
+  protectBy(token, protectionFn) {
+    const existingProtections = this.data.protections || [];
+    return new ArcEvent({
+      ...this.data,
+      protections: [...existingProtections, { token, protectionFn }]
+    });
+  }
+  get hasProtections() {
+    return (this.data.protections?.length ?? 0) > 0;
+  }
+  get protections() {
+    return this.data.protections || [];
+  }
+  getProtectionFor(tokenInstance) {
+    if (!this.data.protections) {
+      return null;
+    }
+    for (const protection of this.data.protections) {
+      if (tokenInstance.getTokenDefinition() === protection.token) {
+        return protection.protectionFn(tokenInstance.params);
+      }
+    }
+    return null;
+  }
+  tags(tagFields) {
+    return new ArcEvent({
+      ...this.data,
+      tagFields
+    });
+  }
+  get tagFields() {
+    return this.data.tagFields || [];
+  }
+  static _sharedSchema = null;
+  static sharedDatabaseStoreSchema() {
+    if (ArcEvent._sharedSchema) {
+      return ArcEvent._sharedSchema;
+    }
+    const eventsSchema = new ArcObject({
+      _id: new ArcString().primaryKey(),
+      type: new ArcString().index(),
+      payload: new ArcString,
+      createdAt: new ArcString().index()
+    });
+    const tagsSchema = new ArcObject({
+      _id: new ArcString().primaryKey(),
+      eventId: new ArcString().index(),
+      tagKey: new ArcString().index(),
+      tagValue: new ArcString().index()
+    });
+    const syncStatusSchema = new ArcObject({
+      _id: new ArcString().primaryKey(),
+      eventId: new ArcString().index(),
+      synced: new ArcBoolean().index(),
+      timestamp: new ArcNumber,
+      retryCount: new ArcNumber
+    });
+    ArcEvent._sharedSchema = {
+      tables: [
+        { name: "events", schema: eventsSchema },
+        { name: "event_tags", schema: tagsSchema },
+        { name: "event_sync_status", schema: syncStatusSchema }
+      ]
+    };
+    return ArcEvent._sharedSchema;
+  }
+  databaseStoreSchema() {
+    return ArcEvent.sharedDatabaseStoreSchema();
+  }
+}
+class AggregateBase {
+  value;
+  _id;
+  #adapters;
+  constructor(row, adapters) {
+    this._id = row._id;
+    const { _id, ...rest } = row;
+    this.value = rest;
+    this.#adapters = adapters;
+  }
+  toJSON() {
+    return { _id: this._id, ...this.value };
+  }
+  get ctx() {
+    const events = this.constructor.__aggregateEvents ?? [];
+    const adapters = this.#adapters;
+    const result = {};
+    for (const entry of events) {
+      const arcEvent = entry.event;
+      result[arcEvent.name] = {
+        emit: async (payload) => {
+          if (!adapters.eventPublisher) {
+            throw new Error(`Cannot emit event "${arcEvent.name}": no eventPublisher adapter available`);
+          }
+          const eventInstance = {
+            type: arcEvent.name,
+            payload,
+            id: `${Date.now()}_${Math.random().toString(36).slice(2)}`,
+            createdAt: new Date
+          };
+          await adapters.eventPublisher.publish(eventInstance);
+        }
+      };
+    }
+    return result;
+  }
+}
+class DataStorage {
+  async commitChanges(changes) {
+    await Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));
+  }
+}
+
+class StoreState {
+  storeName;
+  dataStorage;
+  deserialize;
+  listeners = new Map;
+  constructor(storeName, dataStorage, deserialize) {
+    this.storeName = storeName;
+    this.dataStorage = dataStorage;
+    this.deserialize = deserialize;
+  }
+  fork() {
+    return new ForkedStoreState(this.storeName, this.dataStorage, this);
+  }
+  async set(item) {
+    const change = {
+      type: "set",
+      data: item
+    };
+    await this.applyChanges([change]);
+  }
+  async remove(id2) {
+    const change = {
+      type: "delete",
+      id: id2
+    };
+    await this.applyChanges([change]);
+  }
+  async modify(id2, data) {
+    const change = {
+      type: "modify",
+      id: id2,
+      data
+    };
+    const { from, to } = await this.applyChange(change);
+    return { from, to };
+  }
+  async mutate(id2, editCallback) {
+    const result = await this.find({ where: { _id: id2 } });
+    const object2 = result[0];
+    const [draft, finalize] = create(object2 || {}, { enablePatches: true });
+    await editCallback(draft);
+    const [_, patches] = finalize();
+    const change = {
+      type: "mutate",
+      id: id2,
+      patches
+    };
+    const { from, to } = await this.applyChange(change);
+    return { from, to };
+  }
+  applySerializedChanges(changes) {
+    return Promise.all(changes.map((change) => this.applyChange(change)));
+  }
+  get listenerCount() {
+    return this.listeners.size;
+  }
+  unsubscribe(listener4) {
+    this.listeners.delete(listener4);
+  }
+  notifyListeners(events) {
+    for (const listener4 of this.listeners.values()) {
+      listener4.callback(events);
+    }
+  }
+}
+function deepMerge(target, source) {
+  const output = { ...target };
+  for (const key in source) {
+    if (source[key] === undefined) {
+      output[key] = undefined;
+      continue;
+    }
+    if (isPlainObject(source[key]) && isPlainObject(target[key])) {
+      output[key] = deepMerge(target[key], source[key]);
+    } else {
+      output[key] = source[key];
+    }
+  }
+  return output;
+}
+function isPlainObject(item) {
+  return item && typeof item === "object" && !Array.isArray(item) && !(item instanceof Date) && Object.prototype.toString.call(item) === "[object Object]";
+}
+class ForkedStoreState extends StoreState {
+  master;
+  changedItems = new Map;
+  changes = [];
+  constructor(storeName, dataStorage, master) {
+    super(storeName, dataStorage, master.deserialize);
+    this.master = master;
+  }
+  async applyChangeAndReturnEvent(change) {
+    this.changes.push(change);
+    if (change.type === "set") {
+      const item = this.deserialize ? this.deserialize(change.data) : change.data;
+      this.changedItems.set(change.data._id, item);
+      return {
+        from: null,
+        to: item,
+        event: {
+          type: "set",
+          item: change.data,
+          id: change.data._id
+        }
+      };
+    }
+    if (change.type === "delete") {
+      const from = await this.find({ where: { _id: change.id } }).then((results) => results[0] || null);
+      this.changedItems.set(change.id, null);
+      return {
+        from,
+        to: null,
+        event: {
+          type: "delete",
+          item: null,
+          id: change.id
+        }
+      };
+    }
+    if (change.type === "modify") {
+      const existing = await this.find({
+        where: { _id: change.id }
+      }).then((results) => results[0]);
+      const updated = existing ? deepMerge(existing, change.data) : { _id: change.id, ...change.data };
+      const item = this.deserialize ? this.deserialize(updated) : updated;
+      this.changedItems.set(change.id, item);
+      return {
+        from: existing || null,
+        to: item,
+        event: {
+          type: "set",
+          item,
+          id: change.id
+        }
+      };
+    }
+    if (change.type === "mutate") {
+      const existing = await this.find({
+        where: { _id: change.id }
+      }).then((results) => results[0]);
+      const updated = apply(existing || {}, change.patches);
+      const item = this.deserialize ? this.deserialize(updated) : updated;
+      this.changedItems.set(change.id, item);
+      return {
+        from: existing || null,
+        to: item,
+        event: {
+          type: "set",
+          item,
+          id: change.id
+        }
+      };
+    }
+    throw new Error("Unknown change type");
+  }
+  async applyChange(change) {
+    const { event: event3, from, to } = await this.applyChangeAndReturnEvent(change);
+    this.notifyListeners([event3]);
+    return { from, to };
+  }
+  async applyChanges(changes) {
+    const events = [];
+    for (const change of changes) {
+      const { event: event3 } = await this.applyChangeAndReturnEvent(change);
+      if (event3)
+        events.push(event3);
+    }
+    if (events.length > 0) {
+      this.notifyListeners(events);
+    }
+  }
+  async find(options, listener4) {
+    if (listener4) {
+      this.listeners.set(listener4, { callback: listener4 });
+    }
+    const parentResults = await this.master.find(options);
+    const results = new Map;
+    parentResults.forEach((item) => results.set(item._id, item));
+    for (const [id2, changedItem] of this.changedItems) {
+      if (changedItem === null) {
+        results.delete(id2);
+        continue;
+      }
+      const matches = !options.where || Object.entries(options.where).every(([key, value]) => changedItem[key] === value);
+      if (matches) {
+        results.set(id2, changedItem);
+      } else {
+        results.delete(id2);
+      }
+    }
+    return Array.from(results.values());
+  }
+}
+
+class ForkedDataStorage extends DataStorage {
+  master;
+  stores = new Map;
+  constructor(master) {
+    super();
+    this.master = master;
+  }
+  getReadTransaction() {
+    return this.master.getReadTransaction();
+  }
+  getReadWriteTransaction() {
+    return this.master.getReadWriteTransaction();
+  }
+  getStore(storeName) {
+    if (this.stores.has(storeName))
+      return this.stores.get(storeName);
+    const masterStorage = this.master.getStore(storeName);
+    const storage = new ForkedStoreState(storeName, this, masterStorage);
+    this.stores.set(storeName, storage);
+    return storage;
+  }
+  fork() {
+    return new ForkedDataStorage(this);
+  }
+  async merge() {
+    const changes = Array.from(this.stores.values()).filter((store) => store.changes.length > 0).map((store) => ({
+      store: store.storeName,
+      changes: store.changes
+    }));
+    await this.master.commitChanges(changes);
+  }
+}
+
+class MasterStoreState extends StoreState {
+  constructor(storeName, dataStorage, deserialize) {
+    super(storeName, dataStorage, deserialize);
+  }
+  async applyChangeAndReturnEvent(transaction, change, transactionCache) {
+    if (change.type === "set") {
+      await transaction.set(this.storeName, change.data);
+      const item = this.deserialize ? this.deserialize(change.data) : change.data;
+      if (transactionCache) {
+        transactionCache.set(change.data._id, item);
+      }
+      return {
+        from: null,
+        to: item,
+        event: {
+          type: "set",
+          item: change.data,
+          id: change.data._id
+        }
+      };
+    }
+    if (change.type === "delete") {
+      await transaction.remove(this.storeName, change.id);
+      return {
+        from: null,
+        to: null,
+        event: {
+          type: "delete",
+          item: null,
+          id: change.id
+        }
+      };
+    }
+    if (change.type === "modify") {
+      let existing;
+      if (transactionCache && transactionCache.has(change.id)) {
+        existing = transactionCache.get(change.id);
+      } else {
+        existing = await transaction.find(this.storeName, { where: { _id: change.id } }).then((results) => results[0]);
+      }
+      const updated = existing ? deepMerge(existing, change.data) : { _id: change.id, ...change.data };
+      await transaction.set(this.storeName, updated);
+      const item = this.deserialize ? this.deserialize(updated) : updated;
+      if (transactionCache) {
+        transactionCache.set(change.id, item);
+      }
+      return {
+        from: null,
+        to: item,
+        event: {
+          type: "set",
+          item,
+          id: change.id
+        }
+      };
+    }
+    if (change.type === "mutate") {
+      let existing;
+      if (transactionCache && transactionCache.has(change.id)) {
+        existing = transactionCache.get(change.id);
+      } else {
+        existing = await transaction.find(this.storeName, { where: { _id: change.id } }).then((results) => results[0]);
+      }
+      const updated = apply(existing || {}, change.patches);
+      await transaction.set(this.storeName, updated);
+      const item = this.deserialize ? this.deserialize(updated) : updated;
+      if (transactionCache) {
+        transactionCache.set(change.id, item);
+      }
+      return {
+        from: null,
+        to: item,
+        event: {
+          type: "set",
+          item,
+          id: change.id
+        }
+      };
+    }
+    throw new Error("Unknown change type");
+  }
+  async applyChange(change) {
+    const transaction = await this.dataStorage.getReadWriteTransaction();
+    const transactionCache = new Map;
+    const { event: event3, from, to } = await this.applyChangeAndReturnEvent(transaction, change, transactionCache);
+    await transaction.commit();
+    this.notifyListeners([event3]);
+    return { from, to };
+  }
+  async applyChanges(changes) {
+    const transaction = await this.dataStorage.getReadWriteTransaction();
+    const transactionCache = new Map;
+    const events = [];
+    for (const change of changes) {
+      const { event: event3 } = await this.applyChangeAndReturnEvent(transaction, change, transactionCache);
+      if (event3)
+        events.push(event3);
+    }
+    await transaction.commit();
+    if (events.length > 0) {
+      this.notifyListeners(events);
+    }
+  }
+  async find(options, listener4) {
+    if (listener4) {
+      this.listeners.set(listener4, { callback: listener4 });
+    }
+    const transaction = await this.dataStorage.getReadTransaction();
+    const results = await transaction.find(this.storeName, options);
+    return results.map((item) => this.deserialize ? this.deserialize(item) : item);
+  }
+  notifyListenersPublic(events) {
+    this.notifyListeners(events);
+  }
+}
+
+class MasterDataStorage extends DataStorage {
+  dbAdapter;
+  stores = new Map;
+  reinitTablesExecuted = false;
+  constructor(dbAdapter) {
+    super();
+    this.dbAdapter = dbAdapter;
+    this.executeReinitTablesOnReady();
+  }
+  async executeReinitTablesOnReady() {
+    try {
+      const adapter = await this.dbAdapter;
+      if (!this.reinitTablesExecuted) {
+        await adapter.executeReinitTables(this);
+        this.reinitTablesExecuted = true;
+      }
+    } catch (error) {
+      console.error("Failed to execute reinitTable functions:", error);
+    }
+  }
+  async getReadTransaction() {
+    return (await this.dbAdapter).readTransaction();
+  }
+  async getReadWriteTransaction() {
+    return (await this.dbAdapter).readWriteTransaction();
+  }
+  getStore(storeName) {
+    if (!this.stores.has(storeName)) {
+      this.stores.set(storeName, new MasterStoreState(storeName, this));
+    }
+    return this.stores.get(storeName);
+  }
+  async applyChanges(changes) {
+    return Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));
+  }
+  applySerializedChanges(changes) {
+    return Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applySerializedChanges(changes2)));
+  }
+  async commitChanges(changes) {
+    const transaction = await this.getReadWriteTransaction();
+    const transactionCache = new Map;
+    const eventsByStore = new Map;
+    for (const { store, changes: storeChanges } of changes) {
+      const storeState = this.getStore(store);
+      const storeEvents = [];
+      for (const change of storeChanges) {
+        const { event: event3 } = await storeState.applyChangeAndReturnEvent(transaction, change, transactionCache);
+        if (event3)
+          storeEvents.push(event3);
+      }
+      if (storeEvents.length > 0) {
+        eventsByStore.set(store, storeEvents);
+      }
+    }
+    await transaction.commit();
+    for (const [store, events] of eventsByStore) {
+      const storeState = this.getStore(store);
+      storeState.notifyListenersPublic(events);
+    }
+  }
+  fork() {
+    return new ForkedDataStorage(this);
+  }
+  async destroy() {
+    const adapter = await this.dbAdapter;
+    if (adapter.destroy) {
+      await adapter.destroy();
+    }
+    this.stores.clear();
+    this.reinitTablesExecuted = false;
+  }
+}
+function resolveQueryChange(currentResult, event3, options) {
+  const index = currentResult.findIndex((e) => e._id === event3.id);
+  const isInCurrentResult = index !== -1;
+  if (event3.type === "delete") {
+    if (isInCurrentResult) {
+      return currentResult.toSpliced(index, 1);
+    }
+    return false;
+  }
+  const shouldBeInResult = checkItemMatchesWhere(event3.item, options.where);
+  if (isInCurrentResult && shouldBeInResult) {
+    const newResult = currentResult.toSpliced(index, 1, event3.item);
+    return applyOrderByAndLimit(newResult, options);
+  } else if (isInCurrentResult && !shouldBeInResult) {
+    return currentResult.toSpliced(index, 1);
+  } else if (!isInCurrentResult && shouldBeInResult) {
+    const newResult = [...currentResult, event3.item];
+    return applyOrderByAndLimit(newResult, options);
+  }
+  return false;
+}
+function checkItemMatchesWhere(item, where) {
+  if (!where) {
+    return true;
+  }
+  return Object.entries(where).every(([key, condition]) => {
+    const value = item[key];
+    if (typeof condition !== "object" || condition === null) {
+      return value === condition;
+    }
+    return Object.entries(condition).every(([operator, operand]) => {
+      switch (operator) {
+        case "$eq":
+          return value === operand;
+        case "$ne":
+          return value !== operand;
+        case "$gt":
+          return typeof value === "number" && typeof operand === "number" && value > operand;
+        case "$gte":
+          return typeof value === "number" && typeof operand === "number" && value >= operand;
+        case "$lt":
+          return typeof value === "number" && typeof operand === "number" && value < operand;
+        case "$lte":
+          return typeof value === "number" && typeof operand === "number" && value <= operand;
+        case "$in":
+          return Array.isArray(operand) && operand.includes(value);
+        case "$nin":
+          return Array.isArray(operand) && !operand.includes(value);
+        case "$exists":
+          return typeof operand === "boolean" ? operand ? value !== undefined : value === undefined : true;
+        default:
+          return true;
+      }
+    });
+  });
+}
+function applyOrderByAndLimit(result, options) {
+  let sorted = result;
+  if (options.orderBy) {
+    sorted = [...result].sort((a, b) => {
+      for (const [key, direction] of Object.entries(options.orderBy)) {
+        const aVal = a[key];
+        const bVal = b[key];
+        if (aVal < bVal)
+          return direction === "asc" ? -1 : 1;
+        if (aVal > bVal)
+          return direction === "asc" ? 1 : -1;
+      }
+      return 0;
+    });
+  }
+  if (options.limit !== undefined) {
+    sorted = sorted.slice(0, options.limit);
+  }
+  return sorted;
+}
+
+class ObservableDataStorage {
+  source;
+  onChange;
+  trackedQueries = new Map;
+  stores = new Map;
+  constructor(source, onChange) {
+    this.source = source;
+    this.onChange = onChange;
+  }
+  getStore(storeName) {
+    if (!this.stores.has(storeName)) {
+      this.stores.set(storeName, new ObservableStoreState(storeName, this.source.getStore(storeName), this));
+    }
+    return this.stores.get(storeName);
+  }
+  fork() {
+    return this.source.fork();
+  }
+  getReadTransaction() {
+    return this.source.getReadTransaction();
+  }
+  getReadWriteTransaction() {
+    return this.source.getReadWriteTransaction();
+  }
+  commitChanges(changes) {
+    return this.source.commitChanges(changes);
+  }
+  trackQuery(storeName, options, result, listener4) {
+    const key = this.getQueryKey(storeName, options);
+    this.trackedQueries.set(key, {
+      storeName,
+      options,
+      result,
+      listener: listener4
+    });
+  }
+  handleStoreChange(storeName, events) {
+    let hasChanges = false;
+    for (const query of this.trackedQueries.values()) {
+      if (query.storeName !== storeName)
+        continue;
+      let currentResult = query.result;
+      let queryChanged = false;
+      for (const event3 of events) {
+        const newResult = resolveQueryChange(currentResult, event3, query.options);
+        if (newResult !== false) {
+          currentResult = newResult;
+          queryChanged = true;
+        }
+      }
+      if (queryChanged) {
+        query.result = currentResult;
+        hasChanges = true;
+      }
+    }
+    if (hasChanges) {
+      this.onChange();
+    }
+  }
+  getCachedResult(storeName, options) {
+    const key = this.getQueryKey(storeName, options);
+    return this.trackedQueries.get(key)?.result;
+  }
+  clear() {
+    for (const query of this.trackedQueries.values()) {
+      const sourceStore = this.source.getStore(query.storeName);
+      sourceStore.unsubscribe(query.listener);
+    }
+    this.trackedQueries.clear();
+    this.stores.clear();
+  }
+  getQueryKey(storeName, options) {
+    return `${storeName}:${JSON.stringify(options || {})}`;
+  }
+}
+
+class ObservableStoreState {
+  source;
+  observable;
+  storeName;
+  constructor(storeName, source, observable) {
+    this.source = source;
+    this.observable = observable;
+    this.storeName = storeName;
+  }
+  async find(options = {}, _existingListener) {
+    const cached = this.observable.getCachedResult(this.storeName, options);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const listener4 = (events) => {
+      this.observable.handleStoreChange(this.storeName, events);
+    };
+    const result = await this.source.find(options, listener4);
+    this.observable.trackQuery(this.storeName, options, result, listener4);
+    return result;
+  }
+  unsubscribe(listener4) {
+    this.source.unsubscribe(listener4);
+  }
+  async set(item) {
+    return this.source.set(item);
+  }
+  async remove(id2) {
+    return this.source.remove(id2);
+  }
+  async modify(id2, data) {
+    return this.source.modify(id2, data);
+  }
+  async mutate(id2, editCallback) {
+    return this.source.mutate(id2, editCallback);
+  }
+  fork() {
+    return this.source.fork();
+  }
+  applyChange(change) {
+    return this.source.applyChange(change);
+  }
+  applyChanges(changes) {
+    return this.source.applyChanges(changes);
+  }
+  applySerializedChanges(changes) {
+    return this.source.applySerializedChanges(changes);
+  }
+}
+function extractDatabaseAgnosticSchema(arcObject, tableName) {
+  const columns = [];
+  for (const [fieldName, fieldSchema] of arcObject.entries()) {
+    const arcElement = fieldSchema;
+    if (typeof arcElement.getColumnData !== "function") {
+      throw new Error(`Element for field '${fieldName}' does not implement getColumnData() method. Element type: ${arcElement.constructor.name}`);
+    }
+    const columnInfo = arcElement.getColumnData();
+    const fullColumnInfo = {
+      name: fieldName,
+      ...columnInfo
+    };
+    columns.push(fullColumnInfo);
+  }
+  return {
+    tableName,
+    columns
+  };
+}
+var dateValidator = typeValidatorBuilder("Date", (value) => value instanceof Date);
+function buildContextAccessor(context2, adapters, contextMethod, onCall) {
+  const result = {};
+  for (const element2 of context2.elements) {
+    const ctxFn = element2[contextMethod];
+    if (typeof ctxFn !== "function")
+      continue;
+    const methods = ctxFn.call(element2, adapters);
+    if (!methods || typeof methods !== "object")
+      continue;
+    const wrapped = {};
+    for (const [methodName, method] of Object.entries(methods)) {
+      if (typeof method !== "function")
+        continue;
+      wrapped[methodName] = (...args) => onCall({ element: element2.name, method: methodName, args }, () => method(...args));
+    }
+    result[element2.name] = wrapped;
+  }
+  return result;
+}
+function executeDescriptor(descriptor, context2, adapters, contextMethod) {
+  const element2 = context2.get(descriptor.element);
+  if (!element2) {
+    throw new Error(`Element '${descriptor.element}' not found in context`);
+  }
+  const ctxFn = element2[contextMethod];
+  if (typeof ctxFn !== "function") {
+    throw new Error(`Element '${descriptor.element}' has no ${contextMethod}`);
+  }
+  const methods = ctxFn.call(element2, adapters);
+  const method = methods?.[descriptor.method];
+  if (typeof method !== "function") {
+    throw new Error(`Method '${descriptor.method}' not found on '${descriptor.element}'`);
+  }
+  return method(...descriptor.args);
+}
+
+class ScopedModel {
+  context;
+  scopeName;
+  parent;
+  authAdapter;
+  scopedAdapters;
+  tokenListeners = new Set;
+  constructor(parent, scopeName) {
+    this.parent = parent;
+    this.context = parent.context;
+    this.scopeName = scopeName;
+    this.authAdapter = new AuthAdapter;
+    this.scopedAdapters = {
+      ...parent.getAdapters(),
+      authAdapter: this.authAdapter,
+      scope: this
+    };
+  }
+  setToken(token) {
+    this.authAdapter.setToken(token);
+    const eventWire = this.parent.getAdapters().eventWire;
+    if (eventWire) {
+      eventWire.setScopeToken(this.scopeName, token);
+      if (token && eventWire.getState() === "disconnected") {
+        eventWire.connect();
+      }
+    }
+    for (const listener4 of this.tokenListeners) {
+      listener4();
+    }
+  }
+  getToken() {
+    return this.authAdapter.getToken();
+  }
+  getDecoded() {
+    return this.authAdapter.getDecoded();
+  }
+  getParams() {
+    return this.authAdapter.getParams();
+  }
+  isAuthenticated() {
+    return this.authAdapter.isAuthenticated();
+  }
+  onTokenChange(listener4) {
+    this.tokenListeners.add(listener4);
+    return () => {
+      this.tokenListeners.delete(listener4);
+    };
+  }
+  getAdapters() {
+    return this.scopedAdapters;
+  }
+  getEnvironment() {
+    return this.parent.getEnvironment();
+  }
+  getAuth() {
+    return { scope: this.scopeName, token: this.getToken() };
+  }
+  executeCommand(name, params) {
+    const wire = this.parent.getAdapters().commandWire;
+    if (!wire) {
+      throw new Error(`Cannot execute command "${name}": no commandWire available.`);
+    }
+    return wire.executeCommand(name, params, this.getAuth());
+  }
+  remoteQuery(viewName, options) {
+    const wire = this.parent.getAdapters().queryWire;
+    if (!wire) {
+      throw new Error(`Cannot query "${viewName}": no queryWire available.`);
+    }
+    return wire.query(viewName, options, this.getAuth());
+  }
+  subscribeQuery(descriptor, callback) {
+    const wire = this.parent.getAdapters().eventWire;
+    if (!wire) {
+      throw new Error(`Cannot subscribe to query: no eventWire available.`);
+    }
+    return wire.subscribeQuery(descriptor, callback, this.scopeName);
+  }
+  get query() {
+    return buildContextAccessor(this.context, this.scopedAdapters, "queryContext", (descriptor) => descriptor);
+  }
+  get command() {
+    return buildContextAccessor(this.context, this.scopedAdapters, "mutateContext", (descriptor) => descriptor);
+  }
+  callQuery(descriptor) {
+    return executeDescriptor(descriptor, this.context, this.scopedAdapters, "queryContext");
+  }
+  callCommand(descriptor) {
+    return executeDescriptor(descriptor, this.context, this.scopedAdapters, "mutateContext");
+  }
+}
+
+class Model {
+  context;
+  adapters;
+  environment;
+  initialized = false;
+  scopes = new Map;
+  constructor(context2, options) {
+    this.context = context2;
+    this.adapters = options.adapters;
+    this.environment = options.environment;
+  }
+  async init() {
+    if (this.initialized) {
+      return;
+    }
+    if (this.adapters.eventPublisher) {
+      const views = this.context.elements.filter((element2) => ("getHandlers" in element2) && ("databaseStoreSchema" in element2) && ("schema" in element2));
+      this.adapters.eventPublisher.registerViews(views);
+    }
+    for (const element2 of this.context.elements) {
+      if (element2.init) {
+        await element2.init(this.environment, this.adapters);
+      }
+    }
+    this.initialized = true;
+  }
+  getAdapters() {
+    return this.adapters;
+  }
+  getEnvironment() {
+    return this.environment;
+  }
+  scope(name) {
+    let s = this.scopes.get(name);
+    if (!s) {
+      s = new ScopedModel(this, name);
+      this.scopes.set(name, s);
+    }
+    return s;
+  }
+}
+class StreamingQueryCache {
+  stores = new Map;
+  views = [];
+  activeStreams = new Map;
+  pendingUnsubscribes = new Map;
+  static UNSUBSCRIBE_DELAY_MS = 5000;
+  registerViews(views) {
+    this.views = views;
+    for (const view3 of views) {
+      if (!this.stores.has(view3.name)) {
+        this.stores.set(view3.name, new StreamingStore);
+      }
+    }
+  }
+  getStore(viewName) {
+    if (!this.stores.has(viewName)) {
+      this.stores.set(viewName, new StreamingStore);
+    }
+    return this.stores.get(viewName);
+  }
+  hasData(viewName) {
+    const store = this.stores.get(viewName);
+    return store ? store.hasData() : false;
+  }
+  hasActiveStream(viewName) {
+    return this.activeStreams.has(viewName);
+  }
+  registerStream(viewName, createStream) {
+    const pending = this.pendingUnsubscribes.get(viewName);
+    if (pending) {
+      clearTimeout(pending);
+      this.pendingUnsubscribes.delete(viewName);
+    }
+    const existing = this.activeStreams.get(viewName);
+    if (existing) {
+      existing.refCount++;
+      return {
+        unsubscribe: () => this.unregisterStream(viewName),
+        wasReused: true
+      };
+    }
+    const streamConn = createStream();
+    this.activeStreams.set(viewName, {
+      unsubscribe: streamConn.unsubscribe,
+      refCount: 1
+    });
+    return {
+      unsubscribe: () => this.unregisterStream(viewName),
+      wasReused: false
+    };
+  }
+  unregisterStream(viewName) {
+    const stream = this.activeStreams.get(viewName);
+    if (!stream)
+      return;
+    stream.refCount--;
+    if (stream.refCount <= 0) {
+      const timeout = setTimeout(() => {
+        this.pendingUnsubscribes.delete(viewName);
+        const current2 = this.activeStreams.get(viewName);
+        if (current2 && current2.refCount <= 0) {
+          current2.unsubscribe();
+          this.activeStreams.delete(viewName);
+        }
+      }, StreamingQueryCache.UNSUBSCRIBE_DELAY_MS);
+      this.pendingUnsubscribes.set(viewName, timeout);
+    }
+  }
+  subscribeQuery(descriptor, eventWire, scope) {
+    const key = descriptor.element;
+    const { unsubscribe } = this.registerStream(key, () => {
+      const subId = eventWire.subscribeQuery(descriptor, (data) => {
+        this.setViewData(descriptor.element, data);
+      }, scope);
+      return { unsubscribe: () => eventWire.unsubscribeQuery(subId) };
+    });
+    return unsubscribe;
+  }
+  setViewData(viewName, data) {
+    const store = this.stores.get(viewName);
+    if (!store)
+      return;
+    if (Array.isArray(data)) {
+      store.setAll(data);
+    } else if (data && typeof data === "object" && "_id" in data) {
+      store.setAll([data]);
+    } else {
+      store.setAll([]);
+    }
+  }
+  async applyEvent(event3) {
+    for (const view3 of this.views) {
+      const handlers = view3.getHandlers();
+      const handler = handlers[event3.type];
+      if (!handler)
+        continue;
+      const store = this.stores.get(view3.name);
+      if (!store)
+        continue;
+      const ctx = {
+        set: async (id3, data) => {
+          store.set(String(id3), { _id: String(id3), ...data });
+        },
+        modify: async (id3, data) => {
+          store.modify(String(id3), data);
+        },
+        remove: async (id3) => {
+          store.remove(String(id3));
+        },
+        find: async (options) => {
+          return store.find(options);
+        },
+        findOne: async (where) => {
+          return store.findOne(where);
+        },
+        $auth: {}
+      };
+      await handler(ctx, event3);
+    }
+  }
+  clear() {
+    for (const stream of this.activeStreams.values()) {
+      stream.unsubscribe();
+    }
+    this.activeStreams.clear();
+    for (const store of this.stores.values()) {
+      store.clear();
+    }
+  }
+}
+
+class StreamingStore {
+  data = new Map;
+  listeners = new Set;
+  initialized = false;
+  hasData() {
+    return this.initialized;
+  }
+  setAll(items) {
+    this.initialized = true;
+    this.data.clear();
+    for (const item of items) {
+      this.data.set(item._id, item);
+    }
+    this.notifyListeners(null);
+  }
+  set(id3, item) {
+    this.data.set(id3, item);
+    this.notifyListeners([{ type: "set", id: id3, item }]);
+  }
+  modify(id3, updates) {
+    const existing = this.data.get(id3);
+    if (existing) {
+      const updated = { ...existing, ...updates };
+      this.data.set(id3, updated);
+      this.notifyListeners([{ type: "set", id: id3, item: updated }]);
+    }
+  }
+  remove(id3) {
+    if (this.data.delete(id3)) {
+      this.notifyListeners([{ type: "delete", id: id3, item: null }]);
+    }
+  }
+  clear() {
+    this.initialized = false;
+    this.data.clear();
+    this.notifyListeners(null);
+  }
+  find(options = {}) {
+    let results = Array.from(this.data.values());
+    if (options.where) {
+      results = results.filter((item) => checkItemMatchesWhere(item, options.where));
+    }
+    return applyOrderByAndLimit(results, options);
+  }
+  findOne(where) {
+    const results = this.find({ where });
+    return results[0];
+  }
+  subscribe(listener4) {
+    this.listeners.add(listener4);
+    return () => {
+      this.listeners.delete(listener4);
+    };
+  }
+  notifyListeners(events) {
+    for (const listener4 of this.listeners) {
+      listener4(events);
+    }
+  }
+}
+
+class StreamingEventPublisher {
+  cache;
+  eventWire;
+  views = [];
+  subscribers = new Map;
+  constructor(cache, eventWire) {
+    this.cache = cache;
+    this.eventWire = eventWire;
+  }
+  registerViews(views) {
+    this.views = views;
+    this.cache.registerViews(views);
+  }
+  async publish(event3) {
+    await this.cache.applyEvent(event3);
+    await this.notifySubscribers(event3);
+    this.eventWire.syncEvents([
+      {
+        localId: event3.id,
+        type: event3.type,
+        payload: event3.payload,
+        createdAt: event3.createdAt.toISOString()
+      }
+    ]);
+  }
+  subscribe(eventType, callback) {
+    if (!this.subscribers.has(eventType)) {
+      this.subscribers.set(eventType, new Set);
+    }
+    this.subscribers.get(eventType).add(callback);
+    return () => {
+      const subs = this.subscribers.get(eventType);
+      if (subs) {
+        subs.delete(callback);
+        if (subs.size === 0) {
+          this.subscribers.delete(eventType);
+        }
+      }
+    };
+  }
+  async markSynced(_eventIds) {}
+  async getUnsyncedEvents(_eventType) {
+    return [];
+  }
+  async notifySubscribers(event3) {
+    const subs = this.subscribers.get(event3.type);
+    if (!subs || subs.size === 0)
+      return;
+    const promises = [];
+    for (const callback of subs) {
+      try {
+        const result = callback(event3);
+        if (result instanceof Promise) {
+          promises.push(result);
+        }
+      } catch (error) {
+        console.error(`Listener error for event "${event3.type}":`, error);
+      }
+    }
+    if (promises.length > 0) {
+      await Promise.all(promises.map((p) => p.catch((e) => console.error(e))));
+    }
+  }
+}
+
+class SecuredStoreState {
+  store;
+  tokenInstance;
+  storeName;
+  context;
+  protection;
+  constructor(store, tokenInstance, storeName, context2) {
+    this.store = store;
+    this.tokenInstance = tokenInstance;
+    this.storeName = storeName;
+    this.context = context2;
+    this.protection = this.getProtectionFromContext();
+  }
+  getProtectionFromContext() {
+    if (!this.context) {
+      return null;
+    }
+    const view3 = this.context.elements.find((el) => el.name === this.storeName);
+    if (!view3 || !("getProtectionFor" in view3)) {
+      return null;
+    }
+    return view3.getProtectionFor(this.tokenInstance);
+  }
+  async find(options = {}) {
+    const securedOptions = this.applyTokenCondition(options, "read");
+    if (securedOptions === null) {
+      return [];
+    }
+    return this.store.find(securedOptions);
+  }
+  async set(item) {
+    if (!this.canWrite()) {
+      throw new Error(`Write access denied for store "${this.storeName}" with token "${this.tokenInstance.name}"`);
+    }
+    const writeCondition = this.getWriteCondition();
+    if (writeCondition) {
+      if (!this.itemMatchesCondition(item, writeCondition)) {
+        throw new Error(`Item does not match write condition for store "${this.storeName}"`);
+      }
+    }
+    return this.store.set(item);
+  }
+  async remove(id3) {
+    if (!this.canWrite()) {
+      throw new Error(`Write access denied for store "${this.storeName}" with token "${this.tokenInstance.name}"`);
+    }
+    return this.store.remove(id3);
+  }
+  async modify(id3, data) {
+    if (!this.canWrite()) {
+      throw new Error(`Write access denied for store "${this.storeName}" with token "${this.tokenInstance.name}"`);
+    }
+    return this.store.modify(id3, data);
+  }
+  async applyChanges(changes) {
+    if (!this.canWrite()) {
+      throw new Error(`Write access denied for store "${this.storeName}" with token "${this.tokenInstance.name}"`);
+    }
+    return this.store.applyChanges(changes);
+  }
+  fork() {
+    return this.store.fork();
+  }
+  applyTokenCondition(options, operation) {
+    if (!this.protection) {
+      return options;
+    }
+    const condition = operation === "read" ? this.protection.read : this.protection.write;
+    if (condition === false) {
+      return null;
+    }
+    const mergedWhere = {
+      ...options.where,
+      ...condition
+    };
+    return {
+      ...options,
+      where: mergedWhere
+    };
+  }
+  canWrite() {
+    if (!this.protection) {
+      return true;
+    }
+    return this.protection.write !== false;
+  }
+  getWriteCondition() {
+    if (!this.protection || this.protection.write === false) {
+      return null;
+    }
+    return this.protection.write || null;
+  }
+  itemMatchesCondition(item, condition) {
+    for (const [key, value] of Object.entries(condition)) {
+      if (item[key] !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+
+class SecuredDataStorage {
+  dataStorage;
+  tokenInstance;
+  context;
+  storeCache = new Map;
+  constructor(dataStorage, tokenInstance, context2) {
+    this.dataStorage = dataStorage;
+    this.tokenInstance = tokenInstance;
+    this.context = context2;
+  }
+  getStore(storeName) {
+    let securedStore = this.storeCache.get(storeName);
+    if (!securedStore) {
+      const store = this.dataStorage.getStore(storeName);
+      securedStore = new SecuredStoreState(store, this.tokenInstance, storeName, this.context);
+      this.storeCache.set(storeName, securedStore);
+    }
+    return securedStore;
+  }
+  getUnsecuredStorage() {
+    return this.dataStorage;
+  }
+  getTokenInstance() {
+    return this.tokenInstance;
+  }
+  fork() {
+    return this.dataStorage.fork();
+  }
+}
+class TokenCache {
+  instanceCache = new Map;
+  permissionCache = new Map;
+  ttl;
+  maxSize;
+  constructor(options = {}) {
+    this.ttl = options.ttl ?? 5 * 60 * 1000;
+    this.maxSize = options.maxSize ?? 1000;
+  }
+  async getOrCreate(jwt, factory) {
+    const cached = this.instanceCache.get(jwt);
+    if (cached && cached.expiresAt > Date.now()) {
+      return cached.value;
+    }
+    const instance = await factory();
+    if (instance) {
+      this.setInstance(jwt, instance);
+    }
+    return instance;
+  }
+  async getPermission(instance, permission, factory) {
+    const key = this.getPermissionKey(instance, permission);
+    const cached = this.permissionCache.get(key);
+    if (cached && cached.expiresAt > Date.now()) {
+      return cached.value;
+    }
+    const result = await factory();
+    this.setPermission(key, result);
+    return result;
+  }
+  setInstance(jwt, instance) {
+    this.ensureCapacity(this.instanceCache);
+    this.instanceCache.set(jwt, {
+      value: instance,
+      expiresAt: Date.now() + this.ttl
+    });
+  }
+  setPermission(key, result) {
+    this.ensureCapacity(this.permissionCache);
+    this.permissionCache.set(key, {
+      value: result,
+      expiresAt: Date.now() + this.ttl
+    });
+  }
+  getPermissionKey(instance, permission) {
+    return `${instance.name}:${JSON.stringify(instance.params)}:${permission}`;
+  }
+  ensureCapacity(cache) {
+    if (cache.size >= this.maxSize) {
+      const toRemove = Math.floor(this.maxSize * 0.1);
+      const keys = Array.from(cache.keys()).slice(0, toRemove);
+      for (const key of keys) {
+        cache.delete(key);
+      }
+    }
+  }
+  invalidateInstance(instance) {
+    const prefix = `${instance.name}:${JSON.stringify(instance.params)}:`;
+    for (const key of this.permissionCache.keys()) {
+      if (key.startsWith(prefix)) {
+        this.permissionCache.delete(key);
+      }
+    }
+  }
+  invalidateJWT(jwt) {
+    const instance = this.instanceCache.get(jwt)?.value;
+    this.instanceCache.delete(jwt);
+    if (instance) {
+      this.invalidateInstance(instance);
+    }
+  }
+  clear() {
+    this.instanceCache.clear();
+    this.permissionCache.clear();
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.instanceCache) {
+      if (entry.expiresAt <= now) {
+        this.instanceCache.delete(key);
+      }
+    }
+    for (const [key, entry] of this.permissionCache) {
+      if (entry.expiresAt <= now) {
+        this.permissionCache.delete(key);
+      }
+    }
+  }
+  getStats() {
+    return {
+      instanceCount: this.instanceCache.size,
+      permissionCount: this.permissionCache.size,
+      maxSize: this.maxSize,
+      ttl: this.ttl
+    };
+  }
+}
+
+// src/sqlite-adapter.ts
+class SQLiteReadTransaction {
+  db;
+  tables;
+  adapter;
+  constructor(db, tables, adapter) {
+    this.db = db;
+    this.tables = tables;
+    this.adapter = adapter;
+  }
+  hasSoftDelete(tableName) {
+    if (this.adapter) {
+      return this.adapter.hasSoftDelete(tableName);
+    }
+    const table = this.tables.get(tableName);
+    if (!table)
+      return false;
+    return table.columns.some((col) => col.name === "deleted");
+  }
+  deserializeValue(value, column) {
+    if (value === null || value === undefined)
+      return null;
+    switch (column.type.toLowerCase()) {
+      case "json":
+        if (typeof value === "string") {
+          try {
+            return JSON.parse(value);
+          } catch {
+            return value;
+          }
+        }
+        return value;
+      case "text":
+        if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+          try {
+            const parsed = JSON.parse(value);
+            if (typeof parsed === "object" || Array.isArray(parsed)) {
+              return parsed;
+            }
+          } catch {}
+        }
+        return value;
+      case "datetime":
+      case "timestamp":
+        return new Date(value);
+      default:
+        return value;
+    }
+  }
+  deserializeRow(row, table) {
+    const result = {};
+    for (const column of table.columns) {
+      const value = row[column.name];
+      result[column.name] = this.deserializeValue(value, column);
+    }
+    return result;
+  }
+  getId(store, id2) {
+    return id2;
+  }
+  buildWhereClause(where, tableName) {
+    const conditions = [];
+    const params = [];
+    if (tableName && this.hasSoftDelete(tableName)) {
+      conditions.push('"deleted" = 0');
+    }
+    if (!where) {
+      return {
+        sql: conditions.length > 0 ? conditions.join(" AND ") : "1=1",
+        params
+      };
+    }
+    Object.entries(where).forEach(([key, value]) => {
+      if (typeof value === "object" && value !== null) {
+        Object.entries(value).forEach(([operator, operand]) => {
+          switch (operator) {
+            case "$eq":
+            case "$ne":
+            case "$gt":
+            case "$gte":
+            case "$lt":
+            case "$lte":
+              conditions.push(`"${key}" ${this.getOperatorSymbol(operator)} ?`);
+              params.push(operand);
+              break;
+            case "$in":
+            case "$nin":
+              if (Array.isArray(operand)) {
+                conditions.push(`"${key}" ${operator === "$in" ? "IN" : "NOT IN"} (${operand.map(() => "?").join(", ")})`);
+                params.push(...operand);
+              }
+              break;
+            case "$exists":
+              if (typeof operand === "boolean") {
+                conditions.push(operand ? `"${key}" IS NOT NULL` : `"${key}" IS NULL`);
+              }
+              break;
+          }
+        });
+      } else {
+        conditions.push(`"${key}" = ?`);
+        params.push(value);
+      }
+    });
+    return {
+      sql: conditions.join(" AND "),
+      params
+    };
+  }
+  getOperatorSymbol(operator) {
+    const operators = {
+      $eq: "=",
+      $ne: "!=",
+      $gt: ">",
+      $gte: ">=",
+      $lt: "<",
+      $lte: "<="
+    };
+    return operators[operator] || "=";
+  }
+  buildOrderByClause(orderBy) {
+    if (!orderBy)
+      return "";
+    const orderClauses = Object.entries(orderBy).map(([key, direction]) => `"${key}" ${direction.toUpperCase()}`).join(", ");
+    return orderClauses ? `ORDER BY ${orderClauses}` : "";
+  }
+  async find(store, options) {
+    const { where, limit, offset, orderBy } = options || {};
+    const whereClause = this.buildWhereClause(where, store);
+    const orderByClause = this.buildOrderByClause(orderBy);
+    const table = this.tables.get(store);
+    if (!table) {
+      throw new Error(`Store ${store} not found`);
+    }
+    const query = `
+      SELECT * 
+      FROM "${table.name}" 
+      WHERE ${whereClause.sql}
+      ${orderByClause}
+      ${limit ? `LIMIT ${limit}` : ""}
+      ${offset ? `OFFSET ${offset}` : ""}
+    `;
+    const rows = await this.db.exec(query, whereClause.params);
+    return rows.map((row) => this.deserializeRow(row, table));
+  }
+}
+
+class SQLiteReadWriteTransaction extends SQLiteReadTransaction {
+  adapter;
+  queries = [];
+  constructor(db, tables, adapter) {
+    super(db, tables);
+    this.adapter = adapter;
+  }
+  async remove(store, id2) {
+    const table = this.tables.get(store);
+    if (!table) {
+      throw new Error(`Store ${store} not found`);
+    }
+    const hasSoftDelete = this.adapter.hasSoftDelete(store);
+    if (hasSoftDelete) {
+      const query = `UPDATE "${table.name}" SET "deleted" = 1, "lastUpdate" = ? WHERE "${table.primaryKey}" = ?`;
+      this.queries.push({
+        sql: query,
+        params: [new Date().toISOString(), id2]
+      });
+    } else {
+      const query = `DELETE FROM "${table.name}" WHERE "${table.primaryKey}" = ?`;
+      this.queries.push({
+        sql: query,
+        params: [id2]
+      });
+    }
+  }
+  async set(store, item) {
+    const table = this.tables.get(store);
+    if (!table) {
+      throw new Error(`Store ${store} not found`);
+    }
+    const hasVersioning = this.adapter.hasVersioning(store);
+    if (hasVersioning) {
+      await this.setWithVersioning(store, item, table);
+    } else {
+      await this.setWithoutVersioning(store, item, table);
+    }
+  }
+  async setWithoutVersioning(store, item, table) {
+    const columnNames = table.columns.map((col) => col.name);
+    const values = table.columns.map((column) => {
+      let value = item[column.name];
+      if (value === undefined && column.default !== undefined) {
+        value = column.default;
+      }
+      return this.serializeValue(value, column);
+    });
+    const placeholders = columnNames.map(() => "?").join(", ");
+    if (store === "events") {
+      const simpleInsertSql = `
+        INSERT INTO "${table.name}"
+        (${columnNames.map((c) => `"${c}"`).join(", ")})
+        VALUES (${placeholders})
+      `;
+      this.queries.push({
+        sql: simpleInsertSql,
+        params: values
+      });
+    } else {
+      const sql = `
+        INSERT OR REPLACE INTO "${table.name}"
+        (${columnNames.map((c) => `"${c}"`).join(", ")})
+        VALUES (${placeholders})
+      `;
+      this.queries.push({
+        sql,
+        params: values
+      });
+    }
+  }
+  async setWithVersioning(store, item, table) {
+    const regularColumns = table.columns.filter((col) => col.name !== "__version");
+    const columnNames = regularColumns.map((col) => col.name);
+    const values = regularColumns.map((column) => {
+      let value = item[column.name];
+      if (value === undefined && column.default !== undefined) {
+        value = column.default;
+      }
+      return this.serializeValue(value, column);
+    });
+    columnNames.push("__version");
+    const placeholders = regularColumns.map(() => "?").join(", ");
+    const sql = `
+      WITH next_version AS (
+        INSERT INTO __arc_version_counters (table_name, last_version) 
+        VALUES (?, 1)
+        ON CONFLICT(table_name) 
+        DO UPDATE SET last_version = last_version + 1
+        RETURNING last_version
+      )
+      INSERT OR REPLACE INTO "${table.name}"
+      (${columnNames.map((c) => `"${c}"`).join(", ")})
+      VALUES (${placeholders}, (SELECT last_version FROM next_version))
+    `;
+    this.queries.push({
+      sql,
+      params: [...values, store]
+    });
+  }
+  async commit() {
+    if (this.queries.length === 0) {
+      return Promise.resolve();
+    }
+    try {
+      await this.db.execBatch(this.queries);
+      this.queries = [];
+    } catch (error) {
+      this.queries = [];
+      throw error;
+    }
+  }
+  serializeValue(value, column) {
+    if (value === null || value === undefined)
+      return null;
+    switch (column.type.toLowerCase()) {
+      case "timestamp":
+      case "datetime":
+        if (value instanceof Date) {
+          return value.toISOString();
+        }
+        if (typeof value === "number") {
+          const date = value > 10000000000 ? new Date(value) : new Date(value * 1000);
+          return date.toISOString();
+        }
+        if (typeof value === "string") {
+          const date = new Date(value);
+          if (!isNaN(date.getTime())) {
+            return date.toISOString();
+          }
+        }
+        return value;
+      case "json":
+        return JSON.stringify(value);
+      default:
+        if (value instanceof Date) {
+          return value.toISOString();
+        }
+        if (Array.isArray(value) || typeof value === "object") {
+          return JSON.stringify(value);
+        }
+        return value;
+    }
+  }
+}
+
+class SQLiteAdapter {
+  db;
+  context;
+  tables = new Map;
+  tableSchemas = new Map;
+  pendingReinitTables = [];
+  mapType(arcType, storeData) {
+    if (storeData?.databaseType?.sqlite) {
+      return storeData.databaseType.sqlite;
+    }
+    switch (arcType) {
+      case "string":
+      case "id":
+      case "customId":
+      case "stringEnum":
+        return "TEXT";
+      case "number":
+        return "INTEGER";
+      case "boolean":
+        return "INTEGER";
+      case "date":
+        return "TIMESTAMP";
+      case "object":
+      case "array":
+      case "record":
+        return "JSON";
+      case "blob":
+        return "BLOB";
+      default:
+        return "TEXT";
+    }
+  }
+  buildConstraints(storeData) {
+    const constraints = [];
+    if (storeData?.isPrimaryKey) {
+      constraints.push("PRIMARY KEY");
+    }
+    if (storeData?.isAutoIncrement) {
+      constraints.push("AUTOINCREMENT");
+    }
+    if (storeData?.isUnique) {
+      constraints.push("UNIQUE");
+    }
+    if (storeData?.foreignKey) {
+      const { table, column, onDelete, onUpdate } = storeData.foreignKey;
+      let fkConstraint = `REFERENCES ${table}(${column})`;
+      if (onDelete)
+        fkConstraint += ` ON DELETE ${onDelete}`;
+      if (onUpdate)
+        fkConstraint += ` ON UPDATE ${onUpdate}`;
+      constraints.push(fkConstraint);
+    }
+    return constraints;
+  }
+  generateColumnSQL(columnInfo) {
+    const type = this.mapType(columnInfo.type, columnInfo.storeData);
+    const constraints = [];
+    if (!columnInfo.storeData?.isNullable) {
+      constraints.push("NOT NULL");
+    }
+    constraints.push(...this.buildConstraints(columnInfo.storeData));
+    if (columnInfo.defaultValue !== undefined) {
+      if (typeof columnInfo.defaultValue === "string") {
+        constraints.push(`DEFAULT '${columnInfo.defaultValue}'`);
+      } else {
+        constraints.push(`DEFAULT ${columnInfo.defaultValue}`);
+      }
+    }
+    return `"${columnInfo.name}" ${type} ${constraints.join(" ")}`.trim();
+  }
+  generateCreateTableSQL(tableName, columns) {
+    const columnDefinitions = columns.map((col) => this.generateColumnSQL(col));
+    const indexes = columns.filter((col) => col.storeData?.hasIndex && !col.storeData?.isPrimaryKey).map((col) => `CREATE INDEX IF NOT EXISTS idx_${tableName}_${col.name} ON "${tableName}"("${col.name}");`);
+    let sql = `CREATE TABLE IF NOT EXISTS "${tableName}" (
+  ${columnDefinitions.join(`,
+  `)}
+)`;
+    if (indexes.length > 0) {
+      sql += `;
+` + indexes.join(`
+`);
+    }
+    return sql;
+  }
+  constructor(db, context) {
+    this.db = db;
+    this.context = context;
+    this.context.elements.forEach((element) => {
+      if ("databaseStoreSchema" in element && typeof element.databaseStoreSchema === "function") {
+        const databaseSchema = element.databaseStoreSchema();
+        databaseSchema.tables.forEach((dbTable) => {
+          const agnosticSchema = extractDatabaseAgnosticSchema(dbTable.schema, dbTable.name);
+          const columns = agnosticSchema.columns.map((columnInfo) => ({
+            name: columnInfo.name,
+            type: this.mapType(columnInfo.type, columnInfo.storeData),
+            constraints: this.buildConstraints(columnInfo.storeData),
+            isNullable: columnInfo.storeData?.isNullable || false,
+            defaultValue: columnInfo.defaultValue,
+            isPrimaryKey: columnInfo.storeData?.isPrimaryKey || false,
+            isAutoIncrement: columnInfo.storeData?.isAutoIncrement || false,
+            isUnique: columnInfo.storeData?.isUnique || false,
+            hasIndex: columnInfo.storeData?.hasIndex || false,
+            foreignKey: columnInfo.storeData?.foreignKey
+          }));
+          this.tableSchemas.set(dbTable.name, columns);
+          const legacyTable = {
+            name: dbTable.name,
+            primaryKey: columns.find((col) => col.isPrimaryKey)?.name || "_id",
+            columns: columns.map((col) => ({
+              name: col.name,
+              type: col.type,
+              isOptional: col.isNullable,
+              default: col.defaultValue
+            }))
+          };
+          this.tables.set(dbTable.name, legacyTable);
+        });
+      }
+    });
+  }
+  async initialize() {
+    await this.createVersionCounterTable();
+    await this.createTableVersionsTable();
+    const processedSchemas = new Set;
+    const processedTables = new Set;
+    for (const element of this.context.elements) {
+      if ("databaseStoreSchema" in element && typeof element.databaseStoreSchema === "function") {
+        const databaseSchema = element.databaseStoreSchema();
+        if (processedSchemas.has(databaseSchema)) {
+          continue;
+        }
+        processedSchemas.add(databaseSchema);
+        for (const dbTable of databaseSchema.tables) {
+          const tableKey = dbTable.version ? `${dbTable.name}_v${dbTable.version}` : dbTable.name;
+          if (!processedTables.has(tableKey)) {
+            const agnosticSchema = extractDatabaseAgnosticSchema(dbTable.schema, dbTable.name);
+            let allColumns = [...agnosticSchema.columns];
+            if (dbTable.options?.versioning) {
+              allColumns.push({
+                name: "__version",
+                type: "number",
+                storeData: { isNullable: false, hasIndex: true },
+                defaultValue: 1
+              });
+            }
+            if (dbTable.options?.softDelete) {
+              allColumns.push({
+                name: "deleted",
+                type: "boolean",
+                storeData: { isNullable: false, hasIndex: true },
+                defaultValue: false
+              });
+            }
+            const physicalTableName = this.getPhysicalTableName(dbTable.name, dbTable.version);
+            if (dbTable.version && await this.checkVersionedTableExists(dbTable.name, dbTable.version)) {
+              console.log(`Versioned table ${physicalTableName} already exists, skipping creation`);
+            } else {
+              await this.createTableIfNotExistsNew(physicalTableName, allColumns);
+              if (dbTable.version) {
+                await this.registerTableVersion(dbTable.name, dbTable.version, physicalTableName);
+              }
+            }
+            if (dbTable.version && databaseSchema.reinitTable) {
+              this.pendingReinitTables.push({
+                tableName: physicalTableName,
+                reinitFn: databaseSchema.reinitTable
+              });
+            }
+            const legacyTable = {
+              name: physicalTableName,
+              primaryKey: allColumns.find((col) => col.storeData?.isPrimaryKey)?.name || "_id",
+              columns: allColumns.map((col) => ({
+                name: col.name,
+                type: this.mapType(col.type, col.storeData),
+                isOptional: col.storeData?.isNullable || false,
+                default: col.defaultValue
+              }))
+            };
+            this.tables.set(dbTable.name, legacyTable);
+            processedTables.add(tableKey);
+          }
+        }
+      }
+    }
+  }
+  async createTableIfNotExistsNew(tableName, columns) {
+    const createTableSQL = this.generateCreateTableSQL(tableName, columns);
+    await this.db.exec(createTableSQL);
+  }
+  async createVersionCounterTable() {
+    const sql = `
+      CREATE TABLE IF NOT EXISTS __arc_version_counters (
+        table_name TEXT PRIMARY KEY,
+        last_version INTEGER NOT NULL DEFAULT 0
+      )
+    `;
+    await this.db.exec(sql);
+  }
+  async createTableVersionsTable() {
+    const sql = `
+      CREATE TABLE IF NOT EXISTS __arc_table_versions (
+        table_name TEXT NOT NULL,
+        version INTEGER NOT NULL,
+        physical_table_name TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        is_active INTEGER DEFAULT 0,
+        PRIMARY KEY (table_name, version)
+      )
+    `;
+    await this.db.exec(sql);
+  }
+  getPhysicalTableName(logicalName, version) {
+    return version ? `${logicalName}_v${version}` : logicalName;
+  }
+  async checkVersionedTableExists(logicalName, version) {
+    const result = await this.db.exec("SELECT COUNT(*) as count FROM __arc_table_versions WHERE table_name = ? AND version = ?", [logicalName, version]);
+    return result[0]?.count > 0;
+  }
+  async registerTableVersion(logicalName, version, physicalName) {
+    await this.db.exec("INSERT INTO __arc_table_versions (table_name, version, physical_table_name, is_active) VALUES (?, ?, ?, ?)", [logicalName, version, physicalName, 1]);
+  }
+  hasVersioning(tableName) {
+    const table = this.tables.get(tableName);
+    if (!table)
+      return false;
+    return table.columns.some((col) => col.name === "__version");
+  }
+  hasSoftDelete(tableName) {
+    const table = this.tables.get(tableName);
+    if (!table)
+      return false;
+    return table.columns.some((col) => col.name === "deleted");
+  }
+  async executeReinitTables(dataStorage) {
+    for (const { tableName, reinitFn } of this.pendingReinitTables) {
+      await reinitFn(tableName, dataStorage);
+    }
+    this.pendingReinitTables = [];
+  }
+  readWriteTransaction(stores) {
+    return new SQLiteReadWriteTransaction(this.db, this.tables, this);
+  }
+  readTransaction(stores) {
+    return new SQLiteReadTransaction(this.db, this.tables, this);
+  }
+  async destroy() {
+    for (const tableName of this.tables.keys()) {
+      const table = this.tables.get(tableName);
+      if (table) {
+        await this.db.exec(`DROP TABLE IF EXISTS "${table.name}"`);
+      }
+    }
+    await this.db.exec("DROP TABLE IF EXISTS __arc_version_counters");
+    await this.db.exec("DROP TABLE IF EXISTS __arc_table_versions");
+    this.tables.clear();
+    this.tableSchemas.clear();
+    this.pendingReinitTables = [];
+  }
+}
+var createSQLiteAdapterFactory = (db) => {
+  return async (context) => {
+    const adapter = new SQLiteAdapter(db, context);
+    await adapter.initialize();
+    return adapter;
+  };
+};
+
+// src/bun-sqlite.ts
+class BunSQLiteDatabase {
+  db;
+  constructor(filename = ":memory:") {
+    this.db = new Database(filename);
+    this.db.exec("PRAGMA journal_mode=WAL");
+  }
+  async exec(sql, params) {
+    try {
+      if (params && params.length > 0) {
+        const stmt = this.db.prepare(sql);
+        if (sql.trim().toUpperCase().startsWith("SELECT")) {
+          return stmt.all(...params);
+        } else {
+          stmt.run(...params);
+          return [];
+        }
+      } else {
+        const statements = sql.split(";").filter((s) => s.trim());
+        let result = [];
+        for (const statement of statements) {
+          if (!statement.trim())
+            continue;
+          if (statement.trim().toUpperCase().startsWith("SELECT")) {
+            result = this.db.prepare(statement).all();
+          } else {
+            this.db.exec(statement);
+          }
+        }
+        return result;
+      }
+    } catch (error) {
+      console.error("SQL Error:", error, `
+SQL:`, sql, `
+Params:`, params);
+      throw error;
+    }
+  }
+  async execBatch(queries) {
+    this.db.exec("BEGIN TRANSACTION");
+    try {
+      for (const query of queries) {
+        if (query.params && query.params.length > 0) {
+          this.db.prepare(query.sql).run(...query.params);
+        } else {
+          this.db.exec(query.sql);
+        }
+      }
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  close() {
+    this.db.close();
+  }
+}
+var createBunSQLiteAdapterFactory = (filename = ":memory:") => {
+  return async (context) => {
+    const db = new BunSQLiteDatabase(filename);
+    return createSQLiteAdapterFactory(db)(context);
+  };
+};
+export {
+  createSQLiteAdapterFactory,
+  createBunSQLiteAdapterFactory,
+  SQLiteAdapter,
+  BunSQLiteDatabase
+};