@sylphx/lens-server 1.11.3 → 2.1.0

package/dist/index.js

@@ -5,524 +5,168 @@ import {
   router
 } from "@sylphx/lens-core";
 
+// src/context/index.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var globalContextStore = new AsyncLocalStorage;
+function createContext() {
+  return globalContextStore;
+}
+function useContext() {
+  const ctx = globalContextStore.getStore();
+  if (!ctx) {
+    throw new Error("useContext() called outside of context. " + "Make sure to wrap your code with runWithContext() or use explicit ctx parameter.");
+  }
+  return ctx;
+}
+function tryUseContext() {
+  return globalContextStore.getStore();
+}
+function runWithContext(_context, value, fn) {
+  return globalContextStore.run(value, fn);
+}
+async function runWithContextAsync(context, value, fn) {
+  return runWithContext(context, value, fn);
+}
+function hasContext() {
+  return globalContextStore.getStore() !== undefined;
+}
+function extendContext(current, extension) {
+  return { ...current, ...extension };
+}
 // src/server/create.ts
 import {
-  createContext,
   createEmit,
-  createUpdate as createUpdate2,
   flattenRouter,
   isEntityDef,
   isMutationDef,
-  isPipeline,
   isQueryDef,
-  runWithContext,
   toResolverMap
 } from "@sylphx/lens-core";
 
