bundis 0.1.0

package/src/commands/handshake.ts

@@ -0,0 +1,147 @@
+/**
+ * Handshake / connection commands (§2.2).
+ *
+ * These must be answered before (or alongside) data commands or the stock client
+ * stalls during connect: HELLO, AUTH, SELECT, PING, INFO, QUIT, CLIENT, ECHO.
+ */
+
+import { R, type Reply } from "../resp/types";
+import { Errors } from "../engine/errors";
+import type { CommandContext } from "../engine/context";
+
+/** HELLO [protover [AUTH user pass] [SETNAME name]] → RESP3 server-info map. */
+export function hello(ctx: CommandContext): Reply {
+  let i = 0;
+  if (ctx.argOpt(i) !== undefined && /^\d+$/.test(ctx.str(i))) {
+    const proto = parseInt(ctx.str(i), 10);
+    if (proto !== 2 && proto !== 3) {
+      return R.error("NOPROTO", "unsupported protocol version");
+    }
+    ctx.conn.proto = proto;
+    i++;
+  }
+  // Optional AUTH / SETNAME sub-options.
+  while (ctx.argOpt(i) !== undefined) {
+    const opt = ctx.upper(i);
+    if (opt === "AUTH") {
+      const pass = ctx.str(i + 2); // user is ctx.str(i+1), ignored (single user)
+      if (!authenticate(ctx, pass)) return R.error(...wrongPass());
+      ctx.conn.authed = true;
+      i += 3;
+    } else if (opt === "SETNAME") {
+      ctx.conn.name = ctx.str(i + 1);
+      i += 2;
+    } else {
+      throw Errors.syntax();
+    }
+  }
+  if (requiresAuth(ctx) && !ctx.conn.authed) return R.error(...noAuth());
+  ctx.conn.state = "READY";
+  return helloMap(ctx);
+}
+
+/** AUTH [user] pass */
+export function auth(ctx: CommandContext): Reply {
+  ctx.requireArgc(1);
+  const pass = ctx.argc >= 2 ? ctx.str(1) : ctx.str(0);
+  if (ctx.server.config.password === null) {
+    // No password configured: Redis errors, but we stay lenient and accept.
+    ctx.conn.authed = true;
+    return R.ok();
+  }
+  if (!authenticate(ctx, pass)) throw Errors.wrongPass();
+  ctx.conn.authed = true;
+  return R.ok();
+}
+
+export function ping(ctx: CommandContext): Reply {
+  if (ctx.argc >= 1) return R.bulk(ctx.arg(0));
+  return R.simple("PONG");
+}
+
+export function select(_ctx: CommandContext): Reply {
+  // Single logical DB; accept any index for client compatibility.
+  return R.ok();
+}
+
+export function echo(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(1);
+  return R.bulk(ctx.arg(0));
+}
+
+export function quit(ctx: CommandContext): null {
+  ctx.conn.send(R.ok());
+  ctx.conn.socket.end();
+  return null; // reply already written; socket is closing
+}
+
+export function info(ctx: CommandContext): Reply {
+  const lines = [
+    "# Server",
+    "redis_version:7.4.0",
+    "redis_mode:standalone",
+    "run_id:bundis",
+    "tcp_port:" + ctx.server.config.port,
+    "",
+    "# Clients",
+    "connected_clients:1",
+    "",
+    "# Keyspace",
+    `db0:keys=${ctx.storage.dbsize(ctx.nowMs)},expires=0,avg_ttl=0`,
+    "",
+  ];
+  return R.verbatim("txt", lines.join("\r\n"));
+}
+
+/** CLIENT SETINFO/SETNAME/GETNAME/ID/... — lenient, returns sensible replies. */
+export function client(ctx: CommandContext): Reply {
+  const sub = ctx.upper(0);
+  switch (sub) {
+    case "SETNAME":
+      ctx.conn.name = ctx.argc >= 2 ? ctx.str(1) : "";
+      return R.ok();
+    case "GETNAME":
+      return R.bulk(ctx.conn.name || "");
+    case "ID":
+      return R.int(ctx.conn.id);
+    case "SETINFO":
+      return R.ok();
+    case "INFO":
+      return R.bulk(`id=${ctx.conn.id} name=${ctx.conn.name}`);
+    default:
+      return R.ok();
+  }
+}
+
+// ── helpers ──────────────────────────────────────────────────────────────---
+
+function helloMap(ctx: CommandContext): Reply {
+  return R.map([
+    [R.bulk("server"), R.bulk("bundis")],
+    [R.bulk("version"), R.bulk("0.1.0")],
+    [R.bulk("proto"), R.int(ctx.conn.proto)],
+    [R.bulk("id"), R.int(ctx.conn.id)],
+    [R.bulk("mode"), R.bulk("standalone")],
+    [R.bulk("role"), R.bulk("master")],
+    [R.bulk("modules"), R.array([])],
+  ]);
+}
+
+function authenticate(ctx: CommandContext, pass: string): boolean {
+  const expected = ctx.server.config.password;
+  return expected === null || expected === pass;
+}
+
+function requiresAuth(ctx: CommandContext): boolean {
+  return ctx.server.config.password !== null;
+}
+
+// Small adapters so we can `R.error(...wrongPass())` cleanly.
+function wrongPass(): [string, string] {
+  const e = Errors.wrongPass();
+  return [e.code, e.message];
+}
+function noAuth(): [string, string] {
+  const e = Errors.noAuth();
+  return [e.code, e.message];
+}

