@arcote.tech/arc 0.3.6 → 0.4.1

package/dist/context-element/aggregate/simple-aggregate.d.ts

@@ -0,0 +1,94 @@
+import type { ArcIdAny } from "../../elements/id";
+import type { ArcRawShape } from "../../elements/object";
+/**
+ * Create a simple CRUD aggregate with auto-generated upsert event and update method.
+ *
+ * Equivalent to manually calling:
+ *   aggregate(name, id, schema)
+ *     .publicEvent("updated", { id, ...schema }, upsertHandler)
+ *     .mutateMethod("update", { id, ...schema }, emitHandler)
+ *     .build()
+ *
+ * @example
+ * ```ts
+ * const Task = simpleAggregate("task", taskId, {
+ *   title: string(),
+ *   done: boolean(),
+ * });
+ * ```
+ */
+export declare function simpleAggregate<const Name extends string, Id extends ArcIdAny, SchemaShape extends ArcRawShape>(name: Name, id: Id, schema: SchemaShape): import("./aggregate-builder").AggregateConstructor<Name, Id, import("../..").ArcObject<SchemaShape, [{
+    name: "type";
+    validator: (value: any) => false | {
+        current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expected: "object";
+    };
+}, {
+    name: "schema";
+    validator: (value: any) => false | { [key in keyof SchemaShape]: ReturnType<SchemaShape[key]["validate"]>; };
+}]>, [import("./aggregate-data").AggregateEventEntry<import("..").ArcEvent<{
+    name: "updated";
+    payload: import("../..").ArcObject<{
+        [x: string]: ArcIdAny;
+    } & SchemaShape, [{
+        name: "type";
+        validator: (value: any) => false | {
+            current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+            expected: "object";
+        };
+    }, {
+        name: "schema";
+        validator: (value: any) => false | ({
+            [x: string]: ArcIdAny;
+        } & SchemaShape extends infer T ? { [key in keyof T]: ReturnType<T[key]["validate"]>; } : never);
+    }]>;
+    protections: [];
+}>, Id, import("../..").ArcObject<SchemaShape, [{
+    name: "type";
+    validator: (value: any) => false | {
+        current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expected: "object";
+    };
+}, {
+    name: "schema";
+    validator: (value: any) => false | { [key in keyof SchemaShape]: ReturnType<SchemaShape[key]["validate"]>; };
+}]>, true>], [{
+    name: "update";
+    params: import("../..").ArcObject<{
+        [x: string]: ArcIdAny;
+    } & SchemaShape, [{
+        name: "type";
+        validator: (value: any) => false | {
+            current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+            expected: "object";
+        };
+    }, {
+        name: "schema";
+        validator: (value: any) => false | ({
+            [x: string]: ArcIdAny;
+        } & SchemaShape extends infer T ? { [key in keyof T]: ReturnType<T[key]["validate"]>; } : never);
+    }]>;
+    handler: false | ((ctx: {
+        updated: {
+            emit: (payload: {
+                [x: string]: ArcIdAny;
+            } & SchemaShape extends infer T extends ArcRawShape ? { [key in keyof T]: ReturnType<T[key]["deserialize"]>; } : never) => Promise<void>;
+        };
+    } & {
+        $auth: {
+            params: any;
+            tokenName: string;
+        };
+        $query: {
+            find: (options?: any) => Promise<({ [key in keyof SchemaShape]: ReturnType<SchemaShape[key]["deserialize"]>; } & {
+                _id: ReturnType<Id["deserialize"]>;
+            })[]>;
+            findOne: (where?: any) => Promise<({ [key in keyof SchemaShape]: ReturnType<SchemaShape[key]["deserialize"]>; } & {
+                _id: ReturnType<Id["deserialize"]>;
+            }) | undefined>;
+        };
+    }, params: {
+        [x: string]: ArcIdAny;
+    } & SchemaShape extends infer T extends ArcRawShape ? { [key in keyof T]: ReturnType<T[key]["deserialize"]>; } : never) => Promise<any>);
+}]>;
+//# sourceMappingURL=simple-aggregate.d.ts.map

package/dist/context-element/command/command-context.d.ts

@@ -1,23 +1,8 @@
 import type { ArcToken, ArcTokenAny } from "../../token/token";
 import type { $type } from "../../utils/types/get-type";
 import type { ArcContextElement } from "../context-element";
+import type { ElementContext } from "../element-context";
 import type { CommandProtection } from "./command-data";
