@sylphx/lens-solid 2.3.3 → 2.3.5

package/dist/index.js

@@ -464,6 +464,229 @@ class EntityBuilder_ {
     return createEntityDef(this._name, fields);
   }
 }
+var valueStrategy = {
+  name: "value",
+  encode(_prev, next) {
+    return { strategy: "value", data: next };
+  },
+  decode(_current, update) {
+    return update.data;
+  },
+  estimateSize(update) {
+    return JSON.stringify(update.data).length;
+  }
+};
+var deltaStrategy = {
+  name: "delta",
+  encode(prev, next) {
+    const operations2 = computeStringDiff(prev, next);
+    const diffSize = JSON.stringify(operations2).length;
+    const valueSize = next.length + 20;
+    if (diffSize >= valueSize) {
+      return { strategy: "value", data: next };
+    }
+    return { strategy: "delta", data: operations2 };
+  },
+  decode(current, update) {
+    if (update.strategy === "value") {
+      return update.data;
+    }
+    const operations2 = update.data;
+    return applyStringDiff(current, operations2);
+  },
+  estimateSize(update) {
+    return JSON.stringify(update.data).length;
+  }
+};
+function computeStringDiff(prev, next) {
+  const operations2 = [];
+  let prefixLen = 0;
+  const minLen = Math.min(prev.length, next.length);
+  while (prefixLen < minLen && prev[prefixLen] === next[prefixLen]) {
+    prefixLen++;
+  }
+  let suffixLen = 0;
+  const remainingPrev = prev.length - prefixLen;
+  const remainingNext = next.length - prefixLen;
+  const maxSuffix = Math.min(remainingPrev, remainingNext);
+  while (suffixLen < maxSuffix && prev[prev.length - 1 - suffixLen] === next[next.length - 1 - suffixLen]) {
+    suffixLen++;
+  }
+  const deleteCount = prev.length - prefixLen - suffixLen;
+  const insertText = next.slice(prefixLen, next.length - suffixLen || undefined);
+  if (deleteCount > 0 || insertText.length > 0) {
+    operations2.push({
+      position: prefixLen,
+      ...deleteCount > 0 ? { delete: deleteCount } : {},
+      ...insertText.length > 0 ? { insert: insertText } : {}
+    });
+  }
+  return operations2;
+}
+function applyStringDiff(current, operations2) {
+  let result = current;
+  const sortedOps = [...operations2].sort((a, b) => b.position - a.position);
+  for (const op2 of sortedOps) {
+    const before = result.slice(0, op2.position);
+    const after = result.slice(op2.position + (op2.delete ?? 0));
+    result = before + (op2.insert ?? "") + after;
+  }
+  return result;
+}
+var patchStrategy = {
+  name: "patch",
+  encode(prev, next) {
+    const operations2 = computeJsonPatch(prev, next);
+    const patchSize = JSON.stringify(operations2).length;
+    const valueSize = JSON.stringify(next).length + 20;
+    if (patchSize >= valueSize) {
+      return { strategy: "value", data: next };
+    }
+    return { strategy: "patch", data: operations2 };
+  },
+  decode(current, update) {
+    if (update.strategy === "value") {
+      return update.data;
+    }
+    const operations2 = update.data;
+    return applyJsonPatch(current, operations2);
+  },
+  estimateSize(update) {
+    return JSON.stringify(update.data).length;
+  }
+};
+function computeJsonPatch(prev, next, basePath = "") {
+  const operations2 = [];
+  const prevObj = prev;
+  const nextObj = next;
+  for (const key of Object.keys(prevObj)) {
+    if (!(key in nextObj)) {
+      operations2.push({ op: "remove", path: `${basePath}/${escapeJsonPointer(key)}` });
+    }
+  }
+  for (const [key, nextValue] of Object.entries(nextObj)) {
+    const path = `${basePath}/${escapeJsonPointer(key)}`;
+    const prevValue = prevObj[key];
+    if (!(key in prevObj)) {
+      operations2.push({ op: "add", path, value: nextValue });
+    } else if (!deepEqual2(prevValue, nextValue)) {
+      if (isPlainObject(prevValue) && isPlainObject(nextValue) && !Array.isArray(prevValue) && !Array.isArray(nextValue)) {
+        operations2.push(...computeJsonPatch(prevValue, nextValue, path));
+      } else {
+        operations2.push({ op: "replace", path, value: nextValue });
+      }
+    }
+  }
+  return operations2;
+}
+function applyJsonPatch(current, operations2) {
+  const result = structuredClone(current);
+  for (const op2 of operations2) {
+    const pathParts = parseJsonPointer(op2.path);
+    switch (op2.op) {
+      case "add":
+      case "replace":
+        setValueAtPath(result, pathParts, op2.value);
+        break;
+      case "remove":
+        removeValueAtPath(result, pathParts);
+        break;
+      case "move":
+        if (op2.from) {
+          const fromParts = parseJsonPointer(op2.from);
+          const value = getValueAtPath(result, fromParts);
+          removeValueAtPath(result, fromParts);
+          setValueAtPath(result, pathParts, value);
+        }
+        break;
+      case "copy":
+        if (op2.from) {
+          const fromParts = parseJsonPointer(op2.from);
+          const value = structuredClone(getValueAtPath(result, fromParts));
+          setValueAtPath(result, pathParts, value);
+        }
+        break;
+      case "test":
+        break;
+    }
+  }
+  return result;
+}
+function applyUpdate(current, update) {
+  switch (update.strategy) {
+    case "value":
+      return valueStrategy.decode(current, update);
+    case "delta":
+      return deltaStrategy.decode(current, update);
+    case "patch":
+      return patchStrategy.decode(current, update);
+    default:
+      return update.data;
+  }
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepEqual2(a, b) {
+  if (a === b)
+    return true;
+  if (typeof a !== typeof b)
+    return false;
+  if (typeof a !== "object" || a === null || b === null)
+    return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length)
+    return false;
+  for (const key of aKeys) {
+    if (!deepEqual2(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function escapeJsonPointer(str) {
+  return str.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function parseJsonPointer(path) {
+  if (!path || path === "/")
+    return [];
+  return path.slice(1).split("/").map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function getValueAtPath(obj, path) {
+  let current = obj;
+  for (const key of path) {
+    if (current === null || typeof current !== "object")
+      return;
+    current = current[key];
+  }
+  return current;
+}
+function setValueAtPath(obj, path, value) {
+  if (path.length === 0)
+    return;
+  let current = obj;
+  for (let i = 0;i < path.length - 1; i++) {
+    const key = path[i];
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[path[path.length - 1]] = value;
+}
+function removeValueAtPath(obj, path) {
+  if (path.length === 0)
+    return;
+  let current = obj;
+  for (let i = 0;i < path.length - 1; i++) {
+    const key = path[i];
+    if (!(key in current) || typeof current[key] !== "object")
+      return;
+    current = current[key];
+  }
+  delete current[path[path.length - 1]];
+}
 var OPTIMISTIC_PLUGIN_SYMBOL = Symbol.for("lens:optimistic-plugin");
 var DEFAULT_OPERATION_LOG_CONFIG = {
   maxEntries: 1e4,
@@ -836,18 +1059,744 @@ class ReconnectionMetricsTracker {
     for (const result of results) {
       counts[result.status] = (counts[result.status] ?? 0) + 1;
     }
-    return counts;
-  }
-  percentile(p) {
-    if (this.latencies.length === 0)
-      return 0;
-    const sorted = [...this.latencies].sort((a, b) => a - b);
-    const index = Math.ceil(p / 100 * sorted.length) - 1;
-    return sorted[Math.max(0, index)];
+    return counts;
+  }
+  percentile(p) {
+    if (this.latencies.length === 0)
+      return 0;
+    const sorted = [...this.latencies].sort((a, b) => a - b);
+    const index = Math.ceil(p / 100 * sorted.length) - 1;
+    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) {
+    result = applyOp(result, op2);
+  }
+  return result;
+}
+function applyOp(state, op2) {
+  switch (op2.o) {
+    case "set":
+      return setAtPath(state, op2.p, op2.v);
+    case "del":
+      return deleteAtPath(state, op2.p);
+    case "merge":
+      return mergeAtPath(state, op2.p, op2.v);
+    case "delta": {
+      const current = getAtPath(state, op2.p);
+      const updated = applyUpdate(current, { strategy: "delta", data: op2.d });
+      return setAtPath(state, op2.p, updated);
+    }
+    case "patch": {
+      const current = getAtPath(state, op2.p);
+      const updated = applyUpdate(current, { strategy: "patch", data: op2.d });
+      return setAtPath(state, op2.p, updated);
+    }
+    case "push":
+      return arrayPush(state, op2.p, op2.v);
+    case "unshift":
+      return arrayUnshift(state, op2.p, op2.v);
+    case "splice":
+      return arraySplice(state, op2.p, op2.i, op2.dc, op2.v);
+    case "arrSet":
+      return arraySetAt(state, op2.p, op2.i, op2.v);
+    case "arrDel":
+      return arrayDeleteAt(state, op2.p, op2.i);
+    case "arrSetId":
+      return arraySetById(state, op2.p, op2.id, op2.v);
+    case "arrDelId":
+      return arrayDeleteById(state, op2.p, op2.id);
+    case "arrMerge":
+      return arrayMergeAt(state, op2.p, op2.i, op2.v);
+    case "arrMergeId":
+      return arrayMergeById(state, op2.p, op2.id, op2.v);
+    default:
+      return state;
+  }
+}
+function parsePath(path) {
+  if (!path)
+    return [];
+  return path.split(".");
+}
+function getAtPath(state, path) {
+  const segments = parsePath(path);
+  let current = state;
+  for (const segment of segments) {
+    if (current === null || current === undefined)
+      return;
+    if (typeof current !== "object")
+      return;
+    current = current[segment];
+  }
+  return current;
+}
+function setAtPath(state, path, value) {
+  const segments = parsePath(path);
+  if (segments.length === 0)
+    return value;
+  return updateAtPath(state, segments, () => value);
+}
+function deleteAtPath(state, path) {
+  const segments = parsePath(path);
+  if (segments.length === 0)
+    return;
+  const parentPath = segments.slice(0, -1);
+  const key = segments[segments.length - 1];
+  return updateAtPath(state, parentPath, (parent) => {
+    if (parent === null || parent === undefined)
+      return parent;
+    if (Array.isArray(parent)) {
+      const idx = parseInt(key, 10);
+      const result = [...parent];
+      result.splice(idx, 1);
+      return result;
+    }
+    if (typeof parent === "object") {
+      const { [key]: _, ...rest } = parent;
+      return rest;
+    }
+    return parent;
+  });
+}
+function mergeAtPath(state, path, value) {
+  const segments = parsePath(path);
+  return updateAtPath(state, segments, (current) => {
+    if (current === null || current === undefined)
+      return value;
+    if (typeof current !== "object" || Array.isArray(current))
+      return value;
+    return { ...current, ...value };
+  });
+}
+function updateAtPath(state, segments, transform) {
+  if (segments.length === 0) {
+    return transform(state);
+  }
+  const [head, ...tail] = segments;
+  if (state === null || state === undefined) {
+    const isArrayIndex = /^\d+$/.test(head);
+    const newState = isArrayIndex ? [] : {};
+    return updateAtPath(newState, segments, transform);
+  }
+  if (Array.isArray(state)) {
+    const result = [...state];
+    const idx = parseInt(head, 10);
+    result[idx] = updateAtPath(result[idx], tail, transform);
+    return result;
+  }
+  if (typeof state === "object") {
+    const obj = state;
+    return {
+      ...obj,
+      [head]: updateAtPath(obj[head], tail, transform)
+    };
+  }
+  return { [head]: updateAtPath(undefined, tail, transform) };
+}
+function arrayPush(state, path, items) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr))
+      return items;
+    return [...arr, ...items];
+  });
+}
+function arrayUnshift(state, path, items) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr))
+      return items;
+    return [...items, ...arr];
+  });
+}
+function arraySplice(state, path, index, deleteCount, items) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr))
+      return items ?? [];
+    const result = [...arr];
+    if (items) {
+      result.splice(index, deleteCount, ...items);
+    } else {
+      result.splice(index, deleteCount);
+    }
+    return result;
+  });
+}
+function arraySetAt(state, path, index, value) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr)) {
+      const result2 = [];
+      result2[index] = value;
+      return result2;
+    }
+    const result = [...arr];
+    result[index] = value;
+    return result;
+  });
+}
+function arrayDeleteAt(state, path, index) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr))
+      return [];
+    const result = [...arr];
+    result.splice(index, 1);
+    return result;
+  });
+}
+function arraySetById(state, path, id2, value) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr))
+      return [value];
+    const index = arr.findIndex((item) => item && typeof item === "object" && item.id === id2);
+    if (index === -1) {
+      return [...arr, value];
+    }
+    const result = [...arr];
+    result[index] = value;
+    return result;
+  });
+}
+function arrayDeleteById(state, path, id2) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr))
+      return [];
+    return arr.filter((item) => !(item && typeof item === "object" && item.id === id2));
+  });
+}
+function arrayMergeAt(state, path, index, value) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr)) {
+      const result2 = [];
+      result2[index] = value;
+      return result2;
+    }
+    const result = [...arr];
+    const current = result[index];
+    if (current && typeof current === "object" && !Array.isArray(current)) {
+      result[index] = { ...current, ...value };
+    } else {
+      result[index] = value;
+    }
+    return result;
+  });
+}
+function arrayMergeById(state, path, id2, value) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr))
+      return [{ id: id2, ...value }];
+    const index = arr.findIndex((item) => item && typeof item === "object" && item.id === id2);
+    if (index === -1) {
+      return [...arr, { id: id2, ...value }];
+    }
+    const result = [...arr];
+    const current = result[index];
+    if (current && typeof current === "object" && !Array.isArray(current)) {
+      result[index] = { ...current, ...value };
+    } else {
+      result[index] = { id: id2, ...value };
+    }
+    return result;
+  });
+}
+function isSnapshot(msg) {
+  return msg.$ === "snapshot";
+}
+function isOps(msg) {
+  return msg.$ === "ops";
+}
+function isError(msg) {
+  return msg.$ === "error";
+}
+
+// ../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;
 }