package/src/commands/hash.ts

@@ -0,0 +1,106 @@
+/**
+ * Hash commands (Phase 1).
+ *
+ * Type-conversion notes (§2.4): HGETALL → RESP3 Map (`%`) so the client yields an
+ * object; HEXISTS → Integer (client coerces to boolean); HINCRBYFLOAT → bulk.
+ */
+
+import { R, type Reply } from "../resp/types";
+import { Errors } from "../engine/errors";
+import type { CommandContext } from "../engine/context";
+
+export function hset(ctx: CommandContext): Reply {
+  ctx.requireArgc(3);
+  if (ctx.argc % 2 !== 1) throw Errors.wrongArgs(ctx.cmd); // key + field/value pairs
+  const key = ctx.arg(0);
+  const pairs: Array<[Uint8Array, Uint8Array]> = [];
+  for (let i = 1; i < ctx.argc; i += 2) pairs.push([ctx.arg(i), ctx.arg(i + 1)]);
+  return R.int(ctx.storage.hSet(key, pairs, ctx.nowMs));
+}
+
+/** HMSET is like HSET but returns OK. */
+export function hmset(ctx: CommandContext): Reply {
+  ctx.requireArgc(3);
+  if (ctx.argc % 2 !== 1) throw Errors.wrongArgs(ctx.cmd);
+  const key = ctx.arg(0);
+  const pairs: Array<[Uint8Array, Uint8Array]> = [];
+  for (let i = 1; i < ctx.argc; i += 2) pairs.push([ctx.arg(i), ctx.arg(i + 1)]);
+  ctx.storage.hSet(key, pairs, ctx.nowMs);
+  return R.ok();
+}
+
+export function hsetnx(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(3);
+  const key = ctx.arg(0);
+  const field = ctx.arg(1);
+  return ctx.storage.withTransaction(() => {
+    if (ctx.storage.hExists(key, field, ctx.nowMs)) return R.int(0);
+    ctx.storage.hSet(key, [[field, ctx.arg(2)]], ctx.nowMs);
+    return R.int(1);
+  });
+}
+
+export function hget(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(2);
+  return R.bulk(ctx.storage.hGet(ctx.arg(0), ctx.arg(1), ctx.nowMs));
+}
+
+export function hmget(ctx: CommandContext): Reply {
+  ctx.requireArgc(2);
+  const key = ctx.arg(0);
+  const out: Reply[] = [];
+  for (let i = 1; i < ctx.argc; i++) {
+    out.push(R.bulk(ctx.storage.hGet(key, ctx.arg(i), ctx.nowMs)));
+  }
+  return R.array(out);
+}
+
+export function hgetall(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(1);
+  const entries = ctx.storage.hGetAll(ctx.arg(0), ctx.nowMs);
+  return R.map(entries.map(([f, v]) => [R.bulk(f), R.bulk(v)] as const));
+}
+
+export function hdel(ctx: CommandContext): Reply {
+  ctx.requireArgc(2);
+  return R.int(ctx.storage.hDel(ctx.arg(0), ctx.args.slice(2), ctx.nowMs));
+}
+
+export function hexists(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(2);
+  return R.int(ctx.storage.hExists(ctx.arg(0), ctx.arg(1), ctx.nowMs) ? 1 : 0);
+}
+
+export function hkeys(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(1);
+  return R.array(ctx.storage.hKeys(ctx.arg(0), ctx.nowMs).map((k) => R.bulk(k)));
+}
+
+export function hvals(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(1);
+  return R.array(ctx.storage.hVals(ctx.arg(0), ctx.nowMs).map((v) => R.bulk(v)));
+}
+
+export function hlen(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(1);
+  return R.int(ctx.storage.hLen(ctx.arg(0), ctx.nowMs));
+}
+
+export function hincrby(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(3);
+  return R.int(ctx.storage.hIncrBy(ctx.arg(0), ctx.arg(1), ctx.int(2), ctx.nowMs));
+}
+
+export function hincrbyfloat(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(3);
+  const next = ctx.storage.hIncrByFloat(ctx.arg(0), ctx.arg(1), ctx.float(2), ctx.nowMs);
+  return R.bulk(formatFloat(next));
+}
+
+function formatFloat(n: number): string {
+  if (n === Infinity) return "inf";
+  if (n === -Infinity) return "-inf";
+  let s = n.toPrecision(17);
+  if (s.includes(".") && !/[eE]/.test(s)) s = s.replace(/0+$/, "").replace(/\.$/, "");
+  return Number(s).toString();
+}

