@crvouga/mockingbird-service-redis 0.1.0

package/dist/chunk-4HDEOTYJ.js

@@ -0,0 +1,4767 @@
+// src/clock.ts
+function manualClock(start = 0) {
+  let current = start;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    manual: true,
+    now: () => current,
+    advance(ms) {
+      current += ms;
+      for (const listener of [...listeners]) listener();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+function wallClock() {
+  let offset = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    manual: false,
+    now: () => Date.now() + offset,
+    advance(ms) {
+      offset += ms;
+      for (const listener of [...listeners]) listener();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+
+// src/bytes.ts
+function latin1(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) out += String.fromCharCode(bytes[i] ?? 0);
+  return out;
+}
+function fromLatin1(value) {
+  const out = new Uint8Array(value.length);
+  for (let i = 0; i < value.length; i++) out[i] = value.charCodeAt(i) & 255;
+  return out;
+}
+function utf8(value) {
+  return new TextEncoder().encode(value);
+}
+function utf8Text(bytes) {
+  return new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+}
+function cmpBytes(a, b) {
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) {
+    const d = (a[i] ?? 0) - (b[i] ?? 0);
+    if (d !== 0) return d;
+  }
+  return a.length - b.length;
+}
+var INT64_MAX = 9223372036854775807n;
+var INT64_MIN = -9223372036854775808n;
+function parseI64(bytes) {
+  const text2 = latin1(bytes);
+  if (!/^-?\d+$/.test(text2)) return null;
+  try {
+    const value = BigInt(text2);
+    if (value > INT64_MAX || value < INT64_MIN) return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+function intReply(value) {
+  if (value <= BigInt(Number.MAX_SAFE_INTEGER) && value >= BigInt(Number.MIN_SAFE_INTEGER)) {
+    return Number(value);
+  }
+  return value;
+}
+function globMatch(pattern, value) {
+  const match = (p, v) => {
+    if (p === pattern.length) return v === value.length;
+    const ch = pattern[p];
+    if (ch === "\\") {
+      if (p + 1 >= pattern.length) return false;
+      if (v >= value.length || value[v] !== pattern[p + 1]) return false;
+      return match(p + 2, v + 1);
+    }
+    if (ch === "*") {
+      for (let i = v; i <= value.length; i++) if (match(p + 1, i)) return true;
+      return false;
+    }
+    if (ch === "?") {
+      if (v >= value.length) return false;
+      return match(p + 1, v + 1);
+    }
+    if (ch === "[") {
+      if (v >= value.length) return false;
+      let i = p + 1;
+      let negate = false;
+      if (pattern[i] === "^" || pattern[i] === "!") {
+        negate = true;
+        i++;
+      }
+      let ok2 = false;
+      if (pattern[i] === "]") return false;
+      while (i < pattern.length && pattern[i] !== "]") {
+        if (pattern[i] === "\\" && i + 1 < pattern.length) i++;
+        const start = pattern[i] ?? "";
+        if (pattern[i + 1] === "-" && pattern[i + 2] !== void 0 && pattern[i + 2] !== "]") {
+          const end = pattern[i + 2] ?? "";
+          const cur = value[v] ?? "";
+          if (cur >= start && cur <= end) ok2 = true;
+          i += 3;
+        } else {
+          if (value[v] === start) ok2 = true;
+          i++;
+        }
+      }
+      if (pattern[i] !== "]") return false;
+      if (ok2 === negate) return false;
+      return match(i + 1, v + 1);
+    }
+    if (v >= value.length || value[v] !== ch) return false;
+    return match(p + 1, v + 1);
+  };
+  return match(0, 0);
+}
+
+// src/protocol.ts
+var ok = () => ({ t: "simple", v: "OK" });
+var queued = () => ({ t: "simple", v: "QUEUED" });
+var simple = (v) => ({ t: "simple", v });
+var err = (v) => ({ t: "error", v });
+var int = (v) => ({ t: "int", v });
+var bulk = (v) => ({
+  t: "bulk",
+  v: v === null ? null : typeof v === "string" ? utf8(v) : v
+});
+var arr = (v) => ({ t: "array", v });
+var nil = () => ({ t: "bulk", v: null });
+var nilArray = () => ({ t: "array", v: null });
+var push = (v) => ({ t: "push", v });
+var map = (v) => ({ t: "map", v });
+var wrongType = () => err("WRONGTYPE Operation against a key holding the wrong kind of value");
+function arityError(name) {
+  return err(`ERR wrong number of arguments for '${name}' command`);
+}
+var syntaxError = () => err("ERR syntax error");
+function unknownCommand(name, args) {
+  const shown = args.slice(0, 10).map((arg) => `'${latin1(arg)}'`).join(" ");
+  const extra = shown.length > 0 ? `${shown} ` : "";
+  return err(`ERR unknown command '${name}', with args beginning with: ${extra}`);
+}
+var notInteger = () => err("ERR value is not an integer or out of range");
+var notFloat = () => err("ERR value is not a valid float");
+var noScript = () => err("NOSCRIPT No matching script. Please use EVAL.");
+var readonlyError = () => err("READONLY You can't write against a read only replica.");
+var oomError = () => err("OOM command not allowed when used memory > 'maxmemory'.");
+var busyError = () => err("BUSY Redis is busy running a script. You can only call SCRIPT KILL or SHUTDOWN NOSAVE.");
+var noAuth = () => err("NOAUTH Authentication required.");
+var wrongPass = () => err("WRONGPASS invalid username-password pair or user is disabled.");
+function authWithoutPassword(password) {
+  return err(
+    `ERR AUTH <${password}> called without any password configured for the default user. Are you sure your configuration is correct?`
+  );
+}
+var clusterDisabled = () => err("ERR This instance has cluster support disabled");
+var noSuchKey = () => err("ERR no such key");
+var execWithoutMulti = () => err("ERR EXEC without MULTI");
+var discardWithoutMulti = () => err("ERR DISCARD without MULTI");
+var nestedMulti = () => err("ERR MULTI calls can not be nested");
+var execAbort = () => err("EXECABORT Transaction discarded because of previous errors.");
+var scriptDenied = () => err("ERR This Redis command is not allowed from scripts");
+var notBusy = () => err("NOTBUSY No scripts in execution right now.");
+function pubsubOnly(name) {
+  return err(
+    `ERR Can't execute '${name}': only (P|S)SUBSCRIBE / (P|S)UNSUBSCRIBE / PING / QUIT / RESET are allowed in this context`
+  );
+}
+function noPerm(name) {
+  return err(`NOPERM this user has no permissions to run the '${name}' command`);
+}
+var CRLF = utf8("\r\n");
+function concat(parts) {
+  let size = 0;
+  for (const part of parts) size += part.length;
+  const out = new Uint8Array(size);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function formatDouble(value) {
+  if (Number.isNaN(value)) return "nan";
+  if (value === Infinity) return "inf";
+  if (value === -Infinity) return "-inf";
+  if (Object.is(value, -0)) return "-0";
+  if (Number.isInteger(value)) return String(value);
+  return String(value);
+}
+function encodeReply(reply, protocol = 2) {
+  const parts = [];
+  const text2 = (value) => {
+    parts.push(utf8(value));
+  };
+  const walk = (value) => {
+    switch (value.t) {
+      case "simple":
+        text2(`+${value.v}\r
+`);
+        return;
+      case "error":
+        text2(`-${value.v}\r
+`);
+        return;
+      case "int":
+        text2(`:${value.v.toString()}\r
+`);
+        return;
+      case "bulk":
+        if (value.v === null) {
+          text2(protocol === 3 ? "_\r\n" : "$-1\r\n");
+          return;
+        }
+        text2(`$${value.v.length}\r
+`);
+        parts.push(value.v);
+        parts.push(CRLF);
+        return;
+      case "array":
+        if (value.v === null) {
+          text2(protocol === 3 ? "_\r\n" : "*-1\r\n");
+          return;
+        }
+        text2(`*${value.v.length}\r
+`);
+        for (const item of value.v) walk(item);
+        return;
+      case "null":
+        text2(protocol === 3 ? "_\r\n" : "$-1\r\n");
+        return;
+      case "bool":
+        if (protocol === 3) text2(value.v ? "#t\r\n" : "#f\r\n");
+        else text2(value.v ? ":1\r\n" : ":0\r\n");
+        return;
+      case "double":
+        if (protocol === 3) text2(`,${formatDouble(value.v)}\r
+`);
+        else walk(bulk(formatDouble(value.v)));
+        return;
+      case "map":
+        if (protocol === 3) {
+          text2(`%${value.v.length}\r
+`);
+          for (const [key, item] of value.v) {
+            walk(key);
+            walk(item);
+          }
+          return;
+        }
+        text2(`*${value.v.length * 2}\r
+`);
+        for (const [key, item] of value.v) {
+          walk(key);
+          walk(item);
+        }
+        return;
+      case "push":
+        text2(protocol === 3 ? `>${value.v.length}\r
+` : `*${value.v.length}\r
+`);
+        for (const item of value.v) walk(item);
+        return;
+      default: {
+        const never = value;
+        throw new Error(`unknown reply ${never.t}`);
+      }
+    }
+  };
+  walk(reply);
+  return concat(parts);
+}
+var RespParser = class {
+  buf = new Uint8Array(0);
+  pos = 0;
+  push(chunk) {
+    if (this.pos > 0) this.buf = this.buf.slice(this.pos);
+    this.pos = 0;
+    if (chunk.length > 0) {
+      const next = new Uint8Array(this.buf.length + chunk.length);
+      next.set(this.buf);
+      next.set(chunk, this.buf.length);
+      this.buf = next;
+    }
+    const out = [];
+    while (this.pos < this.buf.length) {
+      const saved = this.pos;
+      const reply = this.tryOne();
+      if (reply === void 0) {
+        this.pos = saved;
+        break;
+      }
+      out.push(reply);
+    }
+    return out;
+  }
+  tryOne() {
+    if (this.pos >= this.buf.length) return void 0;
+    const marker = this.buf[this.pos] ?? 0;
+    if (marker !== 43 && marker !== 45 && marker !== 58 && marker !== 36 && marker !== 42 && marker !== 95 && marker !== 35 && marker !== 44 && marker !== 37 && marker !== 126 && marker !== 62 && marker !== 33) {
+      return this.inline();
+    }
+    this.pos++;
+    if (marker === 43) {
+      const line = this.readLine();
+      if (line === null) return void 0;
+      return simple(line);
+    }
+    if (marker === 45) {
+      const line = this.readLine();
+      if (line === null) return void 0;
+      return err(line);
+    }
+    if (marker === 58) {
+      const line = this.readLine();
+      if (line === null) return void 0;
+      if (!/^-?\d+$/.test(line)) return err("ERR protocol error: invalid integer");
+      const value = BigInt(line);
+      return int(
+        value <= BigInt(Number.MAX_SAFE_INTEGER) && value >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(value) : value
+      );
+    }
+    if (marker === 36) return this.bulk();
+    if (marker === 42) return this.aggregate("array");
+    if (marker === 95) {
+      const line = this.readLine();
+      if (line === null) return void 0;
+      return { t: "null" };
+    }
+    if (marker === 35) {
+      const line = this.readLine();
+      if (line === null) return void 0;
+      return { t: "bool", v: line === "t" };
+    }
+    if (marker === 44) {
+      const line = this.readLine();
+      if (line === null) return void 0;
+      return { t: "double", v: Number(line) };
+    }
+    if (marker === 37) return this.map();
+    if (marker === 126) return this.aggregate("set");
+    if (marker === 62) return this.aggregate("push");
+    if (marker === 33) return this.bulk();
+    return void 0;
+  }
+  inline() {
+    const line = this.readLine();
+    if (line === null) return void 0;
+    if (line.length === 0) return arr([]);
+    const parts = [];
+    let current = "";
+    let quote = null;
+    for (let i = 0; i < line.length; i++) {
+      const ch = line[i];
+      if (quote) {
+        if (ch === quote) quote = null;
+        else current += ch ?? "";
+        continue;
+      }
+      if (ch === "'" || ch === '"') {
+        quote = ch;
+        continue;
+      }
+      if (ch === " ") {
+        if (current.length > 0) {
+          parts.push(current);
+          current = "";
+        }
+        continue;
+      }
+      current += ch ?? "";
+    }
+    if (current.length > 0) parts.push(current);
+    return arr(parts.map((part) => bulk(fromLatin1(part))));
+  }
+  readLine() {
+    for (let i = this.pos; i < this.buf.length; i++) {
+      if (this.buf[i] !== 10) continue;
+      let end = i;
+      if (end > this.pos && this.buf[end - 1] === 13) end--;
+      const line = latin1(this.buf.subarray(this.pos, end));
+      this.pos = i + 1;
+      return line;
+    }
+    return null;
+  }
+  bulk() {
+    const line = this.readLine();
+    if (line === null) return void 0;
+    const size = Number(line);
+    if (!Number.isInteger(size)) return err("ERR protocol error: invalid bulk length");
+    if (size < 0) return nil();
+    if (this.buf.length < this.pos + size + 2) return void 0;
+    const value = this.buf.slice(this.pos, this.pos + size);
+    this.pos += size + 2;
+    return { t: "bulk", v: value };
+  }
+  aggregate(kind) {
+    const line = this.readLine();
+    if (line === null) return void 0;
+    const count = Number(line);
+    if (!Number.isInteger(count)) return err("ERR protocol error: invalid multibulk length");
+    if (count < 0) return nilArray();
+    const items = [];
+    for (let i = 0; i < count; i++) {
+      const item = this.tryOne();
+      if (item === void 0) return void 0;
+      items.push(item);
+    }
+    if (kind === "push") return push(items);
+    return arr(items);
+  }
+  map() {
+    const line = this.readLine();
+    if (line === null) return void 0;
+    const count = Number(line);
+    if (!Number.isInteger(count) || count < 0) return err("ERR protocol error: invalid map length");
+    const pairs = [];
+    for (let i = 0; i < count; i++) {
+      const key = this.tryOne();
+      if (key === void 0) return void 0;
+      const value = this.tryOne();
+      if (value === void 0) return void 0;
+      pairs.push([key, value]);
+    }
+    return map(pairs);
+  }
+};
+function asCommand(reply) {
+  if (reply.t !== "array" || reply.v === null || reply.v.length === 0) {
+    return err("ERR protocol error: expected command array");
+  }
+  const name = reply.v[0];
+  if (name?.t !== "bulk" || name.v === null) return err("ERR protocol error: expected command name");
+  const args = [];
+  for (let i = 1; i < reply.v.length; i++) {
+    const arg = reply.v[i];
+    if (arg?.t !== "bulk" || arg.v === null)
+      return err("ERR protocol error: expected bulk argument");
+    args.push(arg.v);
+  }
+  return { name: latin1(name.v), args };
+}
+
+// src/sha1.ts
+var K = [1518500249, 1859775393, 2400959708, 3395469782];
+function rotl(value, bits) {
+  return (value << bits | value >>> 32 - bits) >>> 0;
+}
+function sha1Hex(data) {
+  const bitLength = data.length * 8;
+  const padded = new Uint8Array((data.length + 9 + 63 & ~63) >>> 0);
+  padded.set(data);
+  padded[data.length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 8, Math.floor(bitLength / 4294967296), false);
+  view.setUint32(padded.length - 4, bitLength >>> 0, false);
+  let h0 = 1732584193;
+  let h1 = 4023233417;
+  let h2 = 2562383102;
+  let h3 = 271733878;
+  let h4 = 3285377520;
+  const w = new Uint32Array(80);
+  for (let offset = 0; offset < padded.length; offset += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(offset + i * 4, false);
+    for (let i = 16; i < 80; i++) {
+      w[i] = rotl((w[i - 3] ?? 0) ^ (w[i - 8] ?? 0) ^ (w[i - 14] ?? 0) ^ (w[i - 16] ?? 0), 1);
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    for (let i = 0; i < 80; i++) {
+      const stage = Math.floor(i / 20);
+      let f = 0;
+      if (stage === 0) f = b & c | ~b & d;
+      else if (stage === 1 || stage === 3) f = b ^ c ^ d;
+      else f = b & c | b & d | c & d;
+      const temp = rotl(a, 5) + f + e + (K[stage] ?? 0) + (w[i] ?? 0) >>> 0;
+      e = d;
+      d = c;
+      c = rotl(b, 30);
+      b = a;
+      a = temp;
+    }
+    h0 = h0 + a >>> 0;
+    h1 = h1 + b >>> 0;
+    h2 = h2 + c >>> 0;
+    h3 = h3 + d >>> 0;
+    h4 = h4 + e >>> 0;
+  }
+  return [h0, h1, h2, h3, h4].map((part) => part.toString(16).padStart(8, "0")).join("");
+}
+
+// src/lua.ts
+var LuaTable = class {
+  array = /* @__PURE__ */ new Map();
+  map = /* @__PURE__ */ new Map();
+  set(key, value) {
+    if (typeof key === "number" && Number.isInteger(key) && key >= 1) {
+      if (value === null) this.array.delete(key);
+      else this.array.set(key, value);
+      return;
+    }
+    const name = keyString(key);
+    if (value === null) this.map.delete(name);
+    else this.map.set(name, value);
+  }
+  get(key) {
+    if (typeof key === "number" && Number.isInteger(key) && key >= 1) {
+      return this.array.has(key) ? this.array.get(key) ?? null : null;
+    }
+    const name = keyString(key);
+    return this.map.has(name) ? this.map.get(name) ?? null : null;
+  }
+  has(key) {
+    if (typeof key === "number" && Number.isInteger(key) && key >= 1) return this.array.has(key);
+    return this.map.has(keyString(key));
+  }
+  length() {
+    let n = 0;
+    while (this.array.has(n + 1)) n++;
+    return n;
+  }
+};
+var LuaStatus = class {
+  constructor(ok2) {
+    this.ok = ok2;
+  }
+  ok;
+};
+var LuaFailure = class {
+  constructor(err2) {
+    this.err = err2;
+  }
+  err;
+};
+var LuaClosure = class {
+  constructor(params, vararg, body, env) {
+    this.params = params;
+    this.vararg = vararg;
+    this.body = body;
+    this.env = env;
+  }
+  params;
+  vararg;
+  body;
+  env;
+};
+function keyString(key) {
+  if (typeof key === "string") return key;
+  if (typeof key === "number") return String(key);
+  if (typeof key === "boolean") return key ? "true" : "false";
+  if (key === null) throw new Error("table index is nil");
+  return `value:${typeof key}`;
+}
+var Env = class {
+  constructor(parent) {
+    this.parent = parent;
+  }
+  parent;
+  vars = /* @__PURE__ */ new Map();
+  varargs = [];
+  get(name) {
+    if (this.vars.has(name)) return this.vars.get(name) ?? null;
+    return this.parent ? this.parent.get(name) : null;
+  }
+  define(name, value) {
+    this.vars.set(name, value);
+  }
+  set(name, value) {
+    if (this.vars.has(name) || this.parent === null) {
+      this.vars.set(name, value);
+      return;
+    }
+    this.parent.set(name, value);
+  }
+};
+var NEXT = { k: "next" };
+function truthy(value) {
+  return value !== null && value !== false;
+}
+function luaEqual(a, b) {
+  if (typeof a === "number" && typeof b === "string") return numberEqualsString(a, b);
+  if (typeof b === "number" && typeof a === "string") return numberEqualsString(b, a);
+  if (a instanceof LuaTable || b instanceof LuaTable) return a === b;
+  return a === b;
+}
+function numberEqualsString(value, text2) {
+  const trimmed = text2.trim();
+  if (!/^[-+]?\d+(\.\d+)?([eE][-+]?\d+)?$/.test(trimmed)) return false;
+  return Number(trimmed) === value;
+}
+function asNumber(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && /^[-+]?\d+(\.\d+)?([eE][-+]?\d+)?$/.test(value.trim())) {
+    return Number(value.trim());
+  }
+  throw new Error("attempt to perform arithmetic on a non-number");
+}
+function asString(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return Number.isInteger(value) ? String(value) : String(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (value === null) throw new Error("attempt to concatenate a nil value");
+  throw new Error("attempt to concatenate a non-string value");
+}
+function execBlock(body, env) {
+  for (const stmt of body) {
+    const flow = exec(stmt, env);
+    if (flow.k !== "next") return flow;
+  }
+  return NEXT;
+}
+function exec(stmt, env) {
+  switch (stmt.k) {
+    case "if": {
+      for (const arm of stmt.arms) {
+        if (truthy(first(evalExpr(arm.cond, env)))) return execBlock(arm.body, new Env(env));
+      }
+      return execBlock(stmt.elseBody, new Env(env));
+    }
+    case "while": {
+      while (truthy(first(evalExpr(stmt.cond, env)))) {
+        const flow = execBlock(stmt.body, new Env(env));
+        if (flow.k === "return") return flow;
+        if (flow.k === "break") break;
+      }
+      return NEXT;
+    }
+    case "for": {
+      const start = asNumber(first(evalExpr(stmt.start, env)));
+      const stop = asNumber(first(evalExpr(stmt.stop, env)));
+      const step = stmt.step ? asNumber(first(evalExpr(stmt.step, env))) : 1;
+      if (step === 0) throw new Error("'for' step is zero");
+      for (let i = start; step > 0 ? i <= stop : i >= stop; i += step) {
+        const local = new Env(env);
+        local.define(stmt.name, i);
+        const flow = execBlock(stmt.body, local);
+        if (flow.k === "return") return flow;
+        if (flow.k === "break") break;
+      }
+      return NEXT;
+    }
+    case "forin": {
+      const produced = evalList(stmt.iter, env);
+      const iter = produced[0] ?? null;
+      const state = produced[1] ?? null;
+      let control = produced[2] ?? null;
+      if (typeof iter !== "function" && !(iter instanceof LuaClosure)) {
+        throw new Error("attempt to call a non-function");
+      }
+      for (; ; ) {
+        const values = callValue(iter, [state, control]);
+        const next = values[0] ?? null;
+        if (next === null) break;
+        control = next;
+        const local = new Env(env);
+        stmt.names.forEach((name, index) => {
+          local.define(name, values[index] ?? null);
+        });
+        const flow = execBlock(stmt.body, local);
+        if (flow.k === "return") return flow;
+        if (flow.k === "break") break;
+      }
+      return NEXT;
+    }
+    case "do":
+      return execBlock(stmt.body, new Env(env));
+    case "return":
+      return { k: "return", values: evalList(stmt.values, env) };
+    case "local": {
+      const values = evalList(stmt.values, env);
+      stmt.names.forEach((name, index) => {
+        env.define(name, values[index] ?? null);
+      });
+      return NEXT;
+    }
+    case "localfn": {
+      const closure = new LuaClosure(stmt.params, stmt.vararg, stmt.body, env);
+      env.define(stmt.name, closure);
+      return NEXT;
+    }
+    case "assign": {
+      const values = evalList(stmt.values, env);
+      stmt.targets.forEach((target, index) => {
+        assign(target, values[index] ?? null, env);
+      });
+      return NEXT;
+    }
+    case "call":
+      evalExpr(stmt.expr, env);
+      return NEXT;
+    case "break":
+      return { k: "break" };
+    default: {
+      const never = stmt;
+      return never;
+    }
+  }
+}
+function assign(target, value, env) {
+  if (target.k === "name") {
+    env.set(target.name, value);
+    return;
+  }
+  const table = first(evalExpr(target.k === "index" ? target.table : target.table, env));
+  if (!(table instanceof LuaTable)) throw new Error("attempt to index a non-table");
+  if (target.k === "field") table.set(target.name, value);
+  else table.set(first(evalExpr(target.key, env)), value);
+}
+function evalList(exprs, env) {
+  if (exprs.length === 0) return [];
+  const out = [];
+  for (let i = 0; i < exprs.length; i++) {
+    const expr = exprs[i];
+    if (!expr) continue;
+    const values = evalExpr(expr, env);
+    if (i === exprs.length - 1) out.push(...values);
+    else out.push(values[0] ?? null);
+  }
+  return out;
+}
+function first(values) {
+  return values[0] ?? null;
+}
+function evalExpr(expr, env) {
+  switch (expr.k) {
+    case "nil":
+      return [null];
+    case "bool":
+      return [expr.v];
+    case "num":
+      return [expr.v];
+    case "str":
+      return [expr.v];
+    case "name":
+      return [env.get(expr.v)];
+    case "dots":
+      return env.varargs;
+    case "un": {
+      const value = first(evalExpr(expr.e, env));
+      if (expr.op === "not") return [!truthy(value)];
+      if (expr.op === "#") {
+        if (typeof value === "string") return [value.length];
+        if (value instanceof LuaTable) return [value.length()];
+        throw new Error("attempt to get length of a non-table");
+      }
+      return [-asNumber(value)];
+    }
+    case "bin": {
+      if (expr.op === "..") {
+        return [asString(first(evalExpr(expr.l, env))) + asString(first(evalExpr(expr.r, env)))];
+      }
+      if (expr.op === "==" || expr.op === "~=") {
+        const equal = luaEqual(first(evalExpr(expr.l, env)), first(evalExpr(expr.r, env)));
+        return [expr.op === "==" ? equal : !equal];
+      }
+      if (expr.op === "<" || expr.op === ">" || expr.op === "<=" || expr.op === ">=") {
+        const op = expr.op;
+        return [
+          compare(
+            expr.l,
+            expr.r,
+            env,
+            (a, b) => op === "<" ? a < b : op === ">" ? a > b : op === "<=" ? a <= b : a >= b
+          )
+        ];
+      }
+      const left = asNumber(first(evalExpr(expr.l, env)));
+      const right = asNumber(first(evalExpr(expr.r, env)));
+      switch (expr.op) {
+        case "+":
+          return [left + right];
+        case "-":
+          return [left - right];
+        case "*":
+          return [left * right];
+        case "/":
+          return [left / right];
+        case "%":
+          return [left % right];
+        case "^":
+          return [left ** right];
+        default:
+          throw new Error(`unexpected operator ${expr.op}`);
+      }
+    }
+    case "and": {
+      const left = evalExpr(expr.l, env);
+      if (!truthy(first(left))) return [first(left)];
+      return evalExpr(expr.r, env);
+    }
+    case "or": {
+      const left = evalExpr(expr.l, env);
+      if (truthy(first(left))) return [first(left)];
+      return evalExpr(expr.r, env);
+    }
+    case "index": {
+      const table = first(evalExpr(expr.t, env));
+      if (!(table instanceof LuaTable)) throw new Error("attempt to index a non-table");
+      return [table.get(first(evalExpr(expr.i, env)))];
+    }
+    case "field": {
+      const table = first(evalExpr(expr.t, env));
+      if (!(table instanceof LuaTable)) throw new Error("attempt to index a non-table");
+      return [table.get(expr.n)];
+    }
+    case "call":
+      return callExpr(expr, env);
+    case "table":
+      return [buildTable(expr, env)];
+    case "fn":
+      return [new LuaClosure(expr.params, expr.vararg, expr.body, env)];
+    default: {
+      const never = expr;
+      return never;
+    }
+  }
+}
+function compare(left, right, env, op) {
+  const a = first(evalExpr(left, env));
+  const b = first(evalExpr(right, env));
+  if (typeof a === "number" && typeof b === "number") return op(a, b);
+  if (typeof a === "string" && typeof b === "string") return op(a, b);
+  throw new Error("attempt to compare incompatible values");
+}
+function callExpr(expr, env) {
+  if (expr.method) {
+    const self = first(evalExpr(expr.callee, env));
+    if (!(self instanceof LuaTable)) throw new Error("attempt to index a non-table");
+    const fn2 = self.get(expr.method);
+    const args = evalList(expr.args, env);
+    return callValue(fn2, [self, ...args]);
+  }
+  const fn = first(evalExpr(expr.callee, env));
+  return callValue(fn, evalList(expr.args, env));
+}
+function callValue(fn, args) {
+  if (fn instanceof LuaClosure) {
+    const local = new Env(fn.env);
+    fn.params.forEach((name, index) => {
+      local.define(name, args[index] ?? null);
+    });
+    local.varargs = fn.vararg ? args.slice(fn.params.length) : [];
+    const flow = execBlock(fn.body, local);
+    return flow.k === "return" ? flow.values : [null];
+  }
+  if (typeof fn === "function") return fn(args);
+  throw new Error("attempt to call a non-function");
+}
+function buildTable(expr, env) {
+  const table = new LuaTable();
+  let index = 1;
+  expr.fields.forEach((field, fieldIndex) => {
+    if (field.name !== void 0) {
+      table.set(field.name, first(evalExpr(field.value, env)));
+      return;
+    }
+    if (field.key) {
+      table.set(first(evalExpr(field.key, env)), first(evalExpr(field.value, env)));
+      return;
+    }
+    const values = evalExpr(field.value, env);
+    const last = fieldIndex === expr.fields.length - 1;
+    const produced = last ? values : [values[0] ?? null];
+    if (produced.length === 0) return;
+    for (const value of produced) {
+      if (value !== null) table.set(index, value);
+      index++;
+    }
+  });
+  return table;
+}
+function tokenize(source) {
+  const toks = [];
+  let i = 0;
+  let line = 1;
+  const peek = (offset = 0) => source[i + offset];
+  while (i < source.length) {
+    const ch = peek();
+    if (ch === "\n") {
+      line++;
+      i++;
+      continue;
+    }
+    if (ch === " " || ch === "	" || ch === "\r") {
+      i++;
+      continue;
+    }
+    if (ch === "-" && peek(1) === "-") {
+      if (peek(2) === "[") {
+        const close = longBracket(source, i + 2);
+        if (close) {
+          const end = source.indexOf(close.end, close.next);
+          if (end < 0) throw new Error(`unfinished long comment at line ${line}`);
+          const skipped = source.slice(i, end);
+          line += skipped.split("\n").length - 1;
+          i = end + close.end.length;
+          continue;
+        }
+      }
+      while (i < source.length && source[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      const quote = ch;
+      i++;
+      let value = "";
+      while (i < source.length && source[i] !== quote) {
+        if (source[i] === "\n") line++;
+        if (source[i] === "\\") {
+          i++;
+          const esc = source[i];
+          const map2 = {
+            n: "\n",
+            r: "\r",
+            t: "	",
+            a: "\x07",
+            b: "\b",
+            f: "\f",
+            v: "\v",
+            "\\": "\\",
+            "'": "'",
+            '"': '"',
+            "\n": "\n"
+          };
+          if (esc !== void 0 && map2[esc] !== void 0) value += map2[esc];
+          else if (esc !== void 0 && esc >= "0" && esc <= "9") {
+            let digits = esc;
+            for (let n = 0; n < 2; n++) {
+              const next = source[i + 1];
+              if (next === void 0 || next < "0" || next > "9") break;
+              i++;
+              digits += next;
+            }
+            value += String.fromCharCode(Number(digits) & 255);
+          } else value += esc ?? "";
+          i++;
+          continue;
+        }
+        value += source[i] ?? "";
+        i++;
+      }
+      if (source[i] !== quote) throw new Error(`unfinished string at line ${line}`);
+      i++;
+      toks.push({ k: "str", v: value, line });
+      continue;
+    }
+    if (ch === "[") {
+      const bracket = longBracket(source, i);
+      if (bracket) {
+        let start = bracket.next;
+        if (source[start] === "\n") {
+          start++;
+          line++;
+        }
+        const end = source.indexOf(bracket.end, start);
+        if (end < 0) throw new Error(`unfinished long string at line ${line}`);
+        const value = source.slice(start, end);
+        line += value.split("\n").length - 1;
+        i = end + bracket.end.length;
+        toks.push({ k: "str", v: value, line });
+        continue;
+      }
+    }
+    const digit = peek(1);
+    if (ch !== void 0 && ch >= "0" && ch <= "9" || ch === "." && digit !== void 0 && digit >= "0" && digit <= "9") {
+      const start = i;
+      if (ch === "0" && (peek(1) === "x" || peek(1) === "X")) {
+        i += 2;
+        while (i < source.length && /[0-9a-fA-F]/.test(source[i] ?? "")) i++;
+        toks.push({ k: "num", v: Number(source.slice(start, i)), line });
+        continue;
+      }
+      while (i < source.length && /[0-9]/.test(source[i] ?? "")) i++;
+      if (source[i] === ".") {
+        i++;
+        while (i < source.length && /[0-9]/.test(source[i] ?? "")) i++;
+      }
+      if (source[i] === "e" || source[i] === "E") {
+        i++;
+        if (source[i] === "+" || source[i] === "-") i++;
+        while (i < source.length && /[0-9]/.test(source[i] ?? "")) i++;
+      }
+      toks.push({ k: "num", v: Number(source.slice(start, i)), line });
+      continue;
+    }
+    if (ch !== void 0 && /[A-Za-z_]/.test(ch)) {
+      const start = i;
+      i++;
+      while (i < source.length && /[A-Za-z0-9_]/.test(source[i] ?? "")) i++;
+      toks.push({ k: "name", v: source.slice(start, i), line });
+      continue;
+    }
+    const three = source.slice(i, i + 3);
+    const two = source.slice(i, i + 2);
+    if (three === "...") {
+      toks.push({ k: "sym", v: "...", line });
+      i += 3;
+      continue;
+    }
+    if (["==", "~=", "<=", ">=", ".."].includes(two)) {
+      toks.push({ k: "sym", v: two, line });
+      i += 2;
+      continue;
+    }
+    toks.push({ k: "sym", v: ch ?? "", line });
+    i++;
+  }
+  toks.push({ k: "eof", line });
+  return toks;
+}
+function longBracket(source, at) {
+  if (source[at] !== "[") return null;
+  let i = at + 1;
+  while (source[i] === "=") i++;
+  if (source[i] !== "[") return null;
+  const marks = i - (at + 1);
+  return { next: i + 1, end: `]${"=".repeat(marks)}]` };
+}
+var Parser = class {
+  constructor(toks) {
+    this.toks = toks;
+  }
+  toks;
+  i = 0;
+  cur() {
+    return this.toks[this.i] ?? { k: "eof", line: 0 };
+  }
+  line() {
+    return this.cur().line;
+  }
+  eat() {
+    const tok = this.cur();
+    this.i++;
+    return tok;
+  }
+  eatSym(value) {
+    const tok = this.cur();
+    if (tok.k === "sym" && tok.v === value) {
+      this.i++;
+      return true;
+    }
+    return false;
+  }
+  expectSym(value) {
+    if (!this.eatSym(value)) throw new Error(`expected '${value}' at line ${this.line()}`);
+  }
+  isName(value) {
+    const tok = this.cur();
+    return tok.k === "name" && (value === void 0 || tok.v === value);
+  }
+  eatName(value) {
+    if (!this.isName(value)) return null;
+    const tok = this.eat();
+    return tok.k === "name" ? tok.v : null;
+  }
+  expectName() {
+    const name = this.eatName();
+    if (name === null) throw new Error(`expected name at line ${this.line()}`);
+    return name;
+  }
+  parseChunk() {
+    const body = this.parseBlock();
+    if (this.cur().k !== "eof") throw new Error(`unexpected token at line ${this.line()}`);
+    return body;
+  }
+  parseBlock() {
+    const body = [];
+    while (!this.blockEnd()) {
+      if (this.isName("return")) {
+        body.push(this.parseReturn());
+        this.eatSym(";");
+        break;
+      }
+      body.push(this.parseStmt());
+      this.eatSym(";");
+    }
+    return body;
+  }
+  blockEnd() {
+    return this.cur().k === "eof" || this.isName("end") || this.isName("else") || this.isName("elseif") || this.isName("until");
+  }
+  parseStmt() {
+    if (this.isName("if")) return this.parseIf();
+    if (this.isName("while")) return this.parseWhile();
+    if (this.isName("for")) return this.parseFor();
+    if (this.isName("do")) {
+      this.eat();
+      const body = this.parseBlock();
+      if (!this.eatName("end")) throw new Error(`expected 'end' at line ${this.line()}`);
+      return { k: "do", body };
+    }
+    if (this.isName("local")) {
+      this.eat();
+      if (this.isName("function")) {
+        this.eat();
+        const name = this.expectName();
+        const fn = this.parseFunctionTail();
+        return { k: "localfn", name, params: fn.params, vararg: fn.vararg, body: fn.body };
+      }
+      const names = [this.expectName()];
+      while (this.eatSym(",")) names.push(this.expectName());
+      const values = [];
+      if (this.eatSym("=")) values.push(...this.parseExprList());
+      return { k: "local", names, values };
+    }
+    if (this.isName("function")) {
+      this.eat();
+      const name = this.expectName();
+      const fn = this.parseFunctionTail();
+      return {
+        k: "assign",
+        targets: [{ k: "name", name }],
+        values: [{ k: "fn", params: fn.params, vararg: fn.vararg, body: fn.body }]
+      };
+    }
+    if (this.isName("break")) {
+      this.eat();
+      return { k: "break" };
+    }
+    const expr = this.parsePrefix();
+    if (this.cur().k === "sym" && this.cur().k === "sym" && (this.cur().v === "=" || this.cur().v === ",")) {
+      const targets = [this.asTarget(expr)];
+      while (this.eatSym(",")) targets.push(this.asTarget(this.parsePrefix()));
+      this.expectSym("=");
+      return { k: "assign", targets, values: this.parseExprList() };
+    }
+    if (expr.k !== "call") throw new Error(`expected statement at line ${this.line()}`);
+    return { k: "call", expr };
+  }
+  parseReturn() {
+    this.eat();
+    if (this.blockEnd() || this.cur().k === "sym" && this.cur().k === "sym" && this.cur().v === ";") {
+      return { k: "return", values: [] };
+    }
+    return { k: "return", values: this.parseExprList() };
+  }
+  parseIf() {
+    this.eat();
+    const arms = [];
+    arms.push({ cond: this.parseExpr(), body: this.afterThen() });
+    while (this.eatName("elseif")) arms.push({ cond: this.parseExpr(), body: this.afterThen() });
+    let elseBody = [];
+    if (this.eatName("else")) elseBody = this.parseBlock();
+    if (!this.eatName("end")) throw new Error(`expected 'end' at line ${this.line()}`);
+    return { k: "if", arms, elseBody };
+  }
+  afterThen() {
+    if (!this.eatName("then")) throw new Error(`expected 'then' at line ${this.line()}`);
+    return this.parseBlock();
+  }
+  parseWhile() {
+    this.eat();
+    const cond = this.parseExpr();
+    if (!this.eatName("do")) throw new Error(`expected 'do' at line ${this.line()}`);
+    const body = this.parseBlock();
+    if (!this.eatName("end")) throw new Error(`expected 'end' at line ${this.line()}`);
+    return { k: "while", cond, body };
+  }
+  parseFor() {
+    this.eat();
+    const name = this.expectName();
+    if (this.eatSym("=")) {
+      const start = this.parseExpr();
+      this.expectSym(",");
+      const stop = this.parseExpr();
+      const step = this.eatSym(",") ? this.parseExpr() : null;
+      if (!this.eatName("do")) throw new Error(`expected 'do' at line ${this.line()}`);
+      const body2 = this.parseBlock();
+      if (!this.eatName("end")) throw new Error(`expected 'end' at line ${this.line()}`);
+      return { k: "for", name, start, stop, step, body: body2 };
+    }
+    const names = [name];
+    while (this.eatSym(",")) names.push(this.expectName());
+    if (!this.eatName("in")) throw new Error(`expected 'in' at line ${this.line()}`);
+    const iter = this.parseExprList();
+    if (!this.eatName("do")) throw new Error(`expected 'do' at line ${this.line()}`);
+    const body = this.parseBlock();
+    if (!this.eatName("end")) throw new Error(`expected 'end' at line ${this.line()}`);
+    return { k: "forin", names, iter, body };
+  }
+  asTarget(expr) {
+    if (expr.k === "name") return { k: "name", name: expr.v };
+    if (expr.k === "index") return { k: "index", table: expr.t, key: expr.i };
+    if (expr.k === "field") return { k: "field", table: expr.t, name: expr.n };
+    throw new Error(`invalid assignment target at line ${this.line()}`);
+  }
+  parseExprList() {
+    const exprs = [this.parseExpr()];
+    while (this.eatSym(",")) exprs.push(this.parseExpr());
+    return exprs;
+  }
+  parseExpr() {
+    return this.parseOr();
+  }
+  parseOr() {
+    let left = this.parseAnd();
+    while (this.eatName("or")) left = { k: "or", l: left, r: this.parseAnd() };
+    return left;
+  }
+  parseAnd() {
+    let left = this.parseCmp();
+    while (this.eatName("and")) left = { k: "and", l: left, r: this.parseCmp() };
+    return left;
+  }
+  parseCmp() {
+    let left = this.parseConcat();
+    const tok = this.cur();
+    if (tok.k === "sym" && ["==", "~=", "<", ">", "<=", ">="].includes(tok.v)) {
+      this.eat();
+      left = { k: "bin", op: tok.v, l: left, r: this.parseConcat() };
+    }
+    return left;
+  }
+  parseConcat() {
+    const left = this.parseAdd();
+    if (this.eatSym("..")) return { k: "bin", op: "..", l: left, r: this.parseConcat() };
+    return left;
+  }
+  parseAdd() {
+    let left = this.parseMul();
+    while (this.cur().k === "sym" && this.cur().k === "sym" && (this.cur().v === "+" || this.cur().v === "-")) {
+      const op = this.eat().v;
+      left = { k: "bin", op, l: left, r: this.parseMul() };
+    }
+    return left;
+  }
+  parseMul() {
+    let left = this.parseUnary();
+    while (this.cur().k === "sym" && ["*", "/", "%"].includes(this.cur().v)) {
+      const op = this.eat().v;
+      left = { k: "bin", op, l: left, r: this.parseUnary() };
+    }
+    return left;
+  }
+  parseUnary() {
+    if (this.eatName("not")) return { k: "un", op: "not", e: this.parseUnary() };
+    if (this.eatSym("#")) return { k: "un", op: "#", e: this.parseUnary() };
+    if (this.eatSym("-")) return { k: "un", op: "-", e: this.parseUnary() };
+    return this.parsePower();
+  }
+  parsePower() {
+    const left = this.parsePrimary();
+    if (this.eatSym("^")) return { k: "bin", op: "^", l: left, r: this.parseUnary() };
+    return left;
+  }
+  parsePrimary() {
+    if (this.eatName("nil")) return { k: "nil" };
+    if (this.eatName("false")) return { k: "bool", v: false };
+    if (this.eatName("true")) return { k: "bool", v: true };
+    if (this.eatSym("...")) return { k: "dots" };
+    const tok = this.cur();
+    if (tok.k === "num") {
+      this.eat();
+      return { k: "num", v: tok.v };
+    }
+    if (tok.k === "str") {
+      this.eat();
+      return { k: "str", v: tok.v };
+    }
+    if (this.isName("function")) {
+      this.eat();
+      const fn = this.parseFunctionTail();
+      return { k: "fn", params: fn.params, vararg: fn.vararg, body: fn.body };
+    }
+    if (this.eatSym("{")) return this.parseTable();
+    return this.parsePrefix();
+  }
+  parsePrefix() {
+    let expr;
+    if (this.eatSym("(")) {
+      expr = this.parseExpr();
+      this.expectSym(")");
+    } else if (this.cur().k === "name") {
+      expr = { k: "name", v: this.expectName() };
+    } else throw new Error(`expected expression at line ${this.line()}`);
+    for (; ; ) {
+      if (this.eatSym(".")) {
+        expr = { k: "field", t: expr, n: this.expectName() };
+        continue;
+      }
+      if (this.eatSym("[")) {
+        const index = this.parseExpr();
+        this.expectSym("]");
+        expr = { k: "index", t: expr, i: index };
+        continue;
+      }
+      if (this.eatSym(":")) {
+        const method = this.expectName();
+        const args = this.parseCallArgs();
+        expr = { k: "call", callee: expr, args, method };
+        continue;
+      }
+      if (this.startsArgs()) {
+        expr = { k: "call", callee: expr, args: this.parseCallArgs() };
+        continue;
+      }
+      return expr;
+    }
+  }
+  startsArgs() {
+    return this.eatSymPeek("(") || this.eatSymPeek("{") || this.cur().k === "str";
+  }
+  eatSymPeek(value) {
+    const tok = this.cur();
+    return tok.k === "sym" && tok.v === value;
+  }
+  parseCallArgs() {
+    if (this.eatSym("(")) {
+      const args = this.cur().k === "sym" && this.cur().v === ")" ? [] : this.parseExprList();
+      this.expectSym(")");
+      return args;
+    }
+    if (this.eatSym("{")) return [this.parseTable()];
+    const tok = this.cur();
+    if (tok.k === "str") {
+      this.eat();
+      return [{ k: "str", v: tok.v }];
+    }
+    throw new Error(`expected arguments at line ${this.line()}`);
+  }
+  parseFunctionTail() {
+    this.expectSym("(");
+    const params = [];
+    let vararg = false;
+    if (!this.eatSym(")")) {
+      for (; ; ) {
+        if (this.eatSym("...")) {
+          vararg = true;
+          break;
+        }
+        params.push(this.expectName());
+        if (!this.eatSym(",")) break;
+      }
+      this.expectSym(")");
+    }
+    const body = this.parseBlock();
+    if (!this.eatName("end")) throw new Error(`expected 'end' at line ${this.line()}`);
+    return { params, vararg, body };
+  }
+  parseTable() {
+    const fields = [];
+    while (!(this.cur().k === "sym" && this.cur().v === "}")) {
+      if (this.eatSym("[")) {
+        const key = this.parseExpr();
+        this.expectSym("]");
+        this.expectSym("=");
+        fields.push({ key, value: this.parseExpr() });
+      } else if (this.cur().k === "name" && this.toks[this.i + 1]?.k === "sym" && this.toks[this.i + 1].v === "=") {
+        const name = this.expectName();
+        this.expectSym("=");
+        fields.push({ name, value: this.parseExpr() });
+      } else fields.push({ value: this.parseExpr() });
+      if (!this.eatSym(",") && !this.eatSym(";")) break;
+    }
+    this.expectSym("}");
+    return { k: "table", fields };
+  }
+};
+function stringSub(value, startRaw, endRaw) {
+  const n = value.length;
+  const normalize = (index) => index < 0 ? n + index + 1 : index;
+  const start = normalize(startRaw);
+  const end = endRaw === void 0 ? n : normalize(endRaw);
+  if (start > end) return "";
+  return value.slice(Math.max(start, 1) - 1, Math.min(end, n));
+}
+function toJson(value) {
+  if (value === null) return null;
+  if (typeof value === "boolean" || typeof value === "number") return value;
+  if (typeof value === "string") return utf8Text(fromLatin1(value));
+  if (value instanceof LuaTable) {
+    const named = [...value.map.keys()];
+    if (named.length === 0 && value.length() === 0) return {};
+    if (named.length === 0) {
+      const list = [];
+      for (let i = 1; i <= value.length(); i++) list.push(toJson(value.get(i)));
+      return list;
+    }
+    const object = {};
+    for (const [key, item] of value.map) object[utf8Text(fromLatin1(key))] = toJson(item);
+    return object;
+  }
+  return null;
+}
+function fromJson(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "boolean" || typeof value === "number") return value;
+  if (typeof value === "string") return latin1(utf8(value));
+  if (Array.isArray(value)) {
+    const table = new LuaTable();
+    value.forEach((item, index) => {
+      table.set(index + 1, fromJson(item));
+    });
+    return table;
+  }
+  if (typeof value === "object") {
+    const table = new LuaTable();
+    for (const [key, item] of Object.entries(value)) table.set(key, fromJson(item));
+    return table;
+  }
+  return null;
+}
+function luaGlobals(host) {
+  const env = new Env(null);
+  const redis = new LuaTable();
+  redis.set("call", host.call);
+  redis.set("pcall", host.pcall);
+  redis.set("error_reply", (args) => [new LuaFailure(asString(args[0] ?? null))]);
+  redis.set("status_reply", (args) => [new LuaStatus(asString(args[0] ?? null))]);
+  redis.set("sha1hex", (args) => [sha1Hex(fromLatin1(asString(args[0] ?? null)))]);
+  redis.set("log", () => [null]);
+  redis.set("replicate_commands", () => [1]);
+  redis.set("set_repl", () => [null]);
+  redis.set("LOG_DEBUG", 0);
+  redis.set("LOG_VERBOSE", 1);
+  redis.set("LOG_NOTICE", 2);
+  redis.set("LOG_WARNING", 3);
+  env.define("redis", redis);
+  const stringLib = new LuaTable();
+  stringLib.set("len", (args) => [asString(args[0] ?? null).length]);
+  stringLib.set("sub", (args) => [
+    stringSub(
+      asString(args[0] ?? null),
+      asNumber(args[1] ?? 1),
+      args[2] === void 0 ? void 0 : asNumber(args[2] ?? 0)
+    )
+  ]);
+  stringLib.set("byte", (args) => {
+    const value = asString(args[0] ?? null);
+    const start = args[1] === void 0 ? 1 : asNumber(args[1] ?? 1);
+    const end = args[2] === void 0 ? start : asNumber(args[2] ?? start);
+    const slice = stringSub(value, start, end);
+    return [...slice].map((ch) => ch.charCodeAt(0));
+  });
+  stringLib.set("char", (args) => [
+    args.map((arg) => String.fromCharCode(asNumber(arg) & 255)).join("")
+  ]);
+  stringLib.set("format", (args) => [formatString(asString(args[0] ?? ""), args.slice(1))]);
+  stringLib.set("find", (args) => {
+    const hay = asString(args[0] ?? null);
+    const needle = asString(args[1] ?? "");
+    const init = args[2] === void 0 ? 1 : asNumber(args[2] ?? 1);
+    const at = hay.indexOf(needle, Math.max(0, init - 1));
+    if (at < 0) return [null];
+    return [at + 1, at + needle.length];
+  });
+  stringLib.set("lower", (args) => [asString(args[0] ?? null).toLowerCase()]);
+  stringLib.set("upper", (args) => [asString(args[0] ?? null).toUpperCase()]);
+  stringLib.set("rep", (args) => [asString(args[0] ?? "").repeat(asNumber(args[1] ?? 0))]);
+  env.define("string", stringLib);
+  const tableLib = new LuaTable();
+  tableLib.set("insert", (args) => {
+    const table = args[0];
+    if (!(table instanceof LuaTable)) throw new Error("bad argument to table.insert");
+    if (args.length >= 3) {
+      const pos = asNumber(args[1] ?? 1);
+      const value = args[2] ?? null;
+      for (let i = table.length(); i >= pos; i--) table.set(i + 1, table.get(i));
+      table.set(pos, value);
+    } else table.set(table.length() + 1, args[1] ?? null);
+    return [null];
+  });
+  tableLib.set("remove", (args) => {
+    const table = args[0];
+    if (!(table instanceof LuaTable)) throw new Error("bad argument to table.remove");
+    const pos = args[1] === void 0 ? table.length() : asNumber(args[1] ?? 1);
+    const value = table.get(pos);
+    const len = table.length();
+    for (let i = pos; i < len; i++) table.set(i, table.get(i + 1));
+    table.set(len, null);
+    return [value];
+  });
+  tableLib.set("concat", (args) => {
+    const table = args[0];
+    if (!(table instanceof LuaTable)) throw new Error("bad argument to table.concat");
+    const sep = args[1] === void 0 || args[1] === null ? "" : asString(args[1]);
+    const start = args[2] === void 0 ? 1 : asNumber(args[2] ?? 1);
+    const finish = args[3] === void 0 ? table.length() : asNumber(args[3] ?? 0);
+    const parts = [];
+    for (let i = start; i <= finish; i++) parts.push(asString(table.get(i)));
+    return [parts.join(sep)];
+  });
+  tableLib.set("unpack", (args) => unpackTable(args));
+  env.define("table", tableLib);
+  const mathLib = new LuaTable();
+  mathLib.set("floor", (args) => [Math.floor(asNumber(args[0] ?? 0))]);
+  mathLib.set("ceil", (args) => [Math.ceil(asNumber(args[0] ?? 0))]);
+  mathLib.set("abs", (args) => [Math.abs(asNumber(args[0] ?? 0))]);
+  mathLib.set("max", (args) => [Math.max(...args.map((arg) => asNumber(arg)))]);
+  mathLib.set("min", (args) => [Math.min(...args.map((arg) => asNumber(arg)))]);
+  mathLib.set("huge", Infinity);
+  env.define("math", mathLib);
+  const cjson = new LuaTable();
+  cjson.set("encode", (args) => [latin1(utf8(JSON.stringify(toJson(args[0] ?? null)) ?? "null"))]);
+  cjson.set("decode", (args) => {
+    const text2 = utf8Text(fromLatin1(asString(args[0] ?? "null")));
+    return [fromJson(JSON.parse(text2))];
+  });
+  env.define("cjson", cjson);
+  env.define("tonumber", (args) => {
+    const value = args[0] ?? null;
+    if (typeof value === "number") return [value];
+    if (typeof value !== "string") return [null];
+    if (!/^[-+]?\d+(\.\d+)?([eE][-+]?\d+)?$/.test(value.trim())) return [null];
+    return [Number(value.trim())];
+  });
+  env.define("tostring", (args) => {
+    const value = args[0] ?? null;
+    if (value === null) return ["nil"];
+    if (typeof value === "boolean") return [value ? "true" : "false"];
+    if (typeof value === "number" || typeof value === "string") return [String(value)];
+    if (value instanceof LuaTable) return ["table"];
+    if (value instanceof LuaStatus) return [value.ok];
+    return ["userdata"];
+  });
+  env.define("type", (args) => {
+    const value = args[0] ?? null;
+    if (value === null) return ["nil"];
+    if (typeof value === "boolean") return ["boolean"];
+    if (typeof value === "number") return ["number"];
+    if (typeof value === "string") return ["string"];
+    if (value instanceof LuaTable) return ["table"];
+    if (typeof value === "function" || value instanceof LuaClosure) return ["function"];
+    return ["userdata"];
+  });
+  env.define("unpack", (args) => unpackTable(args));
+  env.define("ipairs", (args) => {
+    const table = args[0];
+    const iter = (callArgs) => {
+      const subject = callArgs[0];
+      const index = (typeof callArgs[1] === "number" ? callArgs[1] : 0) + 1;
+      if (!(subject instanceof LuaTable) || !subject.has(index)) return [null];
+      return [index, subject.get(index)];
+    };
+    return [iter, table ?? null, 0];
+  });
+  env.define("pairs", (args) => {
+    const table = args[0];
+    if (!(table instanceof LuaTable)) throw new Error("bad argument to pairs");
+    const keys = [...table.array.keys(), ...table.map.keys()];
+    let cursor = 0;
+    const iter = () => {
+      const key = keys[cursor];
+      cursor++;
+      if (key === void 0) return [null];
+      return [key, table.get(key)];
+    };
+    return [iter, table, null];
+  });
+  env.define("error", (args) => {
+    throw new Error(asString(args[0] ?? "error"));
+  });
+  env.define("select", (args) => {
+    const index = args[0];
+    const rest = args.slice(1);
+    if (index === "#") return [rest.length];
+    const at = asNumber(index ?? 1);
+    if (at < 1) throw new Error("bad argument to select");
+    return rest.slice(at - 1);
+  });
+  env.define("next", () => {
+    throw new Error("next is not implemented");
+  });
+  return env;
+}
+function unpackTable(args) {
+  const table = args[0];
+  if (!(table instanceof LuaTable)) throw new Error("bad argument to unpack");
+  const start = args[1] === void 0 ? 1 : asNumber(args[1] ?? 1);
+  const finish = args[2] === void 0 ? table.length() : asNumber(args[2] ?? 0);
+  const out = [];
+  for (let i = start; i <= finish; i++) out.push(table.get(i));
+  return out;
+}
+function formatString(fmt, args) {
+  let out = "";
+  let arg = 0;
+  for (let i = 0; i < fmt.length; i++) {
+    if (fmt[i] !== "%") {
+      out += fmt[i] ?? "";
+      continue;
+    }
+    const spec = fmt[++i];
+    if (spec === "%") {
+      out += "%";
+      continue;
+    }
+    const value = args[arg++] ?? null;
+    if (spec === "s") out += value === null ? "nil" : asString(value);
+    else if (spec === "d" || spec === "i") out += String(Math.trunc(asNumber(value)));
+    else if (spec === "f") out += String(asNumber(value));
+    else if (spec === "q")
+      out += `"${asString(value).replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+    else out += spec ?? "";
+  }
+  return out;
+}
+function runLua(source, env) {
+  let body;
+  try {
+    body = new Parser(tokenize(source)).parseChunk();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Error compiling script: ${message}`);
+  }
+  const flow = execBlock(body, env);
+  return flow.k === "return" ? flow.values : [null];
+}
+
+// src/store.ts
+function emptyStream() {
+  return { entries: [], groups: /* @__PURE__ */ new Map(), lastMs: -1n, lastSeq: 0n };
+}
+function parseStreamId(id) {
+  const dash = id.indexOf("-");
+  if (dash <= 0 || dash === id.length - 1) return null;
+  const msText = id.slice(0, dash);
+  const seqText = id.slice(dash + 1);
+  if (!/^\d+$/.test(msText) || !/^\d+$/.test(seqText)) return null;
+  return { ms: BigInt(msText), seq: BigInt(seqText) };
+}
+function cmpId(a, b) {
+  const left = parseStreamId(a);
+  const right = parseStreamId(b);
+  if (!left || !right) return a < b ? -1 : a > b ? 1 : 0;
+  if (left.ms !== right.ms) return left.ms < right.ms ? -1 : 1;
+  if (left.seq !== right.seq) return left.seq < right.seq ? -1 : 1;
+  return 0;
+}
+var Database = class {
+  constructor(clock) {
+    this.clock = clock;
+  }
+  clock;
+  values = /* @__PURE__ */ new Map();
+  expires = /* @__PURE__ */ new Map();
+  gens = /* @__PURE__ */ new Map();
+  lru = /* @__PURE__ */ new Map();
+  order = [];
+  tick = 0;
+  now() {
+    return this.clock.now();
+  }
+  bump(key) {
+    this.gens.set(key, (this.gens.get(key) ?? 0) + 1);
+  }
+  sweep(key) {
+    const expiry = this.expires.get(key);
+    if (expiry === void 0 || expiry > this.clock.now()) return;
+    this.expires.delete(key);
+    if (this.values.delete(key)) {
+      this.bump(key);
+      this.order = this.order.filter((item) => item !== key);
+      this.lru.delete(key);
+    }
+  }
+  generation(key) {
+    this.sweep(key);
+    return this.gens.get(key) ?? 0;
+  }
+  get(key) {
+    this.sweep(key);
+    const value = this.values.get(key);
+    if (value) this.lru.set(key, ++this.tick);
+    return value;
+  }
+  has(key) {
+    return this.get(key) !== void 0;
+  }
+  put(key, value) {
+    this.sweep(key);
+    if (!this.values.has(key)) this.order.push(key);
+    this.values.set(key, value);
+    this.bump(key);
+    this.lru.set(key, ++this.tick);
+  }
+  /** Remove the key when a collection has no elements left. Streams are kept. */
+  dropIfEmpty(key) {
+    const value = this.values.get(key);
+    if (!value) return;
+    const empty = value.kind === "list" && value.items.length === 0 || value.kind === "set" && value.members.size === 0 || value.kind === "zset" && value.members.size === 0 || value.kind === "hash" && value.fields.size === 0;
+    if (empty) this.delete(key);
+  }
+  setExpiry(key, at) {
+    if (!this.values.has(key)) return;
+    if (at === null) this.expires.delete(key);
+    else this.expires.set(key, at);
+    this.bump(key);
+  }
+  expiry(key) {
+    this.sweep(key);
+    return this.expires.get(key) ?? null;
+  }
+  pttl(key) {
+    this.sweep(key);
+    if (!this.values.has(key)) return -2;
+    const expiry = this.expires.get(key);
+    if (expiry === void 0) return -1;
+    return Math.max(0, expiry - this.clock.now());
+  }
+  delete(key) {
+    this.sweep(key);
+    this.expires.delete(key);
+    const had = this.values.delete(key);
+    if (had) {
+      this.bump(key);
+      this.order = this.order.filter((item) => item !== key);
+      this.lru.delete(key);
+    }
+    return had;
+  }
+  rename(source, dest) {
+    const value = this.get(source);
+    if (!value) return false;
+    const expiry = this.expires.get(source) ?? null;
+    this.delete(source);
+    this.put(dest, value);
+    if (expiry !== null) this.expires.set(dest, expiry);
+    return true;
+  }
+  keys() {
+    const live = [];
+    for (const key of this.order) {
+      this.sweep(key);
+      if (this.values.has(key)) live.push(key);
+    }
+    this.order = live;
+    return live;
+  }
+  matching(pattern) {
+    return this.keys().filter((key) => globMatch(pattern, key));
+  }
+  clear() {
+    for (const key of [...this.values.keys()]) this.delete(key);
+    this.values.clear();
+    this.expires.clear();
+    this.order = [];
+    this.lru.clear();
+  }
+  memory() {
+    let total = 0;
+    for (const [key, value] of this.values) total += key.length + valueBytes(value);
+    return total;
+  }
+  evictLru() {
+    let best = null;
+    let bestTick = Number.POSITIVE_INFINITY;
+    for (const [key, tick] of this.lru) {
+      if (!this.values.has(key)) continue;
+      if (tick < bestTick) {
+        best = key;
+        bestTick = tick;
+      }
+    }
+    if (best === null) return null;
+    this.delete(best);
+    return best;
+  }
+  zsetOrdered(value) {
+    return [...value.members.values()].sort((a, b) => {
+      if (a.score !== b.score) return a.score - b.score;
+      return cmpBytes(a.member, b.member);
+    });
+  }
+};
+function valueBytes(value) {
+  switch (value.kind) {
+    case "string":
+      return value.bytes.length;
+    case "list":
+      return value.items.reduce((sum, item) => sum + item.length, 0);
+    case "set":
+      return [...value.members.values()].reduce((sum, item) => sum + item.length, 0);
+    case "zset":
+      return [...value.members.values()].reduce((sum, item) => sum + item.member.length + 8, 0);
+    case "hash":
+      return [...value.fields.entries()].reduce(
+        (sum, [field, item]) => sum + field.length + item.length,
+        0
+      );
+    case "stream":
+      return value.stream.entries.reduce(
+        (sum, entry) => sum + entry.id.length + entry.fields.reduce((inner, field) => inner + field.length, 0),
+        0
+      );
+    default: {
+      const never = value;
+      return never;
+    }
+  }
+}
+function memberKey(bytes) {
+  return latin1(bytes);
+}
+
+// src/engine.ts
+var RedisConnectionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RedisConnectionError";
+  }
+};
+var RedisReplyError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RedisReplyError";
+  }
+};
+var PREAUTH = /* @__PURE__ */ new Set(["auth", "hello", "quit", "reset"]);
+var PUBSUB_OK = /* @__PURE__ */ new Set([
+  "subscribe",
+  "unsubscribe",
+  "psubscribe",
+  "punsubscribe",
+  "ssubscribe",
+  "sunsubscribe",
+  "ping",
+  "quit",
+  "reset"
+]);
+var IMMEDIATE = /* @__PURE__ */ new Set([
+  "exec",
+  "discard",
+  "multi",
+  "watch",
+  "unwatch",
+  "quit",
+  "reset",
+  "subscribe",
+  "unsubscribe",
+  "psubscribe",
+  "punsubscribe"
+]);
+var WRITES = /* @__PURE__ */ new Set([
+  "set",
+  "setnx",
+  "setex",
+  "psetex",
+  "mset",
+  "append",
+  "setrange",
+  "incr",
+  "incrby",
+  "incrbyfloat",
+  "decr",
+  "decrby",
+  "getset",
+  "getdel",
+  "getex",
+  "del",
+  "unlink",
+  "expire",
+  "pexpire",
+  "expireat",
+  "pexpireat",
+  "persist",
+  "rename",
+  "renamenx",
+  "copy",
+  "flushdb",
+  "flushall",
+  "hset",
+  "hmset",
+  "hdel",
+  "hincrby",
+  "hincrbyfloat",
+  "hsetnx",
+  "lpush",
+  "rpush",
+  "lpop",
+  "rpop",
+  "lset",
+  "lrem",
+  "ltrim",
+  "linsert",
+  "lmove",
+  "rpoplpush",
+  "blpop",
+  "brpop",
+  "sadd",
+  "srem",
+  "spop",
+  "smove",
+  "zadd",
+  "zrem",
+  "zincrby",
+  "zpopmin",
+  "zpopmax",
+  "bzpopmin",
+  "bzpopmax",
+  "zremrangebyrank",
+  "zremrangebyscore",
+  "xadd",
+  "xdel",
+  "xtrim",
+  "xgroup",
+  "xreadgroup",
+  "xack",
+  "xclaim",
+  "xautoclaim",
+  "eval",
+  "evalsha"
+]);
+var SCRIPT_BLOCKED = /* @__PURE__ */ new Set([
+  "blpop",
+  "brpop",
+  "bzpopmin",
+  "bzpopmax",
+  "auth",
+  "select",
+  "watch",
+  "multi",
+  "exec",
+  "discard",
+  "subscribe",
+  "unsubscribe",
+  "psubscribe",
+  "punsubscribe",
+  "shutdown"
+]);
+var VERSION = "7.2.4";
+function text(bytes) {
+  return bytes ? latin1(bytes) : "";
+}
+function upper(bytes) {
+  return text(bytes).toUpperCase();
+}
+function scoreText(score) {
+  if (Number.isNaN(score)) return "nan";
+  if (score === Infinity) return "inf";
+  if (score === -Infinity) return "-inf";
+  if (Number.isInteger(score)) return String(score);
+  return String(score);
+}
+function parseScore(bytes) {
+  if (!bytes) return null;
+  const value = text(bytes).trim().toLowerCase();
+  if (value === "+inf" || value === "inf") return Infinity;
+  if (value === "-inf") return -Infinity;
+  if (!/^[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?$/.test(value)) return null;
+  const score = Number(value);
+  return Number.isFinite(score) ? score : null;
+}
+function parseTimeout(bytes) {
+  if (!bytes) return null;
+  const value = Number(text(bytes));
+  if (!Number.isFinite(value) || value < 0) return null;
+  return value;
+}
+function decodeReply(reply) {
+  switch (reply.t) {
+    case "simple":
+      return reply.v;
+    case "error":
+      throw new RedisReplyError(reply.v);
+    case "int":
+      return typeof reply.v === "bigint" ? intReply(reply.v) : reply.v;
+    case "bulk":
+      return reply.v === null ? null : utf8Text(reply.v);
+    case "array":
+      return reply.v === null ? null : reply.v.map((item) => decodeReply(item));
+    case "null":
+      return null;
+    case "bool":
+      return reply.v;
+    case "double":
+      return reply.v;
+    case "map": {
+      const record = {};
+      for (const [key, value] of reply.v) record[String(decodeReply(key))] = decodeReply(value);
+      return record;
+    }
+    case "push":
+      return reply.v.map((item) => decodeReply(item));
+    default: {
+      const never = reply;
+      return never;
+    }
+  }
+}
+function luaToBytes(value) {
+  if (typeof value === "string") return fromLatin1(value);
+  if (typeof value === "number")
+    return utf8(Number.isInteger(value) ? String(value) : String(value));
+  if (typeof value === "boolean") return utf8(value ? "1" : "");
+  if (value === null) return utf8("");
+  if (value instanceof LuaStatus) return utf8(value.ok);
+  return utf8("");
+}
+function replyToLua(reply) {
+  switch (reply.t) {
+    case "error":
+      throw new Error(reply.v);
+    case "simple":
+      return new LuaStatus(reply.v);
+    case "int":
+      return typeof reply.v === "bigint" ? Number(reply.v) : reply.v;
+    case "bulk":
+      return reply.v === null ? false : latin1(reply.v);
+    case "array":
+    case "push": {
+      if (reply.t === "array" && reply.v === null) return false;
+      const items = reply.v ?? [];
+      const table = new LuaTable();
+      items.forEach((item, index) => {
+        table.set(index + 1, replyToLua(item));
+      });
+      return table;
+    }
+    case "null":
+      return false;
+    case "bool":
+      return reply.v;
+    case "double":
+      return reply.v;
+    case "map": {
+      const table = new LuaTable();
+      for (const [key, value] of reply.v) {
+        const luaKey = replyToLua(key);
+        table.set(luaKey === false ? "" : luaKey, replyToLua(value));
+      }
+      return table;
+    }
+    default: {
+      const never = reply;
+      return never;
+    }
+  }
+}
+function luaToReply(value) {
+  if (value === null || value === false) return nil();
+  if (value === true) return int(1);
+  if (value instanceof LuaStatus) return simple(value.ok);
+  if (value instanceof LuaFailure) return err(value.err);
+  if (typeof value === "number") {
+    if (Number.isInteger(value)) return int(value);
+    return bulk(String(value));
+  }
+  if (typeof value === "string") return { t: "bulk", v: fromLatin1(value) };
+  if (value instanceof LuaTable) {
+    const okField = value.get("ok");
+    const errField = value.get("err");
+    if (typeof okField === "string") return simple(okField);
+    if (typeof errField === "string") return err(errField);
+    const items = [];
+    for (let i = 1; value.has(i); i++) items.push(luaToReply(value.get(i)));
+    return arr(items);
+  }
+  return nil();
+}
+function entryFields(entry) {
+  return arr([bulk(entry.id), arr(entry.fields.map((field) => ({ t: "bulk", v: field })))]);
+}
+var Redis = class {
+  clock;
+  dbs;
+  password;
+  users;
+  authRequired;
+  maxmemory;
+  policy;
+  rngState;
+  faultValue = null;
+  tail = Promise.resolve();
+  sessions = /* @__PURE__ */ new Set();
+  nextClientId = 1;
+  waiters = [];
+  channelSubs = /* @__PURE__ */ new Map();
+  patternSubs = /* @__PURE__ */ new Map();
+  scripts = /* @__PURE__ */ new Map();
+  invoked = "";
+  scriptDepth = 0;
+  commandCount = 0;
+  closed = false;
+  consumersPaused = false;
+  disconnectListeners = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    this.clock = options.clock ?? wallClock();
+    const count = options.databases ?? 16;
+    this.dbs = Array.from({ length: count }, () => new Database(this.clock));
+    this.password = options.password;
+    this.users = options.users ?? [];
+    this.authRequired = options.password !== void 0 || this.users.length > 0;
+    this.maxmemory = options.maxmemory ?? 0;
+    this.policy = options.maxmemoryPolicy ?? "noeviction";
+    this.rngState = options.seed ?? 1;
+  }
+  client() {
+    return new RedisClient(this, this.createSession());
+  }
+  advance(ms) {
+    this.clock.advance(ms);
+  }
+  fault(value) {
+    this.faultValue = value;
+    if (value === "busy") return;
+    if (value === "disconnect" || value === "timeout") {
+      for (const session of [...this.sessions]) this.dropSession(session, value);
+    }
+  }
+  pauseConsumers(paused = true) {
+    this.consumersPaused = paused;
+    if (!paused) this.enqueue(() => this.wakeAll());
+  }
+  waiterCount() {
+    return this.waiters.length;
+  }
+  inspect(db = 0) {
+    const database = this.database(db);
+    return database.keys().map((key) => ({
+      key,
+      type: database.get(key)?.kind ?? "none",
+      pttl: database.pttl(key)
+    }));
+  }
+  reset() {
+    for (const database of this.dbs) database.clear();
+    this.scripts.clear();
+    for (const waiter of [...this.waiters]) {
+      this.finishWaiter(waiter, nilArray());
+    }
+    for (const session of this.sessions) {
+      session.multi = null;
+      session.multiFailed = false;
+      session.watching = [];
+    }
+  }
+  close() {
+    this.closed = true;
+    for (const waiter of [...this.waiters]) {
+      this.failWaiter(waiter, new RedisConnectionError("Connection is closed"));
+    }
+    for (const session of [...this.sessions]) session.dead = true;
+  }
+  onDisconnect(listener) {
+    this.disconnectListeners.add(listener);
+    return () => this.disconnectListeners.delete(listener);
+  }
+  createSession() {
+    const session = {
+      id: this.nextClientId++,
+      db: 0,
+      protocol: 2,
+      name: "",
+      libName: "",
+      libVer: "",
+      authenticated: !this.authRequired,
+      username: "default",
+      readOnly: false,
+      multi: null,
+      multiFailed: false,
+      watching: [],
+      channels: /* @__PURE__ */ new Set(),
+      patterns: /* @__PURE__ */ new Set(),
+      dead: false,
+      quit: false,
+      inExec: false,
+      onPush: () => void 0
+    };
+    this.sessions.add(session);
+    return session;
+  }
+  perform(session, name, args) {
+    if (session.dead || this.closed) {
+      return Promise.reject(new RedisConnectionError("Connection is closed"));
+    }
+    return new Promise((resolve, reject) => {
+      this.enqueue(async () => {
+        try {
+          if (session.dead || this.closed) {
+            reject(new RedisConnectionError("Connection is closed"));
+            return;
+          }
+          if (this.faultValue === "disconnect" || this.faultValue === "timeout") {
+            const message = this.faultValue === "timeout" ? "Command timed out" : "Connection reset";
+            this.dropSession(session, this.faultValue);
+            reject(new RedisConnectionError(message));
+            return;
+          }
+          await this.applyLatency();
+          if (session.dead || this.closed) {
+            reject(new RedisConnectionError("Connection is closed"));
+            return;
+          }
+          const result = this.dispatch(session, name, args);
+          if (result instanceof Promise) {
+            result.then(resolve, reject);
+            return;
+          }
+          resolve(result);
+        } catch (error) {
+          reject(error instanceof Error ? error : new Error(String(error)));
+        }
+      });
+    });
+  }
+  enqueue(task) {
+    this.tail = this.tail.then(task, task).then(
+      () => void 0,
+      () => void 0
+    );
+  }
+  applyLatency() {
+    const fault = this.faultValue;
+    if (fault === null || typeof fault === "string") return Promise.resolve();
+    const target = this.clock.now() + fault.latencyMs;
+    return new Promise((resolve) => {
+      let timer;
+      const finish = () => {
+        if (this.clock.now() < target) return;
+        unsub();
+        if (timer !== void 0) clearTimeout(timer);
+        resolve();
+      };
+      const unsub = this.clock.subscribe(finish);
+      if (!this.clock.manual) timer = setTimeout(finish, fault.latencyMs);
+      finish();
+    });
+  }
+  dropSession(session, reason) {
+    session.dead = true;
+    const message = reason === "timeout" ? "Command timed out" : "Connection reset";
+    for (const waiter of [...this.waiters]) {
+      if (waiter.db >= 0 && this.sessionOf(waiter) === session) {
+        this.failWaiter(waiter, new RedisConnectionError(message));
+      }
+    }
+    this.leavePubsub(session);
+    this.sessions.delete(session);
+    for (const listener of this.disconnectListeners) listener(session);
+  }
+  sessionOf(waiter) {
+    for (const session of this.sessions) {
+      if (session === waiterSession.get(waiter)) return session;
+    }
+    return waiterSession.get(waiter) ?? null;
+  }
+  database(index) {
+    const database = this.dbs[index];
+    if (!database) throw new Error("db index out of range");
+    return database;
+  }
+  random() {
+    this.rngState = Math.imul(1664525, this.rngState) + 1013904223 >>> 0;
+    return this.rngState / 4294967296;
+  }
+  memory() {
+    return this.dbs.reduce((sum, database) => sum + database.memory(), 0);
+  }
+  dispatch(session, nameRaw, args) {
+    const command = nameRaw.toLowerCase();
+    this.invoked = nameRaw;
+    this.commandCount++;
+    if (this.authRequired && !session.authenticated && !PREAUTH.has(command)) return noAuth();
+    if (session.channels.size + session.patterns.size > 0 && !PUBSUB_OK.has(command)) {
+      return pubsubOnly(command);
+    }
+    if (this.faultValue === "busy" && command !== "script" && command !== "shutdown")
+      return busyError();
+    if (session.multi && !IMMEDIATE.has(command)) {
+      const checked = this.execCmd(session, command, args, false);
+      if (checked instanceof Promise || checked.t === "error") {
+        session.multiFailed = true;
+        return checked instanceof Promise ? syntaxError() : checked;
+      }
+      session.multi.push({
+        name: command,
+        args: args.map((arg) => Uint8Array.from(arg))
+      });
+      return queued();
+    }
+    return this.execCmd(session, command, args, true);
+  }
+  execCmd(session, command, args, apply) {
+    if (apply && this.scriptDepth > 0 && SCRIPT_BLOCKED.has(command)) return scriptDenied();
+    if (apply && command === "xread" && args.some((arg) => text(arg).toUpperCase() === "BLOCK") && this.scriptDepth > 0) {
+      return scriptDenied();
+    }
+    if (apply && command === "xreadgroup" && args.some((arg) => text(arg).toUpperCase() === "BLOCK") && this.scriptDepth > 0) {
+      return scriptDenied();
+    }
+    const denied = this.guardWrite(session, command, apply);
+    if (denied) return denied;
+    switch (command) {
+      case "ping":
+        return this.cmdPing(session, args);
+      case "echo":
+        return args.length === 1 ? bulk(args[0] ?? null) : arityError("echo");
+      case "quit":
+        session.quit = true;
+        return ok();
+      case "auth":
+        return this.cmdAuth(session, args);
+      case "hello":
+        return this.cmdHello(session, args);
+      case "select":
+        return this.cmdSelect(session, args);
+      case "reset":
+        return this.cmdReset(session);
+      case "client":
+        return this.cmdClient(session, args, apply);
+      case "info":
+        return bulk(this.info(session, args[0] ? text(args[0]) : "default"));
+      case "time":
+        return this.cmdTime();
+      case "role":
+        return arr([simple("master"), int(0), arr([])]);
+      case "readonly":
+      case "asking":
+        return clusterDisabled();
+      case "cluster":
+        return clusterDisabled();
+      case "module":
+        return args.length >= 1 && upper(args[0]) === "LIST" ? arr([]) : arityError("module");
+      case "command":
+        return arr([]);
+      case "config":
+        return this.cmdConfig(args, apply);
+      case "dbsize":
+        return int(this.database(session.db).keys().length);
+      case "flushdb":
+        if (!apply) return queued();
+        this.database(session.db).clear();
+        return ok();
+      case "flushall":
+        if (!apply) return queued();
+        for (const database of this.dbs) database.clear();
+        return ok();
+      case "randomkey":
+        return this.cmdRandomKey(session);
+      case "scan":
+        return this.cmdScan(session, args);
+      case "keys":
+        return this.cmdKeys(session, args);
+      case "type":
+        return this.cmdType(session, args);
+      case "exists":
+        return this.cmdExists(session, args);
+      case "del":
+      case "unlink":
+        return this.cmdDel(session, args, apply);
+      case "rename":
+        return this.cmdRename(session, args, apply, false);
+      case "renamenx":
+        return this.cmdRename(session, args, apply, true);
+      case "expire":
+      case "pexpire":
+      case "expireat":
+      case "pexpireat":
+        return this.cmdExpire(session, command, args, apply);
+      case "ttl":
+      case "pttl":
+        return this.cmdTtl(session, command, args);
+      case "persist":
+        return this.cmdPersist(session, args, apply);
+      case "get":
+        return this.cmdGet(session, args);
+      case "set":
+        return this.cmdSet(session, args, apply);
+      case "setnx":
+        return args.length === 2 ? this.cmdSet(session, [args[0] ?? utf8(""), args[1] ?? utf8(""), utf8("NX")], apply) : arityError("setnx");
+      case "setex":
+        return args.length === 3 ? this.cmdSet(
+          session,
+          [args[0] ?? utf8(""), args[2] ?? utf8(""), utf8("EX"), args[1] ?? utf8("")],
+          apply
+        ) : arityError("setex");
+      case "psetex":
+        return args.length === 3 ? this.cmdSet(
+          session,
+          [args[0] ?? utf8(""), args[2] ?? utf8(""), utf8("PX"), args[1] ?? utf8("")],
+          apply
+        ) : arityError("psetex");
+      case "mget":
+        return this.cmdMget(session, args);
+      case "mset":
+        return this.cmdMset(session, args, apply);
+      case "append":
+        return this.cmdAppend(session, args, apply);
+      case "strlen":
+        return this.cmdStrlen(session, args);
+      case "getrange":
+        return this.cmdGetRange(session, args);
+      case "setrange":
+        return this.cmdSetRange(session, args, apply);
+      case "incr":
+        return this.cmdIncr(session, args, 1n, apply);
+      case "decr":
+        return this.cmdIncr(session, args, -1n, apply);
+      case "incrby":
+      case "decrby":
+        return this.cmdIncrBy(session, command, args, apply);
+      case "incrbyfloat":
+        return this.cmdIncrByFloat(session, args, apply, false);
+      case "getset":
+        return args.length === 2 ? this.cmdSet(session, [args[0] ?? utf8(""), args[1] ?? utf8(""), utf8("GET")], apply) : arityError("getset");
+      case "getdel":
+        return this.cmdGetDel(session, args, apply);
+      case "getex":
+        return this.cmdGetEx(session, args, apply);
+      case "hset":
+      case "hmset":
+      case "hsetnx":
+      case "hget":
+      case "hdel":
+      case "hexists":
+      case "hgetall":
+      case "hkeys":
+      case "hvals":
+      case "hlen":
+      case "hmget":
+      case "hincrby":
+      case "hincrbyfloat":
+      case "hstrlen":
+        return this.cmdHash(session, command, args, apply);
+      case "lpush":
+      case "rpush":
+      case "lpop":
+      case "rpop":
+      case "llen":
+      case "lrange":
+      case "lindex":
+      case "lset":
+      case "lrem":
+      case "ltrim":
+      case "linsert":
+      case "lmove":
+      case "rpoplpush":
+        return this.cmdList(session, command, args, apply);
+      case "blpop":
+        return this.cmdBlockingList(session, args, apply, "left");
+      case "brpop":
+        return this.cmdBlockingList(session, args, apply, "right");
+      case "sadd":
+      case "srem":
+      case "sismember":
+      case "smismember":
+      case "smembers":
+      case "scard":
+      case "spop":
+      case "srandmember":
+      case "sinter":
+      case "sunion":
+      case "sdiff":
+      case "smove":
+        return this.cmdSetFamily(session, command, args, apply);
+      case "zadd":
+      case "zrem":
+      case "zcard":
+      case "zscore":
+      case "zmscore":
+      case "zrank":
+      case "zrevrank":
+      case "zrange":
+      case "zrevrange":
+      case "zrangebyscore":
+      case "zrevrangebyscore":
+      case "zcount":
+      case "zpopmin":
+      case "zpopmax":
+      case "zincrby":
+      case "zremrangebyscore":
+      case "zremrangebyrank":
+        return this.cmdZset(session, command, args, apply);
+      case "bzpopmin":
+        return this.cmdBlockingZset(session, args, apply, false);
+      case "bzpopmax":
+        return this.cmdBlockingZset(session, args, apply, true);
+      case "xadd":
+      case "xlen":
+      case "xrange":
+      case "xrevrange":
+      case "xdel":
+      case "xtrim":
+      case "xgroup":
+      case "xread":
+      case "xreadgroup":
+      case "xack":
+      case "xpending":
+      case "xclaim":
+      case "xautoclaim":
+      case "xinfo":
+        return this.cmdStream(session, command, args, apply);
+      case "subscribe":
+      case "unsubscribe":
+      case "psubscribe":
+      case "punsubscribe":
+        return this.cmdSub(session, command, args);
+      case "publish":
+        return this.cmdPublish(args);
+      case "pubsub":
+        return this.cmdPubsub(args);
+      case "multi":
+        if (session.multi) return nestedMulti();
+        session.multi = [];
+        session.multiFailed = false;
+        return ok();
+      case "exec":
+        return this.cmdExec(session);
+      case "discard":
+        return this.cmdDiscard(session);
+      case "watch":
+        return this.cmdWatch(session, args);
+      case "unwatch":
+        session.watching = [];
+        return ok();
+      case "eval":
+      case "evalsha":
+        return this.cmdEval(session, command, args, apply);
+      case "script":
+        return this.cmdScript(args, apply);
+      case "shutdown":
+        return ok();
+      default:
+        return unknownCommand(this.invoked, args);
+    }
+  }
+  guardWrite(session, command, apply) {
+    if (!apply || !WRITES.has(command)) return null;
+    if (session.readOnly) return noPerm(command);
+    if (this.faultValue === "readonly") return readonlyError();
+    if (this.faultValue === "oom") return oomError();
+    if (this.maxmemory > 0 && this.memory() > this.maxmemory && this.policy === "noeviction") {
+      return oomError();
+    }
+    if (this.maxmemory > 0 && this.policy === "allkeys-lru") {
+      while (this.memory() > this.maxmemory) {
+        let evicted = false;
+        for (const database of this.dbs) {
+          if (database.evictLru()) {
+            evicted = true;
+            break;
+          }
+        }
+        if (!evicted) break;
+      }
+    }
+    return null;
+  }
+  cmdPing(session, args) {
+    if (args.length > 1) return arityError("ping");
+    if (session.channels.size + session.patterns.size > 0) {
+      return push([bulk("pong"), args[0] ? { t: "bulk", v: args[0] } : bulk("")]);
+    }
+    if (args.length === 1) return { t: "bulk", v: args[0] ?? null };
+    return simple("PONG");
+  }
+  cmdAuth(session, args) {
+    if (args.length !== 1 && args.length !== 2) return arityError("auth");
+    const user = args.length === 2 ? text(args[0]) : "default";
+    const password = text(args.length === 2 ? args[1] : args[0]);
+    if (!this.authRequired) return authWithoutPassword(password);
+    const account = user === "default" ? {
+      password: this.users.find((item) => item.name === "default")?.password ?? this.password,
+      readOnly: this.users.find((item) => item.name === "default")?.readOnly === true
+    } : this.users.find((item) => item.name === user);
+    if (!account || account.password === void 0 || account.password !== password)
+      return wrongPass();
+    session.authenticated = true;
+    session.username = user;
+    session.readOnly = account.readOnly === true;
+    return ok();
+  }
+  cmdHello(session, args) {
+    let protocol = session.protocol;
+    let index = 0;
+    if (args.length > 0) {
+      const requested = Number(text(args[0]));
+      if (requested !== 2 && requested !== 3) return err("NOPROTO unsupported protocol version");
+      protocol = requested;
+      index = 1;
+    }
+    while (index < args.length) {
+      const option = upper(args[index]);
+      if (option === "AUTH") {
+        const user = args[index + 1];
+        const pass = args[index + 2];
+        if (!user || !pass) return syntaxError();
+        const result = this.cmdAuth(session, [user, pass]);
+        if (result.t === "error") return result;
+        index += 3;
+        continue;
+      }
+      if (option === "SETNAME") {
+        const name = args[index + 1];
+        if (!name) return syntaxError();
+        session.name = text(name);
+        index += 2;
+        continue;
+      }
+      return syntaxError();
+    }
+    session.protocol = protocol;
+    return map([
+      [bulk("server"), bulk("redis")],
+      [bulk("version"), bulk(VERSION)],
+      [bulk("proto"), int(protocol)],
+      [bulk("id"), int(session.id)],
+      [bulk("mode"), bulk("standalone")],
+      [bulk("role"), bulk("master")],
+      [bulk("modules"), arr([])]
+    ]);
+  }
+  cmdSelect(session, args) {
+    if (args.length !== 1) return arityError("select");
+    const index = parseI64(args[0] ?? utf8(""));
+    if (index === null) return notInteger();
+    if (index < 0n || index >= BigInt(this.dbs.length)) return err("ERR DB index is out of range");
+    session.db = Number(index);
+    return ok();
+  }
+  cmdReset(session) {
+    session.multi = null;
+    session.multiFailed = false;
+    session.watching = [];
+    this.leavePubsub(session);
+    session.name = "";
+    session.db = 0;
+    session.protocol = 2;
+    session.authenticated = !this.authRequired;
+    session.readOnly = false;
+    return simple("RESET");
+  }
+  cmdClient(session, args, apply) {
+    const sub = upper(args[0]);
+    if (sub === "SETNAME") {
+      if (args.length !== 2) return arityError("client|setname");
+      if (!apply) return queued();
+      session.name = text(args[1]);
+      return ok();
+    }
+    if (sub === "GETNAME") return session.name ? bulk(session.name) : nil();
+    if (sub === "SETINFO") {
+      if (args.length !== 3) return arityError("client|setinfo");
+      const kind = upper(args[1]);
+      if (kind !== "LIB-NAME" && kind !== "LIB-VER") return syntaxError();
+      if (!apply) return queued();
+      if (kind === "LIB-NAME") session.libName = text(args[2]);
+      else session.libVer = text(args[2]);
+      return ok();
+    }
+    if (sub === "ID") return int(session.id);
+    if (sub === "INFO") return bulk(this.clientInfo(session));
+    if (sub === "LIST") {
+      return bulk([...this.sessions].map((item) => this.clientInfo(item)).join("\n"));
+    }
+    if (sub === "PAUSE" || sub === "UNPAUSE") return ok();
+    if (!sub) return arityError("client");
+    return err(`ERR unknown subcommand '${text(args[0]).toLowerCase()}'. Try CLIENT HELP.`);
+  }
+  clientInfo(session) {
+    return `id=${session.id} addr=127.0.0.1:${session.id} laddr=127.0.0.1:6379 name=${session.name} db=${session.db} sub=${session.channels.size} psub=${session.patterns.size} multi=${session.multi ? session.multi.length : -1} lib-name=${session.libName} lib-ver=${session.libVer}`;
+  }
+  info(session, section) {
+    const wanted = section.toLowerCase();
+    const blocks = [
+      [
+        "server",
+        [
+          "# Server",
+          `redis_version:${VERSION}`,
+          "redis_mode:standalone",
+          "os:mockingbird",
+          "arch_bits:64",
+          "tcp_port:6379",
+          "uptime_in_seconds:0"
+        ]
+      ],
+      ["clients", ["# Clients", `connected_clients:${this.sessions.size}`]],
+      [
+        "memory",
+        [
+          "# Memory",
+          `used_memory:${this.memory()}`,
+          `maxmemory:${this.maxmemory}`,
+          `maxmemory_policy:${this.policy}`
+        ]
+      ],
+      [
+        "persistence",
+        ["# Persistence", "loading:0", "rdb_changes_since_last_save:0", "aof_enabled:0"]
+      ],
+      ["stats", ["# Stats", `total_commands_processed:${this.commandCount}`]],
+      ["replication", ["# Replication", "role:master", "connected_slaves:0"]],
+      ["keyspace", ["# Keyspace", ...this.keyspaceLines()]]
+    ];
+    const chosen = wanted === "default" || wanted === "all" || wanted === "" ? blocks : blocks.filter((block) => block[0] === wanted);
+    const lines = chosen.flatMap((block) => block[1]);
+    if (session.id < 0) return "";
+    return `${lines.join("\r\n")}\r
+`;
+  }
+  keyspaceLines() {
+    const lines = [];
+    this.dbs.forEach((database, index) => {
+      const keys = database.keys();
+      if (keys.length === 0) return;
+      let expires = 0;
+      for (const key of keys) if (database.pttl(key) >= 0) expires++;
+      lines.push(`db${index}:keys=${keys.length},expires=${expires},avg_ttl=0`);
+    });
+    return lines;
+  }
+  cmdTime() {
+    const now = Math.trunc(this.clock.now());
+    const seconds = Math.trunc(now / 1e3);
+    const micros = now % 1e3 * 1e3;
+    return arr([bulk(String(seconds)), bulk(String(micros))]);
+  }
+  cmdConfig(args, apply) {
+    const sub = upper(args[0]);
+    if (sub === "GET") {
+      if (args.length !== 2) return arityError("config|get");
+      const key = text(args[1]).toLowerCase();
+      const value = key === "maxmemory" ? String(this.maxmemory) : key === "maxmemory-policy" ? this.policy : key === "timeout" ? "0" : key === "databases" ? String(this.dbs.length) : null;
+      if (value === null) return arr([]);
+      return arr([bulk(key), bulk(value)]);
+    }
+    if (sub === "SET") {
+      if (args.length !== 3) return arityError("config|set");
+      if (!apply) return queued();
+      const key = text(args[1]).toLowerCase();
+      const value = text(args[2]);
+      if (key === "maxmemory") {
+        const parsed = Number(value);
+        if (!Number.isFinite(parsed) || parsed < 0) return err("ERR Invalid argument");
+        return ok();
+      }
+      if (key === "maxmemory-policy") {
+        if (value !== "noeviction" && value !== "allkeys-lru") return err("ERR Invalid argument");
+        this.policy = value;
+        return ok();
+      }
+      return err("ERR Unsupported CONFIG parameter");
+    }
+    return arityError("config");
+  }
+  cmdRandomKey(session) {
+    const keys = this.database(session.db).keys();
+    if (keys.length === 0) return nil();
+    const key = keys[Math.floor(this.random() * keys.length)] ?? keys[0];
+    return key === void 0 ? nil() : { t: "bulk", v: fromLatin1(key) };
+  }
+  cmdScan(session, args) {
+    if (args.length < 1) return arityError("scan");
+    const cursor = Number(text(args[0]));
+    if (!Number.isInteger(cursor) || cursor < 0) return err("ERR invalid cursor");
+    let pattern = "*";
+    let count = 10;
+    for (let i = 1; i < args.length; i++) {
+      const option = upper(args[i]);
+      if (option === "MATCH") {
+        const value = args[++i];
+        if (!value) return syntaxError();
+        pattern = text(value);
+      } else if (option === "COUNT") {
+        const value = args[++i];
+        const parsed = value ? parseI64(value) : null;
+        if (parsed === null || parsed <= 0n) return syntaxError();
+        count = Number(parsed);
+      } else return syntaxError();
+    }
+    const keys = this.database(session.db).matching(pattern);
+    const slice = keys.slice(cursor, cursor + count);
+    const next = cursor + count >= keys.length ? 0 : cursor + count;
+    return arr([
+      bulk(String(next)),
+      arr(slice.map((key) => ({ t: "bulk", v: fromLatin1(key) })))
+    ]);
+  }
+  cmdKeys(session, args) {
+    if (args.length !== 1) return arityError("keys");
+    const keys = this.database(session.db).matching(text(args[0]));
+    return arr(keys.map((key) => ({ t: "bulk", v: fromLatin1(key) })));
+  }
+  cmdType(session, args) {
+    if (args.length !== 1) return arityError("type");
+    const value = this.database(session.db).get(text(args[0]));
+    return simple(value?.kind ?? "none");
+  }
+  cmdExists(session, args) {
+    if (args.length < 1) return arityError("exists");
+    const database = this.database(session.db);
+    return int(args.filter((arg) => database.has(text(arg))).length);
+  }
+  cmdDel(session, args, apply) {
+    if (args.length < 1) return arityError("del");
+    if (!apply) return queued();
+    const database = this.database(session.db);
+    let removed = 0;
+    for (const arg of args) if (database.delete(text(arg))) removed++;
+    return int(removed);
+  }
+  cmdRename(session, args, apply, nx) {
+    if (args.length !== 2) return arityError(nx ? "renamenx" : "rename");
+    const source = text(args[0]);
+    const dest = text(args[1]);
+    if (source === dest) return err("ERR source and destination objects are the same");
+    const database = this.database(session.db);
+    if (!database.has(source)) return noSuchKey();
+    if (nx && database.has(dest)) return int(0);
+    if (!apply) return queued();
+    database.rename(source, dest);
+    return nx ? int(1) : ok();
+  }
+  cmdExpire(session, command, args, apply) {
+    if (args.length < 2) return arityError(command);
+    const key = text(args[0]);
+    const amount = parseI64(args[1] ?? utf8(""));
+    if (amount === null) return notInteger();
+    let flag = "";
+    if (args.length === 3) flag = upper(args[2]);
+    else if (args.length > 3) return syntaxError();
+    if (flag && !["NX", "XX", "GT", "LT"].includes(flag)) return syntaxError();
+    const database = this.database(session.db);
+    if (!database.has(key)) return int(0);
+    if (!apply) return queued();
+    if (amount < 0n && (command === "expire" || command === "pexpire")) {
+      database.delete(key);
+      return int(1);
+    }
+    const now = database.now();
+    const absolute = command === "expire" ? now + Number(amount) * 1e3 : command === "pexpire" ? now + Number(amount) : command === "expireat" ? Number(amount) * 1e3 : Number(amount);
+    const current = database.expiry(key);
+    if (flag === "NX" && current !== null) return int(0);
+    if (flag === "XX" && current === null) return int(0);
+    if ((flag === "GT" || flag === "LT") && current === null) return int(0);
+    if (flag === "GT" && current !== null && absolute <= current) return int(0);
+    if (flag === "LT" && current !== null && absolute >= current) return int(0);
+    database.setExpiry(key, absolute);
+    return int(1);
+  }
+  cmdTtl(session, command, args) {
+    if (args.length !== 1) return arityError(command);
+    const pttl = this.database(session.db).pttl(text(args[0]));
+    if (pttl < 0) return int(pttl);
+    return int(command === "pttl" ? pttl : Math.floor(pttl / 1e3));
+  }
+  cmdPersist(session, args, apply) {
+    if (args.length !== 1) return arityError("persist");
+    const database = this.database(session.db);
+    const key = text(args[0]);
+    if (database.pttl(key) < 0) return int(0);
+    if (!apply) return queued();
+    database.setExpiry(key, null);
+    return int(1);
+  }
+  stringAt(database, key) {
+    const value = database.get(key);
+    if (!value) return null;
+    if (value.kind !== "string") return wrongType();
+    return value.bytes;
+  }
+  cmdGet(session, args) {
+    if (args.length !== 1) return arityError("get");
+    const value = this.stringAt(this.database(session.db), text(args[0]));
+    if (value instanceof Uint8Array) return { t: "bulk", v: value };
+    if (value === null) return nil();
+    return value;
+  }
+  cmdSet(session, args, apply) {
+    if (args.length < 2) return arityError("set");
+    const key = text(args[0]);
+    const value = args[1];
+    if (!value) return arityError("set");
+    let nx = false;
+    let xx = false;
+    let get = false;
+    let mode = null;
+    let amount = 0;
+    for (let i = 2; i < args.length; i++) {
+      const option = upper(args[i]);
+      if (option === "NX") nx = true;
+      else if (option === "XX") xx = true;
+      else if (option === "GET") get = true;
+      else if (option === "KEEPTTL") {
+        if (mode) return syntaxError();
+        mode = "keep";
+      } else if (option === "EX" || option === "PX" || option === "EXAT" || option === "PXAT") {
+        if (mode) return syntaxError();
+        const raw = args[++i];
+        const parsed = raw ? parseI64(raw) : null;
+        if (parsed === null) return notInteger();
+        mode = option.toLowerCase();
+        amount = Number(parsed);
+      } else return syntaxError();
+    }
+    if (nx && xx) return syntaxError();
+    const database = this.database(session.db);
+    const existing = database.get(key);
+    if (existing && existing.kind !== "string") return wrongType();
+    const previous = existing ? { t: "bulk", v: existing.bytes } : nil();
+    if (nx && existing || xx && !existing) return get ? previous : nil();
+    if (!apply) return queued();
+    const kept = mode === "keep" ? database.expiry(key) : null;
+    database.put(key, { kind: "string", bytes: value });
+    const now = database.now();
+    if (mode === "ex") database.setExpiry(key, now + amount * 1e3);
+    else if (mode === "px") database.setExpiry(key, now + amount);
+    else if (mode === "exat") database.setExpiry(key, amount * 1e3);
+    else if (mode === "pxat") database.setExpiry(key, amount);
+    else if (mode === "keep") {
+      if (kept !== null) database.setExpiry(key, kept);
+    } else database.setExpiry(key, null);
+    return get ? previous : ok();
+  }
+  cmdMget(session, args) {
+    if (args.length < 1) return arityError("mget");
+    return arr(args.map((arg) => this.cmdGet(session, [arg])));
+  }
+  cmdMset(session, args, apply) {
+    if (args.length < 2 || args.length % 2 !== 0) return arityError("mset");
+    if (!apply) return queued();
+    for (let i = 0; i < args.length; i += 2) {
+      const result = this.cmdSet(session, [args[i] ?? utf8(""), args[i + 1] ?? utf8("")], true);
+      if (result.t === "error") return result;
+    }
+    return ok();
+  }
+  cmdAppend(session, args, apply) {
+    if (args.length !== 2) return arityError("append");
+    const database = this.database(session.db);
+    const key = text(args[0]);
+    const extra = args[1] ?? utf8("");
+    const current = this.stringAt(database, key);
+    if (current && !(current instanceof Uint8Array)) return current;
+    if (!apply) return queued();
+    const bytes = current instanceof Uint8Array ? concatBytes(current, extra) : extra;
+    database.put(key, { kind: "string", bytes });
+    return int(bytes.length);
+  }
+  cmdStrlen(session, args) {
+    if (args.length !== 1) return arityError("strlen");
+    const value = this.stringAt(this.database(session.db), text(args[0]));
+    if (value instanceof Uint8Array) return int(value.length);
+    if (value === null) return int(0);
+    return value;
+  }
+  cmdGetRange(session, args) {
+    if (args.length !== 3) return arityError("getrange");
+    const value = this.stringAt(this.database(session.db), text(args[0]));
+    if (value && !(value instanceof Uint8Array)) return value;
+    const bytes = value instanceof Uint8Array ? value : utf8("");
+    const [start, end] = indexes(bytes.length, args[1], args[2]);
+    if (start > end) return bulk("");
+    return { t: "bulk", v: bytes.slice(start, end + 1) };
+  }
+  cmdSetRange(session, args, apply) {
+    if (args.length !== 3) return arityError("setrange");
+    const offset = parseI64(args[1] ?? utf8(""));
+    if (offset === null || offset < 0n) return err("ERR offset is out of range");
+    const database = this.database(session.db);
+    const key = text(args[0]);
+    const current = this.stringAt(database, key);
+    if (current && !(current instanceof Uint8Array)) return current;
+    if (!apply) return queued();
+    const patch = args[2] ?? utf8("");
+    const base = current instanceof Uint8Array ? current : new Uint8Array();
+    const next = new Uint8Array(Math.max(base.length, Number(offset) + patch.length));
+    next.set(base);
+    next.set(patch, Number(offset));
+    database.put(key, { kind: "string", bytes: next });
+    return int(next.length);
+  }
+  cmdIncr(session, args, delta, apply) {
+    if (args.length !== 1) return arityError(delta < 0n ? "decr" : "incr");
+    return this.addInteger(session, text(args[0]), delta, apply);
+  }
+  cmdIncrBy(session, command, args, apply) {
+    if (args.length !== 2) return arityError(command);
+    const delta = parseI64(args[1] ?? utf8(""));
+    if (delta === null) return notInteger();
+    return this.addInteger(session, text(args[0]), command === "decrby" ? -delta : delta, apply);
+  }
+  addInteger(session, key, delta, apply) {
+    const database = this.database(session.db);
+    const current = this.stringAt(database, key);
+    if (current && !(current instanceof Uint8Array)) return current;
+    let value = 0n;
+    if (current instanceof Uint8Array) {
+      const parsed = parseI64(current);
+      if (parsed === null) return notInteger();
+      value = parsed;
+    }
+    const next = value + delta;
+    if (next > 9223372036854775807n || next < -9223372036854775808n) return notInteger();
+    if (!apply) return queued();
+    database.put(key, { kind: "string", bytes: utf8(next.toString()) });
+    return int(intReply(next));
+  }
+  cmdIncrByFloat(session, args, apply, hash) {
+    if (hash) return syntaxError();
+    if (args.length !== 2) return arityError("incrbyfloat");
+    const delta = parseScore(args[1]);
+    if (delta === null) return notFloat();
+    const database = this.database(session.db);
+    const key = text(args[0]);
+    const current = this.stringAt(database, key);
+    if (current && !(current instanceof Uint8Array)) return current;
+    const base = current instanceof Uint8Array ? parseScore(current) : 0;
+    if (base === null) return notFloat();
+    if (!apply) return queued();
+    const next = scoreText(base + delta);
+    database.put(key, { kind: "string", bytes: utf8(next) });
+    return bulk(next);
+  }
+  cmdGetDel(session, args, apply) {
+    if (args.length !== 1) return arityError("getdel");
+    const got = this.cmdGet(session, args);
+    if (got.t === "error" || got.t !== "bulk" || got.v === null) return got;
+    if (!apply) return queued();
+    this.database(session.db).delete(text(args[0]));
+    return got;
+  }
+  cmdGetEx(session, args, apply) {
+    if (args.length < 1) return arityError("getex");
+    const got = this.cmdGet(session, [args[0] ?? utf8("")]);
+    if (got.t === "error") return got;
+    if (args.length === 1) return got;
+    if (!apply) return queued();
+    const option = upper(args[1]);
+    if (option === "PERSIST") {
+      this.database(session.db).setExpiry(text(args[0]), null);
+      return got;
+    }
+    const result = this.cmdExpire(
+      session,
+      option === "EX" ? "expire" : option === "PX" ? "pexpire" : option === "EXAT" ? "expireat" : "pexpireat",
+      [args[0] ?? utf8(""), args[2] ?? utf8("")],
+      true
+    );
+    if (result.t === "error") return result;
+    return got;
+  }
+  requireHash(database, key, create) {
+    const value = database.get(key);
+    if (!value) {
+      if (!create) return null;
+      const created = { kind: "hash", fields: /* @__PURE__ */ new Map() };
+      database.put(key, created);
+      return created;
+    }
+    if (value.kind !== "hash") return wrongType();
+    return value;
+  }
+  cmdHash(session, command, args, apply) {
+    const database = this.database(session.db);
+    const key = text(args[0]);
+    if (command === "hset" || command === "hmset" || command === "hsetnx") {
+      if (args.length < 3 || (args.length - 1) % 2 !== 0) return arityError(command);
+      const hash = this.requireHash(database, key, false);
+      if (hash && !(hash instanceof Object && "fields" in hash) && hash !== null)
+        return hash;
+      if (!apply) return queued();
+      const target = this.requireHash(database, key, true);
+      if (!target || !("fields" in target)) return target ?? wrongType();
+      let added = 0;
+      for (let i = 1; i < args.length; i += 2) {
+        const field = memberKey(args[i] ?? utf8(""));
+        const value = args[i + 1] ?? utf8("");
+        if (command === "hsetnx" && target.fields.has(field)) continue;
+        if (!target.fields.has(field)) added++;
+        target.fields.set(field, value);
+      }
+      database.put(key, target);
+      return command === "hmset" ? ok() : int(command === "hsetnx" ? added > 0 ? 1 : 0 : added);
+    }
+    if (command === "hget") {
+      if (args.length !== 2) return arityError("hget");
+      const hash = this.requireHash(database, key, false);
+      if (hash === null) return nil();
+      if (!("fields" in hash)) return hash;
+      const value = hash.fields.get(memberKey(args[1] ?? utf8("")));
+      return value ? { t: "bulk", v: value } : nil();
+    }
+    if (command === "hdel") {
+      if (args.length < 2) return arityError("hdel");
+      const hash = this.requireHash(database, key, false);
+      if (hash === null) return int(0);
+      if (!("fields" in hash)) return hash;
+      if (!apply) return queued();
+      let removed = 0;
+      for (let i = 1; i < args.length; i++) {
+        if (hash.fields.delete(memberKey(args[i] ?? utf8("")))) removed++;
+      }
+      database.dropIfEmpty(key);
+      if (database.has(key)) database.put(key, hash);
+      return int(removed);
+    }
+    if (command === "hexists") {
+      if (args.length !== 2) return arityError("hexists");
+      const hash = this.requireHash(database, key, false);
+      if (hash === null) return int(0);
+      if (!("fields" in hash)) return hash;
+      return int(hash.fields.has(memberKey(args[1] ?? utf8(""))) ? 1 : 0);
+    }
+    if (command === "hlen") {
+      if (args.length !== 1) return arityError("hlen");
+      const hash = this.requireHash(database, key, false);
+      if (hash === null) return int(0);
+      if (!("fields" in hash)) return hash;
+      return int(hash.fields.size);
+    }
+    if (command === "hstrlen") {
+      if (args.length !== 2) return arityError("hstrlen");
+      const hash = this.requireHash(database, key, false);
+      if (hash === null) return int(0);
+      if (!("fields" in hash)) return hash;
+      return int(hash.fields.get(memberKey(args[1] ?? utf8("")))?.length ?? 0);
+    }
+    if (command === "hkeys" || command === "hvals" || command === "hgetall") {
+      if (args.length !== 1) return arityError(command);
+      const hash = this.requireHash(database, key, false);
+      if (hash === null) return arr([]);
+      if (!("fields" in hash)) return hash;
+      const items = [];
+      for (const [field, value] of hash.fields) {
+        if (command !== "hvals") items.push({ t: "bulk", v: fromLatin1(field) });
+        if (command !== "hkeys") items.push({ t: "bulk", v: value });
+      }
+      return arr(items);
+    }
+    if (command === "hmget") {
+      if (args.length < 2) return arityError("hmget");
+      const hash = this.requireHash(database, key, false);
+      if (hash && !("fields" in hash)) return hash;
+      return arr(
+        args.slice(1).map((field) => {
+          const value = hash && "fields" in hash ? hash.fields.get(memberKey(field)) : void 0;
+          return value ? { t: "bulk", v: value } : nil();
+        })
+      );
+    }
+    if (command === "hincrby" || command === "hincrbyfloat") {
+      if (args.length !== 3) return arityError(command);
+      const hash = this.requireHash(database, key, false);
+      if (hash && !("fields" in hash)) return hash;
+      const field = memberKey(args[1] ?? utf8(""));
+      const current = hash && "fields" in hash ? hash.fields.get(field) : void 0;
+      if (command === "hincrby") {
+        const delta2 = parseI64(args[2] ?? utf8(""));
+        if (delta2 === null) return notInteger();
+        const base2 = current ? parseI64(current) : 0n;
+        if (base2 === null) return notInteger();
+        if (!apply) return queued();
+        const target2 = this.requireHash(database, key, true);
+        if (!target2 || !("fields" in target2)) return target2 ?? wrongType();
+        const next2 = base2 + delta2;
+        target2.fields.set(field, utf8(next2.toString()));
+        database.put(key, target2);
+        return int(intReply(next2));
+      }
+      const delta = parseScore(args[2]);
+      if (delta === null) return notFloat();
+      const base = current ? parseScore(current) : 0;
+      if (base === null) return notFloat();
+      if (!apply) return queued();
+      const target = this.requireHash(database, key, true);
+      if (!target || !("fields" in target)) return target ?? wrongType();
+      const next = scoreText(base + delta);
+      target.fields.set(field, utf8(next));
+      database.put(key, target);
+      return bulk(next);
+    }
+    return unknownCommand(command, args);
+  }
+  requireList(database, key, create) {
+    const value = database.get(key);
+    if (!value) {
+      if (!create) return null;
+      const created = { kind: "list", items: [] };
+      database.put(key, created);
+      return created;
+    }
+    if (value.kind !== "list") return wrongType();
+    return value;
+  }
+  cmdList(session, command, args, apply) {
+    const database = this.database(session.db);
+    const key = text(args[0]);
+    if (command === "lpush" || command === "rpush") {
+      if (args.length < 2) return arityError(command);
+      const existing = this.requireList(database, key, false);
+      if (existing && !("items" in existing)) return existing;
+      if (!apply) return queued();
+      const list = this.requireList(database, key, true);
+      if (!list || !("items" in list)) return list ?? wrongType();
+      const items = args.slice(1);
+      if (command === "lpush") for (const item of items) list.items.unshift(item);
+      else for (const item of items) list.items.push(item);
+      database.put(key, list);
+      const length = list.items.length;
+      this.wake(session.db, key);
+      return int(length);
+    }
+    if (command === "lpop" || command === "rpop") {
+      if (args.length < 1 || args.length > 2) return arityError(command);
+      const list = this.requireList(database, key, false);
+      if (list === null) return args.length === 2 ? nilArray() : nil();
+      if (!("items" in list)) return list;
+      const count = args.length === 2 ? parseI64(args[1] ?? utf8("")) : null;
+      if (args.length === 2 && (count === null || count < 0n)) return notInteger();
+      if (!apply) return queued();
+      const take = count === null ? 1 : Number(count);
+      const popped = [];
+      for (let i = 0; i < take && list.items.length > 0; i++) {
+        const item = command === "lpop" ? list.items.shift() : list.items.pop();
+        if (item) popped.push(item);
+      }
+      database.dropIfEmpty(key);
+      if (database.has(key)) database.put(key, list);
+      if (count === null) return popped[0] ? { t: "bulk", v: popped[0] } : nil();
+      return arr(popped.map((item) => ({ t: "bulk", v: item })));
+    }
+    if (command === "llen") {
+      if (args.length !== 1) return arityError("llen");
+      const list = this.requireList(database, key, false);
+      if (list === null) return int(0);
+      if (!("items" in list)) return list;
+      return int(list.items.length);
+    }
+    if (command === "lrange") {
+      if (args.length !== 3) return arityError("lrange");
+      const list = this.requireList(database, key, false);
+      if (list === null) return arr([]);
+      if (!("items" in list)) return list;
+      const [start, end] = indexes(list.items.length, args[1], args[2]);
+      if (start > end) return arr([]);
+      return arr(list.items.slice(start, end + 1).map((item) => ({ t: "bulk", v: item })));
+    }
+    if (command === "lindex") {
+      if (args.length !== 2) return arityError("lindex");
+      const list = this.requireList(database, key, false);
+      if (list === null) return nil();
+      if (!("items" in list)) return list;
+      const at = listIndex(list.items.length, args[1]);
+      const item = at === null ? void 0 : list.items[at];
+      return item ? { t: "bulk", v: item } : nil();
+    }
+    if (command === "lset") {
+      if (args.length !== 3) return arityError("lset");
+      const list = this.requireList(database, key, false);
+      if (list === null) return err("ERR no such key");
+      if (!("items" in list)) return list;
+      const at = listIndex(list.items.length, args[1]);
+      if (at === null || list.items[at] === void 0) return err("ERR index out of range");
+      if (!apply) return queued();
+      list.items[at] = args[2] ?? utf8("");
+      database.put(key, list);
+      return ok();
+    }
+    if (command === "lrem") {
+      if (args.length !== 3) return arityError("lrem");
+      const list = this.requireList(database, key, false);
+      if (list === null) return int(0);
+      if (!("items" in list)) return list;
+      const count = parseI64(args[1] ?? utf8(""));
+      if (count === null) return notInteger();
+      if (!apply) return queued();
+      const target = args[2] ?? utf8("");
+      const matches = list.items.map((item, index) => ({ item, index })).filter(
+        (item) => item.item.length === target.length && item.item.every((byte, index) => byte === target[index])
+      );
+      const chosen = count === 0n ? matches : count > 0n ? matches.slice(0, Number(count)) : matches.slice(matches.length + Number(count));
+      const remove = new Set(chosen.map((item) => item.index));
+      list.items = list.items.filter((_, index) => !remove.has(index));
+      database.dropIfEmpty(key);
+      if (database.has(key)) database.put(key, list);
+      return int(chosen.length);
+    }
+    if (command === "ltrim") {
+      if (args.length !== 3) return arityError("ltrim");
+      const list = this.requireList(database, key, false);
+      if (list === null) return ok();
+      if (!("items" in list)) return list;
+      if (!apply) return queued();
+      const [start, end] = indexes(list.items.length, args[1], args[2]);
+      list.items = start > end ? [] : list.items.slice(start, end + 1);
+      database.dropIfEmpty(key);
+      if (database.has(key)) database.put(key, list);
+      return ok();
+    }
+    if (command === "linsert") {
+      if (args.length !== 4) return arityError("linsert");
+      const list = this.requireList(database, key, false);
+      if (list === null) return int(0);
+      if (!("items" in list)) return list;
+      const where = upper(args[1]);
+      if (where !== "BEFORE" && where !== "AFTER") return syntaxError();
+      const pivot = args[2] ?? utf8("");
+      const at = list.items.findIndex(
+        (item) => item.length === pivot.length && item.every((byte, index) => byte === pivot[index])
+      );
+      if (at < 0) return int(-1);
+      if (!apply) return queued();
+      list.items.splice(where === "BEFORE" ? at : at + 1, 0, args[3] ?? utf8(""));
+      database.put(key, list);
+      this.wake(session.db, key);
+      return int(list.items.length);
+    }
+    if (command === "lmove" || command === "rpoplpush") {
+      const source = key;
+      const dest = command === "rpoplpush" ? text(args[1]) : text(args[1]);
+      const from = command === "rpoplpush" ? "right" : upper(args[2]);
+      const to = command === "rpoplpush" ? "left" : upper(args[3]);
+      if (command === "lmove" && args.length !== 4) return arityError("lmove");
+      if (command === "rpoplpush" && args.length !== 2) return arityError("rpoplpush");
+      if (from !== "LEFT" && from !== "RIGHT" && command === "lmove") return syntaxError();
+      if (to !== "LEFT" && to !== "RIGHT" && command === "lmove") return syntaxError();
+      const list = this.requireList(database, source, false);
+      if (list === null) return nil();
+      if (!("items" in list)) return list;
+      const destList = this.requireList(database, dest, false);
+      if (destList && !("items" in destList)) return destList;
+      if (!apply) return queued();
+      const item = (command === "rpoplpush" || from === "RIGHT" ? list.items.pop() : list.items.shift()) ?? null;
+      if (!item) return nil();
+      database.dropIfEmpty(source);
+      if (database.has(source)) database.put(source, list);
+      const target = this.requireList(database, dest, true);
+      if (!target || !("items" in target)) return target ?? wrongType();
+      if (command === "rpoplpush" || to === "LEFT") target.items.unshift(item);
+      else target.items.push(item);
+      database.put(dest, target);
+      this.wake(session.db, dest);
+      return { t: "bulk", v: item };
+    }
+    return unknownCommand(command, args);
+  }
+  cmdBlockingList(session, args, apply, side) {
+    const name = side === "left" ? "blpop" : "brpop";
+    if (args.length < 2) return arityError(name);
+    const timeout = parseTimeout(args[args.length - 1]);
+    if (timeout === null) return err("ERR timeout is not a float or out of range");
+    const keys = args.slice(0, -1).map((arg) => text(arg));
+    for (const key of keys) {
+      const value = this.database(session.db).get(key);
+      if (value && value.kind !== "list") return wrongType();
+    }
+    if (!apply) return queued();
+    const immediate = this.takeList(session.db, keys, side);
+    if (immediate) return immediate;
+    if (session.inExec || this.scriptDepth > 0) return nilArray();
+    return this.block({
+      kind: "list",
+      keys,
+      db: session.db,
+      side,
+      count: 1,
+      ...timeout > 0 ? { deadline: this.clock.now() + timeout * 1e3 } : {},
+      session
+    });
+  }
+  takeList(dbIndex, keys, side) {
+    if (this.consumersPaused) return null;
+    const database = this.database(dbIndex);
+    for (const key of keys) {
+      const value = database.get(key);
+      if (!value) continue;
+      if (value.kind !== "list") return wrongType();
+      const item = side === "left" ? value.items.shift() : value.items.pop();
+      if (!item) continue;
+      database.dropIfEmpty(key);
+      if (database.has(key)) database.put(key, value);
+      return arr([bulk(key), { t: "bulk", v: item }]);
+    }
+    return null;
+  }
+  requireSet(database, key, create) {
+    const value = database.get(key);
+    if (!value) {
+      if (!create) return null;
+      const created = { kind: "set", members: /* @__PURE__ */ new Map() };
+      database.put(key, created);
+      return created;
+    }
+    if (value.kind !== "set") return wrongType();
+    return value;
+  }
+  cmdSetFamily(session, command, args, apply) {
+    const database = this.database(session.db);
+    const key = text(args[0]);
+    if (command === "sadd" || command === "srem") {
+      if (args.length < 2) return arityError(command);
+      const existing = this.requireSet(database, key, false);
+      if (existing && !("members" in existing)) return existing;
+      if (!apply) return queued();
+      if (command === "srem" && existing === null) return int(0);
+      const set = this.requireSet(database, key, command === "sadd");
+      if (!set || !("members" in set)) return set ?? int(0);
+      let changed = 0;
+      for (const arg of args.slice(1)) {
+        const member = memberKey(arg);
+        if (command === "sadd" && !set.members.has(member)) {
+          set.members.set(member, arg);
+          changed++;
+        }
+        if (command === "srem" && set.members.delete(member)) changed++;
+      }
+      if (command === "sadd") database.put(key, set);
+      database.dropIfEmpty(key);
+      if (database.has(key)) database.put(key, set);
+      return int(changed);
+    }
+    if (command === "sismember") {
+      if (args.length !== 2) return arityError("sismember");
+      const set = this.requireSet(database, key, false);
+      if (set === null) return int(0);
+      if (!("members" in set)) return set;
+      return int(set.members.has(memberKey(args[1] ?? utf8(""))) ? 1 : 0);
+    }
+    if (command === "smismember") {
+      if (args.length < 2) return arityError("smismember");
+      const set = this.requireSet(database, key, false);
+      if (set && !("members" in set)) return set;
+      return arr(
+        args.slice(1).map((arg) => int(set && "members" in set && set.members.has(memberKey(arg)) ? 1 : 0))
+      );
+    }
+    if (command === "smembers" || command === "scard") {
+      if (args.length !== 1) return arityError(command);
+      const set = this.requireSet(database, key, false);
+      if (set === null) return command === "scard" ? int(0) : arr([]);
+      if (!("members" in set)) return set;
+      if (command === "scard") return int(set.members.size);
+      const members = [...set.members.values()].sort((a, b) => compareBytes(a, b));
+      return arr(members.map((member) => ({ t: "bulk", v: member })));
+    }
+    if (command === "spop" || command === "srandmember") {
+      if (args.length < 1 || args.length > 2) return arityError(command);
+      const set = this.requireSet(database, key, false);
+      if (set === null) return args.length === 2 ? arr([]) : nil();
+      if (!("members" in set)) return set;
+      const count = args.length === 2 ? parseI64(args[1] ?? utf8("")) : null;
+      if (args.length === 2 && count === null) return notInteger();
+      if (!apply && command === "spop") return queued();
+      const members = [...set.members.values()];
+      if (members.length === 0) return count === null ? nil() : arr([]);
+      const picked = [];
+      const pool = members.slice();
+      const times = count === null ? 1 : Math.min(
+        Math.abs(Number(count)),
+        command === "srandmember" && count < 0n ? Number(-count) : pool.length
+      );
+      for (let i = 0; i < (count !== null && count < 0n && command === "srandmember" ? Number(-count) : times); i++) {
+        const index = Math.floor(
+          this.random() * (command === "srandmember" && count !== null && count < 0n ? members.length : pool.length)
+        );
+        const member = command === "srandmember" && count !== null && count < 0n ? members[index] : pool.splice(index, 1)[0];
+        if (member) picked.push(member);
+      }
+      if (command === "spop") {
+        for (const member of picked) set.members.delete(memberKey(member));
+        database.dropIfEmpty(key);
+        if (database.has(key)) database.put(key, set);
+      }
+      if (count === null) return picked[0] ? { t: "bulk", v: picked[0] } : nil();
+      return arr(picked.map((member) => ({ t: "bulk", v: member })));
+    }
+    if (command === "sinter" || command === "sunion" || command === "sdiff") {
+      if (args.length < 1) return arityError(command);
+      const sets = [];
+      for (const arg of args) {
+        const set = this.requireSet(database, text(arg), false);
+        if (set && !("members" in set)) return set;
+        sets.push(set && "members" in set ? set : null);
+      }
+      const [first2, ...rest] = sets;
+      let members = new Map(first2?.members ?? []);
+      if (command === "sinter") {
+        for (const set of rest) {
+          members = new Map([...members].filter(([member]) => set?.members.has(member)));
+        }
+      } else if (command === "sunion") {
+        for (const set of rest)
+          for (const [member, bytes] of set?.members ?? []) members.set(member, bytes);
+      } else {
+        for (const set of rest)
+          for (const member of set?.members.keys() ?? []) members.delete(member);
+      }
+      const ordered = [...members.values()].sort((a, b) => compareBytes(a, b));
+      return arr(ordered.map((member) => ({ t: "bulk", v: member })));
+    }
+    if (command === "smove") {
+      if (args.length !== 3) return arityError("smove");
+      const source = this.requireSet(database, key, false);
+      if (source && !("members" in source)) return source;
+      const destKey = text(args[1]);
+      const dest = this.requireSet(database, destKey, false);
+      if (dest && !("members" in dest)) return dest;
+      const member = memberKey(args[2] ?? utf8(""));
+      if (!source || !("members" in source) || !source.members.has(member)) return int(0);
+      if (!apply) return queued();
+      const bytes = source.members.get(member) ?? utf8("");
+      source.members.delete(member);
+      database.dropIfEmpty(key);
+      if (database.has(key)) database.put(key, source);
+      const target = this.requireSet(database, destKey, true);
+      if (!target || !("members" in target)) return target ?? wrongType();
+      target.members.set(member, bytes);
+      database.put(destKey, target);
+      return int(1);
+    }
+    return unknownCommand(command, args);
+  }
+  requireZset(database, key, create) {
+    const value = database.get(key);
+    if (!value) {
+      if (!create) return null;
+      const created = { kind: "zset", members: /* @__PURE__ */ new Map() };
+      database.put(key, created);
+      return created;
+    }
+    if (value.kind !== "zset") return wrongType();
+    return value;
+  }
+  cmdZset(session, command, args, apply) {
+    const database = this.database(session.db);
+    const key = text(args[0]);
+    if (command === "zadd") return this.cmdZadd(session, args, apply);
+    if (command === "zrem") {
+      if (args.length < 2) return arityError("zrem");
+      const zset = this.requireZset(database, key, false);
+      if (zset === null) return int(0);
+      if (!("members" in zset)) return zset;
+      if (!apply) return queued();
+      let removed = 0;
+      for (const arg of args.slice(1)) if (zset.members.delete(memberKey(arg))) removed++;
+      database.dropIfEmpty(key);
+      if (database.has(key)) database.put(key, zset);
+      return int(removed);
+    }
+    if (command === "zcard") {
+      if (args.length !== 1) return arityError("zcard");
+      const zset = this.requireZset(database, key, false);
+      if (zset === null) return int(0);
+      if (!("members" in zset)) return zset;
+      return int(zset.members.size);
+    }
+    if (command === "zscore" || command === "zmscore") {
+      if (command === "zscore" && args.length !== 2) return arityError("zscore");
+      if (command === "zmscore" && args.length < 2) return arityError("zmscore");
+      const zset = this.requireZset(database, key, false);
+      if (zset && !("members" in zset)) return zset;
+      const scores = args.slice(1).map((arg) => {
+        const member = zset && "members" in zset ? zset.members.get(memberKey(arg)) : void 0;
+        return member ? bulk(scoreText(member.score)) : nil();
+      });
+      return command === "zscore" ? scores[0] ?? nil() : arr(scores);
+    }
+    if (command === "zincrby") {
+      if (args.length !== 3) return arityError("zincrby");
+      const delta = parseScore(args[1]);
+      if (delta === null) return notFloat();
+      if (!apply) return queued();
+      const zset = this.requireZset(database, key, true);
+      if (!zset || !("members" in zset)) return zset ?? wrongType();
+      const member = args[2] ?? utf8("");
+      const current = zset.members.get(memberKey(member));
+      const score = (current?.score ?? 0) + delta;
+      zset.members.set(memberKey(member), { member, score });
+      database.put(key, zset);
+      this.wake(session.db, key);
+      return bulk(scoreText(score));
+    }
+    if (command === "zrank" || command === "zrevrank") {
+      if (args.length !== 2) return arityError(command);
+      const zset = this.requireZset(database, key, false);
+      if (zset === null) return nil();
+      if (!("members" in zset)) return zset;
+      const ordered = database.zsetOrdered(zset);
+      const at = ordered.findIndex(
+        (item) => memberKey(item.member) === memberKey(args[1] ?? utf8(""))
+      );
+      if (at < 0) return nil();
+      return int(command === "zrevrank" ? ordered.length - 1 - at : at);
+    }
+    if (command === "zrange" || command === "zrevrange" || command === "zrangebyscore" || command === "zrevrangebyscore") {
+      return this.cmdZrange(database, command, args);
+    }
+    if (command === "zcount") {
+      if (args.length !== 3) return arityError("zcount");
+      const zset = this.requireZset(database, key, false);
+      if (zset === null) return int(0);
+      if (!("members" in zset)) return zset;
+      const min = parseBound(text(args[1]));
+      const max = parseBound(text(args[2]));
+      if (!min || !max) return notFloat();
+      return int(database.zsetOrdered(zset).filter((item) => inBound(item.score, min, max)).length);
+    }
+    if (command === "zpopmin" || command === "zpopmax") {
+      if (args.length < 1 || args.length > 2) return arityError(command);
+      const zset = this.requireZset(database, key, false);
+      if (zset === null) return arr([]);
+      if (!("members" in zset)) return zset;
+      const count = args.length === 2 ? parseI64(args[1] ?? utf8("")) : 1n;
+      if (count === null || count < 0n) return notInteger();
+      if (!apply) return queued();
+      const ordered = database.zsetOrdered(zset);
+      const picked = command === "zpopmax" ? ordered.slice(-Number(count)).reverse() : ordered.slice(0, Number(count));
+      for (const item of picked) zset.members.delete(memberKey(item.member));
+      database.dropIfEmpty(key);
+      if (database.has(key)) database.put(key, zset);
+      return arr(
+        picked.flatMap((item) => [
+          { t: "bulk", v: item.member },
+          bulk(scoreText(item.score))
+        ])
+      );
+    }
+    if (command === "zremrangebyscore" || command === "zremrangebyrank") {
+      if (args.length !== 3) return arityError(command);
+      const zset = this.requireZset(database, key, false);
+      if (zset === null) return int(0);
+      if (!("members" in zset)) return zset;
+      if (!apply) return queued();
+      const ordered = database.zsetOrdered(zset);
+      let removed = 0;
+      if (command === "zremrangebyrank") {
+        const [start, end] = indexes(ordered.length, args[1], args[2]);
+        ordered.forEach((item, index) => {
+          if (index >= start && index <= end) {
+            zset.members.delete(memberKey(item.member));
+            removed++;
+          }
+        });
+      } else {
+        const min = parseBound(text(args[1]));
+        const max = parseBound(text(args[2]));
+        if (!min || !max) return notFloat();
+        for (const item of ordered) {
+          if (!inBound(item.score, min, max)) continue;
+          zset.members.delete(memberKey(item.member));
+          removed++;
+        }
+      }
+      database.dropIfEmpty(key);
+      if (database.has(key)) database.put(key, zset);
+      return int(removed);
+    }
+    return unknownCommand(command, args);
+  }
+  cmdZadd(session, args, apply) {
+    if (args.length < 3) return arityError("zadd");
+    let index = 1;
+    let nx = false;
+    let xx = false;
+    let gt = false;
+    let lt = false;
+    let ch = false;
+    let incr = false;
+    while (index < args.length) {
+      const option = upper(args[index]);
+      if (!["NX", "XX", "GT", "LT", "CH", "INCR"].includes(option)) break;
+      if (option === "NX") nx = true;
+      if (option === "XX") xx = true;
+      if (option === "GT") gt = true;
+      if (option === "LT") lt = true;
+      if (option === "CH") ch = true;
+      if (option === "INCR") incr = true;
+      index++;
+    }
+    if ((gt || lt) && nx)
+      return err("ERR GT, LT, and/or NX options at the same time are not compatible");
+    if ((args.length - index) % 2 !== 0 || index >= args.length) return syntaxError();
+    if (incr && args.length - index !== 2)
+      return err("ERR INCR option supports a single increment-element pair");
+    const database = this.database(session.db);
+    const key = text(args[0]);
+    const existing = this.requireZset(database, key, false);
+    if (existing && !("members" in existing)) return existing;
+    if (!apply) return queued();
+    const zset = this.requireZset(database, key, true);
+    if (!zset || !("members" in zset)) return zset ?? wrongType();
+    let changed = 0;
+    let added = 0;
+    let updatedScore = 0;
+    for (let i = index; i < args.length; i += 2) {
+      const score = parseScore(args[i]);
+      if (score === null) return notFloat();
+      const member = args[i + 1] ?? utf8("");
+      const current = zset.members.get(memberKey(member));
+      if (nx && current) continue;
+      if ((xx || gt || lt) && !current) continue;
+      if (gt && current && score <= current.score) continue;
+      if (lt && current && score >= current.score) continue;
+      const next = incr ? (current?.score ?? 0) + score : score;
+      if (!current) added++;
+      else if (current.score !== next) updatedScore++;
+      zset.members.set(memberKey(member), { member, score: next });
+      if (incr) {
+        database.put(key, zset);
+        this.wake(session.db, key);
+        return bulk(scoreText(next));
+      }
+    }
+    changed = ch ? added + updatedScore : added;
+    database.put(key, zset);
+    this.wake(session.db, key);
+    return int(changed);
+  }
+  cmdZrange(database, command, args) {
+    if (args.length < 3) return arityError(command);
+    const zset = this.requireZset(database, text(args[0]), false);
+    if (zset === null) return arr([]);
+    if (!("members" in zset)) return zset;
+    let byScore = command === "zrangebyscore" || command === "zrevrangebyscore";
+    let rev = command === "zrevrange" || command === "zrevrangebyscore";
+    let withScores = false;
+    let limit = null;
+    const rest = args.slice(3);
+    for (let i = 0; i < rest.length; i++) {
+      const option = upper(rest[i]);
+      if (option === "BYSCORE") byScore = true;
+      else if (option === "REV") rev = true;
+      else if (option === "WITHSCORES") withScores = true;
+      else if (option === "LIMIT") {
+        const offset = parseI64(rest[++i] ?? utf8(""));
+        const count = parseI64(rest[++i] ?? utf8(""));
+        if (offset === null || count === null) return notInteger();
+        limit = { offset: Number(offset), count: Number(count) };
+      } else return syntaxError();
+    }
+    let ordered = database.zsetOrdered(zset);
+    if (byScore) {
+      const left = parseBound(text(args[1]));
+      const right = parseBound(text(args[2]));
+      if (!left || !right) return notFloat();
+      const min = rev ? right : left;
+      const max = rev ? left : right;
+      ordered = ordered.filter((item) => inBound(item.score, min, max));
+    } else {
+      const [start, end] = indexes(ordered.length, args[1], args[2]);
+      ordered = start > end ? [] : ordered.slice(start, end + 1);
+    }
+    if (rev) ordered.reverse();
+    if (limit) ordered = ordered.slice(limit.offset, limit.offset + limit.count);
+    return arr(
+      ordered.flatMap((item) => {
+        const member = { t: "bulk", v: item.member };
+        return withScores ? [member, bulk(scoreText(item.score))] : [member];
+      })
+    );
+  }
+  cmdBlockingZset(session, args, apply, max) {
+    const name = max ? "bzpopmax" : "bzpopmin";
+    if (args.length < 2) return arityError(name);
+    const timeout = parseTimeout(args[args.length - 1]);
+    if (timeout === null) return err("ERR timeout is not a float or out of range");
+    const keys = args.slice(0, -1).map((arg) => text(arg));
+    for (const key of keys) {
+      const value = this.database(session.db).get(key);
+      if (value && value.kind !== "zset") return wrongType();
+    }
+    if (!apply) return queued();
+    const immediate = this.takeZset(session.db, keys, max);
+    if (immediate) return immediate;
+    if (session.inExec || this.scriptDepth > 0) return nilArray();
+    return this.block({
+      kind: "zset",
+      keys,
+      db: session.db,
+      side: "left",
+      max,
+      count: 1,
+      ...timeout > 0 ? { deadline: this.clock.now() + timeout * 1e3 } : {},
+      session
+    });
+  }
+  takeZset(dbIndex, keys, max) {
+    if (this.consumersPaused) return null;
+    const database = this.database(dbIndex);
+    for (const key of keys) {
+      const value = database.get(key);
+      if (!value) continue;
+      if (value.kind !== "zset") return wrongType();
+      const ordered = database.zsetOrdered(value);
+      const member = max ? ordered[ordered.length - 1] : ordered[0];
+      if (!member) continue;
+      value.members.delete(memberKey(member.member));
+      database.dropIfEmpty(key);
+      if (database.has(key)) database.put(key, value);
+      return arr([bulk(key), { t: "bulk", v: member.member }, bulk(scoreText(member.score))]);
+    }
+    return null;
+  }
+  cmdStream(session, command, args, apply) {
+    if (command === "xadd") return this.cmdXadd(session, args, apply);
+    if (command === "xlen") {
+      if (args.length !== 1) return arityError("xlen");
+      const stream = this.stream(session, text(args[0]), false);
+      if (stream === null) return int(0);
+      if (!(stream instanceof Object) || !("entries" in stream)) return stream;
+      return int(stream.entries.length);
+    }
+    if (command === "xrange" || command === "xrevrange")
+      return this.cmdXrange(session, command, args);
+    if (command === "xdel") return this.cmdXdel(session, args, apply);
+    if (command === "xtrim") return this.cmdXtrim(session, args, apply);
+    if (command === "xgroup") return this.cmdXgroup(session, args, apply);
+    if (command === "xread") return this.cmdXread(session, args, apply, false);
+    if (command === "xreadgroup") return this.cmdXread(session, args, apply, true);
+    if (command === "xack") return this.cmdXack(session, args, apply);
+    if (command === "xpending") return this.cmdXpending(session, args);
+    if (command === "xclaim") return this.cmdXclaim(session, args, apply, false);
+    if (command === "xautoclaim") return this.cmdXclaim(session, args, apply, true);
+    if (command === "xinfo") return this.cmdXinfo(session, args);
+    return unknownCommand(command, args);
+  }
+  stream(session, key, create) {
+    const database = this.database(session.db);
+    const value = database.get(key);
+    if (!value) {
+      if (!create) return null;
+      const created = { kind: "stream", stream: emptyStream() };
+      database.put(key, created);
+      return created.stream;
+    }
+    if (value.kind !== "stream") return wrongType();
+    return value.stream;
+  }
+  cmdXadd(session, args, apply) {
+    if (args.length < 4) return arityError("xadd");
+    let index = 1;
+    let nomk = false;
+    let maxlen = null;
+    const key = text(args[0]);
+    while (index < args.length) {
+      const option = upper(args[index]);
+      if (option === "NOMKSTREAM") {
+        nomk = true;
+        index++;
+        continue;
+      }
+      if (option === "MAXLEN" || option === "MINID") {
+        index++;
+        if (upper(args[index]) === "~" || upper(args[index]) === "=") index++;
+        const parsed = parseI64(args[index] ?? utf8(""));
+        if (parsed === null || parsed < 0n) return syntaxError();
+        if (option === "MAXLEN") maxlen = Number(parsed);
+        index++;
+        continue;
+      }
+      break;
+    }
+    const idArg = text(args[index]);
+    const fields = args.slice(index + 1);
+    if (fields.length < 2 || fields.length % 2 !== 0) return syntaxError();
+    const database = this.database(session.db);
+    if (!database.has(key) && nomk) return nil();
+    const stream = this.stream(session, key, true);
+    if (!stream || !("entries" in stream)) return stream ?? wrongType();
+    if (!apply) return queued();
+    const id = this.nextId(stream, idArg);
+    if (typeof id !== "string") return id;
+    stream.entries.push({ id, ...parseStreamId(id) ?? { ms: 0n, seq: 0n }, fields });
+    if (maxlen !== null && stream.entries.length > maxlen) {
+      stream.entries.splice(0, stream.entries.length - maxlen);
+    }
+    const value = database.get(key);
+    if (value && value.kind === "stream") database.put(key, value);
+    this.wake(session.db, key);
+    return bulk(id);
+  }
+  nextId(stream, requested) {
+    if (requested === "*") {
+      let ms = BigInt(Math.max(0, Math.trunc(this.clock.now())));
+      if (ms > stream.lastMs) {
+        stream.lastMs = ms;
+        stream.lastSeq = 0n;
+      } else {
+        ms = stream.lastMs;
+        stream.lastSeq += 1n;
+      }
+      if (stream.lastMs === 0n && stream.lastSeq === 0n) stream.lastSeq = 1n;
+      return `${stream.lastMs}-${stream.lastSeq}`;
+    }
+    const parsed = parseStreamId(requested);
+    if (!parsed) return err("ERR Invalid stream ID specified as stream command argument");
+    if (parsed.ms === 0n && parsed.seq === 0n) {
+      return err("ERR The ID specified in XADD must be greater than 0-0");
+    }
+    const top = stream.entries[stream.entries.length - 1];
+    if (top && cmpId(requested, top.id) <= 0) {
+      return err("ERR The ID specified in XADD is equal or smaller than the target stream top item");
+    }
+    if (parsed.ms > stream.lastMs || parsed.ms === stream.lastMs && parsed.seq > stream.lastSeq) {
+      stream.lastMs = parsed.ms;
+      stream.lastSeq = parsed.seq;
+    }
+    return `${parsed.ms}-${parsed.seq}`;
+  }
+  cmdXrange(session, command, args) {
+    if (args.length < 3) return arityError(command);
+    const stream = this.stream(session, text(args[0]), false);
+    if (stream === null) return arr([]);
+    if (!("entries" in stream)) return stream;
+    const start = text(args[1]);
+    const end = text(args[2]);
+    let count = Infinity;
+    if (upper(args[3]) === "COUNT") {
+      const parsed = parseI64(args[4] ?? utf8(""));
+      if (parsed === null) return syntaxError();
+      count = Number(parsed);
+    }
+    let entries = stream.entries.filter((entry) => {
+      const afterStart = start === "-" || cmpId(entry.id, start) >= 0;
+      const beforeEnd = end === "+" || cmpId(entry.id, end) <= 0;
+      return afterStart && beforeEnd;
+    });
+    if (command === "xrevrange") entries = entries.slice().reverse();
+    return arr(entries.slice(0, count).map((entry) => entryFields(entry)));
+  }
+  cmdXdel(session, args, apply) {
+    if (args.length < 2) return arityError("xdel");
+    const stream = this.stream(session, text(args[0]), false);
+    if (stream === null) return int(0);
+    if (!("entries" in stream)) return stream;
+    if (!apply) return queued();
+    const ids = new Set(args.slice(1).map((arg) => text(arg)));
+    const before = stream.entries.length;
+    stream.entries = stream.entries.filter((entry) => !ids.has(entry.id));
+    return int(before - stream.entries.length);
+  }
+  cmdXtrim(session, args, apply) {
+    if (args.length < 3) return arityError("xtrim");
+    const stream = this.stream(session, text(args[0]), false);
+    if (stream === null) return int(0);
+    if (!("entries" in stream)) return stream;
+    let index = 1;
+    const strategy = upper(args[index]);
+    if (strategy !== "MAXLEN" && strategy !== "MINID") return syntaxError();
+    index++;
+    if (upper(args[index]) === "~" || upper(args[index]) === "=") index++;
+    if (!apply) return queued();
+    const before = stream.entries.length;
+    if (strategy === "MAXLEN") {
+      const length = parseI64(args[index] ?? utf8(""));
+      if (length === null) return syntaxError();
+      if (stream.entries.length > Number(length)) {
+        stream.entries.splice(0, stream.entries.length - Number(length));
+      }
+    }
+    return int(before - stream.entries.length);
+  }
+  cmdXgroup(session, args, apply) {
+    const sub = upper(args[0]);
+    if (sub === "CREATE") {
+      if (args.length < 4) return arityError("xgroup");
+      const key = text(args[1]);
+      const group = text(args[2]);
+      const id = text(args[3]);
+      const mk = args.some((arg) => upper(arg) === "MKSTREAM");
+      let stream = this.stream(session, key, false);
+      if (stream === null) {
+        if (!mk) {
+          return err(
+            "ERR The XGROUP subcommand requires the key to exist. Note that for CREATE you may want to use the MKSTREAM option to create an empty stream automatically."
+          );
+        }
+        if (!apply) return queued();
+        stream = this.stream(session, key, true);
+      }
+      if (!stream || !("groups" in stream)) return stream ?? wrongType();
+      if (stream.groups.has(group)) return err("BUSYGROUP Consumer Group name already exists");
+      if (!apply) return queued();
+      const last = stream.entries[stream.entries.length - 1];
+      const lastId = id === "$" ? last?.id ?? "0-0" : id === "0" ? "0-0" : id;
+      if (lastId !== "0-0" && !parseStreamId(lastId)) {
+        return err("ERR Invalid stream ID specified as stream command argument");
+      }
+      stream.groups.set(group, { name: group, lastId, consumers: /* @__PURE__ */ new Map(), pel: /* @__PURE__ */ new Map() });
+      return ok();
+    }
+    if (sub === "DESTROY") {
+      if (args.length !== 3) return arityError("xgroup");
+      const stream = this.stream(session, text(args[1]), false);
+      if (!stream || !("groups" in stream)) return int(0);
+      if (!apply) return queued();
+      return int(stream.groups.delete(text(args[2])) ? 1 : 0);
+    }
+    if (sub === "CREATECONSUMER") {
+      if (args.length !== 4) return arityError("xgroup");
+      const stream = this.stream(session, text(args[1]), false);
+      if (!stream || !("groups" in stream))
+        return err("ERR The XGROUP subcommand requires the key to exist");
+      const group = stream.groups.get(text(args[2]));
+      if (!group) return err("NOGROUP No such consumer group");
+      if (!apply) return queued();
+      const name = text(args[3]);
+      const created = !group.consumers.has(name);
+      group.consumers.set(name, { seenAt: this.clock.now() });
+      return int(created ? 1 : 0);
+    }
+    if (sub === "DELCONSUMER") {
+      if (args.length !== 4) return arityError("xgroup");
+      const stream = this.stream(session, text(args[1]), false);
+      if (!stream || !("groups" in stream)) return int(0);
+      const group = stream.groups.get(text(args[2]));
+      if (!group) return int(0);
+      if (!apply) return queued();
+      const name = text(args[3]);
+      let pending = 0;
+      for (const [id, item] of group.pel) {
+        if (item.consumer !== name) continue;
+        group.pel.delete(id);
+        pending++;
+      }
+      group.consumers.delete(name);
+      return int(pending);
+    }
+    if (sub === "SETID") {
+      if (args.length < 4) return arityError("xgroup");
+      const stream = this.stream(session, text(args[1]), false);
+      if (!stream || !("groups" in stream))
+        return err("ERR The XGROUP subcommand requires the key to exist");
+      const group = stream.groups.get(text(args[2]));
+      if (!group) return err("NOGROUP No such consumer group");
+      if (!apply) return queued();
+      const id = text(args[3]);
+      group.lastId = id === "$" ? stream.entries[stream.entries.length - 1]?.id ?? "0-0" : id;
+      return ok();
+    }
+    return err(`ERR unknown subcommand '${text(args[0]).toLowerCase()}'. Try XGROUP HELP.`);
+  }
+  cmdXread(session, args, apply, group) {
+    let index = 0;
+    let groupName = "";
+    let consumer = "";
+    let count = Infinity;
+    let block = null;
+    let noack = false;
+    if (group) {
+      if (upper(args[0]) !== "GROUP") return syntaxError();
+      groupName = text(args[1]);
+      consumer = text(args[2]);
+      index = 3;
+    }
+    while (index < args.length && upper(args[index]) !== "STREAMS") {
+      const option = upper(args[index]);
+      if (option === "COUNT") {
+        const parsed = parseI64(args[++index] ?? utf8(""));
+        if (parsed === null || parsed < 0n) return syntaxError();
+        count = Number(parsed);
+      } else if (option === "BLOCK") {
+        const parsed = parseI64(args[++index] ?? utf8(""));
+        if (parsed === null || parsed < 0n) return syntaxError();
+        block = Number(parsed);
+      } else if (option === "NOACK") noack = true;
+      else return syntaxError();
+      index++;
+    }
+    if (upper(args[index]) !== "STREAMS") return syntaxError();
+    const rest = args.slice(index + 1);
+    if (rest.length < 2 || rest.length % 2 !== 0) return syntaxError();
+    const half = rest.length / 2;
+    const keys = rest.slice(0, half).map((arg) => text(arg));
+    const ids = rest.slice(half).map((arg) => text(arg));
+    if (!apply) return queued();
+    for (const key of keys) {
+      const value = this.database(session.db).get(key);
+      if (value && value.kind !== "stream") return wrongType();
+    }
+    const read = this.readStreams(session, keys, ids, count, group, groupName, consumer, noack);
+    if (read.t === "error") return read;
+    if (!(this.consumersPaused && block !== null) && read.t === "array" && read.v && read.v.length > 0) {
+      return read;
+    }
+    if (block === null || session.inExec) return nilArray();
+    if (this.scriptDepth > 0) return scriptDenied();
+    const streamIds = ids.map((id, idIndex) => {
+      if (id !== "$") return id;
+      const existing = this.stream(session, keys[idIndex] ?? "", false);
+      if (existing && "entries" in existing) return existing.entries.at(-1)?.id ?? "0-0";
+      return "0-0";
+    });
+    return this.block({
+      kind: "stream",
+      keys,
+      db: session.db,
+      side: "left",
+      count,
+      streamIds,
+      ...group ? { group: groupName, consumer, ...noack ? { noack: true } : {} } : {},
+      ...block > 0 ? { deadline: this.clock.now() + block } : {},
+      session
+    });
+  }
+  readStreams(session, keys, ids, count, grouped, groupName, consumer, noack) {
+    const rows = [];
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i] ?? "";
+      const id = ids[i] ?? "0-0";
+      const stream = this.stream(session, key, false);
+      if (stream === null) continue;
+      if (!("entries" in stream)) return stream;
+      let chosen = [];
+      if (!grouped) {
+        chosen = stream.entries.filter((entry) => id === "$" ? false : cmpId(entry.id, id) > 0).slice(0, count);
+      } else {
+        const group = stream.groups.get(groupName);
+        if (!group) return err("NOGROUP No such key or consumer group");
+        if (id === ">") {
+          chosen = stream.entries.filter((entry) => cmpId(entry.id, group.lastId) > 0).slice(0, count);
+          for (const entry of chosen) {
+            group.lastId = entry.id;
+            if (!noack) {
+              const pending = group.pel.get(entry.id);
+              group.pel.set(entry.id, {
+                id: entry.id,
+                consumer,
+                deliveries: (pending?.deliveries ?? 0) + 1,
+                deliveredAt: this.clock.now()
+              });
+            }
+            group.consumers.set(consumer, { seenAt: this.clock.now() });
+          }
+        } else {
+          chosen = [...group.pel.values()].filter((item) => item.consumer === consumer && cmpId(item.id, id) > 0).map((item) => stream.entries.find((entry) => entry.id === item.id)).filter((entry) => entry !== void 0).slice(0, count);
+        }
+      }
+      if (chosen.length > 0)
+        rows.push(arr([bulk(key), arr(chosen.map((entry) => entryFields(entry)))]));
+    }
+    return rows.length > 0 ? arr(rows) : nilArray();
+  }
+  cmdXack(session, args, apply) {
+    if (args.length < 3) return arityError("xack");
+    const stream = this.stream(session, text(args[0]), false);
+    if (stream === null) return int(0);
+    if (!("groups" in stream)) return stream;
+    const group = stream.groups.get(text(args[1]));
+    if (!group) return int(0);
+    if (!apply) return queued();
+    let acked = 0;
+    for (const id of args.slice(2).map((arg) => text(arg))) {
+      if (group.pel.delete(id)) acked++;
+    }
+    return int(acked);
+  }
+  cmdXpending(session, args) {
+    if (args.length < 2) return arityError("xpending");
+    const stream = this.stream(session, text(args[0]), false);
+    if (stream === null) return err("ERR no such key");
+    if (!("groups" in stream)) return stream;
+    const group = stream.groups.get(text(args[1]));
+    if (!group) return err("NOGROUP No such consumer group");
+    if (args.length === 2) {
+      if (group.pel.size === 0) return arr([int(0), nil(), nil(), arr([])]);
+      const ids = [...group.pel.keys()].sort(cmpId);
+      const counts = /* @__PURE__ */ new Map();
+      for (const item of group.pel.values())
+        counts.set(item.consumer, (counts.get(item.consumer) ?? 0) + 1);
+      return arr([
+        int(group.pel.size),
+        bulk(ids[0] ?? ""),
+        bulk(ids[ids.length - 1] ?? ""),
+        arr([...counts].map(([name, count2]) => arr([bulk(name), bulk(String(count2))])))
+      ]);
+    }
+    const start = text(args[2]);
+    const end = text(args[3]);
+    const count = parseI64(args[4] ?? utf8(""));
+    if (count === null) return syntaxError();
+    const consumer = args[5] ? text(args[5]) : null;
+    const rows = [...group.pel.values()].filter(
+      (item) => (start === "-" || cmpId(item.id, start) >= 0) && (end === "+" || cmpId(item.id, end) <= 0)
+    ).filter((item) => consumer === null || item.consumer === consumer).sort((a, b) => cmpId(a.id, b.id)).slice(0, Number(count));
+    return arr(
+      rows.map(
+        (item) => arr([
+          bulk(item.id),
+          bulk(item.consumer),
+          int(Math.max(0, this.clock.now() - item.deliveredAt)),
+          int(item.deliveries)
+        ])
+      )
+    );
+  }
+  cmdXclaim(session, args, apply, auto) {
+    const minIdleIndex = auto ? 3 : 3;
+    if (args.length < (auto ? 5 : 5)) return arityError(auto ? "xautoclaim" : "xclaim");
+    const stream = this.stream(session, text(args[0]), false);
+    if (!stream || !("groups" in stream)) return auto ? nilArray() : arr([]);
+    const group = stream.groups.get(text(args[1]));
+    if (!group) return err("NOGROUP No such consumer group");
+    const consumer = text(args[2]);
+    const minIdle = Number(text(args[minIdleIndex]));
+    if (!Number.isFinite(minIdle) || minIdle < 0) return syntaxError();
+    if (!apply) return queued();
+    let count = auto ? 100 : Infinity;
+    let justId = false;
+    const ids = [];
+    if (auto) {
+      const start = text(args[4]);
+      for (let i = 5; i < args.length; i++) {
+        if (upper(args[i]) === "COUNT") {
+          const parsed = parseI64(args[++i] ?? utf8(""));
+          if (parsed === null) return syntaxError();
+          count = Number(parsed);
+        } else if (upper(args[i]) === "JUSTID") justId = true;
+      }
+      const claimed2 = [];
+      const deleted = [];
+      let finished = true;
+      for (const id of [...group.pel.keys()].sort(cmpId)) {
+        if (cmpId(id, start) <= 0) continue;
+        if (claimed2.length >= count) {
+          finished = false;
+          break;
+        }
+        const item = group.pel.get(id);
+        if (!item) continue;
+        const entry = stream.entries.find((candidate) => candidate.id === id);
+        if (!entry) {
+          group.pel.delete(id);
+          deleted.push(id);
+          continue;
+        }
+        if (this.clock.now() - item.deliveredAt < minIdle) continue;
+        item.consumer = consumer;
+        item.deliveries++;
+        item.deliveredAt = this.clock.now();
+        group.consumers.set(consumer, { seenAt: this.clock.now() });
+        claimed2.push(entry);
+      }
+      return arr([
+        bulk(finished ? "0-0" : claimed2[claimed2.length - 1]?.id ?? "0-0"),
+        arr(claimed2.map((entry) => justId ? bulk(entry.id) : entryFields(entry))),
+        arr(deleted.map((id) => bulk(id)))
+      ]);
+    }
+    for (let i = 4; i < args.length; i++) {
+      const option = upper(args[i]);
+      if (option === "IDLE" || option === "TIME" || option === "RETRYCOUNT") i++;
+      else if (option === "FORCE" || option === "JUSTID") {
+        if (option === "JUSTID") justId = true;
+      } else ids.push(text(args[i]));
+    }
+    const claimed = [];
+    for (const id of ids) {
+      const item = group.pel.get(id);
+      const entry = stream.entries.find((candidate) => candidate.id === id);
+      if (!item || !entry) continue;
+      if (this.clock.now() - item.deliveredAt < minIdle) continue;
+      item.consumer = consumer;
+      item.deliveries++;
+      item.deliveredAt = this.clock.now();
+      claimed.push(entry);
+    }
+    group.consumers.set(consumer, { seenAt: this.clock.now() });
+    return arr(claimed.map((entry) => justId ? bulk(entry.id) : entryFields(entry)));
+  }
+  cmdXinfo(session, args) {
+    const sub = upper(args[0]);
+    if (sub === "STREAM") {
+      const stream = this.stream(session, text(args[1]), false);
+      if (!stream || !("entries" in stream)) return err("ERR no such key");
+      const first2 = stream.entries[0];
+      const last = stream.entries[stream.entries.length - 1];
+      return arr([
+        bulk("length"),
+        int(stream.entries.length),
+        bulk("radix-tree-keys"),
+        int(0),
+        bulk("radix-tree-nodes"),
+        int(0),
+        bulk("last-generated-id"),
+        bulk(last?.id ?? "0-0"),
+        bulk("groups"),
+        int(stream.groups.size),
+        bulk("first-entry"),
+        first2 ? entryFields(first2) : nil(),
+        bulk("last-entry"),
+        last ? entryFields(last) : nil()
+      ]);
+    }
+    if (sub === "GROUPS") {
+      const stream = this.stream(session, text(args[1]), false);
+      if (!stream || !("groups" in stream)) return err("ERR no such key");
+      return arr(
+        [...stream.groups.values()].map(
+          (group) => arr([
+            bulk("name"),
+            bulk(group.name),
+            bulk("consumers"),
+            int(group.consumers.size),
+            bulk("pending"),
+            int(group.pel.size),
+            bulk("last-delivered-id"),
+            bulk(group.lastId)
+          ])
+        )
+      );
+    }
+    if (sub === "CONSUMERS") {
+      const stream = this.stream(session, text(args[1]), false);
+      if (!stream || !("groups" in stream)) return err("ERR no such key");
+      const group = stream.groups.get(text(args[2]));
+      if (!group) return err("NOGROUP No such consumer group");
+      return arr(
+        [...group.consumers].map(([name, info]) => {
+          let pending = 0;
+          for (const item of group.pel.values()) if (item.consumer === name) pending++;
+          return arr([
+            bulk("name"),
+            bulk(name),
+            bulk("pending"),
+            int(pending),
+            bulk("idle"),
+            int(Math.max(0, this.clock.now() - info.seenAt))
+          ]);
+        })
+      );
+    }
+    return syntaxError();
+  }
+  cmdSub(session, command, args) {
+    const pattern = command.startsWith("p");
+    const leaving = command.includes("unsubscribe");
+    const names = args.map((arg) => text(arg));
+    if (!leaving && names.length === 0) return arityError(command);
+    const targets = names.length > 0 ? names : [...pattern ? session.patterns : session.channels];
+    if (targets.length === 0) {
+      return push([bulk(command), nil(), int(session.channels.size + session.patterns.size)]);
+    }
+    let last = ok();
+    targets.forEach((name, index) => {
+      if (leaving) {
+        if (pattern) {
+          session.patterns.delete(name);
+          this.patternSubs.get(name)?.delete(session);
+        } else {
+          session.channels.delete(name);
+          this.channelSubs.get(name)?.delete(session);
+        }
+      } else if (pattern) {
+        session.patterns.add(name);
+        const set = this.patternSubs.get(name) ?? /* @__PURE__ */ new Set();
+        set.add(session);
+        this.patternSubs.set(name, set);
+      } else {
+        session.channels.add(name);
+        const set = this.channelSubs.get(name) ?? /* @__PURE__ */ new Set();
+        set.add(session);
+        this.channelSubs.set(name, set);
+      }
+      const reply = push([
+        bulk(command),
+        bulk(name),
+        int(session.channels.size + session.patterns.size)
+      ]);
+      if (index < targets.length - 1) session.onPush(reply);
+      else last = reply;
+    });
+    return last;
+  }
+  cmdPublish(args) {
+    if (args.length !== 2) return arityError("publish");
+    const channel = text(args[0]);
+    const message = args[1] ?? utf8("");
+    let delivered = 0;
+    for (const session of this.channelSubs.get(channel) ?? []) {
+      session.onPush(push([bulk("message"), bulk(channel), { t: "bulk", v: message }]));
+      delivered++;
+    }
+    for (const [pattern, sessions] of this.patternSubs) {
+      if (!globMatch(pattern, channel)) continue;
+      for (const session of sessions) {
+        session.onPush(
+          push([bulk("pmessage"), bulk(pattern), bulk(channel), { t: "bulk", v: message }])
+        );
+        delivered++;
+      }
+    }
+    return int(delivered);
+  }
+  cmdPubsub(args) {
+    const sub = upper(args[0]);
+    if (sub === "NUMSUB") {
+      const rows = [];
+      for (const arg of args.slice(1)) {
+        rows.push(bulk(text(arg)), int(this.channelSubs.get(text(arg))?.size ?? 0));
+      }
+      return arr(rows);
+    }
+    if (sub === "CHANNELS") {
+      const pattern = args[1] ? text(args[1]) : "*";
+      return arr(
+        [...this.channelSubs.keys()].filter((channel) => globMatch(pattern, channel)).map((channel) => bulk(channel))
+      );
+    }
+    if (sub === "NUMPAT") return int(this.patternSubs.size);
+    return arityError("pubsub");
+  }
+  cmdExec(session) {
+    if (!session.multi) return execWithoutMulti();
+    const queuedCommands = session.multi;
+    const failed = session.multiFailed;
+    const watching = session.watching;
+    session.multi = null;
+    session.multiFailed = false;
+    session.watching = [];
+    if (failed) return execAbort();
+    for (const watch of watching) {
+      if (this.database(watch.db).generation(watch.key) !== watch.gen) return nilArray();
+    }
+    const replies = [];
+    session.inExec = true;
+    try {
+      for (const command of queuedCommands) {
+        const reply = this.execCmd(session, command.name, command.args, true);
+        replies.push(reply instanceof Promise ? nilArray() : reply);
+      }
+    } finally {
+      session.inExec = false;
+    }
+    return arr(replies);
+  }
+  cmdDiscard(session) {
+    if (!session.multi) return discardWithoutMulti();
+    session.multi = null;
+    session.multiFailed = false;
+    session.watching = [];
+    return ok();
+  }
+  cmdWatch(session, args) {
+    if (args.length < 1) return arityError("watch");
+    if (session.multi) return err("ERR WATCH inside MULTI is not allowed");
+    for (const arg of args) {
+      const key = text(arg);
+      session.watching.push({ db: session.db, key, gen: this.database(session.db).generation(key) });
+    }
+    return ok();
+  }
+  cmdEval(session, command, args, apply) {
+    if (args.length < 2) return arityError(command);
+    const source = command === "eval" ? text(args[0]) : this.scripts.get(text(args[0]).toLowerCase());
+    if (command === "evalsha" && source === void 0) return noScript();
+    const numkeys = parseI64(args[1] ?? utf8(""));
+    if (numkeys === null) return notInteger();
+    if (numkeys < 0n) return err("ERR Number of keys can't be negative");
+    if (args.length < 2 + Number(numkeys)) {
+      return err("ERR Number of keys can't be greater than number of args");
+    }
+    if (!apply || source === void 0) return queued();
+    const keys = args.slice(2, 2 + Number(numkeys));
+    const argv = args.slice(2 + Number(numkeys));
+    return this.runScript(session, source, keys, argv);
+  }
+  cmdScript(args, apply) {
+    const sub = upper(args[0]);
+    if (sub === "LOAD") {
+      if (args.length !== 2) return arityError("script|load");
+      if (!apply) return queued();
+      const source = text(args[1]);
+      const digest = sha1Hex(utf8(source));
+      this.scripts.set(digest, source);
+      return bulk(digest);
+    }
+    if (sub === "EXISTS") {
+      return arr(args.slice(1).map((arg) => int(this.scripts.has(text(arg).toLowerCase()) ? 1 : 0)));
+    }
+    if (sub === "FLUSH") {
+      if (!apply) return queued();
+      this.scripts.clear();
+      return ok();
+    }
+    if (sub === "KILL") {
+      if (this.faultValue !== "busy" && this.scriptDepth === 0) return notBusy();
+      if (this.faultValue === "busy") this.faultValue = null;
+      return ok();
+    }
+    return arityError("script");
+  }
+  runScript(session, source, keys, argv) {
+    const host = {
+      call: (callArgs) => this.luaDispatch(session, callArgs, false),
+      pcall: (callArgs) => this.luaDispatch(session, callArgs, true)
+    };
+    const env = luaGlobals(host);
+    const keyTable = env.get("redis");
+    const keysTable = new LuaTable();
+    const argvTable = new LuaTable();
+    keys.forEach((key, index) => {
+      keysTable.set(index + 1, latin1(key));
+    });
+    argv.forEach((arg, index) => {
+      argvTable.set(index + 1, latin1(arg));
+    });
+    env.define("KEYS", keysTable);
+    env.define("ARGV", argvTable);
+    if (keyTable instanceof LuaTable) keyTable.set("pcall", host.pcall);
+    this.scriptDepth++;
+    try {
+      const values = runLua(source, env);
+      return luaToReply(values[0] ?? null);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return err(`ERR Error running script: ${message}`);
+    } finally {
+      this.scriptDepth--;
+    }
+  }
+  luaDispatch(session, args, trap) {
+    const name = typeof args[0] === "string" ? args[0].toLowerCase() : "";
+    const bytes = args.slice(1).map((arg) => luaToBytes(arg));
+    try {
+      const reply = this.execCmd(session, name, bytes, true);
+      if (reply instanceof Promise)
+        throw new Error("This Redis command is not allowed from scripts");
+      if (reply.t === "error") {
+        if (!trap) throw new Error(reply.v);
+        const table = new LuaTable();
+        table.set("err", reply.v);
+        return [table];
+      }
+      return [replyToLua(reply)];
+    } catch (error) {
+      if (!trap) throw error;
+      const table = new LuaTable();
+      table.set("err", error instanceof Error ? error.message : String(error));
+      return [table];
+    }
+  }
+  block(spec) {
+    return new Promise((resolve, reject) => {
+      const waiter = {
+        kind: spec.kind,
+        keys: spec.keys,
+        db: spec.db,
+        side: spec.side,
+        count: spec.count,
+        settled: false,
+        resolve,
+        reject,
+        ...spec.deadline !== void 0 ? { deadline: spec.deadline } : {},
+        ...spec.group !== void 0 ? { group: spec.group } : {},
+        ...spec.consumer !== void 0 ? { consumer: spec.consumer } : {},
+        ...spec.streamIds !== void 0 ? { streamIds: spec.streamIds } : {},
+        ...spec.noack ? { noack: true } : {},
+        ...spec.max ? { max: true } : {},
+        ...spec.destKey !== void 0 ? { destKey: spec.destKey } : {},
+        ...spec.destSide !== void 0 ? { destSide: spec.destSide } : {}
+      };
+      waiterSession.set(waiter, spec.session);
+      this.waiters.push(waiter);
+      if (spec.deadline !== void 0) {
+        const deadline = spec.deadline;
+        const fire = () => {
+          if (this.clock.now() < deadline) return;
+          this.enqueue(() => this.finishWaiter(waiter, nilArray()));
+        };
+        waiter.unsub = this.clock.subscribe(fire);
+        if (!this.clock.manual) {
+          waiter.timer = setTimeout(fire, Math.max(0, deadline - this.clock.now()));
+        }
+      }
+    });
+  }
+  wake(dbIndex, key) {
+    for (const waiter of [...this.waiters]) {
+      if (waiter.settled || waiter.db !== dbIndex || !waiter.keys.includes(key)) continue;
+      const reply = this.satisfy(waiter);
+      if (reply) this.finishWaiter(waiter, reply);
+    }
+  }
+  wakeAll() {
+    for (const waiter of [...this.waiters]) {
+      const reply = this.satisfy(waiter);
+      if (reply) this.finishWaiter(waiter, reply);
+    }
+  }
+  satisfy(waiter) {
+    const session = waiterSession.get(waiter);
+    if (!session || session.dead) return nilArray();
+    if (this.consumersPaused) return null;
+    if (waiter.kind === "list") return this.takeList(waiter.db, waiter.keys, waiter.side);
+    if (waiter.kind === "zset") return this.takeZset(waiter.db, waiter.keys, waiter.max === true);
+    const reply = this.readStreams(
+      session,
+      waiter.keys,
+      waiter.streamIds ?? waiter.keys.map(() => ">"),
+      waiter.count,
+      waiter.group !== void 0,
+      waiter.group ?? "",
+      waiter.consumer ?? "",
+      waiter.noack === true
+    );
+    if (reply.t === "array" && reply.v && reply.v.length > 0) return reply;
+    if (reply.t === "error") return reply;
+    return null;
+  }
+  finishWaiter(waiter, reply) {
+    if (waiter.settled) return;
+    waiter.settled = true;
+    waiter.unsub?.();
+    if (waiter.timer !== void 0) clearTimeout(waiter.timer);
+    this.waiters = this.waiters.filter((item) => item !== waiter);
+    waiterSession.delete(waiter);
+    waiter.resolve(reply);
+  }
+  failWaiter(waiter, error) {
+    if (waiter.settled) return;
+    waiter.settled = true;
+    waiter.unsub?.();
+    if (waiter.timer !== void 0) clearTimeout(waiter.timer);
+    this.waiters = this.waiters.filter((item) => item !== waiter);
+    waiterSession.delete(waiter);
+    waiter.reject(error);
+  }
+  leavePubsub(session) {
+    for (const channel of session.channels) this.channelSubs.get(channel)?.delete(session);
+    for (const pattern of session.patterns) this.patternSubs.get(pattern)?.delete(session);
+    session.channels.clear();
+    session.patterns.clear();
+  }
+};
+var waiterSession = /* @__PURE__ */ new WeakMap();
+function concatBytes(left, right) {
+  const out = new Uint8Array(left.length + right.length);
+  out.set(left);
+  out.set(right, left.length);
+  return out;
+}
+function compareBytes(left, right) {
+  const length = Math.min(left.length, right.length);
+  for (let i = 0; i < length; i++) {
+    const diff = (left[i] ?? 0) - (right[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return left.length - right.length;
+}
+function indexes(length, startRaw, endRaw) {
+  let start = Number(text(startRaw));
+  let end = Number(text(endRaw));
+  if (!Number.isInteger(start)) start = 0;
+  if (!Number.isInteger(end)) end = -1;
+  if (start < 0) start = length + start;
+  if (end < 0) end = length + end;
+  if (start < 0) start = 0;
+  if (end >= length) end = length - 1;
+  return [start, end];
+}
+function listIndex(length, raw) {
+  const parsed = parseI64(raw ?? utf8(""));
+  if (parsed === null) return null;
+  let index = Number(parsed);
+  if (index < 0) index = length + index;
+  if (index < 0 || index >= length) return null;
+  return index;
+}
+function parseBound(value) {
+  if (value === "+inf" || value === "inf") return { value: Infinity, exclusive: false };
+  if (value === "-inf") return { value: -Infinity, exclusive: false };
+  let exclusive = false;
+  let textValue = value;
+  if (textValue.startsWith("(")) {
+    exclusive = true;
+    textValue = textValue.slice(1);
+  }
+  const score = parseScore(utf8(textValue));
+  if (score === null) return null;
+  return { value: score, exclusive };
+}
+function inBound(score, min, max) {
+  if (min.exclusive ? score <= min.value : score < min.value) return false;
+  if (max.exclusive ? score >= max.value : score > max.value) return false;
+  return true;
+}
+function toArg(value) {
+  if (typeof value === "number") return utf8(String(value));
+  if (typeof value === "string") return utf8(value);
+  return value;
+}
+var RedisClient = class {
+  constructor(redis, session) {
+    this.redis = redis;
+    this.session = session;
+  }
+  redis;
+  session;
+  get protocol() {
+    return this.session.protocol;
+  }
+  onPush(listener) {
+    const previous = this.session.onPush;
+    this.session.onPush = (reply) => {
+      previous(reply);
+      listener(reply);
+    };
+  }
+  call(command, ...args) {
+    return this.raw(command, ...args).then((reply) => decodeReply(reply));
+  }
+  raw(command, ...args) {
+    return this.redis.perform(
+      this.session,
+      command,
+      args.map((arg) => toArg(arg))
+    );
+  }
+  pipeline() {
+    return new RedisPipeline(this);
+  }
+  async quit() {
+    const reply = await this.call("QUIT");
+    this.session.dead = true;
+    return String(reply);
+  }
+};
+var RedisPipeline = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  commands = [];
+  call(name, ...args) {
+    this.commands.push({ name, args });
+    return this;
+  }
+  async exec() {
+    const out = [];
+    for (const command of this.commands) {
+      try {
+        out.push(await this.client.call(command.name, ...command.args));
+      } catch (error) {
+        out.push(error);
+      }
+    }
+    return out;
+  }
+};
+function createRedis(options) {
+  return new Redis(options ?? {});
+}
+
+export {
+  manualClock,
+  wallClock,
+  encodeReply,
+  RespParser,
+  asCommand,
+  RedisConnectionError,
+  RedisReplyError,
+  Redis,
+  RedisClient,
+  RedisPipeline,
+  createRedis
+};
+//# sourceMappingURL=chunk-4HDEOTYJ.js.map