-/**
- * Build context object from query elements
- * Each element gets its context by calling element.queryContext(adapters)
- * Only includes elements that have queryContext method
- */
-type QueryContext<Elements extends ArcContextElement<any>[]> = {
-    [K in Elements[number] as K["queryContext"] extends (...args: any) => any ? K["name"] : never]: K["queryContext"] extends (...args: any) => infer R ? R : never;
-};
-/**
- * Build context object from mutation elements
- * Each element gets its context by calling element.mutateContext(adapters)
- * Only includes elements that have mutateContext method
- */
-type MutationContext<Elements extends ArcContextElement<any>[]> = {
-    [K in Elements[number] as K["mutateContext"] extends (...args: any) => any ? K["name"] : never]: K["mutateContext"] extends (...args: any) => infer R ? R : never;
-};
 /**
  * Extract token params type from a token
  */
@@ -38,25 +23,11 @@ export type AuthContext<T extends ArcTokenAny> = {
  * Extract union of all token types from protections array
  */
 type ProtectionTokens<Protections extends CommandProtection[]> = Protections[number]["token"];
-/**
- * Get function type for backward compatibility
- * Allows: ctx.get(view).findOne() or ctx.get(event).emit()
- * Returns any for flexibility - the runtime will provide the correct context
- */
-type GetFunction<_QueryElements extends ArcContextElement<any>[], _MutationElements extends ArcContextElement<any>[]> = {
-    get: <T extends ArcContextElement<any>>(element: T) => any;
-};
 /**
  * Command context provided to command handlers
- * Combines query and mutation contexts from all elements
- *
- * Each element is accessible by its name:
- * - Query elements: ctx.myView.findOne(...)
- * - Mutation elements: ctx.myEvent.emit(...)
- * - Auth context: ctx.$auth.params (only for protected commands)
- * - Get function: ctx.get(element) for backward compatibility
+ * Extends shared ElementContext with command-specific $auth support.
  */
-export type ArcCommandContext<QueryElements extends ArcContextElement<any>[], MutationElements extends ArcContextElement<any>[], Protections extends CommandProtection[] = []> = QueryContext<QueryElements> & MutationContext<MutationElements> & GetFunction<QueryElements, MutationElements> & (Protections extends [] ? object : {
+export type ArcCommandContext<QueryElements extends ArcContextElement<any>[], MutationElements extends ArcContextElement<any>[], Protections extends CommandProtection[] = []> = ElementContext<QueryElements, MutationElements> & (Protections extends [] ? object : {
     $auth: AuthContext<ProtectionTokens<Protections>>;
 });
 /**

package/dist/context-element/context-element.d.ts

@@ -3,8 +3,12 @@
  *
  * Every element in Arc (command, event, view, listener) extends this base class.
  * Elements provide type-safe access to their functionality through the context system.
+ *
+ * ArcContextElement extends ArcFragmentBase — context elements ARE fragments,
+ * enabling unified fragment-based registration in modules.
  */
 import type { ModelAdapters } from "../model/model-adapters";
+import { ArcFragmentBase } from "../fragment/arc-fragment";
 export type ArcEnvironment = "client" | "server" | "universal";
 /**
  * Base class for all Arc context elements
@@ -20,12 +24,14 @@ export type ArcEnvironment = "client" | "server" | "universal";
  * 2. Its context generation logic
  * 3. Its handler/logic
  */
-export declare abstract class ArcContextElement<const Name extends string> {
+export declare abstract class ArcContextElement<const Name extends string> extends ArcFragmentBase {
     /**
      * Element name - used for identification and error messages
      * Must be unique within a context
      */
     readonly name: Name;
+    readonly types: readonly ["context-element"];
+    get id(): string;
     constructor(name: Name);
     /**
      * Initialize element in the given environment

package/dist/context-element/element-context.d.ts

@@ -0,0 +1,39 @@
+import type { ModelAdapters } from "../model/model-adapters";
+import type { ArcContextElement } from "./context-element";
+/**
+ * Query context — maps element names to their queryContext return types.
+ * Uses key remapping to filter only elements that have queryContext.
+ */
+type QueryContext<Elements extends ArcContextElement<any>[]> = {
+    [K in Elements[number] as K["queryContext"] extends (...args: any) => any ? K["name"] : never]: K["queryContext"] extends (...args: any) => infer R ? R : never;
+};
+/**
+ * Mutation context — maps element names to their mutateContext return types.
+ * Uses key remapping to filter only elements that have mutateContext.
+ */
+type MutationContext<Elements extends ArcContextElement<any>[]> = {
+    [K in Elements[number] as K["mutateContext"] extends (...args: any) => any ? K["name"] : never]: K["mutateContext"] extends (...args: any) => infer R ? R : never;
+};
+/**
+ * Unified element context — shared between routes, commands, and any
+ * handler that needs typed access to query/mutation elements.
+ *
+ * Elements are accessible by name (ctx.myView, ctx.myAggregate) or
+ * by reference (ctx.query(element), ctx.mutate(element)).
+ */
+export type ElementContext<QueryElements extends ArcContextElement<any>[], MutationElements extends ArcContextElement<any>[]> = QueryContext<QueryElements> & MutationContext<MutationElements> & {
+    get: <T extends ArcContextElement<any>>(element: T) => any;
+    query: <T extends ArcContextElement<any>>(element: T) => T extends {
+        queryContext: (...args: any) => infer R;
+    } ? R : never;
+    mutate: <T extends ArcContextElement<any>>(element: T) => T extends {
+        mutateContext: (...args: any) => infer R;
+    } ? R : never;
+};
+/**
+ * Build element context at runtime.
+ * Shared implementation for routes, commands, etc.
+ */
+export declare function buildElementContext(queryElements: ArcContextElement<any>[], mutationElements: ArcContextElement<any>[], adapters: ModelAdapters): any;
+export {};
+//# sourceMappingURL=element-context.d.ts.map

package/dist/context-element/index.d.ts

@@ -3,8 +3,10 @@
  *
  * Provides dependency injection and element registration
  */
+export * from "./aggregate";
 export * from "./command";
 export * from "./context-element";
+export * from "./element-context";
 export * from "./event";
 export * from "./listener";
 export * from "./route";

package/dist/context-element/route/route.d.ts

@@ -3,31 +3,8 @@ import type { ArcTokenAny } from "../../token/token";
 import type { TokenInstanceAny } from "../../token/token-instance";
 import type { Merge } from "../../utils";
 import { ArcContextElement } from "../context-element";
+import { type ElementContext } from "../element-context";
 import type { ArcRouteData, HttpMethod, RouteHandler, RouteHandlers, RouteProtectionCheck } from "./route-data";
-/**
- * Route context passed to handlers
- */
-export type ArcRouteContext<QueryElements extends ArcContextElement<any>[], MutationElements extends ArcContextElement<any>[]> = {
-    [K in QueryElements[number]["name"]]: QueryElements[number] extends {
-        name: K;
-        queryContext: (...args: any[]) => infer R;
-    } ? R : never;
-} & {
-    [K in MutationElements[number]["name"]]: MutationElements[number] extends {
-        name: K;
-        mutateContext: (...args: any[]) => infer R;
-    } ? R : never;
-} & {
-    get: <T extends ArcContextElement<any>>(element: T) => T extends {
-        queryContext: (...args: any[]) => infer R;
-    } ? R : T extends {
-        mutateContext: (...args: any[]) => infer R;
-    } ? R : never;
-    $auth?: {
-        params: Record<string, any>;
-        tokenName: string;
-    };
-};
 /**
  * Arc Route - Custom HTTP endpoint handler
  *
@@ -96,7 +73,12 @@ export declare class ArcRoute<const Data extends ArcRouteData> extends ArcContex
     /**
      * Set route handlers for HTTP methods
      */
-    handle<Handlers extends RouteHandlers<ArcRouteContext<Data["queryElements"], Data["mutationElements"]>>>(handlers: Handlers): ArcRoute<Merge<Data, {
+    handle<Handlers extends RouteHandlers<ElementContext<Data["queryElements"], Data["mutationElements"]> & {
+        $auth?: {
+            params: Record<string, any>;
+            tokenName: string;
+        };
+    }>>(handlers: Handlers): ArcRoute<Merge<Data, {
         handlers: Handlers;
     }>>;
     /**
@@ -141,7 +123,7 @@ export declare class ArcRoute<const Data extends ArcRouteData> extends ArcContex
     buildContext(adapters: ModelAdapters, authParams?: {
         params: Record<string, any>;
         tokenName: string;
-    }): ArcRouteContext<Data["queryElements"], Data["mutationElements"]>;
+    }): any;
 }
 /**
  * Create a new route with the given name

package/dist/context-element/static-view/static-view.d.ts

@@ -104,7 +104,7 @@ export declare class ArcStaticView<const Data extends ArcStaticViewData> extends
 export declare function staticView<const Name extends string, Id, Schema extends ArcObjectAny | ArcRawShape>(name: Name, id: Id, schema: Schema): ArcStaticView<{
     name: Name;
     id: Id;
-    schema: (Schema & ArcObject<any, any>) | ArcObject<ArcRawShape, [{
+    schema: ArcObject<ArcRawShape, [{
         name: "type";
         validator: (value: any) => false | {
             current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
@@ -115,7 +115,7 @@ export declare function staticView<const Name extends string, Id, Schema extends
         validator: (value: any) => false | {
             [x: string]: unknown;
         };
-    }]>;
+    }]> | (Schema & ArcObject<any, any>);
     items: [];
 }>;
 /**

package/dist/context-element/view/index.d.ts

@@ -1,5 +1,5 @@
 export { ArcView, view, type ArcViewAny, type ArcViewRecord } from "./view";
-export type { ArcViewData } from "./view-data";
+export type { ArcViewData, ViewProtection, ViewProtectionFn } from "./view-data";
 export type { ArcViewHandlerContext, ArcViewItem, ArcViewQueryContext, } from "./view-context";
 export type { ArcObjectAny } from "../../elements/object";
 //# sourceMappingURL=index.d.ts.map

package/dist/data-storage/store-state.abstract.d.ts

@@ -30,6 +30,7 @@ export declare abstract class StoreState<Item extends {
         from: Item | null;
         to: Item | null;
     }[]>;
+    get listenerCount(): number;
     unsubscribe(listener: QueryListenerCallback<Item>): void;
     protected notifyListeners(events: ListenerEvent<Item>[]): void;
 }

package/dist/elements/branded.d.ts

@@ -7,6 +7,7 @@ export declare class ArcBranded<E extends ArcAbstractAny, Brand extends string |
     private parent;
     private brand;
     constructor(parent: E, brand: Brand);
+    get name(): Brand;
     serialize(value: FirstArgument<E["serialize"]> & {
         __brand: Brand;
     }): ReturnType<E["serialize"]>;

package/dist/elements/object.d.ts

@@ -37,9 +37,9 @@ export declare class ArcObject<E extends ArcRawShape, V extends Validators = [
     };
     deserialize(value: AddQuestionMarks<{
         [key in keyof E]: FirstArgument<E[key]["deserialize"]>;
-    }>): {
+    }>): AddQuestionMarks<{
         [key in keyof E]: ReturnType<E[key]["deserialize"]>;
-    };
+    }>;
     deserializePath(path: string[], value: any): any;
     parsePartial(value: Partial<{
         [key in keyof E]: FirstArgument<E[key]["parse"]>;

package/dist/elements/optional.d.ts

@@ -7,7 +7,7 @@ export declare class ArcOptional<E extends ArcElement> implements ArcElement {
     constructor(parent: E);
     parse(value: FirstArgument<E["parse"]> | null | undefined): ReturnType<E["parse"]> | null;
     serialize(value: FirstArgument<E["serialize"]> | null | undefined): ReturnType<E["serialize"]> | null;
-    deserialize(value: FirstArgument<E["deserialize"]> | null | undefined): ReturnType<E["deserialize"]> | null;
+    deserialize(value: FirstArgument<E["deserialize"]> | undefined): ReturnType<E["deserialize"]> | undefined;
     validate(value: unknown): unknown;
     toJsonSchema(): {
         anyOf: any[];

package/dist/fragment/arc-fragment.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ArcFragmentBase — abstract base class for all Arc fragments.
+ *
+ * Every element in Arc (context element, page, wrapper, slot) extends this class.
+ * Fragments declare their types as a list, enabling type-based filtering
+ * without a closed enum — the type system is extensible.
+ *
+ * Usage:
+ *   fragment.is("context-element")  // check single type
+ *   fragment.is("page")             // check single type
+ *   fragments.filter(f => f.is("context-element"))  // filter by type
+ */
+export declare abstract class ArcFragmentBase {
+    abstract readonly id: string;
+    abstract readonly types: readonly string[];
+    is(type: string): boolean;
+}
+//# sourceMappingURL=arc-fragment.d.ts.map

package/dist/fragment/index.d.ts

@@ -0,0 +1,2 @@
+export { ArcFragmentBase } from "./arc-fragment";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts

@@ -8,8 +8,24 @@ export * from "./context";
 export * from "./context-element";
 export * from "./data-storage";
 export * from "./elements";
+export * from "./fragment";
 export * from "./model";
 export * from "./streaming";
 export * from "./token";
 export * from "./utils";
+/**
+ * ONLY_CLIENT — global constant for tree shaking.
+ *
+ * Set via Bun/bundler define plugin:
+ *   define: { ONLY_CLIENT: "true" }   // client build
+ *   define: { ONLY_CLIENT: "false" }  // server build
+ *
+ * Usage in aggregate classes (use function() to preserve this):
+ *   toBadge = ONLY_CLIENT && function(this: Task) {
+ *     return <Badge>{this.value.title}</Badge>;
+ *   }
+ */
+declare global {
+    var ONLY_CLIENT: boolean;
+}
 //# sourceMappingURL=index.d.ts.map