@valkey/valkey-glide 2.3.1 → 2.4.0-rc2

package/build-ts/index.d.ts

@@ -8,8 +8,11 @@
 export * from "../build-ts/native";
 export * from "./BaseClient.js";
 export * from "./Batch.js";
+export * from "./ClientSideCache.js";
 export * from "./Commands.js";
+export * from "./CompressionConfiguration.js";
 export * from "./Errors.js";
+export * from "./EvictionPolicy.js";
 export * from "./GlideClient.js";
 export * from "./GlideClusterClient.js";
 export * from "./Logger.js";

package/build-ts/index.js

@@ -25,8 +25,11 @@ __exportStar(require("../build-ts/native"), exports);
 // Export TypeScript APIs
 __exportStar(require("./BaseClient.js"), exports);
 __exportStar(require("./Batch.js"), exports);
+__exportStar(require("./ClientSideCache.js"), exports);
 __exportStar(require("./Commands.js"), exports);
+__exportStar(require("./CompressionConfiguration.js"), exports);
 __exportStar(require("./Errors.js"), exports);
+__exportStar(require("./EvictionPolicy.js"), exports);
 __exportStar(require("./GlideClient.js"), exports);
 __exportStar(require("./GlideClusterClient.js"), exports);
 __exportStar(require("./Logger.js"), exports);

package/build-ts/server-modules/GlideFt.d.ts

@@ -1,7 +1,7 @@
 /**
  * Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
  */
-import { DecoderOption, GlideRecord, GlideReturnType, GlideString, GlideClient, GlideClusterClient, Field, FtAggregateOptions, FtCreateOptions, FtSearchOptions } from "..";
+import { DecoderOption, GlideRecord, GlideReturnType, GlideString, GlideClient, GlideClusterClient, Field, FtAggregateOptions, FtCreateOptions, FtInfoOptions, FtSearchOptions } from "..";
 /** Response type of {@link GlideFt.info | ft.info} command. */
 export type FtInfoReturnType = Record<string, GlideString | number | GlideString[] | Record<string, GlideString | Record<string, GlideString | number>[]>>;
 /**
@@ -44,6 +44,26 @@ export declare class GlideFt {
      *      dataType: "JSON",
      *      prefixes: ["json:"]
      *  });
+     *
+     * // Create a text search index with all options:
+     * // Note: noStopWords/stopWords are mutually exclusive;
+     * // withOffsets/noOffsets are mutually exclusive.
+     * await GlideFt.create(client, "text_idx", [
+     *     { type: "TEXT", name: "title", sortable: true, nostem: true, weight: 2.0,
+     *       withsuffixtrie: true },
+     *     { type: "NUMERIC", name: "price", sortable: true },
+     *     { type: "TAG", name: "category", sortable: true },
+     * ], {
+     *     dataType: "HASH",
+     *     prefixes: ["product:"],
+     *     score: 1.0,
+     *     language: "english",
+     *     skipInitialScan: true,
+     *     minStemSize: 4,
+     *     withOffsets: true,
+     *     stopWords: ["the", "a", "is"],
+     *     punctuation: ".,;!?",
+     * });
      * ```
      */
     static create(client: GlideClient | GlideClusterClient, indexName: GlideString, schema: Field[], options?: FtCreateOptions): Promise<"OK">;
