@arcote.tech/arc 0.1.2 → 0.1.4

package/dist/index.js

@@ -396,6 +396,22 @@ class ArcObject extends ArcAbstract {
       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]])));
   }
@@ -498,8 +514,111 @@ class ArcArray extends ArcAbstract {
 function array(element) {
   return new ArcArray(element);
 }
+// elements/blob.ts
+var blobValidator = {
+  name: "blob",
+  validator: (value) => {
+    if (!(value instanceof Blob)) {
+      return {
+        currentType: typeof value,
+        expectedType: "Blob"
+      };
+    }
+  }
+};
+
+class ArcBlob extends ArcPrimitive {
+  constructor() {
+    super([blobValidator]);
+  }
+  type(mimeType) {
+    return this.validation("type", (value) => {
+      if (!(value instanceof Blob))
+        return;
+      if (value.type !== mimeType) {
+        return {
+          currentType: value.type,
+          expectedType: mimeType
+        };
+      }
+    });
+  }
+  types(mimeTypes) {
+    return this.validation("types", (value) => {
+      if (!(value instanceof Blob))
+        return;
+      if (!mimeTypes.includes(value.type)) {
+        return {
+          currentType: value.type,
+          expectedTypes: mimeTypes
+        };
+      }
+    });
+  }
+  minSize(bytes) {
+    return this.validation("minSize", (value) => {
+      if (!(value instanceof Blob))
+        return;
+      if (value.size < bytes) {
+        return {
+          currentSize: value.size,
+          minSize: bytes
+        };
+      }
+    });
+  }
+  maxSize(bytes) {
+    return this.validation("maxSize", (value) => {
+      if (!(value instanceof Blob))
+        return;
+      if (value.size > bytes) {
+        return {
+          currentSize: value.size,
+          maxSize: bytes
+        };
+      }
+    });
+  }
+  size(bytes) {
+    return this.validation("size", (value) => {
+      if (!(value instanceof Blob))
+        return;
+      if (value.size !== bytes) {
+        return {
+          currentSize: value.size,
+          expectedSize: bytes
+        };
+      }
+    });
+  }
+  validation(name, validator) {
+    const instance = this.pipeValidation(name, validator);
+    return instance;
+  }
+  parse(value) {
+    if (value instanceof Blob) {
+      return value;
+    }
+    throw new Error("Expected Blob object");
+  }
+}
+function blob() {
+  return new ArcBlob;
+}
 // elements/boolean.ts
 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;
+  }
 }
 function boolean() {
   return new ArcBoolean;
@@ -515,7 +634,10 @@ class ArcDate extends ArcAbstract {
     return new Date(value);
   }
   serialize(value) {
-    return value.getTime();
+    if (value instanceof Date) {
+      return value.getTime();
+    }
+    return value;
   }
   deserialize(value) {
     return new Date(value);
@@ -540,6 +662,173 @@ class ArcDate extends ArcAbstract {
 function date() {
   return new ArcDate;
 }
+// elements/file.ts
+var fileValidator = {
+  name: "file",
+  validator: (value) => {
+    if (!(value instanceof File)) {
+      return {
+        currentType: typeof value,
+        expectedType: "File"
+      };
+    }
+  }
+};
+
+class ArcFile extends ArcPrimitive {
+  constructor() {
+    super([fileValidator]);
+  }
+  type(mimeType) {
+    return this.validation("type", (value) => {
+      if (!(value instanceof File))
+        return;
+      if (value.type !== mimeType) {
+        return {
+          currentType: value.type,
+          expectedType: mimeType
+        };
+      }
+    });
+  }
+  types(mimeTypes) {
+    return this.validation("types", (value) => {
+      if (!(value instanceof File))
+        return;
+      if (!mimeTypes.includes(value.type)) {
+        return {
+          currentType: value.type,
+          expectedTypes: mimeTypes
+        };
+      }
+    });
+  }
+  minSize(bytes) {
+    return this.validation("minSize", (value) => {
+      if (!(value instanceof File))
+        return;
+      if (value.size < bytes) {
+        return {
+          currentSize: value.size,
+          minSize: bytes
+        };
+      }
+    });
+  }
+  maxSize(bytes) {
+    return this.validation("maxSize", (value) => {
+      if (!(value instanceof File))
+        return;
+      if (value.size > bytes) {
+        return {
+          currentSize: value.size,
+          maxSize: bytes
+        };
+      }
+    });
+  }
+  size(bytes) {
+    return this.validation("size", (value) => {
+      if (!(value instanceof File))
+        return;
+      if (value.size !== bytes) {
+        return {
+          currentSize: value.size,
+          expectedSize: bytes
+        };
+      }
+    });
+  }
+  name(expectedName) {
+    return this.validation("name", (value) => {
+      if (!(value instanceof File))
+        return;
+      if (value.name !== expectedName) {
+        return {
+          currentName: value.name,
+          expectedName
+        };
+      }
+    });
+  }
+  namePattern(pattern) {
+    return this.validation("namePattern", (value) => {
+      if (!(value instanceof File))
+        return;
+      if (!pattern.test(value.name)) {
+        return {
+          currentName: value.name,
+          pattern: pattern.toString()
+        };
+      }
+    });
+  }
+  extension(ext) {
+    return this.validation("extension", (value) => {
+      if (!(value instanceof File))
+        return;
+      const fileExt = value.name.split(".").pop()?.toLowerCase();
+      const expectedExt = ext.startsWith(".") ? ext.slice(1).toLowerCase() : ext.toLowerCase();
+      if (fileExt !== expectedExt) {
+        return {
+          currentExtension: fileExt,
+          expectedExtension: expectedExt
+        };
+      }
+    });
+  }
+  extensions(exts) {
+    return this.validation("extensions", (value) => {
+      if (!(value instanceof File))
+        return;
+      const fileExt = value.name.split(".").pop()?.toLowerCase();
+      const normalizedExts = exts.map((ext) => ext.startsWith(".") ? ext.slice(1).toLowerCase() : ext.toLowerCase());
+      if (!fileExt || !normalizedExts.includes(fileExt)) {
+        return {
+          currentExtension: fileExt,
+          expectedExtensions: normalizedExts
+        };
+      }
+    });
+  }
+  lastModifiedAfter(date2) {
+    return this.validation("lastModifiedAfter", (value) => {
+      if (!(value instanceof File))
+        return;
+      if (value.lastModified < date2.getTime()) {
+        return {
+          currentLastModified: new Date(value.lastModified),
+          expectedAfter: date2
+        };
+      }
+    });
+  }
+  lastModifiedBefore(date2) {
+    return this.validation("lastModifiedBefore", (value) => {
+      if (!(value instanceof File))
+        return;
+      if (value.lastModified > date2.getTime()) {
+        return {
+          currentLastModified: new Date(value.lastModified),
+          expectedBefore: date2
+        };
+      }
+    });
+  }
+  validation(name, validator) {
+    const instance = this.pipeValidation(name, validator);
+    return instance;
+  }
+  parse(value) {
+    if (value instanceof File) {
+      return value;
+    }
+    throw new Error("Expected File object");
+  }
+}
+function file() {
+  return new ArcFile;
+}
 // elements/number.ts
 var numberValidator = typeValidatorBuilder("number");
 
@@ -654,26 +943,26 @@ function stringEnum(...values) {
   return new ArcStringEnum(values);
 }
 // utils/arcObjectToStoreSchema.ts
-function getSQLiteType(element) {
-  if (element instanceof ArcDate) {
+function getSQLiteType(element2) {
+  if (element2 instanceof ArcDate) {
     return "TEXT";
   }
-  if (element instanceof ArcArray || element instanceof ArcObject) {
+  if (element2 instanceof ArcArray || element2 instanceof ArcObject) {
     return "TEXT";
   }
-  if (element instanceof ArcBoolean) {
+  if (element2 instanceof ArcBoolean) {
     return "INTEGER";
   }
-  if (element instanceof ArcNumber) {
+  if (element2 instanceof ArcNumber) {
     return "NUMBER";
   }
   return "TEXT";
 }
 function arcObjectToStoreSchema(tableName, schema) {
-  const columns = schema.entries().map(([name, element]) => ({
+  const columns = schema.entries().map(([name, element2]) => ({
     name,
-    type: getSQLiteType(element),
-    isOptional: element instanceof ArcOptional
+    type: getSQLiteType(element2),
+    isOptional: element2 instanceof ArcOptional
   }));
   columns.unshift({
     name: "_id",
@@ -869,6 +1158,7 @@ class ArcCollection extends ArcContextElementWithStore {
   id;
   schema;
   options;
+  _restrictions;
   constructor(name, id3, schema, options) {
     super();
     this.name = name;
@@ -879,6 +1169,22 @@ class ArcCollection extends ArcContextElementWithStore {
   storeSchema() {
     return arcObjectToStoreSchema(this.name, this.schema);
   }
+  restrictions(authContext) {
+    if (this._restrictions) {
+      return this._restrictions(authContext);
+    }
+    return {
+      read: false,
+      write: false,
+      modify: false,
+      delete: false
+    };
+  }
+  auth(restrictionsFn) {
+    const collection = new ArcCollection(this.name, this.id, this.schema, this.options);
+    collection._restrictions = restrictionsFn;
+    return collection;
+  }
   serialize(data) {
     return {
       _id: this.id.serialize(data._id),
@@ -972,9 +1278,10 @@ class ArcCommand extends ArcContextElement {
   name;
   _description;
   _params;
-  _result;
+  _results;
   _elements;
   _handler;
+  _isPublic = false;
   constructor(name) {
     super();
     this.name = name;
@@ -989,14 +1296,22 @@ class ArcCommand extends ArcContextElement {
     clone._description = description;
     return clone;
   }
+  public() {
+    const clone = this.clone();
+    clone._isPublic = true;
+    return clone;
+  }
+  get isPublic() {
+    return this._isPublic;
+  }
   withParams(schema) {
     const clone = this.clone();
     clone._params = schema instanceof ArcObject ? schema : object(schema);
     return clone;
   }
-  withResult(schema) {
+  withResult(...schemas) {
     const clone = this.clone();
-    clone._result = object(schema);
+    clone._results = schemas.map((schema) => object(schema));
     return clone;
   }
   handle(handler) {
@@ -1014,9 +1329,10 @@ class ArcCommand extends ArcContextElement {
     const clone = new ArcCommand(this.name);
     clone._description = this._description;
     clone._params = this._params;
-    clone._result = this._result;
+    clone._results = this._results;
     clone._handler = this._handler;
     clone._elements = this._elements;
+    clone._isPublic = this._isPublic;
     return clone;
   }
 }
@@ -1026,20 +1342,34 @@ function command(name) {
 // context/context.ts
 class ArcContext {
   elements;
-  eventListeners;
   constructor(elements) {
     this.elements = elements;
-    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);
-        });
+  }
+  getSyncListeners(eventType, authContext) {
+    const listeners = [];
+    this.elements.forEach((element2) => {
+      if (element2.observer) {
+        const handlers = element2.observer(authContext);
+        const config = handlers[eventType];
+        if (config && !config.isAsync) {
+          listeners.push(config.handler);
+        }
+      }
+    });
+    return listeners;
+  }
+  getAsyncListeners(eventType, authContext) {
+    const listeners = [];
+    this.elements.forEach((element2) => {
+      if (element2.observer) {
+        const handlers = element2.observer(authContext);
+        const config = handlers[eventType];
+        if (config && config.isAsync) {
+          listeners.push(config.handler);
+        }
       }
     });
+    return listeners;
   }
   pipe(newElements) {
     return new ArcContext([
@@ -1047,73 +1377,44 @@ class ArcContext {
       ...newElements.filter(Boolean)
     ]);
   }
-  queryBuilder(queryContext) {
+  queryBuilder(queryContext, authContext) {
     return new Proxy({}, {
       get: (target, name) => {
-        const element = this.elements.find((element2) => element2.name === name);
-        if (!element) {
+        const element2 = this.elements.find((element3) => element3.name === name);
+        if (!element2) {
           throw new Error(`Element "${String(name)}" not found`);
         }
-        if (!element.queryBuilder) {
+        if (!element2.queryBuilder) {
           throw new Error(`Element "${String(name)}" does not have a query builder`);
         }
-        return element.queryBuilder(queryContext);
+        return element2.queryBuilder(queryContext, authContext);
       }
     });
   }
-  commandContext(client, dataStorage) {
+  commandContext(dataStorage, publishEvent, authContext) {
     return new Proxy({}, {
       get: (target, name) => {
-        if (name === "$client") {
-          return client;
+        if (name === "$auth") {
+          return authContext;
         }
-        const element = this.elements.find((element2) => element2.name === name);
-        if (!element) {
+        const element2 = this.elements.find((element3) => element3.name === name);
+        if (!element2) {
           throw new Error(`Element "${String(name)}" not found`);
         }
-        if (!element.commandContext) {
+        if (!element2.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, queryContext, dataStorage, catchErrorCallback) {
-    return new Proxy({}, {
-      get: (_, name) => {
-        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;
-          }
-        };
+        return element2.commandContext(dataStorage, publishEvent, authContext);
       }
     });
   }
 }
 async function context(elementsPromise) {
-  const elements = await Promise.all(elementsPromise.map(async (element) => {
-    if (element instanceof Promise) {
-      return (await element).default;
+  const elements = await Promise.all(elementsPromise.map(async (element2) => {
+    if (element2 instanceof Promise) {
+      return (await element2).default;
     }
-    return element;
+    return element2;
   })).then((elements2) => elements2.filter(Boolean));
   return new ArcContext(elements);
 }
@@ -1150,12 +1451,44 @@ var eventId = id("event");
 class ArcEvent extends ArcContextElementWithStore {
   name;
   payload;
+  _restrictions;
   storeSchema = () => eventStoreSchema;
   constructor(name, payload) {
     super();
     this.name = name;
     this.payload = payload;
   }
+  restrictions(authContext) {
+    if (this._restrictions) {
+      const eventRestrictions = this._restrictions(authContext);
+      return {
+        read: eventRestrictions.read,
+        write: eventRestrictions.write,
+        modify: false,
+        delete: false
+      };
+    }
+    const isSystemUser = authContext.roles.includes("system") || authContext.roles.includes("admin");
+    if (!isSystemUser) {
+      return {
+        read: false,
+        write: false,
+        modify: false,
+        delete: false
+      };
+    }
+    return {
+      read: true,
+      write: true,
+      modify: false,
+      delete: false
+    };
+  }
+  auth(restrictionsFn) {
+    const event = new ArcEvent(this.name, this.payload);
+    event._restrictions = restrictionsFn;
+    return event;
+  }
   commandContext = (dataStorage, publishEvent) => {
     return {
       emit: async (payload) => {
@@ -1696,10 +2029,7 @@ class MasterDataStorage extends DataStorage {
   }
   getStore(storeName) {
     if (!this.stores.has(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 && "deserialize" in contextElement && typeof contextElement.deserialize === "function" ? (a) => contextElement.deserialize(a) : undefined));
+      this.stores.set(storeName, new MasterStoreState(storeName, this));
     }
     return this.stores.get(storeName);
   }
@@ -1730,6 +2060,37 @@ class SQLiteReadTransaction {
     this.db = db;
     this.tables = tables;
   }
+  deserializeValue(value, column) {
+    if (value === null || value === undefined)
+      return null;
+    switch (column.type.toLowerCase()) {
+      case "json":
+      case "text": {
+        try {
+          const parsed = JSON.parse(value);
+          if (typeof parsed === "object" || Array.isArray(parsed)) {
+            return parsed;
+          }
+          return value;
+        } 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, id3) {
     return id3;
   }
@@ -1797,6 +2158,10 @@ class SQLiteReadTransaction {
     const { where, limit, offset, orderBy } = options || {};
     const whereClause = this.buildWhereClause(where);
     const orderByClause = this.buildOrderByClause(orderBy);
+    const table = this.tables.get(store);
+    if (!table) {
+      throw new Error(`Store ${store} not found`);
+    }
     const query2 = `
       SELECT * 
       FROM ${store} 
@@ -1805,7 +2170,8 @@ class SQLiteReadTransaction {
       ${limit ? `LIMIT ${limit}` : ""}
       ${offset ? `OFFSET ${offset}` : ""}
     `;
-    return await this.db.exec(query2, whereClause.params);
+    const rows = await this.db.exec(query2, whereClause.params);
+    return rows.map((row) => this.deserializeRow(row, table));
   }
 }
 
@@ -1819,23 +2185,23 @@ class SQLiteReadWriteTransaction extends SQLiteReadTransaction {
     await this.db.exec(query2, [new Date().toISOString(), id3]);
   }
   async set(store, item) {
-    const schema = this.tables.get(store);
-    if (!schema) {
+    const table = this.tables.get(store);
+    if (!table) {
       throw new Error(`Store ${store} not found`);
     }
     const now = new Date().toISOString();
-    const columnNames = schema.columns.map((col) => col.name);
-    const values = schema.columns.map((column) => {
+    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);
+      return this.serializeValue(value, column);
     });
     const placeholders = columnNames.map(() => "?").join(", ");
     const sql = `
-        INSERT OR REPLACE INTO ${schema.name}
-        (${columnNames.join(", ")})
+        INSERT OR REPLACE INTO ${table.name}
+        (${columnNames.map((c) => `"${c}"`).join(", ")})
         VALUES (${placeholders})
       `;
     await this.db.exec(sql, values);
@@ -1843,16 +2209,21 @@ class SQLiteReadWriteTransaction extends SQLiteReadTransaction {
   async commit() {
     return Promise.resolve();
   }
-  serializeValue(value) {
+  serializeValue(value, column) {
     if (value === null || value === undefined)
       return null;
-    if (value instanceof Date) {
-      return value.toISOString();
-    }
-    if (Array.isArray(value) || typeof value === "object") {
-      return JSON.stringify(value);
+    switch (column.type.toLowerCase()) {
+      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;
     }
-    return value;
   }
 }
 
@@ -1863,9 +2234,9 @@ class SQLiteAdapter {
   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.context.elements.forEach((element3) => {
+      if ("storeSchema" in element3 && typeof element3.storeSchema === "function") {
+        element3.storeSchema().tables.forEach((table) => {
           this.tables.set(table.name, table);
         });
       }
@@ -1873,9 +2244,9 @@ class SQLiteAdapter {
   }
   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();
+    for (const element3 of this.context.elements) {
+      if ("storeSchema" in element3 && typeof element3.storeSchema === "function") {
+        const schema = element3.storeSchema();
         stores.add(schema);
       }
     }
@@ -1921,64 +2292,214 @@ var createSQLiteAdapterFactory = (db) => {
     return adapter;
   };
 };
-// model/model.ts
-class ModelBase {
-}
-
-class Model extends ModelBase {
-  context;
-  dataStorage;
-  client;
-  catchErrorCallback;
-  queryCache = new QueryCache;
-  constructor(context3, dataStorage, client, catchErrorCallback) {
+// listener/listener.ts
+class ArcListener extends ArcContextElement {
+  name;
+  _description;
+  _elements;
+  _eventElements;
+  _handler;
+  _isAsync = false;
+  constructor(name) {
     super();
-    this.context = context3;
-    this.dataStorage = dataStorage;
-    this.client = client;
-    this.catchErrorCallback = catchErrorCallback;
+    this.name = name;
   }
-  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);
+  use(elements) {
+    const clone = this.clone();
+    clone._elements = elements;
+    return clone;
   }
-  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
+  description(description) {
+    const clone = this.clone();
+    clone._description = description;
+    return clone;
+  }
+  listenTo(events) {
+    const clone = this.clone();
+    clone._eventElements = events;
+    return clone;
+  }
+  async() {
+    const clone = this.clone();
+    clone._isAsync = true;
+    return clone;
+  }
+  handle(handler) {
+    const clone = this.clone();
+    clone._handler = handler;
+    return clone;
+  }
+  observer = (authContext) => {
+    if (!this._handler || !this._elements || !this._eventElements) {
+      return {};
+    }
+    const eventTypes = this._eventElements.filter((element3) => element3 instanceof ArcEvent).map((event3) => event3.name);
+    return eventTypes.reduce((acc, eventType) => {
+      acc[eventType] = {
+        handler: async (event3, dataStorage, publishEvent) => {
+          const ctx = new Proxy({}, {
+            get: (target, name) => {
+              if (name === "$auth") {
+                return authContext;
+              }
+              const element3 = this._elements.find((element4) => element4.name === name);
+              if (!element3) {
+                throw new Error(`Element "${String(name)}" not found in listener "${this.name}"`);
+              }
+              if (!element3.commandContext) {
+                throw new Error(`Element "${String(name)}" does not have a command context`);
+              }
+              return element3.commandContext(dataStorage, publishEvent, authContext);
+            }
+          });
+          await this._handler(ctx, event3);
+        },
+        isAsync: this._isAsync
+      };
+      return acc;
+    }, {});
+  };
+  clone() {
+    const clone = new ArcListener(this.name);
+    clone._description = this._description;
+    clone._elements = this._elements;
+    clone._eventElements = this._eventElements;
+    clone._handler = this._handler;
+    clone._isAsync = this._isAsync;
+    return clone;
+  }
+}
+function listener(name) {
+  return new ArcListener(name);
+}
+// model/model.ts
+class EventPublisher {
+  context;
+  dataStorage;
+  authContext;
+  asyncEvents = [];
+  constructor(context3, dataStorage, authContext) {
+    this.context = context3;
+    this.dataStorage = dataStorage;
+    this.authContext = authContext;
+  }
+  async publishEvent(event3, commandDataStorage) {
+    const recursivePublishEvent = async (childEvent) => {
+      await this.publishEvent(childEvent, commandDataStorage);
     };
+    const syncListeners = this.context.getSyncListeners(event3.type, this.authContext);
+    for (const listener3 of syncListeners) {
+      try {
+        await listener3(event3, commandDataStorage, recursivePublishEvent);
+      } catch (error) {
+        console.error("Sync listener failed:", error);
+        throw error;
+      }
+    }
+    const asyncListeners = this.context.getAsyncListeners(event3.type, this.authContext);
+    if (asyncListeners.length > 0) {
+      this.asyncEvents.push({
+        event: event3,
+        listeners: asyncListeners,
+        authContext: this.authContext
+      });
+    }
+  }
+  async runAsyncListeners() {
+    const allAsyncTasks = this.asyncEvents.flatMap(({ event: event3, listeners, authContext }) => listeners.map(async (listener3) => {
+      const listenerFork = this.dataStorage.fork();
+      const asyncPublishEvent = async (childEvent) => {
+        const childPublisher = new EventPublisher(this.context, listenerFork, authContext);
+        await childPublisher.publishEvent(childEvent, listenerFork);
+        await childPublisher.runAsyncListeners();
+      };
+      try {
+        await listener3(event3, listenerFork, asyncPublishEvent);
+        await listenerFork.merge();
+      } catch (error) {
+        console.error("Async listener failed:", error);
+      }
+    }));
+    await Promise.all(allAsyncTasks);
+    this.asyncEvents = [];
+  }
+}
+
+class ModelBase {
+  token = null;
+  setAuthToken(token) {
+    this.token = token;
   }
-  commands() {
+}
+
+class Model extends ModelBase {
+  context;
+  dataStorage;
+  catchErrorCallback;
+  queryCache = new QueryCache;
+  constructor(context3, dataStorage, catchErrorCallback) {
+    super();
+    this.context = context3;
+    this.dataStorage = dataStorage;
+    this.catchErrorCallback = catchErrorCallback;
+  }
+  async query(queryBuilderFn, authContext) {
     const queryContext = new QueryBuilderContext(this.queryCache, this.dataStorage);
-    return this.context.commandsClient(this.client, queryContext, this.dataStorage, this.catchErrorCallback);
+    const queryBuilder = this.context.queryBuilder(queryContext, authContext);
+    const query2 = queryBuilderFn(queryBuilder).toQuery(queryContext);
+    return query2.run(this.dataStorage);
   }
-  fork() {
-    return new ForkedModel(this.context, this.dataStorage.fork(), this.client, this.catchErrorCallback);
+  subscribe(queryBuilderFn, callback, authContext) {
+    const queryContext = new QueryBuilderContext(this.queryCache, this.dataStorage);
+    const queryBuilder = this.context.queryBuilder(queryContext, authContext);
+    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
+    };
+  }
+  commands(authContext) {
+    return new Proxy({}, {
+      get: (_, name) => {
+        const element3 = this.context.elements.find((element4) => element4.name === name);
+        if (!element3) {
+          throw new Error(`Element "${String(name)}" not found`);
+        }
+        if (!element3.commandClient) {
+          throw new Error(`Element "${String(name)}" does not have a command client`);
+        }
+        return async (arg) => {
+          const forkedDataStorage = this.dataStorage.fork();
+          const eventPublisher = new EventPublisher(this.context, this.dataStorage, authContext);
+          const publishEvent = async (event3) => {
+            await eventPublisher.publishEvent(event3, forkedDataStorage);
+          };
+          const commandContext = this.context.commandContext(forkedDataStorage, publishEvent, authContext);
+          try {
+            const result = await element3.commandClient(commandContext, authContext)(arg);
+            await forkedDataStorage.merge();
+            eventPublisher.runAsyncListeners();
+            return result;
+          } catch (error) {
+            this.catchErrorCallback(error);
+            return error;
+          }
+        };
+      }
+    });
   }
   get $debug() {
     return {};
   }
 }
 
-class ForkedModel extends Model {
-  constructor(context3, dataStorage, client, catchErrorCallback) {
-    super(context3, dataStorage, client, catchErrorCallback);
-  }
-  merge() {}
-}
-
 class RemoteModelClient extends ModelBase {
   context;
   apiBaseUrl;
@@ -1991,14 +2512,107 @@ class RemoteModelClient extends ModelBase {
     this.client = client;
     this.catchErrorCallback = catchErrorCallback;
   }
-  async query(queryBuilderFn) {
+  schemaContainsBlobOrFile(schema) {
+    if (!schema)
+      return false;
+    if (schema && typeof schema === "object" && schema.rawShape) {
+      return this.checkShapeForBlobOrFile(schema.rawShape);
+    }
+    if (schema && typeof schema === "object" && schema._shape) {
+      return this.checkShapeForBlobOrFile(schema._shape);
+    }
+    if (schema && typeof schema === "object") {
+      return this.checkShapeForBlobOrFile(schema);
+    }
+    return false;
+  }
+  checkShapeForBlobOrFile(shape) {
+    if (!shape || typeof shape !== "object") {
+      return false;
+    }
+    for (const key in shape) {
+      const element3 = shape[key];
+      if (this.isBlobOrFileElement(element3)) {
+        return true;
+      }
+      if (element3 && element3.parent && this.isBlobOrFileElement(element3.parent)) {
+        return true;
+      }
+      if (element3 && element3._shape) {
+        if (this.checkShapeForBlobOrFile(element3._shape)) {
+          return true;
+        }
+      }
+      if (element3 && element3.parent && element3.parent._shape) {
+        if (this.checkShapeForBlobOrFile(element3.parent._shape)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  isBlobOrFileElement(element3) {
+    if (!element3) {
+      return false;
+    }
+    const constructorName = element3.constructor?.name;
+    if (constructorName === "ArcBlob" || constructorName === "ArcFile") {
+      return true;
+    }
+    if (element3.validations || element3._validators) {
+      const validators = element3.validations || element3._validators;
+      const hasFileValidator = validators.some((validator) => validator.name === "blob" || validator.name === "file");
+      if (hasFileValidator) {
+        return true;
+      }
+    }
+    return false;
+  }
+  objectToFormData(obj, formData = new FormData, parentKey = "") {
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        const fullKey = parentKey ? `${parentKey}[${key}]` : key;
+        const value = obj[key];
+        if (value instanceof Blob || value instanceof File) {
+          formData.append(fullKey, value);
+        } else if (Array.isArray(value)) {
+          value.forEach((item, index) => {
+            const arrayKey = `${fullKey}[${index}]`;
+            if (item instanceof Blob || item instanceof File) {
+              formData.append(arrayKey, item);
+            } else if (typeof item === "object" && item !== null) {
+              this.objectToFormData(item, formData, arrayKey);
+            } else {
+              formData.append(arrayKey, String(item));
+            }
+          });
+        } else if (typeof value === "object" && value !== null) {
+          this.objectToFormData(value, formData, fullKey);
+        } else {
+          formData.append(fullKey, String(value));
+        }
+      }
+    }
+    return formData;
+  }
+  getAuthHeaders(isFormData = false) {
+    const headers = {};
+    if (!isFormData) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (this.token) {
+      headers.Authorization = `Bearer ${this.token}`;
+    }
+    return headers;
+  }
+  async query(queryBuilderFn, authContext) {
     const queryTracking = {
       element: null,
       queryType: null,
       params: null
     };
     const queryContext = new QueryBuilderContext(new QueryCache, null);
-    const originalQueryBuilder = this.context.queryBuilder(queryContext);
+    const originalQueryBuilder = this.context.queryBuilder(queryContext, authContext);
     const queryBuilderProxy = new Proxy(originalQueryBuilder, {
       get: (target, prop) => {
         queryTracking.element = prop;
@@ -2009,16 +2623,15 @@ class RemoteModelClient extends ModelBase {
             const originalMethod = Reflect.get(elementTarget, methodProp);
             return (...args) => {
               queryTracking.params = args;
-              return originalMethod(...args);
             };
           }
         });
       }
     });
-    const query2 = queryBuilderFn(queryBuilderProxy).toQuery(queryContext);
+    queryBuilderFn(queryBuilderProxy);
     const response = await fetch(`${this.apiBaseUrl}/query`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: this.getAuthHeaders(),
       body: JSON.stringify({
         query: {
           element: queryTracking.element,
@@ -2033,8 +2646,8 @@ class RemoteModelClient extends ModelBase {
     const { result } = await response.json();
     return result;
   }
-  subscribe(queryBuilderFn, callback) {
-    const result = this.query(queryBuilderFn);
+  subscribe(queryBuilderFn, callback, authContext) {
+    const result = this.query(queryBuilderFn, authContext);
     result.then((initialResult) => {
       callback(initialResult);
     }).catch(this.catchErrorCallback);
@@ -2043,24 +2656,34 @@ class RemoteModelClient extends ModelBase {
       result
     };
   }
-  commands() {
+  commands(authContext) {
     const commandsProxy = new Proxy({}, {
       get: (target, prop) => {
-        const element = this.context.elements.find((e) => e.name === prop);
-        if (!element) {
+        const element3 = this.context.elements.find((e) => e.name === prop);
+        if (!element3) {
           throw new Error(`Command ${String(prop)} not found`);
         }
         return Object.assign(async (argument) => {
+          let body;
+          let headers;
+          const commandParams = element3._params;
+          if (this.schemaContainsBlobOrFile(commandParams)) {
+            body = this.objectToFormData(argument);
+            headers = this.getAuthHeaders(true);
+          } else {
+            body = JSON.stringify(argument);
+            headers = this.getAuthHeaders(false);
+          }
           const response = await fetch(`${this.apiBaseUrl}/command/${String(prop)}`, {
             method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(argument)
+            headers,
+            body
           });
           if (!response.ok) {
             throw new Error(`Command ${String(prop)} failed: ${response.statusText}`);
           }
           return response.json();
-        }, { params: element._params });
+        }, { params: element3._params });
       }
     });
     return commandsProxy;
@@ -2141,6 +2764,236 @@ class RTCClient {
 var rtcClientFactory = (token) => (storage) => {
   return new RTCClient(storage, token);
 };
+// view/queries/abstract-view-query.ts
+class ArcViewQuery extends ArcSerializableQuery {
+  view;
+  bindedChangeHandler = this.changeHandler.bind(this);
+  store;
+  constructor(view, params) {
+    super(params);
+    this.view = view;
+  }
+  async run(dataStorage) {
+    const store = dataStorage.getStore(this.view.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);
+  }
+}
+
+// view/queries/find.ts
+class QueryViewResult {
+  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;
+  }
+}
+
+class ArcViewFindQuery extends ArcViewQuery {
+  params;
+  constructor(view, params) {
+    super(view, 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) {
+    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;
+  }
+  createResult(result) {
+    return new QueryViewResult(result);
+  }
+}
+
+// view/query-builders/find.ts
+class ArcViewFindQueryBuilder {
+  view;
+  queryContext;
+  options;
+  constructor(view, queryContext, options) {
+    this.view = view;
+    this.queryContext = queryContext;
+    this.options = options;
+  }
+  toQuery() {
+    return this.queryContext.cacheQuery(ArcViewFindQuery, [
+      this.view,
+      this.options
+    ]);
+  }
+  run() {
+    return this.queryContext.runQuery(this.toQuery());
+  }
+}
+
+// view/queries/find-one.ts
+class QueryViewFindOneResult {
+  result;
+  constructor(result) {
+    this.result = result;
+  }
+  get() {
+    return this.result;
+  }
+  exists() {
+    return this.result !== undefined;
+  }
+}
+
+class ArcViewFindOneQuery extends ArcViewQuery {
+  params;
+  constructor(view, params) {
+    super(view, params);
+    this.params = params;
+  }
+  async fetch(store) {
+    const results = await store.find({ ...this.params, limit: 1 }, this.bindedChangeHandler);
+    return this.createResult(results[0]);
+  }
+  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) {
+    const lastResult = this.lastResult;
+    const currentItem = lastResult?.get();
+    const itemId = change.type === "delete" ? change.id : change.id;
+    const hasCurrentItem = currentItem !== undefined;
+    const isCurrentItem = hasCurrentItem && currentItem._id === itemId;
+    const shouldBeTheResult = change.type !== "delete" && this.checkItem(change.item);
+    if (isCurrentItem && shouldBeTheResult)
+      return this.createResult(change.item);
+    else if (isCurrentItem && (change.type === "delete" || !shouldBeTheResult))
+      return this.createResult(undefined);
+    else if (!hasCurrentItem && shouldBeTheResult)
+      return this.createResult(change.item);
+    return false;
+  }
+  createResult(result) {
+    return new QueryViewFindOneResult(result);
+  }
+}
+
+// view/query-builders/find-one.ts
+class ArcViewFindOneQueryBuilder {
+  view;
+  queryContext;
+  options;
+  constructor(view, queryContext, options) {
+    this.view = view;
+    this.queryContext = queryContext;
+    this.options = options;
+  }
+  toQuery() {
+    return this.queryContext.cacheQuery(ArcViewFindOneQuery, [
+      this.view,
+      this.options
+    ]);
+  }
+  run() {
+    return this.queryContext.runQuery(this.toQuery());
+  }
+}
+
 // view/view.ts
 class ArcView extends ArcContextElementWithStore {
   name;
@@ -2149,6 +3002,8 @@ class ArcView extends ArcContextElementWithStore {
   _description;
   _elements;
   _handler;
+  _isAsync = false;
+  restrictions;
   constructor(name, id3, schema) {
     super();
     this.name = name;
@@ -2158,6 +3013,11 @@ class ArcView extends ArcContextElementWithStore {
   storeSchema = () => {
     return arcObjectToStoreSchema(this.name, this.schema);
   };
+  auth(restrictionsFn) {
+    const clone = this.clone();
+    clone.restrictions = restrictionsFn;
+    return clone;
+  }
   use(elements) {
     const clone = this.clone();
     clone._elements = elements;
@@ -2168,71 +3028,113 @@ class ArcView extends ArcContextElementWithStore {
     clone._description = description;
     return clone;
   }
+  async() {
+    const clone = this.clone();
+    clone._isAsync = true;
+    return clone;
+  }
   handle(handler) {
     const clone = this.clone();
     clone._handler = handler;
     return clone;
   }
-  queryBuilder = (context3) => {
+  applyRestrictions(authContext, options) {
+    if (!this.restrictions) {
+      return options;
+    }
+    const restrictions = this.restrictions(authContext);
+    return {
+      ...options,
+      where: {
+        ...options.where,
+        ...restrictions
+      }
+    };
+  }
+  queryBuilder = (context3, authContext) => {
     return {
       find: (options) => {
-        throw new Error("Not implemented");
+        const restrictedOptions = this.applyRestrictions(authContext, options || {});
+        return new ArcViewFindQueryBuilder(this, context3, restrictedOptions);
+      },
+      findOne: (where) => {
+        const restrictedOptions = this.applyRestrictions(authContext, {
+          where,
+          limit: 1
+        });
+        return new ArcViewFindOneQueryBuilder(this, context3, restrictedOptions);
       }
     };
   };
-  commandContext = (dataStorage, publishEvent) => {
+  commandContext = (dataStorage, publishEvent, authContext) => {
     const store = dataStorage.getStore(this.name);
     return {
       find: async (options) => {
-        return store.find(options);
+        const restrictedOptions = this.applyRestrictions(authContext, options);
+        return store.find(restrictedOptions);
       },
       findOne: async (where) => {
-        const result = await store.find({
+        const restrictedOptions = this.applyRestrictions(authContext, {
           where,
           limit: 1
         });
+        const result = await store.find(restrictedOptions);
         return result[0];
       }
     };
   };
-  observer = () => {
+  observer = (authContext) => {
     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);
+      acc[key] = {
+        handler: async (event3, dataStorage, publishEvent) => {
+          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);
+              await publishEvent({
+                type: "set",
+                to: 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()
+              });
+              await publishEvent({
+                type: "modify",
+                changes: deserialized,
+                from,
+                to
+              });
+            },
+            $auth: authContext
+          };
+          await value(ctx, event3);
+        },
+        isAsync: this._isAsync
       };
       return acc;
     }, {});
@@ -2242,6 +3144,8 @@ class ArcView extends ArcContextElementWithStore {
     clone._description = this._description;
     clone._elements = this._elements;
     clone._handler = this._handler;
+    clone._isAsync = this._isAsync;
+    clone.restrictions = this.restrictions;
     return clone;
   }
 }
@@ -2257,8 +3161,11 @@ export {
   reactive,
   object,
   number,
+  listener,
   id,
+  file,
   event,
+  deepMerge,
   date,
   customId,
   createSQLiteAdapterFactory,
@@ -2266,6 +3173,7 @@ export {
   command,
   collection,
   boolean,
+  blob,
   array,
   StoreState,
   SQLiteAdapter,
@@ -2277,7 +3185,6 @@ export {
   MasterStoreState,
   MasterDataStorage,
   ForkedStoreState,
-  ForkedModel,
   ForkedDataStorage,
   DataStorage,
   ArcView,
@@ -2289,15 +3196,20 @@ export {
   ArcOptional,
   ArcObject,
   ArcNumber,
+  ArcListener,
   ArcId,
+  ArcFile,
   ArcEvent,
   ArcDate,
   ArcCustomId,
+  ArcContextElementWithStore,
+  ArcContextElement,
   ArcContext,
   ArcCommand,
   ArcCollectionQuery,
   ArcCollection,
   ArcBranded,
   ArcBoolean,
+  ArcBlob,
   ArcArray
 };