@arcote.tech/arc 0.1.4 → 0.1.6

package/dist/command/command.d.ts

@@ -9,24 +9,35 @@ export declare class ArcCommand<Name extends string, Params extends ArcObjectAny
     result: Results[number];
 }, Name> {
     readonly name: Name;
-    private _description?;
-    private _params?;
-    private _results?;
-    private _elements?;
-    private _handler?;
-    private _isPublic;
+    _description?: string;
+    _params?: Params;
+    _results?: Results;
+    _elements?: Elements;
+    _handler?: ArcCommmandHandler<Elements, Params, Results> | false;
+    _isPublic: boolean;
     constructor(name: Name);
     use<const E extends ArcContextElementAny[]>(elements: E): ArcCommand<Name, Params, Results, E>;
     description(description: string): ArcCommand<Name, Params, Results, Elements>;
     public(): ArcCommand<Name, Params, Results, Elements>;
     get isPublic(): boolean;
+    matchesCommandPath(pathname: string): {
+        matches: boolean;
+        isPublic: boolean;
+    };
     withParams<NewParams extends ArcRawShape>(schema: NewParams | ArcObject<NewParams>): ArcCommand<Name, ArcObject<NewParams>, Results, Elements>;
     withResult<NewResults extends ArcRawShape[]>(...schemas: NewResults): ArcCommand<Name, Params, { [K in keyof NewResults]: ArcObject<NewResults[K]>; }, Elements>;
     handle(handler: ArcCommmandHandler<Elements, Params, Results> | false): ArcCommand<Name, Params, Results, Elements>;
     commandClient: (ctx: any) => (Params extends ArcObjectAny ? (params: $type<Params>) => Promise<$type<Results[number]>> : () => Promise<$type<Results[number]>>) & {
         params: Params;
     };
-    private clone;
+    protected clone(): ArcCommand<Name, Params, Results, Elements>;
+    toJsonSchema(): {
+        type: string;
+        name: Name;
+        description: string | undefined;
+        parameters: any;
+    };
 }
 export declare function command<Name extends string>(name: Name): ArcCommand<Name, null, any[], any[]>;
+export type ArcCommandAny = ArcCommand<any, any, any, any>;
 //# sourceMappingURL=command.d.ts.map

package/dist/context/context.d.ts

@@ -15,6 +15,8 @@ export type ArcContextElementMethodReturnType<Elements extends ArcContextElement
 }[number]>;
 export type ArcCommandContext<E extends ArcContextElementAny[]> = ArcContextElementMethodReturnType<E, "commandContext"> & {
     $auth: AuthContext;
+} & {
+    get: <ArcElement extends ArcContextElementAny>(element: ArcElement) => ArcElement["commandContext"] extends infer CommandContext ? CommandContext extends (...args: any) => any ? ReturnType<CommandContext> : never : never;
 };
 export type RemoveFalseAndResolvedPromiseFromArray<T extends any[]> = T extends [infer First, ...infer Rest] ? First extends false ? RemoveFalseAndResolvedPromiseFromArray<Rest> : First extends Promise<{
     default: infer Inner;
@@ -41,8 +43,7 @@ export type ContextEvents<Context extends ArcContextAny> = {
     } & ElementEvents<Element>>;
 }[Context["elements"][number]["name"]];
 export type Listener<Context extends ArcContextAny> = (event: ContextEvents<Context>, context: CommandContext<Context>) => Promise<void> | void;
-export declare function context<const Elements extends (ArcContextElementAny | false | Promise<{
-    default: ArcContextElementAny;
-}>)[]>(elementsPromise: Elements): Promise<ArcContext<RemoveFalseAndResolvedPromiseFromArray<Elements>>>;
+export declare function context<const Elements extends ArcContextElementAny[]>(elements: Elements): ArcContext<Elements>;
+export declare function contextMerge<const Contexts extends ArcContextAny[]>(...contexts: Contexts): ArcContext<Contexts[number]["elements"]>;
 export {};
 //# sourceMappingURL=context.d.ts.map

package/dist/context/element.d.ts

@@ -50,7 +50,7 @@ export type StoreSchema = {
 export declare abstract class ArcContextElement<const Event, const Name extends string | undefined = undefined> {
     readonly $event: Event;
     readonly name?: Name;
-    queryBuilder?(queryContext: QueryBuilderContext, authContext: AuthContext): any;
+    queryBuilder?: (queryContext: QueryBuilderContext, authContext: AuthContext) => any;
     commandContext?: (dataStorage: DataStorage, publishEvent: PublishEventFunction, authContext: AuthContext) => any;
     commandClient?: (commandContext: any, authContext: AuthContext) => (...args: any[]) => any;
     observer?: (authContext: AuthContext) => Record<string, ListenerConfig>;

package/dist/context/event.d.ts

@@ -3,14 +3,7 @@ import { ArcObject, type ArcObjectAny, type ArcRawShape } from "../elements/obje
 import type { $type } from "../utils";
 import { ArcContextElementWithStore, type AuthContext, type AuthorizationRestrictions, type EventAuthorizationRestrictions, type StoreSchema } from "./element";
 export type EventMetadata = {
-    occurredAt: string;
-    createdBy?: {
-        id: string;
-        type: string;
-    };
-    source?: string;
-    correlationId?: string;
-    version?: number;
+    createdAt: Date;
 };
 export declare class ArcEvent<const Name extends string, const PayloadShape extends ArcObjectAny | undefined> extends ArcContextElementWithStore<ArcEventInstance<ArcEvent<Name, PayloadShape>>, Name> {
     readonly name: Name;

package/dist/elements/abstract.d.ts

@@ -24,6 +24,10 @@ export declare abstract class ArcAbstract<V extends Validators> implements ArcEl
         name: Name;
         validator: Val;
     }]>;
+    /**
+     * Default JSON Schema representation – concrete subclasses should override where applicable.
+     */
+    toJsonSchema(): any;
     getValidations(): V;
 }
 export type ArcAbstractAny = ArcAbstract<any>;

