@arcote.tech/arc-host 0.3.1 → 0.3.2

package/dist/index.js

@@ -3855,7 +3855,17 @@ class ContextHandler {
       throw new Error(`Command '${commandName}' not found`);
     }
     this.authAdapter.setToken(rawToken);
-    return await command(params);
+    try {
+      return await command(params);
+    } catch (error) {
+      console.error(`[ARC] Command '${commandName}' failed:`);
+      console.error(`[ARC] Params:`, JSON.stringify(params, null, 2));
+      console.error(`[ARC] Error:`, error);
+      if (error instanceof Error) {
+        console.error(`[ARC] Stack:`, error.stack);
+      }
+      throw error;
+    }
   }
   async persistEvents(events, clientId, token) {
     const persistedEvents = [];
@@ -4114,7 +4124,7 @@ class ArcHost {
           return self.handleHttpCommand(req, url, corsHeaders, token);
         }
         if (url.pathname.startsWith("/query/") && req.method === "POST") {
-          return self.handleHttpQuery(req, url, tokenPayload, corsHeaders);
+          return self.handleHttpQuery(req, url, tokenPayload, corsHeaders, token);
         }
         if (url.pathname.startsWith("/stream/") && req.method === "GET") {
           return self.handleHttpStream(req, url, tokenPayload, corsHeaders, token);
@@ -4122,6 +4132,9 @@ class ArcHost {
         if (url.pathname === "/sync/events" && req.method === "POST") {
           return self.handleHttpEventSync(req, tokenPayload, corsHeaders);
         }
+        if (url.pathname.startsWith("/route/")) {
+          return self.handleHttpRoute(req, url, tokenPayload, corsHeaders, token);
+        }
         return new Response("Not Found", { status: 404, headers: corsHeaders });
       },
       websocket: {
@@ -4166,13 +4179,17 @@ class ArcHost {
         headers: { ...corsHeaders, "Content-Type": "application/json" }
       });
     } catch (error) {
+      console.error(`[ARC HTTP] Command '${commandName}' error:`, error);
+      if (error instanceof Error && error.stack) {
+        console.error(`[ARC HTTP] Stack trace:`, error.stack);
+      }
       return new Response(JSON.stringify({ error: error.message }), {
         status: 500,
         headers: { ...corsHeaders, "Content-Type": "application/json" }
       });
     }
   }
-  async handleHttpQuery(req, url, token, corsHeaders) {
+  async handleHttpQuery(req, url, _token, corsHeaders, rawToken) {
     const viewName = url.pathname.split("/query/")[1];
     if (!viewName) {
       return new Response("Invalid query path", {
@@ -4182,9 +4199,18 @@ class ArcHost {
     }
     try {
       const params = await req.json();
-      const dataStorage = this.contextHandler.getDataStorage();
-      const tx = await dataStorage.getReadTransaction();
-      const result = await tx.find(viewName, params);
+      const viewElement = this.contextHandler.getModel().context.get(viewName);
+      if (!viewElement || !viewElement.queryContext) {
+        return new Response(JSON.stringify({ error: "View not found" }), {
+          status: 404,
+          headers: { ...corsHeaders, "Content-Type": "application/json" }
+        });
+      }
+      this.contextHandler.setAuthToken(rawToken);
+      const model = this.contextHandler.getModel();
+      const adapters = model.getAdapters();
+      const queryCtx = viewElement.queryContext(adapters);
+      const result = await queryCtx.find(params);
       return new Response(JSON.stringify(result), {
         headers: { ...corsHeaders, "Content-Type": "application/json" }
       });
@@ -4305,3755 +4331,102 @@ class ArcHost {
       });
     }
   }
-  stop() {
-    for (const conn of this.streamConnections.values()) {
-      conn.unsubscribe();
-    }
-    this.streamConnections.clear();
-    this.server?.stop();
-  }
-}
-// ../adapters/db/sqlite/dist/index.js
-import { Database } from "bun:sqlite";
-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);
+  async handleHttpRoute(req, url, tokenPayload, corsHeaders, rawToken) {
+    const method = req.method;
+    const context = this.contextHandler.getModel().context;
+    let matchedRoute = null;
+    let routeParams = {};
+    for (const element of context.elements) {
+      if (element && typeof element.matchesPath === "function") {
+        const route = element;
+        const match = route.matchesPath(url.pathname);
+        if (match.matches) {
+          matchedRoute = route;
+          routeParams = match.params;
+          break;
         }
-        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
+    if (!matchedRoute) {
+      return new Response(JSON.stringify({ error: "Route not found" }), {
+        status: 404,
+        headers: { ...corsHeaders, "Content-Type": "application/json" }
       });
     }
-    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
+    const handler = matchedRoute.getHandler(method);
+    if (!handler) {
+      return new Response(JSON.stringify({ error: `Method ${method} not allowed` }), {
+        status: 405,
+        headers: { ...corsHeaders, "Content-Type": "application/json" }
       });
     }
-    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]
-        };
+    if (!matchedRoute.isPublic && matchedRoute.hasProtections) {
+      if (!tokenPayload) {
+        return new Response(JSON.stringify({ error: "Unauthorized" }), {
+          status: 401,
+          headers: { ...corsHeaders, "Content-Type": "application/json" }
+        });
       }
-    };
-  },
-  [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);
+      this.contextHandler.setAuthToken(rawToken);
+      let isAuthorized = false;
+      for (const protection of matchedRoute.protections) {
+        if (protection.token.name === tokenPayload.tokenType) {
+          const mockTokenInstance = {
+            params: tokenPayload.params,
+            getTokenDefinition: () => protection.token
+          };
+          const allowed = await protection.check(mockTokenInstance);
+          if (allowed) {
+            isAuthorized = true;
+            break;
+          }
         }
-        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);
+      if (!isAuthorized) {
+        return new Response(JSON.stringify({ error: "Forbidden" }), {
+          status: 403,
+          headers: { ...corsHeaders, "Content-Type": "application/json" }
+        });
       }
-      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);
+    } else if (!matchedRoute.isPublic && !matchedRoute.hasProtections) {
+      if (!tokenPayload) {
+        return new Response(JSON.stringify({ error: "Unauthorized" }), {
+          status: 401,
+          headers: { ...corsHeaders, "Content-Type": "application/json" }
+        });
       }
-      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
+    this.contextHandler.setAuthToken(rawToken);
+    const model = this.contextHandler.getModel();
+    const adapters = model.getAdapters();
+    const authParams = tokenPayload ? { params: tokenPayload.params, tokenName: tokenPayload.tokenType } : undefined;
+    const routeContext = matchedRoute.buildContext(adapters, authParams);
+    try {
+      const response = await handler(routeContext, req, routeParams, url);
+      const newHeaders = new Headers(response.headers);
+      for (const [key, value] of Object.entries(corsHeaders)) {
+        newHeaders.set(key, value);
+      }
+      return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: newHeaders
       });