@@ -135,6 +155,10 @@ export declare class GlideFt {
      * //         }
      * //     ]
      * // ]
+     *
+     * // Aggregate with all query flags:
+     * const result12 = await GlideFt.aggregate(client, "myIndex", "@score:[20 +inf]",
+     *     { loadAll: true, verbatim: true, inorder: true, slop: 1, dialect: 2 });
      * ```
      */
     static aggregate(client: GlideClient | GlideClusterClient, indexName: GlideString, query: GlideString, options?: DecoderOption & FtAggregateOptions): Promise<FtAggregateReturnType>;
@@ -187,9 +211,19 @@ export declare class GlideFt {
      * //         },
      * //     ]
      * // }
+     *
+     * // Get info with scope options:
+     * const localInfo = await GlideFt.info(client, "myIndex", { scope: "LOCAL" });
+     *
+     * // Get cluster-wide info (requires coordinator):
+     * const clusterInfo = await GlideFt.info(client, "myIndex", {
+     *     scope: "PRIMARY",
+     *     shardScope: "ALLSHARDS",
+     *     consistency: "CONSISTENT",
+     * });
      * ```
      */
-    static info(client: GlideClient | GlideClusterClient, indexName: GlideString, options?: DecoderOption): Promise<FtInfoReturnType>;
+    static info(client: GlideClient | GlideClusterClient, indexName: GlideString, options?: DecoderOption & FtInfoOptions): Promise<FtInfoReturnType>;
     /**
      * Parse a query and return information about how that query was parsed.
      *
@@ -237,6 +271,7 @@ export declare class GlideFt {
      * @returns A two-element array, where the first element is the number of documents in the result set, and the
      * second element has the format: `GlideRecord<GlideRecord<GlideString>>`:
      * a mapping between document names and a map of their attributes.
+     * When `nocontent` is set, the attribute maps will be empty.
      *
      * If `count` or `limit` with values `{offset: 0, count: 0}` is
      * set, the command returns array with only one element: the number of documents.
@@ -278,6 +313,20 @@ export declare class GlideFt {
      * //     },
      * //   ],
      * // ]
+     *
+     * // Text search with all options:
+     * // Note: withSortKeys requires sortby; shardScope/consistency are cluster-mode options.
+     * const textResult = await GlideFt.search(client, "myIndex", "hello world", {
+     *     verbatim: true,
+     *     inorder: true,
+     *     slop: 1,
+     *     sortby: "price",
+     *     sortbyOrder: SortOrder.ASC,
+     *     withsortkeys: true,
+     *     shardScope: "ALLSHARDS",
+     *     consistency: "CONSISTENT",
+     *     dialect: 2,
+     * });
      * ```
      */
     static search(client: GlideClient | GlideClusterClient, indexName: GlideString, query: GlideString, options?: FtSearchOptions & DecoderOption): Promise<FtSearchReturnType>;

package/build-ts/server-modules/GlideFt.js

@@ -34,6 +34,26 @@ class GlideFt {
      *      dataType: "JSON",
      *      prefixes: ["json:"]
      *  });
