@arcote.tech/arc 0.3.6 → 0.4.2

package/dist/adapters/auth-adapter.d.ts

@@ -1,9 +1,10 @@
 /**
- * AuthAdapter - Manages authentication token for the model
+ * AuthAdapter - Manages authentication tokens per scope
  *
- * Stores the current JWT token and provides decoded params.
+ * Stores JWT tokens keyed by scope name and provides decoded params.
+ * Auto-persists tokens to localStorage (when available) under `arc:token:{scope}`.
  * On client: decodes token without signature verification
- * On server: token is verified before being set
+ * On server: token is verified before being set (no localStorage)
  */
 export interface DecodedToken {
     tokenName: string;
@@ -12,36 +13,50 @@ export interface DecodedToken {
     exp?: number;
 }
 export declare class AuthAdapter {
-    private token;
-    private decoded;
+    private scopes;
     /**
-     * Set the JWT token
-     * Decodes the payload (without signature verification on client)
+     * Set the JWT token for a scope.
+     * Auto-persists to localStorage when available.
      */
-    setToken(token: string | null): void;
+    setToken(token: string | null, scope?: string): void;
     /**
-     * Get the raw JWT token string
+     * Load all persisted scope tokens from localStorage.
+     * Call once on app init before any queries.
      */
-    getToken(): string | null;
+    loadPersisted(): void;
     /**
-     * Get decoded token data
+     * Get the raw JWT token string for a scope
      */
-    getDecoded(): DecodedToken | null;
+    getToken(scope?: string): string | null;
     /**
-     * Get token params (e.g., { userId, projectId })
+     * Get decoded token data for a scope
      */
-    getParams(): Record<string, any> | null;
+    getDecoded(scope?: string): DecodedToken | null;
     /**
-     * Get token name (e.g., "user")
+     * Get token params for a scope (e.g., { userId, projectId })
      */
-    getTokenName(): string | null;
+    getParams(scope?: string): Record<string, any> | null;
     /**
-     * Check if token is set and valid
+     * Get token name for a scope (e.g., "user")
      */
-    isAuthenticated(): boolean;
+    getTokenName(scope?: string): string | null;
     /**
-     * Check if token is expired
+     * Check if authenticated.
+     * If scope is given, checks that scope. If omitted, checks any scope.
      */
-    isExpired(): boolean;
+    isAuthenticated(scope?: string): boolean;
+    /**
+     * Check if token is expired for a scope
+     */
+    isExpired(scope?: string): boolean;
+    /**
+     * Get all scope names that have tokens
+     */
+    getAllScopes(): string[];
+    /**
+     * Clear all scope tokens and their localStorage entries.
+     * Call on logout.
+     */
+    clear(): void;
 }
 //# sourceMappingURL=auth-adapter.d.ts.map

package/dist/adapters/command-wire.d.ts

@@ -5,8 +5,9 @@
  * - Execute commands remotely on the server
  * - Handle command request/response serialization
  * - Automatic FormData handling for file uploads
+ * - Per-request auth via scope + token
  */
-import { Wire } from "./wire";
+import { Wire, type WireAuth } from "./wire";
 export declare class CommandWire extends Wire {
     constructor(baseUrl: string);
     /**
@@ -14,9 +15,10 @@ export declare class CommandWire extends Wire {
      *
      * @param name - Command name
      * @param params - Command parameters
+     * @param auth - Scope and token for this request
      * @returns Command result from server
      */
-    executeCommand(name: string, params: any): Promise<any>;
+    executeCommand(name: string, params: any, auth?: WireAuth): Promise<any>;
     /**
      * Check if object contains any File instances (recursively)
      */

package/dist/adapters/event-wire.d.ts

@@ -5,6 +5,7 @@
  * - Sends locally created events to the host
  * - Receives events from the host (from other clients)
  * - Handles reconnection and sync state
+ * - Manages per-scope token caching
  */
 export interface SyncableEvent {
     localId: string;
@@ -20,24 +21,33 @@ export interface ReceivedEvent {
     createdAt: string;
     clientId: string;
 }
+import type { ContextDescriptor } from "../model/context-accessor";
 type EventWireState = "disconnected" | "connecting" | "connected";
 export declare class EventWire {
     private readonly baseUrl;
     private instanceId;
     private ws;
     private state;
-    private token;
+    private scopeTokens;
     private lastHostEventId;
     private pendingEvents;
     private onEventCallback?;
     private onSyncedCallback?;
     private reconnectTimeout?;
     private syncRequested;
+    private viewSubscriptions;
+    private viewSubCounter;
+    private pendingViewSubs;
     constructor(baseUrl: string);
     /**
-     * Set authentication token
+     * Set a scope token. If connected, sends scope:auth message to server.
+     * If token is null, removes the scope.
      */
-    setAuthToken(token: string | null): void;
+    setScopeToken(scope: string, token: string | null): void;
+    /**
+     * Check if any scope has a token set
+     */
+    hasScopeTokens(): boolean;
     /**
      * Set the last synced host event ID
      * Used to restore sync state after page refresh
@@ -67,13 +77,28 @@ export declare class EventWire {
      * Set callback for when events are confirmed synced
      */
     onSynced(callback: (localIds: string[]) => void): void;
+    /**
+     * Subscribe to a server-side query via WebSocket.
+     * Server executes the descriptor and pushes results on change.
+     */
+    subscribeQuery(descriptor: ContextDescriptor, callback: (data: any[]) => void, scope?: string): string;
+    /**
+     * Unsubscribe from a server-side query.
+     */
+    unsubscribeQuery(subscriptionId: string): void;
     /**
      * Get current connection state
      */
     getState(): EventWireState;
+    /**
+     * Send all cached scope tokens to the server
+     * Called on connect and reconnect
+     */
+    private sendAllScopeTokens;
     private handleMessage;
     private requestSync;
     private flushPendingEvents;
+    private flushPendingViewSubs;
     private scheduleReconnect;
 }
 export {};

package/dist/adapters/index.d.ts

@@ -16,6 +16,7 @@ export type { ReceivedEvent, SyncableEvent } from "./event-wire";
 export { QueryWire } from "./query-wire";
 export type { StreamConnection } from "./query-wire";
 export { Wire } from "./wire";
+export type { WireAuth } from "./wire";
 export { EVENT_TABLES, LocalEventPublisher } from "./event-publisher";
 export type { EventPublisher, EventWithSyncStatus, StoredEvent, StoredEventSyncStatus, StoredEventTag, } from "./event-publisher";
 //# sourceMappingURL=index.d.ts.map

package/dist/adapters/query-wire.d.ts

@@ -4,8 +4,9 @@
  * Provides:
  * - One-shot queries via HTTP POST
  * - Live queries via Server-Sent Events (SSE)
+ * - Per-request auth via scope + token
  */
-import { Wire } from "./wire";
+import { Wire, type WireAuth } from "./wire";
 export interface StreamConnection {
     eventSource: EventSource;
     unsubscribe: () => void;
@@ -17,18 +18,19 @@ export declare class QueryWire extends Wire {
      *
      * @param viewName - Name of the view to query
      * @param options - Query options (where, orderBy, limit)
+     * @param auth - Scope and token for this request
      * @returns Query results
      */
-    query(viewName: string, options?: any): Promise<any[]>;
+    query(viewName: string, options?: any, auth?: WireAuth): Promise<any[]>;
     /**
      * Create a live query stream using SSE
      *
      * @param viewName - Name of the view to stream
      * @param options - Query options (where, orderBy, limit)
      * @param callback - Called when data changes
-     * @param token - Auth token for the stream (optional, uses wire token if not provided)
+     * @param auth - Scope and token for this request (SSE uses URL params since headers aren't supported)
      * @returns StreamConnection with unsubscribe method
      */
-    stream(viewName: string, options: any, callback: (data: any[]) => void, token?: string | null): StreamConnection;
+    stream(viewName: string, options: any, callback: (data: any[]) => void, auth?: WireAuth): StreamConnection;
 }
 //# sourceMappingURL=query-wire.d.ts.map

package/dist/adapters/wire.d.ts

@@ -1,28 +1,24 @@
 /**
  * Wire - Base abstraction for client-server communication
  *
- * Handles JWT token management and provides fetch abstraction
+ * Handles per-request auth (scope + token) and provides fetch abstraction
  * for making authenticated requests to the server.
  */
+export interface WireAuth {
+    scope: string;
+    token: string | null;
+}
 export declare class Wire {
-    private token;
     protected readonly baseUrl: string;
     constructor(baseUrl: string);
-    /**
-     * Set authentication token for requests
-     */
-    setAuthToken(token: string | null): void;
-    /**
-     * Get the current auth token
-     */
-    getAuthToken(): string | null;
     /**
      * Get the base URL
      */
     getBaseUrl(): string;
     /**
      * Make authenticated fetch request to server
+     * Auth is passed per-request via the auth parameter
      */
-    fetch(endpoint: string, options?: RequestInit): Promise<Response>;
+    fetch(endpoint: string, options?: RequestInit, auth?: WireAuth): Promise<Response>;
 }
 //# sourceMappingURL=wire.d.ts.map

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

@@ -0,0 +1,31 @@
+/**
+ * Aggregate Base Class
+ *
+ * Base class that aggregate instances extend.
+ * Provides this.value (current state), this._id, and this.ctx (mutation context).
+ */
+import type { ArcIdAny } from "../../elements/id";
+import type { ArcObjectAny } from "../../elements/object";
+import type { ModelAdapters } from "../../model/model-adapters";
+import type { $type } from "../../utils/types/get-type";
+import type { ArcViewItem } from "../view/view-context";
+import type { AggregateInstanceCtx } from "./aggregate-builder";
+import type { AggregateEventEntry } from "./aggregate-data";
+/**
+ * Base class for aggregate instances.
+ *
+ * Created by queryContext when wrapping view rows.
+ * Provides:
+ * - this.value — current state from the view
+ * - this._id — entity identifier
+ * - this.ctx — mutation context with emit per registered event
+ */
+export declare class AggregateBase<Id extends ArcIdAny = ArcIdAny, Schema extends ArcObjectAny = ArcObjectAny, Events extends AggregateEventEntry[] = AggregateEventEntry[]> {
+    #private;
+    readonly value: $type<Schema>;
+    readonly _id: $type<Id>;
+    constructor(row: ArcViewItem<Id, Schema>, adapters: ModelAdapters);
+    toJSON(): any;
+    get ctx(): AggregateInstanceCtx<Events>;
+}
+//# sourceMappingURL=aggregate-base.d.ts.map

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

@@ -0,0 +1,139 @@
+import type { ArcIdAny } from "../../elements/id";
+import { ArcObject, type ArcObjectAny, type ArcRawShape } from "../../elements/object";
+import type { ArcTokenAny } from "../../token/token";
+import type { $type } from "../../utils/types/get-type";
+import type { Simplify } from "../../utils";
+import { ArcEvent, type ArcEventAny } from "../event/event";
+import type { ArcEventInstance } from "../event/instance";
+import type { ArcViewHandlerContext } from "../view/view-context";
+import type { ViewProtection, ViewProtectionFn } from "../view/view-data";
+import { AggregateBase } from "./aggregate-base";
+import type { AggregateCronMethodEntry, AggregateEventEntry, AggregateMutateMethodEntry, AggregateQueryMethodEntry } from "./aggregate-data";
+type InlineArcEvent<EN extends string, PS extends ArcRawShape> = ArcEvent<{
+    name: EN;
+    payload: ArcObject<PS>;
+    protections: [];
+}>;
+type AggregateRow<Id extends ArcIdAny, Schema extends ArcObjectAny> = Simplify<$type<Schema> & {
+    _id: $type<Id>;
+}>;
+type AggregatePrivateQuery<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
+    find: (options?: any) => Promise<AggregateRow<Id, Schema>[]>;
+    findOne: (where?: any) => Promise<AggregateRow<Id, Schema> | undefined>;
+};
+type MutateMethodContext<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;
+        } ? $type<E["event"]["payload"]> : undefined) => Promise<void>;
+    };
+} & {
+    $auth: {
+        params: any;
+        tokenName: string;
+    };
+    $query: AggregatePrivateQuery<Id, Schema>;
+};
+type ClientQueryContext<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
+    $query: {
+        find: {
+            <M extends new (row: AggregateRow<Id, Schema>, adapters: any) => any>(options: any, mapper: M): Promise<InstanceType<M>[]>;
+            (options?: any): Promise<AggregateRow<Id, Schema>[]>;
+        };
+        findOne: {
+            <M extends new (row: AggregateRow<Id, Schema>, adapters: any) => any>(where: any, mapper: M): Promise<InstanceType<M> | undefined>;
+            (where?: any): Promise<AggregateRow<Id, Schema> | undefined>;
+        };
+    };
+    $auth: {
+        params: any;
+        tokenName: string;
+    };
+};
+export type AggregateInstanceCtx<Events extends AggregateEventEntry[]> = {
+    [E in Events[number] as E["event"]["name"]]: {
+        emit: (payload: E["event"]["payload"] extends {
+            deserialize: (...a: any) => any;
+        } ? $type<E["event"]["payload"]> : undefined) => Promise<void>;
+    };
+};
+type PublicEvents<Events extends AggregateEventEntry[]> = Extract<Events[number], {
+    isPublic: true;
+}>;
+type PublicEventNames<Events extends AggregateEventEntry[]> = PublicEvents<Events>["event"]["name"];
+type GetPublicEvent<Events extends AggregateEventEntry[], Name extends string> = Extract<PublicEvents<Events>, {
+    event: {
+        name: Name;
+    };
+}>["event"];
+export declare class AggregateBuilder<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny, Events extends AggregateEventEntry[], MutateMethods extends AggregateMutateMethodEntry[], QueryMethods extends AggregateQueryMethodEntry[] = []> {
+    private readonly _name;
+    private readonly _id;
+    private readonly _schema;
+    private readonly _events;
+    private readonly _protections;
+    private readonly _mutateMethods;
+    private readonly _queryMethods;
+    constructor(name: Name, id: Id, schema: Schema, events?: Events, protections?: ViewProtection[], mutateMethods?: MutateMethods, queryMethods?: QueryMethods);
+    protectBy<T extends ArcTokenAny>(token: T, protectionFn: ViewProtectionFn<any>): AggregateBuilder<Name, Id, Schema, Events, MutateMethods, QueryMethods>;
+    event<const EventName extends string, PayloadShape extends ArcRawShape>(eventName: EventName, payload: PayloadShape, handler: (ctx: ArcViewHandlerContext<Id, Schema>, event: ArcEventInstance<InlineArcEvent<EventName, PayloadShape>>) => Promise<void>): AggregateBuilder<Name, Id, Schema, [
+        ...Events,
+        AggregateEventEntry<InlineArcEvent<EventName, PayloadShape>, Id, Schema, false>
+    ], MutateMethods, QueryMethods>;
+    publicEvent<const EventName extends string, PayloadShape extends ArcRawShape>(eventName: EventName, payload: PayloadShape, handler: (ctx: ArcViewHandlerContext<Id, Schema>, event: ArcEventInstance<InlineArcEvent<EventName, PayloadShape>>) => Promise<void>): AggregateBuilder<Name, Id, Schema, [
+        ...Events,
+        AggregateEventEntry<InlineArcEvent<EventName, PayloadShape>, Id, Schema, true>
+    ], MutateMethods, QueryMethods>;
+    handleEvent<E extends ArcEventAny>(arcEvent: E, handler: (ctx: ArcViewHandlerContext<Id, Schema>, event: ArcEventInstance<E>) => Promise<void>): AggregateBuilder<Name, Id, Schema, [
+        ...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): AggregateBuilder<Name, Id, Schema, Events, [
+        ...MutateMethods,
+        {
+            name: MethodName;
+            params: ArcObject<ParamsShape>;
+            handler: typeof handler;
+            handlerReturn: HR;
+            result: R;
+        }
+    ], QueryMethods>;
+    /**
+     * Attach a cron schedule to the last declared mutateMethod.
+     * The CronScheduler will call this method on the given schedule
+     * for every existing aggregate instance.
+     *
+     * @param expression - A cron expression (e.g. "0 *\/6 * * *" for every 6 hours)
+     */
+    cron(expression: string): AggregateBuilder<Name, Id, Schema, Events, MutateMethods, QueryMethods>;
+    clientQuery<const MethodName extends string, H extends (ctx: ClientQueryContext<Id, Schema>, ...args: any[]) => Promise<any>>(methodName: MethodName, handler: H): AggregateBuilder<Name, Id, Schema, Events, MutateMethods, [
+        ...QueryMethods,
+        {
+            name: MethodName;
+            handler: H;
+        }
+    ]>;
+    build(): AggregateConstructor<Name, Id, Schema, Events, MutateMethods, QueryMethods>;
+}
+export type AggregateConstructor<Name extends string = string, Id extends ArcIdAny = ArcIdAny, Schema extends ArcObjectAny = ArcObjectAny, Events extends AggregateEventEntry[] = AggregateEventEntry[], MutateMethods extends AggregateMutateMethodEntry[] = AggregateMutateMethodEntry[], QueryMethods extends AggregateQueryMethodEntry[] = AggregateQueryMethodEntry[]> = (new (row: import("../view/view-context").ArcViewItem<Id, Schema>, adapters: import("../../model/model-adapters").ModelAdapters) => AggregateBase<Id, Schema, Events>) & {
+    readonly __aggregateName: Name;
+    readonly __aggregateId: Id;
+    readonly __aggregateSchema: Schema;
+    readonly __aggregateEvents: Events;
+    readonly __aggregateProtections: ViewProtection[];
+    readonly __aggregateMutateMethods: MutateMethods;
+    readonly __aggregateQueryMethods: QueryMethods;
+    readonly __aggregateCronMethods: AggregateCronMethodEntry[];
+    getEvent<EventName extends PublicEventNames<Events>>(name: EventName): GetPublicEvent<Events, EventName>;
+};
+export type AggregateConstructorAny = AggregateConstructor<any, any, any, any, any, any>;
+/** Extract the full row type ({ _id, ...fields }) from an aggregate constructor. */
+export type AggregateData<Ctor extends AggregateConstructorAny> = {
+    _id: $type<Ctor["__aggregateId"]>;
+} & $type<Ctor["__aggregateSchema"]>;
+export declare function aggregate<const Name extends string, Id extends ArcIdAny, SchemaShape extends ArcRawShape>(name: Name, id: Id, schema: SchemaShape): AggregateBuilder<Name, Id, ArcObject<SchemaShape>, [], [], []>;
+export {};
+//# sourceMappingURL=aggregate-builder.d.ts.map

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