package/src/commands/multikey.ts

@@ -0,0 +1,63 @@
+/**
+ * Multi-key string commands (Phase 1): MGET, MSET, MSETNX, SETEX, PSETEX, SETNX.
+ * MSET/MSETNX run inside one transaction for atomicity.
+ */
+
+import { R, type Reply } from "../resp/types";
+import { Errors } from "../engine/errors";
+import type { CommandContext } from "../engine/context";
+
+export function mget(ctx: CommandContext): Reply {
+  ctx.requireArgc(1);
+  const out: Reply[] = [];
+  for (let i = 0; i < ctx.argc; i++) {
+    out.push(R.bulk(ctx.storage.kvGet(ctx.arg(i), ctx.nowMs)));
+  }
+  return R.array(out);
+}
+
+export function mset(ctx: CommandContext): Reply {
+  ctx.requireArgc(2);
+  if (ctx.argc % 2 !== 0) throw Errors.wrongArgs(ctx.cmd);
+  ctx.storage.withTransaction(() => {
+    for (let i = 0; i < ctx.argc; i += 2) {
+      ctx.storage.kvSet(ctx.arg(i), ctx.arg(i + 1), ctx.nowMs);
+    }
+  });
+  return R.ok();
+}
+
+export function msetnx(ctx: CommandContext): Reply {
+  ctx.requireArgc(2);
+  if (ctx.argc % 2 !== 0) throw Errors.wrongArgs(ctx.cmd);
+  const ok = ctx.storage.withTransaction(() => {
+    for (let i = 0; i < ctx.argc; i += 2) {
+      if (ctx.storage.exists(ctx.arg(i), ctx.nowMs)) return false;
+    }
+    for (let i = 0; i < ctx.argc; i += 2) {
+      ctx.storage.kvSet(ctx.arg(i), ctx.arg(i + 1), ctx.nowMs);
+    }
+    return true;
+  });
+  return R.int(ok ? 1 : 0);
+}
+
+export function setex(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(3);
+  const atMs = ctx.nowMs + Number(ctx.int(1)) * 1000;
+  ctx.storage.kvSet(ctx.arg(0), ctx.arg(2), ctx.nowMs, { expireAtMs: atMs });
+  return R.ok();
+}
+
+export function psetex(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(3);
+  const atMs = ctx.nowMs + Number(ctx.int(1));
+  ctx.storage.kvSet(ctx.arg(0), ctx.arg(2), ctx.nowMs, { expireAtMs: atMs });
+  return R.ok();
+}
+
+export function setnx(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(2);
+  const res = ctx.storage.kvSet(ctx.arg(0), ctx.arg(1), ctx.nowMs, { mode: "NX" });
+  return R.int(res === "set" ? 1 : 0);
+}