-
-// ../client/dist/index.js
 function hasAnySubscription(entities, entityName, select, visited = new Set) {
   if (!entities)
     return false;
@@ -879,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) {
@@ -926,16 +1881,16 @@ class ClientImpl {
         result = await plugin.afterResponse(result, processedOp);
       }
     }
-    if (result.error) {
-      const error = result.error;
+    if (isError(result)) {
+      const error = new Error(result.error);
       for (const plugin of this.plugins) {
         if (plugin.onError) {
           try {
             result = await plugin.onError(error, processedOp, () => this.execute(processedOp));
-            if (!result.error)
+            if (!isError(result))
               break;
           } catch (e) {
-            result = { error: e };
+            result = { $: "error", error: e instanceof Error ? e.message : String(e) };
           }
         }
       }
@@ -1001,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`;
     }
@@ -1016,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);
+      }
+    }
+  }
+  distributeError(endpoint, error) {
+    endpoint.error = error;
+    for (const observer of endpoint.observers.values()) {
+      observer.error?.(error);
     }
-    const sub = this.subscriptions.get(key);
+  }
+  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) => {
@@ -1086,27 +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 (response.error) {
-            throw response.error;
+          const data = await this.scheduleBatchedQuery(key, path, input, select);
+          const ep = this.getOrCreateEndpoint(key);
+          if (ep.data === null) {
+            ep.data = data;
           }
-          sub.data = response.data;
-          for (const observer of sub.observers) {
-            observer.next?.(response.data);
-          }
-          return onfulfilled ? onfulfilled(response.data) : response.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);
@@ -1115,65 +2222,70 @@ 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);
+    const meta = this.getOperationMeta(path);
+    if (meta?.type === "mutation") {
+      return;
+    }
+    const isSubscription = this.requiresSubscription(path, endpoint.mergedSelection);
+    endpoint.isSubscribed = true;
     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: (result) => {
-            if (result.data !== undefined) {
-              sub.data = result.data;
-              sub.error = null;
-              for (const observer of sub.observers) {
-                observer.next?.(result.data);
-              }
-            }
-            if (result.error) {
-              const err = result.error instanceof Error ? result.error : new Error(String(result.error));
-              sub.error = err;
-              for (const observer of sub.observers) {
-                observer.error?.(err);
+          next: (message) => {
+            if (isSnapshot(message)) {
+              this.distributeData(endpoint, message.data);
+            } else if (isOps(message)) {
+              try {
+                const newData = applyOps(endpoint.data, message.ops);
+                this.distributeData(endpoint, newData);
+              } catch (updateErr) {
+                const err = updateErr instanceof Error ? updateErr : new Error(String(updateErr));
+                this.distributeError(endpoint, err);
               }
+            } else if (isError(message)) {
+              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) {
@@ -1186,10 +2298,13 @@ class ClientImpl {
       meta: select ? { select } : {}
     };
     const response = await this.execute(op2);
-    if (response.error) {
-      throw response.error;
+    if (isError(response)) {
+      throw new Error(response.error);
     }
-    return { data: response.data };
+    if (isSnapshot(response)) {
+      return { data: response.data };
+    }
+    return { data: null };
   }
   createAccessor(path) {
     return (descriptor) => {
@@ -1218,6 +2333,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);
@@ -1309,16 +2435,17 @@ async function executeRequest(baseUrl, op2, options) {
     }
     if (!response.ok) {
       return {
-        error: new Error(`HTTP ${response.status}: ${response.statusText}`)
+        $: "error",
+        error: `HTTP ${response.status}: ${response.statusText}`
       };
     }
     const result = await response.json();
     return result;
   } catch (error) {
     if (error instanceof Error && error.name === "AbortError") {
-      return { error: new Error("Request timeout") };
+      return { $: "error", error: "Request timeout" };
     }
-    return { error };
+    return { $: "error", error: error instanceof Error ? error.message : String(error) };
   }
 }
 function createPollingObservable(baseUrl, op2, options) {
@@ -1331,24 +2458,28 @@ function createPollingObservable(baseUrl, op2, options) {
         if (!active)
           return;
         try {
-          const result = await executeRequest(baseUrl, op2, {
+          const message = await executeRequest(baseUrl, op2, {
             headers: options.headers,
             fetch: options.fetch
           });
           if (!active)
             return;
-          if (result.error) {
+          if (isError(message)) {
             retries++;
             if (retries > options.maxRetries) {
-              observer.error?.(result.error);
+              observer.error?.(new Error(message.error));
               return;
             }
           } else {
             retries = 0;
-            const newValue = JSON.stringify(result.data);
-            if (newValue !== JSON.stringify(lastValue)) {
-              lastValue = result.data;
-              observer.next?.(result);
+            if (isSnapshot(message)) {
+              const hasDataChange = JSON.stringify(message.data) !== JSON.stringify(lastValue);
+              if (hasDataChange) {
+                lastValue = message.data;
+                observer.next?.(message);
+              }
+            } else if (isOps(message)) {
+              observer.next?.(message);
             }
           }
           if (active) {
@@ -1397,217 +2528,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";