@@ -0,0 +1,114 @@
+/**
+ * Aggregate Data Types
+ *
+ * Type definitions for aggregate configuration stored as static fields
+ * on the aggregate constructor class.
+ */
+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 { 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;
+    readonly handler: (ctx: any, event: any) => Promise<void>;
+    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.
+ */
+export interface AggregateMutateMethodEntry {
+    readonly name: string;
+    readonly params: ArcObjectAny;
+    readonly handler: ((ctx: any, params: any) => Promise<any>) | false;
+    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;
+    readonly methodName: string;
+    readonly cronExpression: string;
+}
+/**
+ * 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>;
+}
+/**
+ * Maps MutateMethods tuple → { methodName: (params) => Promise<ReturnType> }
+ * Used as return type of mutateContext() on ArcAggregateElement.
+ */
+/** Resolve mutateMethod return type: explicit result > handler return > Promise<any> */
+type MutateReturn<M> = M extends {
+    result: infer R;
+} ? [R] extends [never] ? M extends {
+    handlerReturn: infer HR;
+} ? Promise<HR> : Promise<any> : Promise<R> : M extends {
+    handlerReturn: infer HR;
+} ? Promise<HR> : Promise<any>;
+export type AggregateMutateMethodContext<MutateMethods extends AggregateMutateMethodEntry[]> = {
+    [M in MutateMethods[number] as M["name"]]: M["params"] extends {
+        deserialize: (...a: any) => infer P;
+    } ? (params: P) => MutateReturn<M> : () => MutateReturn<M>;
+};
+/**
+ * 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.
+ */
+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;
+    readonly __aggregateId: ArcIdAny;
+    readonly __aggregateSchema: ArcObjectAny;
+    readonly __aggregateEvents: AggregateEventEntry[];
+    readonly __aggregateProtections: ViewProtection[];
+    readonly __aggregateMutateMethods: AggregateMutateMethodEntry[];
+    readonly __aggregateQueryMethods: AggregateQueryMethodEntry[];
+    readonly __aggregateCronMethods: AggregateCronMethodEntry[];
+}
+export {};
+//# sourceMappingURL=aggregate-data.d.ts.map

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