package/dist/elements/any.d.ts

@@ -0,0 +1,10 @@
+import { ArcAbstract, type Validators } from "./abstract";
+export declare class ArcAny<T, V extends Validators = []> extends ArcAbstract<V> {
+    constructor();
+    parse(value: T): any;
+    serialize(value: T): any;
+    deserialize(value: any): T;
+    toJsonSchema(): {};
+}
+export declare function any<T extends any>(): ArcAny<T, any>;
+//# sourceMappingURL=any.d.ts.map

package/dist/elements/array.d.ts

@@ -54,6 +54,10 @@ export declare class ArcArray<E extends ArcElement, V extends Validators = [
         name: Name;
         validator: Fn;
     }]>>>;
+    toJsonSchema(): {
+        type: string;
+        items: any;
+    };
 }
 export type ArcArrayAny = ArcArray<any>;
 export declare function array<E extends ArcElement>(element: E): ArcArray<E, [{

package/dist/elements/blob.d.ts

@@ -67,6 +67,11 @@ export declare class ArcBlob<V extends Validators = [typeof blobValidator]> exte
      * Override parse to validate blob objects
      */
     parse(value: any): Blob;
+    toJsonSchema(): {
+        type: string;
+        contentEncoding: string;
+        contentMediaType: string;
+    };
 }
 export declare function blob(): ArcBlob<[{
     readonly name: "blob";

package/dist/elements/boolean.d.ts

@@ -11,6 +11,9 @@ export declare class ArcBoolean<V extends Validators> extends ArcPrimitive<V, bo
         name: Name;
         validator: Fn;
     }]>>>;
+    toJsonSchema(): {
+        type: string;
+    };
 }
 export declare function boolean(): ArcBoolean<Validators>;
 //# sourceMappingURL=boolean.d.ts.map

package/dist/elements/branded.d.ts

@@ -17,6 +17,7 @@ export declare class ArcBranded<E extends ArcAbstractAny, Brand extends string |
     };
     optional(): ArcOptional<this>;
     validate(value: unknown): unknown;
+    toJsonSchema(): any;
 }
 export type ArcBrandedAny = ArcBranded<ArcAbstractAny, any>;
 //# sourceMappingURL=branded.d.ts.map

package/dist/elements/date.d.ts

@@ -30,6 +30,10 @@ export declare class ArcDate<V extends Validators = [typeof dateValidator]> exte
         name: Name;
         validator: Fn;
     }]>>>;
+    toJsonSchema(): {
+        type: string;
+        format: string;
+    };
 }
 export declare function date(): ArcDate<[{
     name: "type";

package/dist/elements/default.d.ts

@@ -8,5 +8,6 @@ export declare class ArcDefault<E extends ArcElement> implements ArcElement {
     parse(value: util.FirstArgument<E["parse"]> | undefined): ReturnType<E["parse"]>;
     serialize(value: util.FirstArgument<E["serialize"]> | undefined): ReturnType<E["serialize"]>;
     deserialize(value: util.FirstArgument<E["deserialize"]> | undefined): ReturnType<E["deserialize"]>;
+    toJsonSchema(): any;
 }
 //# sourceMappingURL=default.d.ts.map

package/dist/elements/element.d.ts

@@ -3,5 +3,9 @@ export interface ArcElement {
     deserialize(value: unknown): unknown;
     parse(value: unknown): unknown;
     validate(value: unknown): unknown;
+    /**
+     * Returns JSON Schema Draft-07 representation of this element.
+     */
+    toJsonSchema(): any;
 }
 //# sourceMappingURL=element.d.ts.map

package/dist/elements/file.d.ts

@@ -127,6 +127,11 @@ export declare class ArcFile<V extends Validators = [typeof fileValidator]> exte
      * Override parse to validate file objects
      */
     parse(value: any): File;
+    toJsonSchema(): {
+        type: string;
+        contentEncoding: string;
+        contentMediaType: string;
+    };
 }
 export declare function file(): ArcFile<[{
     readonly name: "file";

package/dist/elements/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./any";
 export * from "./array";
 export * from "./blob";
 export * from "./boolean";

package/dist/elements/number.d.ts

@@ -27,6 +27,9 @@ export declare class ArcNumber<V extends Validators = [typeof numberValidator]>
         name: Name;
         validator: Fn;
     }]>>>;
+    toJsonSchema(): {
+        type: string;
+    };
 }
 export declare function number(): ArcNumber<[{
     name: "type";

package/dist/elements/object.d.ts

@@ -63,6 +63,7 @@ export declare class ArcObject<E extends ArcRawShape, V extends Validators = [
     pick<Keys extends keyof E>(...keys: Keys[]): ArcObject<Pick<E, Keys>, V>;
     omit<Keys extends keyof E>(...keys: Keys[]): ArcObject<Omit<E, Keys>, V>;
     entries(): [string, ArcElement][];
+    toJsonSchema(): any;
 }
 export type ArcObjectAny = ArcObject<any, any>;
 export type ArcObjectKeys<T extends ArcObjectAny> = T extends ArcObject<infer E, any> ? Exclude<keyof E, symbol> : never;
@@ -80,5 +81,9 @@ export declare function object<E extends ArcRawShape>(element: E): ArcObject<E,
     name: "schema";
     validator: (value: any) => false | { [key in keyof E]: ReturnType<E[key]["validate"]>; };
 }]>;
+export type ArcObjectMerge<A extends ArcObjectAny, B extends ArcObjectAny> = [A, B] extends [
+    ArcObject<infer AShape, infer AValidators>,
+    ArcObject<infer BShape, infer BValidators>
+] ? ArcObject<AShape & BShape, [...AValidators, ...BValidators]> : never;
 export {};
 //# sourceMappingURL=object.d.ts.map

