@upstash/redis 0.0.0-ci.d3170677a5859e31d40407781286bdf17d64ca72-20250220114636 → 0.0.0-ci.d3985e1d3f7f296ee10dff2746b51fa88dddc9a9-20251222113217

package/{chunk-AQ2U77ZI.mjs → chunk-LU3F3BSG.mjs}

@@ -8,11 +8,12 @@ var __export = (target, all) => {
 var error_exports = {};
 __export(error_exports, {
   UpstashError: () => UpstashError,
+  UpstashJSONParseError: () => UpstashJSONParseError,
   UrlError: () => UrlError
 });
 var UpstashError = class extends Error {
-  constructor(message) {
-    super(message);
+  constructor(message, options) {
+    super(message, options);
     this.name = "UpstashError";
   }
 };
@@ -24,6 +25,13 @@ var UrlError = class extends Error {
     this.name = "UrlError";
   }
 };
+var UpstashJSONParseError = class extends UpstashError {
+  constructor(body, options) {
+    const truncatedBody = body.length > 200 ? body.slice(0, 200) + "..." : body;
+    super(`Unable to parse response body: ${truncatedBody}`, options);
+    this.name = "UpstashJSONParseError";
+  }
+};
 
 // pkg/util.ts
 function parseRecursive(obj) {
@@ -49,6 +57,14 @@ function parseResponse(result) {
 function deserializeScanResponse(result) {
   return [result[0], ...parseResponse(result.slice(1))];
 }
+function deserializeScanWithTypesResponse(result) {
+  const [cursor, keys] = result;
+  const parsedKeys = [];
+  for (let i = 0; i < keys.length; i += 2) {
+    parsedKeys.push({ key: keys[i], type: keys[i + 1] });
+  }
+  return [cursor, parsedKeys];
+}
 function mergeHeaders(...headers) {
   const merged = {};
   for (const header of headers) {
@@ -61,6 +77,15 @@ function mergeHeaders(...headers) {
   }
   return merged;
 }
+function kvArrayToObject(v) {
+  if (typeof v === "object" && v !== null && !Array.isArray(v)) return v;
+  if (!Array.isArray(v)) return {};
+  const obj = {};
+  for (let i = 0; i < v.length; i += 2) {
+    if (typeof v[i] === "string") obj[v[i]] = v[i + 1];
+  }
+  return obj;
+}
 
 // pkg/http.ts
 var HttpClient = class {
@@ -113,6 +138,8 @@ var HttpClient = class {
     const requestHeaders = mergeHeaders(this.headers, req.headers ?? {});
     const requestUrl = [this.baseUrl, ...req.path ?? []].join("/");
     const isEventStream = requestHeaders.Accept === "text/event-stream";
+    const signal = req.signal ?? this.options.signal;
+    const isSignalFunction = typeof signal === "function";
     const requestOptions = {
       //@ts-expect-error this should throw due to bun regression
       cache: this.options.cache,
@@ -121,7 +148,7 @@ var HttpClient = class {
       body: JSON.stringify(req.body),
       keepalive: this.options.keepAlive,
       agent: this.options.agent,
-      signal: req.signal ?? this.options.signal,
+      signal: isSignalFunction ? signal() : signal,
       /**
        * Fastly specific
        */
@@ -143,13 +170,15 @@ var HttpClient = class {
         res = await fetch(requestUrl, requestOptions);
         break;
       } catch (error_) {
-        if (this.options.signal?.aborted) {
+        if (requestOptions.signal?.aborted && isSignalFunction) {
+          throw error_;
+        } else if (requestOptions.signal?.aborted) {
           const myBlob = new Blob([
-            JSON.stringify({ result: this.options.signal.reason ?? "Aborted" })
+            JSON.stringify({ result: requestOptions.signal.reason ?? "Aborted" })
           ]);
           const myOptions = {
             status: 200,
-            statusText: this.options.signal.reason ?? "Aborted"
+            statusText: requestOptions.signal.reason ?? "Aborted"
           };
           res = new Response(myBlob, myOptions);
           break;
@@ -164,7 +193,13 @@ var HttpClient = class {
       throw error ?? new Error("Exhausted all retries");
     }
     if (!res.ok) {
-      const body2 = await res.json();
+      let body2;
+      const rawBody2 = await res.text();
+      try {
+        body2 = JSON.parse(rawBody2);
+      } catch (error2) {
+        throw new UpstashJSONParseError(rawBody2, { cause: error2 });
+      }
       throw new UpstashError(`${body2.error}, command was: ${JSON.stringify(req.body)}`);
     }
     if (this.readYourWrites) {
@@ -202,7 +237,13 @@ var HttpClient = class {
       })();
       return { result: 1 };
     }
-    const body = await res.json();
+    let body;
+    const rawBody = await res.text();
+    try {
+      body = JSON.parse(rawBody);
+    } catch (error2) {
+      throw new UpstashJSONParseError(rawBody, { cause: error2 });
+    }
     if (this.readYourWrites) {
       const headers = res.headers;
       this.upstashSyncToken = headers.get("upstash-sync-token") ?? "";
@@ -352,9 +393,9 @@ function deserialize(result) {
     return null;
   }
   const obj = {};
-  while (result.length >= 2) {
-    const key = result.shift();
-    const value = result.shift();
+  for (let i = 0; i < result.length; i += 2) {
+    const key = result[i];
+    const value = result[i + 1];
     try {
       obj[key] = JSON.parse(value);
     } catch {
@@ -496,6 +537,13 @@ var EchoCommand = class extends Command {
   }
 };
 
+// pkg/commands/evalRo.ts
+var EvalROCommand = class extends Command {
+  constructor([script, keys, args], opts) {
+    super(["eval_ro", script, keys.length, ...keys, ...args ?? []], opts);
+  }
+};
+
 // pkg/commands/eval.ts
 var EvalCommand = class extends Command {
   constructor([script, keys, args], opts) {
@@ -503,6 +551,13 @@ var EvalCommand = class extends Command {
   }
 };
 
+// pkg/commands/evalshaRo.ts
+var EvalshaROCommand = class extends Command {
+  constructor([sha, keys, args], opts) {
+    super(["evalsha_ro", sha, keys.length, ...keys, ...args ?? []], opts);
+  }
+};
+
 // pkg/commands/evalsha.ts
 var EvalshaCommand = class extends Command {
   constructor([sha, keys, args], opts) {
@@ -539,6 +594,20 @@ var ExpireAtCommand = class extends Command {
   }
 };
 
+// pkg/commands/fcall.ts
+var FCallCommand = class extends Command {
+  constructor([fn, keys, args], opts) {
+    super(["fcall", fn, ...keys ? [keys.length, ...keys] : [0], ...args ?? []], opts);
+  }
+};
+
+// pkg/commands/fcall_ro.ts
+var FCallRoCommand = class extends Command {
+  constructor([fn, keys, args], opts) {
+    super(["fcall_ro", fn, ...keys ? [keys.length, ...keys] : [], ...args ?? []], opts);
+  }
+};
+
 // pkg/commands/flushall.ts
 var FlushAllCommand = class extends Command {
   constructor(args, opts) {
@@ -561,6 +630,85 @@ var FlushDBCommand = class extends Command {
   }
 };
 
+// pkg/commands/function_delete.ts
+var FunctionDeleteCommand = class extends Command {
+  constructor([libraryName], opts) {
+    super(["function", "delete", libraryName], opts);
+  }
+};
+
+// pkg/commands/function_flush.ts
+var FunctionFlushCommand = class extends Command {
+  constructor(opts) {
+    super(["function", "flush"], opts);
+  }
+};
+
+// pkg/commands/function_list.ts
+var FunctionListCommand = class extends Command {
+  constructor([args], opts) {
+    const command = ["function", "list"];
+    if (args?.libraryName) {
+      command.push("libraryname", args.libraryName);
+    }
+    if (args?.withCode) {
+      command.push("withcode");
+    }
+    super(command, { deserialize: deserialize2, ...opts });
+  }
+};
+function deserialize2(result) {
+  if (!Array.isArray(result)) return [];
+  return result.map((libRaw) => {
+    const lib = kvArrayToObject(libRaw);
+    const functionsParsed = lib.functions.map(
+      (fnRaw) => kvArrayToObject(fnRaw)
+    );
+    return {
+      libraryName: lib.library_name,
+      engine: lib.engine,
+      functions: functionsParsed.map((fn) => ({
+        name: fn.name,
+        description: fn.description ?? void 0,
+        flags: fn.flags
+      })),
+      libraryCode: lib.library_code
+    };
+  });
+}
+
+// pkg/commands/function_load.ts
+var FunctionLoadCommand = class extends Command {
+  constructor([args], opts) {
+    super(["function", "load", ...args.replace ? ["replace"] : [], args.code], opts);
+  }
+};
+
+// pkg/commands/function_stats.ts
+var FunctionStatsCommand = class extends Command {
+  constructor(opts) {
+    super(["function", "stats"], { deserialize: deserialize3, ...opts });
+  }
+};
+function deserialize3(result) {
+  const rawEngines = kvArrayToObject(kvArrayToObject(result).engines);
+  const parsedEngines = Object.fromEntries(
+    Object.entries(rawEngines).map(([key, value]) => [key, kvArrayToObject(value)])
+  );
+  const final = {
+    engines: Object.fromEntries(
+      Object.entries(parsedEngines).map(([key, value]) => [
+        key,
+        {
+          librariesCount: value.libraries_count,
+          functionsCount: value.functions_count
+        }
+      ])
+    )
+  };
+  return final;
+}
+
 // pkg/commands/geo_add.ts
 var GeoAddCommand = class extends Command {
   constructor([key, arg1, ...arg2], opts) {
@@ -783,6 +931,122 @@ var HExistsCommand = class extends Command {
   }
 };
 
+// pkg/commands/hexpire.ts
+var HExpireCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields, seconds, option] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(
+      [
+        "hexpire",
+        key,
+        seconds,
+        ...option ? [option] : [],
+        "FIELDS",
+        fieldArray.length,
+        ...fieldArray
+      ],
+      opts
+    );
+  }
+};
+
+// pkg/commands/hexpireat.ts
+var HExpireAtCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields, timestamp, option] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(
+      [
+        "hexpireat",
+        key,
+        timestamp,
+        ...option ? [option] : [],
+        "FIELDS",
+        fieldArray.length,
+        ...fieldArray
+      ],
+      opts
+    );
+  }
+};
+
+// pkg/commands/hexpiretime.ts
+var HExpireTimeCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(["hexpiretime", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
+  }
+};
+
+// pkg/commands/hpersist.ts
+var HPersistCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(["hpersist", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
+  }
+};
+
+// pkg/commands/hpexpire.ts
+var HPExpireCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields, milliseconds, option] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(
+      [
+        "hpexpire",
+        key,
+        milliseconds,
+        ...option ? [option] : [],
+        "FIELDS",
+        fieldArray.length,
+        ...fieldArray
+      ],
+      opts
+    );
+  }
+};
+
+// pkg/commands/hpexpireat.ts
+var HPExpireAtCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields, timestamp, option] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(
+      [
+        "hpexpireat",
+        key,
+        timestamp,
+        ...option ? [option] : [],
+        "FIELDS",
+        fieldArray.length,
+        ...fieldArray
+      ],
+      opts
+    );
+  }
+};
+
+// pkg/commands/hpexpiretime.ts
+var HPExpireTimeCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(["hpexpiretime", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
+  }
+};
+
+// pkg/commands/hpttl.ts
+var HPTtlCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(["hpttl", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
+  }
+};
+
 // pkg/commands/hget.ts
 var HGetCommand = class extends Command {
   constructor(cmd, opts) {
@@ -791,14 +1055,14 @@ var HGetCommand = class extends Command {
 };
 
 // pkg/commands/hgetall.ts
-function deserialize2(result) {
+function deserialize4(result) {
   if (result.length === 0) {
     return null;
   }
   const obj = {};
-  while (result.length >= 2) {
-    const key = result.shift();
-    const value = result.shift();
+  for (let i = 0; i < result.length; i += 2) {
+    const key = result[i];
+    const value = result[i + 1];
     try {
       const valueIsNumberAndNotSafeInteger = !Number.isNaN(Number(value)) && !Number.isSafeInteger(Number(value));
       obj[key] = valueIsNumberAndNotSafeInteger ? value : JSON.parse(value);
@@ -811,7 +1075,7 @@ function deserialize2(result) {
 var HGetAllCommand = class extends Command {
   constructor(cmd, opts) {
     super(["hgetall", ...cmd], {
-      deserialize: (result) => deserialize2(result),
+      deserialize: (result) => deserialize4(result),
       ...opts
     });
   }
@@ -846,7 +1110,7 @@ var HLenCommand = class extends Command {
 };
 
 // pkg/commands/hmget.ts
-function deserialize3(fields, result) {
+function deserialize5(fields, result) {
   if (result.every((field) => field === null)) {
     return null;
   }
@@ -863,7 +1127,7 @@ function deserialize3(fields, result) {
 var HMGetCommand = class extends Command {
   constructor([key, ...fields], opts) {
     super(["hmget", key, ...fields], {
-      deserialize: (result) => deserialize3(fields, result),
+      deserialize: (result) => deserialize5(fields, result),
       ...opts
     });
   }
@@ -914,6 +1178,15 @@ var HStrLenCommand = class extends Command {
   }
 };
 
+// pkg/commands/httl.ts
+var HTtlCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(["httl", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
+  }
+};
+
 // pkg/commands/hvals.ts
 var HValsCommand = class extends Command {
   constructor(cmd, opts) {
@@ -1033,6 +1306,14 @@ var JsonGetCommand = class extends Command {
   }
 };
 
+// pkg/commands/json_merge.ts
+var JsonMergeCommand = class extends Command {
+  constructor(cmd, opts) {
+    const command = ["JSON.MERGE", ...cmd];
+    super(command, opts);
+  }
+};
+
 // pkg/commands/json_mget.ts
 var JsonMGetCommand = class extends Command {
   constructor(cmd, opts) {
@@ -1393,11 +1674,14 @@ var ScanCommand = class extends Command {
     if (typeof opts?.count === "number") {
       command.push("count", opts.count);
     }
-    if (opts?.type && opts.type.length > 0) {
+    if (opts && "withType" in opts && opts.withType === true) {
+      command.push("withtype");
+    } else if (opts && "type" in opts && opts.type && opts.type.length > 0) {
       command.push("type", opts.type);
     }
     super(command, {
-      deserialize: deserializeScanResponse,
+      // @ts-expect-error ignore types here
+      deserialize: opts?.withType ? deserializeScanWithTypesResponse : deserializeScanResponse,
       ...cmdOpts
     });
   }
@@ -1820,18 +2104,18 @@ var XPendingCommand = class extends Command {
 };
 
 // pkg/commands/xrange.ts
-function deserialize4(result) {
+function deserialize6(result) {
   const obj = {};
   for (const e of result) {
-    while (e.length >= 2) {
-      const streamId = e.shift();
-      const entries = e.shift();
+    for (let i = 0; i < e.length; i += 2) {
+      const streamId = e[i];
+      const entries = e[i + 1];
       if (!(streamId in obj)) {
         obj[streamId] = {};
       }
-      while (entries.length >= 2) {
-        const field = entries.shift();
-        const value = entries.shift();
+      for (let j = 0; j < entries.length; j += 2) {
+        const field = entries[j];
+        const value = entries[j + 1];
         try {
           obj[streamId][field] = JSON.parse(value);
         } catch {
@@ -1849,7 +2133,7 @@ var XRangeCommand = class extends Command {
       command.push("COUNT", count);
     }
     super(command, {
-      deserialize: (result) => deserialize4(result),
+      deserialize: (result) => deserialize6(result),
       ...opts
     });
   }
@@ -1912,23 +2196,23 @@ var XRevRangeCommand = class extends Command {
       command.push("COUNT", count);
     }
     super(command, {
-      deserialize: (result) => deserialize5(result),
+      deserialize: (result) => deserialize7(result),
       ...opts
     });
   }
 };
-function deserialize5(result) {
+function deserialize7(result) {
   const obj = {};
   for (const e of result) {
-    while (e.length >= 2) {
-      const streamId = e.shift();
-      const entries = e.shift();
+    for (let i = 0; i < e.length; i += 2) {
+      const streamId = e[i];
+      const entries = e[i + 1];
       if (!(streamId in obj)) {
         obj[streamId] = {};
       }
-      while (entries.length >= 2) {
-        const field = entries.shift();
-        const value = entries.shift();
+      for (let j = 0; j < entries.length; j += 2) {
+        const field = entries[j];
+        const value = entries[j + 1];
         try {
           obj[streamId][field] = JSON.parse(value);
         } catch {
@@ -2327,10 +2611,18 @@ var Pipeline = class {
    * @see https://redis.io/commands/echo
    */
   echo = (...args) => this.chain(new EchoCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/eval_ro
+   */
+  evalRo = (...args) => this.chain(new EvalROCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/eval
    */
   eval = (...args) => this.chain(new EvalCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/evalsha_ro
+   */
+  evalshaRo = (...args) => this.chain(new EvalshaROCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/evalsha
    */
@@ -2411,6 +2703,42 @@ var Pipeline = class {
    * @see https://redis.io/commands/hexists
    */
   hexists = (...args) => this.chain(new HExistsCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hexpire
+   */
+  hexpire = (...args) => this.chain(new HExpireCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hexpireat
+   */
+  hexpireat = (...args) => this.chain(new HExpireAtCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hexpiretime
+   */
+  hexpiretime = (...args) => this.chain(new HExpireTimeCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/httl
+   */
+  httl = (...args) => this.chain(new HTtlCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hpexpire
+   */
+  hpexpire = (...args) => this.chain(new HPExpireCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hpexpireat
+   */
+  hpexpireat = (...args) => this.chain(new HPExpireAtCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hpexpiretime
+   */
+  hpexpiretime = (...args) => this.chain(new HPExpireTimeCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hpttl
+   */
+  hpttl = (...args) => this.chain(new HPTtlCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hpersist
+   */
+  hpersist = (...args) => this.chain(new HPersistCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/hget
    */
@@ -2928,6 +3256,10 @@ var Pipeline = class {
        * @see https://redis.io/commands/json.get
        */
       get: (...args) => this.chain(new JsonGetCommand(args, this.commandOptions)),
+      /**
+       * @see https://redis.io/commands/json.merge
+       */
+      merge: (...args) => this.chain(new JsonMergeCommand(args, this.commandOptions)),
       /**
        * @see https://redis.io/commands/json.mget
        */
@@ -2978,10 +3310,60 @@ var Pipeline = class {
       type: (...args) => this.chain(new JsonTypeCommand(args, this.commandOptions))
     };
   }
+  get functions() {
+    return {
+      /**
+       * @see https://redis.io/docs/latest/commands/function-load/
+       */
+      load: (...args) => this.chain(new FunctionLoadCommand(args, this.commandOptions)),
+      /**
+       * @see https://redis.io/docs/latest/commands/function-list/
+       */
+      list: (...args) => this.chain(new FunctionListCommand(args, this.commandOptions)),
+      /**
+       * @see https://redis.io/docs/latest/commands/function-delete/
+       */
+      delete: (...args) => this.chain(new FunctionDeleteCommand(args, this.commandOptions)),
+      /**
+       * @see https://redis.io/docs/latest/commands/function-flush/
+       */
+      flush: () => this.chain(new FunctionFlushCommand(this.commandOptions)),
+      /**
+       * @see https://redis.io/docs/latest/commands/function-stats/
+       */
+      stats: () => this.chain(new FunctionStatsCommand(this.commandOptions)),
+      /**
+       * @see https://redis.io/docs/latest/commands/fcall/
+       */
+      call: (...args) => this.chain(new FCallCommand(args, this.commandOptions)),
+      /**
+       * @see https://redis.io/docs/latest/commands/fcall_ro/
+       */
+      callRo: (...args) => this.chain(new FCallRoCommand(args, this.commandOptions))
+    };
+  }
 };
 
 // pkg/auto-pipeline.ts
-function createAutoPipelineProxy(_redis, json) {
+var EXCLUDE_COMMANDS = /* @__PURE__ */ new Set([
+  "scan",
+  "keys",
+  "flushdb",
+  "flushall",
+  "dbsize",
+  "hscan",
+  "hgetall",
+  "hkeys",
+  "lrange",
+  "sscan",
+  "smembers",
+  "xrange",
+  "xrevrange",
+  "zscan",
+  "zrange",
+  "exec"
+]);
+function createAutoPipelineProxy(_redis, namespace = "root") {
   const redis = _redis;
   if (!redis.autoPipelineExecutor) {
     redis.autoPipelineExecutor = new AutoPipelineExecutor(redis);
@@ -2991,28 +3373,31 @@ function createAutoPipelineProxy(_redis, json) {
       if (command === "pipelineCounter") {
         return redis2.autoPipelineExecutor.pipelineCounter;
       }
-      if (command === "json") {
-        return createAutoPipelineProxy(redis2, true);
+      if (namespace === "root" && command === "json") {
+        return createAutoPipelineProxy(redis2, "json");
+      }
+      if (namespace === "root" && command === "functions") {
+        return createAutoPipelineProxy(redis2, "functions");
       }
-      const commandInRedisButNotPipeline = command in redis2 && !(command in redis2.autoPipelineExecutor.pipeline);
-      if (commandInRedisButNotPipeline) {
-        return redis2[command];
+      if (namespace === "root") {
+        const commandInRedisButNotPipeline = command in redis2 && !(command in redis2.autoPipelineExecutor.pipeline);
+        const isCommandExcluded = EXCLUDE_COMMANDS.has(command);
+        if (commandInRedisButNotPipeline || isCommandExcluded) {
+          return redis2[command];
+        }
       }
-      const isFunction = json ? typeof redis2.autoPipelineExecutor.pipeline.json[command] === "function" : typeof redis2.autoPipelineExecutor.pipeline[command] === "function";
+      const pipeline = redis2.autoPipelineExecutor.pipeline;
+      const targetFunction = namespace === "json" ? pipeline.json[command] : namespace === "functions" ? pipeline.functions[command] : pipeline[command];
+      const isFunction = typeof targetFunction === "function";
       if (isFunction) {
         return (...args) => {
-          return redis2.autoPipelineExecutor.withAutoPipeline((pipeline) => {
-            if (json) {
-              pipeline.json[command](
-                ...args
-              );
-            } else {
-              pipeline[command](...args);
-            }
+          return redis2.autoPipelineExecutor.withAutoPipeline((pipeline2) => {
+            const targetFunction2 = namespace === "json" ? pipeline2.json[command] : namespace === "functions" ? pipeline2.functions[command] : pipeline2[command];
+            targetFunction2(...args);
           });
         };
       }
-      return redis2.autoPipelineExecutor.pipeline[command];
+      return targetFunction;
     }
   });
 }
@@ -3085,11 +3470,13 @@ var Subscriber = class extends EventTarget {
   subscriptions;
   client;
   listeners;
-  constructor(client, channels, isPattern = false) {
+  opts;
+  constructor(client, channels, isPattern = false, opts) {
     super();
     this.client = client;
     this.subscriptions = /* @__PURE__ */ new Map();
     this.listeners = /* @__PURE__ */ new Map();
+    this.opts = opts;
     for (const channel of channels) {
       if (isPattern) {
         this.subscribeToPattern(channel);
@@ -3148,10 +3535,9 @@ var Subscriber = class extends EventTarget {
         const channel = messageData.slice(secondCommaIndex + 1, thirdCommaIndex);
         const messageStr = messageData.slice(thirdCommaIndex + 1);
         try {
-          const message = JSON.parse(messageStr);
-          this.dispatchToListeners("pmessage", message);
-          this.dispatchToListeners(`pmessageBuffer`, { pattern, channel, message });
-          this.dispatchToListeners(`pmessage:${pattern}`, { channel, message });
+          const message = this.opts?.automaticDeserialization === false ? messageStr : JSON.parse(messageStr);
+          this.dispatchToListeners("pmessage", { pattern, channel, message });
+          this.dispatchToListeners(`pmessage:${pattern}`, { pattern, channel, message });
         } catch (error) {
           this.dispatchToListeners("error", new Error(`Failed to parse message: ${error}`));
         }
@@ -3159,10 +3545,14 @@ var Subscriber = class extends EventTarget {
         const channel = messageData.slice(firstCommaIndex + 1, secondCommaIndex);
         const messageStr = messageData.slice(secondCommaIndex + 1);
         try {
-          const message = type === "subscribe" || type === "psubscribe" ? Number.parseInt(messageStr) : JSON.parse(messageStr);
-          this.dispatchToListeners(type, message);
-          this.dispatchToListeners(`${type}Buffer`, { channel, message });
-          this.dispatchToListeners(`${type}:${channel}`, message);
+          if (type === "subscribe" || type === "psubscribe" || type === "unsubscribe" || type === "punsubscribe") {
+            const count = Number.parseInt(messageStr);
+            this.dispatchToListeners(type, count);
+          } else {
+            const message = this.opts?.automaticDeserialization === false ? messageStr : parseWithTryCatch(messageStr);
+            this.dispatchToListeners(type, { channel, message });
+            this.dispatchToListeners(`${type}:${channel}`, { channel, message });
+          }
         } catch (error) {
           this.dispatchToListeners("error", new Error(`Failed to parse message: ${error}`));
         }
@@ -3232,29 +3622,52 @@ var SubscribeCommand = class extends Command {
     });
   }
 };
+var parseWithTryCatch = (str) => {
+  try {
+    return JSON.parse(str);
+  } catch {
+    return str;
+  }
+};
 
 // pkg/script.ts
-import Hex from "crypto-js/enc-hex.js";
-import sha1 from "crypto-js/sha1.js";
+import { subtle } from "uncrypto";
 var Script = class {
   script;
+  /**
+   * @deprecated This property is initialized to an empty string and will be set in the init method
+   * asynchronously. Do not use this property immidiately after the constructor.
+   *
+   * This property is only exposed for backwards compatibility and will be removed in the
+   * future major release.
+   */
   sha1;
   redis;
   constructor(redis, script) {
     this.redis = redis;
-    this.sha1 = this.digest(script);
     this.script = script;
+    this.sha1 = "";
+    void this.init(script);
+  }
+  /**
+   * Initialize the script by computing its SHA-1 hash.
+   */
+  async init(script) {
+    if (this.sha1) return;
+    this.sha1 = await this.digest(script);
   }
   /**
    * Send an `EVAL` command to redis.
    */
   async eval(keys, args) {
+    await this.init(this.script);
     return await this.redis.eval(this.script, keys, args);
   }
   /**
    * Calculates the sha1 hash of the script and then calls `EVALSHA`.
    */
   async evalsha(keys, args) {
+    await this.init(this.script);
     return await this.redis.evalsha(this.sha1, keys, args);
   }
   /**
@@ -3264,6 +3677,7 @@ var Script = class {
    * Following calls will be able to use the cached script
    */
   async exec(keys, args) {
+    await this.init(this.script);
     const res = await this.redis.evalsha(this.sha1, keys, args).catch(async (error) => {
       if (error instanceof Error && error.message.toLowerCase().includes("noscript")) {
         return await this.redis.eval(this.script, keys, args);
@@ -3275,8 +3689,75 @@ var Script = class {
   /**
    * Compute the sha1 hash of the script and return its hex representation.
    */
-  digest(s) {
-    return Hex.stringify(sha1(s));
+  async digest(s) {
+    const data = new TextEncoder().encode(s);
+    const hashBuffer = await subtle.digest("SHA-1", data);
+    const hashArray = [...new Uint8Array(hashBuffer)];
+    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+};
+
+// pkg/scriptRo.ts
+import { subtle as subtle2 } from "uncrypto";
+var ScriptRO = class {
+  script;
+  /**
+   * @deprecated This property is initialized to an empty string and will be set in the init method
+   * asynchronously. Do not use this property immidiately after the constructor.
+   *
+   * This property is only exposed for backwards compatibility and will be removed in the
+   * future major release.
+   */
+  sha1;
+  redis;
+  constructor(redis, script) {
+    this.redis = redis;
+    this.sha1 = "";
+    this.script = script;
+    void this.init(script);
+  }
+  async init(script) {
+    if (this.sha1) return;
+    this.sha1 = await this.digest(script);
+  }
+  /**
+   * Send an `EVAL_RO` command to redis.
+   */
+  async evalRo(keys, args) {
+    await this.init(this.script);
+    return await this.redis.evalRo(this.script, keys, args);
+  }
+  /**
+   * Calculates the sha1 hash of the script and then calls `EVALSHA_RO`.
+   */
+  async evalshaRo(keys, args) {
+    await this.init(this.script);
+    return await this.redis.evalshaRo(this.sha1, keys, args);
+  }
+  /**
+   * Optimistically try to run `EVALSHA_RO` first.
+   * If the script is not loaded in redis, it will fall back and try again with `EVAL_RO`.
+   *
+   * Following calls will be able to use the cached script
+   */
+  async exec(keys, args) {
+    await this.init(this.script);
+    const res = await this.redis.evalshaRo(this.sha1, keys, args).catch(async (error) => {
+      if (error instanceof Error && error.message.toLowerCase().includes("noscript")) {
+        return await this.redis.evalRo(this.script, keys, args);
+      }
+      throw error;
+    });
+    return res;
+  }
+  /**
+   * Compute the sha1 hash of the script and return its hex representation.
+   */
+  async digest(s) {
+    const data = new TextEncoder().encode(s);
+    const hashBuffer = await subtle2.digest("SHA-1", data);
+    const hashArray = [...new Uint8Array(hashBuffer)];
+    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
   }
 };
 
@@ -3354,6 +3835,10 @@ var Redis = class {
        * @see https://redis.io/commands/json.get
        */
       get: (...args) => new JsonGetCommand(args, this.opts).exec(this.client),
+      /**
+       * @see https://redis.io/commands/json.merge
+       */
+      merge: (...args) => new JsonMergeCommand(args, this.opts).exec(this.client),
       /**
        * @see https://redis.io/commands/json.mget
        */
@@ -3404,6 +3889,40 @@ var Redis = class {
       type: (...args) => new JsonTypeCommand(args, this.opts).exec(this.client)
     };
   }
+  get functions() {
+    return {
+      /**
+       * @see https://redis.io/docs/latest/commands/function-load/
+       */
+      load: (...args) => new FunctionLoadCommand(args, this.opts).exec(this.client),
+      /**
+       * @see https://redis.io/docs/latest/commands/function-list/
+       */
+      list: (...args) => new FunctionListCommand(args, this.opts).exec(this.client),
+      /**
+       * @see https://redis.io/docs/latest/commands/function-delete/
+       */
+      delete: (...args) => new FunctionDeleteCommand(args, this.opts).exec(this.client),
+      /**
+       * @see https://redis.io/docs/latest/commands/function-flush/
+       */
+      flush: () => new FunctionFlushCommand(this.opts).exec(this.client),
+      /**
+       * @see https://redis.io/docs/latest/commands/function-stats/
+       *
+       * Note: `running_script` field is not supported and therefore not included in the type.
+       */
+      stats: () => new FunctionStatsCommand(this.opts).exec(this.client),
+      /**
+       * @see https://redis.io/docs/latest/commands/fcall/
+       */
+      call: (...args) => new FCallCommand(args, this.opts).exec(this.client),
+      /**
+       * @see https://redis.io/docs/latest/commands/fcall_ro/
+       */
+      callRo: (...args) => new FCallRoCommand(args, this.opts).exec(this.client)
+    };
+  }
   /**
    * Wrap a new middleware around the HTTP client.
    */
@@ -3423,8 +3942,36 @@ var Redis = class {
     } catch {
     }
   };
-  createScript(script) {
-    return new Script(this, script);
+  /**
+   * Creates a new script.
+   *
+   * Scripts offer the ability to optimistically try to execute a script without having to send the
+   * entire script to the server. If the script is loaded on the server, it tries again by sending
+   * the entire script. Afterwards, the script is cached on the server.
+   *
+   * @param script - The script to create
+   * @param opts - Optional options to pass to the script `{ readonly?: boolean }`
+   * @returns A new script
+   *
+   * @example
+   * ```ts
+   * const redis = new Redis({...})
+   *
+   * const script = redis.createScript<string>("return ARGV[1];")
+   * const arg1 = await script.eval([], ["Hello World"])
+   * expect(arg1, "Hello World")
+   * ```
+   * @example
+   * ```ts
+   * const redis = new Redis({...})
+   *
+   * const script = redis.createScript<string>("return ARGV[1];", { readonly: true })
+   * const arg1 = await script.evalRo([], ["Hello World"])
+   * expect(arg1, "Hello World")
+   * ```
+   */
+  createScript(script, opts) {
+    return opts?.readonly ? new ScriptRO(this, script) : new Script(this, script);
   }
   /**
    * Create a new pipeline that allows you to send requests in bulk.
@@ -3511,10 +4058,18 @@ var Redis = class {
    * @see https://redis.io/commands/echo
    */
   echo = (...args) => new EchoCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/eval_ro
+   */
+  evalRo = (...args) => new EvalROCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/eval
    */
   eval = (...args) => new EvalCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/evalsha_ro
+   */
+  evalshaRo = (...args) => new EvalshaROCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/evalsha
    */
@@ -3599,6 +4154,42 @@ var Redis = class {
    * @see https://redis.io/commands/hexists
    */
   hexists = (...args) => new HExistsCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hexpire
+   */
+  hexpire = (...args) => new HExpireCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hexpireat
+   */
+  hexpireat = (...args) => new HExpireAtCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hexpiretime
+   */
+  hexpiretime = (...args) => new HExpireTimeCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/httl
+   */
+  httl = (...args) => new HTtlCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hpexpire
+   */
+  hpexpire = (...args) => new HPExpireCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hpexpireat
+   */
+  hpexpireat = (...args) => new HPExpireAtCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hpexpiretime
+   */
+  hpexpiretime = (...args) => new HPExpireTimeCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hpttl
+   */
+  hpttl = (...args) => new HPTtlCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hpersist
+   */
+  hpersist = (...args) => new HPersistCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/hget
    */
@@ -3767,9 +4358,12 @@ var Redis = class {
    * @see https://redis.io/commands/psetex
    */
   psetex = (key, ttl, value) => new PSetEXCommand([key, ttl, value], this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/psubscribe
+   */
   psubscribe = (patterns) => {
     const patternArray = Array.isArray(patterns) ? patterns : [patterns];
-    return new Subscriber(this.client, patternArray, true);
+    return new Subscriber(this.client, patternArray, true, this.opts);
   };
   /**
    * @see https://redis.io/commands/pttl
@@ -3807,10 +4401,9 @@ var Redis = class {
    * @see https://redis.io/commands/sadd
    */
   sadd = (key, member, ...members) => new SAddCommand([key, member, ...members], this.opts).exec(this.client);
-  /**
-   * @see https://redis.io/commands/scan
-   */
-  scan = (...args) => new ScanCommand(args, this.opts).exec(this.client);
+  scan(cursor, opts) {
+    return new ScanCommand([cursor, opts], this.opts).exec(this.client);
+  }
   /**
    * @see https://redis.io/commands/scard
    */
@@ -3904,7 +4497,7 @@ var Redis = class {
    */
   subscribe = (channels) => {
     const channelArray = Array.isArray(channels) ? channels : [channels];
-    return new Subscriber(this.client, channelArray);
+    return new Subscriber(this.client, channelArray, false, this.opts);
   };
   /**
    * @see https://redis.io/commands/sunion