@arcote.tech/arc 0.0.27 → 0.1.2

package/dist/index.js

@@ -1,6 +1,13 @@
 // context/element.ts
 class ArcContextElement {
   $event;
+  name;
+  commandContext;
+  commandClient;
+  observer;
+}
+
+class ArcContextElementWithStore extends ArcContextElement {
 }
 
 // elements/optional.ts
@@ -26,7 +33,7 @@ class ArcOptional {
   }
   validate(value) {
     if (!value)
-      return {};
+      return false;
     return this.parent.validate(value);
   }
 }
@@ -90,7 +97,10 @@ class ArcDefault {
 
 // elements/abstract.ts
 class ArcAbstract {
-  validations = [];
+  validations;
+  constructor(validations = []) {
+    this.validations = validations;
+  }
   default(defaultValueOrCallback) {
     return new ArcDefault(this, defaultValueOrCallback);
   }
@@ -106,10 +116,18 @@ class ArcAbstract {
     return newInstance;
   }
   validate(value) {
-    return this.validations.reduce((acc, { name, validator }) => {
-      acc[name] = validator(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();
@@ -123,9 +141,6 @@ class ArcAbstract {
 
 // elements/abstract-primitive.ts
 class ArcPrimitive extends ArcAbstract {
-  constructor() {
-    super();
-  }
   serialize(value) {
     return value;
   }
@@ -137,8 +152,30 @@ class ArcPrimitive extends ArcAbstract {
   }
 }
 
+// elements/utils/type-validator-builder.ts
+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;
+    }
+  };
+}
+
 // elements/string.ts
+var stringValidator = typeValidatorBuilder("string");
+
 class ArcString extends ArcPrimitive {
+  constructor() {
+    super([stringValidator]);
+  }
   minLength(min) {
     return this.validation("minLength", (value) => {
       if (value.length < min)
@@ -157,6 +194,87 @@ class ArcString extends ArcPrimitive {
         };
     });
   }
+  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
+        };
+      }
+    });
+  }
+  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;
@@ -196,283 +314,571 @@ function customId(name, createFn) {
   return new ArcCustomId(name, createFn);
 }
 
-// context/query.ts
-class ArcQuery {
-  lastResult;
-  listener;
-}
+// elements/object.ts
+var objectValidator = typeValidatorBuilder("object");
 
-// collection/queries/abstract-collection-query.ts
-class ArcCollectionQuery extends ArcQuery {
-  collection;
-  bindedChangeHandler = this.changeHandler.bind(this);
-  store;
-  constructor(collection) {
-    super();
-    this.collection = collection;
-  }
-  async run(dataStorage, listener) {
-    const store = dataStorage.getStore(this.collection.name);
-    this.store = store;
-    const result = await this.fetch(store);
-    this.lastResult = result;
-    if (listener)
-      this.listener = listener;
-    return result;
-  }
-  changeHandler(changes) {
-    let resultChanged = false;
-    for (const change of changes) {
-      const response = this.onChange(change);
-      if (response !== false) {
-        this.lastResult = response;
-        resultChanged = true;
+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;
+        }
       }
-    }
-    if (resultChanged)
-      this.nextResult(this.lastResult);
-  }
-  unsubscribe() {
-    this.store.unsubscribe(this.bindedChangeHandler);
+    ]);
+    this.rawShape = rawShape;
   }
-  nextResult(result) {
-    this.lastResult = result;
-    this.listener?.(result);
+  parse(value) {
+    return Object.entries(this.rawShape).reduce((acc, [key, element]) => {
+      acc[key] = element.parse(value[key]);
+      return acc;
+    }, {});
   }
-}
-
-// collection/queries/abstract-many-items.ts
-class QueryCollectionResult {
-  result;
-  constructor(result) {
-    this.result = result;
+  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;
+    }, {});
   }
-  get(id2) {
-    return id2 ? this.result.find((r) => r._id === id2) : undefined;
+  deserialize(value) {
+    return Object.fromEntries(Object.entries(this.rawShape).map(([key, element]) => [
+      key,
+      element.deserialize(value[key])
+    ]));
   }
-  map(callbackfn) {
-    return this.result.map(callbackfn);
+  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);
   }