package/dist/elements/optional.d.ts

@@ -8,6 +8,9 @@ export declare class ArcOptional<E extends ArcElement> implements ArcElement {
     serialize(value: util.FirstArgument<E["serialize"]> | null | undefined): ReturnType<E["serialize"]> | null;
     deserialize(value: util.FirstArgument<E["deserialize"]> | null | undefined): ReturnType<E["deserialize"]> | null;
     validate(value: unknown): unknown;
+    toJsonSchema(): {
+        anyOf: any[];
+    };
 }
 export type ArcOptionalAny = ArcOptional<ArcAbstractAny>;
 //# sourceMappingURL=optional.d.ts.map

package/dist/elements/or.d.ts

@@ -1,2 +1,37 @@
-export {};
+import { type util } from "../utils";
+import type { ArcElement } from "./element";
+/**
+ * ArcOr allows you to create a union schema from existing Arc elements.
+ * The generic parameter keeps the type-information of every provided
+ * element which results in a **strongly-typed** union of all underlying
+ * element types.
+ */
+export declare class ArcOr<T extends ArcElement[]> implements ArcElement {
+    private readonly elements;
+    constructor(elements: T);
+    /**
+     * Serialises a union value using the first matching element.
+     */
+    serialize(value: util.FirstArgument<T[number]["serialize"]>): ReturnType<T[number]["serialize"]>;
+    /**
+     * Deserialises a raw value using the first element that validates it.
+     */
+    deserialize(value: util.FirstArgument<T[number]["deserialize"]>): ReturnType<T[number]["deserialize"]>;
+    /**
+     * Parses an input value using the first element that validates it.
+     */
+    parse(value: util.FirstArgument<T[number]["parse"]>): ReturnType<T[number]["parse"]>;
+    /**
+     * Runs validation on a value against **all** underlying elements.
+     * Succeeds (returns `false`) when at least one element validates the value.
+     * Otherwise returns a map of errors keyed by the element index.
+     */
+    validate(value: unknown): unknown;
+    toJsonSchema(): {
+        anyOf: any[];
+    };
+    private pickElement;
+    private isTypeOf;
+}
+export declare function or<T extends ArcElement[]>(...elements: T): ArcOr<T>;
 //# sourceMappingURL=or.d.ts.map

package/dist/elements/record.d.ts

@@ -19,6 +19,11 @@ export declare class ArcRecord<Key extends ArcKey, E extends ArcElement, V exten
     parse(value: Record<util.FirstArgument<Key["parse"]>, util.FirstArgument<E["parse"]>>): Record<ReturnType<Key["parse"]>, ReturnType<E["parse"]>>;
     serialize(value: Record<ReturnType<Key["serialize"]>, ReturnType<E["serialize"]>>): Record<ReturnType<Key["serialize"]>, ReturnType<E["serialize"]>>;
     deserialize(value: Record<ReturnType<Key["deserialize"]>, ReturnType<E["deserialize"]>>): Record<ReturnType<Key["deserialize"]>, ReturnType<E["deserialize"]>>;
+    toJsonSchema(): {
+        type: string;
+        propertyNames: any;
+        additionalProperties: any;
+    };
 }
 export type ArcRecordAny = ArcRecord<any, any>;
 export declare function record<Key extends ArcKey, E extends ArcElement>(key: Key, element: E): ArcRecord<Key, E, [{

package/dist/elements/string-enum.d.ts

@@ -13,6 +13,10 @@ export declare class ArcStringEnum<const T extends string[], V extends Validator
     parse<Value extends T[number]>(value: Value): Value;
     serialize<Value extends T[number]>(value: Value): Value;
     deserialize<Value extends T[number]>(value: Value): Value;
+    toJsonSchema(): {
+        readonly type: "string";
+        readonly enum: T;
+    };
     getEnumerators(): T;
 }
 export type ArcStringEnumAny = ArcStringEnum<any>;

package/dist/elements/string.d.ts

@@ -64,6 +64,9 @@ export declare class ArcString<V extends Validators = [typeof stringValidator]>
             currentEmail: string;
         } | undefined;
     }]>;
+    toJsonSchema(): {
+        type: string;
+    };
     url(): ArcString<[...V, {
         name: "url";
         validator: (value: string) => {

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export * from "./db";
 export * from "./elements";
 export * from "./listener";
 export * from "./model";
+export * from "./route";
 export * from "./rtc";
 export * from "./state";
 export * from "./utils";

package/dist/index.js

@@ -2,6 +2,7 @@
 class ArcContextElement {
   $event;
   name;
+  queryBuilder;
   commandContext;
   commandClient;
   observer;
@@ -36,6 +37,12 @@ class ArcOptional {
       return false;
     return this.parent.validate(value);
   }
+  toJsonSchema() {
+    const parentSchema = this.parent.toJsonSchema?.() ?? {};
+    return {
+      anyOf: [parentSchema, { type: "null" }]
+    };
+  }
 }
 
 // elements/branded.ts
@@ -61,6 +68,9 @@ class ArcBranded {
   validate(value) {
     return this.parent.validate(value);
   }
+  toJsonSchema() {
+    return this.parent.toJsonSchema?.() ?? {};
+  }
 }
 
 // elements/default.ts
@@ -93,6 +103,14 @@ class ArcDefault {
     } else
       return this.defaultValueOrCallback;
   }
+  toJsonSchema() {
+    const schema = this.parent.toJsonSchema?.() ?? {};
+    const defaultValue = typeof this.defaultValueOrCallback === "function" ? this.defaultValueOrCallback() : this.defaultValueOrCallback;
+    return {
+      ...schema,
+      default: defaultValue
+    };
+  }
 }
 
 // elements/abstract.ts
@@ -134,6 +152,9 @@ class ArcAbstract {
     newInstance.validations = [...this.validations, { name, validator }];
     return newInstance;
   }
+  toJsonSchema() {
+    return {};
+  }
   getValidations() {
     return this.validations;
   }
@@ -254,6 +275,9 @@ class ArcString extends ArcPrimitive {
       }
     });
   }
