@sylphx/lens-solid 2.0.5 → 2.1.0

package/dist/index.js

@@ -1,3 +1,1232 @@
+// ../core/dist/index.js
+var {createRequire} = (() => ({}));
+// ../../node_modules/.bun/@sylphx+reify-core@0.1.2/node_modules/@sylphx/reify-core/dist/builder.js
+var DSL_MARKER = Symbol("reify");
+// ../../node_modules/.bun/@sylphx+reify-core@0.1.2/node_modules/@sylphx/reify-core/dist/evaluator.js
+var plugins = new Map;
+// ../core/dist/index.js
+var ENTITY_SYMBOL = Symbol("lens:entity");
+var OPTIMISTIC_PLUGIN_SYMBOL = Symbol.for("lens:optimistic-plugin");
+var DEFAULT_OPERATION_LOG_CONFIG = {
+  maxEntries: 1e4,
+  maxAge: 5 * 60 * 1000,
+  maxMemory: 10 * 1024 * 1024,
+  cleanupInterval: 60 * 1000
+};
+function murmurhash3(key, seed = 0) {
+  const remainder = key.length % 4;
+  const bytes = key.length - remainder;
+  let h1 = seed;
+  const c1 = 3432918353;
+  const c2 = 461845907;
+  let i = 0;
+  while (i < bytes) {
+    let k12 = key.charCodeAt(i) & 255 | (key.charCodeAt(i + 1) & 255) << 8 | (key.charCodeAt(i + 2) & 255) << 16 | (key.charCodeAt(i + 3) & 255) << 24;
+    k12 = Math.imul(k12, c1);
+    k12 = k12 << 15 | k12 >>> 17;
+    k12 = Math.imul(k12, c2);
+    h1 ^= k12;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1 = Math.imul(h1, 5) + 3864292196;
+    i += 4;
+  }
+  let 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 = Math.imul(k1, c1);
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = Math.imul(k1, c2);
+    h1 ^= k1;
+  }
+  h1 ^= key.length;
+  h1 ^= h1 >>> 16;
+  h1 = Math.imul(h1, 2246822507);
+  h1 ^= h1 >>> 13;
+  h1 = Math.imul(h1, 3266489909);
+  h1 ^= h1 >>> 16;
+  return (h1 >>> 0).toString(16).padStart(8, "0");
+}
+function hashValue(value) {
+  if (value === null) {
+    return "n:null";
+  }
+  if (value === undefined) {
+    return "u:undefined";
+  }
+  const type = typeof value;
+  switch (type) {
+    case "string":
+      return `s:${murmurhash3(value)}`;
+    case "number":
+      return `n:${murmurhash3(String(value))}`;
+    case "boolean":
+      return value ? "b:true" : "b:false";
+    case "object":
+      return `o:${murmurhash3(stableStringify(value))}`;
+    case "bigint":
+      return `i:${murmurhash3(String(value))}`;
+    case "symbol":
+      return `y:${murmurhash3(String(value))}`;
+    case "function":
+      return `f:${murmurhash3(value.toString())}`;
+    default:
+      return `x:${murmurhash3(String(value))}`;
+  }
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  const keys = Object.keys(value).sort();
+  const pairs = keys.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`);
+  return `{${pairs.join(",")}}`;
+}
+function hashEntityState(data) {
+  return `e:${murmurhash3(stableStringify(data))}`;
+}
+class HashCache {
+  cache = new Map;
+  maxSize;
+  maxAge;
+  constructor(maxSize = 1000, maxAge = 60000) {
+    this.maxSize = maxSize;
+    this.maxAge = maxAge;
+  }
+  get(value) {
+    if (typeof value !== "object" || value === null) {
+      const cached = this.cache.get(value);
+      if (cached && Date.now() - cached.timestamp < this.maxAge) {
+        return cached.hash;
+      }
+      const hash = hashValue(value);
+      this.set(value, hash);
+      return hash;
+    }
+    return hashValue(value);
+  }
+  set(value, hash) {
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== undefined) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(value, { hash, timestamp: Date.now() });
+  }
+  clear() {
+    this.cache.clear();
+  }
+  getStats() {
+    return { size: this.cache.size, maxSize: this.maxSize };
+  }
+}
+
+class FieldHashMap {
+  hashes = new Map;
+  hasChanged(field, value) {
+    const newHash = hashValue(value);
+    const oldHash = this.hashes.get(field);
+    if (oldHash === newHash) {
+      return false;
+    }
+    this.hashes.set(field, newHash);
+    return true;
+  }
+  update(field, value) {
+    this.hashes.set(field, hashValue(value));
+  }
+  getHash(field) {
+    return this.hashes.get(field);
+  }
+  delete(field) {
+    this.hashes.delete(field);
+  }
+  clear() {
+    this.hashes.clear();
+  }
+  getAll() {
+    return new Map(this.hashes);
+  }
+  getCombinedHash() {
+    const sorted = Array.from(this.hashes.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+    return murmurhash3(sorted.map(([k, v]) => `${k}:${v}`).join("|"));
+  }
+}
+var DEFAULT_METRICS_CONFIG = {
+  enabled: true,
+  sampleRate: 1,
+  maxHistory: 1000
+};
+
+class ReconnectionMetricsTracker {
+  config;
+  history = [];
+  pending = new Map;
+  totalAttempts = 0;
+  totalSuccesses = 0;
+  totalFailures = 0;
+  totalSubscriptionsProcessed = 0;
+  totalBytesTransferred = 0;
+  totalBytesCompressed = 0;
+  statusCounts = {
+    current: 0,
+    patched: 0,
+    snapshot: 0,
+    deleted: 0,
+    error: 0
+  };
+  latencies = [];
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_METRICS_CONFIG, ...config };
+  }
+  startReconnection(reconnectId, subscriptionCount) {
+    if (!this.shouldSample())
+      return;
+    const record = {
+      reconnectId,
+      startTime: Date.now(),
+      subscriptionCount
+    };
+    this.pending.set(reconnectId, record);
+    this.totalAttempts++;
+    this.emit({
+      type: "reconnect_start",
+      timestamp: record.startTime,
+      data: {
+        reconnectId,
+        subscriptionCount
+      }
+    });
+  }
+  completeReconnection(reconnectId, results) {
+    const pending = this.pending.get(reconnectId);
+    if (!pending)
+      return;
+    this.pending.delete(reconnectId);
+    const endTime = Date.now();
+    const latency = endTime - pending.startTime;
+    this.totalSuccesses++;
+    this.totalSubscriptionsProcessed += results.length;
+    this.latencies.push(latency);
+    for (const result of results) {
+      this.statusCounts[result.status]++;
+      if (result.data) {
+        const size = JSON.stringify(result.data).length;
+        this.totalBytesTransferred += size;
+      }
+      if (result.patches) {
+        const size = JSON.stringify(result.patches).length;
+        this.totalBytesTransferred += size;
+      }
+    }
+    const record = {
+      reconnectId,
+      startTime: pending.startTime,
+      endTime,
+      latency,
+      subscriptionCount: pending.subscriptionCount,
+      resultCount: results.length,
+      statusBreakdown: this.countStatuses(results),
+      success: true
+    };
+    this.addToHistory(record);
+    this.emit({
+      type: "reconnect_complete",
+      timestamp: endTime,
+      data: {
+        reconnectId,
+        latency,
+        resultCount: results.length,
+        statusBreakdown: record.statusBreakdown
+      }
+    });
+  }
+  failReconnection(reconnectId, error) {
+    const pending = this.pending.get(reconnectId);
+    if (!pending)
+      return;
+    this.pending.delete(reconnectId);
+    const endTime = Date.now();
+    const latency = endTime - pending.startTime;
+    this.totalFailures++;
+    this.latencies.push(latency);
+    const record = {
+      reconnectId,
+      startTime: pending.startTime,
+      endTime,
+      latency,
+      subscriptionCount: pending.subscriptionCount,
+      resultCount: 0,
+      statusBreakdown: {},
+      success: false,
+      error: error.message
+    };
+    this.addToHistory(record);
+    this.emit({
+      type: "reconnect_error",
+      timestamp: endTime,
+      data: {
+        reconnectId,
+        latency,
+        error: error.message
+      }
+    });
+  }
+  recordCompression(originalSize, compressedSize) {
+    this.totalBytesTransferred += compressedSize;
+    this.totalBytesCompressed += originalSize - compressedSize;
+  }
+  getMetrics() {
+    const avgLatency = this.latencies.length > 0 ? this.latencies.reduce((a, b) => a + b, 0) / this.latencies.length : 0;
+    const p50 = this.percentile(50);
+    const p95 = this.percentile(95);
+    const p99 = this.percentile(99);
+    return {
+      totalAttempts: this.totalAttempts,
+      successfulReconnects: this.totalSuccesses,
+      failedReconnects: this.totalFailures,
+      successRate: this.totalAttempts > 0 ? this.totalSuccesses / this.totalAttempts : 1,
+      averageLatency: avgLatency,
+      p50Latency: p50,
+      p95Latency: p95,
+      p99Latency: p99,
+      totalSubscriptionsProcessed: this.totalSubscriptionsProcessed,
+      statusBreakdown: { ...this.statusCounts },
+      bytesTransferred: this.totalBytesTransferred,
+      bytesSaved: this.totalBytesCompressed,
+      compressionRatio: this.totalBytesTransferred > 0 ? (this.totalBytesTransferred - this.totalBytesCompressed) / this.totalBytesTransferred : 1
+    };
+  }
+  getHealth() {
+    const metrics = this.getMetrics();
+    const recentHistory = this.history.slice(-10);
+    let status = "healthy";
+    const issues = [];
+    if (metrics.successRate < 0.5) {
+      status = "unhealthy";
+      issues.push(`Low success rate: ${(metrics.successRate * 100).toFixed(1)}%`);
+    } else if (metrics.successRate < 0.9) {
+      status = "degraded";
+      issues.push(`Degraded success rate: ${(metrics.successRate * 100).toFixed(1)}%`);
+    }
+    if (metrics.p95Latency > 5000) {
+      status = status === "healthy" ? "degraded" : status;
+      issues.push(`High p95 latency: ${metrics.p95Latency}ms`);
+    }
+    const recentFailures = recentHistory.filter((r) => !r.success).length;
+    if (recentFailures > 5) {
+      status = "unhealthy";
+      issues.push(`${recentFailures} failures in last 10 reconnections`);
+    }
+    return {
+      status,
+      metrics,
+      issues,
+      lastReconnect: this.history[this.history.length - 1]?.endTime ?? null,
+      pendingReconnects: this.pending.size
+    };
+  }
+  getHistory(limit = 100) {
+    return this.history.slice(-limit);
+  }
+  reset() {
+    this.history = [];
+    this.pending.clear();
+    this.totalAttempts = 0;
+    this.totalSuccesses = 0;
+    this.totalFailures = 0;
+    this.totalSubscriptionsProcessed = 0;
+    this.totalBytesTransferred = 0;
+    this.totalBytesCompressed = 0;
+    this.statusCounts = { current: 0, patched: 0, snapshot: 0, deleted: 0, error: 0 };
+    this.latencies = [];
+  }
+  toJSON() {
+    return {
+      metrics: this.getMetrics(),
+      health: this.getHealth(),
+      history: this.history.slice(-100)
+    };
+  }
+  shouldSample() {
+    if (!this.config.enabled)
+      return false;
+    if (this.config.sampleRate >= 1)
+      return true;
+    return Math.random() < this.config.sampleRate;
+  }
+  emit(event) {
+    this.config.collector?.(event);
+  }
+  addToHistory(record) {
+    this.history.push(record);
+    if (this.history.length > this.config.maxHistory) {
+      this.history.shift();
+    }
+  }
+  countStatuses(results) {
+    const counts = {};
+    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)];
+  }
+}
+
+// ../client/dist/index.js
+class ClientImpl {
+  transport;
+  plugins;
+  metadata = null;
+  connectPromise = null;
+  subscriptions = new Map;
+  queryResultCache = new Map;
+  callbackWrappers = new WeakMap;
+  constructor(config) {
+    this.transport = config.transport;
+    this.plugins = config.plugins ?? [];
+    this.connectPromise = this.transport.connect();
+    this.connectPromise.then((metadata) => {
+      this.metadata = metadata;
+    }).catch(() => {
+      this.connectPromise = null;
+    });
+  }
+  async ensureConnected() {
+    if (this.metadata)
+      return;
+    if (!this.connectPromise) {
+      this.connectPromise = this.transport.connect();
+    }
+    this.metadata = await this.connectPromise;
+  }
+  async execute(op2) {
+    await this.ensureConnected();
+    let processedOp = op2;
+    for (const plugin of this.plugins) {
+      if (plugin.beforeRequest) {
+        processedOp = await plugin.beforeRequest(processedOp);
+      }
+    }
+    const resultOrObservable = this.transport.execute(processedOp);
+    if (this.isObservable(resultOrObservable)) {
+      return { data: resultOrObservable };
+    }
+    let result = await resultOrObservable;
+    for (const plugin of this.plugins) {
+      if (plugin.afterResponse) {
+        result = await plugin.afterResponse(result, processedOp);
+      }
+    }
+    if (result.error) {
+      const 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)
+              break;
+          } catch (e) {
+            result = { error: e };
+          }
+        }
+      }
+    }
+    return result;
+  }
+  isObservable(value) {
+    return value !== null && typeof value === "object" && "subscribe" in value && typeof value.subscribe === "function";
+  }
+  getOperationMeta(path) {
+    if (!this.metadata)
+      return;
+    const parts = path.split(".");
+    let current = this.metadata.operations;
+    for (const part of parts) {
+      if (!current || typeof current !== "object")
+        return;
+      current = current[part];
+    }
+    if (current && typeof current === "object" && "type" in current) {
+      return current;
+    }
+    return;
+  }
+  generateId(type, path) {
+    return `${type}-${path}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+  makeQueryKey(path, input) {
+    return `${path}:${JSON.stringify(input ?? null)}`;
+  }
+  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, {
+        data: null,
+        callbacks: new Set
+      });
+    }
+    const sub = this.subscriptions.get(key);
+    const result = {
+      get value() {
+        return sub.data;
+      },
+      subscribe: (callback) => {
+        if (callback) {
+          const typedCallback = callback;
+          let wrapped = this.callbackWrappers.get(typedCallback);
+          if (!wrapped) {
+            wrapped = (data) => callback(data);
+            this.callbackWrappers.set(typedCallback, wrapped);
+          }
+          sub.callbacks.add(wrapped);
+          if (sub.data !== null) {
+            callback(sub.data);
+          }
+        }
+        if (!sub.unsubscribe) {
+          this.startSubscription(path, input, key);
+        }
+        return () => {
+          if (callback) {
+            const typedCallback = callback;
+            const wrapped = this.callbackWrappers.get(typedCallback);
+            if (wrapped) {
+              sub.callbacks.delete(wrapped);
+            }
+          }
+          if (sub.callbacks.size === 0 && sub.unsubscribe) {
+            sub.unsubscribe();
+            sub.unsubscribe = undefined;
+          }
+        };
+      },
+      select: (selection) => {
+        return this.executeQuery(path, input, selection);
+      },
+      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;
+          }
+          sub.data = response.data;
+          for (const cb of sub.callbacks) {
+            cb(response.data);
+          }
+          return onfulfilled ? onfulfilled(response.data) : response.data;
+        } catch (error) {
+          if (onrejected) {
+            return onrejected(error);
+          }
+          throw error;
+        }
+      }
+    };
+    if (!select) {
+      this.queryResultCache.set(key, result);
+    }
+    return result;
+  }
+  async startSubscription(path, input, key) {
+    const sub = this.subscriptions.get(key);
+    if (!sub)
+      return;
+    await this.ensureConnected();
+    const meta = this.getOperationMeta(path);
+    const isSubscription = meta?.type === "subscription";
+    if (isSubscription) {
+      const op2 = {
+        id: this.generateId("subscription", path),
+        path,
+        type: "subscription",
+        input
+      };
+      const resultOrObservable = this.transport.execute(op2);
+      if (this.isObservable(resultOrObservable)) {
+        const subscription = resultOrObservable.subscribe({
+          next: (result) => {
+            if (result.data !== undefined) {
+              sub.data = result.data;
+              for (const cb of sub.callbacks) {
+                cb(result.data);
+              }
+            }
+          },
+          error: () => {},
+          complete: () => {}
+        });
+        sub.unsubscribe = () => subscription.unsubscribe();
+      }
+    } else {
+      this.executeQuery(path, input).then(() => {});
+    }
+  }
+  async executeMutation(path, input, select) {
+    await this.ensureConnected();
+    const op2 = {
+      id: this.generateId("mutation", path),
+      path,
+      type: "mutation",
+      input,
+      meta: select ? { select } : {}
+    };
+    const response = await this.execute(op2);
+    if (response.error) {
+      throw response.error;
+    }
+    return { data: response.data };
+  }
+  createAccessor(path) {
+    return (descriptor) => {
+      const isNewApi = descriptor === undefined || descriptor === null || typeof descriptor === "object" && descriptor !== null && (("input" in descriptor) || ("select" in descriptor));
+      const input = isNewApi ? descriptor?.input : descriptor;
+      const select = isNewApi ? descriptor?.select : undefined;
+      const queryResult = this.executeQuery(path, input, select);
+      const originalThen = queryResult.then.bind(queryResult);
+      queryResult.then = async (onfulfilled, onrejected) => {
+        try {
+          await this.ensureConnected();
+          const meta = this.getOperationMeta(path);
+          if (meta?.type === "mutation") {
+            const inputObj = input ?? {};
+            const mutationResult = await this.executeMutation(path, inputObj, select);
+            return onfulfilled ? onfulfilled(mutationResult) : mutationResult;
+          }
+          return originalThen(onfulfilled, onrejected);
+        } catch (error) {
+          if (onrejected) {
+            return onrejected(error);
+          }
+          throw error;
+        }
+      };
+      return queryResult;
+    };
+  }
+}
+function createClient(config) {
+  const impl = new ClientImpl(config);
+  function createNestedProxy(prefix) {
+    const handler = {
+      get(_target, prop) {
+        if (typeof prop === "symbol")
+          return;
+        const key = prop;
+        if (key === "then")
+          return;
+        if (key.startsWith("_"))
+          return;
+        const path = prefix ? `${prefix}.${key}` : key;
+        return createNestedProxy(path);
+      },
+      apply(_target, _thisArg, args) {
+        const accessor = impl.createAccessor(prefix);
+        return accessor(args[0]);
+      }
+    };
+    return new Proxy(() => {}, handler);
+  }
+  return createNestedProxy("");
+}
+var http = function http2(options) {
+  const { url, headers: defaultHeaders = {}, fetch: fetchImpl = fetch, polling = {} } = options;
+  const { interval: pollInterval = 1000, maxRetries = 3 } = polling;
+  const baseUrl = url.replace(/\/$/, "");
+  return {
+    async connect() {
+      const response = await fetchImpl(`${baseUrl}/__lens/metadata`, {
+        method: "GET",
+        headers: {
+          Accept: "application/json",
+          ...defaultHeaders
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to connect: ${response.status} ${response.statusText}`);
+      }
+      return response.json();
+    },
+    execute(op2) {
+      if (op2.type === "subscription") {
+        return createPollingObservable(baseUrl, op2, {
+          interval: pollInterval,
+          maxRetries,
+          headers: defaultHeaders,
+          fetch: fetchImpl
+        });
+      }
+      return executeRequest(baseUrl, op2, {
+        headers: {
+          ...defaultHeaders,
+          ...op2.meta?.headers ?? {}
+        },
+        fetch: fetchImpl,
+        timeout: op2.meta?.timeout
+      });
+    }
+  };
+};
+async function executeRequest(baseUrl, op2, options) {
+  const { headers, fetch: fetchImpl, timeout: timeout2 } = options;
+  try {
+    const controller = new AbortController;
+    let timeoutId;
+    if (timeout2) {
+      timeoutId = setTimeout(() => controller.abort(), timeout2);
+    }
+    const response = await fetchImpl(baseUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...headers
+      },
+      body: JSON.stringify({
+        id: op2.id,
+        path: op2.path,
+        type: op2.type,
+        input: op2.input
+      }),
+      signal: controller.signal
+    });
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    if (!response.ok) {
+      return {
+        error: new 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 };
+  }
+}
+function createPollingObservable(baseUrl, op2, options) {
+  return {
+    subscribe(observer) {
+      let active = true;
+      let retries = 0;
+      let lastValue;
+      const poll = async () => {
+        if (!active)
+          return;
+        try {
+          const result = await executeRequest(baseUrl, op2, {
+            headers: options.headers,
+            fetch: options.fetch
+          });
+          if (!active)
+            return;
+          if (result.error) {
+            retries++;
+            if (retries > options.maxRetries) {
+              observer.error?.(result.error);
+              return;
+            }
+          } else {
+            retries = 0;
+            const newValue = JSON.stringify(result.data);
+            if (newValue !== JSON.stringify(lastValue)) {
+              lastValue = result.data;
+              observer.next?.(result);
+            }
+          }
+          if (active) {
+            setTimeout(poll, options.interval);
+          }
+        } catch (error) {
+          if (active) {
+            observer.error?.(error);
+          }
+        }
+      };
+      poll();
+      return {
+        unsubscribe() {
+          active = false;
+        }
+      };
+    }
+  };
+}
+http.server = function httpServer(options) {
+  const { port, path = "", hostname = "0.0.0.0" } = options;
+  return {
+    listen(server) {
+      Bun.serve({
+        port,
+        hostname,
+        async fetch(req) {
+          const url = new URL(req.url);
+          const basePath = path.replace(/\/$/, "");
+          if (url.pathname === `${basePath}/__lens/metadata` && req.method === "GET") {
+            return Response.json(server.getMetadata());
+          }
+          if (url.pathname === basePath && req.method === "POST") {
+            try {
+              const body = await req.json();
+              const result = await server.execute(body);
+              return Response.json(result);
+            } catch (error) {
+              return Response.json({ error: { message: error.message } }, { status: 500 });
+            }
+          }
+          return new Response("Not Found", { status: 404 });
+        }
+      });
+    }
+  };
+};
+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(entity2, entityId) {
+    const entityKey = `${entity2}:${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, onCleanup } from "solid-js";
+function createQueryHook(baseClient, path) {
+  const getEndpoint = (p) => {
+    const parts = p.split(".");
+    let current = baseClient;
+    for (const part of parts) {
+      current = current[part];
+    }
+    return current;
+  };
+  const useQueryPrimitive = (options) => {
+    const [data, setData] = createSignal(null);
+    const [loading, setLoading] = createSignal(!options?.skip);
+    const [error, setError] = createSignal(null);
+    let unsubscribe = null;
+    const executeQuery = () => {
+      if (unsubscribe) {
+        unsubscribe();
+        unsubscribe = null;
+      }
+      if (options?.skip) {
+        setData(null);
+        setLoading(false);
+        setError(null);
+        return;
+      }
+      const endpoint = getEndpoint(path);
+      const query = endpoint({ input: options?.input, select: options?.select });
+      setLoading(true);
+      setError(null);
+      unsubscribe = query.subscribe((value) => {
+        setData(() => value);
+        setLoading(false);
+        setError(null);
+      });
+      query.then((value) => {
+        setData(() => value);
+        setLoading(false);
+        setError(null);
+      }, (err) => {
+        const queryError = err instanceof Error ? err : new Error(String(err));
+        setError(queryError);
+        setLoading(false);
+      });
+    };
+    executeQuery();
+    createEffect(() => {
+      const _ = JSON.stringify(options);
+      executeQuery();
+    });
+    onCleanup(() => {
+      if (unsubscribe) {
+        unsubscribe();
+        unsubscribe = null;
+      }
+    });
+    const refetch = () => {
+      if (unsubscribe) {
+        unsubscribe();
+        unsubscribe = null;
+      }
+      setLoading(true);
+      setError(null);
+      const endpoint = getEndpoint(path);
+      const query = endpoint({ input: options?.input, select: options?.select });
+      if (query) {
+        unsubscribe = query.subscribe((value) => {
+          setData(() => value);
+          setLoading(false);
+          setError(null);
+        });
+        query.then((value) => {
+          setData(() => value);
+          setLoading(false);
+        }, (err) => {
+          const queryError = err instanceof Error ? err : new Error(String(err));
+          setError(queryError);
+          setLoading(false);
+        });
+      }
+    };
+    return { data, loading, error, refetch };
+  };
+  const fetch2 = async (options) => {
+    const endpoint = getEndpoint(path);
+    const queryResult = endpoint({ input: options?.input, select: options?.select });
+    return queryResult.then((data) => data);
+  };
+  useQueryPrimitive.fetch = fetch2;
+  return useQueryPrimitive;
+}
+function createMutationHook(baseClient, path) {
+  const getEndpoint = (p) => {
+    const parts = p.split(".");
+    let current = baseClient;
+    for (const part of parts) {
+      current = current[part];
+    }
+    return current;
+  };
+  const useMutationPrimitive = (hookOptions) => {
+    const [data, setData] = createSignal(null);
+    const [loading, setLoading] = createSignal(false);
+    const [error, setError] = createSignal(null);
+    const mutate = async (options) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const endpoint = getEndpoint(path);
+        const result = await endpoint({ input: options.input, select: options.select });
+        const mutationResult = result;
+        setData(() => mutationResult.data);
+        setLoading(false);
+        hookOptions?.onSuccess?.(mutationResult.data);
+        hookOptions?.onSettled?.();
+        return mutationResult.data;
+      } catch (err) {
+        const mutationError = err instanceof Error ? err : new Error(String(err));
+        setError(mutationError);
+        setLoading(false);
+        hookOptions?.onError?.(mutationError);
+        hookOptions?.onSettled?.();
+        throw mutationError;
+      }
+    };
+    const reset = () => {
+      setData(null);
+      setLoading(false);
+      setError(null);
+    };
+    return { mutate, loading, error, data, reset };
+  };
+  const fetch2 = async (options) => {
+    const endpoint = getEndpoint(path);
+    const result = await endpoint({ input: options.input, select: options.select });
+    const mutationResult = result;
+    return mutationResult.data;
+  };
+  useMutationPrimitive.fetch = fetch2;
+  return useMutationPrimitive;
+}
+var hookCache = new Map;
+function createClient2(config) {
+  const baseClient = createClient(config);
+  function createProxy(path) {
+    const handler = {
+      get(_target, prop) {
+        if (typeof prop === "symbol")
+          return;
+        const key = prop;
+        if (key === "fetch") {
+          return async (options) => {
+            const parts = path.split(".");
+            let current = baseClient;
+            for (const part of parts) {
+              current = current[part];
+            }
+            const endpointFn = current;
+            const queryResult = endpointFn(options);
+            const result = await queryResult;
+            if (result && typeof result === "object" && "data" in result && Object.keys(result).length === 1) {
+              return result.data;
+            }
+            return result;
+          };
+        }
+        if (key === "then")
+          return;
+        if (key.startsWith("_"))
+          return;
+        const newPath = path ? `${path}.${key}` : key;
+        return createProxy(newPath);
+      },
+      apply(_target, _thisArg, args) {
+        const options = args[0];
+        const isQueryOptions = options && (("input" in options) || ("select" in options) || ("skip" in options));
+        const isMutationOptions = !options || !isQueryOptions && (Object.keys(options).length === 0 || ("onSuccess" in options) || ("onError" in options) || ("onSettled" in options));
+        const cacheKeyQuery = `${path}:query`;
+        const cacheKeyMutation = `${path}:mutation`;
+        if (isQueryOptions) {
+          if (!hookCache.has(cacheKeyQuery)) {
+            hookCache.set(cacheKeyQuery, createQueryHook(baseClient, path));
+          }
+          const hook2 = hookCache.get(cacheKeyQuery);
+          return hook2(options);
+        }
+        if (isMutationOptions) {
+          if (!hookCache.has(cacheKeyMutation)) {
+            hookCache.set(cacheKeyMutation, createMutationHook(baseClient, path));
+          }
+          const hook2 = hookCache.get(cacheKeyMutation);
+          return hook2(options);
+        }
+        if (!hookCache.has(cacheKeyQuery)) {
+          hookCache.set(cacheKeyQuery, createQueryHook(baseClient, path));
+        }
+        const hook = hookCache.get(cacheKeyQuery);
+        return hook(options);
+      }
+    };
+    return new Proxy(() => {}, handler);
+  }
+  return createProxy("");
+}
 // src/context.tsx
 import { createContext, useContext } from "solid-js";
 var LensClientContext = createContext();
@@ -14,17 +1243,20 @@ function useLensClient() {
   return client;
 }
 // src/primitives.ts
-import { createSignal, onCleanup } from "solid-js";
+import { createEffect as createEffect2, createSignal as createSignal2, onCleanup as onCleanup2 } from "solid-js";
 function resolveQuery(input) {
   return typeof input === "function" ? input() : input;
 }
 function createQuery(queryInput, options) {
-  const [data, setData] = createSignal(null);
-  const [loading, setLoading] = createSignal(!options?.skip);
-  const [error, setError] = createSignal(null);
+  const [data, setData] = createSignal2(null);
+  const [loading, setLoading] = createSignal2(!options?.skip);
+  const [error, setError] = createSignal2(null);
   let unsubscribe = null;
-  const executeQuery = () => {
-    const queryResult = resolveQuery(queryInput);
+  const executeQuery = (queryResult) => {
+    if (unsubscribe) {
+      unsubscribe();
+      unsubscribe = null;
+    }
     if (options?.skip || queryResult == null) {
       setData(null);
       setLoading(false);
@@ -48,8 +1280,15 @@ function createQuery(queryInput, options) {
       setLoading(false);
     });
   };
-  executeQuery();
-  onCleanup(() => {
+  const initialQuery = resolveQuery(queryInput);
+  executeQuery(initialQuery);
+  createEffect2(() => {
+    const queryResult = resolveQuery(queryInput);
+    if (queryResult !== initialQuery) {
+      executeQuery(queryResult);
+    }
+  });
+  onCleanup2(() => {
     if (unsubscribe) {
       unsubscribe();
       unsubscribe = null;
@@ -62,7 +1301,22 @@ function createQuery(queryInput, options) {
     }
     setLoading(true);
     setError(null);
-    executeQuery();
+    const queryResult = resolveQuery(queryInput);
+    if (queryResult) {
+      unsubscribe = queryResult.subscribe((value) => {
+        setData(() => value);
+        setLoading(false);
+        setError(null);
+      });
+      queryResult.then((value) => {
+        setData(() => value);
+        setLoading(false);
+      }, (err) => {
+        const queryError = err instanceof Error ? err : new Error(String(err));
+        setError(queryError);
+        setLoading(false);
+      });
+    }
   };
   return {
     data,
@@ -72,9 +1326,9 @@ function createQuery(queryInput, options) {
   };
 }
 function createMutation(mutationFn) {
-  const [data, setData] = createSignal(null);
-  const [loading, setLoading] = createSignal(false);
-  const [error, setError] = createSignal(null);
+  const [data, setData] = createSignal2(null);
+  const [loading, setLoading] = createSignal2(false);
+  const [error, setError] = createSignal2(null);
   const mutate = async (input) => {
     setLoading(true);
     setError(null);
@@ -104,10 +1358,10 @@ function createMutation(mutationFn) {
   };
 }
 function createLazyQuery(queryInput) {
-  const [data, setData] = createSignal(null);
-  const [loading, setLoading] = createSignal(false);
-  const [error, setError] = createSignal(null);
-  const execute = async () => {
+  const [data, setData] = createSignal2(null);
+  const [loading, setLoading] = createSignal2(false);
+  const [error, setError] = createSignal2(null);
+  const execute2 = async () => {
     const queryResult = resolveQuery(queryInput);
     if (queryResult == null) {
       setData(null);
@@ -137,7 +1391,7 @@ function createLazyQuery(queryInput) {
     data,
     loading,
     error,
-    execute,
+    execute: execute2,
     reset
   };
 }
@@ -146,5 +1400,6 @@ export {
   createQuery,
   createMutation,
   createLazyQuery,
+  createClient2 as createClient,
   LensProvider
 };