@arcote.tech/arc-cli 0.7.15 → 0.7.17

package/dist/index.js

@@ -14017,12 +14017,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) {
@@ -14068,9 +14069,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);
         }
@@ -14146,9 +14149,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",
@@ -14156,20 +14163,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;
@@ -14202,10 +14206,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;
       }
@@ -14233,18 +14244,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)
@@ -14720,7 +14730,7 @@ class DataStorage {
   }
 }
 
-class ScopedStore2 {
+class ScopedStore {
   #inner;
   #restrictions;
   #canWrite;
@@ -15073,6 +15083,47 @@ function deepMerge(target, source) {
 function isPlainObject(item) {
   return item && typeof item === "object" && !Array.isArray(item) && !(item instanceof Date) && Object.prototype.toString.call(item) === "[object Object]";
 }
+function murmurHash(key, seed = 0) {
+  let remainder, bytes, h1, h1b, c1, c2, k1, i;
+  remainder = key.length & 3;
+  bytes = key.length - remainder;
+  h1 = seed;
+  c1 = 3432918353;
+  c2 = 461845907;
+  i = 0;
+  while (i < bytes) {
+    k1 = key.charCodeAt(i) & 255 | (key.charCodeAt(++i) & 255) << 8 | (key.charCodeAt(++i) & 255) << 16 | (key.charCodeAt(++i) & 255) << 24;
+    ++i;
+    k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;
+    h1 ^= k1;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1b = (h1 & 65535) * 5 + (((h1 >>> 16) * 5 & 65535) << 16) & 4294967295;
+    h1 = (h1b & 65535) + 27492 + (((h1b >>> 16) + 58964 & 65535) << 16);
+  }
+  k1 = 0;
+  if (remainder >= 3) {
+    k1 ^= (key.charCodeAt(i + 2) & 255) << 16;
+  }
+  if (remainder >= 2) {
+    k1 ^= (key.charCodeAt(i + 1) & 255) << 8;
+  }
+  if (remainder >= 1) {
+    k1 ^= key.charCodeAt(i) & 255;
+    k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;
+    h1 ^= k1;
+  }
+  h1 ^= key.length;
+  h1 ^= h1 >>> 16;
+  h1 = (h1 & 65535) * 2246822507 + (((h1 >>> 16) * 2246822507 & 65535) << 16) & 4294967295;
+  h1 ^= h1 >>> 13;
+  h1 = (h1 & 65535) * 3266489909 + (((h1 >>> 16) * 3266489909 & 65535) << 16) & 4294967295;
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
 function resolveQueryChange(currentResult, event3, options) {
   const index = currentResult.findIndex((e2) => e2._id === event3.id);
   const isInCurrentResult = index !== -1;
@@ -15082,7 +15133,7 @@ function resolveQueryChange(currentResult, event3, options) {
     }
     return false;
   }
-  const shouldBeInResult = checkItemMatchesWhere2(event3.item, options.where);
+  const shouldBeInResult = checkItemMatchesWhere(event3.item, options.where);
   if (isInCurrentResult && shouldBeInResult) {
     const newResult = currentResult.toSpliced(index, 1, event3.item);
     return applyOrderByAndLimit(newResult, options);
@@ -15094,7 +15145,7 @@ function resolveQueryChange(currentResult, event3, options) {
   }
   return false;
 }
-function checkItemMatchesWhere2(item, where) {
+function checkItemMatchesWhere(item, where) {
   if (!where) {
     return true;
   }
@@ -15188,7 +15239,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;
@@ -15200,10 +15252,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();
@@ -15346,7 +15408,7 @@ function executeDescriptor(descriptor, context2, adapters, contextMethod, option
   return method(...descriptor.args);
 }
 
-class ScopedModel4 {
+class ScopedModel3 {
   context;
   scopeName;
   parent;
@@ -15418,13 +15480,6 @@ class ScopedModel4 {
     }
     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);
   }
@@ -15474,251 +15529,142 @@ class Model2 {
   scope(name) {
     let s = this.scopes.get(name);
     if (!s) {
-      s = new ScopedModel4(this, name);
+      s = new ScopedModel3(this, name);
       this.scopes.set(name, s);
     }
     return s;
   }
 }
-
-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);
-      }
+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);
     }
   }
-  getStore(viewName) {
-    if (!this.stores.has(viewName)) {
-      this.stores.set(viewName, new StreamingStore);
+  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 this.stores.get(viewName);
-  }
-  hasData(viewName) {
-    const store = this.stores.get(viewName);
-    return store ? store.hasData() : false;
   }
-  hasActiveStream(viewName) {
-    return this.activeStreams.has(viewName);
-  }
-  registerStream(viewName, createStream) {
-    const pending = this.pendingUnsubscribes.get(viewName);
-    if (pending) {
-      clearTimeout(pending);
-      this.pendingUnsubscribes.delete(viewName);
-    }
-    const existing = this.activeStreams.get(viewName);
-    if (existing) {
-      existing.refCount++;
-      return {
-        unsubscribe: () => this.unregisterStream(viewName),
-        wasReused: true
+  return next;
+}
+
+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 streamConn = createStream();
-    this.activeStreams.set(viewName, {
-      unsubscribe: streamConn.unsubscribe,
-      refCount: 1
-    });
+    const subscribed = entry;
+    subscribed.listeners.add(onChange);
+    let active = true;
     return {
-      unsubscribe: () => this.unregisterStream(viewName),
-      wasReused: false
-    };
-  }
-  unregisterStream(viewName) {
-    const stream2 = this.activeStreams.get(viewName);
-    if (!stream2)
-      return;
-    stream2.refCount--;
-    if (stream2.refCount <= 0) {
-      const timeout = setTimeout(() => {
-        this.pendingUnsubscribes.delete(viewName);
-        const current2 = this.activeStreams.get(viewName);
-        if (current2 && current2.refCount <= 0) {
-          current2.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) };
-    });
-    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);
-      }
-      const stream2 = this.activeStreams.get(viewName);
-      if (stream2) {
-        try {
-          stream2.unsubscribe();
-        } catch {}
-        this.activeStreams.delete(viewName);
+      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);
       }
-      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]);
-    } else {
-      store.setAll([]);
-    }
+    };
   }