+  toJsonSchema() {
+    return { type: "string" };
+  }
   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) => {
@@ -314,6 +338,27 @@ function customId(name, createFn) {
   return new ArcCustomId(name, createFn);
 }
 
+// elements/any.ts
+class ArcAny extends ArcAbstract {
+  constructor() {
+    super([]);
+  }
+  parse(value) {
+    return value;
+  }
+  serialize(value) {
+    return value;
+  }
+  deserialize(value) {
+    return value;
+  }
+  toJsonSchema() {
+    return {};
+  }
+}
+function any() {
+  return new ArcAny;
+}
 // elements/object.ts
 var objectValidator = typeValidatorBuilder("object");
 
@@ -421,6 +466,23 @@ class ArcObject extends ArcAbstract {
   entries() {
     return Object.entries(this.rawShape);
   }
+  toJsonSchema() {
+    const properties = {};
+    const required = [];
+    for (const [key, element] of Object.entries(this.rawShape)) {
+      properties[key] = element.toJsonSchema?.() ?? {};
+      if (!(element instanceof ArcOptional)) {
+        required.push(key);
+      }
+    }
+    const schema = {
+      type: "object",
+      properties
+    };
+    if (required.length)
+      schema.required = required;
+    return schema;
+  }
 }
 function object(element) {
   return new ArcObject(element);
@@ -510,6 +572,12 @@ class ArcArray extends ArcAbstract {
     const instance = this.pipeValidation(name, validator);
     return instance;
   }
+  toJsonSchema() {
+    return {
+      type: "array",
+      items: this.parent.toJsonSchema?.() ?? {}
+    };
+  }
 }
 function array(element) {
   return new ArcArray(element);
@@ -601,6 +669,13 @@ class ArcBlob extends ArcPrimitive {
     }
     throw new Error("Expected Blob object");
   }
+  toJsonSchema() {
+    return {
+      type: "string",
+      contentEncoding: "base64",
+      contentMediaType: "application/octet-stream"
+    };
+  }
 }
 function blob() {
   return new ArcBlob;
@@ -619,6 +694,9 @@ class ArcBoolean extends ArcPrimitive {
     const instance = this.pipeValidation(name, validator);
     return instance;
   }
+  toJsonSchema() {
+    return { type: "boolean" };
+  }
 }
 function boolean() {
   return new ArcBoolean;
@@ -658,6 +736,12 @@ class ArcDate extends ArcAbstract {
     const instance = this.pipeValidation(name, validator);
     return instance;
   }
+  toJsonSchema() {
+    return {
+      type: "string",
+      format: "date-time"
+    };
+  }
 }
 function date() {
   return new ArcDate;
@@ -825,6 +909,13 @@ class ArcFile extends ArcPrimitive {
     }
     throw new Error("Expected File object");
   }
+  toJsonSchema() {
+    return {
+      type: "string",
+      contentEncoding: "base64",
+      contentMediaType: "application/octet-stream"
+    };
+  }
 }
 function file() {
   return new ArcFile;
@@ -852,10 +943,65 @@ class ArcNumber extends ArcPrimitive {
     const instance = this.pipeValidation(name, validator);
     return instance;
   }
+  toJsonSchema() {
+    return { type: "number" };
+  }
 }
 function number() {
   return new ArcNumber;
 }
+// elements/or.ts
+class ArcOr {
+  elements;
+  constructor(elements) {
+    this.elements = elements;
+  }
+  serialize(value) {
+    const element = this.pickElement(value);
+    return element.serialize(value);
+  }
+  deserialize(value) {
+    const element = this.pickElement(value);
+    return element.deserialize(value);
+  }
+  parse(value) {
+    const element = this.pickElement(value);
+    return element.parse(value);
+  }
+  validate(value) {
+    const errors = this.elements.reduce((acc, element, idx) => {
+      const err = element.validate(value);
+      if (err)
+        acc[idx] = err;
+      return acc;
+    }, {});
+    if (Object.keys(errors).length !== this.elements.length)
+      return false;
+    return errors;
+  }
+  toJsonSchema() {
+    return {
+      anyOf: this.elements.map((el) => el.toJsonSchema?.() ?? {})
+    };
+  }
+  pickElement(value) {
+    for (const element of this.elements) {
+      if (this.isTypeOf(element, value))
+        return element;
+    }
+    throw new Error("Unable to match value with any of the provided elements for ArcOr");
+  }
+  isTypeOf(element, value) {
+    try {
+      return element.validate(value) === false;
+    } catch {
+      return false;
+    }
+  }
+}
+function or(...elements) {
+  return new ArcOr(elements);
+}
 // elements/record.ts
 class ArcRecord extends ArcAbstract {
   key;
@@ -906,6 +1052,13 @@ class ArcRecord extends ArcAbstract {
       return acc;
     }, {});
   }
