@arcote.tech/arc 0.4.10 → 0.5.0

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

@@ -6,22 +6,17 @@
  */
 import type { ArcIdAny } from "../../elements/id";
 import type { ArcObjectAny } from "../../elements/object";
-import type { ArcEventAny } from "../event/event";
 import type { Simplify } from "../../utils";
+import type { ArcEventAny } from "../event/event";
 import type { ArcEventInstance } from "../event/instance";
 import type { ArcViewHandlerContext } from "../view/view-context";
 import type { ViewProtection } from "../view/view-data";
 /**
  * Handler for an aggregate event — same signature as ArcView handler.
- * Receives ctx with set/modify/remove and the event instance.
  */
 export type AggregateEventHandler<Id extends ArcIdAny, Schema extends ArcObjectAny, Event extends ArcEventAny> = (ctx: ArcViewHandlerContext<Id, Schema>, event: ArcEventInstance<Event>) => Promise<void>;
 /**
  * Entry in the aggregate's event registry.
- * Pairs an ArcEvent instance with its view handler.
- *
- * - isInline: true if event was created via .event() or .publicEvent() (inline definition)
- * - isPublic: true if event was created via .publicEvent() (accessible via getEvent())
  */
 export interface AggregateEventEntry<Event extends ArcEventAny = ArcEventAny, Id extends ArcIdAny = ArcIdAny, Schema extends ArcObjectAny = ArcObjectAny, IsPublic extends boolean = boolean> {
     readonly event: Event;
@@ -29,34 +24,19 @@ export interface AggregateEventEntry<Event extends ArcEventAny = ArcEventAny, Id
     readonly isInline: boolean;
     readonly isPublic: IsPublic;
 }
