@arcote.tech/arc 0.7.14 → 0.7.16

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

@@ -25,7 +25,19 @@ export interface ReceivedEvent {
     authContext: EventAuthContext | null;
 }
 import type { ContextDescriptor } from "../model/context-accessor";
+import type { QueryResultChange } from "../model/live-query/diff";
 type EventWireState = "disconnected" | "connecting" | "connected";
+/**
+ * Callbacks for a live query subscription. The server answers
+ * `subscribe-query` with a full `query-snapshot` (the query's result),
+ * then pushes positional `query-changes` deltas computed by the server-side
+ * LiveQuery (re-execute + diff). Non-list results always arrive as
+ * snapshots.
+ */
+export interface QuerySubscriptionCallbacks {
+    onSnapshot: (result: any) => void;
+    onChanges: (changes: QueryResultChange[]) => void;
+}
 export declare class EventWire {
     private readonly baseUrl;
     private instanceId;
@@ -38,10 +50,19 @@ export declare class EventWire {
     private onSyncedCallback?;
     private reconnectTimeout?;
     private syncRequested;
-    private viewSubscriptions;
-    private viewSubCounter;
-    private pendingViewSubs;
-    constructor(baseUrl: string);
+    /** Active query subscriptions keyed by subscriptionId. Re-sent in full
+     *  on every (re)connect — the server drops its registry on disconnect,
+     *  and a fresh snapshot follows each re-subscribe. */
+    private querySubscriptions;
+    private querySubCounter;
+    /** When false (streaming mode), the client neither requests the event
+     *  log (`request-sync`) nor consumes domain events — live query
+     *  subscriptions are the only data channel. Local mode keeps full
+     *  event sync. */
+    private readonly enableEventSync;
+    constructor(baseUrl: string, options?: {
+        enableEventSync?: boolean;
+    });
     /**
      * Set a scope token. If connected, sends scope:auth message to server.
      * If token is null, removes the scope.
@@ -81,12 +102,14 @@ export declare class EventWire {
      */
     onSynced(callback: (localIds: string[]) => void): void;
     /**
-     * Subscribe to a server-side query via WebSocket.
-     * Server executes the descriptor and pushes results on change.
+     * Subscribe to a live query. The server executes the descriptor with
+     * tracking, responds with a full `query-snapshot`, then pushes positional
+     * `query-changes` deltas whenever the result changes. Callers dedupe
+     * identical descriptors (StreamingQueryCache).
      */
-    subscribeQuery(descriptor: ContextDescriptor, callback: (data: any[]) => void, scope?: string): string;
+    subscribeQuery(descriptor: ContextDescriptor, scope: string, callbacks: QuerySubscriptionCallbacks): string;
     /**
-     * Unsubscribe from a server-side query.
+     * Unsubscribe from a live query.
      */
     unsubscribeQuery(subscriptionId: string): void;
     /**
@@ -101,7 +124,13 @@ export declare class EventWire {
     private handleMessage;
     private requestSync;
     private flushPendingEvents;
-    private flushPendingViewSubs;
+    /**
+     * (Re)send every active query subscription. Called on each (re)connect —
+     * covers both subscriptions made while offline and re-establishing the
+     * server-side registry after a reconnect (server cleans it on disconnect).
+     * Each re-subscribe yields a fresh snapshot.
+     */
+    private sendAllQuerySubscriptions;
     private scheduleReconnect;
 }
 export {};

package/dist/adapters/index.d.ts

@@ -5,16 +5,15 @@
  * - Wire: Client-server communication
  * - CommandWire: Command execution over network
  * - EventPublisher: Event persistence and synchronization
- * - QueryWire: Remote view queries via HTTP/SSE
+ * - QueryWire: Remote view queries via HTTP
  * - DataStorage: Data persistence (defined elsewhere)
  */
 export { AuthAdapter } from "./auth-adapter";
 export type { DecodedToken } from "./auth-adapter";
 export { CommandWire } from "./command-wire";
 export { EventWire } from "./event-wire";
-export type { ReceivedEvent, SyncableEvent } from "./event-wire";
+export type { QuerySubscriptionCallbacks, 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";

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

@@ -1,16 +1,14 @@
 /**
- * QueryWire - Wire adapter for remote view queries via HTTP/SSE
+ * QueryWire - Wire adapter for remote view queries via HTTP
  *
  * Provides:
  * - One-shot queries via HTTP POST
- * - Live queries via Server-Sent Events (SSE)
  * - Per-request auth via scope + token
+ *
+ * Live updates go through EventWire query subscriptions
+ * (query-snapshot + query-changes), not through this adapter.
  */
 import { Wire, type WireAuth } from "./wire";
-export interface StreamConnection {
-    eventSource: EventSource;
-    unsubscribe: () => void;
-}
 export declare class QueryWire extends Wire {
     constructor(baseUrl: string);
     /**
@@ -22,15 +20,5 @@ export declare class QueryWire extends Wire {
      * @returns Query results
      */
     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 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, auth?: WireAuth): StreamConnection;
 }
 //# sourceMappingURL=query-wire.d.ts.map

package/dist/data-storage/data-storage-observable.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data-storage-observable.test.d.ts.map

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

@@ -6,6 +6,13 @@ export declare class MasterStoreState<Item extends {
     _id: string;
 }> extends StoreState<Item> {
     constructor(storeName: string, dataStorage: DataStorage, deserialize?: (data: any) => Item);
+    /**
+     * Read the current row for `id` — transaction cache first, then the store.
+     * Cache keys are prefixed with the store name: two stores in one
+     * transaction can hold rows under the same `_id` (e.g. two views keyed by
+     * the same aggregate id) and must not shadow each other.
+     */
+    private readExisting;
     applyChangeAndReturnEvent(transaction: ReadWriteTransaction, change: StoreStateChange<Item>, transactionCache?: Map<string, Item>): Promise<{
         from: Item | null;
         to: Item | null;

package/dist/data-storage/store-state-master.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=store-state-master.test.d.ts.map

package/dist/index.js

@@ -211,12 +211,13 @@ class EventWire {
   onSyncedCallback;
   reconnectTimeout;
   syncRequested = false;
-  viewSubscriptions = new Map;
-  viewSubCounter = 0;
-  pendingViewSubs = [];
-  constructor(baseUrl) {
+  querySubscriptions = new Map;
+  querySubCounter = 0;
+  enableEventSync;
+  constructor(baseUrl, options) {
     this.baseUrl = baseUrl;
     this.instanceId = ++eventWireInstanceCounter;
+    this.enableEventSync = options?.enableEventSync ?? true;
   }
   setScopeToken(scope, token) {
     if (token === null) {
@@ -262,9 +263,11 @@ class EventWire {
         if (this.ws && this.ws.readyState === WebSocket.OPEN) {
           this.state = "connected";
           this.sendAllScopeTokens();
-          this.requestSync();
+          if (this.enableEventSync) {
+            this.requestSync();
+          }
           this.flushPendingEvents();
-          this.flushPendingViewSubs();
+          this.sendAllQuerySubscriptions();
         } else {
           console.log(`[EventWire] onopen called but ws is not OPEN, readyState:`, this.ws?.readyState);
         }
@@ -340,9 +343,13 @@ class EventWire {
   onSynced(callback) {
     this.onSyncedCallback = callback;
   }
-  subscribeQuery(descriptor, callback, scope) {
-    const subscriptionId = `qs_${++this.viewSubCounter}_${Date.now()}`;
-    this.viewSubscriptions.set(subscriptionId, callback);
+  subscribeQuery(descriptor, scope, callbacks) {
+    const subscriptionId = `qs_${this.instanceId}_${++this.querySubCounter}`;
+    this.querySubscriptions.set(subscriptionId, {
+      descriptor,
+      scope,
+      callbacks
+    });
     if (this.state === "connected" && this.ws) {
       this.ws.send(JSON.stringify({
         type: "subscribe-query",
@@ -350,20 +357,17 @@ class EventWire {
         descriptor,
         scope
       }));
-    } else {
-      this.pendingViewSubs.push({ subscriptionId, descriptor, scope });
     }
     return subscriptionId;
   }
   unsubscribeQuery(subscriptionId) {
-    this.viewSubscriptions.delete(subscriptionId);
+    this.querySubscriptions.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;
@@ -396,10 +400,17 @@ class EventWire {
           this.lastHostEventId = message.lastHostEventId;
         }
         break;
-      case "query-data": {
-        const cb = this.viewSubscriptions.get(message.subscriptionId);
-        if (cb) {
-          cb(message.data);
+      case "query-snapshot": {
+        const sub = this.querySubscriptions.get(message.subscriptionId);
+        if (sub) {
+          sub.callbacks.onSnapshot(message.result ?? null);
+        }
+        break;
+      }
+      case "query-changes": {
+        const sub = this.querySubscriptions.get(message.subscriptionId);
+        if (sub && Array.isArray(message.changes)) {
+          sub.callbacks.onChanges(message.changes);
         }
         break;
       }
@@ -427,18 +438,17 @@ class EventWire {
       this.pendingEvents = [];
     }
   }
-  flushPendingViewSubs() {
+  sendAllQuerySubscriptions() {
     if (!this.ws || this.state !== "connected")
       return;
-    for (const sub of this.pendingViewSubs) {
+    for (const [subscriptionId, sub] of this.querySubscriptions) {
       this.ws.send(JSON.stringify({
         type: "subscribe-query",
-        subscriptionId: sub.subscriptionId,
+        subscriptionId,
         descriptor: sub.descriptor,
         scope: sub.scope
       }));
     }
-    this.pendingViewSubs = [];
   }
   scheduleReconnect() {
     if (this.reconnectTimeout)
@@ -465,47 +475,6 @@ class QueryWire extends Wire {
     }
     return await response.json();
   }
-  stream(viewName, options, callback, auth) {
-    const params = new URLSearchParams;
-    if (options?.where) {
-      params.set("where", JSON.stringify(options.where));
-    }
-    if (options?.orderBy) {
-      params.set("orderBy", JSON.stringify(options.orderBy));
-    }
-    if (options?.limit) {
-      params.set("limit", String(options.limit));
-    }
-    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}` : ""}`;
-    const eventSource = new EventSource(url);
-    eventSource.onmessage = (event) => {
-      try {
-        const message = JSON.parse(event.data);
-        if (message.type === "data") {
-          callback(message.data);
-        }
-      } catch (err) {
-        console.error("QueryWire: Failed to parse SSE message", err);
-      }
-    };
-    eventSource.onerror = (err) => {
-      console.error("QueryWire: SSE error", err);
-    };
-    const unsubscribe = () => {
-      eventSource.close();
-    };
-    return {
-      eventSource,
-      unsubscribe
-    };
-  }
 }
 // src/adapters/event-publisher.ts
 var EVENT_TABLES = {
@@ -2244,8 +2213,6 @@ class ArcAggregateElement extends ArcContextElement {
         }
         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 [];
@@ -3385,12 +3352,19 @@ class MasterStoreState extends StoreState {
   constructor(storeName, dataStorage, deserialize) {
     super(storeName, dataStorage, deserialize);
   }
+  async readExisting(transaction, id2, transactionCache) {
+    const cacheKey = `${this.storeName}:${id2}`;
+    if (transactionCache && transactionCache.has(cacheKey)) {
+      return transactionCache.get(cacheKey);
+    }
+    return transaction.find(this.storeName, { where: { _id: id2 } }).then((results) => results[0]);
+  }
   async applyChangeAndReturnEvent(transaction, change, transactionCache) {
     if (change.type === "set") {
       await transaction.set(this.storeName, change.data);
       const item = this.deserialize ? this.deserialize(change.data) : change.data;
       if (transactionCache) {
-        transactionCache.set(change.data._id, item);
+        transactionCache.set(`${this.storeName}:${change.data._id}`, item);
       }
       return {
         from: null,
@@ -3404,6 +3378,9 @@ class MasterStoreState extends StoreState {
     }
     if (change.type === "delete") {
       await transaction.remove(this.storeName, change.id);
+      if (transactionCache) {
+        transactionCache.delete(`${this.storeName}:${change.id}`);
+      }
       return {
         from: null,
         to: null,
@@ -3415,17 +3392,12 @@ class MasterStoreState extends StoreState {
       };
     }
     if (change.type === "modify") {
-      let existing;
-      if (transactionCache && transactionCache.has(change.id)) {
-        existing = transactionCache.get(change.id);
-      } else {
-        existing = await transaction.find(this.storeName, { where: { _id: change.id } }).then((results) => results[0]);
-      }
+      const existing = await this.readExisting(transaction, change.id, transactionCache);
       const updated = existing ? deepMerge(existing, change.data) : { _id: change.id, ...change.data };
       await transaction.set(this.storeName, updated);
       const item = this.deserialize ? this.deserialize(updated) : updated;
       if (transactionCache) {
-        transactionCache.set(change.id, item);
+        transactionCache.set(`${this.storeName}:${change.id}`, item);
       }
       return {
         from: null,
@@ -3438,17 +3410,12 @@ class MasterStoreState extends StoreState {
       };
     }
     if (change.type === "mutate") {
-      let existing;
-      if (transactionCache && transactionCache.has(change.id)) {
-        existing = transactionCache.get(change.id);
-      } else {
-        existing = await transaction.find(this.storeName, { where: { _id: change.id } }).then((results) => results[0]);
-      }
+      const existing = await this.readExisting(transaction, change.id, transactionCache);
       const updated = apply2(existing || {}, change.patches);
       await transaction.set(this.storeName, updated);
       const item = this.deserialize ? this.deserialize(updated) : updated;
       if (transactionCache) {
-        transactionCache.set(change.id, item);
+        transactionCache.set(`${this.storeName}:${change.id}`, item);
       }
       return {
         from: null,
@@ -3687,7 +3654,8 @@ class ObservableDataStorage {
   }
   handleStoreChange(storeName, events) {
     let hasChanges = false;
-    for (const query of this.trackedQueries.values()) {
+    const staleKeys = [];
+    for (const [key, query] of this.trackedQueries) {
       if (query.storeName !== storeName)
         continue;
       let currentResult = query.result;
@@ -3699,10 +3667,20 @@ class ObservableDataStorage {
           queryChanged = true;
         }
       }
-      if (queryChanged) {
-        query.result = currentResult;
+      if (!queryChanged)
+        continue;
+      if (query.options.limit !== undefined && query.result.length === query.options.limit && currentResult.length < query.options.limit) {
+        staleKeys.push(key);
         hasChanges = true;
+        continue;
       }
+      query.result = currentResult;
+      hasChanges = true;
+    }
+    for (const key of staleKeys) {
+      const query = this.trackedQueries.get(key);
+      this.source.getStore(query.storeName).unsubscribe(query.listener);
+      this.trackedQueries.delete(key);
     }
     if (hasChanges) {
       this.onChange();
@@ -4516,13 +4494,6 @@ class ScopedModel {
     }
     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);
   }
@@ -4595,245 +4566,260 @@ function mutationExecutor(model) {
     }
   });
 }
-// src/streaming/streaming-query-cache.ts
-class StreamingQueryCache {
-  stores = new Map;
-  views = [];
-  activeStreams = new Map;
-  pendingUnsubscribes = new Map;
-  streamScopes = new Map;
-  static UNSUBSCRIBE_DELAY_MS = 5000;
-  registerViews(views) {
-    this.views = views;
-    for (const view3 of views) {
-      if (!this.stores.has(view3.name)) {
-        this.stores.set(view3.name, new StreamingStore);
-      }
-    }
-  }
-  getStore(viewName) {
-    if (!this.stores.has(viewName)) {
-      this.stores.set(viewName, new StreamingStore);
+// src/model/live-query/diff.ts
+function isIdList(value) {
+  return Array.isArray(value) && value.every((it) => it && typeof it === "object" && typeof it._id === "string");
+}
+function diffResults(prev, next) {
+  if (!isIdList(prev) || !isIdList(next)) {
+    return JSON.stringify(prev) === JSON.stringify(next) ? { kind: "none" } : { kind: "snapshot", result: next };
+  }
+  const json = (o) => JSON.stringify(o);
+  const nextIds = new Set(next.map((it) => it._id));
+  const changes = [];
+  for (const it of prev) {
+    if (!nextIds.has(it._id)) {
+      changes.push({ type: "delete", id: it._id });
+    }
+  }
+  const sim = prev.filter((it) => nextIds.has(it._id));
+  for (let i = 0;i < next.length; i++) {
+    const target = next[i];
+    if (sim[i] && sim[i]._id === target._id && json(sim[i]) === json(target)) {
+      continue;
     }
-    return this.stores.get(viewName);
+    changes.push({ type: "set", id: target._id, item: target, index: i });
+    const oldIdx = sim.findIndex((it) => it._id === target._id);
+    if (oldIdx !== -1)
+      sim.splice(oldIdx, 1);
+    sim.splice(i, 0, target);
   }
-  hasData(viewName) {
-    const store = this.stores.get(viewName);
-    return store ? store.hasData() : false;
+  if (changes.length === 0)
+    return { kind: "none" };
+  if (changes.length > next.length) {
+    return { kind: "snapshot", result: next };
   }
-  hasActiveStream(viewName) {
-    return this.activeStreams.has(viewName);
+  if (sim.length !== next.length || json(sim) !== json(next)) {
+    return { kind: "snapshot", result: next };
   }
-  registerStream(viewName, createStream) {
-    const pending = this.pendingUnsubscribes.get(viewName);
-    if (pending) {
-      clearTimeout(pending);
-      this.pendingUnsubscribes.delete(viewName);
+  return { kind: "changes", changes };
+}
+function applyQueryChanges(result, changes) {
+  const next = [...result];
+  for (const change of changes) {
+    if (change.type === "delete") {
+      const idx = next.findIndex((it) => it._id === change.id);
+      if (idx !== -1)
+        next.splice(idx, 1);
     }
-    const existing = this.activeStreams.get(viewName);
-    if (existing) {
-      existing.refCount++;
-      return {
-        unsubscribe: () => this.unregisterStream(viewName),
-        wasReused: true
-      };
+  }
+  for (const change of changes) {
+    if (change.type === "set") {
+      const idx = next.findIndex((it) => it._id === change.id);
+      if (idx !== -1)
+        next.splice(idx, 1);
+      next.splice(change.index, 0, change.item);
     }
-    const streamConn = createStream();
-    this.activeStreams.set(viewName, {
-      unsubscribe: streamConn.unsubscribe,
-      refCount: 1
-    });
-    return {
-      unsubscribe: () => this.unregisterStream(viewName),
-      wasReused: false
+  }
+  return next;
+}
+
+// src/model/live-query/live-query-subscription.ts
+class LiveQuery {
+  model;
+  descriptor;
+  scope;
+  rawToken;
+  onUpdate;
+  observable = null;
+  adapters = null;
+  lastResult;
+  scheduled = false;
+  running = false;
+  rerunRequested = false;
+  stopped = false;
+  constructor(model, descriptor, scope, rawToken, onUpdate) {
+    this.model = model;
+    this.descriptor = descriptor;
+    this.scope = scope;
+    this.rawToken = rawToken;
+    this.onUpdate = onUpdate;
+  }
+  async start() {
+    const scoped = new ScopedModel(this.model, this.scope);
+    if (this.rawToken)
+      scoped.setToken(this.rawToken);
+    const baseAdapters = scoped.getAdapters();
+    if (!baseAdapters.dataStorage) {
+      throw new Error("LiveQuery requires a dataStorage adapter (server-side)");
+    }
+    this.observable = new ObservableDataStorage(baseAdapters.dataStorage, () => this.schedule());
+    this.adapters = {
+      ...baseAdapters,
+      dataStorage: this.observable
     };
+    this.lastResult = await executeDescriptor(this.descriptor, this.model.context, this.adapters, "queryContext", { fromWire: true });
+    return this.lastResult;
+  }
+  flush() {
+    this.schedule();
   }
-  unregisterStream(viewName) {
-    const stream = this.activeStreams.get(viewName);
-    if (!stream)
+  stop() {
+    this.stopped = true;
+    this.observable?.clear();
+  }
+  schedule() {
+    if (this.stopped)
       return;
-    stream.refCount--;
-    if (stream.refCount <= 0) {
-      const timeout = setTimeout(() => {
-        this.pendingUnsubscribes.delete(viewName);
-        const current = this.activeStreams.get(viewName);
-        if (current && current.refCount <= 0) {
-          current.unsubscribe();
-          this.activeStreams.delete(viewName);
-          this.streamScopes.delete(viewName);
-        }
-      }, StreamingQueryCache.UNSUBSCRIBE_DELAY_MS);
-      this.pendingUnsubscribes.set(viewName, timeout);
-    }
-  }
-  subscribeQuery(descriptor, eventWire, scope) {
-    const key = descriptor.element;
-    if (scope)
-      this.streamScopes.set(key, scope);
-    const { unsubscribe } = this.registerStream(key, () => {
-      const subId = eventWire.subscribeQuery(descriptor, (data) => {
-        this.setViewData(descriptor.element, data);
-      }, scope);
-      return { unsubscribe: () => eventWire.unsubscribeQuery(subId) };
+    if (this.running) {
+      this.rerunRequested = true;
+      return;
+    }
+    if (this.scheduled)
+      return;
+    this.scheduled = true;
+    queueMicrotask(() => {
+      this.scheduled = false;
+      this.run();
     });
-    return unsubscribe;
   }
-  invalidateScope(scope) {
-    for (const [viewName, viewScope] of this.streamScopes) {
-      if (viewScope !== scope)
-        continue;
-      const pending = this.pendingUnsubscribes.get(viewName);
-      if (pending) {
-        clearTimeout(pending);
-        this.pendingUnsubscribes.delete(viewName);
+  async run() {
+    if (this.stopped)
+      return;
+    this.running = true;
+    try {
+      const next = await executeDescriptor(this.descriptor, this.model.context, this.adapters, "queryContext", { fromWire: true });
+      if (this.stopped)
+        return;
+      const diff = diffResults(this.lastResult, next);
+      this.lastResult = next;
+      if (diff.kind === "changes") {
+        this.onUpdate({ type: "changes", changes: diff.changes });
+      } else if (diff.kind === "snapshot") {
+        this.onUpdate({ type: "snapshot", result: diff.result });
       }
-      const stream = this.activeStreams.get(viewName);
-      if (stream) {
-        try {
-          stream.unsubscribe();
-        } catch {}
-        this.activeStreams.delete(viewName);
+    } catch (err) {
+      console.error(`[Arc] LiveQuery re-execute error:`, err);
+    } finally {
+      this.running = false;
+      if (this.rerunRequested) {
+        this.rerunRequested = false;
+        this.schedule();
       }
-      this.streamScopes.delete(viewName);
-      const store = this.stores.get(viewName);
-      if (store)
-        store.clear();
     }
   }
-  setViewData(viewName, data) {
-    const store = this.stores.get(viewName);
-    if (!store)
-      return;
-    if (Array.isArray(data)) {
-      store.setAll(data);
-    } else if (data && typeof data === "object" && "_id" in data) {
-      store.setAll([data]);
+}
+// src/streaming/streaming-query-cache.ts
+class StreamingQueryCache {
+  entries = new Map;
+  static UNSUBSCRIBE_DELAY_MS = 5000;
+  entryKey(descriptor, scope) {
+    return `${scope ?? "default"}:${murmurHash(JSON.stringify(descriptor))}`;
+  }
+  subscribe(descriptor, scope, eventWire, onChange) {
+    const key = this.entryKey(descriptor, scope);
+    let entry = this.entries.get(key);
+    if (entry) {
+      if (entry.pendingUnsub) {
+        clearTimeout(entry.pendingUnsub);
+        entry.pendingUnsub = undefined;
+      }
+      entry.refCount++;
     } else {
-      store.setAll([]);
-    }
-  }
-  async applyEvent(event3) {
-    for (const view3 of this.views) {
-      const handlers = view3.getHandlers();
-      const handler = handlers[event3.type];
-      if (!handler)
-        continue;
-      const store = this.stores.get(view3.name);
-      if (!store)
-        continue;
-      const ctx = {
-        set: async (id3, data) => {
-          store.set(String(id3), { _id: String(id3), ...data });
-        },
-        modify: async (id3, data) => {
-          store.modify(String(id3), data);
-        },
-        remove: async (id3) => {
-          store.remove(String(id3));
-        },
-        find: async (options) => {
-          return store.find(options);
-        },
-        findOne: async (where) => {
-          return store.findOne(where);
-        },
-        $auth: {}
+      const newEntry = {
+        result: undefined,
+        hasResult: false,
+        listeners: new Set,
+        refCount: 1,
+        subscriptionId: ""
       };
-      await handler(ctx, event3);
-    }
-  }
-  clear() {
-    for (const stream of this.activeStreams.values()) {
-      stream.unsubscribe();
-    }
-    this.activeStreams.clear();
-    this.streamScopes.clear();
-    for (const timeout of this.pendingUnsubscribes.values()) {
-      clearTimeout(timeout);
-    }
-    this.pendingUnsubscribes.clear();
-    for (const store of this.stores.values()) {
-      store.clear();
-    }
-  }
-}
-
-class StreamingStore {
-  data = new Map;
-  listeners = new Set;
-  initialized = false;
-  hasData() {
-    return this.initialized;
-  }
-  setAll(items) {
-    this.initialized = true;
-    this.data.clear();
-    for (const item of items) {
-      this.data.set(item._id, item);
-    }
-    this.notifyListeners(null);
-  }
-  set(id3, item) {
-    this.data.set(id3, item);
-    this.notifyListeners([{ type: "set", id: id3, item }]);
-  }
-  modify(id3, updates) {
-    const existing = this.data.get(id3);
-    if (existing) {
-      const updated = { ...existing, ...updates };
-      this.data.set(id3, updated);
-      this.notifyListeners([{ type: "set", id: id3, item: updated }]);
+      newEntry.subscriptionId = eventWire.subscribeQuery(descriptor, scope, {
+        onSnapshot: (result) => {
+          newEntry.result = result;
+          newEntry.hasResult = true;
+          this.notify(newEntry);
+        },
+        onChanges: (changes) => {
+          if (!newEntry.hasResult || !Array.isArray(newEntry.result)) {
+            return;
+          }
+          newEntry.result = applyQueryChanges(newEntry.result, changes);
+          this.notify(newEntry);
+        }
+      });
+      this.entries.set(key, newEntry);
+      entry = newEntry;
     }
+    const subscribed = entry;
+    subscribed.listeners.add(onChange);
+    let active = true;
+    return {
+      read: () => ({
+        result: subscribed.result,
+        loading: !subscribed.hasResult
+      }),
+      unsubscribe: () => {
+        if (!active)
+          return;
+        active = false;
+        subscribed.listeners.delete(onChange);
+        subscribed.refCount--;
+        if (subscribed.refCount > 0)
+          return;
+        subscribed.pendingUnsub = setTimeout(() => {
+          subscribed.pendingUnsub = undefined;
+          if (subscribed.refCount > 0)
+            return;
+          eventWire.unsubscribeQuery(subscribed.subscriptionId);
+          this.entries.delete(key);
+        }, StreamingQueryCache.UNSUBSCRIBE_DELAY_MS);
+      }
+    };
   }
-  remove(id3) {
-    if (this.data.delete(id3)) {
-      this.notifyListeners([{ type: "delete", id: id3, item: null }]);
+  invalidateScope(scope, eventWire) {
+    const prefix = `${scope}:`;
+    for (const [key, entry] of this.entries) {
+      if (!key.startsWith(prefix))
+        continue;
+      if (entry.pendingUnsub)
+        clearTimeout(entry.pendingUnsub);
+      eventWire?.unsubscribeQuery(entry.subscriptionId);
+      this.entries.delete(key);
+      entry.result = undefined;
+      entry.hasResult = false;
+      this.notify(entry);
     }
   }
-  clear() {
-    this.initialized = false;
-    this.data.clear();
-    this.notifyListeners(null);
-  }
-  find(options = {}) {
-    let results = Array.from(this.data.values());
-    if (options.where) {
-      results = results.filter((item) => checkItemMatchesWhere(item, options.where));
+  clear(eventWire) {
+    for (const entry of this.entries.values()) {
+      if (entry.pendingUnsub)
+        clearTimeout(entry.pendingUnsub);
+      eventWire?.unsubscribeQuery(entry.subscriptionId);
     }
-    return applyOrderByAndLimit(results, options);
+    this.entries.clear();
   }
-  findOne(where) {
-    const results = this.find({ where });
-    return results[0];
-  }
-  subscribe(listener4) {
-    this.listeners.add(listener4);
-    return () => {
-      this.listeners.delete(listener4);
-    };
-  }
-  notifyListeners(events) {
-    for (const listener4 of this.listeners) {
-      listener4(events);
+  notify(entry) {
+    for (const listener4 of entry.listeners) {
+      try {
+        listener4();
+      } catch (err) {
+        console.error(`[Arc] Query cache listener error:`, err);
+      }
     }
   }
 }
 // src/streaming/streaming-event-publisher.ts
 class StreamingEventPublisher {
-  cache;
   eventWire;
   views = [];
   subscribers = new Map;
-  constructor(cache, eventWire) {
-    this.cache = cache;
+  constructor(eventWire) {
     this.eventWire = eventWire;
   }
   registerViews(views) {
     this.views = views;
-    this.cache.registerViews(views);
   }
   async publish(event3) {
-    await this.cache.applyEvent(event3);
     await this.notifySubscribers(event3);
     this.eventWire.syncEvents([
       {
@@ -5285,6 +5271,7 @@ export {
   extractDatabaseAgnosticSchema,
   executeDescriptor,
   event,
+  diffResults,
   defaultFunctionData,
   deepMerge,
   date,
@@ -5301,6 +5288,7 @@ export {
   array,
   arcFunctionWithCtx,
   arcFunction,
+  applyQueryChanges,
   applyOrderByAndLimit,
   any,
   aggregate,
@@ -5321,6 +5309,7 @@ export {
   MasterStoreState,
   MasterDataStorage,
   LocalEventPublisher,
+  LiveQuery,
   ForkedStoreState,
   ForkedDataStorage,
   EventWire,

package/dist/model/live-query/diff.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Diff between two query results → positional deltas for the wire.
+ *
+ * The server re-executes a subscribed query and diffs the previous result
+ * against the new one. For lists of items with `_id` it produces minimal
+ * `set`/`delete` changes WITH target positions — the client applies them
+ * blindly (remove-by-id + splice at index), so result order is always the
+ * server's order (only the query handler knows its orderBy).
+ *
+ * Correctness over cleverness: the deltas are verified by simulating their
+ * application; any mismatch falls back to a full snapshot.
+ */
+export type QueryResultChange = {
+    type: "set";
+    id: string;
+    item: any;
+    index: number;
+} | {
+    type: "delete";
+    id: string;
+};
+export type QueryDiff = {
+    kind: "none";
+} | {
+    kind: "changes";
+    changes: QueryResultChange[];
+} | {
+    kind: "snapshot";
+    result: any;
+};
+export declare function diffResults(prev: any, next: any): QueryDiff;
+/**
+ * Apply positional deltas to a result list — the exact client-side
+ * algorithm (exported so client cache and tests share one implementation):
+ * all deletes first, then sets in ascending index order.
+ */
+export declare function applyQueryChanges(result: Array<{
+    _id: string;
+}>, changes: QueryResultChange[]): Array<{
+    _id: string;
+}>;
+//# sourceMappingURL=diff.d.ts.map

package/dist/model/live-query/diff.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=diff.test.d.ts.map

package/dist/model/live-query/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./live-query";
+export * from "./live-query-subscription";
+export * from "./diff";
 //# sourceMappingURL=index.d.ts.map

package/dist/model/live-query/live-query-subscription.d.ts

@@ -0,0 +1,66 @@
+/**
+ * LiveQuery — a server-side query subscription that owns its deltas.
+ *
+ * The SAME query (any descriptor: bare view find or custom clientQuery
+ * handler) is executed with an ObservableDataStorage wrapped around the
+ * real storage. Every `find` the handler makes — already merged with token
+ * restrictions by ScopedStore — gets tracked. After each store commit,
+ * `resolveQueryChange` updates the tracked results in memory; when any of
+ * them changed, the descriptor is re-executed AGAINST THE CACHE (0 SQL)
+ * and the new result is diffed against the previous one.
+ *
+ * The transport layer (WS) only forwards `onUpdate` payloads — all query
+ * logic (filtering, scoping, ordering) lives here, in the query layer.
+ */
+import { type ContextDescriptor } from "../context-accessor";
+import type { ModelLike } from "../model-like";
+import { type QueryResultChange } from "./diff";
+export type LiveQueryUpdate = {
+    type: "changes";
+    changes: QueryResultChange[];
+} | {
+    type: "snapshot";
+    result: any;
+};
+export declare class LiveQuery {
+    private readonly model;
+    private readonly descriptor;
+    private readonly scope;
+    private readonly rawToken;
+    private readonly onUpdate;
+    private observable;
+    private adapters;
+    private lastResult;
+    private scheduled;
+    private running;
+    private rerunRequested;
+    private stopped;
+    constructor(model: ModelLike<any>, descriptor: ContextDescriptor, scope: string, rawToken: string | null, onUpdate: (update: LiveQueryUpdate) => void);
+    /**
+     * Execute the descriptor with tracking and return the initial result.
+     */
+    start(): Promise<any>;
+    /**
+     * Close the initial-execute window: the store listener is registered
+     * before the read transaction, but trackQuery happens after the await —
+     * a commit in between could slip past the tracked entry. One forced
+     * re-execute (cache-backed, no SQL when nothing changed) diffs out any
+     * missed delta.
+     *
+     * Call AFTER the initial result has been delivered (e.g. the snapshot
+     * message was sent) — otherwise the catch-up delta could overtake it.
+     */
+    flush(): void;
+    /**
+     * Stop tracking — unsubscribes all store listeners.
+     */
+    stop(): void;
+    /**
+     * Coalesce re-executes: a single commit can touch multiple stores and
+     * fire onChange several times — one microtask handles them all. A commit
+     * landing DURING a re-execute requests another pass afterwards.
+     */
+    private schedule;
+    private run;
+}
+//# sourceMappingURL=live-query-subscription.d.ts.map

package/dist/model/scoped-model.d.ts

@@ -38,10 +38,6 @@ export declare class ScopedModel<Context extends ArcContextAny> implements Model
      * Execute a remote query via QueryWire with auto-injected scope + token.
      */
     remoteQuery(viewName: string, options?: any): Promise<any[]>;
-    /**
-     * Subscribe to a server-side query via EventWire with auto-injected scope.
-     */
-    subscribeQuery(descriptor: ContextDescriptor, callback: (data: any[]) => void): string;
     /**
      * Query descriptor builder. Returns serializable descriptors.
      *

package/dist/streaming/index.d.ts

@@ -1,4 +1,4 @@
 export { StreamingQueryCache } from "./streaming-query-cache";
-export type { CacheChangeListener, StreamingQueryCacheStore, } from "./streaming-query-cache";
+export type { QuerySubscriptionHandle } from "./streaming-query-cache";
 export { StreamingEventPublisher } from "./streaming-event-publisher";
 //# sourceMappingURL=index.d.ts.map

package/dist/streaming/streaming-event-publisher.d.ts

@@ -1,35 +1,33 @@
 /**
  * StreamingEventPublisher - Event publisher for streaming mode (no local database)
  *
- * When events are emitted:
- * 1. Apply to local cache (optimistic update)
- * 2. Send to server via EventWire
- *
- * This enables instant UI updates while syncing with server.
+ * When events are emitted locally (client-side mutate handlers), they are
+ * sent to the server via EventWire; the server commits them and pushes the
+ * resulting query deltas back through live query subscriptions. No local
+ * optimistic apply — the client holds query RESULTS, not view data, so it
+ * cannot compute how an event affects a custom query handler's output.
  */
 import type { EventPublisher, EventWithSyncStatus } from "../adapters/event-publisher";
 import type { EventWire } from "../adapters/event-wire";
 import type { ArcEventAny } from "../context-element/event/event";
 import type { ArcEventInstance } from "../context-element/event/instance";
 import type { ArcViewAny } from "../context-element/view/view";
-import type { StreamingQueryCache } from "./streaming-query-cache";
 /**
  * StreamingEventPublisher
  */
 export declare class StreamingEventPublisher implements EventPublisher {
-    private readonly cache;
     private readonly eventWire;
     private views;
     private subscribers;
-    constructor(cache: StreamingQueryCache, eventWire: EventWire);
+    constructor(eventWire: EventWire);
     /**
      * Register views for event handling
      */
     registerViews(views: ArcViewAny[]): void;
     /**
      * Publish an event
-     * 1. Apply to local cache (optimistic)
-     * 2. Send to server
+     * 1. Notify local subscribers
+     * 2. Send to server (server commits → live query deltas come back)
      */
     publish(event: ArcEventInstance<ArcEventAny>): Promise<void>;
     /**

package/dist/streaming/streaming-query-cache.d.ts

@@ -1,128 +1,52 @@
 /**
- * StreamingQueryCache - Lightweight in-memory cache for streaming mode
+ * StreamingQueryCache - per-query result cache for streaming mode
  *
- * Used when client connects without local database (no SQLite/IndexedDB).
- * Holds view state in memory, receives data from SSE, applies local events.
+ * Used when the client connects without a local database. Each unique
+ * (scope, descriptor) gets ONE live subscription over the EventWire:
+ * the server executes the query with tracking (LiveQuery), sends a full
+ * `query-snapshot`, then positional `query-changes` deltas. The client
+ * applies deltas blindly — ALL query logic (filtering, scoping, ordering)
+ * lives on the server, in the query layer.
  *
  * Features:
- * - Stores view data in memory (Map-based)
- * - Supports reactive queries with listeners
- * - Applies view handlers for local event emission
- * - Receives updates from SSE stream
- * - Deduplicates SSE streams (one stream per view)
+ * - Dedup: many components with the same query share one subscription
+ *   (refCount + UNSUBSCRIBE_DELAY grace window for quick remounts)
+ * - Snapshot/delta application with listener notifications
+ * - Scope invalidation on token change (workspace switch / re-auth)
  */
 import type { EventWire } from "../adapters/event-wire";
-import type { ArcEventAny } from "../context-element/event/event";
-import type { ArcEventInstance } from "../context-element/event/instance";
-import type { ArcViewAny } from "../context-element/view/view";
-import type { FindOptions } from "../data-storage/find-options";
-import type { ListenerEvent } from "../data-storage/data-storage.abstract";
-/**
- * Cache change listener receives ListenerEvent[] for incremental changes,
- * or null for bulk replacement (setAll) which requires full re-query.
- */
-export type CacheChangeListener = (events: ListenerEvent<any>[] | null) => void;
-export interface StreamingQueryCacheStore<Item extends {
-    _id: string;
-}> {
-    find(options?: FindOptions<Item>): Item[];
-    findOne(where?: Record<string, any>): Item | undefined;
-    subscribe(listener: CacheChangeListener): () => void;
-    hasData(): boolean;
+import type { ContextDescriptor } from "../model/context-accessor";
+export interface QuerySubscriptionHandle {
+    /** Current state — stable shape for React reads. */
+    read(): {
+        result: any;
+        loading: boolean;
+    };
+    unsubscribe(): void;
 }
-/**
- * StreamingQueryCache - Main cache class
- */
 export declare class StreamingQueryCache {
-    private stores;
-    private views;
-    private activeStreams;
-    private pendingUnsubscribes;
-    /**
-     * Tag each active stream with the scope name that subscribed it. Used by
-     * `invalidateScope()` to force-close streams when a scope's token changes
-     * (workspace switch / re-auth) — without this tag, `registerStream()` would
-     * reuse the stale WS subscription (refCount > 0, or within the
-     * UNSUBSCRIBE_DELAY_MS grace window) and the client would keep receiving
-     * data filtered by the previous token.
-     */
-    private streamScopes;
+    private entries;
     private static UNSUBSCRIBE_DELAY_MS;
+    private entryKey;
     /**
-     * Register views that this cache will handle
-     */
-    registerViews(views: ArcViewAny[]): void;
-    /**
-     * Get a store for a specific view
-     */
-    getStore<Item extends {
-        _id: string;
-    }>(viewName: string): StreamingQueryCacheStore<Item>;
-    /**
-     * Check if a store has any data
-     */
-    hasData(viewName: string): boolean;
-    /**
-     * Check if a stream is already active for a view
-     */
-    hasActiveStream(viewName: string): boolean;
-    /**
-     * Register an active stream for a view (increment ref count if exists)
-     * Returns object with unsubscribe function and whether stream was reused
-     */
-    registerStream(viewName: string, createStream: () => {
-        unsubscribe: () => void;
-    }): {
-        unsubscribe: () => void;
-        wasReused: boolean;
-    };
-    /**
-     * Unregister from a stream. When refCount hits 0, delays actual WS
-     * unsubscribe by UNSUBSCRIBE_DELAY_MS. If re-registered within the
-     * window, the existing subscription is reused (cache serves immediately).
-     */
-    private unregisterStream;
-    /**
-     * Subscribe to a query via WebSocket with deduplication.
-     * Multiple callers share a single WS subscription per descriptor key.
-     * Returns unsubscribe function that decrements refcount.
-     */
-    subscribeQuery(descriptor: {
-        element: string;
-        method: string;
-        args: any[];
-    }, eventWire: EventWire, scope?: string): () => void;
-    /**
-     * Force-close every active stream tagged with `scope`. Called when a
-     * scope's token changes (workspace switch / re-auth) so the next
-     * `subscribeQuery()` creates a fresh WS subscription with the new token
-     * instead of reusing the stale one (which would keep pumping data filtered
-     * by the previous token until the page reload).
-     *
-     * Bypasses both `refCount` (other subscribers still mounted) and the
-     * UNSUBSCRIBE_DELAY_MS grace window — both became invalid the moment the
-     * token changed. React's `useQuery` re-subscribes immediately afterwards
-     * via the `subKey` change (token is in the key), getting a fresh stream.
-     *
-     * Bonus: each affected store is also cleared so any in-progress render
-     * that reads `store.find()` between `setToken` and the new WS data
-     * arriving gets `[]` rather than stale rows from the previous workspace.
-     */
-    invalidateScope(scope: string): void;
-    /**
-     * Set data for a view. Accepts array or single item (from queryMethod findOne).
+     * Subscribe to a live query. Identical (scope, descriptor) pairs share
+     * one WS subscription; the last unsubscriber tears it down after a grace
+     * window (instant remounts reuse the cached result without a snapshot
+     * round-trip).
      */
-    setViewData<Item extends {
-        _id: string;
-    }>(viewName: string, data: Item[] | Item | undefined | null): void;
+    subscribe(descriptor: ContextDescriptor, scope: string, eventWire: EventWire, onChange: () => void): QuerySubscriptionHandle;
     /**
-     * Apply an event to update view state
-     * Runs view handlers to update the cache
+     * Force-drop every cached query of `scope`. Called when the scope's token
+     * changes (workspace switch / re-auth) — cached results and the WS
+     * subscriptions behind them were computed with the previous token.
+     * React's `useQuery` re-subscribes immediately afterwards (token is part
+     * of its subscription key), getting fresh snapshots.
      */
-    applyEvent(event: ArcEventInstance<ArcEventAny>): Promise<void>;
+    invalidateScope(scope: string, eventWire?: EventWire): void;
     /**
-     * Clear all cached data and close all streams
+     * Clear all cached queries and tear down their subscriptions.
      */
-    clear(): void;
+    clear(eventWire?: EventWire): void;
+    private notify;
 }
 //# sourceMappingURL=streaming-query-cache.d.ts.map

package/dist/streaming/streaming-query-cache.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=streaming-query-cache.test.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc",
   "type": "module",
-  "version": "0.7.14",
+  "version": "0.7.16",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "Arc framework core rewrite with improved event emission and type safety",