package/src/commands/pubsub.ts

@@ -0,0 +1,106 @@
+/**
+ * Pub/Sub commands (Phase 2): SUBSCRIBE, UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE,
+ * PUBLISH, PUBSUB.
+ *
+ * (Un)subscribe confirmations are sent as RESP3 push frames (`>`), one per
+ * channel, matching what the stock client's subscribe()/unsubscribe() expect.
+ * These handlers write their own frames and return null (the dispatcher then
+ * writes nothing further).
+ */
+
+import { R, type Reply } from "../resp/types";
+import type { CommandContext } from "../engine/context";
+
+export function subscribe(ctx: CommandContext): null {
+  ctx.requireArgc(1);
+  for (let i = 0; i < ctx.argc; i++) {
+    const channel = ctx.str(i);
+    const count = ctx.server.hub.subscribe(ctx.conn, channel);
+    ctx.conn.state = "SUBSCRIBED";
+    ctx.conn.send(R.push([R.bulk("subscribe"), R.bulk(channel), R.int(count)]));
+  }
+  return null;
+}
+
+export function psubscribe(ctx: CommandContext): null {
+  ctx.requireArgc(1);
+  for (let i = 0; i < ctx.argc; i++) {
+    const pattern = ctx.str(i);
+    const count = ctx.server.hub.psubscribe(ctx.conn, pattern);
+    ctx.conn.state = "SUBSCRIBED";
+    ctx.conn.send(R.push([R.bulk("psubscribe"), R.bulk(pattern), R.int(count)]));
+  }
+  return null;
+}
+
+export function unsubscribe(ctx: CommandContext): null {
+  const channels =
+    ctx.argc >= 1
+      ? rangeArgs(ctx, 0)
+      : [...ctx.conn.channels];
+  if (channels.length === 0) {
+    // No channels: still send a single confirmation with null channel.
+    ctx.conn.send(
+      R.push([R.bulk("unsubscribe"), R.nullReply(), R.int(ctx.conn.subscriptionCount())]),
+    );
+    maybeExitSubscribe(ctx);
+    return null;
+  }
+  for (const channel of channels) {
+    const count = ctx.server.hub.unsubscribe(ctx.conn, channel);
+    ctx.conn.send(R.push([R.bulk("unsubscribe"), R.bulk(channel), R.int(count)]));
+  }
+  maybeExitSubscribe(ctx);
+  return null;
+}
+
+export function punsubscribe(ctx: CommandContext): null {
+  const patterns = ctx.argc >= 1 ? rangeArgs(ctx, 0) : [...ctx.conn.patterns];
+  if (patterns.length === 0) {
+    ctx.conn.send(
+      R.push([R.bulk("punsubscribe"), R.nullReply(), R.int(ctx.conn.subscriptionCount())]),
+    );
+    maybeExitSubscribe(ctx);
+    return null;
+  }
+  for (const pattern of patterns) {
+    const count = ctx.server.hub.punsubscribe(ctx.conn, pattern);
+    ctx.conn.send(R.push([R.bulk("punsubscribe"), R.bulk(pattern), R.int(count)]));
+  }
+  maybeExitSubscribe(ctx);
+  return null;
+}
+
+export function publish(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(2);
+  return R.int(ctx.server.hub.publish(ctx.str(0), ctx.arg(1)));
+}
+
+export function pubsub(ctx: CommandContext): Reply {
+  ctx.requireArgc(1);
+  const sub = ctx.upper(0);
+  switch (sub) {
+    case "CHANNELS":
+      return R.array(ctx.server.hub.channelNames().map((c) => R.bulk(c)));
+    case "NUMSUB": {
+      const out: Reply[] = [];
+      for (let i = 1; i < ctx.argc; i++) {
+        const ch = ctx.str(i);
+        out.push(R.bulk(ch), R.int(ctx.server.hub.numSub(ch)));
+      }
+      return R.array(out);
+    }
+    default:
+      return R.array([]);
+  }
+}
+
+function rangeArgs(ctx: CommandContext, from: number): string[] {
+  const out: string[] = [];
+  for (let i = from; i < ctx.argc; i++) out.push(ctx.str(i));
+  return out;
+}
+
+function maybeExitSubscribe(ctx: CommandContext): void {
+  if (!ctx.conn.inSubscribeMode()) ctx.conn.state = "READY";
+}