+     *
+     * // Create a text search index with all options:
+     * // Note: noStopWords/stopWords are mutually exclusive;
+     * // withOffsets/noOffsets are mutually exclusive.
+     * await GlideFt.create(client, "text_idx", [
+     *     { type: "TEXT", name: "title", sortable: true, nostem: true, weight: 2.0,
+     *       withsuffixtrie: true },
+     *     { type: "NUMERIC", name: "price", sortable: true },
+     *     { type: "TAG", name: "category", sortable: true },
+     * ], {
+     *     dataType: "HASH",
+     *     prefixes: ["product:"],
+     *     score: 1.0,
+     *     language: "english",
+     *     skipInitialScan: true,
+     *     minStemSize: 4,
+     *     withOffsets: true,
+     *     stopWords: ["the", "a", "is"],
+     *     punctuation: ".,;!?",
+     * });
      * ```
      */
     static async create(client, indexName, schema, options) {
@@ -45,6 +65,39 @@ class GlideFt {
             if ("prefixes" in options && options.prefixes) {
                 args.push("PREFIX", options.prefixes.length.toString(), ...options.prefixes);
             }
+            if (options.score !== undefined) {
+                args.push("SCORE", options.score.toString());
+            }
+            if (options.language) {
+                args.push("LANGUAGE", options.language);
+            }
+            if (options.skipInitialScan) {
+                args.push("SKIPINITIALSCAN");
+            }
+            if (options.minStemSize !== undefined) {
+                args.push("MINSTEMSIZE", options.minStemSize.toString());
+            }
+            if (options.withOffsets && options.noOffsets) {
+                throw new Error("withOffsets and noOffsets are mutually exclusive.");
+            }
+            if (options.noStopWords && options.stopWords) {
+                throw new Error("noStopWords and stopWords are mutually exclusive.");
+            }
+            if (options.withOffsets) {
+                args.push("WITHOFFSETS");
+            }
+            else if (options.noOffsets) {
+                args.push("NOOFFSETS");
+            }
+            if (options.noStopWords) {
+                args.push("NOSTOPWORDS");
+            }
+            else if (options.stopWords) {
+                args.push("STOPWORDS", options.stopWords.length.toString(), ...options.stopWords);
+            }
+            if (options.punctuation) {
+                args.push("PUNCTUATION", options.punctuation);
+            }
         }
         args.push("SCHEMA");
         schema.forEach((f) => {
@@ -54,6 +107,24 @@ class GlideFt {
             }
             args.push(f.type);
             switch (f.type) {
+                case "TEXT": {
+                    if (f.nostem) {
+                        args.push("NOSTEM");
+                    }
+                    if (f.weight !== undefined) {
+                        args.push("WEIGHT", f.weight.toString());
+                    }
+                    if (f.withsuffixtrie) {
+                        args.push("WITHSUFFIXTRIE");
+                    }
+                    else if (f.nosuffixtrie) {
+                        args.push("NOSUFFIXTRIE");
+                    }
+                    if (f.sortable) {
+                        args.push("SORTABLE");
+                    }
+                    break;
+                }
                 case "TAG": {
                     if (f.separator) {
                         args.push("SEPARATOR", f.separator);
@@ -61,6 +132,15 @@ class GlideFt {
                     if (f.caseSensitive) {
                         args.push("CASESENSITIVE");
                     }
+                    if (f.sortable) {
+                        args.push("SORTABLE");
+                    }
+                    break;
+                }
+                case "NUMERIC": {
+                    if (f.sortable) {
+                        args.push("SORTABLE");
+                    }
                     break;
                 }
                 case "VECTOR": {
@@ -84,16 +164,17 @@ class GlideFt {
                             attributes.push("INITIAL_CAP", f.attributes.initialCap.toString());
                         }
                         // VectorFieldAttributesHnsw attributes
-                        if ("m" in f.attributes && f.attributes.m) {
-                            attributes.push("M", f.attributes.m.toString());
+                        if ("numberOfEdges" in f.attributes &&
+                            f.attributes.numberOfEdges) {
+                            attributes.push("M", f.attributes.numberOfEdges.toString());
                         }
-                        if ("efContruction" in f.attributes &&
-                            f.attributes.efContruction) {
-                            attributes.push("EF_CONSTRUCTION", f.attributes.efContruction.toString());
+                        if ("vectorsExaminedOnConstruction" in f.attributes &&
+                            f.attributes.vectorsExaminedOnConstruction) {
+                            attributes.push("EF_CONSTRUCTION", f.attributes.vectorsExaminedOnConstruction.toString());
                         }
-                        if ("efRuntime" in f.attributes &&
-                            f.attributes.efRuntime) {
-                            attributes.push("EF_RUNTIME", f.attributes.efRuntime.toString());
+                        if ("vectorsExaminedOnRuntime" in f.attributes &&
+                            f.attributes.vectorsExaminedOnRuntime) {
+                            attributes.push("EF_RUNTIME", f.attributes.vectorsExaminedOnRuntime.toString());
                         }
                         args.push(attributes.length.toString(), ...attributes);
                     }
@@ -202,6 +283,10 @@ class GlideFt {
      * //         }
      * //     ]
      * // ]
+     *
+     * // Aggregate with all query flags:
+     * const result12 = await GlideFt.aggregate(client, "myIndex", "@score:[20 +inf]",
+     *     { loadAll: true, verbatim: true, inorder: true, slop: 1, dialect: 2 });
      * ```
      */
     static async aggregate(client, indexName, query, options) {
@@ -262,10 +347,29 @@ class GlideFt {
      * //         },
      * //     ]
      * // }
+     *
+     * // Get info with scope options:
+     * const localInfo = await GlideFt.info(client, "myIndex", { scope: "LOCAL" });
+     *
+     * // Get cluster-wide info (requires coordinator):
+     * const clusterInfo = await GlideFt.info(client, "myIndex", {
+     *     scope: "PRIMARY",
+     *     shardScope: "ALLSHARDS",
+     *     consistency: "CONSISTENT",
+     * });
      * ```
      */
     static async info(client, indexName, options) {
         const args = ["FT.INFO", indexName];
+        if (options?.scope) {
+            args.push(options.scope);
+        }
+        if (options?.shardScope) {
+            args.push(options.shardScope);
+        }
+        if (options?.consistency) {
+            args.push(options.consistency);
+        }
         return _handleCustomCommand(client, args, options).then(__1.convertGlideRecordToRecord);
     }
     /**
@@ -321,6 +425,7 @@ class GlideFt {
      * @returns A two-element array, where the first element is the number of documents in the result set, and the
      * second element has the format: `GlideRecord<GlideRecord<GlideString>>`:
      * a mapping between document names and a map of their attributes.
+     * When `nocontent` is set, the attribute maps will be empty.
      *
      * If `count` or `limit` with values `{offset: 0, count: 0}` is
      * set, the command returns array with only one element: the number of documents.
@@ -362,6 +467,20 @@ class GlideFt {
      * //     },
      * //   ],
      * // ]
+     *
+     * // Text search with all options:
+     * // Note: withSortKeys requires sortby; shardScope/consistency are cluster-mode options.
+     * const textResult = await GlideFt.search(client, "myIndex", "hello world", {
+     *     verbatim: true,
+     *     inorder: true,
+     *     slop: 1,
+     *     sortby: "price",
+     *     sortbyOrder: SortOrder.ASC,
+     *     withsortkeys: true,
+     *     shardScope: "ALLSHARDS",
+     *     consistency: "CONSISTENT",
+     *     dialect: 2,
+     * });
      * ```
      */
     static async search(client, indexName, query, options) {
@@ -541,6 +660,12 @@ function _addFtAggregateOptions(options) {
     if (!options)
         return [];
     const args = [];
+    if (options.verbatim)
+        args.push("VERBATIM");
+    if (options.inorder)
+        args.push("INORDER");
+    if (options.slop !== undefined)
+        args.push("SLOP", options.slop.toString());
     if (options.loadAll)
         args.push("LOAD", "*");
     else if (options.loadFields)
@@ -582,6 +707,8 @@ function _addFtAggregateOptions(options) {
             }
         }
     }
+    if (options.dialect !== undefined)
+        args.push("DIALECT", options.dialect.toString());
     return args;
 }
 /**
@@ -590,7 +717,37 @@ function _addFtAggregateOptions(options) {
 function _addFtSearchOptions(options) {
     if (!options)
         return [];
+    if (!options.sortby && options.sortbyOrder) {
+        throw new Error("sortbyOrder requires sortby to be set.");
+    }
+    if (!options.sortby && options.withsortkeys) {
+        throw new Error("withsortkeys requires sortby to be set.");
+    }
     const args = [];
+    // SHARD SCOPE
+    if (options.shardScope) {
+        args.push(options.shardScope);
+    }
+    // CONSISTENCY
+    if (options.consistency) {
+        args.push(options.consistency);
+    }
+    // NOCONTENT
+    if (options.nocontent) {
+        args.push("NOCONTENT");
+    }
+    // VERBATIM
+    if (options.verbatim) {
+        args.push("VERBATIM");
+    }
+    // INORDER
+    if (options.inorder) {
+        args.push("INORDER");
+    }
+    // SLOP
+    if (options.slop !== undefined) {
+        args.push("SLOP", options.slop.toString());
+    }
     // RETURN
     if (options.returnFields) {
         const returnFields = [];
@@ -599,6 +756,17 @@ function _addFtSearchOptions(options) {
             : returnFields.push(returnField.fieldIdentifier));
         args.push("RETURN", returnFields.length.toString(), ...returnFields);
     }
+    // SORTBY
+    if (options.sortby) {
+        args.push("SORTBY", options.sortby);
+        if (options.sortbyOrder) {
+            args.push(options.sortbyOrder);
+        }
+    }
+    // WITHSORTKEYS
+    if (options.withsortkeys) {
+        args.push("WITHSORTKEYS");
+    }
     // TIMEOUT
     if (options.timeout) {
         args.push("TIMEOUT", options.timeout.toString());
@@ -615,6 +783,10 @@ function _addFtSearchOptions(options) {
     if (options.count) {
         args.push("COUNT");
     }
+    // DIALECT
+    if (options.dialect !== undefined) {
+        args.push("DIALECT", options.dialect.toString());
+    }
     return args;
 }
 /**

package/build-ts/server-modules/GlideFtOptions.d.ts

@@ -7,6 +7,8 @@ interface BaseField {
     name: GlideString;
     /** An alias for field. */
     alias?: GlideString;
+    /** If set, the field value can be used for sorting. Applies to TEXT, TAG, and NUMERIC fields. */
+    sortable?: boolean;
 }
 /**
  * Field contains any blob of data.
@@ -14,6 +16,20 @@ interface BaseField {
 export type TextField = BaseField & {
     /** Field identifier */
     type: "TEXT";