-      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);
+    } catch (error) {
+      return new Response(JSON.stringify({ error: error.message }), {
+        status: 500,
+        headers: { ...corsHeaders, "Content-Type": "application/json" }
       });
-    });
-  } 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);
+  stop() {
+    for (const conn of this.streamConnections.values()) {
+      conn.unsubscribe();
     }
-  });
-  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}`);
+    this.streamConnections.clear();
+    this.server?.stop();
   }
-  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();
-
-class ArcContextElement {
-  name;
-  constructor(name) {
-    this.name = name;
-  }
-}
-
-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)
-      return null;
-    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;
-  }
-  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 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().foreignKey("events", "_id", {
-        onDelete: "CASCADE"
-      }),
-      tagKey: new ArcString().index(),
-      tagValue: new ArcString().index()
-    });
-    const syncStatusSchema = new ArcObject({
-      _id: new ArcString().primaryKey(),
-      eventId: new ArcString().foreignKey("events", "_id", {
-        onDelete: "CASCADE"
-      }),
-      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 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)));
-  }
-  unsubscribe(listener) {
-    this.listeners.delete(listener);
-  }
-  notifyListeners(events) {
-    for (const listener of this.listeners.values()) {
-      listener.callback(events);
-    }
-  }
-}
-function deepMerge(target, source) {
-  const output = { ...target };
-  for (const key in source) {
-    if (source[key] === undefined) {
-      output[key] = undefined;
-      continue;
-    }
-    if (isObject(source[key]) && isObject(target[key])) {
-      output[key] = deepMerge(target[key], source[key]);
-    } else {
-      output[key] = source[key];
-    }
-  }
-  return output;
-}
-function isObject(item) {
-  return item && typeof item === "object" && !Array.isArray(item);
-}
-
-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, listener) {
-    if (listener) {
-      this.listeners.set(listener, { callback: listener });
-    }
-    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, listener) {
-    if (listener) {
-      this.listeners.set(listener, { callback: listener });
-    }
-    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 MasterDataStorage2 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, listener) {
-    const key = this.getQueryKey(storeName, options);
-    this.trackedQueries.set(key, {
-      storeName,
-      options,
-      result,
-      listener
-    });
-  }
-  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 listener = (events) => {
-      this.observable.handleStoreChange(this.storeName, events);
-    };
-    const result = await this.source.find(options, listener);
-    this.observable.trackQuery(this.storeName, options, result, listener);
-    return result;
-  }
-  unsubscribe(listener) {
-    this.source.unsubscribe(listener);
-  }
-  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);
-
-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(jwt2, factory) {
-    const cached = this.instanceCache.get(jwt2);
-    if (cached && cached.expiresAt > Date.now()) {
-      return cached.value;
-    }
-    const instance = await factory();
-    if (instance) {
-      this.setInstance(jwt2, 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(jwt2, instance) {
-    this.ensureCapacity(this.instanceCache);
-    this.instanceCache.set(jwt2, {
-      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(jwt2) {
-    const instance = this.instanceCache.get(jwt2)?.value;
-    this.instanceCache.delete(jwt2);
-    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
-    };
-  }
-}
-
-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;
-  };
-};
-
-class BunSQLiteDatabase {
-  db;
-  constructor(filename = ":memory:") {
-    this.db = new Database(filename);
-  }
-  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);
-  };
-};
-
-// sqliteAdapter.ts
-var sqliteAdapterFactory = (dbName) => {
-  return createBunSQLiteAdapterFactory(dbName);
-};
 // index.ts
 function hostLiveModel(context, dbAdapterFactory) {
   const host = new ArcHost({
@@ -8064,7 +4437,6 @@ function hostLiveModel(context, dbAdapterFactory) {
   return host;
 }
 export {
-  sqliteAdapterFactory,
   hostLiveModel,
   filterEventsForToken,
   canTokenReceiveEvent,
@@ -8074,5 +4446,5 @@ export {
   ArcHost
 };
 
-//# debugId=9946DC76B081270E64756E2164756E21
+//# debugId=788AEA1D4DCA4B2C64756E2164756E21
 //# sourceMappingURL=index.js.map