-  async applyEvent(event3) {
-    for (const view3 of this.views) {
-      const handlers = view3.getHandlers();
-      const handler = handlers[event3.type];
-      if (!handler)
+  invalidateScope(scope, eventWire) {
+    const prefix = `${scope}:`;
+    for (const [key, entry] of this.entries) {
+      if (!key.startsWith(prefix))
         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);
-    }
-  }
-  clear() {
-    for (const stream2 of this.activeStreams.values()) {
-      stream2.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();
+      if (entry.pendingUnsub)
+        clearTimeout(entry.pendingUnsub);
+      eventWire?.unsubscribeQuery(entry.subscriptionId);
+      this.entries.delete(key);
+      entry.result = undefined;
+      entry.hasResult = false;
+      this.notify(entry);
     }
   }
-}
-
-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);
+  clear(eventWire) {
+    for (const entry of this.entries.values()) {
+      if (entry.pendingUnsub)
+        clearTimeout(entry.pendingUnsub);
+      eventWire?.unsubscribeQuery(entry.subscriptionId);
     }
-    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 }]);
-    }
-  }
-  remove(id3) {
-    if (this.data.delete(id3)) {
-      this.notifyListeners([{ type: "delete", id: id3, item: null }]);
-    }
-  }
-  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) => checkItemMatchesWhere2(item, options.where));
-    }
-    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 (err3) {
+        console.error(`[Arc] Query cache listener error:`, err3);
+      }
     }
   }
 }
 
 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([
       {
@@ -18862,7 +18808,7 @@ var init_dist = __esm(() => {
         throw new Error(`Scope violation: access denied to store "${storeName}" (not declared in query/mutate)`);
       }
       const inner = this.#inner.getStore(storeName);
-      return new ScopedStore2(inner, this.#restrictions, permission === "read-write");
+      return new ScopedStore(inner, this.#restrictions, permission === "read-write");
     }
     fork() {
       return this.#inner.fork();
@@ -19724,12 +19670,19 @@ var init_dist = __esm(() => {
     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,
@@ -19743,6 +19696,9 @@ var init_dist = __esm(() => {
       }
       if (change.type === "delete") {
         await transaction.remove(this.storeName, change.id);
+        if (transactionCache) {
+          transactionCache.delete(`${this.storeName}:${change.id}`);
+        }
         return {
           from: null,
           to: null,
@@ -19754,17 +19710,12 @@ var init_dist = __esm(() => {
         };
       }
       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,
@@ -19777,17 +19728,12 @@ var init_dist = __esm(() => {
         };
       }
       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 = apply(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,
@@ -21409,12 +21355,13 @@ class EventWire2 {
   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 = ++eventWireInstanceCounter2;
+    this.enableEventSync = options?.enableEventSync ?? true;
   }
   setScopeToken(scope, token) {
     if (token === null) {
@@ -21460,9 +21407,11 @@ class EventWire2 {
         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);
         }
@@ -21538,9 +21487,13 @@ class EventWire2 {
   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",
@@ -21548,20 +21501,17 @@ class EventWire2 {
         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;
@@ -21594,10 +21544,17 @@ class EventWire2 {
           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;
       }
@@ -21625,18 +21582,17 @@ class EventWire2 {
       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)
@@ -22112,7 +22068,7 @@ class DataStorage2 {
   }
 }
 
-class ScopedStore3 {
+class ScopedStore2 {
   #inner;
   #restrictions;
   #canWrite;
@@ -22465,6 +22421,47 @@ function deepMerge2(target, source) {
 function isPlainObject2(item) {
   return item && typeof item === "object" && !Array.isArray(item) && !(item instanceof Date) && Object.prototype.toString.call(item) === "[object Object]";
 }
+function murmurHash2(key, seed = 0) {
+  let remainder, bytes, h1, h1b, c1, c2, k1, i;
+  remainder = key.length & 3;
+  bytes = key.length - remainder;
+  h1 = seed;
+  c1 = 3432918353;
+  c2 = 461845907;
+  i = 0;
+  while (i < bytes) {
+    k1 = key.charCodeAt(i) & 255 | (key.charCodeAt(++i) & 255) << 8 | (key.charCodeAt(++i) & 255) << 16 | (key.charCodeAt(++i) & 255) << 24;
+    ++i;
+    k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;
+    h1 ^= k1;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1b = (h1 & 65535) * 5 + (((h1 >>> 16) * 5 & 65535) << 16) & 4294967295;
+    h1 = (h1b & 65535) + 27492 + (((h1b >>> 16) + 58964 & 65535) << 16);
+  }
+  k1 = 0;
+  if (remainder >= 3) {
+    k1 ^= (key.charCodeAt(i + 2) & 255) << 16;
+  }
+  if (remainder >= 2) {
+    k1 ^= (key.charCodeAt(i + 1) & 255) << 8;
+  }
+  if (remainder >= 1) {
+    k1 ^= key.charCodeAt(i) & 255;
+    k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;
+    h1 ^= k1;
+  }
+  h1 ^= key.length;
+  h1 ^= h1 >>> 16;
+  h1 = (h1 & 65535) * 2246822507 + (((h1 >>> 16) * 2246822507 & 65535) << 16) & 4294967295;
+  h1 ^= h1 >>> 13;
+  h1 = (h1 & 65535) * 3266489909 + (((h1 >>> 16) * 3266489909 & 65535) << 16) & 4294967295;
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
 function resolveQueryChange2(currentResult, event3, options) {
   const index = currentResult.findIndex((e2) => e2._id === event3.id);
   const isInCurrentResult = index !== -1;
@@ -22474,7 +22471,7 @@ function resolveQueryChange2(currentResult, event3, options) {
     }
     return false;
   }
-  const shouldBeInResult = checkItemMatchesWhere3(event3.item, options.where);
+  const shouldBeInResult = checkItemMatchesWhere2(event3.item, options.where);
   if (isInCurrentResult && shouldBeInResult) {
     const newResult = currentResult.toSpliced(index, 1, event3.item);
     return applyOrderByAndLimit2(newResult, options);
@@ -22486,7 +22483,7 @@ function resolveQueryChange2(currentResult, event3, options) {
   }
   return false;
 }
-function checkItemMatchesWhere3(item, where) {
+function checkItemMatchesWhere2(item, where) {
   if (!where) {
     return true;
   }
@@ -22580,7 +22577,8 @@ class ObservableDataStorage2 {
   }
   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;
@@ -22592,10 +22590,20 @@ class ObservableDataStorage2 {
           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();
@@ -22738,7 +22746,7 @@ function executeDescriptor2(descriptor, context2, adapters, contextMethod, optio
   return method(...descriptor.args);
 }
 
-class ScopedModel5 {
+class ScopedModel4 {
   context;
   scopeName;
   parent;
@@ -22810,13 +22818,6 @@ class ScopedModel5 {
     }
     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 buildContextAccessor2(this.context, this.scopedAdapters, "queryContext", (descriptor) => descriptor);
   }
@@ -22866,251 +22867,142 @@ class Model3 {
   scope(name) {
     let s = this.scopes.get(name);
     if (!s) {
-      s = new ScopedModel5(this, name);
+      s = new ScopedModel4(this, name);
       this.scopes.set(name, s);
     }
     return s;
   }
 }
-
-class StreamingQueryCache2 {
-  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 StreamingStore2);
-      }
+function applyQueryChanges2(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);
     }
   }
-  getStore(viewName) {
-    if (!this.stores.has(viewName)) {
-      this.stores.set(viewName, new StreamingStore2);
+  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 this.stores.get(viewName);
   }
-  hasData(viewName) {
-    const store = this.stores.get(viewName);
-    return store ? store.hasData() : false;
-  }
-  hasActiveStream(viewName) {
-    return this.activeStreams.has(viewName);
-  }
-  registerStream(viewName, createStream) {
-    const pending = this.pendingUnsubscribes.get(viewName);
-    if (pending) {
-      clearTimeout(pending);
-      this.pendingUnsubscribes.delete(viewName);
-    }
-    const existing = this.activeStreams.get(viewName);
-    if (existing) {
-      existing.refCount++;
-      return {
-        unsubscribe: () => this.unregisterStream(viewName),
-        wasReused: true
+  return next;
+}
+
+class StreamingQueryCache2 {
+  entries = new Map;
+  static UNSUBSCRIBE_DELAY_MS = 5000;
+  entryKey(descriptor, scope) {
+    return `${scope ?? "default"}:${murmurHash2(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 = applyQueryChanges2(newEntry.result, changes);
+          this.notify(newEntry);
+        }
+      });
+      this.entries.set(key, newEntry);
+      entry = newEntry;
     }
-    const streamConn = createStream();
-    this.activeStreams.set(viewName, {
-      unsubscribe: streamConn.unsubscribe,
-      refCount: 1
-    });
+    const subscribed = entry;
+    subscribed.listeners.add(onChange);
+    let active = true;
     return {
-      unsubscribe: () => this.unregisterStream(viewName),
-      wasReused: false
-    };
-  }
-  unregisterStream(viewName) {
-    const stream2 = this.activeStreams.get(viewName);
-    if (!stream2)
-      return;
-    stream2.refCount--;
-    if (stream2.refCount <= 0) {
-      const timeout = setTimeout(() => {
-        this.pendingUnsubscribes.delete(viewName);
-        const current22 = this.activeStreams.get(viewName);
-        if (current22 && current22.refCount <= 0) {
-          current22.unsubscribe();
-          this.activeStreams.delete(viewName);
-          this.streamScopes.delete(viewName);
-        }
-      }, StreamingQueryCache2.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) };
-    });
-    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);
-      }
-      const stream2 = this.activeStreams.get(viewName);
-      if (stream2) {
-        try {
-          stream2.unsubscribe();
-        } catch {}
-        this.activeStreams.delete(viewName);
+      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);
+        }, StreamingQueryCache2.UNSUBSCRIBE_DELAY_MS);
       }
-      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]);
-    } 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)
+  invalidateScope(scope, eventWire) {
+    const prefix = `${scope}:`;
+    for (const [key, entry] of this.entries) {
+      if (!key.startsWith(prefix))
         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);
+      if (entry.pendingUnsub)
+        clearTimeout(entry.pendingUnsub);
+      eventWire?.unsubscribeQuery(entry.subscriptionId);
+      this.entries.delete(key);
+      entry.result = undefined;
+      entry.hasResult = false;
+      this.notify(entry);
     }
   }
-  clear() {
-    for (const stream2 of this.activeStreams.values()) {
-      stream2.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();
+  clear(eventWire) {
+    for (const entry of this.entries.values()) {
+      if (entry.pendingUnsub)
+        clearTimeout(entry.pendingUnsub);
+      eventWire?.unsubscribeQuery(entry.subscriptionId);
     }
+    this.entries.clear();
   }
-}
-
-class StreamingStore2 {
-  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 }]);
-    }
-  }
-  remove(id3) {
-    if (this.data.delete(id3)) {
-      this.notifyListeners([{ type: "delete", id: id3, item: null }]);
-    }
-  }
-  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) => checkItemMatchesWhere3(item, options.where));
-    }
-    return applyOrderByAndLimit2(results, options);
-  }
-  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 (err3) {
+        console.error(`[Arc] Query cache listener error:`, err3);
+      }
     }
   }
 }
 
 class StreamingEventPublisher2 {
-  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([
       {
@@ -24689,7 +24581,7 @@ var init_dist2 = __esm(() => {
         throw new Error(`Scope violation: access denied to store "${storeName}" (not declared in query/mutate)`);
       }
       const inner = this.#inner.getStore(storeName);
-      return new ScopedStore3(inner, this.#restrictions, permission === "read-write");
+      return new ScopedStore2(inner, this.#restrictions, permission === "read-write");
     }
     fork() {
       return this.#inner.fork();
@@ -25551,12 +25443,19 @@ var init_dist2 = __esm(() => {
     constructor(storeName, dataStorage, deserialize) {
       super(storeName, dataStorage, deserialize);
     }
+    async readExisting(transaction, id22, transactionCache) {
+      const cacheKey = `${this.storeName}:${id22}`;
+      if (transactionCache && transactionCache.has(cacheKey)) {
+        return transactionCache.get(cacheKey);
+      }
+      return transaction.find(this.storeName, { where: { _id: id22 } }).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,
@@ -25570,6 +25469,9 @@ var init_dist2 = __esm(() => {
       }
       if (change.type === "delete") {
         await transaction.remove(this.storeName, change.id);
+        if (transactionCache) {
+          transactionCache.delete(`${this.storeName}:${change.id}`);
+        }
         return {
           from: null,
           to: null,
@@ -25581,17 +25483,12 @@ var init_dist2 = __esm(() => {
         };
       }
       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 ? deepMerge2(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,
@@ -25604,17 +25501,12 @@ var init_dist2 = __esm(() => {
         };
       }
       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,
@@ -34504,8 +34396,8 @@ ${colors3.yellow}Type declaration errors:${colors3.reset}`);
 }
 
 // src/platform/shared.ts
-import { copyFileSync, existsSync as existsSync10, mkdirSync as mkdirSync9, readdirSync as readdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname8, join as join11 } from "path";
+import { copyFileSync, existsSync as existsSync10, mkdirSync as mkdirSync9, readdirSync as readdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname8, join as join12 } from "path";
 
 // src/builder/module-builder.ts
 import { execSync } from "child_process";
@@ -35300,7 +35192,8 @@ writeFileSync(out, JSON.stringify(result, null, 2) + "\\n");
 `.trim();
 
 // src/builder/chunk-planner.ts
-import { basename as basename3 } from "path";
+import { readFileSync as readFileSync9, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
+import { basename as basename3, join as join10 } from "path";
 var PUBLIC_CHUNK = "public";
 function planChunks(packages, accessMap) {
   const assignments = new Map;
@@ -35332,6 +35225,53 @@ function planChunks(packages, accessMap) {
   });
   return { assignments, groups, chunks };
 }
+var MODULE_CALL = /\bmodule\(\s*["'`]([a-zA-Z0-9_-]+)["'`]/g;
+function collectModuleNames(dir, acc) {
+  let entries;
+  try {
+    entries = readdirSync5(dir);
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    if (e === "node_modules" || e === "dist")
+      continue;
+    const full = join10(dir, e);
+    let isDir = false;
+    try {
+      isDir = statSync2(full).isDirectory();
+    } catch {
+      continue;
+    }
+    if (isDir) {
+      collectModuleNames(full, acc);
+    } else if (e.endsWith(".ts") || e.endsWith(".tsx")) {
+      const src = readFileSync9(full, "utf-8");
+      MODULE_CALL.lastIndex = 0;
+      let m;
+      while (m = MODULE_CALL.exec(src))
+        acc.add(m[1]);
+    }
+  }
+}
+function assertOneModulePerPackage(packages) {
+  const offenders = [];
+  for (const pkg of packages) {
+    const names = new Set;
+    collectModuleNames(join10(pkg.path, "src"), names);
+    if (names.size > 1) {
+      offenders.push({ pkg: pkg.name, modules: [...names].sort() });
+    }
+  }
+  if (offenders.length === 0)
+    return;
+  const detail = offenders.map((o) => `  \u2022 ${o.pkg} declares ${o.modules.length}: ${o.modules.join(", ")}`).join(`
+`);
+  throw new Error(`Arc build: a workspace package must declare at most ONE module().
+` + `Chunk grouping is per-package \u2014 a second module() silently inherits the ` + `first module's token protection and chunk, so e.g. a public onboarding ` + `page sharing a package with a workspaceToken-gated module becomes ` + `unreachable for users without that token.
+${detail}
+` + `Fix: move each extra module() into its own workspace package ` + `(declare its own protectedBy there).`);
+}
 function moduleNameOf(pkgName) {
   return pkgName.includes("/") ? pkgName.split("/").pop() : pkgName;
 }
@@ -35339,17 +35279,19 @@ function resolveChunk(moduleName, access) {
   if (!access || access.rules.length === 0)
     return PUBLIC_CHUNK;
   const tokenNames = new Set(access.rules.map((r) => r.token.name));
-  if (tokenNames.size === 1) {
-    return [...tokenNames][0];
+  if (tokenNames.size > 1) {
+    const list = [...tokenNames].sort().join(", ");
+    throw new Error(`Module "${moduleName}" has access rules for multiple tokens [${list}]. ` + `Multi-token modules are not supported \u2014 split the module or unify on a single token type.`);
   }
-  const list = [...tokenNames].sort().join(", ");
-  throw new Error(`Module "${moduleName}" has access rules for multiple tokens [${list}]. ` + `Multi-token modules are not supported \u2014 split the module or unify on a single token type.`);
+  const tokenName = [...tokenNames][0];
+  const hasCheck = access.rules.some((r) => r.hasCheck);
+  return hasCheck ? `${tokenName}__${moduleName}` : tokenName;
 }
 
 // src/builder/dependency-collector.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync9, mkdirSync as mkdirSync8, readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
-import { basename as basename4, dirname as dirname7, join as join10 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
+import { basename as basename4, dirname as dirname7, join as join11 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function collectFrameworkDeps(arcDir, rootDir, packages, sharedDeps = []) {
   mkdirSync8(arcDir, { recursive: true });
@@ -35360,7 +35302,7 @@ function collectFrameworkDeps(arcDir, rootDir, packages, sharedDeps = []) {
   try {
     const cliDir = dirname7(fileURLToPath6(import.meta.url));
     const arcOtelPkgPath = Bun.resolveSync("@arcote.tech/arc-otel/package.json", cliDir);
-    const arcOtelPkg = JSON.parse(readFileSync9(arcOtelPkgPath, "utf-8"));
+    const arcOtelPkg = JSON.parse(readFileSync10(arcOtelPkgPath, "utf-8"));
     for (const [name, spec] of Object.entries(arcOtelPkg.dependencies ?? {})) {
       if (name.startsWith("@opentelemetry/")) {
         versions[name] = spec;
@@ -35371,10 +35313,10 @@ function collectFrameworkDeps(arcDir, rootDir, packages, sharedDeps = []) {
     console.warn(`[arc-otel] could not resolve @arcote.tech/arc-otel \u2014 image will run without telemetry deps: ${e.message}`);
   }
   let rootArc;
-  const rootPkgPath = join10(rootDir, "package.json");
+  const rootPkgPath = join11(rootDir, "package.json");
   if (existsSync9(rootPkgPath)) {
     try {
-      const rootPkg = JSON.parse(readFileSync9(rootPkgPath, "utf-8"));
+      const rootPkg = JSON.parse(readFileSync10(rootPkgPath, "utf-8"));
       if (rootPkg.arc && typeof rootPkg.arc === "object")
         rootArc = rootPkg.arc;
     } catch {}
@@ -35386,11 +35328,11 @@ function collectFrameworkDeps(arcDir, rootDir, packages, sharedDeps = []) {
     dependencies: versions,
     ...rootArc ? { arc: rootArc } : {}
   };
-  const manifestPath = join10(arcDir, "package.json");
+  const manifestPath = join11(arcDir, "package.json");
   writeFileSync8(manifestPath, JSON.stringify(manifest, null, 2) + `
 `);
-  const hash = sha256Hex2(readFileSync9(manifestPath));
-  writeFileSync8(join10(arcDir, ".deps-hash"), hash + `
+  const hash = sha256Hex2(readFileSync10(manifestPath));
+  writeFileSync8(join11(arcDir, ".deps-hash"), hash + `
 `);
   return { hash, manifestPath };
 }
@@ -35398,7 +35340,7 @@ function sha256Hex2(bytes) {
   return createHash("sha256").update(bytes).digest("hex");
 }
 function resolveFrameworkVersions(rootDir, packages) {
-  const rootPkg = JSON.parse(readFileSync9(join10(rootDir, "package.json"), "utf-8"));
+  const rootPkg = JSON.parse(readFileSync10(join11(rootDir, "package.json"), "utf-8"));
   const rootDeps = rootPkg.dependencies ?? {};
   const rootDevDeps = rootPkg.devDependencies ?? {};
   const required = new Set(FRAMEWORK_PEERS);
@@ -35457,9 +35399,9 @@ function resolveWorkspace() {
     process.exit(1);
   }
   const rootDir = dirname8(packageJsonPath);
-  const rootPkg = JSON.parse(readFileSync10(packageJsonPath, "utf-8"));
+  const rootPkg = JSON.parse(readFileSync11(packageJsonPath, "utf-8"));
   const appName = rootPkg.name ?? "Arc App";
-  const arcDir = join11(rootDir, ".arc", "platform");
+  const arcDir = join12(rootDir, ".arc", "platform");
   log2("Scanning workspaces...");
   const packages = discoverPackages(rootDir);
   if (packages.length > 0) {
@@ -35469,10 +35411,10 @@ function resolveWorkspace() {
   }
   let manifest;
   for (const name of ["manifest.json", "manifest.webmanifest"]) {
-    const manifestPath = join11(rootDir, name);
+    const manifestPath = join12(rootDir, name);
     if (existsSync10(manifestPath)) {
       try {
-        const data = JSON.parse(readFileSync10(manifestPath, "utf-8"));
+        const data = JSON.parse(readFileSync11(manifestPath, "utf-8"));
         const icons = data.icons;
         manifest = {
           path: manifestPath,
@@ -35491,9 +35433,9 @@ function resolveWorkspace() {
     rootPkg,
     appName,
     arcDir,
-    browserDir: join11(arcDir, "browser"),
-    assetsDir: join11(arcDir, "assets"),
-    publicDir: join11(rootDir, "public"),
+    browserDir: join12(arcDir, "browser"),
+    assetsDir: join12(arcDir, "assets"),
+    publicDir: join12(rootDir, "public"),
     packages,
     manifest
   };
@@ -35503,11 +35445,12 @@ async function buildAll(ws, opts = {}) {
   const noCache = opts.noCache ?? false;
   const themePath = ws.rootPkg.arc?.theme;
   log2(`Building (concurrency parallel${noCache ? ", no-cache" : ""})...`);
+  assertOneModulePerPackage(ws.packages);
   await buildContextPackages(ws.rootDir, ws.packages, cache, noCache);
   copyContextServerBundles(ws);
   const accessMap = await extractAccessMap(ws.rootDir, ws.packages);
   mkdirSync9(ws.arcDir, { recursive: true });
-  writeFileSync9(join11(ws.arcDir, "access.json"), JSON.stringify(accessMap, null, 2) + `
+  writeFileSync9(join12(ws.arcDir, "access.json"), JSON.stringify(accessMap, null, 2) + `
 `);
   const plan = planChunks(ws.packages, accessMap);
   ok(`Chunks: ${plan.chunks.map((c) => `${c}(${plan.groups.get(c)?.length ?? 0})`).join(", ")}`);
@@ -35523,7 +35466,7 @@ async function buildAll(ws, opts = {}) {
   collectFrameworkDeps(ws.arcDir, ws.rootDir, ws.packages);
   saveBuildCache(ws.arcDir, cache);
   const finalManifest = assembleManifest(ws, browserResult, cache);
-  writeFileSync9(join11(ws.arcDir, "manifest.json"), JSON.stringify(finalManifest, null, 2));
+  writeFileSync9(join12(ws.arcDir, "manifest.json"), JSON.stringify(finalManifest, null, 2));
   return finalManifest;
 }
 function assembleManifest(ws, browser, cache) {
@@ -35537,40 +35480,40 @@ function assembleManifest(ws, browser, cache) {
   };
 }
 function copyContextServerBundles(ws) {
-  const outDir = join11(ws.arcDir, "server");
+  const outDir = join12(ws.arcDir, "server");
   mkdirSync9(outDir, { recursive: true });
   for (const pkg of ws.packages) {
     if (!isContextPackage(pkg.packageJson))
       continue;
-    const src = join11(pkg.path, "dist", "server", "main", "index.js");
+    const src = join12(pkg.path, "dist", "server", "main", "index.js");
     if (!existsSync10(src)) {
       err(`Server bundle missing for ${pkg.name}: ${src}`);
       continue;
     }
     const safeName = pkg.path.split("/").pop();
-    const dst = join11(outDir, `${safeName}.js`);
+    const dst = join12(outDir, `${safeName}.js`);
     copyFileSync(src, dst);
   }
 }
 function resolveAssetSource(from, pkgDir, rootDir) {
   if (from.startsWith("./") || from.startsWith("../")) {
-    const resolved = join11(pkgDir, from);
+    const resolved = join12(pkgDir, from);
     return existsSync10(resolved) ? resolved : null;
   }
   const candidates = [
-    join11(rootDir, "node_modules", from),
-    join11(pkgDir, "node_modules", from)
+    join12(rootDir, "node_modules", from),
+    join12(pkgDir, "node_modules", from)
   ];
   for (const c of candidates) {
     if (existsSync10(c))
       return c;
   }
-  const bunCacheDir = join11(rootDir, "node_modules", ".bun");
+  const bunCacheDir = join12(rootDir, "node_modules", ".bun");
   if (existsSync10(bunCacheDir)) {
-    for (const entry of readdirSync5(bunCacheDir, { withFileTypes: true })) {
+    for (const entry of readdirSync6(bunCacheDir, { withFileTypes: true })) {
       if (!entry.isDirectory())
         continue;
-      const candidate = join11(bunCacheDir, entry.name, "node_modules", from);
+      const candidate = join12(bunCacheDir, entry.name, "node_modules", from);
       if (existsSync10(candidate))
         return candidate;
     }
@@ -35578,11 +35521,11 @@ function resolveAssetSource(from, pkgDir, rootDir) {
   return null;
 }
 function readBrowserAssets(pkgDir) {
-  const pkgJsonPath = join11(pkgDir, "package.json");
+  const pkgJsonPath = join12(pkgDir, "package.json");
   if (!existsSync10(pkgJsonPath))
     return [];
   try {
-    const pkg = JSON.parse(readFileSync10(pkgJsonPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync11(pkgJsonPath, "utf-8"));
     const assets = pkg.arc?.browserAssets;
     if (!Array.isArray(assets))
       return [];
@@ -35592,14 +35535,14 @@ function readBrowserAssets(pkgDir) {
   }
 }
 function discoverBrowserAssets(ws) {
-  const arcDir = join11(ws.rootDir, "node_modules", "@arcote.tech");
+  const arcDir = join12(ws.rootDir, "node_modules", "@arcote.tech");
   if (!existsSync10(arcDir))
     return [];
   const out = [];
-  for (const entry of readdirSync5(arcDir, { withFileTypes: true })) {
+  for (const entry of readdirSync6(arcDir, { withFileTypes: true })) {
     if (!entry.isDirectory() && !entry.isSymbolicLink())
       continue;
-    const pkgDir = join11(arcDir, entry.name);
+    const pkgDir = join12(arcDir, entry.name);
     const assets = readBrowserAssets(pkgDir);
     for (const asset of assets) {
       const src = resolveAssetSource(asset.from, pkgDir, ws.rootDir);
@@ -35624,7 +35567,7 @@ async function copyBrowserAssets(ws, cache, noCache) {
     to: a.to,
     mtime: mtimeOf(a.src)
   })));
-  const requiredOutputs = assets.map((a) => join11(ws.assetsDir, a.to));
+  const requiredOutputs = assets.map((a) => join12(ws.assetsDir, a.to));
   if (!noCache && isCacheHit(cache, unitId, inputHash, requiredOutputs)) {
     console.log(`  \u2713 cached: browser-assets (${assets.length})`);
     return;
@@ -35632,10 +35575,10 @@ async function copyBrowserAssets(ws, cache, noCache) {
   console.log(`  building: browser-assets (${assets.length})`);
   const outputHashes = {};
   for (const asset of assets) {
-    const dest = join11(ws.assetsDir, asset.to);
+    const dest = join12(ws.assetsDir, asset.to);
     mkdirSync9(dirname8(dest), { recursive: true });
     copyFileSync(asset.src, dest);
-    outputHashes[asset.to] = sha256Hex(readFileSync10(dest));
+    outputHashes[asset.to] = sha256Hex(readFileSync11(dest));
   }
   updateCache(cache, unitId, inputHash, { outputHashes });
 }
@@ -35643,15 +35586,15 @@ async function loadServerContext(ws) {
   globalThis.ONLY_SERVER = true;
   globalThis.ONLY_BROWSER = false;
   globalThis.ONLY_CLIENT = false;
-  const platformDir = join11(process.cwd(), "node_modules", "@arcote.tech", "platform");
-  const platformPkg = JSON.parse(readFileSync10(join11(platformDir, "package.json"), "utf-8"));
-  const platformEntry = join11(platformDir, platformPkg.main ?? "src/index.ts");
+  const platformDir = join12(process.cwd(), "node_modules", "@arcote.tech", "platform");
+  const platformPkg = JSON.parse(readFileSync11(join12(platformDir, "package.json"), "utf-8"));
+  const platformEntry = join12(platformDir, platformPkg.main ?? "src/index.ts");
   await import(platformEntry);
-  const serverDir = join11(ws.arcDir, "server");
-  const bundles = existsSync10(serverDir) ? readdirSync5(serverDir).filter((f) => f.endsWith(".js")) : [];
+  const serverDir = join12(ws.arcDir, "server");
+  const bundles = existsSync10(serverDir) ? readdirSync6(serverDir).filter((f) => f.endsWith(".js")) : [];
   if (bundles.length > 0) {
     for (const file of bundles) {
-      const bundlePath = join11(serverDir, file);
+      const bundlePath = join12(serverDir, file);
       try {
         await import(bundlePath);
       } catch (e) {
@@ -35661,7 +35604,7 @@ async function loadServerContext(ws) {
   } else if (ws.packages.length > 0) {
     const ctxPackages = ws.packages.filter((p) => isContextPackage(p.packageJson));
     for (const ctx of ctxPackages) {
-      const serverDist = join11(ctx.path, "dist", "server", "main", "index.js");
+      const serverDist = join12(ctx.path, "dist", "server", "main", "index.js");
       if (!existsSync10(serverDist)) {
         err(`Context server dist not found: ${serverDist}`);
         continue;
@@ -35691,21 +35634,21 @@ async function platformBuild(opts = {}) {
 }
 
 // src/commands/platform-deploy.ts
-import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname11, join as join19 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync15 } from "fs";
+import { dirname as dirname11, join as join20 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 
 // src/deploy/bootstrap.ts
 var {spawn: spawn4 } = globalThis.Bun;
 import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync13 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname9, join as join17 } from "path";
+import { dirname as dirname9, join as join18 } from "path";
 
 // src/deploy/ansible.ts
 import { spawn as nodeSpawn } from "child_process";
 import { existsSync as existsSync11, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
 import { homedir, tmpdir } from "os";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 
 // src/deploy/assets.ts
 var TERRAFORM_MAIN_TF = `terraform {
@@ -35979,28 +35922,28 @@ var ASSETS = {
 };
 async function materializeAssets(targetDir, files) {
   const { mkdirSync: mkdirSync10, writeFileSync: writeFileSync10 } = await import("fs");
-  const { join: join12 } = await import("path");
+  const { join: join13 } = await import("path");
   mkdirSync10(targetDir, { recursive: true });
   for (const [name, content] of Object.entries(files)) {
-    writeFileSync10(join12(targetDir, name), content);
+    writeFileSync10(join13(targetDir, name), content);
   }
 }
 
 // src/deploy/ansible.ts
 function pickSshKeyForAnsible(configured) {
   if (configured) {
-    const expanded = configured.startsWith("~") ? join12(homedir(), configured.slice(1)) : configured;
+    const expanded = configured.startsWith("~") ? join13(homedir(), configured.slice(1)) : configured;
     return existsSync11(expanded) ? expanded : null;
   }
   for (const name of ["id_ed25519", "id_ecdsa", "id_rsa"]) {
-    const path4 = join12(homedir(), ".ssh", name);
+    const path4 = join13(homedir(), ".ssh", name);
     if (existsSync11(path4))
       return path4;
   }
   return null;
 }
 async function runAnsible(inputs) {
-  const workDir = join12(tmpdir(), "arc-deploy", `ansible-${Date.now()}`);
+  const workDir = join13(tmpdir(), "arc-deploy", `ansible-${Date.now()}`);
   mkdirSync10(workDir, { recursive: true });
   await materializeAssets(workDir, ASSETS.ansible);
   const user = inputs.asRoot ? "root" : inputs.target.user;
@@ -36017,7 +35960,7 @@ async function runAnsible(inputs) {
     ""
   ].join(`
 `);
-  writeFileSync10(join12(workDir, "inventory.ini"), inventory);
+  writeFileSync10(join13(workDir, "inventory.ini"), inventory);
   const extraVarsJson = JSON.stringify({
     username: inputs.target.user,
     ssh_port: port,
@@ -37065,10 +37008,10 @@ import { spawn as nodeSpawn2 } from "child_process";
 import { createHash as createHash2 } from "crypto";
 import { existsSync as existsSync12, mkdirSync as mkdirSync11, writeFileSync as writeFileSync11 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 async function runTerraform(inputs) {
   const wsHash = createHash2("sha256").update(inputs.workspaceDir).digest("hex").slice(0, 16);
-  const workDir = join13(homedir2(), ".arc-deploy", wsHash, "tf");
+  const workDir = join14(homedir2(), ".arc-deploy", wsHash, "tf");
   mkdirSync11(workDir, { recursive: true });
   await materializeAssets(workDir, ASSETS.terraform);
   const sshPubKey = inputs.tf.sshPublicKey ?? expandHome("~/.ssh/id_ed25519.pub");
@@ -37085,7 +37028,7 @@ async function runTerraform(inputs) {
   ].join(`
 `) + `
 `;
-  writeFileSync11(join13(workDir, "terraform.tfvars"), tfvars);
+  writeFileSync11(join14(workDir, "terraform.tfvars"), tfvars);
   await runTf(workDir, ["init", "-input=false", "-no-color"]);
   await runTf(workDir, [
     "apply",
@@ -37143,20 +37086,20 @@ function expandHome(p) {
 }
 
 // src/deploy/config.ts
-import { existsSync as existsSync14, readFileSync as readFileSync12, writeFileSync as writeFileSync12 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync12 } from "fs";
+import { join as join16 } from "path";
 
 // src/deploy/env-file.ts
-import { appendFileSync, existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
-import { join as join14 } from "path";
+import { appendFileSync, existsSync as existsSync13, readFileSync as readFileSync12 } from "fs";
+import { join as join15 } from "path";
 function loadDeployEnvFiles(rootDir, envNames) {
-  const globalsPath = join14(rootDir, "deploy.arc.env");
-  const globals = existsSync13(globalsPath) ? parseEnvFile(readFileSync11(globalsPath, "utf-8"), globalsPath) : {};
+  const globalsPath = join15(rootDir, "deploy.arc.env");
+  const globals = existsSync13(globalsPath) ? parseEnvFile(readFileSync12(globalsPath, "utf-8"), globalsPath) : {};
   const perEnv = {};
   for (const name of envNames) {
-    const envPath = join14(rootDir, `deploy.arc.${name}.env`);
+    const envPath = join15(rootDir, `deploy.arc.${name}.env`);
     if (existsSync13(envPath)) {
-      perEnv[name] = parseEnvFile(readFileSync11(envPath, "utf-8"), envPath);
+      perEnv[name] = parseEnvFile(readFileSync12(envPath, "utf-8"), envPath);
     }
   }
   return { globals, perEnv };
@@ -37172,16 +37115,16 @@ function ensurePersistedSecret(rootDir, scope, key, generate) {
   if (process.env[key])
     return process.env[key];
   const fileName = scope === "globals" ? "deploy.arc.env" : `deploy.arc.${scope}.env`;
-  const path4 = join14(rootDir, fileName);
+  const path4 = join15(rootDir, fileName);
   if (existsSync13(path4)) {
-    const existing = parseEnvFile(readFileSync11(path4, "utf-8"), path4);
+    const existing = parseEnvFile(readFileSync12(path4, "utf-8"), path4);
     if (existing[key]) {
       process.env[key] = existing[key];
       return existing[key];
     }
   }
   const value = generate();
-  const prefix = existsSync13(path4) && !readFileSync11(path4, "utf-8").endsWith(`
+  const prefix = existsSync13(path4) && !readFileSync12(path4, "utf-8").endsWith(`
 `) ? `
 ` : "";
   appendFileSync(path4, `${prefix}${key}=${value}
@@ -37217,7 +37160,7 @@ function parseEnvFile(content, pathForErrors) {
 // src/deploy/config.ts
 var DEPLOY_CONFIG_FILE = "deploy.arc.json";
 function deployConfigPath(rootDir) {
-  return join15(rootDir, DEPLOY_CONFIG_FILE);
+  return join16(rootDir, DEPLOY_CONFIG_FILE);
 }
 function deployConfigExists(rootDir) {
   return existsSync14(deployConfigPath(rootDir));
@@ -37227,7 +37170,7 @@ function loadDeployConfig(rootDir) {
   if (!existsSync14(path4)) {
     throw new Error(`Missing ${DEPLOY_CONFIG_FILE} at ${path4}`);
   }
-  const raw = readFileSync12(path4, "utf-8");
+  const raw = readFileSync13(path4, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -37250,7 +37193,7 @@ function loadDeployConfig(rootDir) {
 }
 function saveDeployConfig(rootDir, cfg) {
   const path4 = deployConfigPath(rootDir);
-  const raw = existsSync14(path4) ? JSON.parse(readFileSync12(path4, "utf-8")) : {};
+  const raw = existsSync14(path4) ? JSON.parse(readFileSync13(path4, "utf-8")) : {};
   raw.target = { ...raw.target, ...cfg.target };
   writeFileSync12(path4, JSON.stringify(raw, null, 2) + `
 `);
@@ -37463,14 +37406,14 @@ function cfgErr(path4, expected) {
 var {spawn: spawn3 } = globalThis.Bun;
 import { existsSync as existsSync15 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 function pickSshKey(target) {
   if (target.sshKey) {
-    const expanded = target.sshKey.startsWith("~") ? join16(homedir3(), target.sshKey.slice(1)) : target.sshKey;
+    const expanded = target.sshKey.startsWith("~") ? join17(homedir3(), target.sshKey.slice(1)) : target.sshKey;
     return existsSync15(expanded) ? expanded : null;
   }
   for (const name of ["id_ed25519", "id_ecdsa", "id_rsa"]) {
-    const path4 = join16(homedir3(), ".ssh", name);
+    const path4 = join17(homedir3(), ".ssh", name);
     if (existsSync15(path4))
       return path4;
   }
@@ -37706,7 +37649,7 @@ async function isRegistryRunning(cfg) {
 }
 async function upStack(inputs) {
   const { cfg } = inputs;
-  const workDir = join17(tmpdir2(), "arc-deploy", `stack-${Date.now()}`);
+  const workDir = join18(tmpdir2(), "arc-deploy", `stack-${Date.now()}`);
   mkdirSync12(workDir, { recursive: true });
   await assertRegistryDnsResolves(cfg);
   const password = process.env[cfg.registry.passwordEnv];
@@ -37714,9 +37657,9 @@ async function upStack(inputs) {
     throw new Error(`Registry password env var ${cfg.registry.passwordEnv} is not set. ` + `Set it (e.g. \`export ${cfg.registry.passwordEnv}=...\`) before bootstrap.`);
   }
   const htpasswdLine = await generateHtpasswd(cfg.registry.username, password);
-  writeFileSync13(join17(workDir, "htpasswd"), htpasswdLine);
-  writeFileSync13(join17(workDir, "Caddyfile"), generateCaddyfile(cfg));
-  writeFileSync13(join17(workDir, "docker-compose.yml"), generateCompose({ cfg }));
+  writeFileSync13(join18(workDir, "htpasswd"), htpasswdLine);
+  writeFileSync13(join18(workDir, "Caddyfile"), generateCaddyfile(cfg));
+  writeFileSync13(join18(workDir, "docker-compose.yml"), generateCompose({ cfg }));
   let observabilityFiles = null;
   let observabilityHtpasswd = null;
   if (cfg.observability?.enabled) {
@@ -37728,30 +37671,30 @@ async function upStack(inputs) {
     }
     observabilityHtpasswd = await generateCaddyBasicAuthLine("admin", adminPassword);
     for (const [relPath, contents] of Object.entries(observabilityFiles)) {
-      const fullPath = join17(workDir, relPath);
+      const fullPath = join18(workDir, relPath);
       mkdirSync12(dirname9(fullPath), { recursive: true });
       writeFileSync13(fullPath, contents);
     }
-    writeFileSync13(join17(workDir, "observability-htpasswd"), observabilityHtpasswd);
+    writeFileSync13(join18(workDir, "observability-htpasswd"), observabilityHtpasswd);
   }
   await assertExec(cfg.target, `sudo mkdir -p ${cfg.target.remoteDir} && sudo chown ${cfg.target.user}:${cfg.target.user} ${cfg.target.remoteDir}`);
   for (const name of Object.keys(cfg.envs)) {
     await assertExec(cfg.target, `mkdir -p ${cfg.target.remoteDir}/${name}`);
   }
   await assertExec(cfg.target, `mkdir -p ${cfg.target.remoteDir}/registry-auth`);
-  await scpUpload(cfg.target, join17(workDir, "Caddyfile"), `${cfg.target.remoteDir}/Caddyfile`);
-  await scpUpload(cfg.target, join17(workDir, "docker-compose.yml"), `${cfg.target.remoteDir}/docker-compose.yml`);
-  await scpUpload(cfg.target, join17(workDir, "htpasswd"), `${cfg.target.remoteDir}/registry-auth/htpasswd`);
+  await scpUpload(cfg.target, join18(workDir, "Caddyfile"), `${cfg.target.remoteDir}/Caddyfile`);
+  await scpUpload(cfg.target, join18(workDir, "docker-compose.yml"), `${cfg.target.remoteDir}/docker-compose.yml`);
+  await scpUpload(cfg.target, join18(workDir, "htpasswd"), `${cfg.target.remoteDir}/registry-auth/htpasswd`);
   if (observabilityFiles && observabilityHtpasswd) {
     await assertExec(cfg.target, `mkdir -p ${cfg.target.remoteDir}/observability/grafana-dashboards`);
     for (const relPath of Object.keys(observabilityFiles)) {
-      const localDir = dirname9(join17(workDir, relPath));
+      const localDir = dirname9(join18(workDir, relPath));
       mkdirSync12(localDir, { recursive: true });
     }
     for (const relPath of Object.keys(observabilityFiles)) {
-      await scpUpload(cfg.target, join17(workDir, relPath), `${cfg.target.remoteDir}/${relPath}`);
+      await scpUpload(cfg.target, join18(workDir, relPath), `${cfg.target.remoteDir}/${relPath}`);
     }
-    await scpUpload(cfg.target, join17(workDir, "observability-htpasswd"), `${cfg.target.remoteDir}/observability-htpasswd`);
+    await scpUpload(cfg.target, join18(workDir, "observability-htpasswd"), `${cfg.target.remoteDir}/observability-htpasswd`);
   }
   await assertExec(cfg.target, `touch ${cfg.target.remoteDir}/.env`);
   if (cfg.observability?.enabled) {
@@ -37919,12 +37862,12 @@ import {
   copyFileSync as copyFileSync2,
   existsSync as existsSync16,
   mkdirSync as mkdirSync13,
-  readFileSync as readFileSync13,
+  readFileSync as readFileSync14,
   realpathSync as realpathSync2,
   writeFileSync as writeFileSync14
 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { dirname as dirname10, join as join18 } from "path";
+import { dirname as dirname10, join as join19 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
 // src/deploy/image-template.ts
@@ -37974,7 +37917,7 @@ function generateDockerfile(inputs) {
 // src/deploy/image.ts
 async function buildImage(ws, opts) {
   await ensureDocker();
-  const manifestPath = join18(ws.arcDir, "manifest.json");
+  const manifestPath = join19(ws.arcDir, "manifest.json");
   if (!existsSync16(manifestPath)) {
     throw new Error(`No build manifest at ${manifestPath}. Run \`arc platform build\` first or omit --skip-build.`);
   }
@@ -37985,9 +37928,9 @@ async function buildImage(ws, opts) {
   const dockerfileInputs = collectDockerfileInputs(ws);
   const dockerfile = generateDockerfile(dockerfileInputs);
   const buildContextDir = ws.rootDir;
-  const dockerfileDir = join18(tmpdir3(), `arc-image-${Date.now()}`);
+  const dockerfileDir = join19(tmpdir3(), `arc-image-${Date.now()}`);
   mkdirSync13(dockerfileDir, { recursive: true });
-  const dockerfilePath = join18(dockerfileDir, "Dockerfile");
+  const dockerfilePath = join19(dockerfileDir, "Dockerfile");
   writeFileSync14(dockerfilePath, dockerfile);
   const buildArgs = [
     "build",
@@ -38013,19 +37956,19 @@ async function buildImage(ws, opts) {
 }
 function embedCliBundle(ws) {
   const source = locateCliBundle();
-  const target = join18(ws.arcDir, "host.js");
+  const target = join19(ws.arcDir, "host.js");
   copyFileSync2(source, target);
 }
 function locateCliBundle() {
   const here = fileURLToPath7(import.meta.url);
   let cur = dirname10(here);
   while (cur !== "/" && cur !== "") {
-    const candidate = join18(cur, "package.json");
+    const candidate = join19(cur, "package.json");
     if (existsSync16(candidate)) {
       try {
-        const pkg = JSON.parse(readFileSync13(candidate, "utf-8"));
+        const pkg = JSON.parse(readFileSync14(candidate, "utf-8"));
         if (pkg.name === "@arcote.tech/arc-cli") {
-          const distIndex = join18(realpathSync2(cur), "dist", "index.js");
+          const distIndex = join19(realpathSync2(cur), "dist", "index.js");
           if (!existsSync16(distIndex)) {
             throw new Error(`arc-cli bundle missing at ${distIndex}. Run \`bun run build\` in packages/cli/.`);
           }
@@ -38058,17 +38001,17 @@ async function ensureDocker() {
   }
 }
 function computeContentHash(manifestPath) {
-  const raw = JSON.parse(readFileSync13(manifestPath, "utf-8"));
+  const raw = JSON.parse(readFileSync14(manifestPath, "utf-8"));
   delete raw.buildTime;
   const canonical = JSON.stringify(raw);
   return createHash3("sha256").update(canonical).digest("hex").slice(0, 12);
 }
 function collectDockerfileInputs(ws) {
-  const hasPublicDir = existsSync16(join18(ws.rootDir, "public"));
-  const hasLocales = existsSync16(join18(ws.rootDir, "locales"));
+  const hasPublicDir = existsSync16(join19(ws.rootDir, "public"));
+  const hasLocales = existsSync16(join19(ws.rootDir, "locales"));
   let manifestPath;
   for (const name of ["manifest.webmanifest", "manifest.json"]) {
-    if (existsSync16(join18(ws.rootDir, name))) {
+    if (existsSync16(join19(ws.rootDir, name))) {
       manifestPath = name;
       break;
     }
@@ -38897,7 +38840,7 @@ async function platformDeploy(envArg, options = {}) {
     err(`Unknown env "${envArg}". Known: ${Object.keys(cfg.envs).join(", ")}`);
     process.exit(1);
   })() : Object.keys(cfg.envs);
-  const manifestPath = join19(ws.arcDir, "manifest.json");
+  const manifestPath = join20(ws.arcDir, "manifest.json");
   if (!options.imageTag) {
     const needBuild = options.rebuild || !existsSync17(manifestPath);
     if (needBuild && !options.skipBuild) {
@@ -38970,9 +38913,9 @@ function readCliVersion2() {
     let cur = dirname11(fileURLToPath8(import.meta.url));
     const root = dirname11(cur).startsWith("/") ? "/" : ".";
     while (cur !== root && cur !== "") {
-      const candidate = join19(cur, "package.json");
+      const candidate = join20(cur, "package.json");
       if (existsSync17(candidate)) {
-        const pkg = JSON.parse(readFileSync14(candidate, "utf-8"));
+        const pkg = JSON.parse(readFileSync15(candidate, "utf-8"));
         if (pkg.name === "@arcote.tech/arc-cli") {
           return pkg.version ?? "unknown";
         }
@@ -38988,8 +38931,8 @@ function readCliVersion2() {
   }
 }
 async function hashDeployConfig(rootDir) {
-  const p2 = join19(rootDir, "deploy.arc.json");
-  const content = readFileSync14(p2);
+  const p2 = join20(rootDir, "deploy.arc.json");
+  const content = readFileSync15(p2);
   const hasher = new Bun.CryptoHasher("sha256");
   hasher.update(content);
   hasher.update(readCliVersion2());
@@ -38997,8 +38940,8 @@ async function hashDeployConfig(rootDir) {
 }
 
 // src/platform/startup.ts
-import { existsSync as existsSync19, readFileSync as readFileSync15, watch } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync16, watch } from "fs";
+import { join as join22 } from "path";
 
 // ../host/src/create-server.ts
 var import_jsonwebtoken = __toESM(require_jsonwebtoken(), 1);
@@ -40055,66 +39998,14 @@ function arcHttpHandlers(ch, cm) {
   ];
 }
 // ../host/src/middleware/ws.ts
-import {
-  ScopedModel as ScopedModel3,
-  ScopedStore,
-  checkItemMatchesWhere
-} from "@arcote.tech/arc";
-var viewSubscribers = new Map;
+import { LiveQuery } from "@arcote.tech/arc";
+var clientQuerySubs = new Map;
 function cleanupClientSubs(clientId) {
-  const prefix = `${clientId}:`;
-  for (const subs of viewSubscribers.values()) {
-    for (const key of subs.keys()) {
-      if (key.startsWith(prefix))
-        subs.delete(key);
-    }
-  }
-}
-function filterChangeForSubscriber(change, restrictions) {
-  const newMatches = change.newRow !== null && (restrictions === null || checkItemMatchesWhere(change.newRow, restrictions));
-  if (newMatches) {
-    return { type: "set", id: change.id, item: change.newRow };
-  }
-  const oldMatches = change.oldRow !== null && (restrictions === null || checkItemMatchesWhere(change.oldRow, restrictions));
-  if (oldMatches) {
-    return { type: "delete", id: change.id, item: null };
-  }
-  return null;
-}
-function broadcastViewChanges(committed, connectionManager) {
-  const byStore = new Map;
-  for (const change of committed) {
-    let list = byStore.get(change.store);
-    if (!list) {
-      list = [];
-      byStore.set(change.store, list);
-    }
-    list.push(change);
-  }
-  for (const [viewName, changes] of byStore) {
-    const subs = viewSubscribers.get(viewName);
-    if (!subs || subs.size === 0)
-      continue;
-    for (const sub of subs.values()) {
-      const filtered = [];
-      for (const change of changes) {
-        const wireChange = filterChangeForSubscriber(change, sub.restrictions);
-        if (wireChange)
-          filtered.push(wireChange);
-      }
-      if (filtered.length === 0)
-        continue;
-      if (sub.buffer) {
-        sub.buffer.push(...filtered);
-        continue;
-      }
-      connectionManager.sendToClient(sub.clientId, {
-        type: "view-changes",
-        element: viewName,
-        scope: sub.scope,
-        changes: filtered
-      });
-    }
+  const subs = clientQuerySubs.get(clientId);
+  if (subs) {
+    for (const live of subs.values())
+      live.stop();
+    clientQuerySubs.delete(clientId);
   }
 }
 function scopeAuthHandler() {
@@ -40213,82 +40104,62 @@ function executeCommandHandler() {
     return true;
   };
 }
-function viewSubscriptionHandler() {
+function querySubscriptionHandler() {
   return async (client, message, ctx) => {
-    if (message.type === "subscribe-view") {
-      const { element: elementName } = message;
+    if (message.type === "subscribe-query") {
+      const { subscriptionId, descriptor } = message;
       const scope = message.scope ?? "default";
       const scopeToken = client.scopeTokens.get(scope) ?? null;
       let rawToken = scopeToken?.raw ?? null;
       if (!rawToken && client.scopeTokens.size > 0) {
         rawToken = client.scopeTokens.values().next().value.raw;
       }
-      const scoped = new ScopedModel3(ctx.contextHandler.getModel(), scope);
-      if (rawToken)
-        scoped.setToken(rawToken);
-      const element = ctx.contextHandler.getModel().context.get(elementName);
-      if (!element || typeof element.getRestrictionsFor !== "function") {
-        ctx.connectionManager.sendToClient(client.id, {
-          type: "error",
-          message: `Cannot subscribe to view "${elementName}": unknown element`
-        });
-        return true;
-      }
-      const { restrictions, denied } = element.getRestrictionsFor(scoped.getAdapters());
-      const subKey = `${client.id}:${scope}`;
-      if (denied) {
-        viewSubscribers.get(elementName)?.delete(subKey);
-        ctx.connectionManager.sendToClient(client.id, {
-          type: "view-snapshot",
-          element: elementName,
-          scope,
-          items: []
-        });
-        return true;
-      }
-      const subscriber = {
-        clientId: client.id,
-        scope,
-        restrictions,
-        buffer: []
-      };
-      if (!viewSubscribers.has(elementName)) {
-        viewSubscribers.set(elementName, new Map);
+      clientQuerySubs.get(client.id)?.get(subscriptionId)?.stop();
+      const live = new LiveQuery(ctx.contextHandler.getModel(), descriptor, scope, rawToken, (update) => {
+        if (update.type === "changes") {
+          ctx.connectionManager.sendToClient(client.id, {
+            type: "query-changes",
+            subscriptionId,
+            changes: update.changes
+          });
+        } else {
+          ctx.connectionManager.sendToClient(client.id, {
+            type: "query-snapshot",
+            subscriptionId,
+            result: update.result ?? null
+          });
+        }
+      });
+      if (!clientQuerySubs.has(client.id)) {
+        clientQuerySubs.set(client.id, new Map);
       }
-      viewSubscribers.get(elementName).set(subKey, subscriber);
+      clientQuerySubs.get(client.id).set(subscriptionId, live);
       try {
-        const store = ctx.contextHandler.getDataStorage().getStore(elementName);
-        const items = restrictions ? await new ScopedStore(store, restrictions, false).find({}) : await store.find({});
+        const result = await live.start();
         ctx.connectionManager.sendToClient(client.id, {
-          type: "view-snapshot",
-          element: elementName,
-          scope,
-          items
+          type: "query-snapshot",
+          subscriptionId,
+          result: result ?? null
         });
+        live.flush();
       } catch (err3) {
-        viewSubscribers.get(elementName)?.delete(subKey);
-        console.error(`[Arc] View subscription error (${elementName}):`, err3);
+        live.stop();
+        clientQuerySubs.get(client.id)?.delete(subscriptionId);
+        console.error(`[Arc] Query subscription error (${descriptor?.element}.${descriptor?.method}):`, err3);
         ctx.connectionManager.sendToClient(client.id, {
           type: "error",
-          message: `Failed to subscribe to view "${elementName}"`
-        });
-        return true;
-      }
-      const buffered = subscriber.buffer;
-      subscriber.buffer = null;
-      if (buffered.length > 0) {
-        ctx.connectionManager.sendToClient(client.id, {
-          type: "view-changes",
-          element: elementName,
-          scope,
-          changes: buffered
+          message: `Failed to subscribe to query "${descriptor?.element}.${descriptor?.method}"`
         });
       }
       return true;
     }
-    if (message.type === "unsubscribe-view") {
-      const scope = message.scope ?? "default";
-      viewSubscribers.get(message.element)?.delete(`${client.id}:${scope}`);
+    if (message.type === "unsubscribe-query") {
+      const subs = clientQuerySubs.get(client.id);
+      const live = subs?.get(message.subscriptionId);
+      if (live) {
+        live.stop();
+        subs.delete(message.subscriptionId);
+      }
       return true;
     }
     return false;
@@ -40300,7 +40171,7 @@ function arcWsHandlers() {
     syncEventsHandler(),
     requestSyncHandler(),
     executeCommandHandler(),
-    viewSubscriptionHandler()
+    querySubscriptionHandler()
   ];
 }
 // ../host/src/create-server.ts
@@ -40313,7 +40184,6 @@ async function createArcServer(config) {
   const cronScheduler = new CronScheduler(contextHandler);
   cronScheduler.start();
   const connectionManager = new ConnectionManager;
-  contextHandler.getEventPublisher().onViewChanges((changes) => broadcastViewChanges(changes, connectionManager));
   function buildCorsHeaders(req) {
     const origin = req?.headers.get("Origin") || "*";
     return {
@@ -40491,7 +40361,7 @@ async function createArcServer(config) {
 // src/platform/server.ts
 init_i18n();
 import { existsSync as existsSync18, mkdirSync as mkdirSync14 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 async function resolveDbAdapterFactory(dbPath) {
   const databaseUrl = process.env.DATABASE_URL;
   if (databaseUrl && databaseUrl.length > 0) {
@@ -40623,15 +40493,13 @@ function parseArcTokensHeader(header) {
   return payloads;
 }
 async function filterManifestForTokens(manifest, moduleAccessMap, tokenPayloads) {
-  const allowedGroups = new Set;
+  const tokensByName = new Map;
   for (const t of tokenPayloads) {
     if (t?.tokenType)
-      allowedGroups.add(t.tokenType);
+      tokensByName.set(t.tokenType, t);
   }
   const filteredGroups = {};
   for (const [name, group] of Object.entries(manifest.groups)) {
-    if (!allowedGroups.has(name))
-      continue;
     let allGranted = true;
     for (const moduleName of group.modules) {
       const access = moduleAccessMap.get(moduleName);
@@ -40639,9 +40507,7 @@ async function filterManifestForTokens(manifest, moduleAccessMap, tokenPayloads)
         continue;
       let granted = false;
       for (const rule of access.rules) {
-        if (rule.token.name !== name)
-          continue;
-        const matching = tokenPayloads.find((t) => t.tokenType === name);
+        const matching = tokensByName.get(rule.token.name);
         if (!matching)
           continue;
         granted = rule.check ? await rule.check(matching) : true;
@@ -40682,28 +40548,28 @@ function staticFilesHandler(ws, devMode, getManifest) {
           return new Response("Forbidden", { status: 403, headers: ctx.corsHeaders });
         }
       }
-      return serveFile(join20(ws.browserDir, file), {
+      return serveFile(join21(ws.browserDir, file), {
         ...ctx.corsHeaders,
         "Cache-Control": devMode ? "no-cache" : "max-age=31536000,immutable"
       });
     }
     if (path4.startsWith("/locales/"))
-      return serveFile(join20(ws.arcDir, path4.slice(1)), {
+      return serveFile(join21(ws.arcDir, path4.slice(1)), {
         ...ctx.corsHeaders,
         "Cache-Control": devMode ? "no-cache" : "max-age=300,stale-while-revalidate=3600"
       });
     if (path4.startsWith("/assets/"))
-      return serveFile(join20(ws.assetsDir, path4.slice(8)), {
+      return serveFile(join21(ws.assetsDir, path4.slice(8)), {
         ...ctx.corsHeaders,
         "Cache-Control": devMode ? "no-cache" : "max-age=31536000,immutable"
       });
     if (path4 === "/styles.css")
-      return serveFile(join20(ws.arcDir, "styles.css"), {
+      return serveFile(join21(ws.arcDir, "styles.css"), {
         ...ctx.corsHeaders,
         "Cache-Control": devMode ? "no-cache" : "max-age=31536000,immutable"
       });
     if (path4 === "/theme.css")
-      return serveFile(join20(ws.arcDir, "theme.css"), {
+      return serveFile(join21(ws.arcDir, "theme.css"), {
         ...ctx.corsHeaders,
         "Cache-Control": devMode ? "no-cache" : "max-age=31536000,immutable"
       });
@@ -40711,7 +40577,7 @@ function staticFilesHandler(ws, devMode, getManifest) {
       return serveFile(ws.manifest.path, ctx.corsHeaders);
     }
     if (path4.lastIndexOf(".") > path4.lastIndexOf("/")) {
-      const publicFile = join20(ws.publicDir, path4.slice(1));
+      const publicFile = join21(ws.publicDir, path4.slice(1));
       if (existsSync18(publicFile))
         return serveFile(publicFile, ctx.corsHeaders);
     }
@@ -40866,7 +40732,7 @@ async function startPlatformServer(opts) {
       stop: () => server.stop()
     };
   }
-  const dbPath = opts.dbPath || join20(ws.arcDir, "data", "arc.db");
+  const dbPath = opts.dbPath || join21(ws.arcDir, "data", "arc.db");
   const baseDbFactory = await resolveDbAdapterFactory(dbPath);
   let dbAdapterFactory = baseDbFactory;
   if (telemetry) {
@@ -40907,17 +40773,17 @@ async function startPlatformServer(opts) {
 async function startPlatform(opts) {
   const { ws, devMode } = opts;
   const port = opts.port ?? parseInt(process.env.PORT || "5005", 10);
-  const dbPath = opts.dbPath ?? join21(ws.rootDir, ".arc", "data", devMode ? "dev.db" : "prod.db");
+  const dbPath = opts.dbPath ?? join22(ws.rootDir, ".arc", "data", devMode ? "dev.db" : "prod.db");
   let manifest;
   if (devMode) {
     manifest = await buildAll(ws);
   } else {
-    const manifestPath = join21(ws.arcDir, "manifest.json");
+    const manifestPath = join22(ws.arcDir, "manifest.json");
     if (!existsSync19(manifestPath)) {
       err("No build found. Run `arc platform build` first.");
       process.exit(1);
     }
-    manifest = JSON.parse(readFileSync15(manifestPath, "utf-8"));
+    manifest = JSON.parse(readFileSync16(manifestPath, "utf-8"));
   }
   log2("Loading server context...");
   const { context: context2, moduleAccess } = await loadServerContext(ws);
@@ -40993,7 +40859,7 @@ function attachDevWatcher(ws, platform3) {
     }, 300);
   };
   for (const pkg of ws.packages) {
-    const srcDir = join21(pkg.path, "src");
+    const srcDir = join22(pkg.path, "src");
     if (!existsSync19(srcDir))
       continue;
     watch(srcDir, { recursive: true }, (_event, filename) => {
@@ -41004,7 +40870,7 @@ function attachDevWatcher(ws, platform3) {
       triggerRebuild();
     });
   }
-  const localesDir = join21(ws.rootDir, "locales");
+  const localesDir = join22(ws.rootDir, "locales");
   if (existsSync19(localesDir)) {
     watch(localesDir, { recursive: false }, (_event, filename) => {
       if (!filename?.endsWith(".po"))