@arcote.tech/arc 0.7.13 → 0.7.15

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

@@ -14,7 +14,7 @@
 import type { ArcEventAny } from "../context-element/event";
 import type { ArcEventInstance } from "../context-element/event/instance";
 import type { ArcViewAny } from "../context-element/view/view";
-import type { DataStorage } from "../data-storage";
+import type { CommittedChange, DataStorage } from "../data-storage";
 /** Shared table names for all events */
 export declare const EVENT_TABLES: {
     readonly events: "events";
@@ -99,12 +99,19 @@ export declare class LocalEventPublisher implements EventPublisher {
     private views;
     private syncCallback?;
     private subscribers;
+    private viewChangesCallbacks;
     constructor(dataStorage: DataStorage);
     /**
      * Set a callback to be called after each event is published
      * Used for syncing events to the host
      */
     onPublish(callback: (event: ArcEventInstance<ArcEventAny>) => void): void;
+    /**
+     * Register a callback fired after each publish commit with the committed
+     * VIEW store changes (old/new rows). Used by the host to broadcast
+     * incremental view deltas to subscribed streaming clients.
+     */
+    onViewChanges(callback: (changes: CommittedChange[]) => void): () => void;
     /**
      * Register views that should be updated when events are published
      */

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

@@ -24,8 +24,17 @@ export interface ReceivedEvent {
     clientId: string;
     authContext: EventAuthContext | null;
 }
-import type { ContextDescriptor } from "../model/context-accessor";
+import type { ListenerEvent } from "../data-storage/data-storage.abstract";
 type EventWireState = "disconnected" | "connecting" | "connected";
+/**
+ * Callbacks for a view replica subscription. The server answers
+ * `subscribe-view` with a full `view-snapshot`, then pushes incremental
+ * `view-changes` deltas (already filtered by the scope's token).
+ */
+export interface ViewSubscriptionCallbacks {
+    onSnapshot: (items: any[]) => void;
+    onChanges: (changes: ListenerEvent<any>[]) => void;
+}
 export declare class EventWire {
     private readonly baseUrl;
     private instanceId;
@@ -38,10 +47,17 @@ export declare class EventWire {
     private onSyncedCallback?;
     private reconnectTimeout?;
     private syncRequested;
+    /** Active view subscriptions keyed by `${scope}:${element}`. Re-sent in
+     *  full on every (re)connect — the server drops its registry on
+     *  disconnect, and a fresh snapshot follows each re-subscribe. */
     private viewSubscriptions;
-    private viewSubCounter;
-    private pendingViewSubs;
-    constructor(baseUrl: string);
+    /** When false (streaming mode), the client neither requests the event
+     *  log (`request-sync`) nor consumes domain events — view replicas 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,14 +97,16 @@ 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 view replica. The server responds with a full
+     * `view-snapshot` of the token's slice, then pushes `view-changes`
+     * deltas. One subscription per `${scope}:${element}` — callers dedupe
+     * (StreamingQueryCache.registerStream).
      */
-    subscribeQuery(descriptor: ContextDescriptor, callback: (data: any[]) => void, scope?: string): string;
+    subscribeView(element: string, scope: string, callbacks: ViewSubscriptionCallbacks): void;
     /**
-     * Unsubscribe from a server-side query.
+     * Unsubscribe from a view replica.
      */
-    unsubscribeQuery(subscriptionId: string): void;
+    unsubscribeView(element: string, scope: string): void;
     /**
      * Get current connection state
      */
@@ -101,7 +119,12 @@ export declare class EventWire {
     private handleMessage;
     private requestSync;
     private flushPendingEvents;
-    private flushPendingViewSubs;
+    /**
+     * (Re)send every active view 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).
+     */
+    private sendAllViewSubscriptions;
     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 { ReceivedEvent, SyncableEvent, ViewSubscriptionCallbacks, } 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 view subscriptions
+ * (view-snapshot + view-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/context-element/aggregate/aggregate-element.d.ts

@@ -196,6 +196,16 @@ export declare class ArcAggregateElement<Name extends string = string, Id extend
     get cronMethods(): AggregateCronMethodEntry[];
     queryContext(adapters: ModelAdapters): AggregateQueryContext<QueryMethods>;
     private buildPrivateQuery;
+    /**
+     * Resolve this aggregate's protection for the current auth context.
+     * Public entry point for the host's view-subscription handler — used to
+     * compute the subscriber's restrictions once at subscribe time (snapshot
+     * filtering + per-delta filtering).
+     */
+    getRestrictionsFor(adapters: ModelAdapters): {
+        restrictions: Record<string, unknown> | null;
+        denied: boolean;
+    };
     private isScopeDenied;
     private getAuth;
     private getScopeRestrictions;

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

@@ -104,6 +104,16 @@ export declare class ArcView<const Data extends ArcViewData> extends ArcContextE
      * @returns Context object with find/findOne methods
      */
     queryContext(adapters: any): ArcViewQueryContext<Data["id"], Data["schema"]>;
+    /**
+     * Resolve this view's protection for the current auth context.
+     * Public entry point for the host's view-subscription handler — used to
+     * compute the subscriber's restrictions once at subscribe time (snapshot
+     * filtering + per-delta filtering).
+     */
+    getRestrictionsFor(adapters: any): {
+        restrictions: Record<string, unknown> | null;
+        denied: boolean;
+    };
     private resolveProtection;
     /**
      * Get event handlers for this view

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

@@ -1,5 +1,5 @@
 import { ForkedDataStorage } from "./data-storage-forked";
-import { DataStorage, type DataStorageChanges } from "./data-storage.abstract";
+import { DataStorage, type CommittedChange, type DataStorageChanges } from "./data-storage.abstract";
 import type { DatabaseAdapter, ReadTransaction, ReadWriteTransaction } from "./database-adapter";
 import type { StoreState } from "./store-state.abstract";
 export declare class MasterDataStorage extends DataStorage {
@@ -22,7 +22,9 @@ export declare class MasterDataStorage extends DataStorage {
             _id: string;
         } | null;
     }[][]>;
-    commitChanges(changes: DataStorageChanges[]): Promise<void>;
+    commitChanges(changes: DataStorageChanges[], options?: {
+        captureRowsFor?: Set<string>;
+    }): Promise<CommittedChange[]>;
     fork(): ForkedDataStorage;
     /**
      * Destroy the data storage - clears all stores and destroys the database

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

@@ -1,5 +1,5 @@
 import type { ForkedDataStorage } from "./data-storage-forked";
-import type { DataStorage, DataStorageChanges, ListenerEvent, QueryListenerCallback } from "./data-storage.abstract";
+import type { CommittedChange, DataStorage, DataStorageChanges, ListenerEvent, QueryListenerCallback } from "./data-storage.abstract";
 import type { ReadTransaction, ReadWriteTransaction } from "./database-adapter";
 import type { FindOptions } from "./find-options";
 import type { StoreState } from "./store-state.abstract";
@@ -25,7 +25,9 @@ export declare class ObservableDataStorage {
     fork(): ForkedDataStorage;
     getReadTransaction(): Promise<ReadTransaction>;
     getReadWriteTransaction(): Promise<ReadWriteTransaction>;
-    commitChanges(changes: DataStorageChanges[]): Promise<void>;
+    commitChanges(changes: DataStorageChanges[], options?: {
+        captureRowsFor?: Set<string>;
+    }): Promise<CommittedChange[]>;
     /**
      * Register a tracked query
      */

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

@@ -9,8 +9,21 @@ export declare abstract class DataStorage {
     abstract fork(): ForkedDataStorage;
     abstract getReadTransaction(): Promise<ReadTransaction>;
     abstract getReadWriteTransaction(): Promise<ReadWriteTransaction>;
-    commitChanges(changes: DataStorageChanges[]): Promise<void>;
+    commitChanges(changes: DataStorageChanges[], _options?: {
+        captureRowsFor?: Set<string>;
+    }): Promise<CommittedChange[]>;
 }
+/**
+ * A change applied and committed to a store, with the row state before and
+ * after the write (store/DB form). Returned by `commitChanges` for stores
+ * requested via `captureRowsFor` — consumed by view-change broadcasting.
+ */
+export type CommittedChange = {
+    store: string;
+    id: string;
+    oldRow: any | null;
+    newRow: any | null;
+};
 export type StoreStateChange<Item> = {
     type: "set";
     data: Item;

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

@@ -6,10 +6,27 @@ export declare class MasterStoreState<Item extends {
     _id: string;
 }> extends StoreState<Item> {
     constructor(storeName: string, dataStorage: DataStorage, deserialize?: (data: any) => Item);
-    applyChangeAndReturnEvent(transaction: ReadWriteTransaction, change: StoreStateChange<Item>, transactionCache?: Map<string, Item>): Promise<{
+    /**
+     * 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>, options?: {
+        captureRows?: boolean;
+    }): Promise<{
         from: Item | null;
         to: Item | null;
         event: ListenerEvent<Item>;
+        /**
+         * Rows in store form (as written to the DB) for change broadcasting:
+         * state before the write and after. Captured for modify/mutate always
+         * (existing is read for the merge anyway); for set/delete only when
+         * `options.captureRows` — avoids extra PK lookups on event tables.
+         */
+        oldRow: Item | null;
+        newRow: Item | null;
     }>;
     applyChange(change: StoreStateChange<Item>): Promise<{
         from: 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

@@ -212,11 +212,11 @@ class EventWire {
   reconnectTimeout;
   syncRequested = false;
   viewSubscriptions = new Map;
-  viewSubCounter = 0;
-  pendingViewSubs = [];
-  constructor(baseUrl) {
+  enableEventSync;
+  constructor(baseUrl, options) {
     this.baseUrl = baseUrl;
     this.instanceId = ++eventWireInstanceCounter;
+    this.enableEventSync = options?.enableEventSync ?? true;
   }
   setScopeToken(scope, token) {
     if (token === null) {
@@ -262,9 +262,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.sendAllViewSubscriptions();
         } else {
           console.log(`[EventWire] onopen called but ws is not OPEN, readyState:`, this.ws?.readyState);
         }
@@ -340,30 +342,26 @@ class EventWire {
   onSynced(callback) {
     this.onSyncedCallback = callback;
   }
-  subscribeQuery(descriptor, callback, scope) {
-    const subscriptionId = `qs_${++this.viewSubCounter}_${Date.now()}`;
-    this.viewSubscriptions.set(subscriptionId, callback);
+  subscribeView(element, scope, callbacks) {
+    const key = `${scope}:${element}`;
+    this.viewSubscriptions.set(key, callbacks);
     if (this.state === "connected" && this.ws) {
       this.ws.send(JSON.stringify({
-        type: "subscribe-query",
-        subscriptionId,
-        descriptor,
+        type: "subscribe-view",
+        element,
         scope
       }));
-    } else {
-      this.pendingViewSubs.push({ subscriptionId, descriptor, scope });
     }
-    return subscriptionId;
   }
-  unsubscribeQuery(subscriptionId) {
-    this.viewSubscriptions.delete(subscriptionId);
+  unsubscribeView(element, scope) {
+    this.viewSubscriptions.delete(`${scope}:${element}`);
     if (this.state === "connected" && this.ws) {
       this.ws.send(JSON.stringify({
-        type: "unsubscribe-query",
-        subscriptionId
+        type: "unsubscribe-view",
+        element,
+        scope
       }));
     }
-    this.pendingViewSubs = this.pendingViewSubs.filter((s) => s.subscriptionId !== subscriptionId);
   }
   getState() {
     return this.state;
@@ -396,10 +394,17 @@ class EventWire {
           this.lastHostEventId = message.lastHostEventId;
         }
         break;
-      case "query-data": {
-        const cb = this.viewSubscriptions.get(message.subscriptionId);
-        if (cb) {
-          cb(message.data);
+      case "view-snapshot": {
+        const sub = this.viewSubscriptions.get(`${message.scope}:${message.element}`);
+        if (sub) {
+          sub.onSnapshot(message.items ?? []);
+        }
+        break;
+      }
+      case "view-changes": {
+        const sub = this.viewSubscriptions.get(`${message.scope}:${message.element}`);
+        if (sub && Array.isArray(message.changes)) {
+          sub.onChanges(message.changes);
         }
         break;
       }
@@ -427,18 +432,19 @@ class EventWire {
       this.pendingEvents = [];
     }
   }
-  flushPendingViewSubs() {
+  sendAllViewSubscriptions() {
     if (!this.ws || this.state !== "connected")
       return;
-    for (const sub of this.pendingViewSubs) {
+    for (const key of this.viewSubscriptions.keys()) {
+      const sepIdx = key.indexOf(":");
+      const scope = key.slice(0, sepIdx);
+      const element = key.slice(sepIdx + 1);
       this.ws.send(JSON.stringify({
-        type: "subscribe-query",
-        subscriptionId: sub.subscriptionId,
-        descriptor: sub.descriptor,
-        scope: sub.scope
+        type: "subscribe-view",
+        element,
+        scope
       }));
     }
-    this.pendingViewSubs = [];
   }
   scheduleReconnect() {
     if (this.reconnectTimeout)
@@ -465,47 +471,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 = {
@@ -519,12 +484,19 @@ class LocalEventPublisher {
   views = [];
   syncCallback;
   subscribers = new Map;
+  viewChangesCallbacks = new Set;
   constructor(dataStorage) {
     this.dataStorage = dataStorage;
   }
   onPublish(callback) {
     this.syncCallback = callback;
   }
+  onViewChanges(callback) {
+    this.viewChangesCallbacks.add(callback);
+    return () => {
+      this.viewChangesCallbacks.delete(callback);
+    };
+  }
   registerViews(views) {
     this.views = views;
   }
@@ -592,7 +564,19 @@ class LocalEventPublisher {
     });
     const viewChanges = await this.collectViewChanges(event);
     allChanges.push(...viewChanges);
-    await this.dataStorage.commitChanges(allChanges);
+    const viewStoreNames = new Set(viewChanges.map((c) => c.store));
+    const committed = await this.dataStorage.commitChanges(allChanges, {
+      captureRowsFor: viewStoreNames
+    });
+    if (committed.length > 0 && this.viewChangesCallbacks.size > 0) {
+      for (const callback of this.viewChangesCallbacks) {
+        try {
+          callback(committed);
+        } catch (error) {
+          console.error(`[EventPublisher] onViewChanges callback error:`, error);
+        }
+      }
+    }
     await this.notifySubscribers(event);
     if (this.syncCallback) {
       this.syncCallback(event);
@@ -1278,8 +1262,9 @@ function object(element) {
 
 // src/data-storage/data-storage.abstract.ts
 class DataStorage {
-  async commitChanges(changes) {
+  async commitChanges(changes, _options) {
     await Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));
+    return [];
   }
 }
 
@@ -2244,8 +2229,11 @@ class ArcAggregateElement extends ArcContextElement {
         }
         return adapters.dataStorage.getStore(viewName).find(options);
       }
-      if (adapters.streamingCache)
-        return adapters.streamingCache.getStore(viewName).find(options);
+      if (adapters.streamingCache) {
+        const store = adapters.streamingCache.getStore(viewName, adapters.scope?.scopeName);
+        if (store.hasData())
+          return store.find(options);
+      }
       if (adapters.queryWire)
         return adapters.queryWire.query(viewName, options);
       return [];
@@ -2273,6 +2261,12 @@ class ArcAggregateElement extends ArcContextElement {
       }
     };
   }
+  getRestrictionsFor(adapters) {
+    return {
+      restrictions: this.getScopeRestrictions(adapters),
+      denied: this.isScopeDenied(adapters)
+    };
+  }
   isScopeDenied(adapters, protections = this._protections) {
     if (protections.length === 0)
       return false;
@@ -2918,6 +2912,13 @@ class ArcView extends ArcContextElement {
           }
           return adapters.dataStorage.getStore(viewName).find(options);
         }
+        if (adapters.streamingCache) {
+          const store = adapters.streamingCache.getStore(viewName, adapters.scope?.scopeName);
+          if (store.hasData()) {
+            const where = restrictions ? { ...options?.where || {}, ...restrictions } : options?.where;
+            return store.find({ ...options, where });
+          }
+        }
         if (adapters.queryWire) {
           const where = restrictions ? { ...options?.where || {}, ...restrictions } : options?.where;
           return adapters.queryWire.query(viewName, { ...options, where });
@@ -2936,6 +2937,13 @@ class ArcView extends ArcContextElement {
           const results = await adapters.dataStorage.getStore(viewName).find({ where });
           return results[0];
         }
+        if (adapters.streamingCache) {
+          const store = adapters.streamingCache.getStore(viewName, adapters.scope?.scopeName);
+          if (store.hasData()) {
+            const mergedWhere = restrictions ? { ...where || {}, ...restrictions } : where;
+            return store.findOne(mergedWhere);
+          }
+        }
         if (adapters.queryWire) {
           const mergedWhere = restrictions ? { ...where, ...restrictions } : where;
           const results = await adapters.queryWire.query(viewName, { where: mergedWhere });
@@ -2945,6 +2953,9 @@ class ArcView extends ArcContextElement {
       }
     };
   }
+  getRestrictionsFor(adapters) {
+    return this.resolveProtection(this.data.protections || [], adapters);
+  }
   resolveProtection(protections, adapters) {
     if (protections.length === 0)
       return { restrictions: null, denied: false };
@@ -3385,12 +3396,23 @@ class MasterStoreState extends StoreState {
   constructor(storeName, dataStorage, deserialize) {
     super(storeName, dataStorage, deserialize);
   }
-  async applyChangeAndReturnEvent(transaction, change, transactionCache) {
+  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, options) {
     if (change.type === "set") {
+      let existing;
+      if (options?.captureRows) {
+        existing = await this.readExisting(transaction, change.data._id, transactionCache);
+      }
       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,
@@ -3399,11 +3421,20 @@ class MasterStoreState extends StoreState {
           type: "set",
           item: change.data,
           id: change.data._id
-        }
+        },
+        oldRow: existing ?? null,
+        newRow: change.data
       };
     }
     if (change.type === "delete") {
+      let existing;
+      if (options?.captureRows) {
+        existing = await this.readExisting(transaction, change.id, transactionCache);
+      }
       await transaction.remove(this.storeName, change.id);
+      if (transactionCache) {
+        transactionCache.delete(`${this.storeName}:${change.id}`);
+      }
       return {
         from: null,
         to: null,
@@ -3411,21 +3442,18 @@ class MasterStoreState extends StoreState {
           type: "delete",
           item: null,
           id: change.id
-        }
+        },
+        oldRow: existing ?? null,
+        newRow: null
       };
     }
     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,
@@ -3434,21 +3462,18 @@ class MasterStoreState extends StoreState {
           type: "set",
           item,
           id: change.id
-        }
+        },
+        oldRow: existing ?? null,
+        newRow: updated
       };
     }
     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,
@@ -3457,7 +3482,9 @@ class MasterStoreState extends StoreState {
           type: "set",
           item,
           id: change.id
-        }
+        },
+        oldRow: existing ?? null,
+        newRow: updated
       };
     }
     throw new Error("Unknown change type");
@@ -3536,17 +3563,22 @@ class MasterDataStorage extends DataStorage {
   applySerializedChanges(changes) {
     return Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applySerializedChanges(changes2)));
   }
-  async commitChanges(changes) {
+  async commitChanges(changes, options) {
     const transaction = await this.getReadWriteTransaction();
     const transactionCache = new Map;
     const eventsByStore = new Map;
+    const committed = [];
     for (const { store, changes: storeChanges } of changes) {
       const storeState = this.getStore(store);
       const storeEvents = [];
+      const capture = options?.captureRowsFor?.has(store) ?? false;
       for (const change of storeChanges) {
-        const { event: event3 } = await storeState.applyChangeAndReturnEvent(transaction, change, transactionCache);
+        const { event: event3, oldRow, newRow } = await storeState.applyChangeAndReturnEvent(transaction, change, transactionCache, { captureRows: capture });
         if (event3)
           storeEvents.push(event3);
+        if (capture) {
+          committed.push({ store, id: event3.id, oldRow, newRow });
+        }
       }
       if (storeEvents.length > 0) {
         eventsByStore.set(store, storeEvents);
@@ -3557,6 +3589,7 @@ class MasterDataStorage extends DataStorage {
       const storeState = this.getStore(store);
       storeState.notifyListenersPublic(events);
     }
+    return committed;
   }
   fork() {
     return new ForkedDataStorage(this);
@@ -3673,8 +3706,8 @@ class ObservableDataStorage {
   getReadWriteTransaction() {
     return this.source.getReadWriteTransaction();
   }
-  commitChanges(changes) {
-    return this.source.commitChanges(changes);
+  commitChanges(changes, options) {
+    return this.source.commitChanges(changes, options);
   }
   trackQuery(storeName, options, result, listener4) {
     const key = this.getQueryKey(storeName, options);
@@ -4516,13 +4549,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);
   }
@@ -4596,120 +4622,107 @@ function mutationExecutor(model) {
   });
 }
 // src/streaming/streaming-query-cache.ts
+var DEFAULT_SCOPE = "default";
+
 class StreamingQueryCache {
   stores = new Map;
   views = [];
   activeStreams = new Map;
   pendingUnsubscribes = new Map;
-  streamScopes = new Map;
   static UNSUBSCRIBE_DELAY_MS = 5000;
+  storeKey(viewName, scope) {
+    return `${scope ?? DEFAULT_SCOPE}:${viewName}`;
+  }
   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);
+  getStore(viewName, scope) {
+    const key = this.storeKey(viewName, scope);
+    if (!this.stores.has(key)) {
+      this.stores.set(key, new StreamingStore);
     }
-    return this.stores.get(viewName);
+    return this.stores.get(key);
   }
-  hasData(viewName) {
-    const store = this.stores.get(viewName);
+  hasData(viewName, scope) {
+    const store = this.stores.get(this.storeKey(viewName, scope));
     return store ? store.hasData() : false;
   }
-  hasActiveStream(viewName) {
-    return this.activeStreams.has(viewName);
-  }
-  registerStream(viewName, createStream) {
-    const pending = this.pendingUnsubscribes.get(viewName);
+  registerStream(key, createStream) {
+    const pending = this.pendingUnsubscribes.get(key);
     if (pending) {
       clearTimeout(pending);
-      this.pendingUnsubscribes.delete(viewName);
+      this.pendingUnsubscribes.delete(key);
     }
-    const existing = this.activeStreams.get(viewName);
+    const existing = this.activeStreams.get(key);
     if (existing) {
       existing.refCount++;
       return {
-        unsubscribe: () => this.unregisterStream(viewName),
+        unsubscribe: () => this.unregisterStream(key),
         wasReused: true
       };
     }
     const streamConn = createStream();
-    this.activeStreams.set(viewName, {
+    this.activeStreams.set(key, {
       unsubscribe: streamConn.unsubscribe,
       refCount: 1
     });
     return {
-      unsubscribe: () => this.unregisterStream(viewName),
+      unsubscribe: () => this.unregisterStream(key),
       wasReused: false
     };
   }
-  unregisterStream(viewName) {
-    const stream = this.activeStreams.get(viewName);
+  unregisterStream(key) {
+    const stream = this.activeStreams.get(key);
     if (!stream)
       return;
     stream.refCount--;
     if (stream.refCount <= 0) {
       const timeout = setTimeout(() => {
-        this.pendingUnsubscribes.delete(viewName);
-        const current = this.activeStreams.get(viewName);
+        this.pendingUnsubscribes.delete(key);
+        const current = this.activeStreams.get(key);
         if (current && current.refCount <= 0) {
           current.unsubscribe();
-          this.activeStreams.delete(viewName);
-          this.streamScopes.delete(viewName);
+          this.activeStreams.delete(key);
         }
       }, StreamingQueryCache.UNSUBSCRIBE_DELAY_MS);
-      this.pendingUnsubscribes.set(viewName, timeout);
+      this.pendingUnsubscribes.set(key, timeout);
     }
   }
-  subscribeQuery(descriptor, eventWire, scope) {
-    const key = descriptor.element;
-    if (scope)
-      this.streamScopes.set(key, scope);
+  subscribeView(viewName, eventWire, scope) {
+    const key = this.storeKey(viewName, scope);
     const { unsubscribe } = this.registerStream(key, () => {
-      const subId = eventWire.subscribeQuery(descriptor, (data) => {
-        this.setViewData(descriptor.element, data);
-      }, scope);
-      return { unsubscribe: () => eventWire.unsubscribeQuery(subId) };
+      const store = this.stores.get(key) ?? new StreamingStore;
+      this.stores.set(key, store);
+      eventWire.subscribeView(viewName, scope ?? DEFAULT_SCOPE, {
+        onSnapshot: (items) => store.setAll(items),
+        onChanges: (changes) => store.applyChanges(changes)
+      });
+      return {
+        unsubscribe: () => eventWire.unsubscribeView(viewName, scope ?? DEFAULT_SCOPE)
+      };
     });
     return unsubscribe;
   }
   invalidateScope(scope) {
-    for (const [viewName, viewScope] of this.streamScopes) {
-      if (viewScope !== scope)
+    const prefix = `${scope}:`;
+    for (const [key, timeout] of this.pendingUnsubscribes) {
+      if (!key.startsWith(prefix))
         continue;
-      const pending = this.pendingUnsubscribes.get(viewName);
-      if (pending) {
-        clearTimeout(pending);
-        this.pendingUnsubscribes.delete(viewName);
-      }
-      const stream = this.activeStreams.get(viewName);
-      if (stream) {
-        try {
-          stream.unsubscribe();
-        } catch {}
-        this.activeStreams.delete(viewName);
-      }
-      this.streamScopes.delete(viewName);
-      const store = this.stores.get(viewName);
-      if (store)
-        store.clear();
+      clearTimeout(timeout);
+      this.pendingUnsubscribes.delete(key);
     }
-  }
-  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]);
-    } else {
-      store.setAll([]);
+    for (const [key, stream] of this.activeStreams) {
+      if (!key.startsWith(prefix))
+        continue;
+      try {
+        stream.unsubscribe();
+      } catch {}
+      this.activeStreams.delete(key);
+    }
+    for (const [key, store] of this.stores) {
+      if (!key.startsWith(prefix))
+        continue;
+      store.clear();
     }
   }
   async applyEvent(event3) {
@@ -4718,28 +4731,30 @@ class StreamingQueryCache {
       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: {}
-      };
-      await handler(ctx, event3);
+      const suffix = `:${view3.name}`;
+      for (const [key, store] of this.stores) {
+        if (!key.endsWith(suffix))
+          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: {}
+        };
+        await handler(ctx, event3);
+      }
     }
   }
   clear() {
@@ -4747,7 +4762,6 @@ class StreamingQueryCache {
       stream.unsubscribe();
     }
     this.activeStreams.clear();
-    this.streamScopes.clear();
     for (const timeout of this.pendingUnsubscribes.values()) {
       clearTimeout(timeout);
     }
@@ -4773,6 +4787,18 @@ class StreamingStore {
     }
     this.notifyListeners(null);
   }
+  applyChanges(events) {
+    if (events.length === 0)
+      return;
+    for (const event3 of events) {
+      if (event3.type === "set" && event3.item) {
+        this.data.set(event3.id, event3.item);
+      } else if (event3.type === "delete") {
+        this.data.delete(event3.id);
+      }
+    }
+    this.notifyListeners(events);
+  }
   set(id3, item) {
     this.data.set(id3, item);
     this.notifyListeners([{ type: "set", id: id3, item }]);

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/streaming-query-cache.d.ts

@@ -2,14 +2,15 @@
  * StreamingQueryCache - Lightweight in-memory 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.
+ * Holds per-(scope, view) replicas of the token's slice of each view:
+ * the server sends a full `view-snapshot` on subscribe, then incremental
+ * `view-changes` deltas. All queries resolve locally against the replica.
  *
  * 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)
+ * - Stores view data in memory (Map-based), keyed by `${scope}:${viewName}`
+ * - Supports reactive queries with listeners (ListenerEvent[] | null)
+ * - Applies view handlers for optimistic local event emission
+ * - Deduplicates WS subscriptions (one stream per scope:view)
  */
 import type { EventWire } from "../adapters/event-wire";
 import type { ArcEventAny } from "../context-element/event/event";
@@ -38,39 +39,29 @@ export declare class StreamingQueryCache {
     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 static UNSUBSCRIBE_DELAY_MS;
+    /** Replica key — restrictions depend on the scope's token, so two scopes
+     *  subscribing the same view must hold separate replicas. */
+    private storeKey;
     /**
      * Register views that this cache will handle
      */
     registerViews(views: ArcViewAny[]): void;
     /**
-     * Get a store for a specific view
+     * Get the replica store for a view in a given scope
      */
     getStore<Item extends {
         _id: string;
-    }>(viewName: string): StreamingQueryCacheStore<Item>;
-    /**
-     * Check if a store has any data
-     */
-    hasData(viewName: string): boolean;
+    }>(viewName: string, scope?: string): StreamingQueryCacheStore<Item>;
     /**
-     * Check if a stream is already active for a view
+     * Check if a replica has received its snapshot
      */
-    hasActiveStream(viewName: string): boolean;
+    hasData(viewName: string, scope?: string): boolean;
     /**
-     * Register an active stream for a view (increment ref count if exists)
+     * Register an active stream for a key (increment ref count if exists)
      * Returns object with unsubscribe function and whether stream was reused
      */
-    registerStream(viewName: string, createStream: () => {
+    registerStream(key: string, createStream: () => {
         unsubscribe: () => void;
     }): {
         unsubscribe: () => void;
@@ -83,21 +74,19 @@ export declare class StreamingQueryCache {
      */
     private unregisterStream;
     /**
-     * Subscribe to a query via WebSocket with deduplication.
-     * Multiple callers share a single WS subscription per descriptor key.
+     * Subscribe to a view replica via WebSocket with deduplication.
+     * Multiple callers share a single WS subscription per (scope, view).
+     * Snapshot → setAll (listeners get null → full re-query);
+     * deltas → applyChanges (listeners get ListenerEvent[] → local resolve).
      * Returns unsubscribe function that decrements refcount.
      */
-    subscribeQuery(descriptor: {
-        element: string;
-        method: string;
-        args: any[];
-    }, eventWire: EventWire, scope?: string): () => void;
+    subscribeView(viewName: string, 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).
+     * Force-close every active stream of `scope`. Called when a scope's token
+     * changes (workspace switch / re-auth) so the next `subscribeView()`
+     * 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
@@ -105,19 +94,15 @@ export declare class StreamingQueryCache {
      * 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
+     * that reads `store.find()` between `setToken` and the new WS snapshot
      * 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).
-     */
-    setViewData<Item extends {
-        _id: string;
-    }>(viewName: string, data: Item[] | Item | undefined | null): void;
-    /**
-     * Apply an event to update view state
-     * Runs view handlers to update the cache
+     * Apply an event to update view state — optimistic local update for
+     * mutations executed client-side. Runs view handlers against every
+     * existing scope-replica of the view (the authoritative per-scope delta
+     * arrives from the server afterwards; sets/deletes are idempotent).
      */
     applyEvent(event: ArcEventInstance<ArcEventAny>): Promise<void>;
     /**

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.13",
+  "version": "0.7.15",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "Arc framework core rewrite with improved event emission and type safety",