+    /** If set, disables stemming when indexing the field. */
+    nostem?: boolean;
+    /** Declares the importance of this field when calculating result accuracy. Default is 1. */
+    weight?: number;
+    /**
+     * If set, keeps a suffix trie for the field to optimize contains and suffix queries.
+     * Mutually exclusive with `nosuffixtrie`.
+     */
+    withsuffixtrie?: boolean;
+    /**
+     * If set, disables the suffix trie for the field.
+     * Mutually exclusive with `withsuffixtrie`.
+     */
+    nosuffixtrie?: boolean;
 };
 /**
  * Tag fields are similar to full-text fields, but they interpret the text as a simple list of
@@ -53,13 +69,15 @@ interface VectorFieldAttributes {
     /** Number of dimensions in the vector. Equivalent to `DIM` in the module API. */
     dimensions: number;
     /**
-     * The distance metric used in vector type field. Can be one of `[L2 | IP | COSINE]`. Equivalent to `DISTANCE_METRIC` in the module API.
+     * The distance metric used in vector type field. Can be one of `[L2 | IP | COSINE]`.
+     * Equivalent to `DISTANCE_METRIC` in the module API.
      */
     distanceMetric: "L2" | "IP" | "COSINE";
     /** Vector type. The only supported type is FLOAT32. */
     type?: "FLOAT32";
     /**
-     * Initial vector capacity in the index affecting memory allocation size of the index. Defaults to `1024`. Equivalent to `INITIAL_CAP` in the module API.
+     * Initial vector capacity in the index affecting memory allocation size of the index.
+     * Defaults to `1024`. Equivalent to `INITIAL_CAP` in the module API.
      */
     initialCap?: number;
 }