@@ -0,0 +1,69 @@
+/**
+ * ArcAggregateElement
+ *
+ * Implements ArcContextElement for an aggregate.
+ * Created by aggregateContextElement(Constructor).
+ *
+ * Looks like an ArcView to the rest of the system:
+ * - queryContext() → find/findOne returning class instances
+ * - mutateContext() → emit per registered event
+ * - getHandlers() / getElements() → for eventPublisher.registerViews()
+ * - databaseStoreSchema() → view table schema
+ */
+import type { DatabaseStoreSchema } from "../../data-storage/database-store";
+import type { ModelAdapters } from "../../model/model-adapters";
+import { ArcContextElement } from "../context-element";
+import type { ArcEventAny } from "../event/event";
+import type { AggregateConstructorAny } from "./aggregate-builder";
+import type { AggregateMutateMethodContext, AggregateQueryContext } from "./aggregate-data";
+/**
+ * ArcAggregateElement — single context element for an aggregate.
+ *
+ * From the framework's perspective this behaves like a view:
+ * - eventPublisher.registerViews() accepts it (duck typing via getHandlers/getElements/schema)
+ * - queryContext provides find/findOne
+ * - mutateContext provides emit per event
+ */
+export declare class ArcAggregateElement<Ctor extends AggregateConstructorAny> extends ArcContextElement<Ctor["__aggregateName"]> {
+    private readonly ctor;
+    /** Expose schema for eventPublisher view registration (duck typing) */
+    readonly schema: Ctor["__aggregateSchema"];
+    constructor(ctor: Ctor);
+    /**
+     * Returns event handlers keyed by event name.
+     * Same shape as ArcView.getHandlers().
+     */
+    getHandlers(): Record<string, (ctx: any, event: any) => Promise<void>>;
+    /**
+     * Returns event elements this aggregate listens to.
+     * Same shape as ArcView.getElements().
+     */
+    getElements(): ArcEventAny[];
+    /**
+     * queryContext — exposes declared queryMethod entries as callable functions.
+     *
+     * Each queryMethod handler receives { $query: { find, findOne }, $auth }
+     * where $query reads from the appropriate adapter (dataStorage, streamingCache, or queryWire).
+     * Returns aggregate class instances.
+     */
+    queryContext(adapters: ModelAdapters): AggregateQueryContext<Ctor["__aggregateQueryMethods"]>;
+    /**
+     * Build private query methods (find/findOne) that work across all adapter modes.
+     * Used internally by queryMethod handlers via ctx.$query.
+     */
+    private buildPrivateQuery;
+    private getAuth;
+    /**
+     * mutateContext — exposes declared mutateMethod entries as callable functions.
+     *
+     * Each mutateMethod becomes a named function: `(params) => Promise<any>`.
+     * The handler receives a context with emit per event + $auth + $query.
+     */
+    mutateContext(adapters: ModelAdapters): AggregateMutateMethodContext<Ctor["__aggregateMutateMethods"]>;
+    /**
+     * databaseStoreSchema — same as ArcView.
+     * Creates a table named after the aggregate with _id + schema fields.
+     */
+    databaseStoreSchema(): DatabaseStoreSchema;
+}
+//# sourceMappingURL=aggregate-element.d.ts.map

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

