@arcote.tech/arc 0.7.15 → 0.7.16

package/dist/index.js

@@ -211,7 +211,8 @@ class EventWire {
   onSyncedCallback;
   reconnectTimeout;
   syncRequested = false;
-  viewSubscriptions = new Map;
+  querySubscriptions = new Map;
+  querySubCounter = 0;
   enableEventSync;
   constructor(baseUrl, options) {
     this.baseUrl = baseUrl;
@@ -266,7 +267,7 @@ class EventWire {
             this.requestSync();
           }
           this.flushPendingEvents();
-          this.sendAllViewSubscriptions();
+          this.sendAllQuerySubscriptions();
         } else {
           console.log(`[EventWire] onopen called but ws is not OPEN, readyState:`, this.ws?.readyState);
         }
@@ -342,24 +343,29 @@ class EventWire {
   onSynced(callback) {
     this.onSyncedCallback = callback;
   }
-  subscribeView(element, scope, callbacks) {
-    const key = `${scope}:${element}`;
-    this.viewSubscriptions.set(key, callbacks);
+  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-view",
-        element,
+        type: "subscribe-query",
+        subscriptionId,
+        descriptor,
         scope
       }));
     }
+    return subscriptionId;
   }
-  unsubscribeView(element, scope) {
-    this.viewSubscriptions.delete(`${scope}:${element}`);
+  unsubscribeQuery(subscriptionId) {
+    this.querySubscriptions.delete(subscriptionId);
     if (this.state === "connected" && this.ws) {
       this.ws.send(JSON.stringify({
-        type: "unsubscribe-view",
-        element,
-        scope
+        type: "unsubscribe-query",
+        subscriptionId
       }));
     }
   }
@@ -394,17 +400,17 @@ class EventWire {
           this.lastHostEventId = message.lastHostEventId;
         }
         break;
-      case "view-snapshot": {
-        const sub = this.viewSubscriptions.get(`${message.scope}:${message.element}`);
+      case "query-snapshot": {
+        const sub = this.querySubscriptions.get(message.subscriptionId);
         if (sub) {
-          sub.onSnapshot(message.items ?? []);
+          sub.callbacks.onSnapshot(message.result ?? null);
         }
         break;
       }
-      case "view-changes": {
-        const sub = this.viewSubscriptions.get(`${message.scope}:${message.element}`);
+      case "query-changes": {
+        const sub = this.querySubscriptions.get(message.subscriptionId);
         if (sub && Array.isArray(message.changes)) {
-          sub.onChanges(message.changes);
+          sub.callbacks.onChanges(message.changes);
         }
         break;
       }
@@ -432,17 +438,15 @@ class EventWire {
       this.pendingEvents = [];
     }
   }
-  sendAllViewSubscriptions() {
+  sendAllQuerySubscriptions() {
     if (!this.ws || this.state !== "connected")
       return;
-    for (const key of this.viewSubscriptions.keys()) {
-      const sepIdx = key.indexOf(":");
-      const scope = key.slice(0, sepIdx);
-      const element = key.slice(sepIdx + 1);
+    for (const [subscriptionId, sub] of this.querySubscriptions) {
       this.ws.send(JSON.stringify({
-        type: "subscribe-view",
-        element,
-        scope
+        type: "subscribe-query",
+        subscriptionId,
+        descriptor: sub.descriptor,
+        scope: sub.scope
       }));
     }
   }
@@ -484,19 +488,12 @@ 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;
   }
@@ -564,19 +561,7 @@ class LocalEventPublisher {
     });
     const viewChanges = await this.collectViewChanges(event);
     allChanges.push(...viewChanges);
-    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.dataStorage.commitChanges(allChanges);
     await this.notifySubscribers(event);
     if (this.syncCallback) {
       this.syncCallback(event);
@@ -1262,9 +1247,8 @@ function object(element) {
 
 // src/data-storage/data-storage.abstract.ts
 class DataStorage {
-  async commitChanges(changes, _options) {
+  async commitChanges(changes) {
     await Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));
-    return [];
   }
 }
 
@@ -2229,11 +2213,6 @@ class ArcAggregateElement extends ArcContextElement {
         }
         return adapters.dataStorage.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 [];
@@ -2261,12 +2240,6 @@ 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;
@@ -2912,13 +2885,6 @@ 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 });
@@ -2937,13 +2903,6 @@ 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 });
@@ -2953,9 +2912,6 @@ 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 };
@@ -3403,12 +3359,8 @@ class MasterStoreState extends StoreState {
     }
     return transaction.find(this.storeName, { where: { _id: id2 } }).then((results) => results[0]);
   }
