@arcote.tech/arc 0.3.6 → 0.4.1

package/dist/index.js

@@ -1,71 +1,126 @@
 // src/adapters/auth-adapter.ts
+var TOKEN_PREFIX = "arc:token:";
+function hasLocalStorage() {
+  return typeof localStorage !== "undefined";
+}
+
 class AuthAdapter {
-  token = null;
-  decoded = null;
-  setToken(token) {
-    this.token = token;
+  scopes = new Map;
+  setToken(token, scope = "default") {
     if (!token) {
-      this.decoded = null;
+      this.scopes.delete(scope);
+      if (hasLocalStorage())
+        localStorage.removeItem(TOKEN_PREFIX + scope);
       return;
     }
     try {
       const parts = token.split(".");
       if (parts.length !== 3) {
-        this.decoded = null;
+        this.scopes.delete(scope);
+        if (hasLocalStorage())
+          localStorage.removeItem(TOKEN_PREFIX + scope);
         return;
       }
       const payload = JSON.parse(atob(parts[1]));
-      this.decoded = {
-        tokenName: payload.tokenName,
-        params: payload.params || {},
-        iat: payload.iat,
-        exp: payload.exp
-      };
+      this.scopes.set(scope, {
+        raw: token,
+        decoded: {
+          tokenName: payload.tokenName,
+          params: payload.params || {},
+          iat: payload.iat,
+          exp: payload.exp
+        }
+      });
+      if (hasLocalStorage())
+        localStorage.setItem(TOKEN_PREFIX + scope, token);
     } catch {
-      this.decoded = null;
+      this.scopes.delete(scope);
+      if (hasLocalStorage())
+        localStorage.removeItem(TOKEN_PREFIX + scope);
     }
   }
-  getToken() {
-    return this.token;
+  loadPersisted() {
+    if (!hasLocalStorage())
+      return;
+    for (let i = 0;i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith(TOKEN_PREFIX)) {
+        const scope = key.slice(TOKEN_PREFIX.length);
+        const raw = localStorage.getItem(key);
+        if (raw) {
+          try {
+            const parts = raw.split(".");
+            if (parts.length !== 3)
+              continue;
+            const payload = JSON.parse(atob(parts[1]));
+            this.scopes.set(scope, {
+              raw,
+              decoded: {
+                tokenName: payload.tokenName,
+                params: payload.params || {},
+                iat: payload.iat,
+                exp: payload.exp
+              }
+            });
+          } catch {
+            localStorage.removeItem(key);
+          }
+        }
+      }
+    }
   }
-  getDecoded() {
-    return this.decoded;
+  getToken(scope = "default") {
+    return this.scopes.get(scope)?.raw ?? null;
   }
-  getParams() {
-    return this.decoded?.params ?? null;
+  getDecoded(scope = "default") {
+    return this.scopes.get(scope)?.decoded ?? null;
   }
-  getTokenName() {
-    return this.decoded?.tokenName ?? null;
+  getParams(scope = "default") {
+    return this.scopes.get(scope)?.decoded?.params ?? null;
   }
-  isAuthenticated() {
-    return this.decoded !== null;
+  getTokenName(scope = "default") {
+    return this.scopes.get(scope)?.decoded?.tokenName ?? null;
   }
-  isExpired() {
-    if (!this.decoded?.exp)
+  isAuthenticated(scope) {
+    if (scope !== undefined) {
+      return this.scopes.has(scope);
+    }
+    return this.scopes.size > 0;
+  }
+  isExpired(scope = "default") {
+    const entry = this.scopes.get(scope);
+    if (!entry?.decoded?.exp)
       return false;
-    return Date.now() > this.decoded.exp;
+    return Date.now() > entry.decoded.exp;
+  }
+  getAllScopes() {
+    return Array.from(this.scopes.keys());
+  }
+  clear() {
+    if (hasLocalStorage()) {
+      for (const scope of this.scopes.keys()) {
+        localStorage.removeItem(TOKEN_PREFIX + scope);
+      }
+    }
+    this.scopes.clear();
   }
 }
 // src/adapters/wire.ts
 class Wire {
-  token = null;
   baseUrl;
   constructor(baseUrl) {
     this.baseUrl = baseUrl;
   }
-  setAuthToken(token) {
-    this.token = token;
-  }
-  getAuthToken() {
-    return this.token;
-  }
   getBaseUrl() {
     return this.baseUrl;
   }
-  async fetch(endpoint, options = {}) {
+  async fetch(endpoint, options = {}, auth) {
     const headers = new Headers(options.headers);
-    if (this.token) {
-      headers.set("Authorization", `Bearer ${this.token}`);
+    if (auth?.token) {
+      headers.set("Authorization", `Bearer ${auth.token}`);
+    }
+    if (auth?.scope) {
+      headers.set("X-Arc-Scope", auth.scope);
     }
     if (options.body && !headers.has("Content-Type") && typeof options.body === "string") {
       headers.set("Content-Type", "application/json");
@@ -83,7 +138,7 @@ class CommandWire extends Wire {
   constructor(baseUrl) {
     super(baseUrl);
   }
-  async executeCommand(name, params) {
+  async executeCommand(name, params, auth) {
     const hasFile = this.containsFile(params);
     let body;
     let headers;
@@ -97,7 +152,7 @@ class CommandWire extends Wire {
       method: "POST",
       body,
       headers
-    });
+    }, auth);
     if (!response.ok) {
       const errorText = await response.text();
       throw new Error(`Command ${name} failed: ${response.status} ${errorText}`);
@@ -135,24 +190,39 @@ class EventWire {
   instanceId;
   ws = null;
   state = "disconnected";
-  token = null;
+  scopeTokens = new Map;
   lastHostEventId = null;
   pendingEvents = [];
   onEventCallback;
   onSyncedCallback;
   reconnectTimeout;
   syncRequested = false;
+  viewSubscriptions = new Map;
+  viewSubCounter = 0;
+  pendingViewSubs = [];
   constructor(baseUrl) {
     this.baseUrl = baseUrl;
     this.instanceId = ++eventWireInstanceCounter;
   }
-  setAuthToken(token) {
-    this.token = token;
-    if (this.state === "connected") {
-      this.disconnect();
-      this.connect();
+  setScopeToken(scope, token) {
+    if (token === null) {
+      this.scopeTokens.delete(scope);
+    } else {
+      this.scopeTokens.set(scope, token);
+    }
+    if (this.state === "connected" && this.ws) {
+      if (token !== null) {
+        this.ws.send(JSON.stringify({
+          type: "scope:auth",
+          scope,
+          token
+        }));
+      }
     }
   }
+  hasScopeTokens() {
+    return this.scopeTokens.size > 0;
+  }
   setLastHostEventId(id) {
     this.lastHostEventId = id;
   }
@@ -171,15 +241,16 @@ class EventWire {
       const host = typeof window !== "undefined" ? window.location.host : "localhost";
       wsUrl = `${protocol}//${host}${this.baseUrl}`;
     }
-    const tokenParam = this.token ? `?token=${this.token}` : "";
-    const url = `${wsUrl}/ws${tokenParam}`;
+    const url = `${wsUrl}/ws`;
     try {
       this.ws = new WebSocket(url);
       this.ws.onopen = () => {
         if (this.ws && this.ws.readyState === WebSocket.OPEN) {
           this.state = "connected";
+          this.sendAllScopeTokens();
           this.requestSync();
           this.flushPendingEvents();
+          this.flushPendingViewSubs();
         } else {
           console.log(`[EventWire] onopen called but ws is not OPEN, readyState:`, this.ws?.readyState);
         }
@@ -254,9 +325,45 @@ class EventWire {
   onSynced(callback) {
     this.onSyncedCallback = callback;
   }
+  subscribeQuery(descriptor, callback, scope) {
+    const subscriptionId = `qs_${++this.viewSubCounter}_${Date.now()}`;
+    this.viewSubscriptions.set(subscriptionId, callback);
+    if (this.state === "connected" && this.ws) {
+      this.ws.send(JSON.stringify({
+        type: "subscribe-query",
+        subscriptionId,
+        descriptor,
+        scope
+      }));
+    } else {
+      this.pendingViewSubs.push({ subscriptionId, descriptor, scope });
+    }
+    return subscriptionId;
+  }
+  unsubscribeQuery(subscriptionId) {
+    this.viewSubscriptions.delete(subscriptionId);
+    if (this.state === "connected" && this.ws) {
+      this.ws.send(JSON.stringify({
+        type: "unsubscribe-query",
+        subscriptionId
+      }));
+    }
+    this.pendingViewSubs = this.pendingViewSubs.filter((s) => s.subscriptionId !== subscriptionId);
+  }
   getState() {
     return this.state;
   }
+  sendAllScopeTokens() {
+    if (!this.ws || this.state !== "connected")
+      return;
+    for (const [scope, token] of this.scopeTokens) {
+      this.ws.send(JSON.stringify({
+        type: "scope:auth",
+        scope,
+        token
+      }));
+    }
+  }
   handleMessage(message) {
     switch (message.type) {
       case "events":
@@ -274,6 +381,13 @@ class EventWire {
           this.lastHostEventId = message.lastHostEventId;
         }
         break;
+      case "query-data": {
+        const cb = this.viewSubscriptions.get(message.subscriptionId);
+        if (cb) {
+          cb(message.data);
+        }
+        break;
+      }
       case "command-result":
         break;
       case "error":
@@ -298,6 +412,19 @@ class EventWire {
       this.pendingEvents = [];
     }
   }
+  flushPendingViewSubs() {
+    if (!this.ws || this.state !== "connected")
+      return;
+    for (const sub of this.pendingViewSubs) {
+      this.ws.send(JSON.stringify({
+        type: "subscribe-query",
+        subscriptionId: sub.subscriptionId,
+        descriptor: sub.descriptor,
+        scope: sub.scope
+      }));
+    }
+    this.pendingViewSubs = [];
+  }
   scheduleReconnect() {
     if (this.reconnectTimeout)
       return;
@@ -312,18 +439,18 @@ class QueryWire extends Wire {
   constructor(baseUrl) {
     super(baseUrl);
   }
-  async query(viewName, options = {}) {
+  async query(viewName, options = {}, auth) {
     const response = await this.fetch(`/query/${viewName}`, {
       method: "POST",
       body: JSON.stringify(options)
-    });
+    }, auth);
     if (!response.ok) {
       const errorText = await response.text();
       throw new Error(`Query ${viewName} failed: ${response.status} ${errorText}`);
     }
     return await response.json();
   }
-  stream(viewName, options, callback, token) {
+  stream(viewName, options, callback, auth) {
     const params = new URLSearchParams;
     if (options?.where) {
       params.set("where", JSON.stringify(options.where));
@@ -334,9 +461,11 @@ class QueryWire extends Wire {
     if (options?.limit) {
       params.set("limit", String(options.limit));
     }
-    const authToken = token ?? this.getAuthToken();
-    if (authToken) {
-      params.set("token", authToken);
+    if (auth?.token) {
+      params.set("token", auth.token);
+    }
+    if (auth?.scope) {
+      params.set("scope", auth.scope);
     }
     const queryString = params.toString();
     const url = `${this.getBaseUrl()}/stream/${viewName}${queryString ? `?${queryString}` : ""}`;
@@ -453,6 +582,18 @@ class LocalEventPublisher {
     }
   }
   async notifySubscribers(event) {
+    const wildcardSubs = this.subscribers.get("*");
+    if (wildcardSubs) {
+      for (const callback of wildcardSubs) {
+        try {
+          const result = callback(event);
+          if (result instanceof Promise)
+            await result;
+        } catch (error) {
+          console.error(`[EventPublisher] Wildcard subscriber error:`, error);
+        }
+      }
+    }
     const subs = this.subscribers.get(event.type);
     if (!subs || subs.size === 0)
       return;
@@ -598,8 +739,8 @@ class ArcOptional {
     return null;
   }
   deserialize(value) {
-    if (!value)
-      return null;
+    if (value == null)
+      return;
     return this.parent.deserialize(value);
   }
   validate(value) {
@@ -636,6 +777,9 @@ class ArcBranded {
     this.parent = parent;
     this.brand = brand;
   }
+  get name() {
+    return this.brand;
+  }
   serialize(value) {
     return this.parent.serialize(value);
   }
@@ -1109,187 +1253,6 @@ function object(element) {
   return new ArcObject(element);
 }
 
-// src/context-element/context-element.ts
-class ArcContextElement {
-  name;
-  constructor(name) {
-    this.name = name;
-  }
-}
-
-// src/context-element/command/command.ts
-class ArcCommand extends ArcContextElement {
-  data;
-  constructor(data) {
-    super(data.name);
-    this.data = data;
-  }
-  description(description) {
-    return new ArcCommand({
-      ...this.data,
-      description
-    });
-  }
-  get isPublic() {
-    return !this.hasProtections;
-  }
-  query(elements) {
-    return new ArcCommand({
-      ...this.data,
-      queryElements: elements
-    });
-  }
-  mutate(elements) {
-    return new ArcCommand({
-      ...this.data,
-      mutationElements: elements
-    });
-  }
-  withParams(schema) {
-    return new ArcCommand({
-      ...this.data,
-      params: schema instanceof ArcObject ? schema : new ArcObject(schema)
-    });
-  }
-  withResult(...schemas) {
-    return new ArcCommand({
-      ...this.data,
-      results: schemas
-    });
-  }
-  handle(handler) {
-    return new ArcCommand({
-      ...this.data,
-      handler
-    });
-  }
-  protectBy(token, check) {
-    const existingProtections = this.data.protections || [];
-    return new ArcCommand({
-      ...this.data,
-      protections: [...existingProtections, { token, check }]
-    });
-  }
-  get hasProtections() {
-    return (this.data.protections?.length ?? 0) > 0;
-  }
-  get protections() {
-    return this.data.protections || [];
-  }
-  async verifyProtections(tokens) {
-    if (!this.data.protections || this.data.protections.length === 0) {
-      return true;
-    }
-    for (const protection of this.data.protections) {
-      const tokenInstance = tokens.find((t) => t.getTokenDefinition() === protection.token);
-      if (!tokenInstance) {
-        return false;
-      }
-      const allowed = await protection.check(tokenInstance);
-      if (!allowed) {
-        return false;
-      }
-    }
-    return true;
-  }
-  async init(environment, adapters) {
-    if (environment === "server" && this.data.handler && adapters.commandWire?.registerCommandHandler) {
-      adapters.commandWire.registerCommandHandler(this.data.name, async (params) => {
-        const executeFunc = this.mutateContext(adapters);
-        return await executeFunc(params);
-      });
-    }
-  }
-  mutateContext(adapters) {
-    const executeFunc = async (params) => {
-      if (this.data.handler) {
-        return await this.executeLocally(params, adapters);
-      }
-      if (!adapters.commandWire) {
-        throw new Error(`Command "${this.data.name}" has no handler and no commandWire adapter available for remote execution`);
-      }
-      return await adapters.commandWire.executeCommand(this.data.name, params);
-    };
-    return Object.assign(executeFunc, { params: this.data.params });
-  }
-  async executeLocally(params, adapters) {
-    if (!this.data.handler) {
-      throw new Error(`Command "${this.data.name}" has no handler`);
-    }
-    const context2 = this.buildCommandContext(adapters);
-    const result = await this.data.handler(context2, params);
-    return result;
-  }
-  buildCommandContext(adapters) {
-    const context2 = {};
-    const elementMap = new Map;
-    for (const element of this.data.queryElements) {
-      if (element.queryContext) {
-        const elementContext = element.queryContext(adapters);
-        context2[element.name] = elementContext;
-        elementMap.set(element, elementContext);
-      }
-    }
-    for (const element of this.data.mutationElements) {
-      if (element.mutateContext) {
-        const elementContext = element.mutateContext(adapters);
-        context2[element.name] = elementContext;
-        elementMap.set(element, elementContext);
-      }
-    }
-    context2.get = (element) => {
-      const cached = elementMap.get(element);
-      if (cached)
-        return cached;
-      if (element.queryContext) {
-        const ctx = element.queryContext(adapters);
-        elementMap.set(element, ctx);
-        return ctx;
-      }
-      if (element.mutateContext) {
-        const ctx = element.mutateContext(adapters);
-        elementMap.set(element, ctx);
-        return ctx;
-      }
-      throw new Error(`Element "${element.name}" has no context available`);
-    };
-    if (this.hasProtections && adapters.authAdapter) {
-      const decoded = adapters.authAdapter.getDecoded();
-      if (decoded) {
-        context2.$auth = {
-          params: decoded.params,
-          tokenName: decoded.tokenName
-        };
-      } else {
-        throw new Error(`Command "${this.data.name}" requires authentication but no valid token found`);
-      }
-    }
-    return context2;
-  }
-  toJsonSchema() {
-    const parametersSchema = this.data.params ? this.data.params.toJsonSchema?.() ?? {
-      type: "object",
-      properties: {}
-    } : { type: "object", properties: {} };
-    return {
-      type: "function",
-      name: this.data.name,
-      description: this.data.description ?? undefined,
-      parameters: parametersSchema,
-      strict: true
-    };
-  }
-}
-function command(name) {
-  return new ArcCommand({
-    name,
-    params: null,
-    results: [],
-    queryElements: [],
-    mutationElements: [],
-    protections: []
-  });
-}
 // src/elements/abstract-primitive.ts
 class ArcPrimitive extends ArcAbstract {
   serialize(value) {
@@ -1582,8 +1545,28 @@ function number() {
   return new ArcNumber;
 }
 
-// src/context-element/event/event.ts
-class ArcEvent extends ArcContextElement {
+// src/fragment/arc-fragment.ts
+class ArcFragmentBase {
+  is(type) {
+    return this.types.includes(type);
+  }
+}
+
+// src/context-element/context-element.ts
+class ArcContextElement extends ArcFragmentBase {
+  name;
+  types = ["context-element"];
+  get id() {
+    return this.name;
+  }
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+}
+
+// src/context-element/event/event.ts
+class ArcEvent extends ArcContextElement {
   data;
   eventId = id("event");
   constructor(data) {
@@ -1615,11 +1598,523 @@ class ArcEvent extends ArcContextElement {
       }
     };
   }
-  protectBy(token, protectionFn) {
+  protectBy(token, protectionFn) {
+    const existingProtections = this.data.protections || [];
+    return new ArcEvent({
+      ...this.data,
+      protections: [...existingProtections, { token, protectionFn }]
+    });
+  }
+  get hasProtections() {
+    return (this.data.protections?.length ?? 0) > 0;
+  }
+  get protections() {
+    return this.data.protections || [];
+  }
+  getProtectionFor(tokenInstance) {
+    if (!this.data.protections) {
+      return null;
+    }
+    for (const protection of this.data.protections) {
+      if (tokenInstance.getTokenDefinition() === protection.token) {
+        return protection.protectionFn(tokenInstance.params);
+      }
+    }
+    return null;
+  }
+  tags(tagFields) {
+    return new ArcEvent({
+      ...this.data,
+      tagFields
+    });
+  }
+  get tagFields() {
+    return this.data.tagFields || [];
+  }
+  static _sharedSchema = null;
+  static sharedDatabaseStoreSchema() {
+    if (ArcEvent._sharedSchema) {
+      return ArcEvent._sharedSchema;
+    }
+    const eventsSchema = new ArcObject({
+      _id: new ArcString().primaryKey(),
+      type: new ArcString().index(),
+      payload: new ArcString,
+      createdAt: new ArcString().index()
+    });
+    const tagsSchema = new ArcObject({
+      _id: new ArcString().primaryKey(),
+      eventId: new ArcString().index(),
+      tagKey: new ArcString().index(),
+      tagValue: new ArcString().index()
+    });
+    const syncStatusSchema = new ArcObject({
+      _id: new ArcString().primaryKey(),
+      eventId: new ArcString().index(),
+      synced: new ArcBoolean().index(),
+      timestamp: new ArcNumber,
+      retryCount: new ArcNumber
+    });
+    ArcEvent._sharedSchema = {
+      tables: [
+        { name: "events", schema: eventsSchema },
+        { name: "event_tags", schema: tagsSchema },
+        { name: "event_sync_status", schema: syncStatusSchema }
+      ]
+    };
+    return ArcEvent._sharedSchema;
+  }
+  databaseStoreSchema() {
+    return ArcEvent.sharedDatabaseStoreSchema();
+  }
+}
+function event(name, payload) {
+  return new ArcEvent({
+    name,
+    payload: payload ? payload instanceof ArcObject ? payload : new ArcObject(payload) : undefined,
+    protections: []
+  });
+}
+
+// src/context-element/aggregate/aggregate-base.ts
+class AggregateBase {
+  value;
+  _id;
+  #adapters;
+  constructor(row, adapters) {
+    this._id = row._id;
+    const { _id, ...rest } = row;
+    this.value = rest;
+    this.#adapters = adapters;
+  }
+  toJSON() {
+    return { _id: this._id, ...this.value };
+  }
+  get ctx() {
+    const events = this.constructor.__aggregateEvents ?? [];
+    const adapters = this.#adapters;
+    const result = {};
+    for (const entry of events) {
+      const arcEvent = entry.event;
+      result[arcEvent.name] = {
+        emit: async (payload) => {
+          if (!adapters.eventPublisher) {
+            throw new Error(`Cannot emit event "${arcEvent.name}": no eventPublisher adapter available`);
+          }
+          const eventInstance = {
+            type: arcEvent.name,
+            payload,
+            id: `${Date.now()}_${Math.random().toString(36).slice(2)}`,
+            createdAt: new Date
+          };
+          await adapters.eventPublisher.publish(eventInstance);
+        }
+      };
+    }
+    return result;
+  }
+}
+
+// src/context-element/aggregate/aggregate-builder.ts
+function createInlineEvent(eventName, payload) {
+  const po = payload instanceof ArcObject ? payload : new ArcObject(payload);
+  return new ArcEvent({
+    name: eventName,
+    payload: po,
+    protections: []
+  });
+}
+
+class AggregateBuilder {
+  _name;
+  _id;
+  _schema;
+  _events;
+  _protections;
+  _mutateMethods;
+  _queryMethods;
+  constructor(name, id2, schema, events = [], protections = [], mutateMethods = [], queryMethods = []) {
+    this._name = name;
+    this._id = id2;
+    this._schema = schema;
+    this._events = events;
+    this._protections = protections;
+    this._mutateMethods = mutateMethods;
+    this._queryMethods = queryMethods;
+  }
+  protectBy(token, protectionFn) {
+    return new AggregateBuilder(this._name, this._id, this._schema, this._events, [...this._protections, { token, protectionFn }], this._mutateMethods, this._queryMethods);
+  }
+  event(eventName, payload, handler) {
+    const arcEvent = createInlineEvent(eventName, payload);
+    const entry = {
+      event: arcEvent,
+      handler,
+      isInline: true,
+      isPublic: false
+    };
+    return new AggregateBuilder(this._name, this._id, this._schema, [...this._events, entry], this._protections, this._mutateMethods, this._queryMethods);
+  }
+  publicEvent(eventName, payload, handler) {
+    const arcEvent = createInlineEvent(eventName, payload);
+    const entry = {
+      event: arcEvent,
+      handler,
+      isInline: true,
+      isPublic: true
+    };
+    return new AggregateBuilder(this._name, this._id, this._schema, [...this._events, entry], this._protections, this._mutateMethods, this._queryMethods);
+  }
+  handleEvent(arcEvent, handler) {
+    const entry = {
+      event: arcEvent,
+      handler,
+      isInline: false,
+      isPublic: false
+    };
+    return new AggregateBuilder(this._name, this._id, this._schema, [...this._events, entry], this._protections, this._mutateMethods, this._queryMethods);
+  }
+  mutateMethod(methodName, config, handler) {
+    const paramsObj = config.params instanceof ArcObject ? config.params : new ArcObject(config.params);
+    const entry = {
+      name: methodName,
+      params: paramsObj,
+      handler
+    };
+    return new AggregateBuilder(this._name, this._id, this._schema, this._events, this._protections, [...this._mutateMethods, entry], this._queryMethods);
+  }
+  cron(expression) {
+    if (this._mutateMethods.length === 0) {
+      throw new Error("cron() must be called immediately after mutateMethod()");
+    }
+    const methods = [...this._mutateMethods];
+    const lastIndex = methods.length - 1;
+    methods[lastIndex] = { ...methods[lastIndex], cronExpression: expression };
+    return new AggregateBuilder(this._name, this._id, this._schema, this._events, this._protections, methods, this._queryMethods);
+  }
+  clientQuery(methodName, handler) {
+    const entry = {
+      name: methodName,
+      handler
+    };
+    return new AggregateBuilder(this._name, this._id, this._schema, this._events, this._protections, this._mutateMethods, [...this._queryMethods, entry]);
+  }
+  build() {
+    const name = this._name;
+    const id2 = this._id;
+    const schema = this._schema;
+    const events = this._events;
+    const protections = this._protections;
+    const mutateMethods = this._mutateMethods;
+    const queryMethods = this._queryMethods;
+    const cronMethods = [];
+    for (const method of mutateMethods) {
+      if (method.cronExpression) {
+        cronMethods.push({
+          aggregateName: name,
+          methodName: method.name,
+          cronExpression: method.cronExpression
+        });
+      }
+    }
+    const AggregateClass = class extends AggregateBase {
+      static __aggregateName = name;
+      static __aggregateId = id2;
+      static __aggregateSchema = schema;
+      static __aggregateEvents = events;
+      static __aggregateProtections = protections;
+      static __aggregateMutateMethods = mutateMethods;
+      static __aggregateQueryMethods = queryMethods;
+      static __aggregateCronMethods = cronMethods;
+      static getEvent(eventName) {
+        const entry = events.find((e) => e.isPublic && e.event.name === eventName);
+        return entry?.event;
+      }
+    };
+    Object.defineProperty(AggregateClass, "name", {
+      value: `${name}Aggregate`
+    });
+    return AggregateClass;
+  }
+}
+function aggregate(name, id2, schema) {
+  const schemaObj = schema instanceof ArcObject ? schema : new ArcObject(schema);
+  return new AggregateBuilder(name, id2, schemaObj, [], [], [], []);
+}
+// src/context-element/aggregate/aggregate-element.ts
+class ArcAggregateElement extends ArcContextElement {
+  ctor;
+  schema;
+  constructor(ctor) {
+    super(ctor.__aggregateName);
+    this.ctor = ctor;
+    this.schema = ctor.__aggregateSchema;
+  }
+  getHandlers() {
+    const handlers = {};
+    for (const entry of this.ctor.__aggregateEvents) {
+      handlers[entry.event.name] = entry.handler;
+    }
+    return handlers;
+  }
+  getElements() {
+    return this.ctor.__aggregateEvents.map((e) => e.event);
+  }
+  queryContext(adapters) {
+    const privateQuery = this.buildPrivateQuery(adapters);
+    const queryMethods = this.ctor.__aggregateQueryMethods ?? [];
+    const auth = this.getAuth(adapters);
+    const result = {};
+    for (const method of queryMethods) {
+      result[method.name] = (...args) => {
+        const ctx = { $query: privateQuery, $auth: auth };
+        return method.handler(ctx, ...args);
+      };
+    }
+    return result;
+  }
+  buildPrivateQuery(adapters) {
+    const viewName = this.ctor.__aggregateName;
+    const protections = this.ctor.__aggregateProtections;
+    const Ctor = this.ctor;
+    const getReadRestrictions = () => {
+      if (protections.length === 0)
+        return null;
+      if (!adapters.authAdapter)
+        return false;
+      const decoded = adapters.authAdapter.getDecoded();
+      if (!decoded)
+        return false;
+      for (const protection of protections) {
+        if (protection.token.name === decoded.tokenName) {
+          const restrictions = protection.protectionFn(decoded.params);
+          if (restrictions === false)
+            return false;
+          return restrictions ?? {};
+        }
+      }
+      return false;
+    };
+    const applyRestrictions = (options) => {
+      const restrictions = getReadRestrictions();
+      if (restrictions === false)
+        return false;
+      if (!restrictions || Object.keys(restrictions).length === 0) {
+        return options || {};
+      }
+      const where = { ...options?.where || {}, ...restrictions };
+      return { ...options, where };
+    };
+    const findRows = async (options) => {
+      if (adapters.dataStorage) {
+        return adapters.dataStorage.getStore(viewName).find(options);
+      }
+      if (adapters.streamingCache) {
+        return adapters.streamingCache.getStore(viewName).find(options);
+      }
+      if (adapters.queryWire) {
+        return adapters.queryWire.query(viewName, options);
+      }
+      return [];
+    };
+    const schema = this.ctor.__aggregateSchema;
+    const deserializeRow = (row) => {
+      const { _id, ...rest } = row;
+      return { _id, ...schema.deserialize(rest) };
+    };
+    return {
+      find: async (options, mapper) => {
+        const restricted = applyRestrictions(options);
+        if (restricted === false)
+          return [];
+        const rows = await findRows(restricted);
+        return mapper ? rows.map((row) => new mapper(row, adapters)) : rows.map(deserializeRow);
+      },
+      findOne: async (where, mapper) => {
+        const restrictions = getReadRestrictions();
+        if (restrictions === false)
+          return;
+        const mergedWhere = restrictions && Object.keys(restrictions).length > 0 ? { ...where, ...restrictions } : where;
+        const rows = await findRows({ where: mergedWhere });
+        const row = rows[0];
+        if (!row)
+          return;
+        return mapper ? new mapper(row, adapters) : deserializeRow(row);
+      }
+    };
+  }
+  getAuth(adapters) {
+    if (adapters.authAdapter) {
+      const decoded = adapters.authAdapter.getDecoded();
+      return decoded ? { params: decoded.params, tokenName: decoded.tokenName } : { params: {}, tokenName: "" };
+    }
+    return { params: {}, tokenName: "" };
+  }
+  mutateContext(adapters) {
+    const events = this.ctor.__aggregateEvents;
+    const privateQuery = this.buildPrivateQuery(adapters);
+    const auth = this.getAuth(adapters);
+    const buildMutateMethodCtx = () => {
+      const ctx = {};
+      for (const entry of events) {
+        const arcEvent = entry.event;
+        ctx[arcEvent.name] = {
+          emit: async (payload) => {
+            if (!adapters.eventPublisher) {
+              throw new Error(`Cannot emit event "${arcEvent.name}": no eventPublisher adapter available`);
+            }
+            const eventInstance = {
+              type: arcEvent.name,
+              payload,
+              id: `${Date.now()}_${Math.random().toString(36).slice(2)}`,
+              createdAt: new Date
+            };
+            await adapters.eventPublisher.publish(eventInstance);
+          }
+        };
+      }
+      ctx.$auth = auth;
+      ctx.$query = privateQuery;
+      return ctx;
+    };
+    const result = {};
+    for (const method of this.ctor.__aggregateMutateMethods ?? []) {
+      result[method.name] = async (params) => {
+        if (!method.handler) {
+          if (!adapters.commandWire) {
+            throw new Error(`Method "${method.name}" is server-only but no commandWire (WebSocket) is available.`);
+          }
+          const wireAuth = adapters.scope ? { scope: adapters.scope.scopeName, token: adapters.scope.getToken() } : undefined;
+          return adapters.commandWire.executeCommand(`${this.ctor.__aggregateName}.${method.name}`, params, wireAuth);
+        }
+        const ctx = buildMutateMethodCtx();
+        return method.handler(ctx, params);
+      };
+    }
+    return result;
+  }
+  databaseStoreSchema() {
+    const viewName = this.ctor.__aggregateName;
+    const idSchema = new ArcObject({
+      _id: new ArcString().primaryKey()
+    });
+    const viewSchema = idSchema.merge(this.ctor.__aggregateSchema.rawShape || {});
+    const eventSchema = ArcEvent.sharedDatabaseStoreSchema();
+    return {
+      tables: [
+        {
+          name: viewName,
+          schema: viewSchema
+        },
+        ...eventSchema.tables
+      ]
+    };
+  }
+}
+// src/context-element/aggregate/index.ts
+function aggregateContextElement(ctor) {
+  return new ArcAggregateElement(ctor);
+}
+// src/context-element/element-context.ts
+function buildElementContext(queryElements, mutationElements, adapters) {
+  const context2 = {};
+  const elementMap = new Map;
+  for (const element of queryElements) {
+    if (element.queryContext) {
+      const ctx = element.queryContext(adapters);
+      context2[element.name] = ctx;
+      elementMap.set(element, ctx);
+    }
+  }
+  for (const element of mutationElements) {
+    if (element.mutateContext) {
+      const ctx = element.mutateContext(adapters);
+      context2[element.name] = ctx;
+      elementMap.set(element, ctx);
+    }
+  }
+  context2.get = (element) => {
+    const cached = elementMap.get(element);
+    if (cached)
+      return cached;
+    if (element.queryContext) {
+      const ctx = element.queryContext(adapters);
+      elementMap.set(element, ctx);
+      return ctx;
+    }
+    if (element.mutateContext) {
+      const ctx = element.mutateContext(adapters);
+      elementMap.set(element, ctx);
+      return ctx;
+    }
+    throw new Error(`Element "${element.name}" has no context available`);
+  };
+  context2.query = (element) => {
+    if (!element.queryContext) {
+      throw new Error(`Element "${element.name}" has no queryContext`);
+    }
+    return element.queryContext(adapters);
+  };
+  context2.mutate = (element) => {
+    if (!element.mutateContext) {
+      throw new Error(`Element "${element.name}" has no mutateContext`);
+    }
+    return element.mutateContext(adapters);
+  };
+  return context2;
+}
+
+// src/context-element/command/command.ts
+class ArcCommand extends ArcContextElement {
+  data;
+  constructor(data) {
+    super(data.name);
+    this.data = data;
+  }
+  description(description) {
+    return new ArcCommand({
+      ...this.data,
+      description
+    });
+  }
+  get isPublic() {
+    return !this.hasProtections;
+  }
+  query(elements) {
+    return new ArcCommand({
+      ...this.data,
+      queryElements: elements
+    });
+  }
+  mutate(elements) {
+    return new ArcCommand({
+      ...this.data,
+      mutationElements: elements
+    });
+  }
+  withParams(schema) {
+    return new ArcCommand({
+      ...this.data,
+      params: schema instanceof ArcObject ? schema : new ArcObject(schema)
+    });
+  }
+  withResult(...schemas) {
+    return new ArcCommand({
+      ...this.data,
+      results: schemas
+    });
+  }
+  handle(handler) {
+    return new ArcCommand({
+      ...this.data,
+      handler
+    });
+  }
+  protectBy(token, check) {
     const existingProtections = this.data.protections || [];
-    return new ArcEvent({
+    return new ArcCommand({
       ...this.data,
-      protections: [...existingProtections, { token, protectionFn }]
+      protections: [...existingProtections, { token, check }]
     });
   }
   get hasProtections() {
@@ -1628,67 +2123,86 @@ class ArcEvent extends ArcContextElement {
   get protections() {
     return this.data.protections || [];
   }
-  getProtectionFor(tokenInstance) {
-    if (!this.data.protections) {
-      return null;
+  async verifyProtections(tokens) {
+    if (!this.data.protections || this.data.protections.length === 0) {
+      return true;
     }
     for (const protection of this.data.protections) {
-      if (tokenInstance.getTokenDefinition() === protection.token) {
-        return protection.protectionFn(tokenInstance.params);
+      const tokenInstance = tokens.find((t) => t.getTokenDefinition() === protection.token);
+      if (!tokenInstance) {
+        return false;
+      }
+      const allowed = await protection.check(tokenInstance);
+      if (!allowed) {
+        return false;
       }
     }
-    return null;
+    return true;
   }
-  tags(tagFields) {
-    return new ArcEvent({
-      ...this.data,
-      tagFields
-    });
+  async init(environment, adapters) {
+    if (environment === "server" && this.data.handler && adapters.commandWire?.registerCommandHandler) {
+      adapters.commandWire.registerCommandHandler(this.data.name, async (params) => {
+        const executeFunc = this.mutateContext(adapters);
+        return await executeFunc(params);
+      });
+    }
   }
-  get tagFields() {
-    return this.data.tagFields || [];
+  mutateContext(adapters) {
+    const executeFunc = async (params) => {
+      if (this.data.handler) {
+        return await this.executeLocally(params, adapters);
+      }
+      if (!adapters.commandWire) {
+        throw new Error(`Command "${this.data.name}" has no handler and no commandWire adapter available for remote execution`);
+      }
+      return await adapters.commandWire.executeCommand(this.data.name, params);
+    };
+    return Object.assign(executeFunc, { params: this.data.params });
   }
-  static _sharedSchema = null;
-  static sharedDatabaseStoreSchema() {
-    if (ArcEvent._sharedSchema) {
-      return ArcEvent._sharedSchema;
+  async executeLocally(params, adapters) {
+    if (!this.data.handler) {
+      throw new Error(`Command "${this.data.name}" has no handler`);
     }
-    const eventsSchema = new ArcObject({
-      _id: new ArcString().primaryKey(),
-      type: new ArcString().index(),
-      payload: new ArcString,
-      createdAt: new ArcString().index()
-    });
-    const tagsSchema = new ArcObject({
-      _id: new ArcString().primaryKey(),
-      eventId: new ArcString().index(),
-      tagKey: new ArcString().index(),
-      tagValue: new ArcString().index()
-    });
-    const syncStatusSchema = new ArcObject({
-      _id: new ArcString().primaryKey(),
-      eventId: new ArcString().index(),
-      synced: new ArcBoolean().index(),
-      timestamp: new ArcNumber,
-      retryCount: new ArcNumber
-    });
-    ArcEvent._sharedSchema = {
-      tables: [
-        { name: "events", schema: eventsSchema },
-        { name: "event_tags", schema: tagsSchema },
-        { name: "event_sync_status", schema: syncStatusSchema }
-      ]
-    };
-    return ArcEvent._sharedSchema;
+    const context2 = this.buildCommandContext(adapters);
+    const result = await this.data.handler(context2, params);
+    return result;
   }
-  databaseStoreSchema() {
-    return ArcEvent.sharedDatabaseStoreSchema();
+  buildCommandContext(adapters) {
+    const context2 = buildElementContext(this.data.queryElements, this.data.mutationElements, adapters);
+    if (this.hasProtections && adapters.authAdapter) {
+      const decoded = adapters.authAdapter.getDecoded();
+      if (decoded) {
+        context2.$auth = {
+          params: decoded.params,
+          tokenName: decoded.tokenName
+        };
+      } else {
+        throw new Error(`Command "${this.data.name}" requires authentication but no valid token found`);
+      }
+    }
+    return context2;
+  }
+  toJsonSchema() {
+    const parametersSchema = this.data.params ? this.data.params.toJsonSchema?.() ?? {
+      type: "object",
+      properties: {}
+    } : { type: "object", properties: {} };
+    return {
+      type: "function",
+      name: this.data.name,
+      description: this.data.description ?? undefined,
+      parameters: parametersSchema,
+      strict: true
+    };
   }
 }
-function event(name, payload) {
-  return new ArcEvent({
+function command(name) {
+  return new ArcCommand({
     name,
-    payload: payload ? payload instanceof ArcObject ? payload : new ArcObject(payload) : undefined,
+    params: null,
+    results: [],
+    queryElements: [],
+    mutationElements: [],
     protections: []
   });
 }
@@ -1941,38 +2455,7 @@ class ArcRoute extends ArcContextElement {
     return true;
   }
   buildContext(adapters, authParams) {
-    const context2 = {};
-    const elementMap = new Map;
-    for (const element of this.data.queryElements) {
-      if (element.queryContext) {
-        const elementContext = element.queryContext(adapters);
-        context2[element.name] = elementContext;
-        elementMap.set(element, elementContext);
-      }
-    }
-    for (const element of this.data.mutationElements) {
-      if (element.mutateContext) {
-        const elementContext = element.mutateContext(adapters);
-        context2[element.name] = elementContext;
-        elementMap.set(element, elementContext);
-      }
-    }
-    context2.get = (element) => {
-      const cached = elementMap.get(element);
-      if (cached)
-        return cached;
-      if (element.queryContext) {
-        const ctx = element.queryContext(adapters);
-        elementMap.set(element, ctx);
-        return ctx;
-      }
-      if (element.mutateContext) {
-        const ctx = element.mutateContext(adapters);
-        elementMap.set(element, ctx);
-        return ctx;
-      }
-      throw new Error(`Element "${element.name}" has no context available`);
-    };
+    const context2 = buildElementContext(this.data.queryElements, this.data.mutationElements, adapters);
     if (authParams) {
       context2.$auth = authParams;
     }
@@ -2394,6 +2877,9 @@ class StoreState {
   applySerializedChanges(changes) {
     return Promise.all(changes.map((change) => this.applyChange(change)));
   }
+  get listenerCount() {
+    return this.listeners.size;
+  }
   unsubscribe(listener4) {
     this.listeners.delete(listener4);
   }
@@ -3621,12 +4107,144 @@ class ArcStringEnum extends ArcAbstract {
 function stringEnum(...values) {
   return new ArcStringEnum(values);
 }
+// src/model/context-accessor.ts
+function buildContextAccessor(context2, adapters, contextMethod, onCall) {
+  const result = {};
+  for (const element2 of context2.elements) {
+    const ctxFn = element2[contextMethod];
+    if (typeof ctxFn !== "function")
+      continue;
+    const methods = ctxFn.call(element2, adapters);
+    if (!methods || typeof methods !== "object")
+      continue;
+    const wrapped = {};
+    for (const [methodName, method] of Object.entries(methods)) {
+      if (typeof method !== "function")
+        continue;
+      wrapped[methodName] = (...args) => onCall({ element: element2.name, method: methodName, args }, () => method(...args));
+    }
+    result[element2.name] = wrapped;
+  }
+  return result;
+}
+function executeDescriptor(descriptor, context2, adapters, contextMethod) {
+  const element2 = context2.get(descriptor.element);
+  if (!element2) {
+    throw new Error(`Element '${descriptor.element}' not found in context`);
+  }
+  const ctxFn = element2[contextMethod];
+  if (typeof ctxFn !== "function") {
+    throw new Error(`Element '${descriptor.element}' has no ${contextMethod}`);
+  }
+  const methods = ctxFn.call(element2, adapters);
+  const method = methods?.[descriptor.method];
+  if (typeof method !== "function") {
+    throw new Error(`Method '${descriptor.method}' not found on '${descriptor.element}'`);
+  }
+  return method(...descriptor.args);
+}
+
+// src/model/scoped-model.ts
+class ScopedModel {
+  context;
+  scopeName;
+  parent;
+  authAdapter;
+  scopedAdapters;
+  tokenListeners = new Set;
+  constructor(parent, scopeName) {
+    this.parent = parent;
+    this.context = parent.context;
+    this.scopeName = scopeName;
+    this.authAdapter = new AuthAdapter;
+    this.scopedAdapters = {
+      ...parent.getAdapters(),
+      authAdapter: this.authAdapter,
+      scope: this
+    };
+  }
+  setToken(token) {
+    this.authAdapter.setToken(token);
+    const eventWire = this.parent.getAdapters().eventWire;
+    if (eventWire) {
+      eventWire.setScopeToken(this.scopeName, token);
+      if (token && eventWire.getState() === "disconnected") {
+        eventWire.connect();
+      }
+    }
+    for (const listener4 of this.tokenListeners) {
+      listener4();
+    }
+  }
+  getToken() {
+    return this.authAdapter.getToken();
+  }
+  getDecoded() {
+    return this.authAdapter.getDecoded();
+  }
+  getParams() {
+    return this.authAdapter.getParams();
+  }
+  isAuthenticated() {
+    return this.authAdapter.isAuthenticated();
+  }
+  onTokenChange(listener4) {
+    this.tokenListeners.add(listener4);
+    return () => {
+      this.tokenListeners.delete(listener4);
+    };
+  }
+  getAdapters() {
+    return this.scopedAdapters;
+  }
+  getEnvironment() {
+    return this.parent.getEnvironment();
+  }
+  getAuth() {
+    return { scope: this.scopeName, token: this.getToken() };
+  }
+  executeCommand(name, params) {
+    const wire = this.parent.getAdapters().commandWire;
+    if (!wire) {
+      throw new Error(`Cannot execute command "${name}": no commandWire available.`);
+    }
+    return wire.executeCommand(name, params, this.getAuth());
+  }
+  remoteQuery(viewName, options) {
+    const wire = this.parent.getAdapters().queryWire;
+    if (!wire) {
+      throw new Error(`Cannot query "${viewName}": no queryWire available.`);
+    }
+    return wire.query(viewName, options, this.getAuth());
+  }
+  subscribeQuery(descriptor, callback) {
+    const wire = this.parent.getAdapters().eventWire;
+    if (!wire) {
+      throw new Error(`Cannot subscribe to query: no eventWire available.`);
+    }
+    return wire.subscribeQuery(descriptor, callback, this.scopeName);
+  }
+  get query() {
+    return buildContextAccessor(this.context, this.scopedAdapters, "queryContext", (descriptor) => descriptor);
+  }
+  get command() {
+    return buildContextAccessor(this.context, this.scopedAdapters, "mutateContext", (descriptor) => descriptor);
+  }
+  callQuery(descriptor) {
+    return executeDescriptor(descriptor, this.context, this.scopedAdapters, "queryContext");
+  }
+  callCommand(descriptor) {
+    return executeDescriptor(descriptor, this.context, this.scopedAdapters, "mutateContext");
+  }
+}
+
 // src/model/model.ts
 class Model {
   context;
   adapters;
   environment;
   initialized = false;
+  scopes = new Map;
   constructor(context2, options) {
     this.context = context2;
     this.adapters = options.adapters;
@@ -3653,6 +4271,14 @@ class Model {
   getEnvironment() {
     return this.environment;
   }
+  scope(name) {
+    let s = this.scopes.get(name);
+    if (!s) {
+      s = new ScopedModel(this, name);
+      this.scopes.set(name, s);
+    }
+    return s;
+  }
 }
 // src/model/mutation-executor/mutation-executor.ts
 function mutationExecutor(model) {
@@ -3675,6 +4301,8 @@ class StreamingQueryCache {
   stores = new Map;
   views = [];
   activeStreams = new Map;
+  pendingUnsubscribes = new Map;
+  static UNSUBSCRIBE_DELAY_MS = 5000;
   registerViews(views) {
     this.views = views;
     for (const view3 of views) {
@@ -3697,6 +4325,11 @@ class StreamingQueryCache {
     return this.activeStreams.has(viewName);
   }
   registerStream(viewName, createStream) {
+    const pending = this.pendingUnsubscribes.get(viewName);
+    if (pending) {
+      clearTimeout(pending);
+      this.pendingUnsubscribes.delete(viewName);
+    }
     const existing = this.activeStreams.get(viewName);
     if (existing) {
       existing.refCount++;
@@ -3721,14 +4354,37 @@ class StreamingQueryCache {
       return;
     stream.refCount--;
     if (stream.refCount <= 0) {
-      stream.unsubscribe();
-      this.activeStreams.delete(viewName);
+      const timeout = setTimeout(() => {
+        this.pendingUnsubscribes.delete(viewName);
+        const current = this.activeStreams.get(viewName);
+        if (current && current.refCount <= 0) {
+          current.unsubscribe();
+          this.activeStreams.delete(viewName);
+        }
+      }, StreamingQueryCache.UNSUBSCRIBE_DELAY_MS);
+      this.pendingUnsubscribes.set(viewName, timeout);
     }
   }
-  setViewData(viewName, items) {
+  subscribeQuery(descriptor, eventWire, scope) {
+    const key = descriptor.element;
+    const { unsubscribe } = this.registerStream(key, () => {
+      const subId = eventWire.subscribeQuery(descriptor, (data) => {
+        this.setViewData(descriptor.element, data);
+      }, scope);
+      return { unsubscribe: () => eventWire.unsubscribeQuery(subId) };
+    });
+    return unsubscribe;
+  }
+  setViewData(viewName, data) {
     const store = this.stores.get(viewName);
-    if (store) {
-      store.setAll(items);
+    if (!store)
+      return;
+    if (Array.isArray(data)) {
+      store.setAll(data);
+    } else if (data && typeof data === "object" && "_id" in data) {
+      store.setAll([data]);
+    } else {
+      store.setAll([]);
     }
   }
   async applyEvent(event3) {
@@ -3775,35 +4431,39 @@ class StreamingQueryCache {
 class StreamingStore {
   data = new Map;
   listeners = new Set;
+  initialized = false;
   hasData() {
-    return this.data.size > 0;
+    return this.initialized;
   }
   setAll(items) {
+    this.initialized = true;
     this.data.clear();
     for (const item of items) {
       this.data.set(item._id, item);
     }
-    this.notifyListeners();
+    this.notifyListeners(null);
   }
   set(id3, item) {
     this.data.set(id3, item);
-    this.notifyListeners();
+    this.notifyListeners([{ type: "set", id: id3, item }]);
   }
   modify(id3, updates) {
     const existing = this.data.get(id3);
     if (existing) {
-      this.data.set(id3, { ...existing, ...updates });
-      this.notifyListeners();
+      const updated = { ...existing, ...updates };
+      this.data.set(id3, updated);
+      this.notifyListeners([{ type: "set", id: id3, item: updated }]);
     }
   }
   remove(id3) {
     if (this.data.delete(id3)) {
-      this.notifyListeners();
+      this.notifyListeners([{ type: "delete", id: id3, item: null }]);
     }
   }
   clear() {
+    this.initialized = false;
     this.data.clear();
-    this.notifyListeners();
+    this.notifyListeners(null);
   }
   find(options = {}) {
     let results = Array.from(this.data.values());
@@ -3822,9 +4482,9 @@ class StreamingStore {
       this.listeners.delete(listener4);
     };
   }
-  notifyListeners() {
+  notifyListeners(events) {
     for (const listener4 of this.listeners) {
-      listener4();
+      listener4(events);
     }
   }
 }
@@ -3893,126 +4553,6 @@ class StreamingEventPublisher {
     }
   }
 }
-// src/streaming/streaming-live-query.ts
-function isStaticView(element2) {
-  return element2 && "items" in element2 && !("getHandlers" in element2);
-}
-function streamingLiveQuery(model, queryFn, callback, options) {
-  const { queryWire, cache, authToken } = options;
-  let currentResult = undefined;
-  const unsubscribers = [];
-  const queriedViews = new Set;
-  const staticViews = new Set;
-  const queryContext = new Proxy({}, {
-    get(_target, viewName) {
-      const element2 = model.context.get(viewName);
-      if (!element2) {
-        throw new Error(`View '${viewName}' not found in context`);
-      }
-      if (isStaticView(element2)) {
-        staticViews.add(viewName);
-        return element2.queryContext(model.getAdapters());
-      }
-      queriedViews.add(viewName);
-      return {
-        find: async (findOptions = {}) => {
-          const store = cache.getStore(viewName);
-          return store.find(findOptions);
-        },
-        findOne: async (where) => {
-          const store = cache.getStore(viewName);
-          return store.findOne(where);
-        }
-      };
-    }
-  });
-  const executeQuery = async () => {
-    const result = await queryFn(queryContext);
-    currentResult = result;
-    callback(result);
-  };
-  const setupStreams = async () => {
-    queriedViews.clear();
-    staticViews.clear();
-    await queryFn(queryContext);
-    if (queriedViews.size === 0 && staticViews.size > 0) {
-      executeQuery();
-      return;
-    }
-    for (const viewName of queriedViews) {
-      const store = cache.getStore(viewName);
-      const cacheUnsub = store.subscribe(() => {
-        executeQuery();
-      });
-      unsubscribers.push(cacheUnsub);
-      const { unsubscribe: streamUnsub, wasReused } = cache.registerStream(viewName, () => {
-        return queryWire.stream(viewName, {}, (data) => {
-          cache.setViewData(viewName, data);
-        }, authToken);
-      });
-      unsubscribers.push(streamUnsub);
-      if (wasReused && cache.hasData(viewName)) {
-        executeQuery();
-      }
-    }
-  };
-  setupStreams();
-  return {
-    get result() {
-      return currentResult;
-    },
-    unsubscribe: () => {
-      for (const unsub of unsubscribers) {
-        unsub();
-      }
-    }
-  };
-}
-// src/model/live-query/live-query.ts
-function liveQuery(model, queryFn, callback) {
-  let currentResult = undefined;
-  const adapters = model.getAdapters();
-  if (!adapters.dataStorage && adapters.streamingCache && adapters.queryWire) {
-    return streamingLiveQuery(model, queryFn, callback, {
-      queryWire: adapters.queryWire,
-      cache: adapters.streamingCache,
-      authToken: adapters.authAdapter?.getToken?.() ?? null
-    });
-  }
-  if (!adapters.dataStorage && !adapters.queryWire) {
-    throw new Error("liveQuery requires dataStorage or queryWire adapter");
-  }
-  const observableStorage = adapters.dataStorage ? observeQueries(adapters.dataStorage, () => {
-    executeQuery();
-  }) : null;
-  const observableAdapters = {
-    ...adapters,
-    dataStorage: observableStorage ?? undefined
-  };
-  const queryContext = new Proxy({}, {
-    get(_target, viewName) {
-      const element2 = model.context.get(viewName);
-      if (!element2) {
-        throw new Error(`View '${viewName}' not found in context`);
-      }
-      return element2.queryContext(observableAdapters);
-    }
-  });
-  const executeQuery = async () => {
-    const result = await queryFn(queryContext);
-    currentResult = result;
-    callback(result);
-  };
-  Promise.resolve().then(() => executeQuery());
-  return {
-    get result() {
-      return currentResult;
-    },
-    unsubscribe: () => {
-      observableStorage?.clear();
-    }
-  };
-}
 // src/token/secured-data-storage.ts
 class SecuredStoreState {
   store;
@@ -4396,7 +4936,6 @@ export {
   token,
   stringEnum,
   string,
-  streamingLiveQuery,
   staticView,
   secureDataStorage,
   route,
@@ -4408,11 +4947,11 @@ export {
   number,
   mutationExecutor,
   murmurHash,
-  liveQuery,
   listener,
   id,
   file,
   extractDatabaseAgnosticSchema,
+  executeDescriptor,
   event,
   deepMerge,
   date,
@@ -4421,11 +4960,15 @@ export {
   context,
   command,
   checkItemMatchesWhere,
+  buildElementContext,
+  buildContextAccessor,
   boolean,
   blob,
   array,
   applyOrderByAndLimit,
   any,
+  aggregateContextElement,
+  aggregate,
   Wire,
   TokenInstance,
   TokenCache,
@@ -4434,6 +4977,7 @@ export {
   StoreState,
   SecuredStoreState,
   SecuredDataStorage,
+  ScopedModel,
   QueryWire,
   ObservableDataStorage,
   Model,
@@ -4460,6 +5004,7 @@ export {
   ArcNumber,
   ArcListener,
   ArcId,
+  ArcFragmentBase,
   ArcFile,
   ArcEvent,
   ArcDate,
@@ -4472,5 +5017,8 @@ export {
   ArcBlob,
   ArcArray,
   ArcAny,
-  ArcAbstract
+  ArcAggregateElement,
+  ArcAbstract,
+  AggregateBuilder,
+  AggregateBase
 };