@@ -0,0 +1,31 @@
+/**
+ * Aggregate module
+ *
+ * Exports:
+ * - aggregate() — builder entry point
+ * - aggregateContextElement() — creates ArcContextElement from aggregate class
+ * - AggregateBase — base class for instances
+ * - Types
+ */
+export { aggregate, AggregateBuilder } from "./aggregate-builder";
+export type { AggregateConstructor, AggregateConstructorAny, AggregateData, AggregateInstanceCtx, } from "./aggregate-builder";
+export { AggregateBase } from "./aggregate-base";
+export { ArcAggregateElement } from "./aggregate-element";
+export type { AggregateCronMethodEntry, AggregateEventEntry, AggregateEventHandler, AggregateMutateMethodContext, AggregateMutateMethodEntry, AggregateQueryContext, AggregateQueryMethodEntry, AggregateStaticConfig, } from "./aggregate-data";
+export type { ArcEventPayload } from "../event/instance";
+import type { AggregateConstructorAny } from "./aggregate-builder";
+import { ArcAggregateElement } from "./aggregate-element";
+/**
+ * Create an ArcContextElement from an aggregate class.
+ *
+ * @param ctor - Aggregate class (extends the result of aggregate().build())
+ * @returns ArcAggregateElement ready for context([])
+ *
+ * @example
+ * ```ts
+ * const taskElement = aggregateContextElement(Task);
+ * const appContext = context([taskElement]);
+ * ```
+ */
+export declare function aggregateContextElement<Ctor extends AggregateConstructorAny>(ctor: Ctor): ArcAggregateElement<Ctor>;
+//# sourceMappingURL=index.d.ts.map