package/src/commands/set.ts

@@ -0,0 +1,58 @@
+/**
+ * Set commands (Phase 1).
+ *
+ * Type-conversion notes (§2.4): SMEMBERS / SPOP(count) / SRANDMEMBER(count) →
+ * RESP3 Set (`~`) so the client yields an array; SISMEMBER → Integer (client
+ * coerces to boolean).
+ */
+
+import { R, type Reply } from "../resp/types";
+import type { CommandContext } from "../engine/context";
+
+export function sadd(ctx: CommandContext): Reply {
+  ctx.requireArgc(2);
+  return R.int(ctx.storage.sAdd(ctx.arg(0), ctx.args.slice(2), ctx.nowMs));
+}
+
+export function srem(ctx: CommandContext): Reply {
+  ctx.requireArgc(2);
+  return R.int(ctx.storage.sRem(ctx.arg(0), ctx.args.slice(2), ctx.nowMs));
+}
+
+export function sismember(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(2);
+  return R.int(ctx.storage.sIsMember(ctx.arg(0), ctx.arg(1), ctx.nowMs) ? 1 : 0);
+}
+
+export function smembers(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(1);
+  return R.set(ctx.storage.sMembers(ctx.arg(0), ctx.nowMs).map((m) => R.bulk(m)));
+}
+
+export function scard(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(1);
+  return R.int(ctx.storage.sCard(ctx.arg(0), ctx.nowMs));
+}
+
+export function srandmember(ctx: CommandContext): Reply {
+  ctx.requireArgc(1);
+  const hasCount = ctx.argOpt(1) !== undefined;
+  const count = hasCount ? Number(ctx.int(1)) : null;
+  const res = ctx.storage.sRandMember(ctx.arg(0), count, ctx.nowMs);
+  if (count === null) {
+    return res === null ? R.nullReply() : R.bulk(res as Uint8Array);
+  }
+  // With a count argument, reply is an array (possibly empty), not a set.
+  return R.array((res as Uint8Array[]).map((m) => R.bulk(m)));
+}
+
+export function spop(ctx: CommandContext): Reply {
+  ctx.requireArgc(1);
+  const hasCount = ctx.argOpt(1) !== undefined;
+  const count = hasCount ? Number(ctx.int(1)) : null;
+  const res = ctx.storage.sPop(ctx.arg(0), count, ctx.nowMs);
+  if (count === null) {
+    return res === null ? R.nullReply() : R.bulk(res as Uint8Array);
+  }
+  return R.set((res as Uint8Array[]).map((m) => R.bulk(m)));
+}

package/src/commands/string.ts