+  toJsonSchema() {
+    return {
+      type: "object",
+      propertyNames: this.key.toJsonSchema?.() ?? {},
+      additionalProperties: this.element.toJsonSchema?.() ?? {}
+    };
+  }
 }
 function record(key, element) {
   return new ArcRecord(key, element);
@@ -935,6 +1088,12 @@ class ArcStringEnum extends ArcAbstract {
   deserialize(value) {
     return value;
   }
+  toJsonSchema() {
+    return {
+      type: "string",
+      enum: this.values
+    };
+  }
   getEnumerators() {
     return this.values;
   }
@@ -1114,7 +1273,7 @@ class ArcFindQuery extends ArcCollectionQuery {
   }
   onChange(change) {
     const lastResult = this.lastResult;
-    const lastResultAsArray = lastResult?.toArray() || [];
+    const lastResultAsArray = lastResult || [];
     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);
@@ -1304,6 +1463,16 @@ class ArcCommand extends ArcContextElement {
   get isPublic() {
     return this._isPublic;
   }
+  matchesCommandPath(pathname) {
+    if (!pathname.startsWith("/command/")) {
+      return { matches: false, isPublic: false };
+    }
+    const commandName = pathname.split("/command/")[1];
+    if (commandName === this.name) {
+      return { matches: true, isPublic: this._isPublic };
+    }
+    return { matches: false, isPublic: false };
+  }
   withParams(schema) {
     const clone = this.clone();
     clone._params = schema instanceof ArcObject ? schema : object(schema);
@@ -1335,6 +1504,18 @@ class ArcCommand extends ArcContextElement {
     clone._isPublic = this._isPublic;
     return clone;
   }
+  toJsonSchema() {
+    const parametersSchema = this._params ? this._params.toJsonSchema?.() ?? {
+      type: "object",
+      properties: {}
+    } : { type: "object", properties: {} };
+    return {
+      type: "function",
+      name: this.name,
+      description: this._description ?? undefined,
+      parameters: parametersSchema
+    };
+  }
 }
 function command(name) {
   return new ArcCommand(name);
@@ -1397,6 +1578,18 @@ class ArcContext {
         if (name === "$auth") {
           return authContext;
         }
+        if (name === "get") {
+          return (e) => {
+            const element3 = this.elements.find((element4) => element4.name === e.name);
+            if (!element3) {
+              throw new Error(`Element "${String(name)}" not found`);
+            }
+            if (!element3.commandContext) {
+              throw new Error(`Element "${String(name)}" does not have a command context`);
+            }
+            return element3.commandContext(dataStorage, publishEvent, authContext);
+          };
+        }
         const element2 = this.elements.find((element3) => element3.name === name);
         if (!element2) {
           throw new Error(`Element "${String(name)}" not found`);
@@ -1409,15 +1602,14 @@ class ArcContext {
     });
   }
 }
-async function context(elementsPromise) {
-  const elements = await Promise.all(elementsPromise.map(async (element2) => {
-    if (element2 instanceof Promise) {
-      return (await element2).default;
-    }
-    return element2;
-  })).then((elements2) => elements2.filter(Boolean));
+function context(elements) {
   return new ArcContext(elements);
 }
+function contextMerge(...contexts) {
+  return new ArcContext([
+    ...contexts.map((context2) => context2.elements).flat()
+  ]);
+}
 // context/event.ts
 var eventValidator = typeValidatorBuilder("object");
 var eventStoreSchema = {
@@ -1496,7 +1688,7 @@ class ArcEvent extends ArcContextElementWithStore {
           id: eventId.generate(),
           type: this.name,
           payload,
-          createdAt: new Date().toISOString()
+          createdAt: new Date
         };
         await dataStorage.getStore("events").set(event);
         await publishEvent(event);
@@ -2342,6 +2534,18 @@ class ArcListener extends ArcContextElement {
               if (name === "$auth") {
                 return authContext;
               }
+              if (name === "get") {
+                return (e) => {
+                  const element4 = this._elements.find((element5) => element5.name === e.name);
+                  if (!element4) {
+                    throw new Error(`Element "${String(name)}" not found in listener "${this.name}"`);
+                  }
+                  if (!element4.commandContext) {
+                    throw new Error(`Element "${String(name)}" does not have a command context`);
+                  }
+                  return element4.commandContext(dataStorage, publishEvent, authContext);
+                };
+              }
               const element3 = this._elements.find((element4) => element4.name === name);
               if (!element3) {
                 throw new Error(`Element "${String(name)}" not found in listener "${this.name}"`);
@@ -2495,6 +2699,40 @@ class Model extends ModelBase {
       }
     });
   }
+  routes(authContext) {
+    return new Proxy({}, {
+      get: (_, name) => {
+        const element3 = this.context.elements.find((element4) => element4.name === name);
+        if (!element3) {
+          throw new Error(`Route element "${String(name)}" not found`);
+        }
+        if (typeof element3.getHandler !== "function") {
+          throw new Error(`Element "${String(name)}" does not have route handlers`);
+        }
+        return async (method, req, routeParams, url) => {
+          const handler = element3.getHandler(method);
+          if (!handler) {
+            throw new Error(`Method ${method} not allowed for route ${String(name)}`);
+          }
+          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 handler(commandContext, req, routeParams, url);
+            await forkedDataStorage.merge();
+            eventPublisher.runAsyncListeners();
+            return result;
+          } catch (error) {
+            this.catchErrorCallback(error);
+            throw error;
+          }
+        };
+      }
+    });
+  }
   get $debug() {
     return {};
   }
@@ -2643,14 +2881,16 @@ class RemoteModelClient extends ModelBase {
     if (!response.ok) {
       throw new Error(`Query failed: ${response.statusText}`);
     }
-    const { result } = await response.json();
-    return result;
+    return await response.json();
   }
   subscribe(queryBuilderFn, callback, authContext) {
     const result = this.query(queryBuilderFn, authContext);
     result.then((initialResult) => {
       callback(initialResult);
-    }).catch(this.catchErrorCallback);
+    }).catch((error) => {
+      console.error("Error in subscribe", error);
+      callback(null);
+    });
     return {
       unsubscribe: () => {},
       result
@@ -2688,6 +2928,95 @@ class RemoteModelClient extends ModelBase {
     });
     return commandsProxy;
   }
+  routes(authContext) {
+    throw new Error("Remote model client does not support route execution");
+  }
+}
+// route/route.ts
+class ArcRoute extends ArcContextElement {
+  name;
+  _description;
+  _path;
+  _elements;
+  _handlers;
+  _isPublic = false;
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  use(elements) {
+    const clone = this.clone();
+    clone._elements = elements;
+    return clone;
+  }
+  description(description) {
+    const clone = this.clone();
+    clone._description = description;
+    return clone;
+  }
+  path(path) {
+    const clone = this.clone();
+    clone._path = path;
+    return clone;
+  }
+  public() {
+    const clone = this.clone();
+    clone._isPublic = true;
+    return clone;
+  }
+  get isPublic() {
+    return this._isPublic;
+  }
+  get routePath() {
+    return this._path || `/${this.name}`;
+  }
+  handle(handlers) {
+    const clone = this.clone();
+    clone._handlers = handlers;
+    return clone;
+  }
+  getHandler(method) {
+    return this._handlers?.[method];
+  }
+  matchesPath(pathname) {
+    const routePath = this.routePath;
+    const routeParts = routePath.split("/").filter(Boolean);
+    const pathParts = pathname.split("/").filter(Boolean);
+    if (routeParts.length !== pathParts.length) {
+      return { matches: false, params: {} };
+    }
+    const params = {};
+    for (let i = 0;i < routeParts.length; i++) {
+      const routePart = routeParts[i];
+      const pathPart = pathParts[i];
+      if (routePart.startsWith(":")) {
+        const paramName = routePart.slice(1);
+        params[paramName] = pathPart;
+      } else if (routePart !== pathPart) {
+        return { matches: false, params: {} };
+      }
+    }
+    return { matches: true, params };
+  }
+  matchesRoutePath(pathname) {
+    const { matches, params } = this.matchesPath(pathname);
+    if (matches) {
+      return { matches: true, isPublic: this._isPublic, params };
+    }
+    return { matches: false, isPublic: false };
+  }
+  clone() {
+    const clone = new ArcRoute(this.name);
+    clone._description = this._description;
+    clone._path = this._path;
+    clone._handlers = this._handlers;
+    clone._elements = this._elements;
+    clone._isPublic = this._isPublic;
+    return clone;
+  }
+}
+function route(name) {
+  return new ArcRoute(name);
 }
 // rtc/client.ts
 class RTCClient {
@@ -2795,22 +3124,6 @@ class ArcViewQuery extends ArcSerializableQuery {
 }
 
 // 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) {
@@ -2857,7 +3170,7 @@ class ArcViewFindQuery extends ArcViewQuery {
   }
   onChange(change) {
     const lastResult = this.lastResult;
-    const lastResultAsArray = lastResult?.toArray() || [];
+    const lastResultAsArray = lastResult || [];
     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);
@@ -2870,7 +3183,7 @@ class ArcViewFindQuery extends ArcViewQuery {
     return false;
   }
   createResult(result) {
-    return new QueryViewResult(result);
+    return result;
   }
 }
 