@@ -81,18 +99,18 @@ export type VectorFieldAttributesFlat = VectorFieldAttributes & {
 export type VectorFieldAttributesHnsw = VectorFieldAttributes & {
     algorithm: "HNSW";
     /**
-     * Number of maximum allowed outgoing edges for each node in the graph in each layer. Default is `16`, maximum is `512`.
-     * Equivalent to `M` in the module API.
+     * Number of maximum allowed outgoing edges for each node in the graph in each layer.
+     * Default is `16`, maximum is `512`. Equivalent to `M` in the module API.
      */
     numberOfEdges?: number;
     /**
-     * Controls the number of vectors examined during index construction. Default value is `200`, Maximum value is `4096`.
-     * Equivalent to `EF_CONSTRUCTION` in the module API.
+     * Controls the number of vectors examined during index construction.
+     * Default value is `200`, Maximum value is `4096`. Equivalent to `EF_CONSTRUCTION` in the module API.
      */
     vectorsExaminedOnConstruction?: number;
     /**
-     * Controls the number of vectors examined during query operations. Default value is `10`, Maximum value is `4096`.
-     * Equivalent to `EF_RUNTIME` in the module API.
+     * Controls the number of vectors examined during query operations.
+     * Default value is `10`, Maximum value is `4096`. Equivalent to `EF_RUNTIME` in the module API.
      */
     vectorsExaminedOnRuntime?: number;
 };
@@ -106,6 +124,36 @@ export interface FtCreateOptions {
     dataType: "JSON" | "HASH";
     /** The prefix of the key to be indexed. */
     prefixes?: GlideString[];
+    /** Default score for documents in the index. Default is 1.0. */
+    score?: number;
+    /** Default language for documents in the index. */
+    language?: string;
+    /** If set, does not scan and index existing documents on index creation. */
+    skipInitialScan?: boolean;
+    /** Minimum word length to stem. Words shorter than this are not stemmed. */
+    minStemSize?: number;
+    /**
+     * If set, stores term offsets for document fields.
+     * Mutually exclusive with `noOffsets`.
+     */
+    withOffsets?: boolean;
+    /**
+     * If set, does not store term offsets.
+     * Mutually exclusive with `withOffsets`.
+     */
+    noOffsets?: boolean;
+    /**
+     * If set, disables stop-word filtering.
+     * Mutually exclusive with `stopWords`.
+     */
+    noStopWords?: boolean;
+    /**
+     * Custom list of stop words.
+     * Mutually exclusive with `noStopWords`.
+     */
+    stopWords?: GlideString[];
+    /** Custom punctuation characters to use during tokenization. */
+    punctuation?: GlideString;
 }
 /** Additional parameters for {@link GlideFt.aggregate | FT.AGGREGATE} command. */
 export type FtAggregateOptions = {
@@ -123,6 +171,14 @@ export type FtAggregateOptions = {
      * the parameter name.
      */
     params?: GlideRecord<GlideString>;
+    /** If set, stemming is not applied to term searches. */
+    verbatim?: boolean;
+    /** If set, proximity matching of terms must be in order. */
+    inorder?: boolean;
+    /** Specifies a slop value for proximity matching of terms. */
+    slop?: number;
+    /** The query dialect version to use. */
+    dialect?: number;
 } & ({
     /** List of fields to load from the index. */
     loadFields?: GlideString[];
@@ -218,6 +274,39 @@ export type FtSearchOptions = {
      * the parameter name.
      */
     params?: GlideRecord<GlideString>;
+    /** If true, returns only document IDs without field content.
+     * The document entries in the result will have empty value arrays. */
+    nocontent?: boolean;
+    /** Query dialect version. Only dialect 2 is currently supported in valkey-search. */
+    dialect?: number;
+    /** If set, stemming is not applied to text terms in the query. */
+    verbatim?: boolean;
+    /** If set, proximity matching of text terms must be in order. */
+    inorder?: boolean;
+    /** Specifies a slop value for proximity matching of text terms. */
+    slop?: number;
+    /** Field name to sort results by. Sorting is applied before the LIMIT clause. */
+    sortby?: GlideString;
+    /** Sort direction for `sortby`. Only used when `sortby` is set. */
+    sortbyOrder?: SortOrder | "ASC" | "DESC";
+    /** If set and `sortby` is specified, augments the output with the sort key value.
+     * When enabled, each document value in the result map becomes a two-element array
+     * `[sortKey, fieldMap]` instead of just `fieldMap`. The sort key is the value of the
+     * field used for sorting, or `null` if the field is missing from the document.
+     */
+    withsortkeys?: boolean;
+    /**
+     * Controls shard participation in cluster mode.
+     * `ALLSHARDS` terminates with timeout error if not all shards respond (default).
+     * `SOMESHARDS` generates a best-effort reply if not all shards respond within the timeout.
+     */
+    shardScope?: "ALLSHARDS" | "SOMESHARDS";
+    /**
+     * Controls consistency requirements in cluster mode.
+     * `CONSISTENT` terminates with an error if the cluster is in an inconsistent state (default).
+     * `INCONSISTENT` generates a best-effort reply if the cluster remains inconsistent within the timeout.
+     */
+    consistency?: "CONSISTENT" | "INCONSISTENT";
 } & ({
     /**
      * Configure query pagination. By default only first 10 documents are returned.
@@ -240,4 +329,13 @@ export type FtSearchOptions = {
     /** `limit` and `count` are mutually exclusive. */
     limit?: never;
 });
+/** Additional parameters for {@link GlideFt.info | FT.INFO} command. */
+export interface FtInfoOptions {
+    /** Controls which nodes provide index information in cluster mode. */
+    scope?: "LOCAL" | "PRIMARY" | "CLUSTER";
+    /** Controls shard participation in cluster mode. */
+    shardScope?: "ALLSHARDS" | "SOMESHARDS";
+    /** Controls consistency requirements in cluster mode. */
+    consistency?: "CONSISTENT" | "INCONSISTENT";
+}
 export {};

package/package.json

@@ -4,7 +4,7 @@
   "main": "build-ts/index.js",
   "module": "build-ts/index.js",
   "types": "build-ts/index.d.ts",
-  "version": "2.3.1",
+  "version": "2.4.0-rc2",
   "exports": {
     ".": {
       "import": {
@@ -135,11 +135,11 @@
     }
   },
   "optionalDependencies": {
-    "@valkey/valkey-glide-darwin-x64": "2.3.1",
-    "@valkey/valkey-glide-darwin-arm64": "2.3.1",
-    "@valkey/valkey-glide-linux-x64-gnu": "2.3.1",
-    "@valkey/valkey-glide-linux-arm64-gnu": "2.3.1",
-    "@valkey/valkey-glide-linux-x64-musl": "2.3.1",
-    "@valkey/valkey-glide-linux-arm64-musl": "2.3.1"
+    "@valkey/valkey-glide-darwin-x64": "2.4.0-rc2",
+    "@valkey/valkey-glide-darwin-arm64": "2.4.0-rc2",
+    "@valkey/valkey-glide-linux-x64-gnu": "2.4.0-rc2",
+    "@valkey/valkey-glide-linux-arm64-gnu": "2.4.0-rc2",
+    "@valkey/valkey-glide-linux-x64-musl": "2.4.0-rc2",
+    "@valkey/valkey-glide-linux-arm64-musl": "2.4.0-rc2"
   }
 }