@@ -0,0 +1,156 @@
+/**
+ * String / KV + numeric commands (Phase 0).
+ *
+ * SET (with EX/PX/EXAT/PXAT/NX/XX/KEEPTTL/GET), GET, GETSET, GETDEL, APPEND,
+ * STRLEN, DEL, EXISTS, INCR/DECR/INCRBY/DECRBY/INCRBYFLOAT.
+ *
+ * Type-conversion notes (§2.4): GET miss → RESP3 null; EXISTS → Integer (the
+ * stock client coerces 1/0 to boolean); INCRBYFLOAT → bulk string.
+ */
+
+import { R, type Reply } from "../resp/types";
+import { Errors } from "../engine/errors";
+import type { CommandContext } from "../engine/context";
+import type { SetOptions } from "../storage/types";
+
+export function set(ctx: CommandContext): Reply {
+  ctx.requireArgc(2);
+  const key = ctx.arg(0);
+  const value = ctx.arg(1);
+  const opts: { -readonly [K in keyof SetOptions]: SetOptions[K] } = {};
+  let wantGet = false;
+
+  let i = 2;
+  while (ctx.argOpt(i) !== undefined) {
+    const o = ctx.upper(i);
+    switch (o) {
+      case "EX":
+        opts.expireAtMs = ctx.nowMs + Number(ctx.int(i + 1)) * 1000;
+        i += 2;
+        break;
+      case "PX":
+        opts.expireAtMs = ctx.nowMs + Number(ctx.int(i + 1));
+        i += 2;
+        break;
+      case "EXAT":
+        opts.expireAtMs = Number(ctx.int(i + 1)) * 1000;
+        i += 2;
+        break;
+      case "PXAT":
+        opts.expireAtMs = Number(ctx.int(i + 1));
+        i += 2;
+        break;
+      case "NX":
+        opts.mode = "NX";
+        i += 1;
+        break;
+      case "XX":
+        opts.mode = "XX";
+        i += 1;
+        break;
+      case "KEEPTTL":
+        opts.keepTtl = true;
+        i += 1;
+        break;
+      case "GET":
+        wantGet = true;
+        i += 1;
+        break;
+      default:
+        throw Errors.syntax();
+    }
+  }
+
+  let old: Uint8Array | null = null;
+  const result = ctx.storage.withTransaction(() => {
+    if (wantGet) old = ctx.storage.kvGet(key, ctx.nowMs);
+    return ctx.storage.kvSet(key, value, ctx.nowMs, opts);
+  });
+
+  if (wantGet) return R.bulk(old);
+  return result === "set" ? R.ok() : R.nullReply();
+}
+
+export function get(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(1);
+  return R.bulk(ctx.storage.kvGet(ctx.arg(0), ctx.nowMs));
+}
+
+export function getset(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(2);
+  const key = ctx.arg(0);
+  return ctx.storage.withTransaction(() => {
+    const old = ctx.storage.kvGet(key, ctx.nowMs);
+    ctx.storage.kvSet(key, ctx.arg(1), ctx.nowMs);
+    return R.bulk(old);
+  });
+}
+
+export function getdel(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(1);
+  const key = ctx.arg(0);
+  return ctx.storage.withTransaction(() => {
+    const old = ctx.storage.kvGet(key, ctx.nowMs);
+    if (old !== null) ctx.storage.del([key], ctx.nowMs);
+    return R.bulk(old);
+  });
+}
+
+export function append(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(2);
+  return R.int(ctx.storage.append(ctx.arg(0), ctx.arg(1), ctx.nowMs));
+}
+
+export function strlen(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(1);
+  const v = ctx.storage.kvGet(ctx.arg(0), ctx.nowMs);
+  return R.int(v === null ? 0 : v.length);
+}
+
+export function del(ctx: CommandContext): Reply {
+  ctx.requireArgc(1);
+  return R.int(ctx.storage.del(ctx.args.slice(1), ctx.nowMs));
+}
+
+export function exists(ctx: CommandContext): Reply {
+  ctx.requireArgc(1);
+  let n = 0;
+  for (let i = 0; i < ctx.argc; i++) {
+    if (ctx.storage.exists(ctx.arg(i), ctx.nowMs)) n++;
+  }
+  return R.int(n);
+}
+
+export function incr(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(1);
+  return R.int(ctx.storage.incrBy(ctx.arg(0), 1n, ctx.nowMs));
+}
+
+export function decr(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(1);
+  return R.int(ctx.storage.incrBy(ctx.arg(0), -1n, ctx.nowMs));
+}
+
+export function incrby(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(2);
+  return R.int(ctx.storage.incrBy(ctx.arg(0), ctx.int(1), ctx.nowMs));
+}
+
+export function decrby(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(2);
+  return R.int(ctx.storage.incrBy(ctx.arg(0), -ctx.int(1), ctx.nowMs));
+}
+
+export function incrbyfloat(ctx: CommandContext): Reply {
+  ctx.requireExactArgc(2);
+  const next = ctx.storage.incrByFloat(ctx.arg(0), ctx.float(1), ctx.nowMs);
+  return R.bulk(formatFloat(next));
+}
+
+function formatFloat(n: number): string {
+  if (n === Infinity) return "inf";
+  if (n === -Infinity) return "-inf";
+  let s = n.toPrecision(17);
+  if (s.includes(".") && !/[eE]/.test(s)) s = s.replace(/0+$/, "").replace(/\.$/, "");
+  return Number(s).toString();
+}