@@ -2896,19 +3209,6 @@ class ArcViewFindQueryBuilder {
 }
 
 // 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) {
@@ -2955,7 +3255,7 @@ class ArcViewFindOneQuery extends ArcViewQuery {
   }
   onChange(change) {
     const lastResult = this.lastResult;
-    const currentItem = lastResult?.get();
+    const currentItem = lastResult;
     const itemId = change.type === "delete" ? change.id : change.id;
     const hasCurrentItem = currentItem !== undefined;
     const isCurrentItem = hasCurrentItem && currentItem._id === itemId;
@@ -2969,7 +3269,7 @@ class ArcViewFindOneQuery extends ArcViewQuery {
     return false;
   }
   createResult(result) {
-    return new QueryViewFindOneResult(result);
+    return result;
   }
 }
 
@@ -3038,6 +3338,14 @@ class ArcView extends ArcContextElementWithStore {
     clone._handler = handler;
     return clone;
   }
+  handleEvent(event3, handler) {
+    const clone = this.clone();
+    clone._handler = {
+      ...clone._handler ?? {},
+      [event3.name]: handler
+    };
+    return clone;
+  }
   applyRestrictions(authContext, options) {
     if (!this.restrictions) {
       return options;
@@ -3157,8 +3465,10 @@ export {
   stringEnum,
   string,
   rtcClientFactory,
+  route,
   record,
   reactive,
+  or,
   object,
   number,
   listener,
@@ -3169,12 +3479,15 @@ export {
   date,
   customId,
   createSQLiteAdapterFactory,
+  contextMerge,
   context,
   command,
   collection,
   boolean,
   blob,
   array,
+  arcObjectToStoreSchema,
+  any,
   StoreState,
   SQLiteAdapter,
   RemoteModelClient,
@@ -3190,9 +3503,11 @@ export {
   ArcView,
   ArcStringEnum,
   ArcString,
+  ArcRoute,
   ArcRecord,
   ArcQueryBuilder,
   ArcQuery,
+  ArcOr,
   ArcOptional,
   ArcObject,
   ArcNumber,
@@ -3211,5 +3526,6 @@ export {
   ArcBranded,
   ArcBoolean,
   ArcBlob,
-  ArcArray
+  ArcArray,
+  ArcAny
 };

package/dist/model/model.d.ts

@@ -15,6 +15,7 @@ export declare abstract class ModelBase<C extends ArcContextAny> {
         unsubscribe: () => void;
     };
     abstract commands(authContext: AuthContext): ArcContextElementMethodReturnType<C["elements"], "commandClient">;
+    abstract routes(authContext: AuthContext): any;
 }
 export declare class Model<C extends ArcContextAny> extends ModelBase<C> {
     private readonly context;
@@ -28,6 +29,7 @@ export declare class Model<C extends ArcContextAny> extends ModelBase<C> {
         unsubscribe: () => void;
     };
     commands(authContext: AuthContext): ArcContextElementMethodReturnType<C["elements"], "commandClient">;
+    routes(authContext: AuthContext): any;
     get $debug(): {};
 }
 export declare class RemoteModelClient<C extends ArcContextAny> extends ModelBase<C> {
@@ -62,6 +64,7 @@ export declare class RemoteModelClient<C extends ArcContextAny> extends ModelBas
         unsubscribe: () => void;
     };
     commands(authContext: AuthContext): ArcContextElementMethodReturnType<C["elements"], "commandClient">;
+    routes(authContext: AuthContext): any;
 }
 export {};
 //# sourceMappingURL=model.d.ts.map

package/dist/route/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./route";
+//# sourceMappingURL=index.d.ts.map

package/dist/route/route.d.ts

@@ -0,0 +1,35 @@
+import type { ArcCommandContext } from "../context";
+import { ArcContextElement, type ArcContextElementAny } from "../context/element";
+export type ArcRouteHandler<ContextElements extends ArcContextElementAny[]> = (ctx: ArcCommandContext<ContextElements>, request: Request, params: Record<string, string>, url: URL) => Promise<Response> | Response;
+export type ArcRouteHandlers<ContextElements extends ArcContextElementAny[]> = {
+    [Method in "GET" | "POST" | "PUT" | "DELETE" | "PATCH"]?: ArcRouteHandler<ContextElements>;
+};
+export declare class ArcRoute<Name extends string, const Elements extends ArcContextElementAny[]> extends ArcContextElement<null, Name> {
+    readonly name: Name;
+    private _description?;
+    private _path?;
+    private _elements?;
+    private _handlers?;
+    private _isPublic;
+    constructor(name: Name);
+    use<const E extends ArcContextElementAny[]>(elements: E): ArcRoute<Name, E>;
+    description(description: string): ArcRoute<Name, Elements>;
+    path(path: string): ArcRoute<Name, Elements>;
+    public(): ArcRoute<Name, Elements>;
+    get isPublic(): boolean;
+    get routePath(): string;
+    handle(handlers: ArcRouteHandlers<Elements>): ArcRoute<Name, Elements>;
+    getHandler(method: string): ArcRouteHandler<Elements> | undefined;
+    matchesPath(pathname: string): {
+        matches: boolean;
+        params: Record<string, string>;
+    };
+    matchesRoutePath(pathname: string): {
+        matches: boolean;
+        isPublic: boolean;
+        params?: Record<string, string>;
+    };
+    private clone;
+}
+export declare function route<Name extends string>(name: Name): ArcRoute<Name, any[]>;
+//# sourceMappingURL=route.d.ts.map

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./arcObjectToStoreSchema";
+//# sourceMappingURL=index.d.ts.map

package/dist/utils.d.ts

@@ -1,6 +1,7 @@
 import type { ArcCollectionAny, CollectionItem } from "./collection/collection";
 import type { QueryCollectionResult } from "./collection/queries/find";
 import type { ArcElement } from "./elements/element";
+export * from "./utils/index";
 export declare namespace objectUtil {
     export type MergeShapes<U, V> = {
         [k in Exclude<keyof U, keyof V>]: U[k];

package/dist/view/queries/find-one.d.ts

@@ -1,18 +1,12 @@
 import type { ListenerEvent, StoreState } from "../../data-storage";
 import type { FindOptions } from "../../data-storage/types";
 import { ArcViewQuery, type ArcViewAny, type ArcViewItem } from "./abstract-view-query";
-export declare class QueryViewFindOneResult<V extends ArcViewAny> {
-    private result;
-    constructor(result: ArcViewItem<V["id"], V["schema"]> | undefined);
-    get(): ArcViewItem<V["id"], V["schema"]> | undefined;
-    exists(): boolean;
-}
-export declare class ArcViewFindOneQuery<View extends ArcViewAny> extends ArcViewQuery<View, QueryViewFindOneResult<View>, FindOptions<ArcViewItem<View["id"], View["schema"]>>> {
+export declare class ArcViewFindOneQuery<View extends ArcViewAny> extends ArcViewQuery<View, ArcViewItem<View["id"], View["schema"]> | undefined, FindOptions<ArcViewItem<View["id"], View["schema"]>>> {
     protected params: FindOptions<ArcViewItem<View["id"], View["schema"]>>;
     constructor(view: View, params: FindOptions<ArcViewItem<View["id"], View["schema"]>>);
-    protected fetch(store: StoreState<ArcViewItem<View["id"], View["schema"]>>): Promise<QueryViewFindOneResult<View>>;
+    protected fetch(store: StoreState<ArcViewItem<View["id"], View["schema"]>>): Promise<ArcViewItem<View["id"], View["schema"]> | undefined>;
     protected checkItem(item: ArcViewItem<View["id"], View["schema"]>): boolean;
-    protected onChange(change: ListenerEvent<ArcViewItem<View["id"], View["schema"]>>): false | QueryViewFindOneResult<View>;
-    protected createResult(result: ArcViewItem<View["id"], View["schema"]> | undefined): QueryViewFindOneResult<View>;
+    protected onChange(change: ListenerEvent<ArcViewItem<View["id"], View["schema"]>>): false | ArcViewItem<View["id"], View["schema"]> | undefined;
+    protected createResult(result: ArcViewItem<View["id"], View["schema"]> | undefined): ArcViewItem<View["id"], View["schema"]> | undefined;
 }
 //# sourceMappingURL=find-one.d.ts.map

package/dist/view/queries/find.d.ts

@@ -9,12 +9,12 @@ export declare class QueryViewResult<V extends ArcViewAny> {
     map<U>(callbackfn: (value: ArcViewItem<V["id"], V["schema"]>, index: number, array: ArcViewItem<V["id"], V["schema"]>[]) => U): U[];
     toArray(): ArcViewItem<V["id"], V["schema"]>[];
 }
-export declare class ArcViewFindQuery<View extends ArcViewAny> extends ArcViewQuery<View, QueryViewResult<View>, FindOptions<ArcViewItem<View["id"], View["schema"]>>> {
+export declare class ArcViewFindQuery<View extends ArcViewAny> extends ArcViewQuery<View, ArcViewItem<View["id"], View["schema"]>[], FindOptions<ArcViewItem<View["id"], View["schema"]>>> {
     protected params: FindOptions<ArcViewItem<View["id"], View["schema"]>>;
     constructor(view: View, params: FindOptions<ArcViewItem<View["id"], View["schema"]>>);
-    protected fetch(store: StoreState<ArcViewItem<View["id"], View["schema"]>>): Promise<QueryViewResult<View>>;
+    protected fetch(store: StoreState<ArcViewItem<View["id"], View["schema"]>>): Promise<ArcViewItem<View["id"], View["schema"]>[]>;
     protected checkItem(item: ArcViewItem<View["id"], View["schema"]>): boolean;
-    protected onChange(change: ListenerEvent<ArcViewItem<View["id"], View["schema"]>>): false | QueryViewResult<View>;
-    protected createResult(result: ArcViewItem<View["id"], View["schema"]>[]): QueryViewResult<View>;
+    protected onChange(change: ListenerEvent<ArcViewItem<View["id"], View["schema"]>>): false | ArcViewItem<View["id"], View["schema"]>[];
+    protected createResult(result: ArcViewItem<View["id"], View["schema"]>[]): ArcViewItem<View["id"], View["schema"]>[];
 }
 //# sourceMappingURL=find.d.ts.map

package/dist/view/query-builders/find-one.d.ts

@@ -7,7 +7,7 @@ export declare class ArcViewFindOneQueryBuilder<V extends ArcViewAny> {
     protected queryContext: QueryBuilderContext;
     protected options: FindOptions<ArcViewItem<V["id"], V["schema"]>>;
     constructor(view: V, queryContext: QueryBuilderContext, options: FindOptions<ArcViewItem<V["id"], V["schema"]>>);
-    toQuery(): ArcViewFindOneQuery<ArcViewAny>;
-    run(): import("../queries/find-one").QueryViewFindOneResult<ArcViewAny>;
+    toQuery(): ArcViewFindOneQuery<V>;
+    run(): ArcViewItem<V["id"], V["schema"]> | undefined;
 }
 //# sourceMappingURL=find-one.d.ts.map

package/dist/view/query-builders/find.d.ts

@@ -7,7 +7,7 @@ export declare class ArcViewFindQueryBuilder<V extends ArcViewAny> {
     protected queryContext: QueryBuilderContext;
     protected options: FindOptions<ArcViewItem<V["id"], V["schema"]>>;
     constructor(view: V, queryContext: QueryBuilderContext, options: FindOptions<ArcViewItem<V["id"], V["schema"]>>);
-    toQuery(): ArcViewFindQuery<ArcViewAny>;
-    run(): import("..").QueryViewResult<ArcViewAny>;
+    toQuery(): ArcViewFindQuery<V>;
+    run(): ArcViewItem<V["id"], V["schema"]>[];
 }
 //# sourceMappingURL=find.d.ts.map

package/dist/view/view.d.ts

@@ -1,9 +1,10 @@
+import type { ArcEventAny, ArcEventInstance } from "../context";
 import { ArcContextElementWithStore, type ArcContextElementAny, type AuthContext, type ListenerConfig, type PublishEventFunction, type StoreSchema } from "../context/element";
 import type { QueryBuilderContext } from "../context/query-builder-context";
 import type { DataStorage } from "../data-storage";
 import type { FindOptions, WhereCondition } from "../data-storage/types";
 import { type ArcIdAny, type ArcObjectAny } from "../elements";
-import type { $type } from "../utils";
+import type { $type, objectUtil } from "../utils";
 import { ArcViewFindQueryBuilder } from "./query-builders/find";
 import { ArcViewFindOneQueryBuilder } from "./query-builders/find-one";
 type GetEvents<Elements extends ArcContextElementAny[]> = Elements[number]["$event"];
@@ -19,8 +20,9 @@ type ArcViewItem<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
     _id: $type<Id>;
 } & $type<Schema>;
 type ArcViewHandler<Elements extends ArcContextElementAny[], Id extends ArcIdAny, Schema extends ArcObjectAny> = {
-    [Event in GetEvents<Elements> as Event["type"]]: (ctx: ArcViewHandlerContext<Id, Schema>, event: Event) => Promise<void>;
+    [Event in GetEvents<Elements> as Event["type"]]: ArcViewEventHandler<Id, Schema, Event>;
 };
+type ArcViewEventHandler<Id extends ArcIdAny, Schema extends ArcObjectAny, Event extends any> = (ctx: ArcViewHandlerContext<Id, Schema>, event: Event) => Promise<void>;
 export declare class ArcView<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny, const Elements extends ArcContextElementAny[]> extends ArcContextElementWithStore<null, Name> {
     readonly name: Name;
     readonly id: Id;
@@ -41,6 +43,7 @@ export declare class ArcView<Name extends string, Id extends ArcIdAny, Schema ex
     description(description: string): ArcView<Name, Id, Schema, Elements>;
     async(): ArcView<Name, Id, Schema, Elements>;
     handle<Handler extends ArcViewHandler<Elements, Id, Schema>>(handler: Handler): ArcView<Name, Id, Schema, Elements>;
+    handleEvent<Event extends ArcEventAny>(event: Event, handler: ArcViewEventHandler<Id, Schema, ArcEventInstance<Event>>): ArcView<Name, Id, Schema, [...Elements, Event]>;
     /**
      * Helper function to merge where conditions from restrictions with query options
      */
@@ -57,5 +60,6 @@ export declare class ArcView<Name extends string, Id extends ArcIdAny, Schema ex
     private clone;
 }
 export declare function view<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny>(name: Name, id: Id, schema: Schema): ArcView<Name, Id, Schema, any[]>;
+export type ArcViewRecord<View extends ArcView<any, any, any, any>> = objectUtil.simplify<ArcViewItem<View["id"], View["schema"]>>;
 export {};
 //# sourceMappingURL=view.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc",
   "type": "module",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "Arc is a framework designed to align code closely with business logic, streamlining development and enhancing productivity.",