@sylphx/lens-solid 2.3.13 → 2.3.14

package/dist/index.d.ts

@@ -25,6 +25,5 @@
  * ```
  */
 export { createClient, type MutationEndpoint, type MutationPrimitiveOptions, type MutationPrimitiveResult, type QueryEndpoint, type QueryPrimitiveOptions, type QueryPrimitiveResult, type TypedClient, } from "./create.js";
-export { LensProvider, type LensProviderProps, useLensClient } from "./context.js";
 export { type CreateLazyQueryResult, type CreateMutationResult, type CreateQueryOptions, type CreateQueryResult, createLazyQuery, createMutation, createQuery, type MutationFn, type QueryInput, } from "./primitives.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAMH,OAAO,EACN,YAAY,EACZ,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,WAAW,GAChB,MAAM,aAAa,CAAC;AAMrB,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAMnF,OAAO,EACN,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,eAAe,EAEf,cAAc,EAEd,WAAW,EACX,KAAK,UAAU,EAEf,KAAK,UAAU,GACf,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EACN,YAAY,EACZ,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,WAAW,GAChB,MAAM,aAAa,CAAC;AAErB,OAAO,EACN,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,eAAe,EACf,cAAc,EACd,WAAW,EACX,KAAK,UAAU,EACf,KAAK,UAAU,GACf,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -3,465 +3,9 @@ var DSL_MARKER = Symbol("reify");
 // ../../node_modules/.bun/@sylphx+reify-core@0.1.2/node_modules/@sylphx/reify-core/dist/evaluator.js
 var plugins = new Map;
 // ../core/dist/index.js
-class FieldType {
-  _nullable = false;
-  _optional = false;
-  _default;
-  _resolutionMode = "exposed";
-  _resolver;
-  _subscriptionResolver;
-  nullable() {
-    const clone = Object.create(this);
-    clone._nullable = true;
-    return clone;
-  }
-  optional() {
-    const clone = Object.create(this);
-    clone._optional = true;
-    return clone;
-  }
-  default(value) {
-    const clone = Object.create(this);
-    clone._default = value;
-    return clone;
-  }
-  isNullable() {
-    return this._nullable;
-  }
-  isOptional() {
-    return this._optional;
-  }
-  getDefault() {
-    return this._default;
-  }
-  serialize(value) {
-    return value;
-  }
-  deserialize(value) {
-    return value;
-  }
-  resolve(fn) {
-    const clone = Object.create(this);
-    clone._resolutionMode = "resolve";
-    clone._resolver = fn;
-    return clone;
-  }
-  subscribe(fn) {
-    const clone = Object.create(this);
-    clone._resolutionMode = "subscribe";
-    clone._subscriptionResolver = fn;
-    return clone;
-  }
-  hasResolver() {
-    return this._resolutionMode === "resolve" && this._resolver !== undefined;
-  }
-  hasSubscription() {
-    return this._resolutionMode === "subscribe" && this._subscriptionResolver !== undefined;
-  }
-  getResolutionMode() {
-    return this._resolutionMode;
-  }
-}
-
-class IdType extends FieldType {
-  _type = "id";
-  _tsType;
-}
-
-class StringType extends FieldType {
-  _type = "string";
-  _tsType;
-}
-
-class IntType extends FieldType {
-  _type = "int";
-  _tsType;
-}
-
-class FloatType extends FieldType {
-  _type = "float";
-  _tsType;
-}
-
-class BooleanType extends FieldType {
-  _type = "boolean";
-  _tsType;
-}
-
-class DateTimeType extends FieldType {
-  _type = "datetime";
-  _tsType;
-  serialize(value) {
-    if (!(value instanceof Date)) {
-      throw new Error(`Expected Date instance, got ${typeof value}`);
-    }
-    return value.toISOString();
-  }
-  deserialize(value) {
-    if (typeof value !== "string") {
-      throw new Error(`Expected string, got ${typeof value}`);
-    }
-    const date = new Date(value);
-    if (Number.isNaN(date.getTime())) {
-      throw new Error(`Invalid date string: ${value}`);
-    }
-    return date;
-  }
-  validate(value) {
-    return value instanceof Date && !Number.isNaN(value.getTime());
-  }
-}
-
-class TimestampType extends FieldType {
-  _type = "timestamp";
-  _tsType;
-  validate(value) {
-    return typeof value === "number" && !Number.isNaN(value) && Number.isFinite(value);
-  }
-}
-
-class DecimalType extends FieldType {
-  _type = "decimal";
-  _tsType;
-  serialize(value) {
-    if (typeof value !== "number" || Number.isNaN(value)) {
-      throw new Error(`Expected number, got ${typeof value}`);
-    }
-    return value.toString();
-  }
-  deserialize(value) {
-    if (typeof value !== "string") {
-      throw new Error(`Expected string, got ${typeof value}`);
-    }
-    const num = Number.parseFloat(value);
-    if (Number.isNaN(num)) {
-      throw new Error(`Invalid decimal string: ${value}`);
-    }
-    return num;
-  }
-  validate(value) {
-    return typeof value === "number" && !Number.isNaN(value) && Number.isFinite(value);
-  }
-}
-
-class DateType extends FieldType {
-  _type = "date";
-  _tsType;
-  serialize(value) {
-    if (!(value instanceof Date)) {
-      throw new Error(`Expected Date instance, got ${typeof value}`);
-    }
-    return value.toISOString().split("T")[0];
-  }
-  deserialize(value) {
-    if (typeof value !== "string") {
-      throw new Error(`Expected string, got ${typeof value}`);
-    }
-    const date = new Date(`${value}T00:00:00.000Z`);
-    if (Number.isNaN(date.getTime())) {
-      throw new Error(`Invalid date string: ${value}`);
-    }
-    return date;
-  }
-  validate(value) {
-    return value instanceof Date && !Number.isNaN(value.getTime());
-  }
-}
-
-class BigIntType extends FieldType {
-  _type = "bigint";
-  _tsType;
-  serialize(value) {
-    if (typeof value !== "bigint") {
-      throw new Error(`Expected bigint, got ${typeof value}`);
-    }
-    return value.toString();
-  }
-  deserialize(value) {
-    if (typeof value !== "string") {
-      throw new Error(`Expected string, got ${typeof value}`);
-    }
-    try {
-      return BigInt(value);
-    } catch {
-      throw new Error(`Invalid bigint string: ${value}`);
-    }
-  }
-  validate(value) {
-    return typeof value === "bigint";
-  }
-}
-
-class BytesType extends FieldType {
-  _type = "bytes";
-  _tsType;
-  serialize(value) {
-    if (!(value instanceof Uint8Array)) {
-      throw new Error(`Expected Uint8Array, got ${typeof value}`);
-    }
-    if (typeof btoa === "function") {
-      return btoa(String.fromCharCode(...value));
-    }
-    return Buffer.from(value).toString("base64");
-  }
-  deserialize(value) {
-    if (typeof value !== "string") {
-      throw new Error(`Expected string, got ${typeof value}`);
-    }
-    if (typeof atob === "function") {
-      const binary = atob(value);
-      const bytes = new Uint8Array(binary.length);
-      for (let i = 0;i < binary.length; i++) {
-        bytes[i] = binary.charCodeAt(i);
-      }
-      return bytes;
-    }
-    return new Uint8Array(Buffer.from(value, "base64"));
-  }
-  validate(value) {
-    return value instanceof Uint8Array;
-  }
-}
-
-class JsonType extends FieldType {
-  _type = "json";
-  _tsType;
-  serialize(value) {
-    return value;
-  }
-  deserialize(value) {
-    return value;
-  }
-}
-
-class EnumType extends FieldType {
-  values;
-  _type = "enum";
-  _tsType;
-  constructor(values) {
-    super();
-    this.values = values;
-  }
-}
-
-class ObjectType extends FieldType {
-  _type = "object";
-  _tsType;
-}
-
-class ArrayType extends FieldType {
-  itemType;
-  _type = "array";
-  _tsType;
-  constructor(itemType) {
-    super();
-    this.itemType = itemType;
-  }
-}
-
-class ScalarType extends FieldType {
-  definition;
-  _type = "scalar";
-  _tsType;
-  constructor(definition) {
-    super();
-    this.definition = definition;
-  }
-  serialize(value) {
-    if (this.definition.validate && !this.definition.validate(value)) {
-      throw new Error(`Validation failed for scalar type: ${this.definition.name}`);
-    }
-    return this.definition.serialize(value);
-  }
-  deserialize(value) {
-    return this.definition.deserialize(value);
-  }
-  validate(value) {
-    return this.definition.validate ? this.definition.validate(value) : true;
-  }
-}
-var CustomType = ScalarType;
-
-class HasOneType extends FieldType {
-  target;
-  foreignKey;
-  _type = "hasOne";
-  _tsType;
-  _relationKind = "hasOne";
-  constructor(target, foreignKey) {
-    super();
-    this.target = target;
-    this.foreignKey = foreignKey;
-  }
-}
-
-class HasManyType extends FieldType {
-  target;
-  foreignKey;
-  _type = "hasMany";
-  _tsType;
-  _relationKind = "hasMany";
-  constructor(target, foreignKey) {
-    super();
-    this.target = target;
-    this.foreignKey = foreignKey;
-  }
-}
-
-class BelongsToType extends FieldType {
-  target;
-  foreignKey;
-  _type = "belongsTo";
-  _tsType;
-  _relationKind = "belongsTo";
-  constructor(target, foreignKey) {
-    super();
-    this.target = target;
-    this.foreignKey = foreignKey;
-  }
-}
-
-class LazyOneType extends FieldType {
-  targetRef;
-  _type = "lazyOne";
-  _tsType;
-  _relationKind = "one";
-  constructor(targetRef) {
-    super();
-    this.targetRef = targetRef;
-  }
-  getTarget() {
-    return this.targetRef();
-  }
-}
-
-class LazyManyType extends FieldType {
-  targetRef;
-  _type = "lazyMany";
-  _tsType;
-  _relationKind = "many";
-  constructor(targetRef) {
-    super();
-    this.targetRef = targetRef;
-  }
-  getTarget() {
-    return this.targetRef();
-  }
-}
-var t = {
-  id: () => new IdType,
-  string: () => new StringType,
-  int: () => new IntType,
-  float: () => new FloatType,
-  boolean: () => new BooleanType,
-  datetime: () => new DateTimeType,
-  timestamp: () => new TimestampType,
-  date: () => new DateType,
-  decimal: () => new DecimalType,
-  bigint: () => new BigIntType,
-  bytes: () => new BytesType,
-  json: () => new JsonType,
-  enum: (values) => new EnumType(values),
-  object: () => new ObjectType,
-  array: (itemType) => new ArrayType(itemType),
-  custom: (definition) => new CustomType(definition),
-  hasOne: (target) => new HasOneType(target),
-  hasMany: (target) => new HasManyType(target),
-  belongsTo: (target) => new BelongsToType(target),
-  one: (targetRef) => new LazyOneType(targetRef),
-  many: (targetRef) => new LazyManyType(targetRef)
-};
-function createContextualField(field) {
-  const wrapper = {
-    field,
-    resolve(fn) {
-      return field.resolve(fn);
-    },
-    subscribe(fn) {
-      return field.subscribe(fn);
-    },
-    nullable() {
-      return createContextualField(field.nullable());
-    },
-    optional() {
-      return createContextualField(field.optional());
-    },
-    default(value) {
-      return createContextualField(field.default(value));
-    }
-  };
-  return Object.assign(Object.create(field), wrapper);
-}
-function createTypeBuilder() {
-  return {
-    id: () => createContextualField(new IdType),
-    string: () => createContextualField(new StringType),
-    int: () => createContextualField(new IntType),
-    float: () => createContextualField(new FloatType),
-    boolean: () => createContextualField(new BooleanType),
-    datetime: () => createContextualField(new DateTimeType),
-    timestamp: () => createContextualField(new TimestampType),
-    date: () => createContextualField(new DateType),
-    decimal: () => createContextualField(new DecimalType),
-    bigint: () => createContextualField(new BigIntType),
-    bytes: () => createContextualField(new BytesType),
-    json: () => createContextualField(new ObjectType),
-    enum: (values) => createContextualField(new EnumType(values)),
-    object: () => createContextualField(new ObjectType),
-    array: (itemType) => createContextualField(new ArrayType(itemType)),
-    custom: (definition) => createContextualField(new CustomType(definition)),
-    hasOne: (target) => createContextualField(new HasOneType(target)),
-    hasMany: (target) => createContextualField(new HasManyType(target)),
-    belongsTo: (target) => createContextualField(new BelongsToType(target)),
-    one: (targetRef) => createContextualField(new LazyOneType(targetRef)),
-    many: (targetRef) => createContextualField(new LazyManyType(targetRef))
-  };
-}
+var MODEL_SYMBOL = Symbol("lens:model");
 var LIST_SYMBOL = Symbol("lens:list");
 var NULLABLE_SYMBOL = Symbol("lens:nullable");
-var MODEL_SYMBOL = Symbol("lens:model");
-var ENTITY_SYMBOL = Symbol("lens:entity");
-function defineEntity(nameOrFields, maybeFieldsOrBuilder) {
-  if (typeof nameOrFields === "object" && maybeFieldsOrBuilder === undefined) {
-    const fields2 = nameOrFields;
-    return createEntityDef(undefined, fields2);
-  }
-  const name = nameOrFields;
-  if (maybeFieldsOrBuilder === undefined) {
-    return new EntityBuilder_(name);
-  }
-  if (typeof maybeFieldsOrBuilder === "function") {
-    const builder = maybeFieldsOrBuilder;
-    const fields2 = builder(t);
-    return createEntityDef(name, fields2);
-  }
-  const fields = maybeFieldsOrBuilder;
-  return createEntityDef(name, fields);
-}
-function createEntityDef(name, fields) {
-  return {
-    [ENTITY_SYMBOL]: true,
-    _name: name,
-    fields,
-    "~entity": {
-      name,
-      type: undefined
-    }
-  };
-}
-var entity2 = Object.assign(defineEntity, (name) => new EntityBuilder_(name));
-
-class EntityBuilder_ {
-  _name;
-  constructor(_name) {
-    this._name = _name;
-  }
-  define(builder) {
-    const contextualBuilder = createTypeBuilder();
-    const fields = builder(contextualBuilder);
-    return createEntityDef(this._name, fields);
-  }
-}
 var valueStrategy = {
   name: "value",
   encode(_prev, next) {
@@ -1099,8 +643,8 @@ class SubscriptionRegistry {
       }
     }
   }
-  getByEntity(entity22, entityId) {
-    const entityKey = `${entity22}:${entityId}`;
+  getByEntity(entity2, entityId) {
+    const entityKey = `${entity2}:${entityId}`;
     const ids = this.entityIndex.get(entityKey);
     if (!ids)
       return [];
@@ -1317,10 +861,17 @@ function applyOp(state, op2) {
       return state;
   }
 }
+var FORBIDDEN_PATH_SEGMENTS = new Set(["__proto__", "constructor", "prototype"]);
 function parsePath(path) {
   if (!path)
     return [];
-  return path.split(".");
+  const segments = path.split(".");
+  for (const segment of segments) {
+    if (FORBIDDEN_PATH_SEGMENTS.has(segment)) {
+      throw new Error(`Forbidden path segment: "${segment}" - potential prototype pollution attack`);
+    }
+  }
+  return segments;
 }
 function getAtPath(state, path) {
   const segments = parsePath(path);
@@ -1385,6 +936,12 @@ function updateAtPath(state, segments, transform) {
   if (Array.isArray(state)) {
     const result = [...state];
     const idx = parseInt(head, 10);
+    if (Number.isNaN(idx) || idx < 0) {
+      return {
+        ...Object.fromEntries(state.map((v, i) => [String(i), v])),
+        [head]: updateAtPath(undefined, tail, transform)
+      };
+    }
     result[idx] = updateAtPath(result[idx], tail, transform);
     return result;
   }
@@ -1787,6 +1344,15 @@ function filterToSelection(data, selection) {
   }
   return result;
 }
+function isQueryCapable(t) {
+  return "query" in t && typeof t.query === "function";
+}
+function isMutationCapable(t) {
+  return "mutation" in t && typeof t.mutation === "function";
+}
+function isSubscriptionCapable(t) {
+  return "subscription" in t && typeof t.subscription === "function";
+}
 function hasAnySubscription(entities, entityName, select, visited = new Set) {
   if (!entities)
     return false;
@@ -1859,7 +1425,16 @@ class ClientImpl {
         processedOp = await plugin.beforeRequest(processedOp);
       }
     }
-    const resultOrObservable = this.transport.execute(processedOp);
+    let resultOrObservable;
+    if (processedOp.type === "mutation" && isMutationCapable(this.transport)) {
+      resultOrObservable = this.transport.mutation(processedOp);
+    } else if (processedOp.type === "subscription" && isSubscriptionCapable(this.transport)) {
+      resultOrObservable = this.transport.subscription(processedOp);
+    } else if (isQueryCapable(this.transport)) {
+      resultOrObservable = this.transport.query(processedOp);
+    } else {
+      throw new Error(`Transport does not support ${processedOp.type} operations`);
+    }
     let result;
     if (this.isObservable(resultOrObservable)) {
       result = await this.firstValueFrom(resultOrObservable);
@@ -1937,6 +1512,8 @@ class ClientImpl {
       return false;
     if (meta.type === "subscription")
       return true;
+    if (meta.live)
+      return true;
     if (meta.type === "query" && meta.returnType && this.metadata?.entities) {
       return hasAnySubscription(this.metadata.entities, meta.returnType, select);
     }
@@ -2241,13 +1818,17 @@ class ClientImpl {
         input,
         meta: endpoint.mergedSelection ? { select: endpoint.mergedSelection } : {}
       };
-      const resultOrObservable = this.transport.execute(op2);
+      const resultOrObservable = isSubscriptionCapable(this.transport) ? this.transport.subscription(op2) : isQueryCapable(this.transport) ? this.transport.query(op2) : Promise.reject(new Error("Transport does not support subscriptions"));
       if (this.isObservable(resultOrObservable)) {
         const subscription = resultOrObservable.subscribe({
           next: (message) => {
             if (isSnapshot(message)) {
               this.distributeData(endpoint, message.data);
             } else if (isOps(message)) {
+              if (endpoint.data === null || endpoint.data === undefined) {
+                console.warn(`[Lens] Received ops message before snapshot for ${path}. Skipping update.`);
+                return;
+              }
               try {
                 const newData = applyOps(endpoint.data, message.ops);
                 this.distributeData(endpoint, newData);
@@ -2301,13 +1882,19 @@ class ClientImpl {
     if (isSnapshot(response)) {
       return { data: response.data };
     }
-    return { data: null };
+    throw new Error(`Mutation received unexpected message type: ${response.$}. Mutations should return snapshot.`);
   }
   createAccessor(path) {
     return (descriptor) => {
-      const isNewApi = descriptor === undefined || descriptor === null || typeof descriptor === "object" && descriptor !== null && (("input" in descriptor) || ("select" in descriptor));
-      const input = isNewApi ? descriptor?.input : descriptor;
-      const select = isNewApi ? descriptor?.select : undefined;
+      let input;
+      let select;
+      if (descriptor && typeof descriptor === "object" && (("input" in descriptor) || ("select" in descriptor))) {
+        input = descriptor.input;
+        select = descriptor.select;
+      } else {
+        input = descriptor;
+        select = undefined;
+      }
       const queryResult = this.executeQuery(path, input, select);
       const originalThen = queryResult.then.bind(queryResult);
       queryResult.then = async (onfulfilled, onrejected) => {
@@ -2384,15 +1971,17 @@ var http = function http2(options) {
       }
       return response.json();
     },
-    execute(op2) {
-      if (op2.type === "subscription") {
-        return createPollingObservable(baseUrl, op2, {
-          interval: pollInterval,
-          maxRetries,
-          headers: defaultHeaders,
-          fetch: fetchImpl
-        });
-      }
+    query(op2) {
+      return executeRequest(baseUrl, op2, {
+        headers: {
+          ...defaultHeaders,
+          ...op2.meta?.headers ?? {}
+        },
+        fetch: fetchImpl,
+        timeout: op2.meta?.timeout
+      });
+    },
+    mutation(op2) {
       return executeRequest(baseUrl, op2, {
         headers: {
           ...defaultHeaders,
@@ -2401,6 +1990,14 @@ var http = function http2(options) {
         fetch: fetchImpl,
         timeout: op2.meta?.timeout
       });
+    },
+    subscription(op2) {
+      return createPollingObservable(baseUrl, op2, {
+        interval: pollInterval,
+        maxRetries,
+        headers: defaultHeaders,
+        fetch: fetchImpl
+      });
     }
   };
 };
@@ -2499,6 +2096,18 @@ function createPollingObservable(baseUrl, op2, options) {
     }
   };
 }
+function firstValueFromServer(observable) {
+  return new Promise((resolve, reject) => {
+    let subscription;
+    subscription = observable.subscribe({
+      next: (value) => {
+        subscription?.unsubscribe?.();
+        resolve(value);
+      },
+      error: reject
+    });
+  });
+}
 http.server = function httpServer(options) {
   const { port, path = "", hostname = "0.0.0.0" } = options;
   return {
@@ -2515,7 +2124,7 @@ http.server = function httpServer(options) {
           if (url.pathname === basePath && req.method === "POST") {
             try {
               const body = await req.json();
-              const result = await server.execute(body);
+              const result = await firstValueFromServer(server.execute(body));
               return Response.json(result);
             } catch (error) {
               return Response.json({ error: { message: error.message } }, { status: 500 });
@@ -2695,8 +2304,8 @@ class SubscriptionRegistry2 {
       }
     }
   }
-  getByEntity(entity3, entityId) {
-    const entityKey = `${entity3}:${entityId}`;
+  getByEntity(entity2, entityId) {
+    const entityKey = `${entity2}:${entityId}`;
     const ids = this.entityIndex.get(entityKey);
     if (!ids)
       return [];
@@ -3025,21 +2634,6 @@ function createClient2(config) {
   }
   return createProxy("");
 }
-// src/context.tsx
-import { createContext, useContext } from "solid-js";
-var LensClientContext = createContext();
-var LensProvider = (props) => {
-  return /* @__PURE__ */ React.createElement(LensClientContext.Provider, {
-    value: props.client
-  }, props.children);
-};
-function useLensClient() {
-  const client = useContext(LensClientContext);
-  if (!client) {
-    throw new Error("useLensClient must be used within a <LensProvider>. " + "Make sure to wrap your app with <LensProvider client={client}>.");
-  }
-  return client;
-}
 // src/primitives.ts
 import { createEffect as createEffect2, createSignal as createSignal2, onCleanup as onCleanup2 } from "solid-js";
 function resolveQuery(input) {
@@ -3194,10 +2788,8 @@ function createLazyQuery(queryInput) {
   };
 }
 export {
-  useLensClient,
   createQuery,
   createMutation,
   createLazyQuery,
-  createClient2 as createClient,
-  LensProvider
+  createClient2 as createClient
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/lens-solid",
-	"version": "2.3.13",
+	"version": "2.3.14",
 	"description": "SolidJS bindings for Lens API framework",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -31,8 +31,8 @@
 	"author": "SylphxAI",
 	"license": "MIT",
 	"dependencies": {
-		"@sylphx/lens-client": "^2.7.8",
-		"@sylphx/lens-core": "^3.0.1"
+		"@sylphx/lens-client": "^3.0.0",
+		"@sylphx/lens-core": "^4.0.1"
 	},
 	"peerDependencies": {
 		"solid-js": ">=1.8.0"

package/src/index.ts

@@ -25,10 +25,6 @@
  * ```
  */
 
-// =============================================================================
-// New API (v4) - Recommended
-// =============================================================================
-
 export {
 	createClient,
 	type MutationEndpoint,
@@ -40,27 +36,14 @@ export {
 	type TypedClient,
 } from "./create.js";
 
-// =============================================================================
-// Legacy API (v3) - Deprecated
-// =============================================================================
-
-export { LensProvider, type LensProviderProps, useLensClient } from "./context.js";
-
-// =============================================================================
-// Reactive Primitives
-// =============================================================================
-
 export {
 	type CreateLazyQueryResult,
 	type CreateMutationResult,
 	type CreateQueryOptions,
 	type CreateQueryResult,
 	createLazyQuery,
-	// Mutation primitive
 	createMutation,
-	// Query primitives
 	createQuery,
 	type MutationFn,
-	// Types
 	type QueryInput,
 } from "./primitives.js";