-/**
- * Context passed to mutateMethod handlers.
- * Provides emit per registered event + $auth from adapters.
- */
-export type AggregateMutateContext<Events extends AggregateEventEntry[]> = {
-    [E in Events[number] as E["event"]["name"]]: {
-        emit: (payload: any) => Promise<void>;
-    };
-} & {
-    $auth: {
-        params: any;
-        tokenName: string;
-    };
-};
 /**
  * Entry in the aggregate's mutateMethod registry.
- * Defines a named mutation exposed via mutateContext/useCommands.
+ * Stores the ArcFunction for runtime infrastructure + fields for type extraction.
  */
 export interface AggregateMutateMethodEntry {
     readonly name: string;
-    readonly params: ArcObjectAny;
-    readonly handler: ((ctx: any, params: any) => Promise<any>) | false;
+    readonly params: ArcObjectAny | null;
+    readonly handler: Function | false | null;
     readonly result?: any;
     readonly cronExpression?: string;
 }
 /**
  * Cron method entry extracted at build time.
- * Used by CronScheduler to discover and register cron jobs.
  */
 export interface AggregateCronMethodEntry {
     readonly aggregateName: string;
@@ -65,17 +45,15 @@ export interface AggregateCronMethodEntry {
 }
 /**
  * Entry in the aggregate's clientQuery registry.
- * Defines a named query exposed via queryContext/useQuery.
  */
 export interface AggregateQueryMethodEntry {
     readonly name: string;
-    readonly handler: (...args: any[]) => Promise<any>;
+    readonly handler: Function | false | null;
 }
 /**
- * Maps MutateMethods tuple → { methodName: (params) => Promise<ReturnType> }
- * Used as return type of mutateContext() on ArcAggregateElement.
+ * Resolve mutateMethod return type from entry fields.
+ * explicit result > handler return > Promise<any>
  */
-/** Resolve mutateMethod return type: explicit result > handler return > Promise<any> */
 type MutateReturn<M> = M extends {
     result: infer R;
 } ? [R] extends [never] ? M extends {
@@ -83,6 +61,10 @@ type MutateReturn<M> = M extends {
 } ? Promise<HR> : Promise<any> : Promise<R> : M extends {
     handlerReturn: infer HR;
 } ? Promise<HR> : Promise<any>;
+/**
+ * Maps MutateMethods tuple → { methodName: (params) => Promise<ReturnType> }
+ * Used as return type of mutateContext().
+ */
 export type AggregateMutateMethodContext<MutateMethods extends AggregateMutateMethodEntry[]> = {
     [M in MutateMethods[number] as M["name"]]: M["params"] extends {
         deserialize: (...a: any) => infer P;
@@ -90,15 +72,13 @@ export type AggregateMutateMethodContext<MutateMethods extends AggregateMutateMe
 };
 /**
  * Maps QueryMethods tuple → { methodName: consumer API }
- * Extracts params and return type directly from handler.
- * Uses rest args pattern so handlers without params produce no-arg consumer methods.
+ * Extracts args and return type directly from handler (same as pre-refactor).
  */
 export type AggregateQueryContext<QueryMethods extends AggregateQueryMethodEntry[]> = {
     [M in QueryMethods[number] as M["name"]]: M["handler"] extends (ctx: any, ...args: infer Args) => Promise<infer R> ? (...args: Args) => Promise<Simplify<R>> : never;
 };
 /**
  * Static configuration stored on the aggregate constructor.
- * Read by aggregateContextElement() to build the ArcContextElement.
  */
 export interface AggregateStaticConfig {
     readonly __aggregateName: string;

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

@@ -1,14 +1,12 @@
 /**
  * ArcAggregateElement — unified aggregate builder + context element.
  *
- * aggregate() returns this directly. No .build() or aggregateContextElement() needed.
+ * aggregate() returns this directly. No .build() needed.
  * Each builder method returns a new immutable instance.
  *
- * From the framework's perspective, behaves like a view:
- * - queryContext() → named query methods
- * - mutateContext() → named mutation methods
- * - getHandlers() / getElements() → for eventPublisher registration
- * - databaseStoreSchema() → table schema
+ * mutateMethod/clientQuery use the ArcFunction callback pattern:
+ *   .mutateMethod('create', fn => fn.withParams({...}).handle(...))
+ *   .clientQuery('getAll', fn => fn.handle(async ctx => ctx.$query.find({})))
  */
 import type { DatabaseStoreSchema } from "../../data-storage/database-store";
 import type { ArcIdAny } from "../../elements/id";
@@ -20,6 +18,8 @@ import type { ArcTokenAny } from "../../token/token";
 import { ArcContextElement } from "../context-element";
 import { ArcEvent, type ArcEventAny } from "../event/event";
 import type { ArcEventInstance } from "../event/instance";
+import { ArcFunction, type DefaultFunctionData } from "../function/arc-function";
+import type { ArcFunctionData } from "../function/arc-function-data";
 import type { ArcViewHandlerContext, ArcViewItem } from "../view/view-context";
 import type { ViewProtection, ViewProtectionFn } from "../view/view-data";
 import { AggregateBase } from "./aggregate-base";
@@ -42,7 +42,11 @@ type AggregatePrivateQuery<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
         (where?: any): Promise<AggregateRow<Id, Schema> | undefined>;
     };
 };
-type MutateMethodContext<Id extends ArcIdAny, Schema extends ArcObjectAny, Events extends AggregateEventEntry[]> = {
+/**
+ * ExtraCtx for mutateMethod handlers.
+ * Event emitters + $query + $auth — injected by aggregate.
+ */
+type MutateMethodExtraCtx<Id extends ArcIdAny, Schema extends ArcObjectAny, Events extends AggregateEventEntry[]> = {
     [E in Events[number] as E["event"]["name"]]: {
         emit: (payload: E["event"]["payload"] extends {
             deserialize: (...a: any) => any;
@@ -55,7 +59,10 @@ type MutateMethodContext<Id extends ArcIdAny, Schema extends ArcObjectAny, Event
     };
     $query: AggregatePrivateQuery<Id, Schema>;
 };
-type ClientQueryContext<Id extends ArcIdAny, Schema extends ArcObjectAny, Events extends AggregateEventEntry[]> = {
+/**
+ * ExtraCtx for clientQuery handlers.
+ */
+type ClientQueryExtraCtx<Id extends ArcIdAny, Schema extends ArcObjectAny, Events extends AggregateEventEntry[]> = {
     $query: AggregatePrivateQuery<Id, Schema>;
     $auth: {
         params: any;
@@ -91,10 +98,8 @@ export type AggregateConstructor<Id extends ArcIdAny = ArcIdAny, Schema extends
     getEvent<EventName extends PublicEventNames<Events>>(name: EventName): GetPublicEvent<Events, EventName>;
 };
 export type AggregateConstructorAny = AggregateConstructor<any, any, any>;
-/** Extract the full row type from an aggregate element. */
 export type AggregateData<El extends ArcAggregateElement<any, any, any, any, any>> = AggregateRow<El extends ArcAggregateElement<infer _N, infer I, any, any, any> ? I : never, El extends ArcAggregateElement<infer _N, any, infer S, any, any> ? S : never>;
 export declare class ArcAggregateElement<Name extends string = string, Id extends ArcIdAny = ArcIdAny, Schema extends ArcObjectAny = ArcObjectAny, Events extends AggregateEventEntry[] = AggregateEventEntry[], MutateMethods extends AggregateMutateMethodEntry[] = AggregateMutateMethodEntry[], QueryMethods extends AggregateQueryMethodEntry[] = AggregateQueryMethodEntry[]> extends ArcContextElement<Name> {
-    /** Expose schema for eventPublisher view registration (duck typing) */
     readonly schema: Schema;
     private readonly _id_factory;
     private readonly _events;
@@ -119,53 +124,75 @@ export declare class ArcAggregateElement<Name extends string = string, Id extend
         ...Events,
         AggregateEventEntry<E, ArcIdAny, ArcObjectAny, false>
     ], MutateMethods, QueryMethods>;
-    mutateMethod<const MethodName extends string, ParamsShape extends ArcRawShape, HR = void, R = never>(methodName: MethodName, config: {
-        params: ParamsShape;
-        result?: R;
-    }, handler: ((ctx: MutateMethodContext<Id, Schema, Events>, params: $type<ArcObject<ParamsShape>>) => Promise<HR>) | false): ArcAggregateElement<Name, Id, Schema, Events, [
+    /**
+     * Define a mutation method using ArcFunction callback pattern.
+     *
+     * The callback receives an ArcFunction pre-configured with ExtraCtx
+     * containing event emitters, $query, and $auth.
+     *
+     * @example
+     * ```typescript
+     * .mutateMethod('create', fn => fn
+     *   .withParams({ title: string() })
+     *   .withResult({ id: string() })
+     *   .handle(async (ctx, params) => {
+     *     const id = taskId.generate();
+     *     await ctx.created.emit({ title: params.title });
+     *     return { id };
+     *   })
+     * )
+     * ```
+     */
+    mutateMethod<const MethodName extends string, ReturnFn extends ArcFunction<ArcFunctionData, MutateMethodExtraCtx<Id, Schema, Events>>>(methodName: MethodName, configure: (fn: ArcFunction<DefaultFunctionData, MutateMethodExtraCtx<Id, Schema, Events>>) => ReturnFn): ArcAggregateElement<Name, Id, Schema, Events, [
         ...MutateMethods,
         {
             name: MethodName;
-            params: ArcObject<ParamsShape>;
-            handler: typeof handler;
-            handlerReturn: HR;
-            result: R;
+            params: ReturnFn["data"]["params"];
+            handler: ReturnFn["data"]["handler"];
+            handlerReturn: ReturnFn["data"]["handler"] extends (...args: any[]) => Promise<infer HR> ? HR : void;
+            result: ReturnFn["data"]["result"] extends ArcObjectAny ? $type<ReturnFn["data"]["result"]> : never;
         }
     ], QueryMethods>;
     cron(expression: string): ArcAggregateElement<Name, Id, Schema, Events, MutateMethods, QueryMethods>;
-    clientQuery<const MethodName extends string, H extends (ctx: ClientQueryContext<Id, Schema, Events>, ...args: any[]) => Promise<any>>(methodName: MethodName, handler: H): ArcAggregateElement<Name, Id, Schema, Events, MutateMethods, [
+    /**
+     * Define a client query method using ArcFunction callback pattern.
+     *
+     * The callback receives an ArcFunction pre-configured with ExtraCtx
+     * containing $query, $auth, and Aggregate constructor.
+     *
+     * @example
+     * ```typescript
+     * .clientQuery('getAll', fn => fn
+     *   .handle(async (ctx) => ctx.$query.find({}))
+     * )
+     * .clientQuery('getById', fn => fn
+     *   .withParams({ id: taskId })
+     *   .handle(async (ctx, { id }) => ctx.$query.findOne({ _id: id }))
+     * )
+     * ```
+     */
+    clientQuery<const MethodName extends string, ReturnFn extends ArcFunction<ArcFunctionData, ClientQueryExtraCtx<Id, Schema, Events>>>(methodName: MethodName, configure: (fn: ArcFunction<DefaultFunctionData, ClientQueryExtraCtx<Id, Schema, Events>>) => ReturnFn): ArcAggregateElement<Name, Id, Schema, Events, MutateMethods, [
         ...QueryMethods,
         {
             name: MethodName;
-            handler: H;
+            handler: ReturnFn["data"]["handler"];
         }
     ]>;
-    /**
-     * Declare seed data inserted after table creation.
-     * Rows with `_id` use it as-is; rows without get auto-generated IDs.
-     */
     seedWith(data: Array<$type<Schema> & {
         _id?: $type<Id>;
     }>, options?: {
         version?: number;
     }): ArcAggregateElement<Name, Id, Schema, Events, MutateMethods, QueryMethods>;
-    /**
-     * Return a copy with seed data attached.
-     * Use with context.replace() to add seeds to framework-provided aggregates.
-     */
     withSeeds(data: Array<$type<Schema> & {
         _id?: $type<Id>;
     }>, options?: {
         version?: number;
     }): ArcAggregateElement<Name, Id, Schema, Events, MutateMethods, QueryMethods>;
-    /** The internal AggregateConstructor class. Use in clientQuery to extend with business methods. */
     get Aggregate(): AggregateConstructor<Id, Schema, Events>;
     private buildConstructor;
     getHandlers(): Record<string, (ctx: any, event: any) => Promise<void>>;
     getElements(): ArcEventAny[];
-    /** Public event accessor (same as old static getEvent) */
     getEvent<EventName extends PublicEventNames<Events>>(eventName: EventName): GetPublicEvent<Events, EventName>;
-    /** Cron methods for CronScheduler discovery */
     get cronMethods(): AggregateCronMethodEntry[];
     queryContext(adapters: ModelAdapters): AggregateQueryContext<QueryMethods>;
     private buildPrivateQuery;

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

@@ -1,34 +1,16 @@
-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";
-/**
- * Extract token params type from a token
- */
-type TokenParams<T extends ArcTokenAny> = T extends {
-    paramsSchema: infer P extends {
-        deserialize: (...args: any) => any;
-    };
-} ? $type<P> : Record<string, any>;
-/**
- * Auth context type for protected commands
- * Provides access to token params from the authenticated user
- */
-export type AuthContext<T extends ArcTokenAny> = {
-    params: TokenParams<T>;
-    tokenName: T extends ArcToken<infer Name, any, any, any> ? Name : string;
-};
+import type { FnAuthContext, FnProtection } from "../function/arc-function-data";
 /**
  * Extract union of all token types from protections array
  */
-type ProtectionTokens<Protections extends CommandProtection[]> = Protections[number]["token"];
+type ProtectionTokens<Protections extends FnProtection[]> = Protections[number]["token"];
 /**
- * Command context provided to command handlers
- * Extends shared ElementContext with command-specific $auth support.
+ * Command context provided to command handlers.
+ * Extends shared ElementContext with $auth from protectedBy().
  */
-export type ArcCommandContext<QueryElements extends ArcContextElement<any>[], MutationElements extends ArcContextElement<any>[], Protections extends CommandProtection[] = []> = ElementContext<QueryElements, MutationElements> & (Protections extends [] ? object : {
-    $auth: AuthContext<ProtectionTokens<Protections>>;
+export type ArcCommandContext<QueryElements extends ArcContextElement<any>[], MutationElements extends ArcContextElement<any>[], Protections extends FnProtection[] = []> = ElementContext<QueryElements, MutationElements> & (Protections extends [] ? object : {
+    $auth: FnAuthContext<ProtectionTokens<Protections>>;
 });
 /**
  * Helper type to extract command context from command data
@@ -36,7 +18,7 @@ export type ArcCommandContext<QueryElements extends ArcContextElement<any>[], Mu
 export type ArcCommandContextFromData<Data> = Data extends {
     queryElements: infer Q extends ArcContextElement<any>[];
     mutationElements: infer M extends ArcContextElement<any>[];
-    protections?: infer P extends CommandProtection[];
+    protections?: infer P extends FnProtection[];
 } ? ArcCommandContext<Q, M, P extends undefined ? [] : P> : never;
 export {};
 //# sourceMappingURL=command-context.d.ts.map

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

@@ -1,23 +1,14 @@
 import type { ArcObjectAny } from "../../elements/object";
-import type { ArcTokenAny } from "../../token/token";
-import type { TokenInstanceAny } from "../../token/token-instance";
 import type { ArcContextElement } from "../context-element";
+import type { FnProtection, FnProtectionCheck } from "../function/arc-function-data";
 import type { ArcCommandHandler } from "./command-handler";
 /**
- * Protection check function for commands
- * Receives token instance and returns whether access is allowed
+ * Protection types — aliases for unified FnProtection
  */
-export type CommandProtectionCheck<T extends ArcTokenAny> = (tokenInstance: TokenInstanceAny) => boolean | Promise<boolean>;
-/**
- * Protection configuration for a command
- */
-export type CommandProtection = {
-    token: ArcTokenAny;
-    check: CommandProtectionCheck<any>;
-};
+export type CommandProtection = FnProtection;
+export type CommandProtectionCheck<T> = FnProtectionCheck<any>;
 /**
  * Command data configuration
- * Contains all generic types and non-generic configuration in one object
  */
 export type ArcCommandData = {
     name: string;

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

@@ -6,160 +6,68 @@ import type { TokenInstanceAny } from "../../token/token-instance";
 import type { Merge } from "../../utils";
 import type { $type } from "../../utils/types/get-type";
 import { ArcContextElement } from "../context-element";
+import { ArcFunction } from "../function/arc-function";
+import type { FnProtection, FnProtectionCheck } from "../function/arc-function-data";
 import type { ArcCommandContextFromData } from "./command-context";
-import type { ArcCommandData, CommandProtection, CommandProtectionCheck } from "./command-data";
+import type { ArcCommandData } from "./command-data";
 import type { ArcCommandHandler } from "./command-handler";
 /**
  * Arc Command - Business action that modifies state
  *
- * Commands are the primary way to execute business logic in Arc Framework.
- * They can:
- * - Accept typed parameters
- * - Return typed results
- * - Query state through query elements (views)
- * - Mutate state through mutation elements (events, other commands)
- *
- * Commands follow the factory pattern from the Arc guide:
- * - All configuration in a single Data object
- * - Type-safe throughout
- * - Immutable with clone-on-modify
- * - Separate query and mutation concerns
+ * Uses ArcFunction internally (#fn) for unified params, result, protection,
+ * and context dependency management.
  *
  * @example
  * ```typescript
  * const registerCmd = command("register")
- *   .public()
  *   .query([usersView])
  *   .mutate([userRegisteredEvent])
  *   .withParams({ email: string(), password: string() })
  *   .withResult({ success: boolean() })
+ *   .protectBy(adminToken, t => t.canI('register'))
  *   .handle(async (ctx, params) => {
- *     // Business logic here
  *     return { success: true };
  *   });
  * ```
  */
 export declare class ArcCommand<const Data extends ArcCommandData> extends ArcContextElement<Data["name"]> {
+    #private;
     private readonly data;
-    constructor(data: Data);
-    /**
-     * Set command description for documentation and tooling
-     */
+    constructor(data: Data, fn?: ArcFunction<any>);
     description<const Desc extends string>(description: Desc): ArcCommand<Merge<Data, {
         description: Desc;
     }>>;
-    /**
-     * Check if command is public (no protections = public)
-     * Commands without protectBy() are considered public
-     */
     get isPublic(): boolean;
-    /**
-     * Add query elements (views) that this command needs to read from
-     * Query elements provide read-only access to state
-     *
-     * @param elements - Array of view elements to query
-     */
     query<const Elements extends ArcContextElement<any>[]>(elements: Elements): ArcCommand<Merge<Data, {
         queryElements: Elements;
     }>>;
-    /**
-     * Add mutation elements (events, commands) that this command needs to modify state
-     * Mutation elements provide write access to state
-     *
-     * @param elements - Array of event/command elements to mutate with
-     */
     mutate<const Elements extends ArcContextElement<any>[]>(elements: Elements): ArcCommand<Merge<Data, {
         mutationElements: Elements;
     }>>;
-    /**
-     * Define command parameters schema
-     *
-     * @param schema - Object schema or raw shape defining parameter structure
-     */
     withParams<NewParams extends ArcRawShape>(schema: NewParams | ArcObject<NewParams>): ArcCommand<Merge<Data, {
         params: ArcObject<NewParams>;
     }>>;
-    /**
-     * Define command result schemas
-     * Commands can return multiple result types (success, error variants)
-     *
-     * @param schemas - Array of object schemas for possible results
-     */
     withResult<NewResults extends ArcRawShape[]>(...schemas: NewResults): ArcCommand<Merge<Data, {
         results: { [K in keyof NewResults]: ArcObject<NewResults[K]>; };
     }>>;
-    /**
-     * Set command handler function
-     * The handler contains the business logic for this command
-     *
-     * @param handler - Function that executes command logic, or false to disable
-     */
     handle<Handler extends ArcCommandHandler<ArcCommandContextFromData<Data>, Data["params"] extends ArcObjectAny ? $type<Data["params"]> : null, $type<Data["results"][number]>> | false>(handler: Handler): ArcCommand<Merge<Data, {
         handler: Handler;
     }>>;
-    /**
-     * Add token-based protection to this command
-     * Multiple protections can be added (all must pass)
-     *
-     * @param token - Token definition to protect with
-     * @param check - Function to check if access is allowed
-     *
-     * @example
-     * ```typescript
-     * command("editForm")
-     *   .protectBy(moderatorToken, (token) => token.canI('form:edit'))
-     *   .handle(async (ctx, params) => { ... });
-     * ```
-     */
-    protectBy<T extends ArcTokenAny>(token: T, check: CommandProtectionCheck<T>): ArcCommand<Merge<Data, {
-        protections: [...Data["protections"] extends infer P extends CommandProtection[] ? P : [], {
+    protectBy<T extends ArcTokenAny>(token: T, check: FnProtectionCheck<T>): ArcCommand<Merge<Data, {
+        protections: [...Data["protections"] extends infer P extends FnProtection[] ? P : [], {
             token: T;
             check: typeof check;
         }];
     }>>;
-    /**
-     * Check if command has protections
-     */
     get hasProtections(): boolean;
-    /**
-     * Get all protection configurations
-     */
-    get protections(): CommandProtection[];
-    /**
-     * Verify all protections pass for given token instances
-     *
-     * @param tokens - Array of token instances to verify
-     * @returns true if all protections pass
-     */
+    get protections(): FnProtection[];
     verifyProtections(tokens: TokenInstanceAny[]): Promise<boolean>;
-    /**
-     * Initialize command in the given environment
-     * On server: registers command handler for remote execution
-     */
     init(environment: import("../context-element").ArcEnvironment, adapters: ModelAdapters): Promise<void>;
-    /**
-     * Generate mutation context for this command
-     * Provides execute functionality to run the command
-     *
-     * @param adapters - Available adapters (storage, commandWire, eventPublisher)
-     * @returns Context object with execute method
-     */
     mutateContext(adapters: ModelAdapters): ((params: Data["params"] extends ArcObjectAny ? $type<Data["params"]> : null) => Promise<$type<Data["results"][number]>>) & {
         params: Data["params"];
     };
-    /**
-     * Execute command locally with handler
-     * Collects events and publishes them via eventPublisher
-     */
     private executeLocally;
-    /**
-     * Build command context with access to query and mutation elements
-     */
     private buildCommandContext;
-    /**
-     * Convert command to JSON Schema format
-     * Used for OpenAPI documentation and validation
-     */
     toJsonSchema(): {
         type: string;
         name: string;
@@ -168,21 +76,6 @@ export declare class ArcCommand<const Data extends ArcCommandData> extends ArcCo
         strict: boolean;
     };
 }
-/**
- * Create a new command with the given name
- *
- * @param name - Unique command name
- * @returns New command instance ready for configuration
- *
- * @example
- * ```typescript
- * const myCommand = command("myCommand")
- *   .withParams({ input: string() })
- *   .handle(async (ctx, params) => {
- *     // logic here
- *   });
- * ```
- */
 export declare function command<const Name extends string>(name: Name): ArcCommand<{
     readonly name: Name;
     readonly params: null;
@@ -191,8 +84,5 @@ export declare function command<const Name extends string>(name: Name): ArcComma
     readonly mutationElements: [];
     readonly protections: [];
 }>;
-/**
- * Type alias for any command (used in collections)
- */
 export type ArcCommandAny = ArcCommand<any>;
 //# sourceMappingURL=command.d.ts.map

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

@@ -1,5 +1,5 @@
 export { ArcCommand, command, type ArcCommandAny } from "./command";
-export type { ArcCommandContext, ArcCommandContextFromData, AuthContext, } from "./command-context";
+export type { ArcCommandContext, ArcCommandContextFromData, } from "./command-context";
 export type { ArcCommandData, CommandProtection, CommandProtectionCheck, } from "./command-data";
 export type { ArcCommandHandler } from "./command-handler";
 export type { ArcObjectAny, ArcRawShape } from "../../elements/object";

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

@@ -2,37 +2,47 @@ 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.
+ * Callable accessor — both a function (for references) and an object (for named access).
  *
- * Elements are accessible by name (ctx.myView, ctx.myAggregate) or
- * by reference (ctx.query(element), ctx.mutate(element)).
+ * @example
+ * ```typescript
+ * // By name (declared in .query()/.mutate()):
+ * ctx.query.myMessages.getByConversation({ conversationId })
+ *
+ * // By reference (factories, dynamic elements):
+ * ctx.query(messageElement).getByConversation({ conversationId })
+ * ```
+ */
+type QueryAccessor<Elements extends ArcContextElement<any>[]> = ((element: ArcContextElement<any>) => any) & QueryContext<Elements>;
+type MutateAccessor<Elements extends ArcContextElement<any>[]> = ((element: ArcContextElement<any>) => any) & MutationContext<Elements>;
+/**
+ * Unified element context — shared between routes, commands, listeners.
+ *
+ * Elements are accessible by name (ctx.query.myView) or
+ * by reference (ctx.query(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;
+export type ElementContext<QueryElements extends ArcContextElement<any>[], MutationElements extends ArcContextElement<any>[]> = {
+    query: QueryAccessor<QueryElements>;
+    mutate: MutateAccessor<MutationElements>;
+    $auth?: {
+        params: any;
+        tokenName: string;
+    };
 };
 /**
  * Build element context at runtime.
- * Shared implementation for routes, commands, etc.
+ * Shared implementation for routes, commands, listeners.
  */
 export declare function buildElementContext(queryElements: ArcContextElement<any>[], mutationElements: ArcContextElement<any>[], adapters: ModelAdapters): any;
 export {};