-  toArray() {
-    return this.result;
+  parsePartial(value) {
+    return Object.entries(value).reduce((acc, [key, value2]) => {
+      acc[key] = this.rawShape[key].parse(value2);
+      return acc;
+    }, {});
   }
-}
-
-class ArcManyItemsQuery extends ArcCollectionQuery {
-  filterFn;
-  sortFn;
-  constructor(collection, filterFn, sortFn) {
-    super(collection);
-    this.filterFn = filterFn;
-    this.sortFn = sortFn;
+  deserializePartial(value) {
+    return Object.entries(value).reduce((acc, [key, value2]) => {
+      acc[key] = this.rawShape[key].deserialize(value2);
+      return acc;
+    }, {});
   }
-  onChange(change) {
-    const lastResult = this.lastResult;
-    const lastResultAsArray = lastResult?.toArray() || [];
-    const index = lastResultAsArray.findIndex((e) => e._id === (change.type === "delete" ? change.id : change.id));
-    const isInLastResult = index !== -1;
-    const shouldBeInTheResult = change.type !== "delete" && this.checkItem(change.item);
-    if (isInLastResult && shouldBeInTheResult)
-      return this.createResult(lastResultAsArray.toSpliced(index, 1, change.item));
-    else if (isInLastResult && (change.type === "delete" || !shouldBeInTheResult))
-      return this.createResult(lastResultAsArray.toSpliced(index, 1));
-    else if (!isInLastResult && shouldBeInTheResult)
-      return this.createResult(lastResultAsArray.concat(change.item));
-    return false;
+  serializePartial(value) {
+    return Object.entries(value).reduce((acc, [key, value2]) => {
+      acc[key] = this.rawShape[key].serialize(value2);
+      return acc;
+    }, {});
   }
-  createResult(result) {
-    if (this.sortFn)
-      return new QueryCollectionResult(result.sort(this.sortFn));
-    return new QueryCollectionResult(result);
+  pick(...keys) {
+    return new ArcObject(Object.fromEntries(keys.map((key) => [key, this.rawShape[key]])));
   }
-  createFiltredResult(result) {
-    if (this.filterFn)
-      return this.createResult(result.filter(this.filterFn));
-    return this.createResult(result);
+  omit(...keys) {
+    return new ArcObject(Object.fromEntries(Object.entries(this.rawShape).filter(([key]) => !keys.includes(key))));
   }
-  checkItem(item) {
-    if (this.filterFn)
-      return this.filterFn(item);
-    return true;
+  entries() {
+    return Object.entries(this.rawShape);
   }
 }
-
-// collection/queries/all-items.ts
-class ArcAllItemsQuery extends ArcManyItemsQuery {
-  async fetch(store) {
-    const results = await store.findAll(this.bindedChangeHandler);
-    return this.createFiltredResult(results);
-  }
+function object(element) {
+  return new ArcObject(element);
 }
 
-// context/query-builders.ts
-class ArcQueryBuilder {
-}
+// elements/array.ts
+var arrayValidator = typeValidatorBuilder("array", Array.isArray);
 
-// collection/query-builders/abstract-many-items.ts
-function sortComparatorBuilder(comparator) {
-  if (typeof comparator === "function") {
-    return comparator;
-  } else if (Array.isArray(comparator)) {
-    return (a, b) => {
-      for (const [key, order] of comparator) {
-        if (a[key] < b[key])
-          return order === "ASC" ? -1 : 1;
-        if (a[key] > b[key])
-          return order === "ASC" ? 1 : -1;
+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;
+        }
       }
-      return 0;
-    };
+    ]);
+    this.parent = parent;
   }
-  throw new Error("Invalid comparator type");
-}
-
-class ArcManyItemsQueryBuilder extends ArcQueryBuilder {
-  filterFn;
-  sortFn;
-  filter(callback) {
-    this.filterFn = callback;
-    return this;
+  minLength(min) {
+    return this.validation("minLength", (value) => {
+      if (value.length < min)
+        return {
+          currentLength: value.length,
+          minLength: min
+        };
+    });
   }
-  sort(comparator) {
-    this.sortFn = sortComparatorBuilder(comparator);
-    return this;
+  maxLength(max) {
+    return this.validation("maxLength", (value) => {
+      if (value.length > max)
+        return {
+          currentLength: value.length,
+          maxLength: max
+        };
+    });
   }
-}
-
-// collection/query-builders/all-items.ts
-class ArcAllItemsQueryBuilder extends ArcManyItemsQueryBuilder {
-  collection;
-  constructor(collection) {
-    super();
-    this.collection = collection;
-    if (collection.options.sort)
-      this.sortFn = collection.options.sort;
+  length(number) {
+    return this.validation("length", (value) => {
+      if (value.length !== number) {
+        return {
+          currentLength: value.length,
+          length: number
+        };
+      }
+    });
   }
-  toQuery() {
-    return new ArcAllItemsQuery(this.collection, this.filterFn, this.sortFn);
+  nonEmpty() {
+    return this.validation("nonEmpty", (value) => {
+      if (value.length === 0)
+        return { msg: "array is empty" };
+    });
   }
-}
-
-// db/index-query.ts
-function indexQueryPredicate(item, query) {
-  if (!("$gt" in query) && !("$gte" in query) && !("$lt" in query) && !("$lte" in query)) {
-    return Object.entries(query).every(([key, value]) => item[key] === value);
-  }
-  if (query.$gt) {
-    const isGreaterThan = Object.entries(query.$gt).every(([key, value]) => item[key] > value);
-    if (!isGreaterThan)
-      return false;
+  parse(value) {
+    return value.map((v) => this.parent.parse(v));
   }
-  if (query.$gte) {
-    const isGreaterThanOrEqual = Object.entries(query.$gte).every(([key, value]) => item[key] >= value);
-    if (!isGreaterThanOrEqual)
-      return false;
+  serialize(value) {
+    return value.map((v) => this.parent.serialize(v));
   }
-  if (query.$lt) {
-    const isLessThan = Object.entries(query.$lt).every(([key, value]) => item[key] < value);
-    if (!isLessThan)
-      return false;
+  deserialize(value) {
+    if (!Array.isArray(value))
+      return [];
+    return value.map((v) => this.parent.deserialize(v));
   }
-  if (query.$lte) {
-    const isLessThanOrEqual = Object.entries(query.$lte).every(([key, value]) => item[key] <= value);
-    if (!isLessThanOrEqual)
-      return false;
+  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);
   }
-  return true;
-}
-
-// collection/queries/indexed.ts
-class ArcIndexedItemsQuery extends ArcManyItemsQuery {
-  index;
-  data;
-  filterFn;
-  sortFn;
-  constructor(collection, index, data, filterFn, sortFn) {
-    super(collection, filterFn, sortFn);
-    this.index = index;
-    this.data = data;
-    this.filterFn = filterFn;
-    this.sortFn = sortFn;
+  validation(name, validator) {
+    const instance = this.pipeValidation(name, validator);
+    return instance;
   }
-  checkItem(item) {
-    if (!super.checkItem(item))
-      return false;
-    return indexQueryPredicate(item, this.data);
+}
+function array(element) {
+  return new ArcArray(element);
+}
+// elements/boolean.ts
+class ArcBoolean extends ArcPrimitive {
+}
+function boolean() {
+  return new ArcBoolean;
+}
+// elements/date.ts
+var dateValidator = typeValidatorBuilder("Date", (value) => value instanceof Date);
+
+class ArcDate extends ArcAbstract {
+  constructor() {
+    super([dateValidator]);
   }
-  async fetch(store) {
-    const results = await store.findByIndex(this.index, this.data, this.bindedChangeHandler);
-    return this.createFiltredResult(results);
+  parse(value) {
+    return new Date(value);
+  }
+  serialize(value) {
+    return value.getTime();
+  }
+  deserialize(value) {
+    return new Date(value);
+  }
+  after(after) {
+    return this.validation("after", (value) => {
+      if (value <= after)
+        return { current: value, after };
+    });
+  }
+  before(before) {
+    return this.validation("before", (value) => {
+      if (value >= before)
+        return { current: value, before };
+    });
+  }
+  validation(name, validator) {
+    const instance = this.pipeValidation(name, validator);
+    return instance;
   }
 }
+function date() {
+  return new ArcDate;
+}
+// elements/number.ts
+var numberValidator = typeValidatorBuilder("number");
 
-// collection/query-builders/indexed.ts
-class ArcIndexedItemsQueryBuilder extends ArcManyItemsQueryBuilder {
-  collection;
-  index;
-  data;
-  constructor(collection, index, data) {
+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;
+  }
+}
+function number() {
+  return new ArcNumber;
+}
+// elements/record.ts
+class ArcRecord extends ArcAbstract {
+  key;
+  element;
+  constructor(key, element) {
+    super([
+      {
+        name: "schema",
+        validator: (value) => {
+          const errors = Object.entries(value).reduce((acc, [key2, element2]) => {
+            const error = this.element.validate(element2);
+            if (error) {
+              acc[key2] = error;
+            }
+            return acc;
+          }, {});
+          if (Object.entries(errors).some(([key2, element2]) => !!(key2 || element2))) {
+            return errors;
+          }
+          return false;
+        }
+      }
+    ]);
+    this.key = key;
+    this.element = element;
+  }
+  parse(value) {
+    if (!value)
+      return {};
+    return Object.entries(value).reduce((acc, [key, recordValue]) => {
+      acc[key] = this.element.parse(recordValue);
+      return acc;
+    }, {});
+  }
+  serialize(value) {
+    if (!value)
+      return {};
+    return Object.entries(value).reduce((acc, [key, recordValue]) => {
+      acc[key] = this.element.serialize(recordValue);
+      return acc;
+    }, {});
+  }
+  deserialize(value) {
+    if (!value)
+      return {};
+    return Object.entries(value).reduce((acc, [key, recordValue]) => {
+      acc[key] = this.element.deserialize(recordValue);
+      return acc;
+    }, {});
+  }
+}
+function record(key, element) {
+  return new ArcRecord(key, element);
+}
+// elements/string-enum.ts
+class ArcStringEnum extends ArcAbstract {
+  values;
+  constructor(values) {
+    super([
+      {
+        name: "schema",
+        validator: (value) => {
+          if (this.values.includes(value))
+            return false;
+          return { expect: values, current: value };
+        }
+      }
+    ]);
+    this.values = values;
+  }
+  parse(value) {
+    return value;
+  }
+  serialize(value) {
+    return value;
+  }
+  deserialize(value) {
+    return value;
+  }
+  getEnumerators() {
+    return this.values;
+  }
+}
+function stringEnum(...values) {
+  return new ArcStringEnum(values);
+}
+// utils/arcObjectToStoreSchema.ts
+function getSQLiteType(element) {
+  if (element instanceof ArcDate) {
+    return "TEXT";
+  }
+  if (element instanceof ArcArray || element instanceof ArcObject) {
+    return "TEXT";
+  }
+  if (element instanceof ArcBoolean) {
+    return "INTEGER";
+  }
+  if (element instanceof ArcNumber) {
+    return "NUMBER";
+  }
+  return "TEXT";
+}
+function arcObjectToStoreSchema(tableName, schema) {
+  const columns = schema.entries().map(([name, element]) => ({
+    name,
+    type: getSQLiteType(element),
+    isOptional: element instanceof ArcOptional
+  }));
+  columns.unshift({
+    name: "_id",
+    type: "TEXT",
+    isOptional: false
+  }, {
+    name: "deleted",
+    type: "INTEGER",
+    isOptional: false,
+    default: 0
+  }, {
+    name: "lastUpdate",
+    type: "TEXT",
+    isOptional: false
+  });
+  return {
+    tables: [
+      {
+        name: tableName,
+        columns,
+        primaryKey: "_id"
+      }
+    ]
+  };
+}
+
+// context/query.ts
+class ArcQuery {
+  lastResult;
+  listeners = new Set;
+  subscribe(listener) {
+    this.listeners.add(listener);
+  }
+  unsubscribe(listener) {
+    this.listeners.delete(listener);
+  }
+  nextResult(result) {
+    this.lastResult = result;
+    this.listeners.forEach((listener) => listener(result));
+  }
+}
+
+// context/serializable-query.ts
+class ArcSerializableQuery extends ArcQuery {
+  params;
+  static key;
+  constructor(params) {
     super();
+    this.params = params;
+  }
+  serialize() {
+    return {
+      key: this.constructor.key,
+      params: this.params
+    };
+  }
+}
+
+// collection/queries/abstract-collection-query.ts
+class ArcCollectionQuery extends ArcSerializableQuery {
+  collection;
+  bindedChangeHandler = this.changeHandler.bind(this);
+  store;
+  constructor(collection, params) {
+    super(params);
     this.collection = collection;
-    this.index = index;
-    this.data = data;
-    if (collection.options.sort)
-      this.sortFn = collection.options.sort;
   }
-  toQuery() {
-    return new ArcIndexedItemsQuery(this.collection, this.index, this.data, this.filterFn, this.sortFn);
+  async run(dataStorage) {
+    const store = dataStorage.getStore(this.collection.name);
+    this.store = store;
+    const result = await this.fetch(store);
+    this.lastResult = result;
+    return result;
+  }
+  changeHandler(changes) {
+    let resultChanged = false;
+    for (const change of changes) {
+      const response = this.onChange(change);
+      if (response !== false) {
+        this.lastResult = response;
+        resultChanged = true;
+      }
+    }
+    if (resultChanged)
+      this.nextResult(this.lastResult);
+  }
+}
+
+// collection/queries/find.ts
+class QueryCollectionResult {
+  result;
+  constructor(result) {
+    this.result = result;
+  }
+  get(id3) {
+    return id3 ? this.result.find((r) => r._id === id3) : undefined;
+  }
+  map(callbackfn) {
+    return this.result.map(callbackfn);
+  }
+  toArray() {
+    return this.result;
   }
 }
 
-// collection/queries/one-item.ts
-class ArcOneItemQuery extends ArcCollectionQuery {
-  id2;
-  constructor(collection, id2) {
-    super(collection);
-    this.id = id2;
+class ArcFindQuery extends ArcCollectionQuery {
+  params;
+  constructor(collection, params) {
+    super(collection, params);
+    this.params = params;
+  }
+  async fetch(store) {
+    const results = await store.find(this.params, this.bindedChangeHandler);
+    return this.createResult(results);
+  }
+  checkItem(item) {
+    if (!this.params.where)
+      return true;
+    return Object.entries(this.params.where).every(([key, condition]) => {
+      const value = item[key];
+      if (typeof condition !== "object" || condition === null) {
+        return value === condition;
+      }
+      return Object.entries(condition).every(([operator, operatorValue]) => {
+        switch (operator) {
+          case "$eq":
+            return value === operatorValue;
+          case "$ne":
+            return value !== operatorValue;
+          case "$gt":
+            return typeof value === "number" && typeof operatorValue === "number" && value > operatorValue;
+          case "$gte":
+            return typeof value === "number" && typeof operatorValue === "number" && value >= operatorValue;
+          case "$lt":
+            return typeof value === "number" && typeof operatorValue === "number" && value < operatorValue;
+          case "$lte":
+            return typeof value === "number" && typeof operatorValue === "number" && value <= operatorValue;
+          case "$in":
+            return Array.isArray(operatorValue) && operatorValue.includes(value);
+          case "$nin":
+            return Array.isArray(operatorValue) && !operatorValue.includes(value);
+          case "$exists":
+            return typeof operatorValue === "boolean" ? operatorValue ? value !== undefined : value === undefined : true;
+          default:
+            return true;
+        }
+      });
+    });
   }
   onChange(change) {
-    if (change.id !== this.id)
-      return false;
-    if (change.type === "delete")
-      return null;
-    if (change.type === "set")
-      return change.item;
+    const lastResult = this.lastResult;
+    const lastResultAsArray = lastResult?.toArray() || [];
+    const index = lastResultAsArray.findIndex((e) => e._id === (change.type === "delete" ? change.id : change.id));
+    const isInLastResult = index !== -1;
+    const shouldBeInTheResult = change.type !== "delete" && this.checkItem(change.item);
+    if (isInLastResult && shouldBeInTheResult)
+      return this.createResult(lastResultAsArray.toSpliced(index, 1, change.item));
+    else if (isInLastResult && (change.type === "delete" || !shouldBeInTheResult))
+      return this.createResult(lastResultAsArray.toSpliced(index, 1));
+    else if (!isInLastResult && shouldBeInTheResult)
+      return this.createResult(lastResultAsArray.concat(change.item));
     return false;
   }
-  async fetch(store) {
-    const result = await store.findById(this.id, this.bindedChangeHandler);
-    return result;
+  createResult(result) {
+    return new QueryCollectionResult(result);
   }
 }
 
-// collection/query-builders/one-item.ts
-class ArcOneItemQueryBuilder extends ArcQueryBuilder {
+// collection/query-builders/find.ts
+class ArcFindQueryBuilder {
   collection;
-  id2;
-  constructor(collection, id2) {
-    super();
+  queryContext;
+  options;
+  constructor(collection, queryContext, options) {
     this.collection = collection;
-    this.id = id2;
+    this.queryContext = queryContext;
+    this.options = options;
   }
   toQuery() {
-    return new ArcOneItemQuery(this.collection, this.id);
+    return this.queryContext.cacheQuery(ArcFindQuery, [
+      this.collection,
+      this.options
+    ]);
+  }
+  run() {
+    return this.queryContext.runQuery(this.toQuery());
   }
 }
 
 // collection/collection.ts
-class ArcCollection extends ArcContextElement {
+class ArcCollection extends ArcContextElementWithStore {
   name;
-  id2;
+  id;
   schema;
   options;
-  constructor(name, id2, schema, options) {
+  constructor(name, id3, schema, options) {
     super();
     this.name = name;
-    this.id = id2;
+    this.id = id3;
     this.schema = schema;
     this.options = options;
   }
+  storeSchema() {
+    return arcObjectToStoreSchema(this.name, this.schema);
+  }
   serialize(data) {
     return {
       _id: this.id.serialize(data._id),
@@ -485,22 +891,22 @@ class ArcCollection extends ArcContextElement {
       ...this.schema.deserialize(data)
     };
   }
-  queryBuilder() {
+  queryBuilder = (context) => {
     return {
-      all: () => new ArcAllItemsQueryBuilder(this),
-      one: (id2) => new ArcOneItemQueryBuilder(this, id2)
+      find: (options) => new ArcFindQueryBuilder(this, context, options || {})
     };
-  }
-  commandContext(dataStorage, publishEvent) {
+  };
+  commandContext = (dataStorage, publishEvent) => {
     const store = dataStorage.getStore(this.name);
     return {
       add: async (data) => {
         if (this.id instanceof ArcCustomId)
           throw new Error("Collection with custom id not support 'add' method");
-        const id2 = this.id.generate();
+        const id3 = this.id.generate();
         const parsed = this.schema.parse(data);
         const body = {
-          _id: id2,
+          _id: id3,
+          lastUpdate: new Date().toISOString(),
           ...parsed
         };
         await store.set(body);
@@ -508,16 +914,16 @@ class ArcCollection extends ArcContextElement {
           type: "set",
           to: body
         });
-        return { id: id2 };
+        return { id: id3 };
       },
-      remove: async (id2) => {
-        await store.remove(id2);
+      remove: async (id3) => {
+        await store.remove(id3);
         return { success: true };
       },
-      set: async (id2, data) => {
+      set: async (id3, data) => {
         const parsed = this.schema.parse(data);
         const body = {
-          _id: id2,
+          _id: id3,
           ...parsed
         };
         await store.set(body);
@@ -527,15 +933,19 @@ class ArcCollection extends ArcContextElement {
         });
         return { success: true };
       },
-      all: async () => {
-        return store.findAll();
+      find: async (options) => {
+        return store.find(options);
       },
-      one: async (id2) => {
-        return store.findById(id2);
+      findOne: async (where) => {
+        const result = await store.find({
+          where,
+          limit: 1
+        });
+        return result[0];
       },
-      modify: async (id2, data) => {
+      modify: async (id3, data) => {
         const deserialized = this.schema.serializePartial(data);
-        const { from, to } = await store.modify(id2, deserialized);
+        const { from, to } = await store.modify(id3, deserialized);
         await publishEvent({
           type: "modify",
           changes: deserialized,
@@ -543,8 +953,8 @@ class ArcCollection extends ArcContextElement {
           to
         });
       },
-      edit: async (id2, editCallback) => {
-        const { from, to } = await store.mutate(id2, editCallback);
+      edit: async (id3, editCallback) => {
+        const { from, to } = await store.mutate(id3, editCallback);
         await publishEvent({
           type: "mutate",
           from,
@@ -552,118 +962,385 @@ class ArcCollection extends ArcContextElement {
         });
       }
     };
-  }
-  indexBy(indexes) {
-    return new ArcIndexedCollection(this.name, this.id, this.schema, this.options, indexes);
-  }
+  };
 }
-
-class ArcIndexedCollection extends ArcCollection {
-  indexes;
-  constructor(name, id2, schema, options, indexes) {
-    super(name, id2, schema, options);
-    this.indexes = indexes;
-  }
-  commandContext(dataStorage, publishEvent) {
-    const superContext = super.commandContext(dataStorage, publishEvent);
-    return new Proxy(superContext, {
-      get: (target, name) => {
-        if (name in target) {
-          return target[name];
-        }
-        if (!(name in this.indexes)) {
-          throw new Error(`Index "${name}" not found in collection "${this.name}"`);
-        }
-        return (data) => dataStorage.getStore(this.name).findByIndex(name, data);
-      }
-    });
+function collection(name, id3, schema, options = {}) {
+  return new ArcCollection(name, id3, schema, options);
+}
+// command/command.ts
+class ArcCommand extends ArcContextElement {
+  name;
+  _description;
+  _params;
+  _result;
+  _elements;
+  _handler;
+  constructor(name) {
+    super();
+    this.name = name;
   }
-  queryBuilder() {
-    const superQueryBuilder = super.queryBuilder();
-    return new Proxy({}, {
-      get: (target, name) => {
-        if (name in superQueryBuilder)
-          return superQueryBuilder[name];
-        if (!(name in this.indexes)) {
-          throw new Error(`Index "${name}" not found in collection "${this.name}"`);
-        }
-        return (data) => new ArcIndexedItemsQueryBuilder(this, name, data);
-      }
-    });
+  use(elements) {
+    const clone = this.clone();
+    clone._elements = elements;
+    return clone;
+  }
+  description(description) {
+    const clone = this.clone();
+    clone._description = description;
+    return clone;
+  }
+  withParams(schema) {
+    const clone = this.clone();
+    clone._params = schema instanceof ArcObject ? schema : object(schema);
+    return clone;
+  }
+  withResult(schema) {
+    const clone = this.clone();
+    clone._result = object(schema);
+    return clone;
+  }
+  handle(handler) {
+    const clone = this.clone();
+    clone._handler = handler;
+    return clone;
+  }
+  commandClient = (ctx) => {
+    return Object.assign(async (params) => {
+      if (this._handler)
+        return this._handler?.(ctx, params);
+    }, { params: this._params });
+  };
+  clone() {
+    const clone = new ArcCommand(this.name);
+    clone._description = this._description;
+    clone._params = this._params;
+    clone._result = this._result;
+    clone._handler = this._handler;
+    clone._elements = this._elements;
+    return clone;
   }
 }
-function collection(name, id2, schema, options = {}) {
-  return new ArcCollection(name, id2, schema, options);
+function command(name) {
+  return new ArcCommand(name);
 }
 // context/context.ts
 class ArcContext {
-  version;
   elements;
-  commands;
-  listeners;
-  elementsMap;
-  constructor(version, elements, commands, listeners) {
-    this.version = version;
+  eventListeners;
+  constructor(elements) {
     this.elements = elements;
-    this.commands = commands;
-    this.listeners = listeners;
-    this.elementsMap = Object.fromEntries(elements.map((element) => [element.name, element]));
+    this.eventListeners = new Map;
+    elements.forEach((element) => {
+      if (element.observer) {
+        const handlers = element.observer();
+        Object.entries(handlers).forEach(([alias, handler]) => {
+          const listeners = this.eventListeners.get(alias) || [];
+          listeners.push(handler);
+          this.eventListeners.set(alias, listeners);
+        });
+      }
+    });
+  }
+  pipe(newElements) {
+    return new ArcContext([
+      ...this.elements,
+      ...newElements.filter(Boolean)
+    ]);
   }
-  queryBuilder() {
+  queryBuilder(queryContext) {
     return new Proxy({}, {
       get: (target, name) => {
-        const element = this.elementsMap[name];
+        const element = this.elements.find((element2) => element2.name === name);
         if (!element) {
-          throw new Error(`Collection "${name}" not found`);
+          throw new Error(`Element "${String(name)}" not found`);
+        }
+        if (!element.queryBuilder) {
+          throw new Error(`Element "${String(name)}" does not have a query builder`);
         }
-        return element.queryBuilder();
+        return element.queryBuilder(queryContext);
       }
     });
   }
-  commandContext(client, dataStorage, publishEvent) {
+  commandContext(client, dataStorage) {
     return new Proxy({}, {
       get: (target, name) => {
         if (name === "$client") {
           return client;
         }
-        const element = this.elementsMap[name];
-        return element.commandContext(dataStorage, (event) => publishEvent({
-          element: name,
-          ...event
-        }));
+        const element = this.elements.find((element2) => element2.name === name);
+        if (!element) {
+          throw new Error(`Element "${String(name)}" not found`);
+        }
+        if (!element.commandContext) {
+          throw new Error(`Element "${String(name)}" does not have a command context`);
+        }
+        return element.commandContext(dataStorage, async (event) => {
+          const listeners = this.eventListeners.get(event.type) || [];
+          await Promise.all(listeners.map((listener) => listener(event, dataStorage)));
+        });
       }
     });
   }
-  commandsClient(client, dataStorage, catchErrorCallback) {
+  commandsClient(client, queryContext, dataStorage, catchErrorCallback) {
     return new Proxy({}, {
       get: (_, name) => {
-        if (name in this.commands) {
-          return async (...args) => {
-            const forkedDataStorage = dataStorage.fork();
-            const commandContext = this.commandContext(client, forkedDataStorage, async (data) => {
-              if (!this.listeners)
-                return;
-              await Promise.all(this.listeners?.map((listener) => listener(data, commandContext)));
-            });
-            try {
-              const result = await this.commands[name](commandContext, ...args);
-              await forkedDataStorage.merge();
-              return result;
-            } catch (error) {
-              console.log("error", error);
-              catchErrorCallback(error);
-              return error;
-            }
-          };
+        const element = this.elements.find((element2) => element2.name === name);
+        if (!element) {
+          throw new Error(`Element "${String(name)}" not found`);
+        }
+        if (!element.commandClient) {
+          throw new Error(`Element "${String(name)}" does not have a command client`);
+        }
+        return async (arg) => {
+          const forkedDataStorage = dataStorage.fork();
+          const commandContext = this.commandContext(client, forkedDataStorage);
+          try {
+            const result = await element.commandClient(commandContext)(arg);
+            await forkedDataStorage.merge();
+            return result;
+          } catch (error) {
+            console.log("error", error);
+            catchErrorCallback(error);
+            return error;
+          }
+        };
+      }
+    });
+  }
+}
+async function context(elementsPromise) {
+  const elements = await Promise.all(elementsPromise.map(async (element) => {
+    if (element instanceof Promise) {
+      return (await element).default;
+    }
+    return element;
+  })).then((elements2) => elements2.filter(Boolean));
+  return new ArcContext(elements);
+}
+// context/event.ts
+var eventValidator = typeValidatorBuilder("object");
+var eventStoreSchema = {
+  tables: [
+    {
+      name: "events",
+      primaryKey: "id",
+      columns: [
+        {
+          name: "id",
+          type: "string"
+        },
+        {
+          name: "type",
+          type: "string"
+        },
+        {
+          name: "payload",
+          type: "object"
+        },
+        {
+          name: "createdAt",
+          type: "datetime"
         }
-        console.warn(`Command '${name}' not found in the context.`);
+      ]
+    }
+  ]
+};
+var eventId = id("event");
+
+class ArcEvent extends ArcContextElementWithStore {
+  name;
+  payload;
+  storeSchema = () => eventStoreSchema;
+  constructor(name, payload) {
+    super();
+    this.name = name;
+    this.payload = payload;
+  }
+  commandContext = (dataStorage, publishEvent) => {
+    return {
+      emit: async (payload) => {
+        const event = {
+          id: eventId.generate(),
+          type: this.name,
+          payload,
+          createdAt: new Date().toISOString()
+        };
+        await dataStorage.getStore("events").set(event);
+        await publishEvent(event);
+      }
+    };
+  };
+}
+function event(name, payload) {
+  return new ArcEvent(name, payload ? new ArcObject(payload) : undefined);
+}
+// context/query-builder-context.ts
+class QueryBuilderContext {
+  queryCache;
+  dataStorage;
+  usedQueries = new Set;
+  constructor(queryCache, dataStorage) {
+    this.queryCache = queryCache;
+    this.dataStorage = dataStorage;
+  }
+  cacheQuery(QueryConstructor, args) {
+    return new QueryConstructor(...args);
+  }
+  runQuery(query) {
+    this.usedQueries.add(query);
+    return query.run(this.dataStorage);
+  }
+  getUsedQueries() {
+    const queries = Array.from(this.usedQueries);
+    this.usedQueries.clear();
+    return queries;
+  }
+}
+// context/query-builders.ts
+class ArcQueryBuilder {
+  queryContext;
+  constructor(queryContext) {
+    this.queryContext = queryContext;
+  }
+  run() {
+    const query = this.toQuery();
+    return this.queryContext.runQuery(query);
+  }
+}
+// utils/murmur-hash.ts
+function murmurHash(key, seed = 0) {
+  var remainder, bytes, h1, h1b, c1, c1b, c2, c2b, k1, i;
+  remainder = key.length & 3;
+  bytes = key.length - remainder;
+  h1 = seed;
+  c1 = 3432918353;
+  c2 = 461845907;
+  i = 0;
+  while (i < bytes) {
+    k1 = key.charCodeAt(i) & 255 | (key.charCodeAt(++i) & 255) << 8 | (key.charCodeAt(++i) & 255) << 16 | (key.charCodeAt(++i) & 255) << 24;
+    ++i;
+    k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;
+    h1 ^= k1;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1b = (h1 & 65535) * 5 + (((h1 >>> 16) * 5 & 65535) << 16) & 4294967295;
+    h1 = (h1b & 65535) + 27492 + (((h1b >>> 16) + 58964 & 65535) << 16);
+  }
+  k1 = 0;
+  switch (remainder) {
+    case 3:
+      k1 ^= (key.charCodeAt(i + 2) & 255) << 16;
+    case 2:
+      k1 ^= (key.charCodeAt(i + 1) & 255) << 8;
+    case 1:
+      k1 ^= key.charCodeAt(i) & 255;
+      k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;
+      k1 = k1 << 15 | k1 >>> 17;
+      k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;
+      h1 ^= k1;
+  }
+  h1 ^= key.length;
+  h1 ^= h1 >>> 16;
+  h1 = (h1 & 65535) * 2246822507 + (((h1 >>> 16) * 2246822507 & 65535) << 16) & 4294967295;
+  h1 ^= h1 >>> 13;
+  h1 = (h1 & 65535) * 3266489909 + (((h1 >>> 16) * 3266489909 & 65535) << 16) & 4294967295;
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
+
+// context/query-cache.ts
+class QueryCache {
+  cache = new Map;
+  getIndexHash(value) {
+    if (typeof value === "number" || typeof value === "string" || typeof value === "function" || value === null || value === undefined) {
+      return value;
+    }
+    return murmurHash(value);
+  }
+  set(index, query) {
+    let current = this.cache;
+    for (let i = 0;i < index.length - 1; i++) {
+      const hashedIndex = this.getIndexHash(index[i]);
+      if (!current.has(hashedIndex)) {
+        current.set(hashedIndex, new Map);
+      }
+      current = current.get(hashedIndex);
+    }
+    const lastHashedIndex = this.getIndexHash(index[index.length - 1]);
+    current.set(lastHashedIndex, query);
+  }
+  get(index) {
+    let current = this.cache;
+    for (let i = 0;i < index.length - 1; i++) {
+      const hashedIndex = this.getIndexHash(index[i]);
+      if (!current.has(hashedIndex)) {
         return;
       }
+      current = current.get(hashedIndex);
+    }
+    const lastHashedIndex = this.getIndexHash(index[index.length - 1]);
+    return current.get(lastHashedIndex);
+  }
+  debug() {
+    return this.cache;
+  }
+}
+// context/reactive-query.ts
+class ReactiveQuery extends ArcQuery {
+  queryContext;
+  queryBuilder;
+  fn;
+  queries = [];
+  constructor(queryContext, queryBuilder, fn) {
+    super();
+    this.queryContext = queryContext;
+    this.queryBuilder = queryBuilder;
+    this.fn = fn;
+  }
+  run() {
+    const promise = new Promise(async (resolve) => {
+      const value = await this.runQuery();
+      resolve(value);
+    });
+    return promise;
+  }
+  onChangeHandler = this.onChange.bind(this);
+  async onChange() {
+    const value = await this.runQuery();
+    await this.nextResult(value);
+  }
+  async runQuery() {
+    const value = await this.fn(this.queryBuilder);
+    const queries = this.queryContext.getUsedQueries();
+    this.queries.forEach((query) => {
+      if (!queries.includes(query)) {
+        query.unsubscribe(this.onChangeHandler);
+      }
+    });
+    queries.forEach((query) => {
+      if (!this.queries.includes(query)) {
+        query.subscribe(this.onChangeHandler);
+      }
     });
+    this.queries = queries;
+    return value;
+  }
+}
+
+class ReactiveQueryBuilder {
+  queryBuilder;
+  fn;
+  constructor(queryBuilder, fn) {
+    this.queryBuilder = queryBuilder;
+    this.fn = fn;
+  }
+  toQuery(context2) {
+    return new ReactiveQuery(context2, this.queryBuilder, this.fn);
   }
 }
-function context(version, elements, commands, listeners) {
-  return new ArcContext(version, elements, commands, listeners);
+function reactive(fn) {
+  return (context2) => new ReactiveQueryBuilder(context2, fn);
 }
 // data-storage/data-storage.abstract.ts
 class DataStorage {
@@ -717,30 +1394,31 @@ class StoreState {
     };
     await this.applyChanges([change]);
   }
-  async remove(id2) {
+  async remove(id3) {
     const change = {
       type: "delete",
-      id: id2
+      id: id3
     };
     await this.applyChanges([change]);
   }
-  async modify(id2, data) {
+  async modify(id3, data) {
     const change = {
       type: "modify",
-      id: id2,
+      id: id3,
       data
     };
     const { from, to } = await this.applyChange(change);
     return { from, to };
   }
-  async mutate(id2, editCallback) {
-    const object = await this.findById(id2);
-    const [draft, finalize] = create(object || {}, { enablePatches: true });
+  async mutate(id3, editCallback) {
+    const result = await this.find({ where: { _id: id3 } });
+    const object3 = result[0];
+    const [draft, finalize] = create(object3 || {}, { enablePatches: true });
     await editCallback(draft);
     const [_, patches] = finalize();
     const change = {
       type: "mutate",
-      id: id2,
+      id: id3,
       patches
     };
     const { from, to } = await this.applyChange(change);
@@ -784,10 +1462,10 @@ class ForkedStoreState extends StoreState {
       };
     }
     if (change.type === "delete") {
-      const from = await this.findById(change.id);
+      const from = await this.find({ where: { _id: change.id } }).then((results) => results[0] || null);
       this.changedItems.set(change.id, null);
       return {
-        from: from || null,
+        from,
         to: null,
         event: {
           type: "delete",
@@ -797,7 +1475,9 @@ class ForkedStoreState extends StoreState {
       };
     }
     if (change.type === "modify") {
-      const existing = await this.findById(change.id);
+      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);
@@ -812,7 +1492,9 @@ class ForkedStoreState extends StoreState {
       };
     }
     if (change.type === "mutate") {
-      const existing = await this.findById(change.id);
+      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);
@@ -829,59 +1511,42 @@ class ForkedStoreState extends StoreState {
     throw new Error("Unknown change type");
   }
   async applyChange(change) {
-    const { event, from, to } = await this.applyChangeAndReturnEvent(change);
-    this.notifyListeners([event]);
+    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 } = await this.applyChangeAndReturnEvent(change);
-      if (event)
-        events.push(event);
+      const { event: event3 } = await this.applyChangeAndReturnEvent(change);
+      if (event3)
+        events.push(event3);
     }
     if (events.length > 0) {
       this.notifyListeners(events);
     }
   }
-  async findById(id2, listener) {
-    if (listener)
-      this.listeners.set(listener, { callback: listener, id: id2 });
-    if (this.changedItems.has(id2))
-      return this.changedItems.get(id2);
-    return await this.master.findById(id2);
-  }
-  async findByIndex(index, data, listener) {
-    if (listener)
+  async find(options, listener) {
+    if (listener) {
       this.listeners.set(listener, { callback: listener });
-    const parentResult = await this.master.findByIndex(index, data);
+    }
+    const parentResults = await this.master.find(options);
     const results = new Map;
-    parentResult.forEach((item) => results.set(item._id, item));
-    for (const [id2, changedItem] of this.changedItems) {
+    parentResults.forEach((item) => results.set(item._id, item));
+    for (const [id3, changedItem] of this.changedItems) {
       if (changedItem === null) {
-        results.delete(id2);
+        results.delete(id3);
         continue;
       }
-      const matches = Object.entries(data).every(([key, value]) => changedItem[key] === value);
+      const matches = !options.where || Object.entries(options.where).every(([key, value]) => changedItem[key] === value);
       if (matches) {
-        results.set(id2, changedItem);
+        results.set(id3, changedItem);
       } else {
-        results.delete(id2);
+        results.delete(id3);
       }
     }
     return Array.from(results.values());
   }
-  async findAll(listener) {
-    if (listener)
-      this.listeners.set(listener, { callback: listener });
-    const parentResult = await this.master.findAll();
-    return parentResult.map((item) => {
-      const id2 = item._id;
-      if (this.changedItems.has(id2))
-        return this.changedItems.get(id2);
-      return item;
-    });
-  }
 }
 
 // data-storage/data-storage-forked.ts
@@ -920,8 +1585,6 @@ class ForkedDataStorage extends DataStorage {
 // data-storage/store-state-master.ts
 import { apply as apply2 } from "mutative";
 class MasterStoreState extends StoreState {
-  items = new Map;
-  isComplete = false;
   constructor(storeName, dataStorage, deserialize) {
     super(storeName, dataStorage, deserialize);
   }
@@ -929,7 +1592,6 @@ class MasterStoreState extends StoreState {
     if (change.type === "set") {
       await transaction.set(this.storeName, change.data);
       const item = this.deserialize ? this.deserialize(change.data) : change.data;
-      this.items.set(change.data._id, item);
       return {
         from: null,
         to: item,
@@ -942,7 +1604,6 @@ class MasterStoreState extends StoreState {
     }
     if (change.type === "delete") {
       await transaction.remove(this.storeName, change.id);
-      this.items.set(change.id, null);
       return {
         from: null,
         to: null,
@@ -954,11 +1615,10 @@ class MasterStoreState extends StoreState {
       };
     }
     if (change.type === "modify") {
-      const existing = await transaction.findById(this.storeName, change.id);
+      const 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;
-      this.items.set(change.id, item);
       return {
         from: null,
         to: item,
@@ -970,11 +1630,10 @@ class MasterStoreState extends StoreState {
       };
     }
     if (change.type === "mutate") {
-      const existing = await transaction.findById(this.storeName, change.id);
-      const updated = apply2(existing, change.patches);
+      const existing = await transaction.find(this.storeName, { where: { _id: change.id } }).then((results) => results[0]);
+      const updated = apply2(existing || {}, change.patches);
       await transaction.set(this.storeName, updated);
       const item = this.deserialize ? this.deserialize(updated) : updated;
-      this.items.set(change.id, item);
       return {
         from: null,
         to: item,
@@ -989,77 +1648,31 @@ class MasterStoreState extends StoreState {
   }
   async applyChange(change) {
     const transaction = await this.dataStorage.getReadWriteTransaction();
-    const { event, from, to } = await this.applyChangeAndReturnEvent(transaction, change);
-    this.notifyListeners([event]);
+    const { event: event3, from, to } = await this.applyChangeAndReturnEvent(transaction, change);
+    await transaction.commit();
+    this.notifyListeners([event3]);
     return { from, to };
   }
   async applyChanges(changes) {
     const transaction = await this.dataStorage.getReadWriteTransaction();
     const events = [];
     for (const change of changes) {
-      const { event } = await this.applyChangeAndReturnEvent(transaction, change);
-      if (event)
-        events.push(event);
+      const { event: event3 } = await this.applyChangeAndReturnEvent(transaction, change);
+      if (event3)
+        events.push(event3);
     }
     await transaction.commit();
     if (events.length > 0) {
       this.notifyListeners(events);
     }
   }
-  async findById(id2, listener) {
-    if (!id2)
-      return;
-    if (listener)
-      this.listeners.set(listener, { callback: listener, id: id2 });
-    if (this.items.has(id2))
-      return this.items.get(id2);
-    const transaction = await this.dataStorage.getReadTransaction();
-    const result = await transaction.findById(this.storeName, id2);
-    const item = result && this.deserialize ? this.deserialize(result) : result;
-    if (!item)
-      return;
-    this.items.set(id2, item);
-    return item;
-  }
-  async findByIndex(index, data, listener) {
-    if (listener)
+  async find(options, listener) {
+    if (listener) {
       this.listeners.set(listener, { callback: listener });
-    if (this.isComplete) {
-      const results2 = Array.from(this.items.values()).filter((item) => {
-        if (!item)
-          return false;
-        return indexQueryPredicate(item, data);
-      });
-      return results2;
     }
     const transaction = await this.dataStorage.getReadTransaction();
-    const dbResults = await transaction.findByIndex(this.storeName, index, data);
-    const results = dbResults.map((item) => {
-      const id2 = item._id;
-      if (this.items.has(id2))
-        return this.items.get(id2);
-      const processedItem = this.deserialize ? this.deserialize(item) : item;
-      return processedItem;
-    });
-    return results;
-  }
-  async findAll(listener) {
-    if (listener)
-      this.listeners.set(listener, { callback: listener });
-    if (this.isComplete)
-      return Array.from(this.items.values()).filter((e) => !!e);
-    const transaction = await this.dataStorage.getReadTransaction();
-    const dbResults = await transaction.findAll(this.storeName);
-    const items = dbResults.map((item) => {
-      const id2 = item._id;
-      if (this.items.has(id2))
-        return this.items.get(id2);
-      const processedItem = this.deserialize ? this.deserialize(item) : item;
-      this.items.set(processedItem._id, processedItem);
-      return processedItem;
-    });
-    this.isComplete = true;
-    return items;
+    const results = await transaction.find(this.storeName, options);
+    return results.map((item) => this.deserialize ? this.deserialize(item) : item);
   }
 }
 
@@ -1083,250 +1696,376 @@ class MasterDataStorage extends DataStorage {
   }
   getStore(storeName) {
     if (!this.stores.has(storeName)) {
-      const contextElement = this.arcContext.elementsMap[storeName];
+      const contextElement = this.arcContext.elements.find((element) => element.name === storeName);
       if (!contextElement)
         console.log(`Can't find ${storeName} as context element`);
-      this.stores.set(storeName, new MasterStoreState(storeName, this, contextElement && contextElement.deserialize ? (a) => contextElement.deserialize(a) : undefined));
+      this.stores.set(storeName, new MasterStoreState(storeName, this, contextElement && "deserialize" in contextElement && typeof contextElement.deserialize === "function" ? (a) => contextElement.deserialize(a) : undefined));
     }
     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) {
-    await Promise.all([
-      this.applyChanges(changes),
-      this.rtcAdapter.commitChanges(changes)
-    ]);
-  }
-  fork() {
-    return new ForkedDataStorage(this);
-  }
-  async sync(progressCallback) {
-    await this.rtcAdapter.sync(progressCallback);
-  }
-}
-// elements/object.ts
-class ArcObject extends ArcAbstract {
-  rawShape;
-  constructor(rawShape) {
-    super();
-    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;
-    }, {});
+  applySerializedChanges(changes) {
+    return Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applySerializedChanges(changes2)));
   }
-  deserializePartial(value) {
-    return Object.entries(value).reduce((acc, [key, value2]) => {
-      acc[key] = this.rawShape[key].deserialize(value2);
-      return acc;
-    }, {});
+  async commitChanges(changes) {
+    await Promise.all([
+      this.applyChanges(changes),
+      this.rtcAdapter.commitChanges(changes)
+    ]);
   }
-  serializePartial(value) {
-    return Object.entries(value).reduce((acc, [key, value2]) => {
-      acc[key] = this.rawShape[key].serialize(value2);
-      return acc;
-    }, {});
+  fork() {
+    return new ForkedDataStorage(this);
   }
-  pick(...keys) {
-    return new ArcObject(Object.fromEntries(keys.map((key) => [key, this.rawShape[key]])));
+  async sync(progressCallback) {
+    await this.rtcAdapter.sync(progressCallback);
   }
-  validate(value) {
-    console.log(this.rawShape);
-    return Object.entries(this.rawShape).reduce((acc, [key, element]) => {
-      if (!element.validate) {
-        return acc;
+}
+// db/sqliteAdapter.ts
+class SQLiteReadTransaction {
+  db;
+  tables;
+  constructor(db, tables) {
+    this.db = db;
+    this.tables = tables;
+  }
+  getId(store, id3) {
+    return id3;
+  }
+  buildWhereClause(where) {
+    if (!where) {
+      return { sql: "deleted != 1", params: [] };
+    }
+    const conditions = ["deleted != 1"];
+    const 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);
       }
-      console.log(element);
-      acc[key] = element.validate(value[key]);
-      return acc;
-    }, {});
+    });
+    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);
+    const orderByClause = this.buildOrderByClause(orderBy);
+    const query2 = `
+      SELECT * 
+      FROM ${store} 
+      WHERE ${whereClause.sql}
+      ${orderByClause}
+      ${limit ? `LIMIT ${limit}` : ""}
+      ${offset ? `OFFSET ${offset}` : ""}
+    `;
+    return await this.db.exec(query2, whereClause.params);
   }
-}
-function object(element) {
-  return new ArcObject(element);
 }
 
-// elements/array.ts
-class ArcArray extends ArcAbstract {
-  parent;
-  constructor(parent) {
-    super();
-    this.parent = parent;
-  }
-  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));
+class SQLiteReadWriteTransaction extends SQLiteReadTransaction {
+  async remove(store, id3) {
+    const table = this.tables.get(store);
+    if (!table) {
+      throw new Error(`Store ${store} not found`);
+    }
+    const query2 = `UPDATE ${store} SET deleted = 1, lastUpdate = ? WHERE ${table.primaryKey} = ?`;
+    await this.db.exec(query2, [new Date().toISOString(), id3]);
   }
-  deserializePath(path, value) {
-    if (path.length === 0) {
-      return this.deserialize(value);
+  async set(store, item) {
+    const schema = this.tables.get(store);
+    if (!schema) {
+      throw new Error(`Store ${store} not found`);
     }
-    if (this.parent instanceof ArcObject || this.parent instanceof ArcArray) {
-      return this.parent.deserializePath(path, value);
+    const now = new Date().toISOString();
+    const columnNames = schema.columns.map((col) => col.name);
+    const values = schema.columns.map((column) => {
+      let value = item[column.name];
+      if (value === undefined && column.default !== undefined) {
+        value = column.default;
+      }
+      return this.serializeValue(value);
+    });
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const sql = `
+        INSERT OR REPLACE INTO ${schema.name}
+        (${columnNames.join(", ")})
+        VALUES (${placeholders})
+      `;
+    await this.db.exec(sql, values);
+  }
+  async commit() {
+    return Promise.resolve();
+  }
+  serializeValue(value) {
+    if (value === null || value === undefined)
+      return null;
+    if (value instanceof Date) {
+      return value.toISOString();
     }
-    return this.parent.deserialize(value);
+    if (Array.isArray(value) || typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return value;
   }
 }
-function array(element) {
-  return new ArcArray(element);
-}
-// elements/boolean.ts
-class ArcBoolean extends ArcPrimitive {
-}
-function boolean() {
-  return new ArcBoolean;
-}
-// elements/date.ts
-class ArcDate extends ArcAbstract {
-  constructor() {
-    super();
-  }
-  parse(value) {
-    return new Date(value);
-  }
-  serialize(value) {
-    return value.getTime();
+
+class SQLiteAdapter {
+  db;
+  context;
+  tables = new Map;
+  constructor(db, context3) {
+    this.db = db;
+    this.context = context3;
+    this.context.elements.forEach((element) => {
+      if ("storeSchema" in element && typeof element.storeSchema === "function") {
+        element.storeSchema().tables.forEach((table) => {
+          this.tables.set(table.name, table);
+        });
+      }
+    });
   }
-  deserialize(value) {
-    return new Date(value);
+  async initialize() {
+    const stores = new Set;
+    for (const element of this.context.elements) {
+      if ("storeSchema" in element && typeof element.storeSchema === "function") {
+        const schema = element.storeSchema();
+        stores.add(schema);
+      }
+    }
+    for (const schema of stores) {
+      for (const table of schema.tables) {
+        await this.createTableIfNotExists(table);
+      }
+    }
   }
-}
-function date() {
-  return new ArcDate;
-}
-// elements/number.ts
-class ArcNumber extends ArcPrimitive {
-  min(min) {
-    return this.validation("min", (value) => {
-      if (value < min)
-        return { current: value, min };
+  async createTableIfNotExists(table) {
+    const columns = table.columns.map((column) => {
+      const constraints = [];
+      if (!column.isOptional) {
+        constraints.push("NOT NULL");
+      }
+      if (column.default !== undefined) {
+        constraints.push(`DEFAULT ${JSON.stringify(column.default)}`);
+      }
+      if (column.name === table.primaryKey) {
+        constraints.push("PRIMARY KEY");
+      }
+      return `"${column.name}" ${column.type} ${constraints.join(" ")}`.trim();
     });
+    const createTableSQL = `
+      CREATE TABLE IF NOT EXISTS ${table.name} (
+        ${columns.join(`,
+        `)}
+      )
+    `;
+    await this.db.exec(createTableSQL);
   }
-  max(max) {
-    return this.validation("max", (value) => {
-      if (value > max)
-        return { current: value, max };
-    });
+  readWriteTransaction(stores) {
+    return new SQLiteReadWriteTransaction(this.db, this.tables);
   }
-  validation(name, validator) {
-    const instance = this.pipeValidation(name, validator);
-    return instance;
+  readTransaction(stores) {
+    return new SQLiteReadTransaction(this.db, this.tables);
   }
 }
-function number() {
-  return new ArcNumber;
+var createSQLiteAdapterFactory = (db) => {
+  return async (context3) => {
+    const adapter = new SQLiteAdapter(db, context3);
+    await adapter.initialize();
+    return adapter;
+  };
+};
+// model/model.ts
+class ModelBase {
 }
-// elements/record.ts
-class ArcRecord extends ArcAbstract {
-  key;
-  element;
-  constructor(key, element) {
+
+class Model extends ModelBase {
+  context;
+  dataStorage;
+  client;
+  catchErrorCallback;
+  queryCache = new QueryCache;
+  constructor(context3, dataStorage, client, catchErrorCallback) {
     super();
-    this.key = key;
-    this.element = element;
+    this.context = context3;
+    this.dataStorage = dataStorage;
+    this.client = client;
+    this.catchErrorCallback = catchErrorCallback;
+  }
+  async query(queryBuilderFn) {
+    const queryContext = new QueryBuilderContext(this.queryCache, this.dataStorage);
+    const queryBuilder = this.context.queryBuilder(queryContext);
+    const query2 = queryBuilderFn(queryBuilder).toQuery(queryContext);
+    return query2.run(this.dataStorage);
+  }
+  subscribe(queryBuilderFn, callback) {
+    const queryContext = new QueryBuilderContext(this.queryCache, this.dataStorage);
+    const queryBuilder = this.context.queryBuilder(queryContext);
+    const query2 = queryBuilderFn(queryBuilder).toQuery(queryContext);
+    query2.subscribe(callback);
+    const runPromise = query2.run(this.dataStorage);
+    runPromise.then((result) => {
+      callback(result);
+    });
+    return {
+      unsubscribe: () => {
+        query2.unsubscribe(callback);
+      },
+      result: runPromise
+    };
   }
-  parse(value) {
-    if (!value)
-      return {};
-    return Object.entries(value).reduce((acc, [key, recordValue]) => {
-      acc[key] = this.element.parse(recordValue);
-      return acc;
-    }, {});
+  commands() {
+    const queryContext = new QueryBuilderContext(this.queryCache, this.dataStorage);
+    return this.context.commandsClient(this.client, queryContext, this.dataStorage, this.catchErrorCallback);
   }
-  serialize(value) {
-    if (!value)
-      return {};
-    return Object.entries(value).reduce((acc, [key, recordValue]) => {
-      acc[key] = this.element.serialize(recordValue);
-      return acc;
-    }, {});
+  fork() {
+    return new ForkedModel(this.context, this.dataStorage.fork(), this.client, this.catchErrorCallback);
   }
-  deserialize(value) {
-    if (!value)
-      return {};
-    return Object.entries(value).reduce((acc, [key, recordValue]) => {
-      acc[key] = this.element.deserialize(recordValue);
-      return acc;
-    }, {});
+  get $debug() {
+    return {};
   }
 }
-function record(key, element) {
-  return new ArcRecord(key, element);
+
+class ForkedModel extends Model {
+  constructor(context3, dataStorage, client, catchErrorCallback) {
+    super(context3, dataStorage, client, catchErrorCallback);
+  }
+  merge() {}
 }
-// elements/string-enum.ts
-class ArcStringEnum extends ArcAbstract {
-  values;
-  constructor(values) {
+
+class RemoteModelClient extends ModelBase {
+  context;
+  apiBaseUrl;
+  client;
+  catchErrorCallback;
+  constructor(context3, apiBaseUrl, client, catchErrorCallback) {
     super();
-    this.values = values;
-  }
-  parse(value) {
-    return value;
-  }
-  serialize(value) {
-    return value;
+    this.context = context3;
+    this.apiBaseUrl = apiBaseUrl;
+    this.client = client;
+    this.catchErrorCallback = catchErrorCallback;
+  }
+  async query(queryBuilderFn) {
+    const queryTracking = {
+      element: null,
+      queryType: null,
+      params: null
+    };
+    const queryContext = new QueryBuilderContext(new QueryCache, null);
+    const originalQueryBuilder = this.context.queryBuilder(queryContext);
+    const queryBuilderProxy = new Proxy(originalQueryBuilder, {
+      get: (target, prop) => {
+        queryTracking.element = prop;
+        const originalElement = Reflect.get(target, prop);
+        return new Proxy(originalElement, {
+          get: (elementTarget, methodProp) => {
+            queryTracking.queryType = methodProp;
+            const originalMethod = Reflect.get(elementTarget, methodProp);
+            return (...args) => {
+              queryTracking.params = args;
+              return originalMethod(...args);
+            };
+          }
+        });
+      }
+    });
+    const query2 = queryBuilderFn(queryBuilderProxy).toQuery(queryContext);
+    const response = await fetch(`${this.apiBaseUrl}/query`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        query: {
+          element: queryTracking.element,
+          queryType: queryTracking.queryType,
+          params: queryTracking.params
+        }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Query failed: ${response.statusText}`);
+    }
+    const { result } = await response.json();
+    return result;
   }
-  deserialize(value) {
-    return value;
+  subscribe(queryBuilderFn, callback) {
+    const result = this.query(queryBuilderFn);
+    result.then((initialResult) => {
+      callback(initialResult);
+    }).catch(this.catchErrorCallback);
+    return {
+      unsubscribe: () => {},
+      result
+    };
   }
-  getEnumerators() {
-    return this.values;
+  commands() {
+    const commandsProxy = new Proxy({}, {
+      get: (target, prop) => {
+        const element = this.context.elements.find((e) => e.name === prop);
+        if (!element) {
+          throw new Error(`Command ${String(prop)} not found`);
+        }
+        return Object.assign(async (argument) => {
+          const response = await fetch(`${this.apiBaseUrl}/command/${String(prop)}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(argument)
+          });
+          if (!response.ok) {
+            throw new Error(`Command ${String(prop)} failed: ${response.statusText}`);
+          }
+          return response.json();
+        }, { params: element._params });
+      }
+    });
+    return commandsProxy;
   }
 }
-function stringEnum(...values) {
-  return new ArcStringEnum(values);
-}
 // rtc/client.ts
 class RTCClient {
   storage;
@@ -1350,41 +2089,9 @@ class RTCClient {
   }
   async performSync() {
     this.connectWebSocket();
-    const arcState = await this.storage.getStore("state").findById("$arc", (a) => a);
-    const response = await fetch(`/ws/sync?lastSync=${arcState?.lastSyncDate || ""}`, {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.token}`
-      }
-    });
-    if (!response.ok) {
-      throw new Error("Sync failed");
-    }
-    const { results, syncDate } = await response.json();
-    const pendingStoreChanges = [];
-    const transaction = await this.storage.getReadWriteTransaction();
-    for (const { store, items } of results) {
-      this.syncProgressCallback?.({ store, size: items.length });
-      for (const item of items) {
-        if (item.deleted) {
-          await transaction.remove(store, item._id);
-        } else {
-          await transaction.set(store, item);
-        }
-      }
-    }
-    await transaction.commit();
-    const stateStorage = this.storage.getStore("state");
-    await stateStorage.applyChanges([
-      {
-        type: "set",
-        data: { _id: "$arc", lastSyncDate: syncDate }
-      }
-    ]);
   }
   async connectWebSocket() {
-    this._socket = new WebSocket(`wss://${window.location.host}/ws?token=${this.token}`);
+    this._socket = new WebSocket(`wss://${window.location.host}/api/ws?token=${this.token}`);
     this.openSocket = new Promise((resolve) => {
       this._socket.addEventListener("open", () => {
         this.reconnectAttempts = 0;
@@ -1434,138 +2141,160 @@ class RTCClient {
 var rtcClientFactory = (token) => (storage) => {
   return new RTCClient(storage, token);
 };
-// state/query.ts
-class ArcStateQuery extends ArcQuery {
-  state;
-  bindedChangeHandler = this.changeHandler.bind(this);
-  store;
-  constructor(state) {
-    super();
-    this.state = state;
-  }
-  async run(dataStorage, listener) {
-    this.store = dataStorage.getStore("state");
-    const result = await this.store.findById(this.state.name, this.bindedChangeHandler);
-    this.lastResult = this.state.deserialize(result);
-    if (listener)
-      this.listener = listener;
-    return this.lastResult;
-  }
-  onChange(change) {
-    if (change.type === "set")
-      return change.item;
-    return false;
-  }
-  changeHandler(changes) {
-    for (const change of changes) {
-      const response = this.onChange(change);
-      if (response !== false)
-        this.lastResult = this.state.deserialize(response);
-    }
-    if (this.lastResult)
-      this.nextResult(this.lastResult);
-  }
-  unsubscribe() {
-    this.store.unsubscribe(this.bindedChangeHandler);
-  }
-  nextResult(result) {
-    this.lastResult = result;
-    this.listener?.(result);
-  }
-}
-
-// state/query-builder.ts
-class ArcStateQueryBuilder extends ArcQueryBuilder {
-  state;
-  constructor(state) {
-    super();
-    this.state = state;
-  }
-  toQuery() {
-    return new ArcStateQuery(this.state);
-  }
-}
-
-// state/state.ts
-class ArcState extends ArcContextElement {
+// view/view.ts
+class ArcView extends ArcContextElementWithStore {
   name;
+  id;
   schema;
-  constructor(name, schema) {
+  _description;
+  _elements;
+  _handler;
+  constructor(name, id3, schema) {
     super();
     this.name = name;
+    this.id = id3;
     this.schema = schema;
   }
-  serialize(data) {
+  storeSchema = () => {
+    return arcObjectToStoreSchema(this.name, this.schema);
+  };
+  use(elements) {
+    const clone = this.clone();
+    clone._elements = elements;
+    return clone;
+  }
+  description(description) {
+    const clone = this.clone();
+    clone._description = description;
+    return clone;
+  }
+  handle(handler) {
+    const clone = this.clone();
+    clone._handler = handler;
+    return clone;
+  }
+  queryBuilder = (context3) => {
     return {
-      ...this.schema.serialize(data),
-      _id: this.name
+      find: (options) => {
+        throw new Error("Not implemented");
+      }
     };
-  }
-  deserialize(data) {
-    return this.schema.deserialize(data || {});
-  }
-  queryBuilder() {
-    return new ArcStateQueryBuilder(this);
-  }
-  commandContext(dataStorage, publishEvent) {
-    const store = dataStorage.getStore("state");
+  };
+  commandContext = (dataStorage, publishEvent) => {
+    const store = dataStorage.getStore(this.name);
     return {
-      get: async () => {
-        return store.findById(this.name);
+      find: async (options) => {
+        return store.find(options);
       },
-      modify: async (data) => {
-        const serialized = this.serialize(data);
-        const { from, to } = await store.modify(this.name, serialized);
-        await publishEvent({
-          type: "modify",
-          changes: data,
-          from,
-          to
+      findOne: async (where) => {
+        const result = await store.find({
+          where,
+          limit: 1
         });
-      },
-      edit: async (editCallback) => {
-        const { from, to } = await store.mutate(this.name, editCallback);
+        return result[0];
       }
     };
+  };
+  observer = () => {
+    return Object.entries(this._handler ?? {}).reduce((acc, [key, value]) => {
+      acc[key] = (event3, dataStorage) => {
+        const store = dataStorage.getStore(this.name);
+        const ctx = {
+          remove: async (id3) => {
+            await store.remove(id3);
+            return { success: true };
+          },
+          set: async (id3, data) => {
+            const parsed = this.schema.parse(data);
+            const body = {
+              _id: id3,
+              lastUpdate: new Date().toISOString(),
+              ...parsed
+            };
+            await store.set(body);
+            return { success: true };
+          },
+          find: async (options) => {
+            return store.find(options);
+          },
+          findOne: async (where) => {
+            const result = await store.find({
+              where,
+              limit: 1
+            });
+            return result[0];
+          },
+          modify: async (id3, data) => {
+            const deserialized = this.schema.serializePartial(data);
+            const { from, to } = await store.modify(id3, {
+              ...deserialized,
+              lastUpdate: new Date().toISOString()
+            });
+          }
+        };
+        value(ctx, event3);
+      };
+      return acc;
+    }, {});
+  };
+  clone() {
+    const clone = new ArcView(this.name, this.id, this.schema);
+    clone._description = this._description;
+    clone._elements = this._elements;
+    clone._handler = this._handler;
+    return clone;
   }
 }
-function state(name, schema) {
-  return new ArcState(name, schema);
+function view(name, id3, schema) {
+  return new ArcView(name, id3, schema);
 }
 export {
+  view,
   stringEnum,
   string,
-  state,
   rtcClientFactory,
   record,
+  reactive,
   object,
   number,
   id,
+  event,
   date,
   customId,
+  createSQLiteAdapterFactory,
   context,
+  command,
   collection,
   boolean,
   array,
   StoreState,
+  SQLiteAdapter,
+  RemoteModelClient,
+  QueryCache,
+  QueryBuilderContext,
+  ModelBase,
+  Model,
   MasterStoreState,
   MasterDataStorage,
   ForkedStoreState,
+  ForkedModel,
   ForkedDataStorage,
   DataStorage,
+  ArcView,
   ArcStringEnum,
   ArcString,
-  ArcState,
   ArcRecord,
   ArcQueryBuilder,
   ArcQuery,
   ArcOptional,
   ArcObject,
   ArcNumber,
-  ArcIndexedCollection,
   ArcId,
+  ArcEvent,
   ArcDate,
   ArcCustomId,
+  ArcContext,
+  ArcCommand,
   ArcCollectionQuery,
   ArcCollection,
   ArcBranded,