@upstash/redis 0.0.0-ci.8bd938831856fbab2f4aadc67ecb9de61efb6123 → 0.0.0-ci.8c525689f9001cdc6f09b0d60915e4f4a8d934a6-20250918133539

package/nodejs.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,36 +15,90 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // platforms/nodejs.ts
 var nodejs_exports = {};
 __export(nodejs_exports, {
-  Redis: () => Redis2
+  Redis: () => Redis2,
+  errors: () => error_exports
 });
 module.exports = __toCommonJS(nodejs_exports);
 
 // pkg/error.ts
+var error_exports = {};
+__export(error_exports, {
+  UpstashError: () => UpstashError,
+  UrlError: () => UrlError
+});
 var UpstashError = class extends Error {
   constructor(message) {
     super(message);
     this.name = "UpstashError";
   }
 };
+var UrlError = class extends Error {
+  constructor(url) {
+    super(
+      `Upstash Redis client was passed an invalid URL. You should pass a URL starting with https. Received: "${url}". `
+    );
+    this.name = "UrlError";
+  }
+};
+
+// pkg/util.ts
+function parseRecursive(obj) {
+  const parsed = Array.isArray(obj) ? obj.map((o) => {
+    try {
+      return parseRecursive(o);
+    } catch {
+      return o;
+    }
+  }) : JSON.parse(obj);
+  if (typeof parsed === "number" && parsed.toString() !== obj) {
+    return obj;
+  }
+  return parsed;
+}
+function parseResponse(result) {
+  try {
+    return parseRecursive(result);
+  } catch {
+    return 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) {
+    if (!header) continue;
+    for (const [key, value] of Object.entries(header)) {
+      if (value !== void 0 && value !== null) {
+        merged[key] = value;
+      }
+    }
+  }
+  return merged;
+}
 
 // pkg/http.ts
 var HttpClient = class {
   baseUrl;
   headers;
   options;
+  readYourWrites;
+  upstashSyncToken = "";
+  hasCredentials;
   retry;
   constructor(config) {
     this.options = {
@@ -54,76 +106,141 @@ var HttpClient = class {
       agent: config.agent,
       responseEncoding: config.responseEncoding ?? "base64",
       // default to base64
-      cache: config.cache
+      cache: config.cache,
+      signal: config.signal,
+      keepAlive: config.keepAlive ?? true
     };
-    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.upstashSyncToken = "";
+    this.readYourWrites = config.readYourWrites ?? true;
+    this.baseUrl = (config.baseUrl || "").replace(/\/$/, "");
+    const urlRegex = /^https?:\/\/[^\s#$./?].\S*$/;
+    if (this.baseUrl && !urlRegex.test(this.baseUrl)) {
+      throw new UrlError(this.baseUrl);
+    }
     this.headers = {
       "Content-Type": "application/json",
       ...config.headers
     };
+    this.hasCredentials = Boolean(this.baseUrl && this.headers.authorization.split(" ")[1]);
     if (this.options.responseEncoding === "base64") {
       this.headers["Upstash-Encoding"] = "base64";
     }
-    if (typeof config?.retry === "boolean" && config?.retry === false) {
-      this.retry = {
-        attempts: 1,
-        backoff: () => 0
-      };
-    } else {
-      this.retry = {
-        attempts: config?.retry?.retries ?? 5,
-        backoff: config?.retry?.backoff ?? ((retryCount) => Math.exp(retryCount) * 50)
-      };
-    }
+    this.retry = typeof config.retry === "boolean" && !config.retry ? {
+      attempts: 1,
+      backoff: () => 0
+    } : {
+      attempts: config.retry?.retries ?? 5,
+      backoff: config.retry?.backoff ?? ((retryCount) => Math.exp(retryCount) * 50)
+    };
   }
   mergeTelemetry(telemetry) {
-    function merge(obj, key, value) {
-      if (!value) {
-        return obj;
-      }
-      if (obj[key]) {
-        obj[key] = [obj[key], value].join(",");
-      } else {
-        obj[key] = value;
-      }
-      return obj;
-    }
     this.headers = merge(this.headers, "Upstash-Telemetry-Runtime", telemetry.runtime);
     this.headers = merge(this.headers, "Upstash-Telemetry-Platform", telemetry.platform);
     this.headers = merge(this.headers, "Upstash-Telemetry-Sdk", telemetry.sdk);
   }
   async request(req) {
+    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,
       method: "POST",
-      headers: this.headers,
+      headers: requestHeaders,
       body: JSON.stringify(req.body),
-      keepalive: true,
-      agent: this.options?.agent,
+      keepalive: this.options.keepAlive,
+      agent: this.options.agent,
+      signal: isSignalFunction ? signal() : signal,
       /**
        * Fastly specific
        */
-      backend: this.options?.backend
+      backend: this.options.backend
     };
+    if (!this.hasCredentials) {
+      console.warn(
+        "[Upstash Redis] Redis client was initialized without url or token. Failed to execute command."
+      );
+    }
+    if (this.readYourWrites) {
+      const newHeader = this.upstashSyncToken;
+      this.headers["upstash-sync-token"] = newHeader;
+    }
     let res = null;
     let error = null;
     for (let i = 0; i <= this.retry.attempts; i++) {
       try {
-        res = await fetch([this.baseUrl, ...req.path ?? []].join("/"), requestOptions);
+        res = await fetch(requestUrl, requestOptions);
         break;
-      } catch (err) {
-        error = err;
-        await new Promise((r) => setTimeout(r, this.retry.backoff(i)));
+      } catch (error_) {
+        if (requestOptions.signal?.aborted && isSignalFunction) {
+          throw error_;
+        } else if (requestOptions.signal?.aborted) {
+          const myBlob = new Blob([
+            JSON.stringify({ result: requestOptions.signal.reason ?? "Aborted" })
+          ]);
+          const myOptions = {
+            status: 200,
+            statusText: requestOptions.signal.reason ?? "Aborted"
+          };
+          res = new Response(myBlob, myOptions);
+          break;
+        }
+        error = error_;
+        if (i < this.retry.attempts) {
+          await new Promise((r) => setTimeout(r, this.retry.backoff(i)));
+        }
       }
     }
     if (!res) {
       throw error ?? new Error("Exhausted all retries");
     }
-    const body = await res.json();
     if (!res.ok) {
-      throw new UpstashError(`${body.error}, command was: ${JSON.stringify(req.body)}`);
+      const body2 = await res.json();
+      throw new UpstashError(`${body2.error}, command was: ${JSON.stringify(req.body)}`);
+    }
+    if (this.readYourWrites) {
+      const headers = res.headers;
+      this.upstashSyncToken = headers.get("upstash-sync-token") ?? "";
+    }
+    if (isEventStream && req && req.onMessage && res.body) {
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      (async () => {
+        try {
+          while (true) {
+            const { value, done } = await reader.read();
+            if (done) break;
+            const chunk = decoder.decode(value);
+            const lines = chunk.split("\n");
+            for (const line of lines) {
+              if (line.startsWith("data: ")) {
+                const data = line.slice(6);
+                req.onMessage?.(data);
+              }
+            }
+          }
+        } catch (error2) {
+          if (error2 instanceof Error && error2.name === "AbortError") {
+          } else {
+            console.error("Stream reading error:", error2);
+          }
+        } finally {
+          try {
+            await reader.cancel();
+          } catch {
+          }
+        }
+      })();
+      return { result: 1 };
     }
-    if (this.options?.responseEncoding === "base64") {
+    const body = await res.json();
+    if (this.readYourWrites) {
+      const headers = res.headers;
+      this.upstashSyncToken = headers.get("upstash-sync-token") ?? "";
+    }
+    if (this.options.responseEncoding === "base64") {
       if (Array.isArray(body)) {
         return body.map(({ result: result2, error: error2 }) => ({
           result: decode(result2),
@@ -154,8 +271,9 @@ function base64decode(b64) {
 function decode(raw) {
   let result = void 0;
   switch (typeof raw) {
-    case "undefined":
+    case "undefined": {
       return raw;
+    }
     case "number": {
       result = raw;
       break;
@@ -163,7 +281,7 @@ function decode(raw) {
     case "object": {
       if (Array.isArray(raw)) {
         result = raw.map(
-          (v) => typeof v === "string" ? base64decode(v) : Array.isArray(v) ? v.map(decode) : v
+          (v) => typeof v === "string" ? base64decode(v) : Array.isArray(v) ? v.map((element) => decode(element)) : v
         );
       } else {
         result = null;
@@ -174,49 +292,140 @@ function decode(raw) {
       result = raw === "OK" ? "OK" : base64decode(raw);
       break;
     }
-    default:
+    default: {
       break;
+    }
   }
   return result;
 }
-
-// pkg/util.ts
-function parseRecursive(obj) {
-  const parsed = Array.isArray(obj) ? obj.map((o) => {
-    try {
-      return parseRecursive(o);
-    } catch {
-      return o;
-    }
-  }) : JSON.parse(obj);
-  if (typeof parsed === "number" && parsed.toString() !== obj) {
+function merge(obj, key, value) {
+  if (!value) {
     return obj;
   }
-  return parsed;
+  obj[key] = obj[key] ? [obj[key], value].join(",") : value;
+  return obj;
 }
-function parseResponse(result) {
-  try {
-    return parseRecursive(result);
-  } catch {
-    return result;
-  }
+
+// pkg/auto-pipeline.ts
+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, json) {
+  const redis = _redis;
+  if (!redis.autoPipelineExecutor) {
+    redis.autoPipelineExecutor = new AutoPipelineExecutor(redis);
+  }
+  return new Proxy(redis, {
+    get: (redis2, command) => {
+      if (command === "pipelineCounter") {
+        return redis2.autoPipelineExecutor.pipelineCounter;
+      }
+      if (command === "json") {
+        return createAutoPipelineProxy(redis2, true);
+      }
+      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";
+      if (isFunction) {
+        return (...args) => {
+          return redis2.autoPipelineExecutor.withAutoPipeline((pipeline) => {
+            if (json) {
+              pipeline.json[command](
+                ...args
+              );
+            } else {
+              pipeline[command](...args);
+            }
+          });
+        };
+      }
+      return redis2.autoPipelineExecutor.pipeline[command];
+    }
+  });
 }
+var AutoPipelineExecutor = class {
+  pipelinePromises = /* @__PURE__ */ new WeakMap();
+  activePipeline = null;
+  indexInCurrentPipeline = 0;
+  redis;
+  pipeline;
+  // only to make sure that proxy can work
+  pipelineCounter = 0;
+  // to keep track of how many times a pipeline was executed
+  constructor(redis) {
+    this.redis = redis;
+    this.pipeline = redis.pipeline();
+  }
+  async withAutoPipeline(executeWithPipeline) {
+    const pipeline = this.activePipeline ?? this.redis.pipeline();
+    if (!this.activePipeline) {
+      this.activePipeline = pipeline;
+      this.indexInCurrentPipeline = 0;
+    }
+    const index = this.indexInCurrentPipeline++;
+    executeWithPipeline(pipeline);
+    const pipelineDone = this.deferExecution().then(() => {
+      if (!this.pipelinePromises.has(pipeline)) {
+        const pipelinePromise = pipeline.exec({ keepErrors: true });
+        this.pipelineCounter += 1;
+        this.pipelinePromises.set(pipeline, pipelinePromise);
+        this.activePipeline = null;
+      }
+      return this.pipelinePromises.get(pipeline);
+    });
+    const results = await pipelineDone;
+    const commandResult = results[index];
+    if (commandResult.error) {
+      throw new UpstashError(`Command failed: ${commandResult.error}`);
+    }
+    return commandResult.result;
+  }
+  async deferExecution() {
+    await Promise.resolve();
+    await Promise.resolve();
+  }
+};
 
 // pkg/commands/command.ts
 var defaultSerializer = (c) => {
   switch (typeof c) {
     case "string":
     case "number":
-    case "boolean":
+    case "boolean": {
       return c;
-    default:
+    }
+    default: {
       return JSON.stringify(c);
+    }
   }
 };
 var Command = class {
   command;
   serialize;
   deserialize;
+  headers;
+  path;
+  onMessage;
+  isStreaming;
+  signal;
   /**
    * Create a new command instance.
    *
@@ -224,21 +433,45 @@ var Command = class {
    */
   constructor(command, opts) {
     this.serialize = defaultSerializer;
-    this.deserialize = typeof opts?.automaticDeserialization === "undefined" || opts.automaticDeserialization ? opts?.deserialize ?? parseResponse : (x) => x;
+    this.deserialize = opts?.automaticDeserialization === void 0 || opts.automaticDeserialization ? opts?.deserialize ?? parseResponse : (x) => x;
     this.command = command.map((c) => this.serialize(c));
+    this.headers = opts?.headers;
+    this.path = opts?.path;
+    this.onMessage = opts?.streamOptions?.onMessage;
+    this.isStreaming = opts?.streamOptions?.isStreaming ?? false;
+    this.signal = opts?.streamOptions?.signal;
+    if (opts?.latencyLogging) {
+      const originalExec = this.exec.bind(this);
+      this.exec = async (client) => {
+        const start = performance.now();
+        const result = await originalExec(client);
+        const end = performance.now();
+        const loggerResult = (end - start).toFixed(2);
+        console.log(
+          `Latency for \x1B[38;2;19;185;39m${this.command[0].toString().toUpperCase()}\x1B[0m: \x1B[38;2;0;255;255m${loggerResult} ms\x1B[0m`
+        );
+        return result;
+      };
+    }
   }
   /**
    * Execute the command using a client.
    */
   async exec(client) {
     const { result, error } = await client.request({
-      body: this.command
+      body: this.command,
+      path: this.path,
+      upstashSyncToken: client.upstashSyncToken,
+      headers: this.headers,
+      onMessage: this.onMessage,
+      isStreaming: this.isStreaming,
+      signal: this.signal
     });
     if (error) {
       throw new UpstashError(error);
     }
-    if (typeof result === "undefined") {
-      throw new Error("Request did not return a result");
+    if (result === void 0) {
+      throw new TypeError("Request did not return a result");
     }
     return this.deserialize(result);
   }
@@ -265,6 +498,37 @@ var BitCountCommand = class extends Command {
   }
 };
 
+// pkg/commands/bitfield.ts
+var BitFieldCommand = class {
+  constructor(args, client, opts, execOperation = (command) => command.exec(this.client)) {
+    this.client = client;
+    this.opts = opts;
+    this.execOperation = execOperation;
+    this.command = ["bitfield", ...args];
+  }
+  command;
+  chain(...args) {
+    this.command.push(...args);
+    return this;
+  }
+  get(...args) {
+    return this.chain("get", ...args);
+  }
+  set(...args) {
+    return this.chain("set", ...args);
+  }
+  incrby(...args) {
+    return this.chain("incrby", ...args);
+  }
+  overflow(overflow) {
+    return this.chain("overflow", overflow);
+  }
+  exec() {
+    const command = new Command(this.command, this.opts);
+    return this.execOperation(command);
+  }
+};
+
 // pkg/commands/bitop.ts
 var BitOpCommand = class extends Command {
   constructor(cmd, opts) {
@@ -279,6 +543,21 @@ var BitPosCommand = class extends Command {
   }
 };
 
+// pkg/commands/copy.ts
+var CopyCommand = class extends Command {
+  constructor([key, destinationKey, opts], commandOptions) {
+    super(["COPY", key, destinationKey, ...opts?.replace ? ["REPLACE"] : []], {
+      ...commandOptions,
+      deserialize(result) {
+        if (result > 0) {
+          return "COPIED";
+        }
+        return "NOT_COPIED";
+      }
+    });
+  }
+};
+
 // pkg/commands/dbsize.ts
 var DBSizeCommand = class extends Command {
   constructor(opts) {
@@ -314,6 +593,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) {
@@ -321,6 +607,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) {
@@ -328,6 +621,14 @@ var EvalshaCommand = class extends Command {
   }
 };
 
+// pkg/commands/exec.ts
+var ExecCommand = class extends Command {
+  constructor(cmd, opts) {
+    const normalizedCmd = cmd.map((arg) => typeof arg === "string" ? arg : String(arg));
+    super(normalizedCmd, opts);
+  }
+};
+
 // pkg/commands/exists.ts
 var ExistsCommand = class extends Command {
   constructor(cmd, opts) {
@@ -338,7 +639,7 @@ var ExistsCommand = class extends Command {
 // pkg/commands/expire.ts
 var ExpireCommand = class extends Command {
   constructor(cmd, opts) {
-    super(["expire", ...cmd], opts);
+    super(["expire", ...cmd.filter(Boolean)], opts);
   }
 };
 
@@ -400,6 +701,129 @@ var GeoDistCommand = class extends Command {
   }
 };
 
+// pkg/commands/geo_hash.ts
+var GeoHashCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key] = cmd;
+    const members = Array.isArray(cmd[1]) ? cmd[1] : cmd.slice(1);
+    super(["GEOHASH", key, ...members], opts);
+  }
+};
+
+// pkg/commands/geo_pos.ts
+var GeoPosCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key] = cmd;
+    const members = Array.isArray(cmd[1]) ? cmd[1] : cmd.slice(1);
+    super(["GEOPOS", key, ...members], {
+      deserialize: (result) => transform(result),
+      ...opts
+    });
+  }
+};
+function transform(result) {
+  const final = [];
+  for (const pos of result) {
+    if (!pos?.[0] || !pos?.[1]) {
+      continue;
+    }
+    final.push({ lng: Number.parseFloat(pos[0]), lat: Number.parseFloat(pos[1]) });
+  }
+  return final;
+}
+
+// pkg/commands/geo_search.ts
+var GeoSearchCommand = class extends Command {
+  constructor([key, centerPoint, shape, order, opts], commandOptions) {
+    const command = ["GEOSEARCH", key];
+    if (centerPoint.type === "FROMMEMBER" || centerPoint.type === "frommember") {
+      command.push(centerPoint.type, centerPoint.member);
+    }
+    if (centerPoint.type === "FROMLONLAT" || centerPoint.type === "fromlonlat") {
+      command.push(centerPoint.type, centerPoint.coordinate.lon, centerPoint.coordinate.lat);
+    }
+    if (shape.type === "BYRADIUS" || shape.type === "byradius") {
+      command.push(shape.type, shape.radius, shape.radiusType);
+    }
+    if (shape.type === "BYBOX" || shape.type === "bybox") {
+      command.push(shape.type, shape.rect.width, shape.rect.height, shape.rectType);
+    }
+    command.push(order);
+    if (opts?.count) {
+      command.push("COUNT", opts.count.limit, ...opts.count.any ? ["ANY"] : []);
+    }
+    const transform2 = (result) => {
+      if (!opts?.withCoord && !opts?.withDist && !opts?.withHash) {
+        return result.map((member) => {
+          try {
+            return { member: JSON.parse(member) };
+          } catch {
+            return { member };
+          }
+        });
+      }
+      return result.map((members) => {
+        let counter = 1;
+        const obj = {};
+        try {
+          obj.member = JSON.parse(members[0]);
+        } catch {
+          obj.member = members[0];
+        }
+        if (opts.withDist) {
+          obj.dist = Number.parseFloat(members[counter++]);
+        }
+        if (opts.withHash) {
+          obj.hash = members[counter++].toString();
+        }
+        if (opts.withCoord) {
+          obj.coord = {
+            long: Number.parseFloat(members[counter][0]),
+            lat: Number.parseFloat(members[counter][1])
+          };
+        }
+        return obj;
+      });
+    };
+    super(
+      [
+        ...command,
+        ...opts?.withCoord ? ["WITHCOORD"] : [],
+        ...opts?.withDist ? ["WITHDIST"] : [],
+        ...opts?.withHash ? ["WITHHASH"] : []
+      ],
+      {
+        deserialize: transform2,
+        ...commandOptions
+      }
+    );
+  }
+};
+
+// pkg/commands/geo_search_store.ts
+var GeoSearchStoreCommand = class extends Command {
+  constructor([destination, key, centerPoint, shape, order, opts], commandOptions) {
+    const command = ["GEOSEARCHSTORE", destination, key];
+    if (centerPoint.type === "FROMMEMBER" || centerPoint.type === "frommember") {
+      command.push(centerPoint.type, centerPoint.member);
+    }
+    if (centerPoint.type === "FROMLONLAT" || centerPoint.type === "fromlonlat") {
+      command.push(centerPoint.type, centerPoint.coordinate.lon, centerPoint.coordinate.lat);
+    }
+    if (shape.type === "BYRADIUS" || shape.type === "byradius") {
+      command.push(shape.type, shape.radius, shape.radiusType);
+    }
+    if (shape.type === "BYBOX" || shape.type === "bybox") {
+      command.push(shape.type, shape.rect.width, shape.rect.height, shape.rectType);
+    }
+    command.push(order);
+    if (opts?.count) {
+      command.push("COUNT", opts.count.limit, ...opts.count.any ? ["ANY"] : []);
+    }
+    super([...command, ...opts?.storeDist ? ["STOREDIST"] : []], commandOptions);
+  }
+};
+
 // pkg/commands/get.ts
 var GetCommand = class extends Command {
   constructor(cmd, opts) {
@@ -421,6 +845,27 @@ var GetDelCommand = class extends Command {
   }
 };
 
+// pkg/commands/getex.ts
+var GetExCommand = class extends Command {
+  constructor([key, opts], cmdOpts) {
+    const command = ["getex", key];
+    if (opts) {
+      if ("ex" in opts && typeof opts.ex === "number") {
+        command.push("ex", opts.ex);
+      } else if ("px" in opts && typeof opts.px === "number") {
+        command.push("px", opts.px);
+      } else if ("exat" in opts && typeof opts.exat === "number") {
+        command.push("exat", opts.exat);
+      } else if ("pxat" in opts && typeof opts.pxat === "number") {
+        command.push("pxat", opts.pxat);
+      } else if ("persist" in opts && opts.persist) {
+        command.push("persist");
+      }
+    }
+    super(command, cmdOpts);
+  }
+};
+
 // pkg/commands/getrange.ts
 var GetRangeCommand = class extends Command {
   constructor(cmd, opts) {
@@ -449,6 +894,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) {
@@ -462,16 +1023,12 @@ 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 {
-      const valueIsNumberAndNotSafeInteger = !Number.isNaN(Number(value)) && !Number.isSafeInteger(value);
-      if (valueIsNumberAndNotSafeInteger) {
-        obj[key] = value;
-      } else {
-        obj[key] = JSON.parse(value);
-      }
+      const valueIsNumberAndNotSafeInteger = !Number.isNaN(Number(value)) && !Number.isSafeInteger(Number(value));
+      obj[key] = valueIsNumberAndNotSafeInteger ? value : JSON.parse(value);
     } catch {
       obj[key] = value;
     }
@@ -517,15 +1074,15 @@ var HLenCommand = class extends Command {
 
 // pkg/commands/hmget.ts
 function deserialize2(fields, result) {
-  if (result.length === 0 || result.every((field) => field === null)) {
+  if (result.every((field) => field === null)) {
     return null;
   }
   const obj = {};
-  for (let i = 0; i < fields.length; i++) {
+  for (const [i, field] of fields.entries()) {
     try {
-      obj[fields[i]] = JSON.parse(result[i]);
+      obj[field] = JSON.parse(result[i]);
     } catch {
-      obj[fields[i]] = result[i];
+      obj[field] = result[i];
     }
   }
   return obj;
@@ -552,9 +1109,9 @@ function deserialize3(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 {
@@ -573,7 +1130,7 @@ var HRandFieldCommand = class extends Command {
       command.push("WITHVALUES");
     }
     super(command, {
-      // @ts-ignore TODO:
+      // @ts-expect-error to silence compiler
       deserialize: cmd[2] ? (result) => deserialize3(result) : opts?.deserialize,
       ...opts
     });
@@ -590,7 +1147,10 @@ var HScanCommand = class extends Command {
     if (typeof cmdOpts?.count === "number") {
       command.push("count", cmdOpts.count);
     }
-    super(command, opts);
+    super(command, {
+      deserialize: deserializeScanResponse,
+      ...opts
+    });
   }
 };
 
@@ -615,6 +1175,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) {
@@ -734,6 +1303,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) {
@@ -741,6 +1318,17 @@ var JsonMGetCommand = class extends Command {
   }
 };
 
+// pkg/commands/json_mset.ts
+var JsonMSetCommand = class extends Command {
+  constructor(cmd, opts) {
+    const command = ["JSON.MSET"];
+    for (const c of cmd) {
+      command.push(c.key, c.path, c.value);
+    }
+    super(command, opts);
+  }
+};
+
 // pkg/commands/json_numincrby.ts
 var JsonNumIncrByCommand = class extends Command {
   constructor(cmd, opts) {
@@ -854,6 +1442,14 @@ var LMoveCommand = class extends Command {
   }
 };
 
+// pkg/commands/lmpop.ts
+var LmPopCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [numkeys, keys, direction, count] = cmd;
+    super(["LMPOP", numkeys, ...keys, direction, ...count ? ["COUNT", count] : []], opts);
+  }
+};
+
 // pkg/commands/lpop.ts
 var LPopCommand = class extends Command {
   constructor(cmd, opts) {
@@ -938,7 +1534,7 @@ var MSetCommand = class extends Command {
 // pkg/commands/msetnx.ts
 var MSetNXCommand = class extends Command {
   constructor([kv], opts) {
-    super(["msetnx", ...Object.entries(kv).flatMap((_) => _)], opts);
+    super(["msetnx", ...Object.entries(kv).flat()], opts);
   }
 };
 
@@ -963,11 +1559,32 @@ var PExpireAtCommand = class extends Command {
   }
 };
 
+// pkg/commands/pfadd.ts
+var PfAddCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["pfadd", ...cmd], opts);
+  }
+};
+
+// pkg/commands/pfcount.ts
+var PfCountCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["pfcount", ...cmd], opts);
+  }
+};
+
+// pkg/commands/pfmerge.ts
+var PfMergeCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["pfmerge", ...cmd], opts);
+  }
+};
+
 // pkg/commands/ping.ts
 var PingCommand = class extends Command {
   constructor(cmd, opts) {
     const command = ["ping"];
-    if (typeof cmd !== "undefined" && typeof cmd[0] !== "undefined") {
+    if (cmd?.[0] !== void 0) {
       command.push(cmd[0]);
     }
     super(command, opts);
@@ -1054,10 +1671,16 @@ 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, cmdOpts);
+    super(command, {
+      // @ts-expect-error ignore types here
+      deserialize: opts?.withType ? deserializeScanWithTypesResponse : deserializeScanResponse,
+      ...cmdOpts
+    });
   }
 };
 
@@ -1250,7 +1873,10 @@ var SScanCommand = class extends Command {
     if (typeof opts?.count === "number") {
       command.push("count", opts.count);
     }
-    super(command, cmdOpts);
+    super(command, {
+      deserialize: deserializeScanResponse,
+      ...cmdOpts
+    });
   }
 };
 
@@ -1310,6 +1936,14 @@ var UnlinkCommand = class extends Command {
   }
 };
 
+// pkg/commands/xack.ts
+var XAckCommand = class extends Command {
+  constructor([key, group, id], opts) {
+    const ids = Array.isArray(id) ? [...id] : [id];
+    super(["XACK", key, group, ...ids], opts);
+  }
+};
+
 // pkg/commands/xadd.ts
 var XAddCommand = class extends Command {
   constructor([key, id, entries, opts], commandOptions) {
@@ -1320,7 +1954,7 @@ var XAddCommand = class extends Command {
       }
       if (opts.trim) {
         command.push(opts.trim.type, opts.trim.comparison, opts.trim.threshold);
-        if (typeof opts.trim.limit !== "undefined") {
+        if (opts.trim.limit !== void 0) {
           command.push("LIMIT", opts.trim.limit);
         }
       }
@@ -1333,19 +1967,152 @@ var XAddCommand = class extends Command {
   }
 };
 
+// pkg/commands/xautoclaim.ts
+var XAutoClaim = class extends Command {
+  constructor([key, group, consumer, minIdleTime, start, options], opts) {
+    const commands = [];
+    if (options?.count) {
+      commands.push("COUNT", options.count);
+    }
+    if (options?.justId) {
+      commands.push("JUSTID");
+    }
+    super(["XAUTOCLAIM", key, group, consumer, minIdleTime, start, ...commands], opts);
+  }
+};
+
+// pkg/commands/xclaim.ts
+var XClaimCommand = class extends Command {
+  constructor([key, group, consumer, minIdleTime, id, options], opts) {
+    const ids = Array.isArray(id) ? [...id] : [id];
+    const commands = [];
+    if (options?.idleMS) {
+      commands.push("IDLE", options.idleMS);
+    }
+    if (options?.idleMS) {
+      commands.push("TIME", options.timeMS);
+    }
+    if (options?.retryCount) {
+      commands.push("RETRYCOUNT", options.retryCount);
+    }
+    if (options?.force) {
+      commands.push("FORCE");
+    }
+    if (options?.justId) {
+      commands.push("JUSTID");
+    }
+    if (options?.lastId) {
+      commands.push("LASTID", options.lastId);
+    }
+    super(["XCLAIM", key, group, consumer, minIdleTime, ...ids, ...commands], opts);
+  }
+};
+
+// pkg/commands/xdel.ts
+var XDelCommand = class extends Command {
+  constructor([key, ids], opts) {
+    const cmds = Array.isArray(ids) ? [...ids] : [ids];
+    super(["XDEL", key, ...cmds], opts);
+  }
+};
+
+// pkg/commands/xgroup.ts
+var XGroupCommand = class extends Command {
+  constructor([key, opts], commandOptions) {
+    const command = ["XGROUP"];
+    switch (opts.type) {
+      case "CREATE": {
+        command.push("CREATE", key, opts.group, opts.id);
+        if (opts.options) {
+          if (opts.options.MKSTREAM) {
+            command.push("MKSTREAM");
+          }
+          if (opts.options.ENTRIESREAD !== void 0) {
+            command.push("ENTRIESREAD", opts.options.ENTRIESREAD.toString());
+          }
+        }
+        break;
+      }
+      case "CREATECONSUMER": {
+        command.push("CREATECONSUMER", key, opts.group, opts.consumer);
+        break;
+      }
+      case "DELCONSUMER": {
+        command.push("DELCONSUMER", key, opts.group, opts.consumer);
+        break;
+      }
+      case "DESTROY": {
+        command.push("DESTROY", key, opts.group);
+        break;
+      }
+      case "SETID": {
+        command.push("SETID", key, opts.group, opts.id);
+        if (opts.options?.ENTRIESREAD !== void 0) {
+          command.push("ENTRIESREAD", opts.options.ENTRIESREAD.toString());
+        }
+        break;
+      }
+      default: {
+        throw new Error("Invalid XGROUP");
+      }
+    }
+    super(command, commandOptions);
+  }
+};
+
+// pkg/commands/xinfo.ts
+var XInfoCommand = class extends Command {
+  constructor([key, options], opts) {
+    const cmds = [];
+    if (options.type === "CONSUMERS") {
+      cmds.push("CONSUMERS", key, options.group);
+    } else {
+      cmds.push("GROUPS", key);
+    }
+    super(["XINFO", ...cmds], opts);
+  }
+};
+
+// pkg/commands/xlen.ts
+var XLenCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["XLEN", ...cmd], opts);
+  }
+};
+
+// pkg/commands/xpending.ts
+var XPendingCommand = class extends Command {
+  constructor([key, group, start, end, count, options], opts) {
+    const consumers = options?.consumer === void 0 ? [] : Array.isArray(options.consumer) ? [...options.consumer] : [options.consumer];
+    super(
+      [
+        "XPENDING",
+        key,
+        group,
+        ...options?.idleTime ? ["IDLE", options.idleTime] : [],
+        start,
+        end,
+        count,
+        ...consumers
+      ],
+      opts
+    );
+  }
+};
+
 // pkg/commands/xrange.ts
 function deserialize4(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 {
@@ -1369,6 +2136,99 @@ var XRangeCommand = class extends Command {
   }
 };
 
+// pkg/commands/xread.ts
+var UNBALANCED_XREAD_ERR = "ERR Unbalanced XREAD list of streams: for each stream key an ID or '$' must be specified";
+var XReadCommand = class extends Command {
+  constructor([key, id, options], opts) {
+    if (Array.isArray(key) && Array.isArray(id) && key.length !== id.length) {
+      throw new Error(UNBALANCED_XREAD_ERR);
+    }
+    const commands = [];
+    if (typeof options?.count === "number") {
+      commands.push("COUNT", options.count);
+    }
+    if (typeof options?.blockMS === "number") {
+      commands.push("BLOCK", options.blockMS);
+    }
+    commands.push(
+      "STREAMS",
+      ...Array.isArray(key) ? [...key] : [key],
+      ...Array.isArray(id) ? [...id] : [id]
+    );
+    super(["XREAD", ...commands], opts);
+  }
+};
+
+// pkg/commands/xreadgroup.ts
+var UNBALANCED_XREADGROUP_ERR = "ERR Unbalanced XREADGROUP list of streams: for each stream key an ID or '$' must be specified";
+var XReadGroupCommand = class extends Command {
+  constructor([group, consumer, key, id, options], opts) {
+    if (Array.isArray(key) && Array.isArray(id) && key.length !== id.length) {
+      throw new Error(UNBALANCED_XREADGROUP_ERR);
+    }
+    const commands = [];
+    if (typeof options?.count === "number") {
+      commands.push("COUNT", options.count);
+    }
+    if (typeof options?.blockMS === "number") {
+      commands.push("BLOCK", options.blockMS);
+    }
+    if (typeof options?.NOACK === "boolean" && options.NOACK) {
+      commands.push("NOACK");
+    }
+    commands.push(
+      "STREAMS",
+      ...Array.isArray(key) ? [...key] : [key],
+      ...Array.isArray(id) ? [...id] : [id]
+    );
+    super(["XREADGROUP", "GROUP", group, consumer, ...commands], opts);
+  }
+};
+
+// pkg/commands/xrevrange.ts
+var XRevRangeCommand = class extends Command {
+  constructor([key, end, start, count], opts) {
+    const command = ["XREVRANGE", key, end, start];
+    if (typeof count === "number") {
+      command.push("COUNT", count);
+    }
+    super(command, {
+      deserialize: (result) => deserialize5(result),
+      ...opts
+    });
+  }
+};
+function deserialize5(result) {
+  const obj = {};
+  for (const e of result) {
+    for (let i = 0; i < e.length; i += 2) {
+      const streamId = e[i];
+      const entries = e[i + 1];
+      if (!(streamId in obj)) {
+        obj[streamId] = {};
+      }
+      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 {
+          obj[streamId][field] = value;
+        }
+      }
+    }
+  }
+  return obj;
+}
+
+// pkg/commands/xtrim.ts
+var XTrimCommand = class extends Command {
+  constructor([key, options], opts) {
+    const { limit, strategy, threshold, exactness = "~" } = options;
+    super(["XTRIM", key, strategy, exactness, threshold, ...limit ? ["LIMIT", limit] : []], opts);
+  }
+};
+
 // pkg/commands/zadd.ts
 var ZAddCommand = class extends Command {
   constructor([key, arg1, ...arg2], opts) {
@@ -1384,6 +2244,11 @@ var ZAddCommand = class extends Command {
     if ("incr" in arg1 && arg1.incr) {
       command.push("incr");
     }
+    if ("lt" in arg1 && arg1.lt) {
+      command.push("lt");
+    } else if ("gt" in arg1 && arg1.gt) {
+      command.push("gt");
+    }
     if ("score" in arg1 && "member" in arg1) {
       command.push(arg1.score, arg1.member);
     }
@@ -1478,7 +2343,7 @@ var ZRangeCommand = class extends Command {
     if (opts?.rev) {
       command.push("rev");
     }
-    if (typeof opts?.count !== "undefined" && typeof opts?.offset !== "undefined") {
+    if (opts?.count !== void 0 && opts.offset !== void 0) {
       command.push("limit", opts.offset, opts.count);
     }
     if (opts?.withScores) {
@@ -1540,7 +2405,10 @@ var ZScanCommand = class extends Command {
     if (typeof opts?.count === "number") {
       command.push("count", opts.count);
     }
-    super(command, cmdOpts);
+    super(command, {
+      deserialize: deserializeScanResponse,
+      ...cmdOpts
+    });
   }
 };
 
@@ -1569,7 +2437,7 @@ var ZUnionCommand = class extends Command {
       if ("aggregate" in opts) {
         command.push("aggregate", opts.aggregate);
       }
-      if (opts?.withScores) {
+      if (opts.withScores) {
         command.push("withscores");
       }
     }
@@ -1600,6 +2468,183 @@ var ZUnionStoreCommand = class extends Command {
   }
 };
 
+// pkg/commands/psubscribe.ts
+var PSubscribeCommand = class extends Command {
+  constructor(cmd, opts) {
+    const sseHeaders = {
+      Accept: "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    };
+    super([], {
+      ...opts,
+      headers: sseHeaders,
+      path: ["psubscribe", ...cmd],
+      streamOptions: {
+        isStreaming: true,
+        onMessage: opts?.streamOptions?.onMessage,
+        signal: opts?.streamOptions?.signal
+      }
+    });
+  }
+};
+
+// pkg/commands/subscribe.ts
+var Subscriber = class extends EventTarget {
+  subscriptions;
+  client;
+  listeners;
+  constructor(client, channels, isPattern = false) {
+    super();
+    this.client = client;
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
+    for (const channel of channels) {
+      if (isPattern) {
+        this.subscribeToPattern(channel);
+      } else {
+        this.subscribeToChannel(channel);
+      }
+    }
+  }
+  subscribeToChannel(channel) {
+    const controller = new AbortController();
+    const command = new SubscribeCommand([channel], {
+      streamOptions: {
+        signal: controller.signal,
+        onMessage: (data) => this.handleMessage(data, false)
+      }
+    });
+    command.exec(this.client).catch((error) => {
+      if (error.name !== "AbortError") {
+        this.dispatchToListeners("error", error);
+      }
+    });
+    this.subscriptions.set(channel, {
+      command,
+      controller,
+      isPattern: false
+    });
+  }
+  subscribeToPattern(pattern) {
+    const controller = new AbortController();
+    const command = new PSubscribeCommand([pattern], {
+      streamOptions: {
+        signal: controller.signal,
+        onMessage: (data) => this.handleMessage(data, true)
+      }
+    });
+    command.exec(this.client).catch((error) => {
+      if (error.name !== "AbortError") {
+        this.dispatchToListeners("error", error);
+      }
+    });
+    this.subscriptions.set(pattern, {
+      command,
+      controller,
+      isPattern: true
+    });
+  }
+  handleMessage(data, isPattern) {
+    const messageData = data.replace(/^data:\s*/, "");
+    const firstCommaIndex = messageData.indexOf(",");
+    const secondCommaIndex = messageData.indexOf(",", firstCommaIndex + 1);
+    const thirdCommaIndex = isPattern ? messageData.indexOf(",", secondCommaIndex + 1) : -1;
+    if (firstCommaIndex !== -1 && secondCommaIndex !== -1) {
+      const type = messageData.slice(0, firstCommaIndex);
+      if (isPattern && type === "pmessage" && thirdCommaIndex !== -1) {
+        const pattern = messageData.slice(firstCommaIndex + 1, secondCommaIndex);
+        const channel = messageData.slice(secondCommaIndex + 1, thirdCommaIndex);
+        const messageStr = messageData.slice(thirdCommaIndex + 1);
+        try {
+          const message = 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}`));
+        }
+      } else {
+        const channel = messageData.slice(firstCommaIndex + 1, secondCommaIndex);
+        const messageStr = messageData.slice(secondCommaIndex + 1);
+        try {
+          if (type === "subscribe" || type === "psubscribe" || type === "unsubscribe" || type === "punsubscribe") {
+            const count = Number.parseInt(messageStr);
+            this.dispatchToListeners(type, count);
+          } else {
+            const message = JSON.parse(messageStr);
+            this.dispatchToListeners(type, { channel, message });
+            this.dispatchToListeners(`${type}:${channel}`, { channel, message });
+          }
+        } catch (error) {
+          this.dispatchToListeners("error", new Error(`Failed to parse message: ${error}`));
+        }
+      }
+    }
+  }
+  dispatchToListeners(type, data) {
+    const listeners = this.listeners.get(type);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(data);
+      }
+    }
+  }
+  on(type, listener) {
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(type)?.add(listener);
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+  async unsubscribe(channels) {
+    if (channels) {
+      for (const channel of channels) {
+        const subscription = this.subscriptions.get(channel);
+        if (subscription) {
+          try {
+            subscription.controller.abort();
+          } catch {
+          }
+          this.subscriptions.delete(channel);
+        }
+      }
+    } else {
+      for (const subscription of this.subscriptions.values()) {
+        try {
+          subscription.controller.abort();
+        } catch {
+        }
+      }
+      this.subscriptions.clear();
+      this.removeAllListeners();
+    }
+  }
+  getSubscribedChannels() {
+    return [...this.subscriptions.keys()];
+  }
+};
+var SubscribeCommand = class extends Command {
+  constructor(cmd, opts) {
+    const sseHeaders = {
+      Accept: "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    };
+    super([], {
+      ...opts,
+      headers: sseHeaders,
+      path: ["subscribe", ...cmd],
+      streamOptions: {
+        isStreaming: true,
+        onMessage: opts?.streamOptions?.onMessage,
+        signal: opts?.streamOptions?.signal
+      }
+    });
+  }
+};
+
 // pkg/commands/zdiffstore.ts
 var ZDiffStoreCommand = class extends Command {
   constructor(cmd, opts) {
@@ -1626,20 +2671,21 @@ var Pipeline = class {
     this.commands = [];
     this.commandOptions = opts.commandOptions;
     this.multiExec = opts.multiExec ?? false;
+    if (this.commandOptions?.latencyLogging) {
+      const originalExec = this.exec.bind(this);
+      this.exec = async (options) => {
+        const start = performance.now();
+        const result = await (options ? originalExec(options) : originalExec());
+        const end = performance.now();
+        const loggerResult = (end - start).toFixed(2);
+        console.log(
+          `Latency for \x1B[38;2;19;185;39m${this.multiExec ? ["MULTI-EXEC"] : ["PIPELINE"].toString().toUpperCase()}\x1B[0m: \x1B[38;2;0;255;255m${loggerResult} ms\x1B[0m`
+        );
+        return result;
+      };
+    }
   }
-  /**
-   * Send the pipeline request to upstash.
-   *
-   * Returns an array with the results of all pipelined commands.
-   *
-   * If all commands are statically chained from start to finish, types are inferred. You can still define a return type manually if necessary though:
-   * ```ts
-   * const p = redis.pipeline()
-   * p.get("key")
-   * const result = p.exec<[{ greeting: string }]>()
-   * ```
-   */
-  exec = async () => {
+  exec = async (options) => {
     if (this.commands.length === 0) {
       throw new Error("Pipeline is empty");
     }
@@ -1648,7 +2694,12 @@ var Pipeline = class {
       path,
       body: Object.values(this.commands).map((c) => c.command)
     });
-    return res.map(({ error, result }, i) => {
+    return options?.keepErrors ? res.map(({ error, result }, i) => {
+      return {
+        error,
+        result: this.commands[i].deserialize(result)
+      };
+    }) : res.map(({ error, result }, i) => {
       if (error) {
         throw new UpstashError(
           `Command ${i + 1} [ ${this.commands[i].command[0]} ] failed: ${error}`
@@ -1678,7 +2729,24 @@ var Pipeline = class {
   /**
    * @see https://redis.io/commands/bitcount
    */
-  bitcount = (...args) => this.chain(new BitCountCommand(args, this.commandOptions));
+  bitcount = (...args) => this.chain(new BitCountCommand(args, this.commandOptions));
+  /**
+   * Returns an instance that can be used to execute `BITFIELD` commands on one key.
+   *
+   * @example
+   * ```typescript
+   * redis.set("mykey", 0);
+   * const result = await redis.pipeline()
+   *   .bitfield("mykey")
+   *   .set("u4", 0, 16)
+   *   .incr("u4", "#1", 1)
+   *   .exec();
+   * console.log(result); // [[0, 1]]
+   * ```
+   *
+   * @see https://redis.io/commands/bitfield
+   */
+  bitfield = (...args) => new BitFieldCommand(args, this.client, this.commandOptions, this.chain.bind(this));
   /**
    * @see https://redis.io/commands/bitop
    */
@@ -1689,6 +2757,10 @@ var Pipeline = class {
    * @see https://redis.io/commands/bitpos
    */
   bitpos = (...args) => this.chain(new BitPosCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/copy
+   */
+  copy = (...args) => this.chain(new CopyCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/zdiffstore
    */
@@ -1713,10 +2785,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
    */
@@ -1741,6 +2821,30 @@ var Pipeline = class {
    * @see https://redis.io/commands/flushdb
    */
   flushdb = (...args) => this.chain(new FlushDBCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/geoadd
+   */
+  geoadd = (...args) => this.chain(new GeoAddCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/geodist
+   */
+  geodist = (...args) => this.chain(new GeoDistCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/geopos
+   */
+  geopos = (...args) => this.chain(new GeoPosCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/geohash
+   */
+  geohash = (...args) => this.chain(new GeoHashCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/geosearch
+   */
+  geosearch = (...args) => this.chain(new GeoSearchCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/geosearchstore
+   */
+  geosearchstore = (...args) => this.chain(new GeoSearchStoreCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/get
    */
@@ -1753,6 +2857,10 @@ var Pipeline = class {
    * @see https://redis.io/commands/getdel
    */
   getdel = (...args) => this.chain(new GetDelCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/getex
+   */
+  getex = (...args) => this.chain(new GetExCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/getrange
    */
@@ -1769,6 +2877,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
    */
@@ -1861,6 +3005,10 @@ var Pipeline = class {
    * @see https://redis.io/commands/lpop
    */
   lpop = (...args) => this.chain(new LPopCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/lmpop
+   */
+  lmpop = (...args) => this.chain(new LmPopCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/lpos
    */
@@ -1913,6 +3061,18 @@ var Pipeline = class {
    * @see https://redis.io/commands/pexpireat
    */
   pexpireat = (...args) => this.chain(new PExpireAtCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/pfadd
+   */
+  pfadd = (...args) => this.chain(new PfAddCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/pfcount
+   */
+  pfcount = (...args) => this.chain(new PfCountCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/pfmerge
+   */
+  pfmerge = (...args) => this.chain(new PfMergeCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/ping
    */
@@ -1956,7 +3116,7 @@ var Pipeline = class {
   /**
    * @see https://redis.io/commands/sadd
    */
-  sadd = (key, ...members) => this.chain(new SAddCommand([key, ...members], this.commandOptions));
+  sadd = (key, member, ...members) => this.chain(new SAddCommand([key, member, ...members], this.commandOptions));
   /**
    * @see https://redis.io/commands/scan
    */
@@ -2083,10 +3243,7 @@ var Pipeline = class {
   zadd = (...args) => {
     if ("score" in args[1]) {
       return this.chain(
-        new ZAddCommand(
-          [args[0], args[1], ...args.slice(2)],
-          this.commandOptions
-        )
+        new ZAddCommand([args[0], args[1], ...args.slice(2)], this.commandOptions)
       );
     }
     return this.chain(
@@ -2096,6 +3253,62 @@ var Pipeline = class {
       )
     );
   };
+  /**
+   * @see https://redis.io/commands/xadd
+   */
+  xadd = (...args) => this.chain(new XAddCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/xack
+   */
+  xack = (...args) => this.chain(new XAckCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/xdel
+   */
+  xdel = (...args) => this.chain(new XDelCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/xgroup
+   */
+  xgroup = (...args) => this.chain(new XGroupCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/xread
+   */
+  xread = (...args) => this.chain(new XReadCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/xreadgroup
+   */
+  xreadgroup = (...args) => this.chain(new XReadGroupCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/xinfo
+   */
+  xinfo = (...args) => this.chain(new XInfoCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/xlen
+   */
+  xlen = (...args) => this.chain(new XLenCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/xpending
+   */
+  xpending = (...args) => this.chain(new XPendingCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/xclaim
+   */
+  xclaim = (...args) => this.chain(new XClaimCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/xautoclaim
+   */
+  xautoclaim = (...args) => this.chain(new XAutoClaim(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/xtrim
+   */
+  xtrim = (...args) => this.chain(new XTrimCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/xrange
+   */
+  xrange = (...args) => this.chain(new XRangeCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/xrevrange
+   */
+  xrevrange = (...args) => this.chain(new XRevRangeCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/zcard
    */
@@ -2213,22 +3426,22 @@ var Pipeline = class {
        * @see https://redis.io/commands/json.forget
        */
       forget: (...args) => this.chain(new JsonForgetCommand(args, this.commandOptions)),
-      /**
-       * @see https://redis.io/commands/geoadd
-       */
-      geoadd: (...args) => new GeoAddCommand(args, this.commandOptions).exec(this.client),
-      /**
-       * @see https://redis.io/commands/geodist
-       */
-      geodist: (...args) => new GeoDistCommand(args, this.commandOptions).exec(this.client),
       /**
        * @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
        */
       mget: (...args) => this.chain(new JsonMGetCommand(args, this.commandOptions)),
+      /**
+       * @see https://redis.io/commands/json.mset
+       */
+      mset: (...args) => this.chain(new JsonMSetCommand(args, this.commandOptions)),
       /**
        * @see https://redis.io/commands/json.numincrby
        */
@@ -2274,27 +3487,43 @@ var Pipeline = class {
 };
 
 // pkg/script.ts
-var import_enc_hex = __toESM(require("crypto-js/enc-hex"));
-var import_sha1 = __toESM(require("crypto-js/sha1"));
+var import_uncrypto = require("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);
   }
   /**
@@ -2304,19 +3533,87 @@ var Script = class {
    * Following calls will be able to use the cached script
    */
   async exec(keys, args) {
-    const res = await this.redis.evalsha(this.sha1, keys, args).catch(async (err) => {
-      if (err instanceof Error && err.message.toLowerCase().includes("noscript")) {
+    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);
       }
-      throw err;
+      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 import_uncrypto.subtle.digest("SHA-1", data);
+    const hashArray = [...new Uint8Array(hashBuffer)];
+    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+};
+
+// pkg/scriptRo.ts
+var import_uncrypto2 = require("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.
    */
-  digest(s) {
-    return import_enc_hex.default.stringify((0, import_sha1.default)(s));
+  async digest(s) {
+    const data = new TextEncoder().encode(s);
+    const hashBuffer = await import_uncrypto2.subtle.digest("SHA-1", data);
+    const hashArray = [...new Uint8Array(hashBuffer)];
+    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
   }
 };
 
@@ -2325,6 +3622,7 @@ var Redis = class {
   client;
   opts;
   enableTelemetry;
+  enableAutoPipelining;
   /**
    * Create a new redis client
    *
@@ -2340,6 +3638,16 @@ var Redis = class {
     this.client = client;
     this.opts = opts;
     this.enableTelemetry = opts?.enableTelemetry ?? true;
+    if (opts?.readYourWrites === false) {
+      this.client.readYourWrites = false;
+    }
+    this.enableAutoPipelining = opts?.enableAutoPipelining ?? true;
+  }
+  get readYourWritesSyncToken() {
+    return this.client.upstashSyncToken;
+  }
+  set readYourWritesSyncToken(session) {
+    this.client.upstashSyncToken = session;
   }
   get json() {
     return {
@@ -2379,22 +3687,22 @@ var Redis = class {
        * @see https://redis.io/commands/json.forget
        */
       forget: (...args) => new JsonForgetCommand(args, this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/commands/geoadd
-       */
-      geoadd: (...args) => new GeoAddCommand(args, this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/commands/geodist
-       */
-      geodist: (...args) => new GeoDistCommand(args, this.opts).exec(this.client),
       /**
        * @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
        */
       mget: (...args) => new JsonMGetCommand(args, this.opts).exec(this.client),
+      /**
+       * @see https://redis.io/commands/json.mset
+       */
+      mset: (...args) => new JsonMSetCommand(args, this.opts).exec(this.client),
       /**
        * @see https://redis.io/commands/json.numincrby
        */
@@ -2456,8 +3764,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.
@@ -2469,6 +3805,9 @@ var Redis = class {
     commandOptions: this.opts,
     multiExec: false
   });
+  autoPipeline = () => {
+    return createAutoPipelineProxy(this);
+  };
   /**
    * Create a new transaction to allow executing multiple steps atomically.
    *
@@ -2483,6 +3822,22 @@ var Redis = class {
     commandOptions: this.opts,
     multiExec: true
   });
+  /**
+   * Returns an instance that can be used to execute `BITFIELD` commands on one key.
+   *
+   * @example
+   * ```typescript
+   * redis.set("mykey", 0);
+   * const result = await redis.bitfield("mykey")
+   *   .set("u4", 0, 16)
+   *   .incr("u4", "#1", 1)
+   *   .exec();
+   * console.log(result); // [0, 1]
+   * ```
+   *
+   * @see https://redis.io/commands/bitfield
+   */
+  bitfield = (...args) => new BitFieldCommand(args, this.client, this.opts);
   /**
    * @see https://redis.io/commands/append
    */
@@ -2501,6 +3856,10 @@ var Redis = class {
    * @see https://redis.io/commands/bitpos
    */
   bitpos = (...args) => new BitPosCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/copy
+   */
+  copy = (...args) => new CopyCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/dbsize
    */
@@ -2521,14 +3880,26 @@ 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
    */
   evalsha = (...args) => new EvalshaCommand(args, this.opts).exec(this.client);
+  /**
+   * Generic method to execute any Redis command.
+   */
+  exec = (args) => new ExecCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/exists
    */
@@ -2549,6 +3920,30 @@ var Redis = class {
    * @see https://redis.io/commands/flushdb
    */
   flushdb = (...args) => new FlushDBCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/geoadd
+   */
+  geoadd = (...args) => new GeoAddCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/geopos
+   */
+  geopos = (...args) => new GeoPosCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/geodist
+   */
+  geodist = (...args) => new GeoDistCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/geohash
+   */
+  geohash = (...args) => new GeoHashCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/geosearch
+   */
+  geosearch = (...args) => new GeoSearchCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/geosearchstore
+   */
+  geosearchstore = (...args) => new GeoSearchStoreCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/get
    */
@@ -2561,6 +3956,10 @@ var Redis = class {
    * @see https://redis.io/commands/getdel
    */
   getdel = (...args) => new GetDelCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/getex
+   */
+  getex = (...args) => new GetExCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/getrange
    */
@@ -2577,6 +3976,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
    */
@@ -2669,6 +4104,10 @@ var Redis = class {
    * @see https://redis.io/commands/lpop
    */
   lpop = (...args) => new LPopCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/lmpop
+   */
+  lmpop = (...args) => new LmPopCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/lpos
    */
@@ -2721,6 +4160,18 @@ var Redis = class {
    * @see https://redis.io/commands/pexpireat
    */
   pexpireat = (...args) => new PExpireAtCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/pfadd
+   */
+  pfadd = (...args) => new PfAddCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/pfcount
+   */
+  pfcount = (...args) => new PfCountCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/pfmerge
+   */
+  pfmerge = (...args) => new PfMergeCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/ping
    */
@@ -2729,6 +4180,13 @@ 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);
+  };
   /**
    * @see https://redis.io/commands/pttl
    */
@@ -2764,11 +4222,10 @@ var Redis = class {
   /**
    * @see https://redis.io/commands/sadd
    */
-  sadd = (key, ...members) => new SAddCommand([key, ...members], this.opts).exec(this.client);
-  /**
-   * @see https://redis.io/commands/scan
-   */
-  scan = (...args) => new ScanCommand(args, this.opts).exec(this.client);
+  sadd = (key, member, ...members) => new SAddCommand([key, member, ...members], this.opts).exec(this.client);
+  scan(cursor, opts) {
+    return new ScanCommand([cursor, opts], this.opts).exec(this.client);
+  }
   /**
    * @see https://redis.io/commands/scard
    */
@@ -2857,6 +4314,13 @@ var Redis = class {
    * @see https://redis.io/commands/strlen
    */
   strlen = (...args) => new StrLenCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/subscribe
+   */
+  subscribe = (channels) => {
+    const channelArray = Array.isArray(channels) ? channels : [channels];
+    return new Subscriber(this.client, channelArray);
+  };
   /**
    * @see https://redis.io/commands/sunion
    */
@@ -2889,19 +4353,66 @@ var Redis = class {
    * @see https://redis.io/commands/xadd
    */
   xadd = (...args) => new XAddCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/xack
+   */
+  xack = (...args) => new XAckCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/xdel
+   */
+  xdel = (...args) => new XDelCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/xgroup
+   */
+  xgroup = (...args) => new XGroupCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/xread
+   */
+  xread = (...args) => new XReadCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/xreadgroup
+   */
+  xreadgroup = (...args) => new XReadGroupCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/xinfo
+   */
+  xinfo = (...args) => new XInfoCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/xlen
+   */
+  xlen = (...args) => new XLenCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/xpending
+   */
+  xpending = (...args) => new XPendingCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/xclaim
+   */
+  xclaim = (...args) => new XClaimCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/xautoclaim
+   */
+  xautoclaim = (...args) => new XAutoClaim(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/xtrim
+   */
+  xtrim = (...args) => new XTrimCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/xrange
    */
   xrange = (...args) => new XRangeCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/xrevrange
+   */
+  xrevrange = (...args) => new XRevRangeCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/zadd
    */
   zadd = (...args) => {
     if ("score" in args[1]) {
-      return new ZAddCommand(
-        [args[0], args[1], ...args.slice(2)],
-        this.opts
-      ).exec(this.client);
+      return new ZAddCommand([args[0], args[1], ...args.slice(2)], this.opts).exec(
+        this.client
+      );
     }
     return new ZAddCommand(
       [args[0], args[1], ...args.slice(2)],
@@ -2991,25 +4502,52 @@ var Redis = class {
 };
 
 // version.ts
-var VERSION = "v0.0.0-ci.8bd938831856fbab2f4aadc67ecb9de61efb6123";
+var VERSION = "v1.30.2";
 
 // platforms/nodejs.ts
 if (typeof atob === "undefined") {
-  global.atob = function(b64) {
-    return Buffer.from(b64, "base64").toString("utf-8");
-  };
+  global.atob = (b64) => Buffer.from(b64, "base64").toString("utf8");
 }
 var Redis2 = class _Redis extends Redis {
+  /**
+   * Create a new redis client by providing a custom `Requester` implementation
+   *
+   * @example
+   * ```ts
+   *
+   * import { UpstashRequest, Requester, UpstashResponse, Redis } from "@upstash/redis"
+   *
+   *  const requester: Requester = {
+   *    request: <TResult>(req: UpstashRequest): Promise<UpstashResponse<TResult>> => {
+   *      // ...
+   *    }
+   *  }
+   *
+   * const redis = new Redis(requester)
+   * ```
+   */
   constructor(configOrRequester) {
     if ("request" in configOrRequester) {
       super(configOrRequester);
       return;
     }
-    if (configOrRequester.url.startsWith(" ") || configOrRequester.url.endsWith(" ") || /\r|\n/.test(configOrRequester.url)) {
-      console.warn("The redis url contains whitespace or newline, which can cause errors!");
+    if (!configOrRequester.url) {
+      console.warn(
+        `[Upstash Redis] The 'url' property is missing or undefined in your Redis config.`
+      );
+    } else if (configOrRequester.url.startsWith(" ") || configOrRequester.url.endsWith(" ") || /\r|\n/.test(configOrRequester.url)) {
+      console.warn(
+        "[Upstash Redis] The redis url contains whitespace or newline, which can cause errors!"
+      );
     }
-    if (configOrRequester.token.startsWith(" ") || configOrRequester.token.endsWith(" ") || /\r|\n/.test(configOrRequester.token)) {
-      console.warn("The redis token contains whitespace or newline, which can cause errors!");
+    if (!configOrRequester.token) {
+      console.warn(
+        `[Upstash Redis] The 'token' property is missing or undefined in your Redis config.`
+      );
+    } else if (configOrRequester.token.startsWith(" ") || configOrRequester.token.endsWith(" ") || /\r|\n/.test(configOrRequester.token)) {
+      console.warn(
+        "[Upstash Redis] The redis token contains whitespace or newline, which can cause errors!"
+      );
     }
     const client = new HttpClient({
       baseUrl: configOrRequester.url,
@@ -3017,18 +4555,28 @@ var Redis2 = class _Redis extends Redis {
       headers: { authorization: `Bearer ${configOrRequester.token}` },
       agent: configOrRequester.agent,
       responseEncoding: configOrRequester.responseEncoding,
-      cache: configOrRequester.cache || "no-store"
+      cache: configOrRequester.cache ?? "no-store",
+      signal: configOrRequester.signal,
+      keepAlive: configOrRequester.keepAlive,
+      readYourWrites: configOrRequester.readYourWrites
     });
     super(client, {
       automaticDeserialization: configOrRequester.automaticDeserialization,
-      enableTelemetry: !process.env.UPSTASH_DISABLE_TELEMETRY
+      enableTelemetry: !process.env.UPSTASH_DISABLE_TELEMETRY,
+      latencyLogging: configOrRequester.latencyLogging,
+      enableAutoPipelining: configOrRequester.enableAutoPipelining
     });
     this.addTelemetry({
-      // @ts-ignore
-      runtime: typeof EdgeRuntime === "string" ? "edge-light" : `node@${process.version}`,
-      platform: process.env.VERCEL ? "vercel" : process.env.AWS_REGION ? "aws" : "unknown",
+      runtime: (
+        // @ts-expect-error to silence compiler
+        typeof EdgeRuntime === "string" ? "edge-light" : `node@${process.version}`
+      ),
+      platform: process.env.UPSTASH_CONSOLE ? "console" : process.env.VERCEL ? "vercel" : process.env.AWS_REGION ? "aws" : "unknown",
       sdk: `@upstash/redis@${VERSION}`
     });
+    if (this.enableAutoPipelining) {
+      return this.autoPipeline();
+    }
   }
   /**
    * Create a new Upstash Redis instance from environment variables.
@@ -3040,24 +4588,26 @@ var Redis2 = class _Redis extends Redis {
    * your environment using `process.env`.
    */
   static fromEnv(config) {
-    if (typeof process?.env === "undefined") {
-      throw new Error(
-        'Unable to get environment variables, `process.env` is undefined. If you are deploying to cloudflare, please import from "@upstash/redis/cloudflare" instead'
+    if (process.env === void 0) {
+      throw new TypeError(
+        '[Upstash Redis] Unable to get environment variables, `process.env` is undefined. If you are deploying to cloudflare, please import from "@upstash/redis/cloudflare" instead'
       );
     }
-    const url = process?.env["UPSTASH_REDIS_REST_URL"];
+    const url = process.env.UPSTASH_REDIS_REST_URL || process.env.KV_REST_API_URL;
     if (!url) {
-      throw new Error("Unable to find environment variable: `UPSTASH_REDIS_REST_URL`");
+      console.warn("[Upstash Redis] Unable to find environment variable: `UPSTASH_REDIS_REST_URL`");
     }
-    const token = process?.env["UPSTASH_REDIS_REST_TOKEN"];
+    const token = process.env.UPSTASH_REDIS_REST_TOKEN || process.env.KV_REST_API_TOKEN;
     if (!token) {
-      throw new Error("Unable to find environment variable: `UPSTASH_REDIS_REST_TOKEN`");
+      console.warn(
+        "[Upstash Redis] Unable to find environment variable: `UPSTASH_REDIS_REST_TOKEN`"
+      );
     }
     return new _Redis({ ...config, url, token });
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Redis
+  Redis,
+  errors
 });
-//# sourceMappingURL=nodejs.js.map