-  async applyChangeAndReturnEvent(transaction, change, transactionCache, options) {
+  async applyChangeAndReturnEvent(transaction, change, transactionCache) {
     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) {
@@ -3421,16 +3373,10 @@ 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}`);
@@ -3442,9 +3388,7 @@ class MasterStoreState extends StoreState {
           type: "delete",
           item: null,
           id: change.id
-        },
-        oldRow: existing ?? null,
-        newRow: null
+        }
       };
     }
     if (change.type === "modify") {
@@ -3462,9 +3406,7 @@ class MasterStoreState extends StoreState {
           type: "set",
           item,
           id: change.id
-        },
-        oldRow: existing ?? null,
-        newRow: updated
+        }
       };
     }
     if (change.type === "mutate") {
@@ -3482,9 +3424,7 @@ class MasterStoreState extends StoreState {
           type: "set",
           item,
           id: change.id
-        },
-        oldRow: existing ?? null,
-        newRow: updated
+        }
       };
     }
     throw new Error("Unknown change type");
@@ -3563,22 +3503,17 @@ class MasterDataStorage extends DataStorage {
   applySerializedChanges(changes) {
     return Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applySerializedChanges(changes2)));
   }
-  async commitChanges(changes, options) {
+  async commitChanges(changes) {
     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, oldRow, newRow } = await storeState.applyChangeAndReturnEvent(transaction, change, transactionCache, { captureRows: capture });
+        const { event: event3 } = await storeState.applyChangeAndReturnEvent(transaction, change, transactionCache);
         if (event3)
           storeEvents.push(event3);
-        if (capture) {
-          committed.push({ store, id: event3.id, oldRow, newRow });
-        }
       }
       if (storeEvents.length > 0) {
         eventsByStore.set(store, storeEvents);
@@ -3589,7 +3524,6 @@ class MasterDataStorage extends DataStorage {
       const storeState = this.getStore(store);
       storeState.notifyListenersPublic(events);
     }
-    return committed;
   }
   fork() {
     return new ForkedDataStorage(this);
@@ -3706,8 +3640,8 @@ class ObservableDataStorage {
   getReadWriteTransaction() {
     return this.source.getReadWriteTransaction();
   }
-  commitChanges(changes, options) {
-    return this.source.commitChanges(changes, options);
+  commitChanges(changes) {
+    return this.source.commitChanges(changes);
   }
   trackQuery(storeName, options, result, listener4) {
     const key = this.getQueryKey(storeName, options);
@@ -3720,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;
@@ -3732,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();
@@ -4621,245 +4566,260 @@ 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;
-  static UNSUBSCRIBE_DELAY_MS = 5000;
-  storeKey(viewName, scope) {
-    return `${scope ?? DEFAULT_SCOPE}:${viewName}`;
-  }
-  registerViews(views) {
-    this.views = views;
-  }
-  getStore(viewName, scope) {
-    const key = this.storeKey(viewName, scope);
-    if (!this.stores.has(key)) {
-      this.stores.set(key, 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(key);
+    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, scope) {
-    const store = this.stores.get(this.storeKey(viewName, scope));
-    return store ? store.hasData() : false;
+  if (changes.length === 0)
+    return { kind: "none" };
+  if (changes.length > next.length) {
+    return { kind: "snapshot", result: next };
   }
-  registerStream(key, createStream) {
-    const pending = this.pendingUnsubscribes.get(key);
-    if (pending) {
-      clearTimeout(pending);
-      this.pendingUnsubscribes.delete(key);
-    }
-    const existing = this.activeStreams.get(key);
-    if (existing) {
-      existing.refCount++;
-      return {
-        unsubscribe: () => this.unregisterStream(key),
-        wasReused: true
-      };
-    }
-    const streamConn = createStream();
-    this.activeStreams.set(key, {
-      unsubscribe: streamConn.unsubscribe,
-      refCount: 1
-    });
-    return {
-      unsubscribe: () => this.unregisterStream(key),
-      wasReused: false
-    };
+  if (sim.length !== next.length || json(sim) !== json(next)) {
+    return { kind: "snapshot", result: next };
   }
-  unregisterStream(key) {
-    const stream = this.activeStreams.get(key);
-    if (!stream)
-      return;
-    stream.refCount--;
-    if (stream.refCount <= 0) {
-      const timeout = setTimeout(() => {
-        this.pendingUnsubscribes.delete(key);
-        const current = this.activeStreams.get(key);
-        if (current && current.refCount <= 0) {
-          current.unsubscribe();
-          this.activeStreams.delete(key);
-        }
-      }, StreamingQueryCache.UNSUBSCRIBE_DELAY_MS);
-      this.pendingUnsubscribes.set(key, timeout);
-    }
-  }
-  subscribeView(viewName, eventWire, scope) {
-    const key = this.storeKey(viewName, scope);
-    const { unsubscribe } = this.registerStream(key, () => {
-      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) {
-    const prefix = `${scope}:`;
-    for (const [key, timeout] of this.pendingUnsubscribes) {
-      if (!key.startsWith(prefix))
-        continue;
-      clearTimeout(timeout);
-      this.pendingUnsubscribes.delete(key);
-    }
-    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) {
-    for (const view3 of this.views) {
-      const handlers = view3.getHandlers();
-      const handler = handlers[event3.type];
-      if (!handler)
-        continue;
-      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);
-      }
+  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);
     }
   }
-  clear() {
-    for (const stream of this.activeStreams.values()) {
-      stream.unsubscribe();
-    }
-    this.activeStreams.clear();
-    for (const timeout of this.pendingUnsubscribes.values()) {
-      clearTimeout(timeout);
-    }
-    this.pendingUnsubscribes.clear();
-    for (const store of this.stores.values()) {
-      store.clear();
+  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);
     }
   }
+  return next;
 }
 
-class StreamingStore {
-  data = new Map;
-  listeners = new Set;
-  initialized = false;
-  hasData() {
-    return this.initialized;
+// 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;
   }
-  setAll(items) {
-    this.initialized = true;
-    this.data.clear();
-    for (const item of items) {
-      this.data.set(item._id, item);
+  flush() {
+    this.schedule();
+  }
+  stop() {
+    this.stopped = true;
+    this.observable?.clear();
+  }
+  schedule() {
+    if (this.stopped)
+      return;
+    if (this.running) {
+      this.rerunRequested = true;
+      return;
     }
-    this.notifyListeners(null);
+    if (this.scheduled)
+      return;
+    this.scheduled = true;
+    queueMicrotask(() => {
+      this.scheduled = false;
+      this.run();
+    });
   }
-  applyChanges(events) {
-    if (events.length === 0)
+  async run() {
+    if (this.stopped)
       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.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 });
+      }
+    } catch (err) {
+      console.error(`[Arc] LiveQuery re-execute error:`, err);
+    } finally {
+      this.running = false;
+      if (this.rerunRequested) {
+        this.rerunRequested = false;
+        this.schedule();
       }
     }
-    this.notifyListeners(events);
-  }
-  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 }]);
+}
+// 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 {
+      const newEntry = {
+        result: undefined,
+        hasResult: false,
+        listeners: new Set,
+        refCount: 1,
+        subscriptionId: ""
+      };
+      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);
-  }
-  findOne(where) {
-    const results = this.find({ where });
-    return results[0];
-  }
-  subscribe(listener4) {
-    this.listeners.add(listener4);
-    return () => {
-      this.listeners.delete(listener4);
-    };
+    this.entries.clear();
   }
-  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([
       {
@@ -5311,6 +5271,7 @@ export {
   extractDatabaseAgnosticSchema,
   executeDescriptor,
   event,
+  diffResults,
   defaultFunctionData,
   deepMerge,
   date,
@@ -5327,6 +5288,7 @@ export {
   array,
   arcFunctionWithCtx,
   arcFunction,
+  applyQueryChanges,
   applyOrderByAndLimit,
   any,
   aggregate,
@@ -5347,6 +5309,7 @@ export {
   MasterStoreState,
   MasterDataStorage,
   LocalEventPublisher,
+  LiveQuery,
   ForkedStoreState,
   ForkedDataStorage,
   EventWire,