-// src/state/graph-state-manager.ts
-import {
-  applyUpdate,
-  computeArrayDiff,
-  createUpdate,
-  makeEntityKey
-} from "@sylphx/lens-core";
-
-class GraphStateManager {
-  clients = new Map;
-  canonical = new Map;
-  canonicalArrays = new Map;
-  clientStates = new Map;
-  clientArrayStates = new Map;
-  entitySubscribers = new Map;
-  config;
-  constructor(config = {}) {
-    this.config = config;
-  }
-  addClient(client) {
-    this.clients.set(client.id, client);
-    this.clientStates.set(client.id, new Map);
-    this.clientArrayStates.set(client.id, new Map);
-  }
-  removeClient(clientId) {
-    for (const [key, subscribers] of this.entitySubscribers) {
-      subscribers.delete(clientId);
-      if (subscribers.size === 0) {
-        this.cleanupEntity(key);
-      }
-    }
-    this.clients.delete(clientId);
-    this.clientStates.delete(clientId);
-    this.clientArrayStates.delete(clientId);
-  }
-  subscribe(clientId, entity, id, fields = "*") {
-    const key = this.makeKey(entity, id);
-    let subscribers = this.entitySubscribers.get(key);
-    if (!subscribers) {
-      subscribers = new Set;
-      this.entitySubscribers.set(key, subscribers);
-    }
-    subscribers.add(clientId);
-    const clientStateMap = this.clientStates.get(clientId);
-    if (clientStateMap) {
-      const fieldSet = fields === "*" ? "*" : new Set(fields);
-      clientStateMap.set(key, {
-        lastState: {},
-        fields: fieldSet
-      });
-    }
-    const canonicalState = this.canonical.get(key);
-    if (canonicalState) {
-      this.sendInitialData(clientId, entity, id, canonicalState, fields);
-    }
-  }
-  unsubscribe(clientId, entity, id) {
-    const key = this.makeKey(entity, id);
-    const subscribers = this.entitySubscribers.get(key);
-    if (subscribers) {
-      subscribers.delete(clientId);
-      if (subscribers.size === 0) {
-        this.cleanupEntity(key);
+// src/plugin/types.ts
+class PluginManager {
+  plugins = [];
+  register(plugin) {
+    this.plugins.push(plugin);
+  }
+  getPlugins() {
+    return this.plugins;
+  }
+  async runOnConnect(ctx) {
+    for (const plugin of this.plugins) {
+      if (plugin.onConnect) {
+        const result = await plugin.onConnect(ctx);
+        if (result === false)
+          return false;
       }
     }
-    const clientStateMap = this.clientStates.get(clientId);
-    if (clientStateMap) {
-      clientStateMap.delete(key);
-    }
+    return true;
   }
-  updateSubscription(clientId, entity, id, fields) {
-    const key = this.makeKey(entity, id);
-    const clientStateMap = this.clientStates.get(clientId);
-    if (clientStateMap) {
-      const state = clientStateMap.get(key);
-      if (state) {
-        state.fields = fields === "*" ? "*" : new Set(fields);
+  async runOnDisconnect(ctx) {
+    for (const plugin of this.plugins) {
+      if (plugin.onDisconnect) {
+        await plugin.onDisconnect(ctx);
       }
     }
   }
-  emit(entity, id, data, options = {}) {
-    const key = this.makeKey(entity, id);
-    let currentCanonical = this.canonical.get(key);
-    if (options.replace || !currentCanonical) {
-      currentCanonical = { ...data };
-    } else {
-      currentCanonical = { ...currentCanonical, ...data };
-    }
-    this.canonical.set(key, currentCanonical);
-    const subscribers = this.entitySubscribers.get(key);
-    if (!subscribers)
-      return;
-    for (const clientId of subscribers) {
-      this.pushToClient(clientId, entity, id, key, currentCanonical);
-    }
-  }
-  emitField(entity, id, field, update) {
-    const key = this.makeKey(entity, id);
-    let currentCanonical = this.canonical.get(key);
-    if (!currentCanonical) {
-      currentCanonical = {};
-    }
-    const oldValue = currentCanonical[field];
-    const newValue = applyUpdate(oldValue, update);
-    currentCanonical = { ...currentCanonical, [field]: newValue };
-    this.canonical.set(key, currentCanonical);
-    const subscribers = this.entitySubscribers.get(key);
-    if (!subscribers)
-      return;
-    for (const clientId of subscribers) {
-      this.pushFieldToClient(clientId, entity, id, key, field, newValue);
-    }
-  }
-  emitBatch(entity, id, updates) {
-    const key = this.makeKey(entity, id);
-    let currentCanonical = this.canonical.get(key);
-    if (!currentCanonical) {
-      currentCanonical = {};
-    }
-    const changedFields = [];
-    for (const { field, update } of updates) {
-      const oldValue = currentCanonical[field];
-      const newValue = applyUpdate(oldValue, update);
-      currentCanonical[field] = newValue;
-      changedFields.push(field);
-    }
-    this.canonical.set(key, currentCanonical);
-    const subscribers = this.entitySubscribers.get(key);
-    if (!subscribers)
-      return;
-    for (const clientId of subscribers) {
-      this.pushFieldsToClient(clientId, entity, id, key, changedFields, currentCanonical);
-    }
-  }
-  processCommand(entity, id, command) {
-    switch (command.type) {
-      case "full":
-        this.emit(entity, id, command.data, {
-          replace: command.replace
-        });
-        break;
-      case "field":
-        this.emitField(entity, id, command.field, command.update);
-        break;
-      case "batch":
-        this.emitBatch(entity, id, command.updates);
-        break;
-      case "array":
-        this.emitArrayOperation(entity, id, command.operation);
-        break;
+  async runOnSubscribe(ctx) {
+    for (const plugin of this.plugins) {
+      if (plugin.onSubscribe) {
+        const result = await plugin.onSubscribe(ctx);
+        if (result === false)
+          return false;
+      }
     }
+    return true;
   }
-  emitArray(entity, id, items) {
-    const key = this.makeKey(entity, id);
-    this.canonicalArrays.set(key, [...items]);
-    const subscribers = this.entitySubscribers.get(key);
-    if (!subscribers)
-      return;
-    for (const clientId of subscribers) {
-      this.pushArrayToClient(clientId, entity, id, key, items);
+  async runOnUnsubscribe(ctx) {
+    for (const plugin of this.plugins) {
+      if (plugin.onUnsubscribe) {
+        await plugin.onUnsubscribe(ctx);
+      }
     }
   }
-  emitArrayOperation(entity, id, operation) {
-    const key = this.makeKey(entity, id);
-    let currentArray = this.canonicalArrays.get(key);
-    if (!currentArray) {
-      currentArray = [];
-    }
-    const newArray = this.applyArrayOperation([...currentArray], operation);
-    this.canonicalArrays.set(key, newArray);
-    const subscribers = this.entitySubscribers.get(key);
-    if (!subscribers)
-      return;
-    for (const clientId of subscribers) {
-      this.pushArrayToClient(clientId, entity, id, key, newArray);
-    }
-  }
-  applyArrayOperation(array, operation) {
-    switch (operation.op) {
-      case "push":
-        return [...array, operation.item];
-      case "unshift":
-        return [operation.item, ...array];
-      case "insert":
-        return [
-          ...array.slice(0, operation.index),
-          operation.item,
-          ...array.slice(operation.index)
-        ];
-      case "remove":
-        return [...array.slice(0, operation.index), ...array.slice(operation.index + 1)];
-      case "removeById": {
-        const idx = array.findIndex((item) => typeof item === "object" && item !== null && ("id" in item) && item.id === operation.id);
-        if (idx === -1)
-          return array;
-        return [...array.slice(0, idx), ...array.slice(idx + 1)];
-      }
-      case "update":
-        return array.map((item, i) => i === operation.index ? operation.item : item);
-      case "updateById":
-        return array.map((item) => typeof item === "object" && item !== null && ("id" in item) && item.id === operation.id ? operation.item : item);
-      case "merge":
-        return array.map((item, i) => i === operation.index && typeof item === "object" && item !== null ? { ...item, ...operation.partial } : item);
-      case "mergeById":
-        return array.map((item) => typeof item === "object" && item !== null && ("id" in item) && item.id === operation.id ? { ...item, ...operation.partial } : item);
-      default:
-        return array;
-    }
-  }
-  pushArrayToClient(clientId, entity, id, key, newArray) {
-    const client = this.clients.get(clientId);
-    if (!client)
-      return;
-    const clientArrayStateMap = this.clientArrayStates.get(clientId);
-    if (!clientArrayStateMap)
-      return;
-    let clientArrayState = clientArrayStateMap.get(key);
-    if (!clientArrayState) {
-      clientArrayState = { lastState: [] };
-      clientArrayStateMap.set(key, clientArrayState);
-    }
-    const { lastState } = clientArrayState;
-    if (JSON.stringify(lastState) === JSON.stringify(newArray)) {
-      return;
-    }
-    const diff = computeArrayDiff(lastState, newArray);
-    if (diff === null || diff.length === 0) {
-      client.send({
-        type: "update",
-        entity,
-        id,
-        updates: {
-          _items: { strategy: "value", data: newArray }
-        }
-      });
-    } else if (diff.length === 1 && diff[0].op === "replace") {
-      client.send({
-        type: "update",
-        entity,
-        id,
-        updates: {
-          _items: { strategy: "value", data: newArray }
-        }
-      });
-    } else {
-      client.send({
-        type: "update",
-        entity,
-        id,
-        updates: {
-          _items: { strategy: "array", data: diff }
+  async runBeforeSend(ctx) {
+    let data = ctx.data;
+    for (const plugin of this.plugins) {
+      if (plugin.beforeSend) {
+        const result = await plugin.beforeSend({ ...ctx, data });
+        if (result !== undefined) {
+          data = result;
         }
-      });
-    }
-    clientArrayState.lastState = [...newArray];
-  }
-  getArrayState(entity, id) {
-    return this.canonicalArrays.get(this.makeKey(entity, id));
-  }
-  getState(entity, id) {
-    return this.canonical.get(this.makeKey(entity, id));
-  }
-  hasSubscribers(entity, id) {
-    const subscribers = this.entitySubscribers.get(this.makeKey(entity, id));
-    return subscribers !== undefined && subscribers.size > 0;
-  }
-  pushToClient(clientId, entity, id, key, newState) {
-    const client = this.clients.get(clientId);
-    if (!client)
-      return;
-    const clientStateMap = this.clientStates.get(clientId);
-    if (!clientStateMap)
-      return;
-    const clientEntityState = clientStateMap.get(key);
-    if (!clientEntityState)
-      return;
-    const { lastState, fields } = clientEntityState;
-    const fieldsToCheck = fields === "*" ? Object.keys(newState) : Array.from(fields);
-    const updates = {};
-    let hasChanges = false;
-    for (const field of fieldsToCheck) {
-      const oldValue = lastState[field];
-      const newValue = newState[field];
-      if (oldValue === newValue)
-        continue;
-      if (typeof oldValue === "object" && typeof newValue === "object" && JSON.stringify(oldValue) === JSON.stringify(newValue)) {
-        continue;
-      }
-      const update = createUpdate(oldValue, newValue);
-      updates[field] = update;
-      hasChanges = true;
-    }
-    if (!hasChanges)
-      return;
-    client.send({
-      type: "update",
-      entity,
-      id,
-      updates
-    });
-    for (const field of fieldsToCheck) {
-      if (newState[field] !== undefined) {
-        clientEntityState.lastState[field] = newState[field];
       }
     }
+    return data;
   }
-  pushFieldToClient(clientId, entity, id, key, field, newValue) {
-    const client = this.clients.get(clientId);
-    if (!client)
-      return;
-    const clientStateMap = this.clientStates.get(clientId);
-    if (!clientStateMap)
-      return;
-    const clientEntityState = clientStateMap.get(key);
-    if (!clientEntityState)
-      return;
-    const { lastState, fields } = clientEntityState;
-    if (fields !== "*" && !fields.has(field)) {
-      return;
-    }
-    const oldValue = lastState[field];
-    if (oldValue === newValue)
-      return;
-    if (typeof oldValue === "object" && typeof newValue === "object" && JSON.stringify(oldValue) === JSON.stringify(newValue)) {
-      return;
-    }
-    const update = createUpdate(oldValue, newValue);
-    client.send({
-      type: "update",
-      entity,
-      id,
-      updates: { [field]: update }
-    });
-    clientEntityState.lastState[field] = newValue;
-  }
-  pushFieldsToClient(clientId, entity, id, key, changedFields, newState) {
-    const client = this.clients.get(clientId);
-    if (!client)
-      return;
-    const clientStateMap = this.clientStates.get(clientId);
-    if (!clientStateMap)
-      return;
-    const clientEntityState = clientStateMap.get(key);
-    if (!clientEntityState)
-      return;
-    const { lastState, fields } = clientEntityState;
-    const updates = {};
-    let hasChanges = false;
-    for (const field of changedFields) {
-      if (fields !== "*" && !fields.has(field)) {
-        continue;
-      }
-      const oldValue = lastState[field];
-      const newValue = newState[field];
-      if (oldValue === newValue)
-        continue;
-      if (typeof oldValue === "object" && typeof newValue === "object" && JSON.stringify(oldValue) === JSON.stringify(newValue)) {
-        continue;
-      }
-      const update = createUpdate(oldValue, newValue);
-      updates[field] = update;
-      hasChanges = true;
-    }
-    if (!hasChanges)
-      return;
-    client.send({
-      type: "update",
-      entity,
-      id,
-      updates
-    });
-    for (const field of changedFields) {
-      if (newState[field] !== undefined) {
-        clientEntityState.lastState[field] = newState[field];
+  async runAfterSend(ctx) {
+    for (const plugin of this.plugins) {
+      if (plugin.afterSend) {
+        await plugin.afterSend(ctx);
       }
     }
   }
-  sendInitialData(clientId, entity, id, state, fields) {
-    const client = this.clients.get(clientId);
-    if (!client)
-      return;
-    const key = this.makeKey(entity, id);
-    const clientStateMap = this.clientStates.get(clientId);
-    if (!clientStateMap)
-      return;
-    const fieldsToSend = fields === "*" ? Object.keys(state) : fields;
-    const dataToSend = {};
-    const updates = {};
-    for (const field of fieldsToSend) {
-      if (state[field] !== undefined) {
-        dataToSend[field] = state[field];
-        updates[field] = { strategy: "value", data: state[field] };
+  async runBeforeMutation(ctx) {
+    for (const plugin of this.plugins) {
+      if (plugin.beforeMutation) {
+        const result = await plugin.beforeMutation(ctx);
+        if (result === false)
+          return false;
       }
     }
-    client.send({
-      type: "update",
-      entity,
-      id,
-      updates
-    });
-    const clientEntityState = clientStateMap.get(key);
-    if (clientEntityState) {
-      clientEntityState.lastState = { ...dataToSend };
-    }
+    return true;
   }
-  cleanupEntity(key) {
-    const [entity, id] = key.split(":");
-    if (this.config.onEntityUnsubscribed) {
-      this.config.onEntityUnsubscribed(entity, id);
+  async runAfterMutation(ctx) {
+    for (const plugin of this.plugins) {
+      if (plugin.afterMutation) {
+        await plugin.afterMutation(ctx);
+      }
     }
-    this.entitySubscribers.delete(key);
-  }
-  makeKey(entity, id) {
-    return makeEntityKey(entity, id);
   }
-  getStats() {
-    let totalSubscriptions = 0;
-    for (const subscribers of this.entitySubscribers.values()) {
-      totalSubscriptions += subscribers.size;
+  async runOnReconnect(ctx) {
+    for (const plugin of this.plugins) {
+      if (plugin.onReconnect) {
+        const result = await plugin.onReconnect(ctx);
+        if (result !== null) {
+          return result;
+        }
+      }
     }
-    return {
-      clients: this.clients.size,
-      entities: this.canonical.size,
-      totalSubscriptions
-    };
-  }
-  clear() {
-    this.clients.clear();
-    this.canonical.clear();
-    this.canonicalArrays.clear();
-    this.clientStates.clear();
-    this.clientArrayStates.clear();
-    this.entitySubscribers.clear();
-  }
-}
-function createGraphStateManager(config) {
-  return new GraphStateManager(config);
-}
-
-// src/server/create.ts
-function getEntityTypeName(returnSpec) {
-  if (!returnSpec)
-    return;
-  if (isEntityDef(returnSpec)) {
-    return returnSpec._name;
-  }
-  if (Array.isArray(returnSpec) && returnSpec.length === 1 && isEntityDef(returnSpec[0])) {
-    return returnSpec[0]._name;
-  }
-  return;
-}
-function getInputFields(inputSchema) {
-  if (!inputSchema?.shape)
-    return [];
-  return Object.keys(inputSchema.shape);
-}
-function sugarToPipeline(optimistic, entityType, inputFields) {
-  if (isPipeline(optimistic)) {
-    return optimistic;
-  }
-  if (!entityType) {
-    return optimistic;
+    return null;
   }
-  if (optimistic === "merge") {
-    const args = { type: entityType };
-    for (const field of inputFields) {
-      args[field] = { $input: field };
+  async runOnUpdateFields(ctx) {
+    for (const plugin of this.plugins) {
+      if (plugin.onUpdateFields) {
+        await plugin.onUpdateFields(ctx);
+      }
     }
-    return {
-      $pipe: [{ $do: "entity.update", $with: args }]
-    };
   }
-  if (optimistic === "create") {
-    const args = { type: entityType, id: { $temp: true } };
-    for (const field of inputFields) {
-      if (field !== "id") {
-        args[field] = { $input: field };
+  runEnhanceOperationMeta(ctx) {
+    for (const plugin of this.plugins) {
+      if (plugin.enhanceOperationMeta) {
+        plugin.enhanceOperationMeta(ctx);
       }
     }
-    return {
-      $pipe: [{ $do: "entity.create", $with: args }]
-    };
-  }
-  if (optimistic === "delete") {
-    return {
-      $pipe: [{ $do: "entity.delete", $with: { type: entityType, id: { $input: "id" } } }]
-    };
   }
-  if (typeof optimistic === "object" && optimistic !== null && "merge" in optimistic && typeof optimistic.merge === "object") {
-    const extra = optimistic.merge;
-    const args = { type: entityType };
-    for (const field of inputFields) {
-      args[field] = { $input: field };
-    }
-    for (const [key, value] of Object.entries(extra)) {
-      args[key] = value;
+  async runOnBroadcast(ctx) {
+    for (const plugin of this.plugins) {
+      if (plugin.onBroadcast) {
+        const result = await plugin.onBroadcast(ctx);
+        if (result && typeof result === "object" && "version" in result) {
+          return result;
+        }
+        if (result === true) {
+          return { version: 0, patch: null, data: ctx.data };
+        }
+      }
     }
-    return {
-      $pipe: [{ $do: "entity.update", $with: args }]
-    };
+    return null;
   }
-  return optimistic;
+}
+function createPluginManager() {
+  return new PluginManager;
 }
 
+// src/server/dataloader.ts
 class DataLoader {
   batchFn;
   batch = new Map;
@@ -538,16 +182,13 @@ class DataLoader {
       } else {
         this.batch.set(key, [{ resolve, reject }]);
       }
-      this.scheduleDispatch();
+      if (!this.scheduled) {
+        this.scheduled = true;
+        queueMicrotask(() => this.flush());
+      }
     });
   }
-  scheduleDispatch() {
-    if (this.scheduled)
-      return;
-    this.scheduled = true;
-    queueMicrotask(() => this.dispatch());
-  }
-  async dispatch() {
+  async flush() {
     this.scheduled = false;
     const batch = this.batch;
     this.batch = new Map;
@@ -556,22 +197,70 @@ class DataLoader {
       return;
     try {
       const results = await this.batchFn(keys);
-      keys.forEach((key, index) => {
-        const callbacks = batch.get(key);
-        const result = results[index] ?? null;
-        for (const { resolve } of callbacks)
+      let i = 0;
+      for (const [_key, callbacks] of batch) {
+        const result = results[i++];
+        for (const { resolve } of callbacks) {
           resolve(result);
-      });
+        }
+      }
     } catch (error) {
-      for (const callbacks of batch.values()) {
-        for (const { reject } of callbacks)
-          reject(error);
+      for (const [, callbacks] of batch) {
+        for (const { reject } of callbacks) {
+          reject(error instanceof Error ? error : new Error(String(error)));
+        }
       }
     }
   }
-  clear() {
-    this.batch.clear();
+}
+
+// src/server/selection.ts
+function extractSelect(value) {
+  if (value === true)
+    return null;
+  if (typeof value !== "object" || value === null)
+    return null;
+  const obj = value;
+  if ("input" in obj || "select" in obj && typeof obj.select === "object") {
+    return obj.select ?? null;
+  }
+  if ("select" in obj && typeof obj.select === "object") {
+    return obj.select;
+  }
+  return value;
+}
+function applySelection(data, select) {
+  if (!data)
+    return data;
+  if (Array.isArray(data)) {
+    return data.map((item) => applySelection(item, select));
+  }
+  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(select)) {
+    if (!(key in obj))
+      continue;
+    if (value === true) {
+      result[key] = obj[key];
+    } else if (typeof value === "object" && value !== null) {
+      const nestedSelect = extractSelect(value);
+      if (nestedSelect) {
+        result[key] = applySelection(obj[key], nestedSelect);
+      } else {
+        result[key] = obj[key];
+      }
+    }
   }
+  return result;
+}
+
+// src/server/create.ts
+function isAsyncIterable(value) {
+  return value != null && typeof value === "object" && Symbol.asyncIterator in value;
 }
 var noopLogger = {};
 
@@ -584,11 +273,8 @@ class LensServerImpl {
   version;
   logger;
   ctx = createContext();
-  stateManager;
   loaders = new Map;
-  connections = new Map;
-  connectionCounter = 0;
-  server = null;
+  pluginManager;
   constructor(config) {
     const queries = { ...config.queries ?? {} };
     const mutations = { ...config.mutations ?? {} };
@@ -609,6 +295,14 @@ class LensServerImpl {
     this.contextFactory = config.context ?? (() => ({}));
     this.version = config.version ?? "1.0.0";
     this.logger = config.logger ?? noopLogger;
+    this.pluginManager = createPluginManager();
+    for (const plugin of config.plugins ?? []) {
+      this.pluginManager.register(plugin);
+    }
+    this.injectNames();
+    this.validateDefinitions();
+  }
+  injectNames() {
     for (const [name, def] of Object.entries(this.entities)) {
       if (def && typeof def === "object" && !def._name) {
         def._name = name;
@@ -617,16 +311,6 @@ class LensServerImpl {
     for (const [name, def] of Object.entries(this.mutations)) {
       if (def && typeof def === "object") {
         def._name = name;
-        const lastSegment = name.includes(".") ? name.split(".").pop() : name;
-        if (!def._optimistic) {
-          if (lastSegment.startsWith("update")) {
-            def._optimistic = "merge";
-          } else if (lastSegment.startsWith("create") || lastSegment.startsWith("add")) {
-            def._optimistic = "create";
-          } else if (lastSegment.startsWith("delete") || lastSegment.startsWith("remove")) {
-            def._optimistic = "delete";
-          }
-        }
       }
     }
     for (const [name, def] of Object.entries(this.queries)) {
@@ -634,9 +318,8 @@ class LensServerImpl {
         def._name = name;
       }
     }
-    this.stateManager = new GraphStateManager({
-      onEntityUnsubscribed: (_entity, _id) => {}
-    });
+  }
+  validateDefinitions() {
     for (const [name, def] of Object.entries(this.queries)) {
       if (!isQueryDef(def)) {
         throw new Error(`Invalid query definition: ${name}`);
@@ -648,9 +331,6 @@ class LensServerImpl {
       }
     }
   }
-  getStateManager() {
-    return this.stateManager;
-  }
   getMetadata() {
     return {
       version: this.version,
@@ -673,76 +353,645 @@ class LensServerImpl {
       return { error: error instanceof Error ? error : new Error(String(error)) };
     }
   }
-  buildOperationsMap() {
-    const result = {};
-    const setNested = (path, meta) => {
-      const parts = path.split(".");
-      let current = result;
-      for (let i = 0;i < parts.length - 1; i++) {
-        const part = parts[i];
-        if (!current[part] || "type" in current[part]) {
-          current[part] = {};
-        }
-        current = current[part];
-      }
-      current[parts[parts.length - 1]] = meta;
-    };
-    for (const [name, _def] of Object.entries(this.queries)) {
-      setNested(name, { type: "query" });
+  async executeQuery(name, input) {
+    const queryDef = this.queries[name];
+    if (!queryDef)
+      throw new Error(`Query not found: ${name}`);
+    let select;
+    let cleanInput = input;
+    if (input && typeof input === "object" && "$select" in input) {
+      const { $select, ...rest } = input;
+      select = $select;
+      cleanInput = Object.keys(rest).length > 0 ? rest : undefined;
     }
-    for (const [name, def] of Object.entries(this.mutations)) {
-      const meta = { type: "mutation" };
-      if (def._optimistic) {
-        const entityType = getEntityTypeName(def._output);
-        const inputFields = getInputFields(def._input);
-        meta.optimistic = sugarToPipeline(def._optimistic, entityType, inputFields);
+    if (queryDef._input && cleanInput !== undefined) {
+      const result = queryDef._input.safeParse(cleanInput);
+      if (!result.success) {
+        throw new Error(`Invalid input: ${JSON.stringify(result.error)}`);
       }
-      setNested(name, meta);
     }
-    return result;
+    const context = await this.contextFactory();
+    try {
+      return await runWithContext(this.ctx, context, async () => {
+        const resolver = queryDef._resolve;
+        if (!resolver)
+          throw new Error(`Query ${name} has no resolver`);
+        const emit = createEmit(() => {});
+        const onCleanup = () => () => {};
+        const lensContext = { ...context, emit, onCleanup };
+        const result = resolver({ input: cleanInput, ctx: lensContext });
+        let data;
+        if (isAsyncIterable(result)) {
+          for await (const value of result) {
+            data = value;
+            break;
+          }
+          if (data === undefined) {
+            throw new Error(`Query ${name} returned empty stream`);
+          }
+        } else {
+          data = await result;
+        }
+        return this.processQueryResult(name, data, select);
+      });
+    } finally {
+      this.clearLoaders();
+    }
   }
-  handleWebSocket(ws) {
-    const clientId = `client_${++this.connectionCounter}`;
-    const conn = {
-      id: clientId,
-      ws,
-      subscriptions: new Map
-    };
-    this.connections.set(clientId, conn);
-    this.stateManager.addClient({
-      id: clientId,
-      send: (msg) => {
-        ws.send(JSON.stringify(msg));
+  async executeMutation(name, input) {
+    const mutationDef = this.mutations[name];
+    if (!mutationDef)
+      throw new Error(`Mutation not found: ${name}`);
+    if (mutationDef._input) {
+      const result = mutationDef._input.safeParse(input);
+      if (!result.success) {
+        throw new Error(`Invalid input: ${JSON.stringify(result.error)}`);
       }
-    });
+    }
+    const context = await this.contextFactory();
+    try {
+      return await runWithContext(this.ctx, context, async () => {
+        const resolver = mutationDef._resolve;
+        if (!resolver)
+          throw new Error(`Mutation ${name} has no resolver`);
+        const emit = createEmit(() => {});
+        const onCleanup = () => () => {};
+        const lensContext = { ...context, emit, onCleanup };
+        return await resolver({ input, ctx: lensContext });
+      });
+    } finally {
+      this.clearLoaders();
+    }
+  }
+  async processQueryResult(_operationName, data, select) {
+    if (!data)
+      return data;
+    const processed = await this.resolveEntityFields(data);
+    if (select) {
+      return applySelection(processed, select);
+    }
+    return processed;
+  }
+  async resolveEntityFields(data) {
+    if (!data || !this.resolverMap)
+      return data;
+    if (Array.isArray(data)) {
+      return Promise.all(data.map((item) => this.resolveEntityFields(item)));
+    }
+    if (typeof data !== "object")
+      return data;
+    const obj = data;
+    const typeName = this.getTypeName(obj);
+    if (!typeName)
+      return data;
+    const resolverDef = this.resolverMap.get(typeName);
+    if (!resolverDef)
+      return data;
+    const result = { ...obj };
+    for (const fieldName of resolverDef.getFieldNames()) {
+      const field = String(fieldName);
+      if (resolverDef.isExposed(field))
+        continue;
+      const existingValue = result[field];
+      if (existingValue !== undefined) {
+        result[field] = await this.resolveEntityFields(existingValue);
+        continue;
+      }
+      const loaderKey = `${typeName}.${field}`;
+      const loader = this.getOrCreateLoaderForField(loaderKey, resolverDef, field);
+      result[field] = await loader.load(obj);
+      result[field] = await this.resolveEntityFields(result[field]);
+    }
+    return result;
+  }
+  getTypeName(obj) {
+    if ("__typename" in obj)
+      return obj.__typename;
+    if ("_type" in obj)
+      return obj._type;
+    for (const [name, def] of Object.entries(this.entities)) {
+      if (isEntityDef(def) && this.matchesEntity(obj, def)) {
+        return name;
+      }
+    }
+    return;
+  }
+  matchesEntity(obj, entityDef) {
+    return "id" in obj || entityDef._name in obj;
+  }
+  getOrCreateLoaderForField(loaderKey, resolverDef, fieldName) {
+    let loader = this.loaders.get(loaderKey);
+    if (!loader) {
+      loader = new DataLoader(async (parents) => {
+        const results = [];
+        for (const parent of parents) {
+          try {
+            const result = await resolverDef.resolveField(fieldName, parent, {}, {});
+            results.push(result);
+          } catch {
+            results.push(null);
+          }
+        }
+        return results;
+      });
+      this.loaders.set(loaderKey, loader);
+    }
+    return loader;
+  }
+  clearLoaders() {
+    this.loaders.clear();
+  }
+  buildOperationsMap() {
+    const result = {};
+    const setNested = (path, meta) => {
+      const parts = path.split(".");
+      let current = result;
+      for (let i = 0;i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (!current[part] || "type" in current[part]) {
+          current[part] = {};
+        }
+        current = current[part];
+      }
+      current[parts[parts.length - 1]] = meta;
+    };
+    for (const [name, def] of Object.entries(this.queries)) {
+      const meta = { type: "query" };
+      this.pluginManager.runEnhanceOperationMeta({
+        path: name,
+        type: "query",
+        meta,
+        definition: def
+      });
+      setNested(name, meta);
+    }
+    for (const [name, def] of Object.entries(this.mutations)) {
+      const meta = { type: "mutation" };
+      this.pluginManager.runEnhanceOperationMeta({
+        path: name,
+        type: "mutation",
+        meta,
+        definition: def
+      });
+      setNested(name, meta);
+    }
+    return result;
+  }
+  async addClient(clientId, send) {
+    const allowed = await this.pluginManager.runOnConnect({
+      clientId,
+      send: (msg) => send(msg)
+    });
+    return allowed;
+  }
+  removeClient(clientId, subscriptionCount) {
+    this.pluginManager.runOnDisconnect({ clientId, subscriptionCount });
+  }
+  async subscribe(ctx) {
+    return this.pluginManager.runOnSubscribe(ctx);
+  }
+  unsubscribe(ctx) {
+    this.pluginManager.runOnUnsubscribe(ctx);
+  }
+  async broadcast(entity, entityId, data) {
+    await this.pluginManager.runOnBroadcast({ entity, entityId, data });
+  }
+  async send(clientId, subscriptionId, entity, entityId, data, isInitial) {
+    const transformedData = await this.pluginManager.runBeforeSend({
+      clientId,
+      subscriptionId,
+      entity,
+      entityId,
+      data,
+      isInitial,
+      fields: "*"
+    });
+    await this.pluginManager.runAfterSend({
+      clientId,
+      subscriptionId,
+      entity,
+      entityId,
+      data: transformedData,
+      isInitial,
+      fields: "*",
+      timestamp: Date.now()
+    });
+  }
+  async handleReconnect(ctx) {
+    return this.pluginManager.runOnReconnect(ctx);
+  }
+  async updateFields(ctx) {
+    await this.pluginManager.runOnUpdateFields(ctx);
+  }
+  getPluginManager() {
+    return this.pluginManager;
+  }
+}
+function createApp(config) {
+  const server = new LensServerImpl(config);
+  return server;
+}
+// src/sse/handler.ts
+class SSEHandler {
+  heartbeatInterval;
+  onConnectCallback;
+  onDisconnectCallback;
+  clients = new Map;
+  clientCounter = 0;
+  constructor(config = {}) {
+    this.heartbeatInterval = config.heartbeatInterval ?? 30000;
+    this.onConnectCallback = config.onConnect;
+    this.onDisconnectCallback = config.onDisconnect;
+  }
+  handleConnection(_req) {
+    const clientId = `sse_${++this.clientCounter}_${Date.now()}`;
+    const encoder = new TextEncoder;
+    const stream = new ReadableStream({
+      start: (controller) => {
+        const heartbeat = setInterval(() => {
+          try {
+            controller.enqueue(encoder.encode(`: heartbeat ${Date.now()}
+
+`));
+          } catch {
+            this.removeClient(clientId);
+          }
+        }, this.heartbeatInterval);
+        this.clients.set(clientId, { controller, heartbeat, encoder });
+        controller.enqueue(encoder.encode(`event: connected
+data: ${JSON.stringify({ clientId })}
+
+`));
+        const client = {
+          id: clientId,
+          send: (message) => this.send(clientId, message),
+          sendEvent: (event, data) => this.sendEvent(clientId, event, data),
+          close: () => this.closeClient(clientId)
+        };
+        this.onConnectCallback?.(client);
+      },
+      cancel: () => {
+        this.removeClient(clientId);
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Access-Control-Allow-Origin": "*"
+      }
+    });
+  }
+  send(clientId, message) {
+    const client = this.clients.get(clientId);
+    if (!client)
+      return false;
+    try {
+      const data = `data: ${JSON.stringify(message)}
+
+`;
+      client.controller.enqueue(client.encoder.encode(data));
+      return true;
+    } catch {
+      this.removeClient(clientId);
+      return false;
+    }
+  }
+  sendEvent(clientId, event, data) {
+    const client = this.clients.get(clientId);
+    if (!client)
+      return false;
+    try {
+      const message = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+      client.controller.enqueue(client.encoder.encode(message));
+      return true;
+    } catch {
+      this.removeClient(clientId);
+      return false;
+    }
+  }
+  broadcast(message) {
+    for (const clientId of this.clients.keys()) {
+      this.send(clientId, message);
+    }
+  }
+  removeClient(clientId) {
+    const client = this.clients.get(clientId);
+    if (client) {
+      clearInterval(client.heartbeat);
+      this.clients.delete(clientId);
+      this.onDisconnectCallback?.(clientId);
+    }
+  }
+  closeClient(clientId) {
+    const client = this.clients.get(clientId);
+    if (client) {
+      try {
+        client.controller.close();
+      } catch {}
+      this.removeClient(clientId);
+    }
+  }
+  getClientCount() {
+    return this.clients.size;
+  }
+  getClientIds() {
+    return Array.from(this.clients.keys());
+  }
+  hasClient(clientId) {
+    return this.clients.has(clientId);
+  }
+  closeAll() {
+    for (const clientId of this.clients.keys()) {
+      this.closeClient(clientId);
+    }
+  }
+}
+function createSSEHandler(config = {}) {
+  return new SSEHandler(config);
+}
+
+// src/handlers/http.ts
+function createHTTPHandler(server, options = {}) {
+  const { pathPrefix = "", cors } = options;
+  const corsHeaders = {
+    "Access-Control-Allow-Origin": cors?.origin ? Array.isArray(cors.origin) ? cors.origin.join(", ") : cors.origin : "*",
+    "Access-Control-Allow-Methods": cors?.methods?.join(", ") ?? "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": cors?.headers?.join(", ") ?? "Content-Type, Authorization"
+  };
+  const handler = async (request) => {
+    const url = new URL(request.url);
+    const pathname = url.pathname;
+    if (request.method === "OPTIONS") {
+      return new Response(null, {
+        status: 204,
+        headers: corsHeaders
+      });
+    }
+    const metadataPath = `${pathPrefix}/__lens/metadata`;
+    if (request.method === "GET" && pathname === metadataPath) {
+      return new Response(JSON.stringify(server.getMetadata()), {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders
+        }
+      });
+    }
+    const operationPath = pathPrefix || "/";
+    if (request.method === "POST" && (pathname === operationPath || pathname === `${pathPrefix}/`)) {
+      try {
+        const body = await request.json();
+        const operationPath2 = body.operation ?? body.path;
+        if (!operationPath2) {
+          return new Response(JSON.stringify({ error: "Missing operation path" }), {
+            status: 400,
+            headers: {
+              "Content-Type": "application/json",
+              ...corsHeaders
+            }
+          });
+        }
+        const result2 = await server.execute({
+          path: operationPath2,
+          input: body.input
+        });
+        if (result2.error) {
+          return new Response(JSON.stringify({ error: result2.error.message }), {
+            status: 500,
+            headers: {
+              "Content-Type": "application/json",
+              ...corsHeaders
+            }
+          });
+        }
+        return new Response(JSON.stringify({ data: result2.data }), {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders
+          }
+        });
+      } catch (error) {
+        return new Response(JSON.stringify({ error: String(error) }), {
+          status: 500,
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders
+          }
+        });
+      }
+    }
+    return new Response(JSON.stringify({ error: "Not found" }), {
+      status: 404,
+      headers: {
+        "Content-Type": "application/json",
+        ...corsHeaders
+      }
+    });
+  };
+  const result = handler;
+  result.handle = handler;
+  return result;
+}
+
+// src/handlers/unified.ts
+function createHandler(server, options = {}) {
+  const { ssePath = "/__lens/sse", heartbeatInterval, ...httpOptions } = options;
+  const pathPrefix = httpOptions.pathPrefix ?? "";
+  const fullSsePath = `${pathPrefix}${ssePath}`;
+  const httpHandler = createHTTPHandler(server, httpOptions);
+  const pluginManager = server.getPluginManager();
+  const sseHandler = new SSEHandler({
+    ...heartbeatInterval !== undefined && { heartbeatInterval },
+    onConnect: (client) => {
+      pluginManager.runOnConnect({ clientId: client.id });
+    },
+    onDisconnect: (clientId) => {
+      pluginManager.runOnDisconnect({ clientId, subscriptionCount: 0 });
+    }
+  });
+  const handler = async (request) => {
+    const url = new URL(request.url);
+    if (request.method === "GET" && url.pathname === fullSsePath) {
+      return sseHandler.handleConnection(request);
+    }
+    return httpHandler(request);
+  };
+  const result = handler;
+  result.handle = handler;
+  result.sse = sseHandler;
+  return result;
+}
+// src/handlers/framework.ts
+function createServerClientProxy(server) {
+  function createProxy(path) {
+    return new Proxy(() => {}, {
+      get(_, prop) {
+        if (typeof prop === "symbol")
+          return;
+        if (prop === "then")
+          return;
+        const newPath = path ? `${path}.${prop}` : String(prop);
+        return createProxy(newPath);
+      },
+      async apply(_, __, args) {
+        const input = args[0];
+        const result = await server.execute({ path, input });
+        if (result.error) {
+          throw result.error;
+        }
+        return result.data;
+      }
+    });
+  }
+  return createProxy("");
+}
+async function handleWebQuery(server, path, url) {
+  try {
+    const inputParam = url.searchParams.get("input");
+    const input = inputParam ? JSON.parse(inputParam) : undefined;
+    const result = await server.execute({ path, input });
+    if (result.error) {
+      return Response.json({ error: result.error.message }, { status: 400 });
+    }
+    return Response.json({ data: result.data });
+  } catch (error) {
+    return Response.json({ error: error instanceof Error ? error.message : "Unknown error" }, { status: 500 });
+  }
+}
+async function handleWebMutation(server, path, request) {
+  try {
+    const body = await request.json();
+    const input = body.input;
+    const result = await server.execute({ path, input });
+    if (result.error) {
+      return Response.json({ error: result.error.message }, { status: 400 });
+    }
+    return Response.json({ data: result.data });
+  } catch (error) {
+    return Response.json({ error: error instanceof Error ? error.message : "Unknown error" }, { status: 500 });
+  }
+}
+function handleWebSSE(server, path, url, signal) {
+  const inputParam = url.searchParams.get("input");
+  const input = inputParam ? JSON.parse(inputParam) : undefined;
+  const stream = new ReadableStream({
+    start(controller) {
+      const encoder = new TextEncoder;
+      const result = server.execute({ path, input });
+      if (result && typeof result === "object" && "subscribe" in result) {
+        const observable = result;
+        const subscription = observable.subscribe({
+          next: (value) => {
+            const data = `data: ${JSON.stringify(value.data)}
+
+`;
+            controller.enqueue(encoder.encode(data));
+          },
+          error: (err) => {
+            const data = `event: error
+data: ${JSON.stringify({ error: err.message })}
+
+`;
+            controller.enqueue(encoder.encode(data));
+            controller.close();
+          },
+          complete: () => {
+            controller.close();
+          }
+        });
+        if (signal) {
+          signal.addEventListener("abort", () => {
+            subscription.unsubscribe();
+            controller.close();
+          });
+        }
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
+function createFrameworkHandler(server, options = {}) {
+  const basePath = options.basePath ?? "";
+  return async (request) => {
+    const url = new URL(request.url);
+    const path = url.pathname.replace(basePath, "").replace(/^\//, "");
+    if (request.headers.get("accept") === "text/event-stream") {
+      return handleWebSSE(server, path, url, request.signal);
+    }
+    if (request.method === "GET") {
+      return handleWebQuery(server, path, url);
+    }
+    if (request.method === "POST") {
+      return handleWebMutation(server, path, request);
+    }
+    return new Response("Method not allowed", { status: 405 });
+  };
+}
+// src/handlers/ws.ts
+function createWSHandler(server, options = {}) {
+  const { logger = {} } = options;
+  const connections = new Map;
+  const wsToConnection = new WeakMap;
+  let connectionCounter = 0;
+  async function handleConnection(ws) {
+    const clientId = `client_${++connectionCounter}`;
+    const conn = {
+      id: clientId,
+      ws,
+      subscriptions: new Map
+    };
+    connections.set(clientId, conn);
+    wsToConnection.set(ws, conn);
+    const sendFn = (msg) => {
+      ws.send(JSON.stringify(msg));
+    };
+    const allowed = await server.addClient(clientId, sendFn);
+    if (!allowed) {
+      ws.close();
+      connections.delete(clientId);
+      return;
+    }
     ws.onmessage = (event) => {
-      this.handleMessage(conn, event.data);
+      handleMessage(conn, event.data);
     };
     ws.onclose = () => {
-      this.handleDisconnect(conn);
+      handleDisconnect(conn);
     };
   }
-  handleMessage(conn, data) {
+  function handleMessage(conn, data) {
     try {
       const message = JSON.parse(data);
       switch (message.type) {
         case "handshake":
-          this.handleHandshake(conn, message);
+          handleHandshake(conn, message);
           break;
         case "subscribe":
-          this.handleSubscribe(conn, message);
+          handleSubscribe(conn, message);
           break;
         case "updateFields":
-          this.handleUpdateFields(conn, message);
+          handleUpdateFields(conn, message);
           break;
         case "unsubscribe":
-          this.handleUnsubscribe(conn, message);
+          handleUnsubscribe(conn, message);
           break;
         case "query":
-          this.handleQuery(conn, message);
+          handleQuery(conn, message);
           break;
         case "mutation":
-          this.handleMutation(conn, message);
+          handleMutation(conn, message);
+          break;
+        case "reconnect":
+          handleReconnect(conn, message);
           break;
       }
     } catch (error) {
@@ -752,165 +1001,125 @@ class LensServerImpl {
       }));
     }
   }
-  handleHandshake(conn, message) {
+  function handleHandshake(conn, message) {
+    const metadata = server.getMetadata();
     conn.ws.send(JSON.stringify({
       type: "handshake",
       id: message.id,
-      version: this.version,
-      operations: this.buildOperationsMap()
+      version: metadata.version,
+      operations: metadata.operations
     }));
   }
-  async handleSubscribe(conn, message) {
+  async function handleSubscribe(conn, message) {
     const { id, operation, input, fields } = message;
-    const sub = {
-      id,
-      operation,
-      input,
-      fields,
-      entityKeys: new Set,
-      cleanups: [],
-      lastData: null
-    };
-    conn.subscriptions.set(id, sub);
+    let result;
     try {
-      await this.executeSubscription(conn, sub);
+      result = await server.execute({ path: operation, input });
+      if (result.error) {
+        conn.ws.send(JSON.stringify({
+          type: "error",
+          id,
+          error: { code: "EXECUTION_ERROR", message: result.error.message }
+        }));
+        return;
+      }
     } catch (error) {
       conn.ws.send(JSON.stringify({
         type: "error",
         id,
         error: { code: "EXECUTION_ERROR", message: String(error) }
       }));
+      return;
     }
-  }
-  async executeSubscription(conn, sub) {
-    const queryDef = this.queries[sub.operation];
-    if (!queryDef) {
-      throw new Error(`Query not found: ${sub.operation}`);
-    }
-    if (queryDef._input && sub.input !== undefined) {
-      const result = queryDef._input.safeParse(sub.input);
-      if (!result.success) {
-        throw new Error(`Invalid input: ${JSON.stringify(result.error)}`);
-      }
-    }
-    const context = await this.contextFactory();
-    let isFirstUpdate = true;
-    const emitData = (data) => {
-      if (!data)
-        return;
-      const entityName = this.getEntityNameFromOutput(queryDef._output);
-      const entities = this.extractEntities(entityName, data);
-      for (const { entity, id, entityData } of entities) {
-        const entityKey = `${entity}:${id}`;
-        sub.entityKeys.add(entityKey);
-        this.stateManager.subscribe(conn.id, entity, id, sub.fields);
-        this.stateManager.emit(entity, id, entityData);
-      }
-      if (isFirstUpdate) {
-        conn.ws.send(JSON.stringify({
-          type: "data",
-          id: sub.id,
-          data
-        }));
-        isFirstUpdate = false;
-        sub.lastData = data;
-      } else {
-        const updates = this.computeUpdates(sub.lastData, data);
-        if (updates && Object.keys(updates).length > 0) {
-          conn.ws.send(JSON.stringify({
-            type: "update",
-            id: sub.id,
-            updates
-          }));
+    const entities = result.data ? extractEntities(result.data) : [];
+    const existingSub = conn.subscriptions.get(id);
+    if (existingSub) {
+      for (const cleanup of existingSub.cleanups) {
+        try {
+          cleanup();
+        } catch (e) {
+          logger.error?.("Cleanup error:", e);
         }
-        sub.lastData = data;
       }
-    };
-    await runWithContext(this.ctx, context, async () => {
-      const resolver = queryDef._resolve;
-      if (!resolver) {
-        throw new Error(`Query ${sub.operation} has no resolver`);
-      }
-      const emit = createEmit((command) => {
-        const entityName = this.getEntityNameFromOutput(queryDef._output);
-        if (entityName) {
-          const entities = this.extractEntities(entityName, command.type === "full" ? command.data : {});
-          for (const { entity, id } of entities) {
-            this.stateManager.processCommand(entity, id, command);
-          }
-        }
-        if (command.type === "full") {
-          emitData(command.data);
-        }
+      server.unsubscribe({
+        clientId: conn.id,
+        subscriptionId: id,
+        operation: existingSub.operation,
+        entityKeys: Array.from(existingSub.entityKeys)
       });
-      const onCleanup = (fn) => {
-        sub.cleanups.push(fn);
-        return () => {
-          const idx = sub.cleanups.indexOf(fn);
-          if (idx >= 0)
-            sub.cleanups.splice(idx, 1);
-        };
-      };
-      const lensContext = {
-        ...context,
-        emit,
-        onCleanup
-      };
-      const result = resolver({
-        input: sub.input,
-        ctx: lensContext
+      conn.subscriptions.delete(id);
+    }
+    const sub = {
+      id,
+      operation,
+      input,
+      fields,
+      entityKeys: new Set(entities.map(({ entity, entityId }) => `${entity}:${entityId}`)),
+      cleanups: [],
+      lastData: result.data
+    };
+    for (const { entity, entityId, entityData } of entities) {
+      const allowed = await server.subscribe({
+        clientId: conn.id,
+        subscriptionId: id,
+        operation,
+        input,
+        fields,
+        entity,
+        entityId
       });
-      if (isAsyncIterable(result)) {
-        for await (const value of result) {
-          emitData(value);
-        }
-      } else {
-        const value = await result;
-        emitData(value);
+      if (!allowed) {
+        conn.ws.send(JSON.stringify({
+          type: "error",
+          id,
+          error: { code: "SUBSCRIPTION_REJECTED", message: "Subscription rejected by plugin" }
+        }));
+        return;
       }
-    });
+      await server.send(conn.id, id, entity, entityId, entityData, true);
+    }
+    conn.subscriptions.set(id, sub);
   }
-  handleUpdateFields(conn, message) {
+  async function handleUpdateFields(conn, message) {
     const sub = conn.subscriptions.get(message.id);
     if (!sub)
       return;
+    const previousFields = sub.fields;
+    let newFields;
     if (message.addFields?.includes("*")) {
-      sub.fields = "*";
-      for (const entityKey of sub.entityKeys) {
-        const [entity, id] = entityKey.split(":");
-        this.stateManager.updateSubscription(conn.id, entity, id, "*");
-      }
+      newFields = "*";
+    } else if (message.setFields !== undefined) {
+      newFields = message.setFields;
+    } else if (sub.fields === "*") {
       return;
-    }
-    if (message.setFields !== undefined) {
-      sub.fields = message.setFields;
-      for (const entityKey of sub.entityKeys) {
-        const [entity, id] = entityKey.split(":");
-        this.stateManager.updateSubscription(conn.id, entity, id, sub.fields);
-      }
-      return;
-    }
-    if (sub.fields === "*") {
-      return;
-    }
-    const fields = new Set(sub.fields);
-    if (message.addFields) {
-      for (const field of message.addFields) {
-        fields.add(field);
+    } else {
+      const fields = new Set(sub.fields);
+      if (message.addFields) {
+        for (const field of message.addFields) {
+          fields.add(field);
+        }
       }
-    }
-    if (message.removeFields) {
-      for (const field of message.removeFields) {
-        fields.delete(field);
+      if (message.removeFields) {
+        for (const field of message.removeFields) {
+          fields.delete(field);
+        }
       }
+      newFields = Array.from(fields);
     }
-    sub.fields = Array.from(fields);
+    sub.fields = newFields;
     for (const entityKey of sub.entityKeys) {
-      const [entity, id] = entityKey.split(":");
-      this.stateManager.updateSubscription(conn.id, entity, id, sub.fields);
+      const [entity, entityId] = entityKey.split(":");
+      await server.updateFields({
+        clientId: conn.id,
+        subscriptionId: sub.id,
+        entity,
+        entityId,
+        fields: newFields,
+        previousFields
+      });
     }
   }
-  handleUnsubscribe(conn, message) {
+  function handleUnsubscribe(conn, message) {
     const sub = conn.subscriptions.get(message.id);
     if (!sub)
       return;
@@ -918,23 +1127,32 @@ class LensServerImpl {
       try {
         cleanup();
       } catch (e) {
-        this.logger.error?.("Cleanup error:", e);
+        logger.error?.("Cleanup error:", e);
       }
     }
-    for (const entityKey of sub.entityKeys) {
-      const [entity, id] = entityKey.split(":");
-      this.stateManager.unsubscribe(conn.id, entity, id);
-    }
     conn.subscriptions.delete(message.id);
+    server.unsubscribe({
+      clientId: conn.id,
+      subscriptionId: message.id,
+      operation: sub.operation,
+      entityKeys: Array.from(sub.entityKeys)
+    });
   }
-  async handleQuery(conn, message) {
+  async function handleQuery(conn, message) {
     try {
-      let input = message.input;
-      if (message.select) {
-        input = { ...message.input || {}, $select: message.select };
+      const result = await server.execute({
+        path: message.operation,
+        input: message.input
+      });
+      if (result.error) {
+        conn.ws.send(JSON.stringify({
+          type: "error",
+          id: message.id,
+          error: { code: "EXECUTION_ERROR", message: result.error.message }
+        }));
+        return;
       }
-      const result = await this.executeQuery(message.operation, input);
-      const selected = message.fields && !message.select ? this.applySelection(result, message.fields) : result;
+      const selected = message.fields ? applySelection2(result.data, message.fields) : result.data;
       conn.ws.send(JSON.stringify({
         type: "result",
         id: message.id,
@@ -948,18 +1166,30 @@ class LensServerImpl {
       }));
     }
   }
-  async handleMutation(conn, message) {
+  async function handleMutation(conn, message) {
     try {
-      const result = await this.executeMutation(message.operation, message.input);
-      const entityName = this.getEntityNameFromMutation(message.operation);
-      const entities = this.extractEntities(entityName, result);
-      for (const { entity, id, entityData } of entities) {
-        this.stateManager.emit(entity, id, entityData);
+      const result = await server.execute({
+        path: message.operation,
+        input: message.input
+      });
+      if (result.error) {
+        conn.ws.send(JSON.stringify({
+          type: "error",
+          id: message.id,
+          error: { code: "EXECUTION_ERROR", message: result.error.message }
+        }));
+        return;
+      }
+      if (result.data) {
+        const entities = extractEntities(result.data);
+        for (const { entity, entityId, entityData } of entities) {
+          await server.broadcast(entity, entityId, entityData);
+        }
       }
       conn.ws.send(JSON.stringify({
         type: "result",
         id: message.id,
-        data: result
+        data: result.data
       }));
     } catch (error) {
       conn.ws.send(JSON.stringify({
@@ -969,250 +1199,131 @@ class LensServerImpl {
       }));
     }
   }
-  handleDisconnect(conn) {
-    for (const sub of conn.subscriptions.values()) {
-      for (const cleanup of sub.cleanups) {
-        try {
-          cleanup();
-        } catch (e) {
-          this.logger.error?.("Cleanup error:", e);
-        }
-      }
-    }
-    this.stateManager.removeClient(conn.id);
-    this.connections.delete(conn.id);
-  }
-  async executeQuery(name, input) {
-    const queryDef = this.queries[name];
-    if (!queryDef) {
-      throw new Error(`Query not found: ${name}`);
-    }
-    let select;
-    let cleanInput = input;
-    if (input && typeof input === "object" && "$select" in input) {
-      const { $select, ...rest } = input;
-      select = $select;
-      cleanInput = Object.keys(rest).length > 0 ? rest : undefined;
-    }
-    if (queryDef._input && cleanInput !== undefined) {
-      const result = queryDef._input.safeParse(cleanInput);
-      if (!result.success) {
-        throw new Error(`Invalid input: ${JSON.stringify(result.error)}`);
-      }
-    }
-    const context = await this.contextFactory();
-    try {
-      return await runWithContext(this.ctx, context, async () => {
-        const resolver = queryDef._resolve;
-        if (!resolver) {
-          throw new Error(`Query ${name} has no resolver`);
-        }
-        const emit = createEmit(() => {});
-        const onCleanup = () => () => {};
-        const lensContext = {
-          ...context,
-          emit,
-          onCleanup
+  async function handleReconnect(conn, message) {
+    const startTime = Date.now();
+    const ctx = {
+      clientId: conn.id,
+      reconnectId: message.reconnectId,
+      subscriptions: message.subscriptions.map((sub) => {
+        const mapped = {
+          id: sub.id,
+          entity: sub.entity,
+          entityId: sub.entityId,
+          fields: sub.fields,
+          version: sub.version
         };
-        const result = resolver({
-          input: cleanInput,
-          ctx: lensContext
-        });
-        let data;
-        if (isAsyncIterable(result)) {
-          for await (const value of result) {
-            data = value;
-            break;
-          }
-          if (data === undefined) {
-            throw new Error(`Query ${name} returned empty stream`);
-          }
-        } else {
-          data = await result;
+        if (sub.dataHash !== undefined) {
+          mapped.dataHash = sub.dataHash;
         }
-        return this.processQueryResult(name, data, select);
-      });
-    } finally {
-      this.clearLoaders();
-    }
-  }
-  async executeMutation(name, input) {
-    const mutationDef = this.mutations[name];
-    if (!mutationDef) {
-      throw new Error(`Mutation not found: ${name}`);
-    }
-    if (mutationDef._input) {
-      const result = mutationDef._input.safeParse(input);
-      if (!result.success) {
-        throw new Error(`Invalid input: ${JSON.stringify(result.error)}`);
-      }
-    }
-    const context = await this.contextFactory();
-    try {
-      return await runWithContext(this.ctx, context, async () => {
-        const resolver = mutationDef._resolve;
-        if (!resolver) {
-          throw new Error(`Mutation ${name} has no resolver`);
+        if (sub.input !== undefined) {
+          mapped.input = sub.input;
         }
-        const emit = createEmit(() => {});
-        const onCleanup = () => () => {};
-        const lensContext = {
-          ...context,
-          emit,
-          onCleanup
-        };
-        const result = await resolver({
-          input,
-          ctx: lensContext
-        });
-        const entityName = this.getEntityNameFromMutation(name);
-        const entities = this.extractEntities(entityName, result);
-        for (const { entity, id, entityData } of entities) {
-          this.stateManager.emit(entity, id, entityData);
+        return mapped;
+      })
+    };
+    const results = await server.handleReconnect(ctx);
+    if (results === null) {
+      conn.ws.send(JSON.stringify({
+        type: "error",
+        error: {
+          code: "RECONNECT_ERROR",
+          message: "State management not available for reconnection",
+          reconnectId: message.reconnectId
         }
-        return result;
-      });
-    } finally {
-      this.clearLoaders();
-    }
-  }
-  async handleRequest(req) {
-    const url = new URL(req.url);
-    if (req.method === "GET" && url.pathname.endsWith("/__lens/metadata")) {
-      return new Response(JSON.stringify(this.getMetadata()), {
-        headers: { "Content-Type": "application/json" }
-      });
+      }));
+      return;
     }
-    if (req.method === "POST") {
-      try {
-        const body = await req.json();
-        if (this.queries[body.operation]) {
-          const result = await this.executeQuery(body.operation, body.input);
-          return new Response(JSON.stringify({ data: result }), {
-            headers: { "Content-Type": "application/json" }
-          });
-        }
-        if (this.mutations[body.operation]) {
-          const result = await this.executeMutation(body.operation, body.input);
-          return new Response(JSON.stringify({ data: result }), {
-            headers: { "Content-Type": "application/json" }
-          });
+    try {
+      for (const sub of message.subscriptions) {
+        let clientSub = conn.subscriptions.get(sub.id);
+        if (!clientSub) {
+          clientSub = {
+            id: sub.id,
+            operation: "",
+            input: sub.input,
+            fields: sub.fields,
+            entityKeys: new Set([`${sub.entity}:${sub.entityId}`]),
+            cleanups: [],
+            lastData: null
+          };
+          conn.subscriptions.set(sub.id, clientSub);
         }
-        return new Response(JSON.stringify({ error: `Operation not found: ${body.operation}` }), {
-          status: 404,
-          headers: { "Content-Type": "application/json" }
-        });
-      } catch (error) {
-        return new Response(JSON.stringify({ error: String(error) }), {
-          status: 500,
-          headers: { "Content-Type": "application/json" }
-        });
       }
-    }
-    return new Response("Method not allowed", { status: 405 });
-  }
-  async listen(port) {
-    this.server = Bun.serve({
-      port,
-      fetch: (req, server) => {
-        if (server.upgrade(req)) {
-          return;
-        }
-        return this.handleRequest(req);
-      },
-      websocket: {
-        message: (ws, message) => {
-          const conn = this.findConnectionByWs(ws);
-          if (conn) {
-            this.handleMessage(conn, String(message));
-          }
-        },
-        close: (ws) => {
-          const conn = this.findConnectionByWs(ws);
-          if (conn) {
-            this.handleDisconnect(conn);
-          }
+      conn.ws.send(JSON.stringify({
+        type: "reconnect_ack",
+        results,
+        serverTime: Date.now(),
+        reconnectId: message.reconnectId,
+        processingTime: Date.now() - startTime
+      }));
+    } catch (error) {
+      conn.ws.send(JSON.stringify({
+        type: "error",
+        error: {
+          code: "RECONNECT_ERROR",
+          message: String(error),
+          reconnectId: message.reconnectId
         }
-      }
-    });
-    this.logger.info?.(`Lens server listening on port ${port}`);
-  }
-  async close() {
-    if (this.server && typeof this.server.stop === "function") {
-      this.server.stop();
-    }
-    this.server = null;
-  }
-  findConnectionByWs(ws) {
-    for (const conn of this.connections.values()) {
-      if (conn.ws === ws) {
-        return conn;
-      }
+      }));
     }
-    return;
   }
-  getEntityNameFromOutput(output) {
-    if (!output)
-      return "unknown";
-    if (typeof output === "object" && output !== null) {
-      if ("_name" in output) {
-        return output._name;
-      }
-      if ("name" in output) {
-        return output.name;
-      }
-    }
-    if (Array.isArray(output) && output.length > 0) {
-      const first = output[0];
-      if (typeof first === "object" && first !== null) {
-        if ("_name" in first) {
-          return first._name;
-        }
-        if ("name" in first) {
-          return first.name;
+  function handleDisconnect(conn) {
+    const subscriptionCount = conn.subscriptions.size;
+    for (const sub of conn.subscriptions.values()) {
+      for (const cleanup of sub.cleanups) {
+        try {
+          cleanup();
+        } catch (e) {
+          logger.error?.("Cleanup error:", e);
         }
       }
     }
-    return "unknown";
-  }
-  getEntityNameFromMutation(name) {
-    const mutationDef = this.mutations[name];
-    if (!mutationDef)
-      return "unknown";
-    return this.getEntityNameFromOutput(mutationDef._output);
+    connections.delete(conn.id);
+    server.removeClient(conn.id, subscriptionCount);
   }
-  extractEntities(entityName, data) {
+  function extractEntities(data) {
     const results = [];
     if (!data)
       return results;
     if (Array.isArray(data)) {
       for (const item of data) {
         if (item && typeof item === "object" && "id" in item) {
+          const entityName = getEntityName(item);
           results.push({
             entity: entityName,
-            id: String(item.id),
+            entityId: String(item.id),
             entityData: item
           });
         }
       }
     } else if (typeof data === "object" && "id" in data) {
+      const entityName = getEntityName(data);
       results.push({
         entity: entityName,
-        id: String(data.id),
+        entityId: String(data.id),
         entityData: data
       });
     }
     return results;
   }
-  applySelection(data, fields) {
+  function getEntityName(data) {
+    if (!data || typeof data !== "object")
+      return "unknown";
+    if ("__typename" in data)
+      return String(data.__typename);
+    if ("_type" in data)
+      return String(data._type);
+    return "unknown";
+  }
+  function applySelection2(data, fields) {
     if (fields === "*" || !data)
       return data;
     if (Array.isArray(data)) {
-      return data.map((item) => this.applySelectionToObject(item, fields));
+      return data.map((item) => applySelectionToObject(item, fields));
     }
-    return this.applySelectionToObject(data, fields);
+    return applySelectionToObject(data, fields);
   }
-  applySelectionToObject(data, fields) {
+  function applySelectionToObject(data, fields) {
     if (!data || typeof data !== "object")
       return null;
     const result = {};
@@ -1220,299 +1331,748 @@ class LensServerImpl {
     if ("id" in obj) {
       result.id = obj.id;
     }
-    if (Array.isArray(fields)) {
-      for (const field of fields) {
-        if (field in obj) {
-          result[field] = obj[field];
-        }
-      }
-      return result;
-    }
-    for (const [key, value] of Object.entries(fields)) {
-      if (value === false)
-        continue;
-      const dataValue = obj[key];
-      if (value === true) {
-        result[key] = dataValue;
-      } else if (typeof value === "object" && value !== null) {
-        const nestedSelect = value.select ?? value;
-        if (Array.isArray(dataValue)) {
-          result[key] = dataValue.map((item) => this.applySelectionToObject(item, nestedSelect));
-        } else if (dataValue !== null && typeof dataValue === "object") {
-          result[key] = this.applySelectionToObject(dataValue, nestedSelect);
-        } else {
-          result[key] = dataValue;
-        }
+    for (const field of fields) {
+      if (field in obj) {
+        result[field] = obj[field];
       }
     }
     return result;
   }
-  async executeEntityResolvers(entityName, data, select) {
-    if (!data || !select || !this.resolverMap)
-      return data;
-    const resolverDef = this.resolverMap.get(entityName);
-    if (!resolverDef)
-      return data;
-    const result = { ...data };
-    const context = await this.contextFactory();
-    for (const [fieldName, fieldSelect] of Object.entries(select)) {
-      if (fieldSelect === false || fieldSelect === true)
-        continue;
-      if (!resolverDef.hasField(fieldName))
-        continue;
-      const fieldArgs = typeof fieldSelect === "object" && fieldSelect !== null && "args" in fieldSelect ? fieldSelect.args ?? {} : {};
-      result[fieldName] = await resolverDef.resolveField(fieldName, data, fieldArgs, context);
-      const nestedSelect = fieldSelect.select;
-      if (nestedSelect && result[fieldName]) {
-        const relationData = result[fieldName];
-        const targetEntity = this.getRelationTargetEntity(entityName, fieldName);
-        if (Array.isArray(relationData)) {
-          result[fieldName] = await Promise.all(relationData.map((item) => this.executeEntityResolvers(targetEntity, item, nestedSelect)));
-        } else {
-          result[fieldName] = await this.executeEntityResolvers(targetEntity, relationData, nestedSelect);
+  const handler = {
+    handleConnection,
+    handler: {
+      open(ws) {
+        if (ws && typeof ws === "object" && "send" in ws) {
+          handleConnection(ws);
+        }
+      },
+      message(ws, message) {
+        const conn = wsToConnection.get(ws);
+        if (conn) {
+          handleMessage(conn, String(message));
+        } else if (ws && typeof ws === "object" && "send" in ws) {
+          handleConnection(ws);
+          const newConn = wsToConnection.get(ws);
+          if (newConn) {
+            handleMessage(newConn, String(message));
+          }
+        }
+      },
+      close(ws) {
+        const conn = wsToConnection.get(ws);
+        if (conn) {
+          handleDisconnect(conn);
         }
       }
+    },
+    async close() {
+      for (const conn of connections.values()) {
+        handleDisconnect(conn);
+        conn.ws.close();
+      }
+      connections.clear();
+    }
+  };
+  return handler;
+}
+// src/storage/types.ts
+var DEFAULT_STORAGE_CONFIG = {
+  maxPatchesPerEntity: 1000,
+  maxPatchAge: 5 * 60 * 1000,
+  cleanupInterval: 60 * 1000,
+  maxRetries: 3
+};
+
+// src/storage/memory.ts
+function makeKey(entity, entityId) {
+  return `${entity}:${entityId}`;
+}
+function computePatch(oldState, newState) {
+  const patch = [];
+  const oldKeys = new Set(Object.keys(oldState));
+  const newKeys = new Set(Object.keys(newState));
+  for (const key of newKeys) {
+    const oldValue = oldState[key];
+    const newValue = newState[key];
+    if (!oldKeys.has(key)) {
+      patch.push({ op: "add", path: `/${key}`, value: newValue });
+    } else if (JSON.stringify(oldValue) !== JSON.stringify(newValue)) {
+      patch.push({ op: "replace", path: `/${key}`, value: newValue });
     }
-    return result;
   }
-  getRelationTargetEntity(entityName, fieldName) {
-    const entityDef = this.entities[entityName];
-    if (!entityDef)
-      return fieldName;
-    const fields = entityDef.fields;
-    if (!fields)
-      return fieldName;
-    const fieldDef = fields[fieldName];
-    if (!fieldDef)
-      return fieldName;
-    if (fieldDef._type === "hasMany" || fieldDef._type === "hasOne" || fieldDef._type === "belongsTo") {
-      return fieldDef._target ?? fieldName;
-    }
-    return fieldName;
-  }
-  serializeEntity(entityName, data) {
-    if (data === null)
-      return null;
-    const entityDef = this.entities[entityName];
-    if (!entityDef)
-      return data;
-    const fields = entityDef.fields;
-    if (!fields)
-      return data;
-    const result = {};
-    for (const [fieldName, value] of Object.entries(data)) {
-      const fieldType = fields[fieldName];
-      if (!fieldType) {
-        result[fieldName] = value;
-        continue;
+  for (const key of oldKeys) {
+    if (!newKeys.has(key)) {
+      patch.push({ op: "remove", path: `/${key}` });
+    }
+  }
+  return patch;
+}
+function hashState(state) {
+  return JSON.stringify(state);
+}
+function memoryStorage(config = {}) {
+  const cfg = { ...DEFAULT_STORAGE_CONFIG, ...config };
+  const entities = new Map;
+  let cleanupTimer = null;
+  if (cfg.cleanupInterval > 0) {
+    cleanupTimer = setInterval(() => cleanup(), cfg.cleanupInterval);
+  }
+  function cleanup() {
+    const now = Date.now();
+    const minTimestamp = now - cfg.maxPatchAge;
+    for (const state of entities.values()) {
+      state.patches = state.patches.filter((p) => p.timestamp >= minTimestamp);
+    }
+  }
+  function trimPatches(state) {
+    if (state.patches.length > cfg.maxPatchesPerEntity) {
+      state.patches = state.patches.slice(-cfg.maxPatchesPerEntity);
+    }
+  }
+  return {
+    async emit(entity, entityId, data) {
+      const key = makeKey(entity, entityId);
+      const existing = entities.get(key);
+      const now = Date.now();
+      if (!existing) {
+        const newState = {
+          data: { ...data },
+          version: 1,
+          patches: []
+        };
+        entities.set(key, newState);
+        return {
+          version: 1,
+          patch: null,
+          changed: true
+        };
       }
-      if (value === null || value === undefined) {
-        result[fieldName] = value;
-        continue;
+      const oldHash = hashState(existing.data);
+      const newHash = hashState(data);
+      if (oldHash === newHash) {
+        return {
+          version: existing.version,
+          patch: null,
+          changed: false
+        };
       }
-      if (fieldType._type === "hasMany" || fieldType._type === "belongsTo" || fieldType._type === "hasOne") {
-        const targetEntity = fieldType._target;
-        if (targetEntity && Array.isArray(value)) {
-          result[fieldName] = value.map((item) => this.serializeEntity(targetEntity, item));
-        } else if (targetEntity && typeof value === "object") {
-          result[fieldName] = this.serializeEntity(targetEntity, value);
-        } else {
-          result[fieldName] = value;
+      const patch = computePatch(existing.data, data);
+      const newVersion = existing.version + 1;
+      existing.data = { ...data };
+      existing.version = newVersion;
+      if (patch.length > 0) {
+        existing.patches.push({
+          version: newVersion,
+          patch,
+          timestamp: now
+        });
+        trimPatches(existing);
+      }
+      return {
+        version: newVersion,
+        patch: patch.length > 0 ? patch : null,
+        changed: true
+      };
+    },
+    async getState(entity, entityId) {
+      const key = makeKey(entity, entityId);
+      const state = entities.get(key);
+      return state ? { ...state.data } : null;
+    },
+    async getVersion(entity, entityId) {
+      const key = makeKey(entity, entityId);
+      const state = entities.get(key);
+      return state?.version ?? 0;
+    },
+    async getLatestPatch(entity, entityId) {
+      const key = makeKey(entity, entityId);
+      const state = entities.get(key);
+      if (!state || state.patches.length === 0) {
+        return null;
+      }
+      return state.patches[state.patches.length - 1].patch;
+    },
+    async getPatchesSince(entity, entityId, sinceVersion) {
+      const key = makeKey(entity, entityId);
+      const state = entities.get(key);
+      if (!state) {
+        return sinceVersion === 0 ? [] : null;
+      }
+      if (sinceVersion >= state.version) {
+        return [];
+      }
+      const relevantPatches = state.patches.filter((p) => p.version > sinceVersion);
+      if (relevantPatches.length === 0) {
+        return null;
+      }
+      relevantPatches.sort((a, b) => a.version - b.version);
+      if (relevantPatches[0].version !== sinceVersion + 1) {
+        return null;
+      }
+      for (let i = 1;i < relevantPatches.length; i++) {
+        if (relevantPatches[i].version !== relevantPatches[i - 1].version + 1) {
+          return null;
         }
-        continue;
       }
-      if (typeof fieldType.serialize === "function") {
-        try {
-          result[fieldName] = fieldType.serialize(value);
-        } catch (error) {
-          this.logger.warn?.(`Failed to serialize field ${entityName}.${fieldName}:`, error);
-          result[fieldName] = value;
+      return relevantPatches.map((p) => p.patch);
+    },
+    async has(entity, entityId) {
+      const key = makeKey(entity, entityId);
+      return entities.has(key);
+    },
+    async delete(entity, entityId) {
+      const key = makeKey(entity, entityId);
+      entities.delete(key);
+    },
+    async clear() {
+      entities.clear();
+    },
+    async dispose() {
+      if (cleanupTimer) {
+        clearInterval(cleanupTimer);
+        cleanupTimer = null;
+      }
+      entities.clear();
+    }
+  };
+}
+// src/plugin/op-log.ts
+function opLog(options = {}) {
+  const storage = options.storage ?? memoryStorage(options);
+  const debug = options.debug ?? false;
+  const log = (...args) => {
+    if (debug) {
+      console.log("[opLog]", ...args);
+    }
+  };
+  return {
+    name: "opLog",
+    getStorage() {
+      return storage;
+    },
+    async getVersion(entity, entityId) {
+      return storage.getVersion(entity, entityId);
+    },
+    async getState(entity, entityId) {
+      return storage.getState(entity, entityId);
+    },
+    async getLatestPatch(entity, entityId) {
+      return storage.getLatestPatch(entity, entityId);
+    },
+    async onBroadcast(ctx) {
+      const { entity, entityId, data } = ctx;
+      log("onBroadcast:", entity, entityId);
+      const result = await storage.emit(entity, entityId, data);
+      log("  Version:", result.version, "Patch ops:", result.patch?.length ?? 0);
+      return {
+        version: result.version,
+        patch: result.patch,
+        data
+      };
+    },
+    async onReconnect(ctx) {
+      log("Reconnect:", ctx.clientId, "subscriptions:", ctx.subscriptions.length);
+      const results = [];
+      for (const sub of ctx.subscriptions) {
+        const currentVersion = await storage.getVersion(sub.entity, sub.entityId);
+        const currentState = await storage.getState(sub.entity, sub.entityId);
+        if (currentState === null) {
+          results.push({
+            id: sub.id,
+            entity: sub.entity,
+            entityId: sub.entityId,
+            status: "deleted",
+            version: 0
+          });
+          log("  Subscription", sub.id, `${sub.entity}:${sub.entityId}`, "status: deleted");
+          continue;
         }
-      } else {
-        result[fieldName] = value;
+        if (sub.version >= currentVersion) {
+          results.push({
+            id: sub.id,
+            entity: sub.entity,
+            entityId: sub.entityId,
+            status: "current",
+            version: currentVersion
+          });
+          log("  Subscription", sub.id, `${sub.entity}:${sub.entityId}`, "status: current", "version:", currentVersion);
+          continue;
+        }
+        const patches = await storage.getPatchesSince(sub.entity, sub.entityId, sub.version);
+        if (patches !== null && patches.length > 0) {
+          results.push({
+            id: sub.id,
+            entity: sub.entity,
+            entityId: sub.entityId,
+            status: "patched",
+            version: currentVersion,
+            patches
+          });
+          log("  Subscription", sub.id, `${sub.entity}:${sub.entityId}`, "status: patched", "version:", currentVersion, "patches:", patches.length);
+          continue;
+        }
+        results.push({
+          id: sub.id,
+          entity: sub.entity,
+          entityId: sub.entityId,
+          status: "snapshot",
+          version: currentVersion,
+          data: currentState
+        });
+        log("  Subscription", sub.id, `${sub.entity}:${sub.entityId}`, "status: snapshot", "version:", currentVersion);
       }
+      return results;
     }
-    return result;
+  };
+}
+function isOpLogPlugin(plugin) {
+  return plugin.name === "opLog" && "getStorage" in plugin;
+}
+// src/plugin/optimistic.ts
+import {
+  isPipeline,
+  OPTIMISTIC_PLUGIN_SYMBOL
+} from "@sylphx/lens-core";
+import { isOptimisticPlugin } from "@sylphx/lens-core";
+function getEntityTypeName(returnSpec) {
+  if (!returnSpec)
+    return;
+  if (typeof returnSpec !== "object")
+    return;
+  const spec = returnSpec;
+  if ("_name" in spec && typeof spec._name === "string") {
+    return spec._name;
   }
-  async processQueryResult(queryName, data, select) {
-    if (data === null || data === undefined)
-      return data;
-    const queryDef = this.queries[queryName];
-    const entityName = this.getEntityNameFromOutput(queryDef?._output);
-    if (Array.isArray(data)) {
-      const processedItems = await Promise.all(data.map(async (item) => {
-        let result2 = item;
-        if (select && this.resolverMap) {
-          result2 = await this.executeEntityResolvers(entityName, item, select);
+  if ("~entity" in spec) {
+    const entity = spec["~entity"];
+    if (entity?.name)
+      return entity.name;
+  }
+  if ("_tag" in spec) {
+    if (spec._tag === "entity" && spec.entityDef) {
+      const entityDef = spec.entityDef;
+      if (entityDef._name)
+        return entityDef._name;
+    }
+    if (spec._tag === "array" && spec.element) {
+      return getEntityTypeName(spec.element);
+    }
+  }
+  return;
+}
+function getInputFields(schema) {
+  if (!schema?.shape)
+    return [];
+  return Object.keys(schema.shape);
+}
+function $input(field) {
+  return { $input: field };
+}
+function sugarToPipeline(sugar, entityType, inputFields) {
+  if (!sugar)
+    return;
+  if (isPipeline(sugar))
+    return sugar;
+  const entity = entityType ?? "Entity";
+  switch (sugar) {
+    case "merge": {
+      const updateData = {
+        type: entity,
+        id: $input("id")
+      };
+      for (const field of inputFields) {
+        if (field !== "id") {
+          updateData[field] = $input(field);
+        }
+      }
+      const pipeline = {
+        $pipe: [
+          {
+            $do: "entity.update",
+            $with: updateData,
+            $as: "result"
+          }
+        ]
+      };
+      return pipeline;
+    }
+    case "create": {
+      const pipeline = {
+        $pipe: [
+          {
+            $do: "entity.create",
+            $with: {
+              type: entity,
+              id: { $temp: true },
+              $fromOutput: true
+            },
+            $as: "result"
+          }
+        ]
+      };
+      return pipeline;
+    }
+    case "delete": {
+      const pipeline = {
+        $pipe: [
+          {
+            $do: "entity.delete",
+            $with: {
+              type: entity,
+              id: { id: $input("id") }
+            },
+            $as: "result"
+          }
+        ]
+      };
+      return pipeline;
+    }
+    default:
+      if (typeof sugar === "object" && "merge" in sugar) {
+        const updateData = {
+          type: entity,
+          id: $input("id")
+        };
+        for (const field of inputFields) {
+          if (field !== "id") {
+            updateData[field] = $input(field);
+          }
         }
-        if (select) {
-          result2 = this.applySelection(result2, select);
+        for (const [key, value] of Object.entries(sugar.merge)) {
+          updateData[key] = value;
         }
-        if (entityName) {
-          return this.serializeEntity(entityName, result2);
+        const pipeline = {
+          $pipe: [
+            {
+              $do: "entity.update",
+              $with: updateData,
+              $as: "result"
+            }
+          ]
+        };
+        return pipeline;
+      }
+      return;
+  }
+}
+function isOptimisticDSL(value) {
+  if (value === "merge" || value === "create" || value === "delete")
+    return true;
+  if (isPipeline(value))
+    return true;
+  if (typeof value === "object" && value !== null && "merge" in value)
+    return true;
+  return false;
+}
+function optimisticPlugin(options = {}) {
+  const { autoDerive = true, debug = false } = options;
+  const log = (...args) => {
+    if (debug) {
+      console.log("[optimisticPlugin]", ...args);
+    }
+  };
+  return {
+    name: "optimistic",
+    [OPTIMISTIC_PLUGIN_SYMBOL]: true,
+    enhanceOperationMeta(ctx) {
+      if (ctx.type !== "mutation")
+        return;
+      const def = ctx.definition;
+      let optimisticSpec = def._optimistic;
+      if (!optimisticSpec && autoDerive) {
+        const lastSegment = ctx.path.includes(".") ? ctx.path.split(".").pop() : ctx.path;
+        if (lastSegment.startsWith("update")) {
+          optimisticSpec = "merge";
+        } else if (lastSegment.startsWith("create") || lastSegment.startsWith("add")) {
+          optimisticSpec = "create";
+        } else if (lastSegment.startsWith("delete") || lastSegment.startsWith("remove")) {
+          optimisticSpec = "delete";
         }
-        return result2;
-      }));
-      return processedItems;
-    }
-    let result = data;
-    if (select && this.resolverMap) {
-      result = await this.executeEntityResolvers(entityName, data, select);
+        log(`Auto-derived optimistic for ${ctx.path}:`, optimisticSpec);
+      }
+      if (optimisticSpec && isOptimisticDSL(optimisticSpec)) {
+        const entityType = getEntityTypeName(def._output);
+        const inputFields = getInputFields(def._input);
+        const pipeline = sugarToPipeline(optimisticSpec, entityType, inputFields);
+        if (pipeline) {
+          ctx.meta.optimistic = pipeline;
+          log(`Added optimistic config for ${ctx.path}:`, pipeline);
+        }
+      }
     }
-    if (select) {
-      result = this.applySelection(result, select);
+  };
+}
+// src/reconnect/operation-log.ts
+import { DEFAULT_OPERATION_LOG_CONFIG } from "@sylphx/lens-core";
+
+class OperationLog {
+  entries = [];
+  config;
+  totalMemory = 0;
+  entityIndex = new Map;
+  oldestVersionIndex = new Map;
+  newestVersionIndex = new Map;
+  cleanupTimer = null;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_OPERATION_LOG_CONFIG, ...config };
+    if (this.config.cleanupInterval > 0) {
+      this.cleanupTimer = setInterval(() => this.cleanup(), this.config.cleanupInterval);
+    }
+  }
+  append(entry) {
+    const index = this.entries.length;
+    this.entries.push(entry);
+    this.totalMemory += entry.patchSize;
+    let indices = this.entityIndex.get(entry.entityKey);
+    if (!indices) {
+      indices = [];
+      this.entityIndex.set(entry.entityKey, indices);
+      this.oldestVersionIndex.set(entry.entityKey, entry.version);
+      this.newestVersionIndex.set(entry.entityKey, entry.version);
+    } else {
+      const currentOldest = this.oldestVersionIndex.get(entry.entityKey);
+      const currentNewest = this.newestVersionIndex.get(entry.entityKey);
+      if (entry.version < currentOldest) {
+        this.oldestVersionIndex.set(entry.entityKey, entry.version);
+      }
+      if (entry.version > currentNewest) {
+        this.newestVersionIndex.set(entry.entityKey, entry.version);
+      }
     }
-    if (entityName && typeof result === "object" && result !== null) {
-      return this.serializeEntity(entityName, result);
+    indices.push(index);
+    this.checkLimits();
+  }
+  appendBatch(entries) {
+    for (const entry of entries) {
+      this.append(entry);
     }
-    return result;
   }
-  computeUpdates(oldData, newData) {
-    if (!oldData || !newData)
-      return null;
-    if (typeof oldData !== "object" || typeof newData !== "object")
+  getSince(entityKey, fromVersion) {
+    const oldestVersion = this.oldestVersionIndex.get(entityKey);
+    const newestVersion = this.newestVersionIndex.get(entityKey);
+    if (oldestVersion === undefined || newestVersion === undefined) {
+      return fromVersion === 0 ? [] : null;
+    }
+    if (fromVersion >= newestVersion) {
+      return [];
+    }
+    if (fromVersion < oldestVersion - 1) {
       return null;
-    const updates = {};
-    const oldObj = oldData;
-    const newObj = newData;
-    for (const key of Object.keys(newObj)) {
-      const oldValue = oldObj[key];
-      const newValue = newObj[key];
-      if (!this.deepEqual(oldValue, newValue)) {
-        updates[key] = createUpdate2(oldValue, newValue);
+    }
+    const indices = this.entityIndex.get(entityKey) ?? [];
+    const result = [];
+    for (const idx of indices) {
+      const entry = this.entries[idx];
+      if (entry && entry.version > fromVersion) {
+        result.push(entry);
+      }
+    }
+    result.sort((a, b) => a.version - b.version);
+    if (result.length > 0) {
+      if (result[0].version !== fromVersion + 1) {
+        return null;
+      }
+      for (let i = 1;i < result.length; i++) {
+        if (result[i].version !== result[i - 1].version + 1) {
+          return null;
+        }
       }
     }
-    return Object.keys(updates).length > 0 ? updates : null;
+    return result;
   }
-  deepEqual(a, b) {
-    if (a === b)
-      return true;
-    if (typeof a !== typeof b)
-      return false;
-    if (typeof a !== "object" || a === null || b === null)
+  hasVersion(entityKey, version) {
+    const oldest = this.oldestVersionIndex.get(entityKey);
+    const newest = this.newestVersionIndex.get(entityKey);
+    if (oldest === undefined || newest === undefined) {
       return false;
-    const aObj = a;
-    const bObj = b;
-    const aKeys = Object.keys(aObj);
-    const bKeys = Object.keys(bObj);
-    if (aKeys.length !== bKeys.length)
-      return false;
-    for (const key of aKeys) {
-      if (!this.deepEqual(aObj[key], bObj[key]))
-        return false;
     }
-    return true;
+    return version >= oldest && version <= newest;
   }
-  clearLoaders() {
-    for (const loader of this.loaders.values()) {
-      loader.clear();
-    }
-    this.loaders.clear();
+  getOldestVersion(entityKey) {
+    return this.oldestVersionIndex.get(entityKey) ?? null;
   }
-}
-function isAsyncIterable(value) {
-  return value !== null && typeof value === "object" && Symbol.asyncIterator in value;
-}
-function createServer(config) {
-  const server = new LensServerImpl(config);
-  return server;
-}
-// src/sse/handler.ts
-class SSEHandler {
-  stateManager;
-  heartbeatInterval;
-  clients = new Map;
-  clientCounter = 0;
-  constructor(config) {
-    this.stateManager = config.stateManager;
-    this.heartbeatInterval = config.heartbeatInterval ?? 30000;
+  getNewestVersion(entityKey) {
+    return this.newestVersionIndex.get(entityKey) ?? null;
   }
-  handleConnection(_req) {
-    const clientId = `sse_${++this.clientCounter}_${Date.now()}`;
-    const encoder = new TextEncoder;
-    const stream = new ReadableStream({
-      start: (controller) => {
-        const stateClient = {
-          id: clientId,
-          send: (msg) => {
-            try {
-              const data = `data: ${JSON.stringify(msg)}
-
-`;
-              controller.enqueue(encoder.encode(data));
-            } catch {
-              this.removeClient(clientId);
-            }
-          }
-        };
-        this.stateManager.addClient(stateClient);
-        controller.enqueue(encoder.encode(`event: connected
-data: ${JSON.stringify({ clientId })}
-
-`));
-        const heartbeat = setInterval(() => {
-          try {
-            controller.enqueue(encoder.encode(`: heartbeat ${Date.now()}
-
-`));
-          } catch {
-            this.removeClient(clientId);
-          }
-        }, this.heartbeatInterval);
-        this.clients.set(clientId, { controller, heartbeat });
-      },
-      cancel: () => {
-        this.removeClient(clientId);
+  getAll(entityKey) {
+    const indices = this.entityIndex.get(entityKey) ?? [];
+    const result = [];
+    for (const idx of indices) {
+      const entry = this.entries[idx];
+      if (entry) {
+        result.push(entry);
       }
-    });
-    return new Response(stream, {
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive",
-        "Access-Control-Allow-Origin": "*"
+    }
+    return result.sort((a, b) => a.version - b.version);
+  }
+  cleanup() {
+    const now = Date.now();
+    let removedCount = 0;
+    const minTimestamp = now - this.config.maxAge;
+    while (this.entries.length > 0 && this.entries[0].timestamp < minTimestamp) {
+      this.removeOldest();
+      removedCount++;
+    }
+    while (this.entries.length > this.config.maxEntries) {
+      this.removeOldest();
+      removedCount++;
+    }
+    while (this.totalMemory > this.config.maxMemory && this.entries.length > 0) {
+      this.removeOldest();
+      removedCount++;
+    }
+    if (removedCount > this.entries.length * 0.1) {
+      this.rebuildIndices();
+    }
+  }
+  removeOldest() {
+    const removed = this.entries.shift();
+    if (!removed)
+      return;
+    this.totalMemory -= removed.patchSize;
+    const indices = this.entityIndex.get(removed.entityKey);
+    if (indices && indices.length > 0) {
+      indices.shift();
+      if (indices.length === 0) {
+        this.entityIndex.delete(removed.entityKey);
+        this.oldestVersionIndex.delete(removed.entityKey);
+        this.newestVersionIndex.delete(removed.entityKey);
+      } else {
+        const nextEntry = this.entries[indices[0] - 1];
+        if (nextEntry) {
+          this.oldestVersionIndex.set(removed.entityKey, nextEntry.version);
+        }
       }
-    });
+    }
   }
-  removeClient(clientId) {
-    const client = this.clients.get(clientId);
-    if (client) {
-      clearInterval(client.heartbeat);
-      this.clients.delete(clientId);
+  rebuildIndices() {
+    this.entityIndex.clear();
+    this.oldestVersionIndex.clear();
+    this.newestVersionIndex.clear();
+    this.totalMemory = 0;
+    for (let i = 0;i < this.entries.length; i++) {
+      const entry = this.entries[i];
+      this.totalMemory += entry.patchSize;
+      let indices = this.entityIndex.get(entry.entityKey);
+      if (!indices) {
+        indices = [];
+        this.entityIndex.set(entry.entityKey, indices);
+        this.oldestVersionIndex.set(entry.entityKey, entry.version);
+      }
+      indices.push(i);
+      this.newestVersionIndex.set(entry.entityKey, entry.version);
     }
-    this.stateManager.removeClient(clientId);
   }
-  closeClient(clientId) {
-    const client = this.clients.get(clientId);
-    if (client) {
-      try {
-        client.controller.close();
-      } catch {}
-      this.removeClient(clientId);
+  checkLimits() {
+    const needsCleanup = this.entries.length > this.config.maxEntries || this.totalMemory > this.config.maxMemory;
+    if (needsCleanup) {
+      this.cleanup();
     }
   }
-  getClientCount() {
-    return this.clients.size;
+  getStats() {
+    return {
+      entryCount: this.entries.length,
+      entityCount: this.entityIndex.size,
+      memoryUsage: this.totalMemory,
+      oldestTimestamp: this.entries[0]?.timestamp ?? null,
+      newestTimestamp: this.entries[this.entries.length - 1]?.timestamp ?? null,
+      config: { ...this.config }
+    };
   }
-  getClientIds() {
-    return Array.from(this.clients.keys());
+  clear() {
+    this.entries = [];
+    this.entityIndex.clear();
+    this.oldestVersionIndex.clear();
+    this.newestVersionIndex.clear();
+    this.totalMemory = 0;
   }
-  closeAll() {
-    for (const clientId of this.clients.keys()) {
-      this.closeClient(clientId);
+  dispose() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    this.clear();
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
     }
+    if (this.config.cleanupInterval > 0) {
+      this.cleanupTimer = setInterval(() => this.cleanup(), this.config.cleanupInterval);
+    }
+    this.cleanup();
   }
 }
-function createSSEHandler(config) {
-  return new SSEHandler(config);
+function coalescePatches(patches) {
+  const flatPatches = patches.flat();
+  const pathMap = new Map;
+  for (const op of flatPatches) {
+    const existing = pathMap.get(op.path);
+    if (!existing) {
+      pathMap.set(op.path, op);
+      continue;
+    }
+    switch (op.op) {
+      case "replace":
+      case "add":
+        pathMap.set(op.path, op);
+        break;
+      case "remove":
+        pathMap.set(op.path, op);
+        break;
+      case "move":
+      case "copy":
+        pathMap.set(op.path, op);
+        break;
+      case "test":
+        break;
+    }
+  }
+  const result = Array.from(pathMap.values());
+  result.sort((a, b) => {
+    const depthA = a.path.split("/").length;
+    const depthB = b.path.split("/").length;
+    if (depthA !== depthB)
+      return depthA - depthB;
+    return a.path.localeCompare(b.path);
+  });
+  return result;
+}
+function estimatePatchSize(patch) {
+  return JSON.stringify(patch).length;
 }
 export {
+  useContext,
+  tryUseContext,
+  runWithContextAsync,
+  runWithContext,
   router,
   query,
+  optimisticPlugin,
+  opLog,
   mutation,
-  createServer,
+  memoryStorage,
+  isOptimisticPlugin,
+  isOpLogPlugin,
+  hasContext,
+  handleWebSSE,
+  handleWebQuery,
+  handleWebMutation,
+  extendContext,
+  estimatePatchSize,
+  createWSHandler,
+  createServerClientProxy,
   createSSEHandler,
-  createGraphStateManager,
+  createPluginManager,
+  createHandler,
+  createHTTPHandler,
+  createFrameworkHandler,
+  createContext,
+  createApp,
+  coalescePatches,
   SSEHandler,
-  GraphStateManager
+  PluginManager,
+  OperationLog,
+  DEFAULT_STORAGE_CONFIG
 };