@sylphx/lens-solid 2.3.4 → 2.3.6

package/dist/index.js

@@ -1069,6 +1069,217 @@ class ReconnectionMetricsTracker {
     return sorted[Math.max(0, index)];
   }
 }
+class SubscriptionRegistry {
+  subscriptions = new Map;
+  entityIndex = new Map;
+  add(sub) {
+    const tracked = {
+      ...sub,
+      state: "pending",
+      lastDataHash: sub.lastData ? hashEntityState(sub.lastData) : null,
+      createdAt: Date.now(),
+      lastUpdateAt: null
+    };
+    this.subscriptions.set(sub.id, tracked);
+    const entityKey = `${sub.entity}:${sub.entityId}`;
+    let ids = this.entityIndex.get(entityKey);
+    if (!ids) {
+      ids = new Set;
+      this.entityIndex.set(entityKey, ids);
+    }
+    ids.add(sub.id);
+  }
+  get(id2) {
+    return this.subscriptions.get(id2);
+  }
+  has(id2) {
+    return this.subscriptions.has(id2);
+  }
+  remove(id2) {
+    const sub = this.subscriptions.get(id2);
+    if (!sub)
+      return;
+    this.subscriptions.delete(id2);
+    const entityKey = `${sub.entity}:${sub.entityId}`;
+    const ids = this.entityIndex.get(entityKey);
+    if (ids) {
+      ids.delete(id2);
+      if (ids.size === 0) {
+        this.entityIndex.delete(entityKey);
+      }
+    }
+  }
+  getByEntity(entity22, entityId) {
+    const entityKey = `${entity22}:${entityId}`;
+    const ids = this.entityIndex.get(entityKey);
+    if (!ids)
+      return [];
+    const result = [];
+    for (const id2 of ids) {
+      const sub = this.subscriptions.get(id2);
+      if (sub) {
+        result.push(sub);
+      }
+    }
+    return result;
+  }
+  updateVersion(id2, version, data) {
+    const sub = this.subscriptions.get(id2);
+    if (!sub)
+      return;
+    sub.version = version;
+    sub.lastUpdateAt = Date.now();
+    if (data !== undefined) {
+      sub.lastData = data;
+      sub.lastDataHash = hashEntityState(data);
+    }
+    if (sub.state === "pending" || sub.state === "reconnecting") {
+      sub.state = "active";
+    }
+  }
+  updateData(id2, data) {
+    const sub = this.subscriptions.get(id2);
+    if (!sub)
+      return;
+    sub.lastData = data;
+    sub.lastDataHash = hashEntityState(data);
+  }
+  getLastData(id2) {
+    return this.subscriptions.get(id2)?.lastData ?? null;
+  }
+  getVersion(id2) {
+    return this.subscriptions.get(id2)?.version ?? null;
+  }
+  markActive(id2) {
+    const sub = this.subscriptions.get(id2);
+    if (sub) {
+      sub.state = "active";
+    }
+  }
+  markError(id2) {
+    const sub = this.subscriptions.get(id2);
+    if (sub) {
+      sub.state = "error";
+    }
+  }
+  markAllReconnecting() {
+    for (const sub of this.subscriptions.values()) {
+      if (sub.state === "active") {
+        sub.state = "reconnecting";
+      }
+    }
+  }
+  getByState(state) {
+    const result = [];
+    for (const sub of this.subscriptions.values()) {
+      if (sub.state === state) {
+        result.push(sub);
+      }
+    }
+    return result;
+  }
+  getAllForReconnect() {
+    const result = [];
+    for (const sub of this.subscriptions.values()) {
+      if (sub.state === "reconnecting" || sub.state === "active") {
+        const reconnectSub = {
+          id: sub.id,
+          entity: sub.entity,
+          entityId: sub.entityId,
+          fields: sub.fields,
+          version: sub.version,
+          input: sub.input
+        };
+        if (sub.lastDataHash) {
+          reconnectSub.dataHash = sub.lastDataHash;
+        }
+        result.push(reconnectSub);
+      }
+    }
+    return result;
+  }
+  processReconnectResult(id2, version, data) {
+    const sub = this.subscriptions.get(id2);
+    if (!sub)
+      return;
+    sub.version = version;
+    sub.state = "active";
+    sub.lastUpdateAt = Date.now();
+    if (data !== undefined) {
+      sub.lastData = data;
+      sub.lastDataHash = hashEntityState(data);
+    }
+  }
+  getObserver(id2) {
+    return this.subscriptions.get(id2)?.observer;
+  }
+  updateObserver(id2, observer) {
+    const sub = this.subscriptions.get(id2);
+    if (sub) {
+      sub.observer = observer;
+    }
+  }
+  notifyNext(id2, data) {
+    const sub = this.subscriptions.get(id2);
+    sub?.observer.next?.({ data, version: sub.version });
+  }
+  notifyError(id2, error) {
+    this.subscriptions.get(id2)?.observer.error?.(error);
+  }
+  notifyAllReconnectingError(error) {
+    for (const sub of this.subscriptions.values()) {
+      if (sub.state === "reconnecting") {
+        sub.observer.error?.(error);
+      }
+    }
+  }
+  get size() {
+    return this.subscriptions.size;
+  }
+  getIds() {
+    return Array.from(this.subscriptions.keys());
+  }
+  values() {
+    return this.subscriptions.values();
+  }
+  getStats() {
+    const byState = {
+      pending: 0,
+      active: 0,
+      reconnecting: 0,
+      error: 0
+    };
+    const byEntity = {};
+    for (const sub of this.subscriptions.values()) {
+      byState[sub.state]++;
+      const entityKey = `${sub.entity}:${sub.entityId}`;
+      byEntity[entityKey] = (byEntity[entityKey] ?? 0) + 1;
+    }
+    return {
+      total: this.subscriptions.size,
+      byState,
+      byEntity
+    };
+  }
+  clear() {
+    for (const sub of this.subscriptions.values()) {
+      sub.observer.complete?.();
+    }
+    this.subscriptions.clear();
+    this.entityIndex.clear();
+  }
+  clearErrors() {
+    const toRemove = [];
+    for (const [id2, sub] of this.subscriptions) {
+      if (sub.state === "error") {
+        toRemove.push(id2);
+      }
+    }
+    for (const id2 of toRemove) {
+      this.remove(id2);
+    }
+  }
+}
 function applyOps(state, ops) {
   let result = state;
   for (const op2 of ops) {
@@ -1310,6 +1521,282 @@ function isError(msg) {
 }
 
 // ../client/dist/index.js
+class SelectionRegistry {
+  endpoints = new Map;
+  addSubscriber(params) {
+    const { endpointKey, subscriberId, selection, onData, onError } = params;
+    let endpoint = this.endpoints.get(endpointKey);
+    const previousSelection = endpoint ? { ...endpoint.mergedSelection } : {};
+    if (!endpoint) {
+      endpoint = {
+        key: endpointKey,
+        subscribers: new Map,
+        mergedSelection: {},
+        lastData: null,
+        isSubscribed: false,
+        createdAt: Date.now(),
+        lastSelectionChangeAt: null
+      };
+      this.endpoints.set(endpointKey, endpoint);
+    }
+    const subscriberMeta = {
+      id: subscriberId,
+      selection,
+      onData,
+      createdAt: Date.now()
+    };
+    if (onError) {
+      subscriberMeta.onError = onError;
+    }
+    endpoint.subscribers.set(subscriberId, subscriberMeta);
+    const newSelection = this.computeMergedSelection(endpoint);
+    const analysis = this.analyzeSelectionChange(previousSelection, newSelection);
+    if (analysis.hasChanged) {
+      endpoint.mergedSelection = newSelection;
+      endpoint.lastSelectionChangeAt = Date.now();
+    }
+    return analysis;
+  }
+  removeSubscriber(endpointKey, subscriberId) {
+    const endpoint = this.endpoints.get(endpointKey);
+    if (!endpoint) {
+      return this.noChangeAnalysis();
+    }
+    const previousSelection = { ...endpoint.mergedSelection };
+    endpoint.subscribers.delete(subscriberId);
+    if (endpoint.subscribers.size === 0) {
+      this.endpoints.delete(endpointKey);
+      return this.analyzeSelectionChange(previousSelection, {});
+    }
+    const newSelection = this.computeMergedSelection(endpoint);
+    const analysis = this.analyzeSelectionChange(previousSelection, newSelection);
+    if (analysis.hasChanged) {
+      endpoint.mergedSelection = newSelection;
+      endpoint.lastSelectionChangeAt = Date.now();
+    }
+    return analysis;
+  }
+  getMergedSelection(endpointKey) {
+    return this.endpoints.get(endpointKey)?.mergedSelection ?? null;
+  }
+  getSubscriberIds(endpointKey) {
+    const endpoint = this.endpoints.get(endpointKey);
+    return endpoint ? Array.from(endpoint.subscribers.keys()) : [];
+  }
+  getSubscriberCount(endpointKey) {
+    return this.endpoints.get(endpointKey)?.subscribers.size ?? 0;
+  }
+  hasSubscribers(endpointKey) {
+    return (this.endpoints.get(endpointKey)?.subscribers.size ?? 0) > 0;
+  }
+  distributeData(endpointKey, data) {
+    const endpoint = this.endpoints.get(endpointKey);
+    if (!endpoint)
+      return;
+    endpoint.lastData = data;
+    for (const subscriber of endpoint.subscribers.values()) {
+      try {
+        const filteredData = filterToSelection(data, subscriber.selection);
+        subscriber.onData(filteredData);
+      } catch (error) {
+        if (subscriber.onError) {
+          subscriber.onError(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    }
+  }
+  distributeError(endpointKey, error) {
+    const endpoint = this.endpoints.get(endpointKey);
+    if (!endpoint)
+      return;
+    for (const subscriber of endpoint.subscribers.values()) {
+      subscriber.onError?.(error);
+    }
+  }
+  getLastData(endpointKey) {
+    return this.endpoints.get(endpointKey)?.lastData ?? null;
+  }
+  markSubscribed(endpointKey) {
+    const endpoint = this.endpoints.get(endpointKey);
+    if (endpoint) {
+      endpoint.isSubscribed = true;
+    }
+  }
+  markUnsubscribed(endpointKey) {
+    const endpoint = this.endpoints.get(endpointKey);
+    if (endpoint) {
+      endpoint.isSubscribed = false;
+    }
+  }
+  isSubscribed(endpointKey) {
+    return this.endpoints.get(endpointKey)?.isSubscribed ?? false;
+  }
+  getEndpointKeys() {
+    return Array.from(this.endpoints.keys());
+  }
+  clear() {
+    this.endpoints.clear();
+  }
+  getStats() {
+    let totalSubscribers = 0;
+    for (const endpoint of this.endpoints.values()) {
+      totalSubscribers += endpoint.subscribers.size;
+    }
+    return {
+      endpointCount: this.endpoints.size,
+      totalSubscribers,
+      avgSubscribersPerEndpoint: this.endpoints.size > 0 ? totalSubscribers / this.endpoints.size : 0
+    };
+  }
+  computeMergedSelection(endpoint) {
+    const selections = Array.from(endpoint.subscribers.values()).map((s) => s.selection);
+    return mergeSelections(selections);
+  }
+  analyzeSelectionChange(previous, next) {
+    const previousFields = this.flattenSelectionKeys(previous);
+    const nextFields = this.flattenSelectionKeys(next);
+    const addedFields = new Set;
+    const removedFields = new Set;
+    for (const field of nextFields) {
+      if (!previousFields.has(field)) {
+        addedFields.add(field);
+      }
+    }
+    for (const field of previousFields) {
+      if (!nextFields.has(field)) {
+        removedFields.add(field);
+      }
+    }
+    const hasChanged = addedFields.size > 0 || removedFields.size > 0;
+    return {
+      hasChanged,
+      previousSelection: previous,
+      newSelection: next,
+      addedFields,
+      removedFields,
+      isExpanded: addedFields.size > 0,
+      isShrunk: removedFields.size > 0
+    };
+  }
+  flattenSelectionKeys(selection, prefix = "") {
+    const keys = new Set;
+    for (const [key, value] of Object.entries(selection)) {
+      const path = prefix ? `${prefix}.${key}` : key;
+      keys.add(path);
+      if (typeof value === "boolean") {
+        continue;
+      }
+      if (typeof value === "object" && value !== null) {
+        let nestedSelection;
+        if ("select" in value && typeof value.select === "object") {
+          nestedSelection = value.select;
+        } else if (!("input" in value)) {
+          nestedSelection = value;
+        }
+        if (nestedSelection) {
+          const nestedKeys = this.flattenSelectionKeys(nestedSelection, path);
+          for (const nestedKey of nestedKeys) {
+            keys.add(nestedKey);
+          }
+        }
+      }
+    }
+    return keys;
+  }
+  noChangeAnalysis() {
+    return {
+      hasChanged: false,
+      previousSelection: {},
+      newSelection: {},
+      addedFields: new Set,
+      removedFields: new Set,
+      isExpanded: false,
+      isShrunk: false
+    };
+  }
+}
+function mergeSelections(selections) {
+  if (selections.length === 0)
+    return {};
+  if (selections.length === 1)
+    return selections[0];
+  const merged = {};
+  const allKeys = new Set;
+  for (const selection of selections) {
+    for (const key of Object.keys(selection)) {
+      allKeys.add(key);
+    }
+  }
+  for (const key of allKeys) {
+    const values = selections.map((s) => s[key]).filter((v) => v !== undefined && v !== null);
+    if (values.length === 0)
+      continue;
+    if (values.some((v) => v === true)) {
+      merged[key] = true;
+      continue;
+    }
+    const nestedSelections = [];
+    let lastInput;
+    for (const value of values) {
+      if (typeof value === "object" && value !== null) {
+        if ("select" in value && typeof value.select === "object") {
+          nestedSelections.push(value.select);
+          if ("input" in value) {
+            lastInput = value.input;
+          }
+        } else if ("input" in value) {
+          lastInput = value.input;
+          merged[key] = { input: lastInput };
+        } else {
+          nestedSelections.push(value);
+        }
+      }
+    }
+    if (nestedSelections.length > 0) {
+      const mergedNested = mergeSelections(nestedSelections);
+      if (lastInput !== undefined) {
+        merged[key] = { input: lastInput, select: mergedNested };
+      } else {
+        merged[key] = mergedNested;
+      }
+    }
+  }
+  return merged;
+}
+function filterToSelection(data, selection) {
+  if (data == null)
+    return data;
+  if (Array.isArray(data)) {
+    return data.map((item) => filterToSelection(item, selection));
+  }
+  if (typeof data !== "object")
+    return data;
+  const obj = data;
+  const result = {};
+  if ("id" in obj) {
+    result.id = obj.id;
+  }
+  for (const [key, value] of Object.entries(selection)) {
+    if (!(key in obj))
+      continue;
+    if (value === true) {
+      result[key] = obj[key];
+    } else if (typeof value === "object" && value !== null) {
+      let nestedSelection = null;
+      if ("select" in value && typeof value.select === "object") {
+        nestedSelection = value.select;
+      } else if (!("input" in value)) {
+        nestedSelection = value;
+      }
+      if (nestedSelection) {
+        result[key] = filterToSelection(obj[key], nestedSelection);
+      } else {
+        result[key] = obj[key];
+      }
+    }
+  }
+  return result;
+}
 function hasAnySubscription(entities, entityName, select, visited = new Set) {
   if (!entities)
     return false;
@@ -1341,13 +1828,19 @@ function hasAnySubscription(entities, entityName, select, visited = new Set) {
   }
   return false;
 }
+var subscriberIdCounter = 0;
+function generateSubscriberId() {
+  return `sub_${Date.now()}_${++subscriberIdCounter}`;
+}
 
 class ClientImpl {
   transport;
   plugins;
   metadata = null;
   connectPromise = null;
-  subscriptions = new Map;
+  endpoints = new Map;
+  pendingBatches = new Map;
+  batchScheduled = false;
   queryResultCache = new Map;
   observerEntries = new WeakMap;
   constructor(config) {
@@ -1463,7 +1956,7 @@ class ClientImpl {
     return `${type}-${path}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   }
   inputHashCache = new WeakMap;
-  makeQueryKey(path, input) {
+  makeEndpointKey(path, input) {
     if (input === undefined || input === null) {
       return `${path}:null`;
     }
@@ -1478,69 +1971,231 @@ class ClientImpl {
     }
     return `${path}:${hash}`;
   }
-  executeQuery(path, input, select) {
-    const key = this.makeQueryKey(path, input);
-    const cached = this.queryResultCache.get(key);
-    if (cached && !select) {
-      return cached;
-    }
-    if (!this.subscriptions.has(key)) {
-      this.subscriptions.set(key, {
+  makeQueryResultKey(endpointKey, select) {
+    if (!select)
+      return endpointKey;
+    return `${endpointKey}:${JSON.stringify(select)}`;
+  }
+  getOrCreateEndpoint(key) {
+    let endpoint = this.endpoints.get(key);
+    if (!endpoint) {
+      endpoint = {
         data: null,
         error: null,
         completed: false,
-        observers: new Set,
-        ...select && { select }
-      });
+        observers: new Map,
+        mergedSelection: undefined,
+        isSubscribed: false
+      };
+      this.endpoints.set(key, endpoint);
+    }
+    return endpoint;
+  }
+  addObserver(key, observer) {
+    const endpoint = this.getOrCreateEndpoint(key);
+    const previousSelection = endpoint.mergedSelection;
+    endpoint.observers.set(observer.id, observer);
+    const selections = Array.from(endpoint.observers.values()).map((o) => o.selection).filter((s) => s !== undefined);
+    endpoint.mergedSelection = selections.length > 0 ? mergeSelections(selections) : undefined;
+    const selectionChanged = JSON.stringify(previousSelection) !== JSON.stringify(endpoint.mergedSelection);
+    const isExpanded = selectionChanged && this.isSelectionExpanded(previousSelection, endpoint.mergedSelection);
+    return { endpoint, selectionChanged, isExpanded };
+  }
+  removeObserver(key, observerId) {
+    const endpoint = this.endpoints.get(key);
+    if (!endpoint)
+      return { endpoint: undefined, shouldUnsubscribe: false };
+    endpoint.observers.delete(observerId);
+    if (endpoint.observers.size === 0) {
+      return { endpoint, shouldUnsubscribe: true };
+    }
+    const selections = Array.from(endpoint.observers.values()).map((o) => o.selection).filter((s) => s !== undefined);
+    endpoint.mergedSelection = selections.length > 0 ? mergeSelections(selections) : undefined;
+    return { endpoint, shouldUnsubscribe: false };
+  }
+  isSelectionExpanded(previous, current) {
+    if (!previous)
+      return current !== undefined;
+    if (!current)
+      return false;
+    const previousKeys = this.flattenSelectionKeys(previous);
+    const currentKeys = this.flattenSelectionKeys(current);
+    for (const key of currentKeys) {
+      if (!previousKeys.has(key))
+        return true;
+    }
+    return false;
+  }
+  flattenSelectionKeys(selection, prefix = "") {
+    const keys = new Set;
+    for (const [key, value] of Object.entries(selection)) {
+      const path = prefix ? `${prefix}.${key}` : key;
+      keys.add(path);
+      if (typeof value === "boolean") {
+        continue;
+      }
+      if (typeof value === "object" && value !== null) {
+        const nested = "select" in value ? value.select : value;
+        if (nested && typeof nested === "object") {
+          for (const nestedKey of this.flattenSelectionKeys(nested, path)) {
+            keys.add(nestedKey);
+          }
+        }
+      }
+    }
+    return keys;
+  }
+  distributeData(endpoint, data) {
+    endpoint.data = data;
+    endpoint.error = null;
+    for (const observer of endpoint.observers.values()) {
+      if (observer.next) {
+        const filteredData = observer.selection ? filterToSelection(data, observer.selection) : data;
+        observer.next(filteredData);
+      }
     }
-    const sub = this.subscriptions.get(key);
+  }
+  distributeError(endpoint, error) {
+    endpoint.error = error;
+    for (const observer of endpoint.observers.values()) {
+      observer.error?.(error);
+    }
+  }
+  scheduleBatchedQuery(key, path, input, selection) {
+    return new Promise((resolve, reject) => {
+      const observerId = generateSubscriberId();
+      let batch = this.pendingBatches.get(key);
+      if (!batch) {
+        batch = {
+          path,
+          input,
+          observers: [],
+          mergedSelection: undefined
+        };
+        this.pendingBatches.set(key, batch);
+      }
+      batch.observers.push({ id: observerId, selection, resolve, reject });
+      const selections = batch.observers.map((o) => o.selection).filter((s) => s !== undefined);
+      batch.mergedSelection = selections.length > 0 ? mergeSelections(selections) : undefined;
+      if (!this.batchScheduled) {
+        this.batchScheduled = true;
+        queueMicrotask(() => this.flushBatches());
+      }
+    });
+  }
+  async flushBatches() {
+    this.batchScheduled = false;
+    const batches = Array.from(this.pendingBatches.entries());
+    this.pendingBatches.clear();
+    await Promise.all(batches.map(async ([key, batch]) => {
+      try {
+        const op2 = {
+          id: this.generateId("query", batch.path),
+          path: batch.path,
+          type: "query",
+          input: batch.input,
+          meta: batch.mergedSelection ? { select: batch.mergedSelection } : {}
+        };
+        const response = await this.execute(op2);
+        if (isError(response)) {
+          const error = new Error(response.error);
+          for (const observer of batch.observers) {
+            observer.reject(error);
+          }
+          return;
+        }
+        if (isSnapshot(response)) {
+          const endpoint = this.getOrCreateEndpoint(key);
+          endpoint.data = response.data;
+          for (const observer of batch.observers) {
+            const filteredData = observer.selection ? filterToSelection(response.data, observer.selection) : response.data;
+            observer.resolve(filteredData);
+          }
+        }
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        for (const observer of batch.observers) {
+          observer.reject(err);
+        }
+      }
+    }));
+  }
+  executeQuery(path, input, select) {
+    const key = this.makeEndpointKey(path, input);
+    const cacheKey = this.makeQueryResultKey(key, select);
+    const cached = this.queryResultCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const endpoint = this.getOrCreateEndpoint(key);
     const result = {
       get value() {
-        return sub.data;
+        if (endpoint.data === null)
+          return null;
+        return select ? filterToSelection(endpoint.data, select) : endpoint.data;
       },
       subscribe: (observerOrCallback) => {
+        const observerId = generateSubscriberId();
         let entry;
         if (typeof observerOrCallback === "function") {
           const callback = observerOrCallback;
-          entry = { next: (data) => callback(data) };
+          entry = {
+            id: observerId,
+            selection: select,
+            next: (data) => callback(data)
+          };
         } else if (observerOrCallback && typeof observerOrCallback === "object") {
           const observer = observerOrCallback;
           entry = {
+            id: observerId,
+            selection: select,
             next: observer.next ? (data) => observer.next(data) : undefined,
             error: observer.error,
             complete: observer.complete
           };
         } else {
-          entry = {};
+          entry = { id: observerId, selection: select };
         }
         if (observerOrCallback) {
           this.observerEntries.set(observerOrCallback, entry);
         }
-        sub.observers.add(entry);
-        if (sub.error && entry.error) {
-          entry.error(sub.error);
-        } else if (sub.data !== null && entry.next) {
-          entry.next(sub.data);
-        }
-        if (sub.completed && entry.complete) {
-          entry.complete();
-        }
-        if (!sub.unsubscribe) {
+        const { endpoint: ep, isExpanded } = this.addObserver(key, entry);
+        if (!ep.isSubscribed) {
+          this.startSubscription(path, input, key);
+        } else if (isExpanded) {
+          if (ep.unsubscribe) {
+            ep.unsubscribe();
+          }
+          ep.isSubscribed = false;
           this.startSubscription(path, input, key);
+        } else {
+          if (ep.error && entry.error) {
+            entry.error(ep.error);
+          } else if (ep.data !== null && entry.next) {
+            const filteredData = select ? filterToSelection(ep.data, select) : ep.data;
+            entry.next(filteredData);
+          }
+          if (ep.completed && entry.complete) {
+            entry.complete();
+          }
         }
         return () => {
           if (observerOrCallback) {
             const storedEntry = this.observerEntries.get(observerOrCallback);
             if (storedEntry) {
-              sub.observers.delete(storedEntry);
+              const { shouldUnsubscribe } = this.removeObserver(key, storedEntry.id);
+              if (shouldUnsubscribe) {
+                ep.unsubscribe?.();
+                ep.isSubscribed = false;
+                this.endpoints.delete(key);
+                for (const [k] of this.queryResultCache) {
+                  if (k.startsWith(key)) {
+                    this.queryResultCache.delete(k);
+                  }
+                }
+              }
             }
           }
-          if (sub.observers.size === 0 && sub.unsubscribe) {
-            sub.unsubscribe();
-            sub.unsubscribe = undefined;
-            this.subscriptions.delete(key);
-            this.queryResultCache.delete(key);
-          }
         };
       },
       select: (selection) => {
@@ -1548,30 +2203,17 @@ class ClientImpl {
       },
       then: async (onfulfilled, onrejected) => {
         try {
-          const op2 = {
-            id: this.generateId("query", path),
-            path,
-            type: "query",
-            input,
-            meta: select ? { select } : {}
-          };
-          const response = await this.execute(op2);
-          if (isError(response)) {
-            throw new Error(response.error);
+          const data = await this.scheduleBatchedQuery(key, path, input, select);
+          const ep = this.getOrCreateEndpoint(key);
+          if (ep.data === null) {
+            ep.data = data;
           }
-          if (isSnapshot(response)) {
-            sub.data = response.data;
-            for (const observer of sub.observers) {
-              observer.next?.(response.data);
-            }
-            return onfulfilled ? onfulfilled(response.data) : response.data;
-          }
-          return onfulfilled ? onfulfilled(sub.data) : sub.data;
+          return onfulfilled ? onfulfilled(data) : data;
         } catch (error) {
           const err = error instanceof Error ? error : new Error(String(error));
-          sub.error = err;
-          for (const observer of sub.observers) {
-            observer.error?.(err);
+          const ep = this.endpoints.get(key);
+          if (ep) {
+            ep.error = err;
           }
           if (onrejected) {
             return onrejected(error);
@@ -1580,78 +2222,77 @@ class ClientImpl {
         }
       }
     };
-    if (!select) {
-      this.queryResultCache.set(key, result);
-    }
+    this.queryResultCache.set(cacheKey, result);
     return result;
   }
   async startSubscription(path, input, key) {
-    const sub = this.subscriptions.get(key);
-    if (!sub)
+    const endpoint = this.endpoints.get(key);
+    if (!endpoint)
       return;
-    await this.ensureConnected();
-    const isSubscription = this.requiresSubscription(path, sub.select);
+    endpoint.isSubscribed = true;
+    try {
+      await this.ensureConnected();
+    } catch (error) {
+      endpoint.isSubscribed = false;
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.distributeError(endpoint, err);
+      return;
+    }
+    const meta = this.getOperationMeta(path);
+    if (meta?.type === "mutation") {
+      return;
+    }
+    const isSubscription = this.requiresSubscription(path, endpoint.mergedSelection);
     if (isSubscription) {
       const op2 = {
         id: this.generateId("subscription", path),
         path,
         type: "subscription",
-        input
+        input,
+        meta: endpoint.mergedSelection ? { select: endpoint.mergedSelection } : {}
       };
       const resultOrObservable = this.transport.execute(op2);
       if (this.isObservable(resultOrObservable)) {
         const subscription = resultOrObservable.subscribe({
           next: (message) => {
             if (isSnapshot(message)) {
-              sub.data = message.data;
-              sub.error = null;
-              for (const observer of sub.observers) {
-                observer.next?.(message.data);
-              }
+              this.distributeData(endpoint, message.data);
             } else if (isOps(message)) {
               try {
-                sub.data = applyOps(sub.data, message.ops);
-                sub.error = null;
-                for (const observer of sub.observers) {
-                  observer.next?.(sub.data);
-                }
+                const newData = applyOps(endpoint.data, message.ops);
+                this.distributeData(endpoint, newData);
               } catch (updateErr) {
                 const err = updateErr instanceof Error ? updateErr : new Error(String(updateErr));
-                sub.error = err;
-                for (const observer of sub.observers) {
-                  observer.error?.(err);
-                }
+                this.distributeError(endpoint, err);
               }
             } else if (isError(message)) {
-              const err = new Error(message.error);
-              sub.error = err;
-              for (const observer of sub.observers) {
-                observer.error?.(err);
-              }
+              this.distributeError(endpoint, new Error(message.error));
             }
           },
           error: (err) => {
-            sub.error = err;
-            for (const observer of sub.observers) {
-              observer.error?.(err);
-            }
+            this.distributeError(endpoint, err);
           },
           complete: () => {
-            sub.completed = true;
-            for (const observer of sub.observers) {
+            endpoint.completed = true;
+            for (const observer of endpoint.observers.values()) {
               observer.complete?.();
             }
           }
         });
-        sub.unsubscribe = () => subscription.unsubscribe();
+        endpoint.unsubscribe = () => subscription.unsubscribe();
       }
     } else {
-      this.executeQuery(path, input).then(() => {
-        sub.completed = true;
-        for (const observer of sub.observers) {
+      try {
+        const data = await this.scheduleBatchedQuery(key, path, input, endpoint.mergedSelection);
+        this.distributeData(endpoint, data);
+        endpoint.completed = true;
+        for (const observer of endpoint.observers.values()) {
           observer.complete?.();
         }
-      });
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.distributeError(endpoint, err);
+      }
     }
   }
   async executeMutation(path, input, select) {
@@ -1699,6 +2340,17 @@ class ClientImpl {
       return queryResult;
     };
   }
+  getStats() {
+    let totalObservers = 0;
+    for (const endpoint of this.endpoints.values()) {
+      totalObservers += endpoint.observers.size;
+    }
+    return {
+      endpointCount: this.endpoints.size,
+      totalObservers,
+      pendingBatches: this.pendingBatches.size
+    };
+  }
 }
 function createClient(config) {
   const impl = new ClientImpl(config);
@@ -1883,217 +2535,6 @@ http.server = function httpServer(options) {
     }
   };
 };
-class SubscriptionRegistry {
-  subscriptions = new Map;
-  entityIndex = new Map;
-  add(sub) {
-    const tracked = {
-      ...sub,
-      state: "pending",
-      lastDataHash: sub.lastData ? hashEntityState(sub.lastData) : null,
-      createdAt: Date.now(),
-      lastUpdateAt: null
-    };
-    this.subscriptions.set(sub.id, tracked);
-    const entityKey = `${sub.entity}:${sub.entityId}`;
-    let ids = this.entityIndex.get(entityKey);
-    if (!ids) {
-      ids = new Set;
-      this.entityIndex.set(entityKey, ids);
-    }
-    ids.add(sub.id);
-  }
-  get(id) {
-    return this.subscriptions.get(id);
-  }
-  has(id) {
-    return this.subscriptions.has(id);
-  }
-  remove(id) {
-    const sub = this.subscriptions.get(id);
-    if (!sub)
-      return;
-    this.subscriptions.delete(id);
-    const entityKey = `${sub.entity}:${sub.entityId}`;
-    const ids = this.entityIndex.get(entityKey);
-    if (ids) {
-      ids.delete(id);
-      if (ids.size === 0) {
-        this.entityIndex.delete(entityKey);
-      }
-    }
-  }
-  getByEntity(entity3, entityId) {
-    const entityKey = `${entity3}:${entityId}`;
-    const ids = this.entityIndex.get(entityKey);
-    if (!ids)
-      return [];
-    const result = [];
-    for (const id of ids) {
-      const sub = this.subscriptions.get(id);
-      if (sub) {
-        result.push(sub);
-      }
-    }
-    return result;
-  }
-  updateVersion(id, version, data) {
-    const sub = this.subscriptions.get(id);
-    if (!sub)
-      return;
-    sub.version = version;
-    sub.lastUpdateAt = Date.now();
-    if (data !== undefined) {
-      sub.lastData = data;
-      sub.lastDataHash = hashEntityState(data);
-    }
-    if (sub.state === "pending" || sub.state === "reconnecting") {
-      sub.state = "active";
-    }
-  }
-  updateData(id, data) {
-    const sub = this.subscriptions.get(id);
-    if (!sub)
-      return;
-    sub.lastData = data;
-    sub.lastDataHash = hashEntityState(data);
-  }
-  getLastData(id) {
-    return this.subscriptions.get(id)?.lastData ?? null;
-  }
-  getVersion(id) {
-    return this.subscriptions.get(id)?.version ?? null;
-  }
-  markActive(id) {
-    const sub = this.subscriptions.get(id);
-    if (sub) {
-      sub.state = "active";
-    }
-  }
-  markError(id) {
-    const sub = this.subscriptions.get(id);
-    if (sub) {
-      sub.state = "error";
-    }
-  }
-  markAllReconnecting() {
-    for (const sub of this.subscriptions.values()) {
-      if (sub.state === "active") {
-        sub.state = "reconnecting";
-      }
-    }
-  }
-  getByState(state) {
-    const result = [];
-    for (const sub of this.subscriptions.values()) {
-      if (sub.state === state) {
-        result.push(sub);
-      }
-    }
-    return result;
-  }
-  getAllForReconnect() {
-    const result = [];
-    for (const sub of this.subscriptions.values()) {
-      if (sub.state === "reconnecting" || sub.state === "active") {
-        const reconnectSub = {
-          id: sub.id,
-          entity: sub.entity,
-          entityId: sub.entityId,
-          fields: sub.fields,
-          version: sub.version,
-          input: sub.input
-        };
-        if (sub.lastDataHash) {
-          reconnectSub.dataHash = sub.lastDataHash;
-        }
-        result.push(reconnectSub);
-      }
-    }
-    return result;
-  }
-  processReconnectResult(id, version, data) {
-    const sub = this.subscriptions.get(id);
-    if (!sub)
-      return;
-    sub.version = version;
-    sub.state = "active";
-    sub.lastUpdateAt = Date.now();
-    if (data !== undefined) {
-      sub.lastData = data;
-      sub.lastDataHash = hashEntityState(data);
-    }
-  }
-  getObserver(id) {
-    return this.subscriptions.get(id)?.observer;
-  }
-  updateObserver(id, observer) {
-    const sub = this.subscriptions.get(id);
-    if (sub) {
-      sub.observer = observer;
-    }
-  }
-  notifyNext(id, data) {
-    const sub = this.subscriptions.get(id);
-    sub?.observer.next?.({ data, version: sub.version });
-  }
-  notifyError(id, error) {
-    this.subscriptions.get(id)?.observer.error?.(error);
-  }
-  notifyAllReconnectingError(error) {
-    for (const sub of this.subscriptions.values()) {
-      if (sub.state === "reconnecting") {
-        sub.observer.error?.(error);
-      }
-    }
-  }
-  get size() {
-    return this.subscriptions.size;
-  }
-  getIds() {
-    return Array.from(this.subscriptions.keys());
-  }
-  values() {
-    return this.subscriptions.values();
-  }
-  getStats() {
-    const byState = {
-      pending: 0,
-      active: 0,
-      reconnecting: 0,
-      error: 0
-    };
-    const byEntity = {};
-    for (const sub of this.subscriptions.values()) {
-      byState[sub.state]++;
-      const entityKey = `${sub.entity}:${sub.entityId}`;
-      byEntity[entityKey] = (byEntity[entityKey] ?? 0) + 1;
-    }
-    return {
-      total: this.subscriptions.size,
-      byState,
-      byEntity
-    };
-  }
-  clear() {
-    for (const sub of this.subscriptions.values()) {
-      sub.observer.complete?.();
-    }
-    this.subscriptions.clear();
-    this.entityIndex.clear();
-  }
-  clearErrors() {
-    const toRemove = [];
-    for (const [id, sub] of this.subscriptions) {
-      if (sub.state === "error") {
-        toRemove.push(id);
-      }
-    }
-    for (const id of toRemove) {
-      this.remove(id);
-    }
-  }
-}
 
 // src/create.ts
 import { createEffect, createSignal, on, onCleanup } from "solid-js";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/lens-solid",
-	"version": "2.3.4",
+	"version": "2.3.6",
 	"description": "SolidJS bindings for Lens API framework",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -31,8 +31,8 @@
 	"author": "SylphxAI",
 	"license": "MIT",
 	"dependencies": {
-		"@sylphx/lens-client": "^2.6.0",
-		"@sylphx/lens-core": "^2.12.0"
+		"@sylphx/lens-client": "^2.7.1",
+		"@sylphx/lens-core": "^2.12.1"
 	},
 	"peerDependencies": {
 		"solid-js": ">=1.8.0"