resplite 1.2.20 → 1.3.0

package/README.md

@@ -126,11 +126,13 @@ const ks = await m.enableKeyspaceNotifications();
 // → { ok: true, previous: '', applied: 'KEA' }
 // If CONFIG is renamed and configCommand was not set, ok=false and error explains how to fix it.
 
-// Step 0c — Start dirty tracking (in-process, same script)
+// Start dirty tracking (in-process, same script)
+let dirtyLogging = true;
 await m.startDirtyTracker({
   onProgress: (p) => {
-    // one callback per keyspace event tracked during bulk/cutover
-    console.log(`[dirty ${p.totalEvents}] event=${p.event} key=${p.key}`);
+    if (dirtyLogging) {
+      console.log(`[dirty ${p.totalEvents}] event=${p.event} key=${p.key}`);
+    }
   },
 });
 
@@ -151,8 +153,12 @@ await m.bulk({
 const { run, dirty } = m.status();
 console.log('bulk status:', run.status, '— dirty counts:', dirty);
 
+// Stop dirty progress logs so the next prompt is visible (tracker keeps recording until stopDirtyTracker)
+dirtyLogging = false;
+
 // Step 2 — Pause for cutover:
 // stop the app that is still writing to Redis, then press Enter.
+// (readline reads from stdin, so Enter is captured even if anything else writes to stdout.)
 const rl = createInterface({ input: stdin, output: stdout });
 await rl.question('Stop app traffic to Redis, then press Enter to apply the final dirty set...');
 rl.close();
@@ -543,14 +549,14 @@ To reproduce the benchmark, run `npm run benchmark -- --template default`. Numbe
 | Category | Commands |
 |---|---|
 | **Connection** | PING, ECHO, QUIT |
-| **Strings** | GET, SET, MGET, MSET, DEL, EXISTS, INCR, DECR, INCRBY, DECRBY |
+| **Strings** | GET, SET, MGET, MSET, DEL, EXISTS, INCR, DECR, INCRBY, DECRBY, STRLEN |
 | **TTL** | EXPIRE, PEXPIRE, TTL, PTTL, PERSIST |
-| **Hashes** | HSET, HGET, HMGET, HGETALL, HDEL, HEXISTS, HINCRBY |
-| **Sets** | SADD, SREM, SMEMBERS, SISMEMBER, SCARD |
-| **Lists** | LPUSH, RPUSH, LLEN, LRANGE, LINDEX, LPOP, RPOP, BLPOP, BRPOP |
-| **Sorted sets** | ZADD, ZREM, ZCARD, ZSCORE, ZRANGE, ZREVRANGE, ZRANGEBYSCORE, ZREVRANGEBYSCORE, ZRANK, ZREVRANK |
+| **Hashes** | HSET, HGET, HMGET, HGETALL, HKEYS, HVALS, HDEL, HEXISTS, HINCRBY |
+| **Sets** | SADD, SREM, SMEMBERS, SISMEMBER, SCARD, SPOP, SRANDMEMBER |
+| **Lists** | LPUSH, RPUSH, LLEN, LRANGE, LINDEX, LPOP, RPOP, LSET, LTRIM, BLPOP, BRPOP |
+| **Sorted sets** | ZADD, ZREM, ZCARD, ZSCORE, ZRANGE, ZREVRANGE, ZRANGEBYSCORE, ZREVRANGEBYSCORE, ZRANK, ZREVRANK, ZCOUNT, ZINCRBY, ZREMRANGEBYRANK, ZREMRANGEBYSCORE |
 | **Search (FT.\*)** | FT.CREATE, FT.INFO, FT.ADD, FT.DEL, FT.SEARCH, FT.SUGADD, FT.SUGGET, FT.SUGDEL |
-| **Introspection** | TYPE, OBJECT IDLETIME, SCAN, KEYS, MONITOR |
+| **Introspection** | TYPE, OBJECT IDLETIME, SCAN, KEYS, RENAME, MONITOR |
 | **Admin** | SQLITE.INFO, CACHE.INFO, MEMORY.INFO |
 
 ### Not supported (v1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "resplite",
-  "version": "1.2.20",
+  "version": "1.3.0",
   "description": "A RESP2 server with practical Redis compatibility, backed by SQLite",
   "type": "module",
   "main": "src/index.js",

package/scripts/benchmark-redis-vs-resplite.js

@@ -293,6 +293,103 @@ async function benchDel(client, n) {
   }
 }
 
+async function benchStrlen(client, n) {
+  const key = 'bm:strlen';
+  await client.set(key, 'hello-world');
+  for (let i = 0; i < n; i++) await client.sendCommand(['STRLEN', key]);
+}
+
+async function benchHkeys(client, n) {
+  const key = 'bm:hash:keys';
+  await client.del(key);
+  await client.hSet(key, Object.fromEntries(Array.from({ length: 50 }, (_, i) => [`f${i}`, `v${i}`])));
+  for (let i = 0; i < n; i++) await client.sendCommand(['HKEYS', key]);
+}
+
+async function benchHvals(client, n) {
+  const key = 'bm:hash:vals';
+  await client.del(key);
+  await client.hSet(key, Object.fromEntries(Array.from({ length: 50 }, (_, i) => [`f${i}`, `v${i}`])));
+  for (let i = 0; i < n; i++) await client.sendCommand(['HVALS', key]);
+}
+
+async function benchLset(client, n) {
+  const key = 'bm:list:lset';
+  await client.del(key);
+  await client.rPush(key, Array.from({ length: 10 }, (_, i) => `item-${i}`));
+  for (let i = 0; i < n; i++) await client.sendCommand(['LSET', key, '5', `val-${i}`]);
+}
+
+async function benchLtrim(client, n) {
+  const key = 'bm:list:ltrim';
+  for (let i = 0; i < n; i++) {
+    await client.del(key);
+    await client.rPush(key, Array.from({ length: 20 }, (_, j) => `x${j}`));
+    await client.sendCommand(['LTRIM', key, '0', '9']);
+  }
+}
+
+async function benchRename(client, n) {
+  const a = 'bm:rename:a';
+  const b = 'bm:rename:b';
+  await client.set(a, 'v');
+  for (let i = 0; i < n; i++) {
+    await client.sendCommand(['RENAME', a, b]);
+    await client.sendCommand(['RENAME', b, a]);
+  }
+}
+
+async function benchZcount(client, n) {
+  const key = 'bm:zset:count';
+  await client.del(key);
+  await client.zAdd(key, Array.from({ length: 100 }, (_, i) => ({ score: i, value: `m${i}` })));
+  for (let i = 0; i < n; i++) await client.sendCommand(['ZCOUNT', key, '0', '99']);
+}
+
+async function benchZincrby(client, n) {
+  const key = 'bm:zset:incr';
+  await client.del(key);
+  await client.zAdd(key, { score: 0, value: 'member' });
+  for (let i = 0; i < n; i++) await client.sendCommand(['ZINCRBY', key, '1', 'member']);
+}
+
+async function benchZremrangebyrank(client, n) {
+  const key = 'bm:zset:remrank';
+  for (let i = 0; i < n; i++) {
+    await client.del(key);
+    await client.zAdd(key, Array.from({ length: 100 }, (_, j) => ({ score: j, value: `m${j}` })));
+    await client.sendCommand(['ZREMRANGEBYRANK', key, '0', '9']);
+  }
+}
+
+async function benchZremrangebyscore(client, n) {
+  const key = 'bm:zset:remscore';
+  for (let i = 0; i < n; i++) {
+    await client.del(key);
+    await client.zAdd(key, Array.from({ length: 100 }, (_, j) => ({ score: j, value: `m${j}` })));
+    await client.sendCommand(['ZREMRANGEBYSCORE', key, '0', '9']);
+  }
+}
+
+async function benchSpop(client, n) {
+  const key = 'bm:set:spop';
+  await client.del(key);
+  await client.sAdd(key, Array.from({ length: 50 }, (_, i) => `m${i}`));
+  for (let i = 0; i < n; i++) {
+    const v = await client.sendCommand(['SPOP', key]);
+    if (v === null || (Array.isArray(v) && v.length === 0)) {
+      await client.sAdd(key, Array.from({ length: 50 }, (_, j) => `m${j}`));
+    }
+  }
+}
+
+async function benchSrandmember(client, n) {
+  const key = 'bm:set:srand';
+  await client.del(key);
+  await client.sAdd(key, Array.from({ length: 50 }, (_, i) => `m${i}`));
+  for (let i = 0; i < n; i++) await client.sendCommand(['SRANDMEMBER', key]);
+}
+
 const FT_INDEX = 'bm_ft_idx';
 const FT_DOCS = 50;
 
@@ -343,6 +440,18 @@ const SUITES = [
   { name: 'ZRANK+ZREVRANK', fn: benchZrankZrevrank, iterScale: 1 },
   { name: 'ZREVRANGEBYSCORE', fn: benchZrevrangebyscore, iterScale: 1 },
   { name: 'SET+DEL', fn: benchDel, iterScale: 1 },
+  { name: 'STRLEN', fn: benchStrlen, iterScale: 1 },
+  { name: 'HKEYS(50)', fn: benchHkeys, iterScale: 1 },
+  { name: 'HVALS(50)', fn: benchHvals, iterScale: 1 },
+  { name: 'LSET', fn: benchLset, iterScale: 1 },
+  { name: 'LTRIM', fn: benchLtrim, iterScale: 1 },
+  { name: 'RENAME', fn: benchRename, iterScale: 1 },
+  { name: 'ZCOUNT', fn: benchZcount, iterScale: 1 },
+  { name: 'ZINCRBY', fn: benchZincrby, iterScale: 1 },
+  { name: 'ZREMRANGEBYRANK', fn: benchZremrangebyrank, iterScale: 1 },
+  { name: 'ZREMRANGEBYSCORE', fn: benchZremrangebyscore, iterScale: 1 },
+  { name: 'SPOP', fn: benchSpop, iterScale: 1 },
+  { name: 'SRANDMEMBER', fn: benchSrandmember, iterScale: 1 },
   { name: 'FT.SEARCH', fn: benchFtSearch, iterScale: 1 },
 ];
 

package/src/commands/hkeys.js

@@ -0,0 +1,16 @@
+/**
+ * HKEYS key - returns array of field names in the hash.
+ */
+
+export function handleHkeys(engine, args) {
+  if (!args || args.length < 1) {
+    return { error: 'ERR wrong number of arguments for \'HKEYS\' command' };
+  }
+  try {
+    const fields = engine.hkeys(args[0]);
+    return fields;
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') ? msg : msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/hvals.js

@@ -0,0 +1,16 @@
+/**
+ * HVALS key - returns array of values in the hash.
+ */
+
+export function handleHvals(engine, args) {
+  if (!args || args.length < 1) {
+    return { error: 'ERR wrong number of arguments for \'HVALS\' command' };
+  }
+  try {
+    const values = engine.hvals(args[0]);
+    return values;
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') ? msg : msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/lset.js

@@ -0,0 +1,16 @@
+/**
+ * LSET key index element - sets list element at index to element. Returns OK.
+ */
+
+export function handleLset(engine, args) {
+  if (!args || args.length < 3) {
+    return { error: 'ERR wrong number of arguments for \'LSET\' command' };
+  }
+  try {
+    engine.lset(args[0], args[1], args[2]);
+    return { simple: 'OK' };
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') ? msg : msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/ltrim.js

@@ -0,0 +1,16 @@
+/**
+ * LTRIM key start stop - trims list to the specified range. Returns OK.
+ */
+
+export function handleLtrim(engine, args) {
+  if (!args || args.length < 3) {
+    return { error: 'ERR wrong number of arguments for \'LTRIM\' command' };
+  }
+  try {
+    engine.ltrim(args[0], args[1], args[2]);
+    return { simple: 'OK' };
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') ? msg : msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/registry.js

@@ -9,6 +9,7 @@ import * as quit from './quit.js';
 import * as get from './get.js';
 import * as set from './set.js';
 import * as setex from './setex.js';
+import * as strlen from './strlen.js';
 import * as del from './del.js';
 import * as unlink from './unlink.js';
 import * as exists from './exists.js';
@@ -29,6 +30,8 @@ import * as hset from './hset.js';
 import * as hget from './hget.js';
 import * as hmget from './hmget.js';
 import * as hgetall from './hgetall.js';
+import * as hkeys from './hkeys.js';
+import * as hvals from './hvals.js';
 import * as hdel from './hdel.js';
 import * as hlen from './hlen.js';
 import * as hexists from './hexists.js';
@@ -38,6 +41,8 @@ import * as srem from './srem.js';
 import * as smembers from './smembers.js';
 import * as sismember from './sismember.js';
 import * as scard from './scard.js';
+import * as spop from './spop.js';
+import * as srandmember from './srandmember.js';
 import * as lpush from './lpush.js';
 import * as rpush from './rpush.js';
 import * as llen from './llen.js';
@@ -46,10 +51,13 @@ import * as lindex from './lindex.js';
 import * as lpop from './lpop.js';
 import * as rpop from './rpop.js';
 import * as lrem from './lrem.js';
+import * as lset from './lset.js';
+import * as ltrim from './ltrim.js';
 import * as blpop from './blpop.js';
 import * as brpop from './brpop.js';
 import * as scan from './scan.js';
 import * as keys from './keys.js';
+import * as rename from './rename.js';
 import * as zadd from './zadd.js';
 import * as zrem from './zrem.js';
 import * as zcard from './zcard.js';
@@ -60,6 +68,10 @@ import * as zrevrange from './zrevrange.js';
 import * as zrevrangebyscore from './zrevrangebyscore.js';
 import * as zrevrank from './zrevrank.js';
 import * as zrank from './zrank.js';
+import * as zcount from './zcount.js';
+import * as zincrby from './zincrby.js';
+import * as zremrangebyrank from './zremrangebyrank.js';
+import * as zremrangebyscore from './zremrangebyscore.js';
 import * as sqliteInfo from './sqlite-info.js';
 import * as cacheInfo from './cache-info.js';
 import * as memoryInfo from './memory-info.js';
@@ -82,6 +94,7 @@ const HANDLERS = new Map([
   ['GET', (e, a) => get.handleGet(e, a)],
   ['SET', (e, a) => set.handleSet(e, a)],
   ['SETEX', (e, a) => setex.handleSetex(e, a)],
+  ['STRLEN', (e, a) => strlen.handleStrlen(e, a)],
   ['DEL', (e, a) => del.handleDel(e, a)],
   ['UNLINK', (e, a) => unlink.handleUnlink(e, a)],
   ['EXISTS', (e, a) => exists.handleExists(e, a)],
@@ -102,6 +115,8 @@ const HANDLERS = new Map([
   ['HGET', (e, a) => hget.handleHget(e, a)],
   ['HMGET', (e, a) => hmget.handleHmget(e, a)],
   ['HGETALL', (e, a) => hgetall.handleHgetall(e, a)],
+  ['HKEYS', (e, a) => hkeys.handleHkeys(e, a)],
+  ['HVALS', (e, a) => hvals.handleHvals(e, a)],
   ['HDEL', (e, a) => hdel.handleHdel(e, a)],
   ['HLEN', (e, a) => hlen.handleHlen(e, a)],
   ['HEXISTS', (e, a) => hexists.handleHexists(e, a)],
@@ -111,6 +126,8 @@ const HANDLERS = new Map([
   ['SMEMBERS', (e, a) => smembers.handleSmembers(e, a)],
   ['SISMEMBER', (e, a) => sismember.handleSismember(e, a)],
   ['SCARD', (e, a) => scard.handleScard(e, a)],
+  ['SPOP', (e, a) => spop.handleSpop(e, a)],
+  ['SRANDMEMBER', (e, a) => srandmember.handleSrandmember(e, a)],
   ['LPUSH', (e, a) => lpush.handleLpush(e, a)],
   ['RPUSH', (e, a) => rpush.handleRpush(e, a)],
   ['LLEN', (e, a) => llen.handleLlen(e, a)],
@@ -119,10 +136,13 @@ const HANDLERS = new Map([
   ['LPOP', (e, a, ctx) => lpop.handleLpop(e, a)],
   ['RPOP', (e, a, ctx) => rpop.handleRpop(e, a)],
   ['LREM', (e, a) => lrem.handleLrem(e, a)],
+  ['LSET', (e, a) => lset.handleLset(e, a)],
+  ['LTRIM', (e, a) => ltrim.handleLtrim(e, a)],
   ['BLPOP', (e, a, ctx) => blpop.handleBlpop(e, a, ctx)],
   ['BRPOP', (e, a, ctx) => brpop.handleBrpop(e, a, ctx)],
   ['SCAN', (e, a) => scan.handleScan(e, a)],
   ['KEYS', (e, a) => keys.handleKeys(e, a)],
+  ['RENAME', (e, a) => rename.handleRename(e, a)],
   ['ZADD', (e, a) => zadd.handleZadd(e, a)],
   ['ZREM', (e, a) => zrem.handleZrem(e, a)],
   ['ZCARD', (e, a) => zcard.handleZcard(e, a)],
@@ -133,6 +153,10 @@ const HANDLERS = new Map([
   ['ZREVRANGEBYSCORE', (e, a) => zrevrangebyscore.handleZrevrangebyscore(e, a)],
   ['ZREVRANK', (e, a) => zrevrank.handleZrevrank(e, a)],
   ['ZRANK', (e, a) => zrank.handleZrank(e, a)],
+  ['ZCOUNT', (e, a) => zcount.handleZcount(e, a)],
+  ['ZINCRBY', (e, a) => zincrby.handleZincrby(e, a)],
+  ['ZREMRANGEBYRANK', (e, a) => zremrangebyrank.handleZremrangebyrank(e, a)],
+  ['ZREMRANGEBYSCORE', (e, a) => zremrangebyscore.handleZremrangebyscore(e, a)],
   ['SQLITE.INFO', (e, a) => sqliteInfo.handleSqliteInfo(e, a)],
   ['CACHE.INFO', (e, a) => cacheInfo.handleCacheInfo(e, a)],
   ['MEMORY.INFO', (e, a) => memoryInfo.handleMemoryInfo(e, a)],

package/src/commands/rename.js

@@ -0,0 +1,16 @@
+/**
+ * RENAME key newkey - renames key to newkey, overwriting newkey if it exists. Returns OK.
+ */
+
+export function handleRename(engine, args) {
+  if (!args || args.length < 2) {
+    return { error: 'ERR wrong number of arguments for \'RENAME\' command' };
+  }
+  try {
+    engine.rename(args[0], args[1]);
+    return { simple: 'OK' };
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') ? msg : msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/spop.js

@@ -0,0 +1,21 @@
+/**
+ * SPOP key [count] - removes and returns one or more random members. Default count 1.
+ */
+
+export function handleSpop(engine, args) {
+  if (!args || args.length < 1) {
+    return { error: 'ERR wrong number of arguments for \'SPOP\' command' };
+  }
+  try {
+    let count = null;
+    if (args.length >= 2) {
+      const n = parseInt(String(args[1]), 10);
+      if (!Number.isNaN(n)) count = n;
+    }
+    const result = engine.spop(args[0], count);
+    return result;
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') ? msg : msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/srandmember.js

@@ -0,0 +1,21 @@
+/**
+ * SRANDMEMBER key [count] - returns one or more random members without removing. Default count 1.
+ */
+
+export function handleSrandmember(engine, args) {
+  if (!args || args.length < 1) {
+    return { error: 'ERR wrong number of arguments for \'SRANDMEMBER\' command' };
+  }
+  try {
+    let count = null;
+    if (args.length >= 2) {
+      const n = parseInt(String(args[1]), 10);
+      if (!Number.isNaN(n)) count = n;
+    }
+    const result = engine.srandmember(args[0], count);
+    return result;
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') ? msg : msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/strlen.js

@@ -0,0 +1,16 @@
+/**
+ * STRLEN key - returns length of string value in bytes, or 0 if key does not exist.
+ */
+
+export function handleStrlen(engine, args) {
+  if (!args || args.length < 1) {
+    return { error: 'ERR wrong number of arguments for \'STRLEN\' command' };
+  }
+  try {
+    const len = engine.strlen(args[0]);
+    return len;
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') ? msg : msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/zcount.js

@@ -0,0 +1,21 @@
+/**
+ * ZCOUNT key min max - returns count of members in sorted set with score in [min, max].
+ */
+
+export function handleZcount(engine, args) {
+  if (!args || args.length < 3) {
+    return { error: 'ERR wrong number of arguments for \'ZCOUNT\' command' };
+  }
+  try {
+    const min = parseFloat(String(args[1]));
+    const max = parseFloat(String(args[2]));
+    if (Number.isNaN(min) || Number.isNaN(max)) {
+      return { error: 'ERR value is not a valid float' };
+    }
+    const n = engine.zcount(args[0], min, max);
+    return n;
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') ? msg : msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/zincrby.js

@@ -0,0 +1,16 @@
+/**
+ * ZINCRBY key increment member - increments member's score, returns new score.
+ */
+
+export function handleZincrby(engine, args) {
+  if (!args || args.length < 3) {
+    return { error: 'ERR wrong number of arguments for \'ZINCRBY\' command' };
+  }
+  try {
+    const score = engine.zincrby(args[0], args[1], args[2]);
+    return score;
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') ? msg : msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/zremrangebyrank.js

@@ -0,0 +1,21 @@
+/**
+ * ZREMRANGEBYRANK key start stop - removes members in rank range. Returns count removed.
+ */
+
+export function handleZremrangebyrank(engine, args) {
+  if (!args || args.length < 3) {
+    return { error: 'ERR wrong number of arguments for \'ZREMRANGEBYRANK\' command' };
+  }
+  try {
+    const start = parseInt(String(args[1]), 10);
+    const stop = parseInt(String(args[2]), 10);
+    if (Number.isNaN(start) || Number.isNaN(stop)) {
+      return { error: 'ERR value is not an integer or out of range' };
+    }
+    const n = engine.zremrangebyrank(args[0], start, stop);
+    return n;
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') ? msg : msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/zremrangebyscore.js

@@ -0,0 +1,21 @@
+/**
+ * ZREMRANGEBYSCORE key min max - removes members with score in [min, max]. Returns count removed.
+ */
+
+export function handleZremrangebyscore(engine, args) {
+  if (!args || args.length < 3) {
+    return { error: 'ERR wrong number of arguments for \'ZREMRANGEBYSCORE\' command' };
+  }
+  try {
+    const min = parseFloat(String(args[1]));
+    const max = parseFloat(String(args[2]));
+    if (Number.isNaN(min) || Number.isNaN(max)) {
+      return { error: 'ERR value is not a valid float' };
+    }
+    const n = engine.zremrangebyscore(args[0], min, max);
+    return n;
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') ? msg : msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/engine/engine.js

@@ -10,6 +10,7 @@ import { createSetsStorage } from '../storage/sqlite/sets.js';
 import { createListsStorage } from '../storage/sqlite/lists.js';
 import { createZsetsStorage } from '../storage/sqlite/zsets.js';
 import { createBlockingManager } from '../blocking/manager.js';
+import { runInTransaction } from '../storage/sqlite/tx.js';
 import { expectString, expectHash, expectSet, expectList, expectZset, typeName } from './validate.js';
 import { asKey, asValue } from '../util/buffers.js';
 
@@ -55,6 +56,15 @@ export function createEngine(opts = {}) {
       return strings.get(k);
     },
 
+    strlen(key) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return 0;
+      expectString(meta);
+      const v = strings.get(k);
+      return v ? v.length : 0;
+    },
+
     set(key, value, options = {}) {
       const k = asKey(key);
       getKeyMeta(key); // lazy-expire if needed
@@ -201,6 +211,20 @@ export function createEngine(opts = {}) {
       return hashes.getAll(k);
     },
 
+    hkeys(key) {
+      const flat = this.hgetall(key);
+      const out = [];
+      for (let i = 0; i < flat.length; i += 2) out.push(flat[i]);
+      return out;
+    },
+
+    hvals(key) {
+      const flat = this.hgetall(key);
+      const out = [];
+      for (let i = 1; i < flat.length; i += 2) out.push(flat[i]);
+      return out;
+    },
+
     hdel(key, fields) {
       const k = asKey(key);
       const meta = getKeyMeta(key);
@@ -267,6 +291,22 @@ export function createEngine(opts = {}) {
       return sets.count(asKey(key));
     },
 
+    spop(key, count = null) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return count != null && count !== 1 ? [] : null;
+      expectSet(meta);
+      return sets.popRandom(k, count);
+    },
+
+    srandmember(key, count = null) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return count != null && count !== 1 ? [] : null;
+      expectSet(meta);
+      return sets.getRandomMembers(k, count);
+    },
+
     lpush(key, ...values) {
       const k = asKey(key);
       getKeyMeta(key);
@@ -341,6 +381,28 @@ export function createEngine(opts = {}) {
       return lists.lrem(k, c, elem);
     },
 
+    lset(key, index, value) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) throw new Error('ERR no such key');
+      expectList(meta);
+      const i = parseInt(Buffer.isBuffer(index) ? index.toString() : String(index), 10);
+      if (Number.isNaN(i)) throw new Error('ERR index out of range');
+      const val = Buffer.isBuffer(value) ? value : asValue(value);
+      lists.lset(k, i, val);
+    },
+
+    ltrim(key, start, stop) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return;
+      expectList(meta);
+      const s = parseInt(Buffer.isBuffer(start) ? start.toString() : String(start), 10);
+      const e = parseInt(Buffer.isBuffer(stop) ? stop.toString() : String(stop), 10);
+      if (Number.isNaN(s) || Number.isNaN(e)) return;
+      lists.ltrim(k, s, e);
+    },
+
     zadd(key, scoreMemberPairs) {
       const k = asKey(key);
       getKeyMeta(key);
@@ -423,6 +485,44 @@ export function createEngine(opts = {}) {
       });
     },
 
+    zcount(key, min, max) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return 0;
+      expectZset(meta);
+      return zsets.countByScore(k, min, max);
+    },
+
+    zincrby(key, increment, member) {
+      const k = asKey(key);
+      getKeyMeta(key);
+      const inc = parseFloat(Buffer.isBuffer(increment) ? increment.toString() : String(increment));
+      if (Number.isNaN(inc)) throw new Error('ERR value is not a valid float');
+      return zsets.incr(k, asKey(member), inc);
+    },
+
+    zremrangebyrank(key, start, stop) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return 0;
+      expectZset(meta);
+      const s = parseInt(Buffer.isBuffer(start) ? start.toString() : String(start), 10);
+      const e = parseInt(Buffer.isBuffer(stop) ? stop.toString() : String(stop), 10);
+      if (Number.isNaN(s) || Number.isNaN(e)) return 0;
+      return zsets.removeRangeByRank(k, s, e);
+    },
+
+    zremrangebyscore(key, min, max) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return 0;
+      expectZset(meta);
+      const minNum = parseFloat(Buffer.isBuffer(min) ? min.toString() : String(min));
+      const maxNum = parseFloat(Buffer.isBuffer(max) ? max.toString() : String(max));
+      if (Number.isNaN(minNum) || Number.isNaN(maxNum)) throw new Error('ERR value is not a valid float');
+      return zsets.removeRangeByScore(k, minNum, maxNum);
+    },
+
     zrevrangebyscore(key, max, min, options = {}) {
       const k = asKey(key);
       const meta = getKeyMeta(key);
@@ -459,6 +559,38 @@ export function createEngine(opts = {}) {
       return { cursor: nextCursor, keys: keysList };
     },
 
+    rename(key, newkey) {
+      const k = asKey(key);
+      const nk = asKey(newkey);
+      const meta = getKeyMeta(key);
+      if (!meta) throw new Error('ERR no such key');
+      if (k.equals(nk)) return;
+      runInTransaction(db, () => {
+        if (keys.get(nk)) keys.delete(nk);
+        keys.set(nk, meta.type, { expiresAt: meta.expiresAt });
+        switch (meta.type) {
+          case KEY_TYPES.STRING:
+            strings.copyKey(k, nk);
+            break;
+          case KEY_TYPES.HASH:
+            hashes.copyKey(k, nk);
+            break;
+          case KEY_TYPES.SET:
+            sets.copyKey(k, nk);
+            break;
+          case KEY_TYPES.LIST:
+            lists.copyKey(k, nk);
+            break;
+          case KEY_TYPES.ZSET:
+            zsets.copyKey(k, nk);
+            break;
+          default:
+            throw new Error('ERR unknown key type');
+        }
+        keys.delete(k);
+      });
+    },
+
     // Expose for storage/commands that need direct access
     _db: db,
     _cache: cache ?? null,

package/src/storage/sqlite/hashes.js

@@ -103,5 +103,13 @@ export function createHashesStorage(db, keys) {
         return next;
       });
     },
+
+    /** Copy all field/value rows from oldKey to newKey. Caller ensures newKey exists in redis_keys. */
+    copyKey(oldKey, newKey) {
+      const rows = getAllStmt.all(oldKey);
+      for (let i = 0; i < rows.length; i += 2) {
+        insertStmt.run(newKey, rows[i], rows[i + 1]);
+      }
+    },
   };
 }

package/src/storage/sqlite/lists.js

@@ -41,6 +41,15 @@ export function createListsStorage(db, keys) {
     'SELECT seq, value FROM redis_list_items WHERE key = ? ORDER BY seq ASC'
   );
   const deleteAllItemsStmt = db.prepare('DELETE FROM redis_list_items WHERE key = ?');
+  const updateItemStmt = db.prepare(
+    'UPDATE redis_list_items SET value = ? WHERE key = ? AND seq = ?'
+  );
+  const deleteBeforeSeqStmt = db.prepare(
+    'DELETE FROM redis_list_items WHERE key = ? AND seq < ?'
+  );
+  const deleteAfterSeqStmt = db.prepare(
+    'DELETE FROM redis_list_items WHERE key = ? AND seq > ?'
+  );
 
   function getMeta(key) {
     return getMetaStmt.get(key) || null;
@@ -279,5 +288,56 @@ export function createListsStorage(db, keys) {
         return toDelete.length;
       });
     },
+
+    lset(key, index, value) {
+      return runInTransaction(db, () => {
+        const meta = getMeta(key);
+        const len = length(meta);
+        if (len === 0) throw new Error('ERR no such key');
+        const idx = parseInt(String(index), 10);
+        if (Number.isNaN(idx)) throw new Error('ERR index out of range');
+        const i = idx < 0 ? len + idx : idx;
+        if (i < 0 || i >= len) throw new Error('ERR index out of range');
+        const seq = meta.headSeq + i;
+        const r = updateItemStmt.run(value, key, seq);
+        if (r.changes === 0) throw new Error('ERR index out of range');
+        keys.bumpVersion(key);
+      });
+    },
+
+    ltrim(key, start, stop) {
+      return runInTransaction(db, () => {
+        const meta = getMeta(key);
+        const len = length(meta);
+        if (len === 0) return;
+
+        let s = start < 0 ? Math.max(0, len + start) : Math.min(start, len - 1);
+        let e = stop < 0 ? Math.max(0, len + stop) : Math.min(stop, len - 1);
+        if (s > e) {
+          deleteAllItemsStmt.run(key);
+          deleteMetaStmt.run(key);
+          keys.delete(key);
+          return;
+        }
+
+        const newHead = meta.headSeq + s;
+        const newTail = meta.headSeq + e;
+        deleteBeforeSeqStmt.run(key, newHead);
+        deleteAfterSeqStmt.run(key, newTail);
+        updateMetaStmt.run(newHead, newTail, key);
+        keys.bumpVersion(key);
+      });
+    },
+
+    /** Copy list from oldKey to newKey. Caller ensures newKey exists in redis_keys. */
+    copyKey(oldKey, newKey) {
+      const meta = getMeta(oldKey);
+      if (!meta) return;
+      insertMetaStmt.run(newKey, meta.headSeq, meta.tailSeq);
+      const rows = selectAllWithSeqStmt.all(oldKey);
+      for (const r of rows) {
+        insertItemStmt.run(newKey, r.seq, r.value);
+      }
+    },
   };
 }

package/src/storage/sqlite/sets.js

@@ -68,5 +68,65 @@ export function createSetsStorage(db, keys) {
       const row = countStmt.get(key);
       return row ? row.n : 0;
     },
+
+    /** Copy all members from oldKey to newKey. Caller ensures newKey exists in redis_keys. */
+    copyKey(oldKey, newKey) {
+      const rows = membersStmt.all(oldKey);
+      for (const r of rows) {
+        insertStmt.run(newKey, r.member);
+      }
+    },
+
+    /** Get random members without removing. count null/1 = single; count > 0 = up to count distinct; count < 0 = |count| with replacement. */
+    getRandomMembers(key, count) {
+      const arr = membersStmt.all(key).map((r) => r.member);
+      if (arr.length === 0) return count != null && count !== 1 ? [] : null;
+      const c = count == null ? 1 : count;
+      if (c === 1) return arr[Math.floor(Math.random() * arr.length)];
+      if (c > 0) {
+        const shuffled = arr.slice();
+        for (let i = shuffled.length - 1; i > 0; i--) {
+          const j = Math.floor(Math.random() * (i + 1));
+          [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+        }
+        return shuffled.slice(0, Math.min(c, shuffled.length));
+      }
+      const out = [];
+      for (let i = 0; i < -c; i++) out.push(arr[Math.floor(Math.random() * arr.length)]);
+      return out;
+    },
+
+    /** Remove and return random members. Returns single member or array. */
+    popRandom(key, count, options = {}) {
+      return runInTransaction(db, () => {
+        const arr = membersStmt.all(key).map((r) => r.member);
+        if (arr.length === 0) return count != null && count !== 1 ? [] : null;
+        const c = count == null ? 1 : count;
+        let chosen;
+        if (c === 1) {
+          chosen = [arr[Math.floor(Math.random() * arr.length)]];
+        } else if (c > 0) {
+          const shuffled = arr.slice();
+          for (let i = shuffled.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+          }
+          chosen = shuffled.slice(0, Math.min(c, shuffled.length));
+        } else {
+          chosen = [];
+          for (let i = 0; i < -c; i++) chosen.push(arr[Math.floor(Math.random() * arr.length)]);
+        }
+        for (const m of chosen) deleteStmt.run(key, m);
+        const row = countStmt.get(key);
+        const remaining = (row && row.n) || 0;
+        if (remaining === 0) {
+          deleteAllStmt.run(key);
+          keys.delete(key);
+        } else {
+          keys.bumpVersion(key);
+        }
+        return c === 1 ? chosen[0] : chosen;
+      });
+    },
   };
 }

package/src/storage/sqlite/strings.js

@@ -59,5 +59,13 @@ export function createStringsStorage(db, keys) {
         keys.delete(key);
       });
     },
+
+    /**
+     * Copy key's value to newKey. Caller must ensure newKey row exists in redis_keys.
+     */
+    copyKey(oldKey, newKey) {
+      const row = getStmt.get(oldKey);
+      if (row) insertStmt.run(newKey, row.value);
+    },
   };
 }

package/src/storage/sqlite/zsets.js

@@ -62,6 +62,13 @@ export function createZsetsStorage(db, keys) {
      ORDER BY score DESC, member DESC
      LIMIT ? OFFSET ?`
   );
+  const selectAllStmt = db.prepare('SELECT member, score FROM redis_zsets WHERE key = ?');
+  const countByScoreStmt = db.prepare(
+    'SELECT COUNT(*) AS n FROM redis_zsets WHERE key = ? AND score >= ? AND score <= ?'
+  );
+  const deleteByScoreRangeStmt = db.prepare(
+    'DELETE FROM redis_zsets WHERE key = ? AND score >= ? AND score <= ?'
+  );
 
   return {
     /**
@@ -256,5 +263,79 @@ export function createZsetsStorage(db, keys) {
       }
       return out;
     },
+
+    /** Copy all member/score rows from oldKey to newKey. Caller ensures newKey exists in redis_keys. */
+    copyKey(oldKey, newKey) {
+      const rows = selectAllStmt.all(oldKey);
+      for (const r of rows) {
+        upsertStmt.run(newKey, r.member, r.score);
+      }
+    },
+
+    countByScore(key, min, max) {
+      const row = countByScoreStmt.get(key, min, max);
+      return row ? row.n : 0;
+    },
+
+    incr(key, member, increment, options = {}) {
+      return runInTransaction(db, () => {
+        const now = options.updatedAt ?? Date.now();
+        const meta = keys.get(key);
+        if (meta && meta.type !== KEY_TYPES.ZSET) {
+          throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
+        }
+        if (!meta) {
+          keys.set(key, KEY_TYPES.ZSET, { updatedAt: now });
+        } else {
+          keys.bumpVersion(key);
+        }
+        const cur = scoreStmt.get(key, member);
+        const prev = cur == null ? 0 : cur.score;
+        const next = prev + increment;
+        upsertStmt.run(key, member, next);
+        return formatScore(next);
+      });
+    },
+
+    removeRangeByRank(key, start, stop) {
+      return runInTransaction(db, () => {
+        const len = this.count(key);
+        if (len === 0) return 0;
+        let s = start >= 0 ? start : Math.max(0, len + start);
+        let e = stop >= 0 ? stop : Math.max(0, len + stop);
+        if (s > e) return 0;
+        s = Math.min(s, len - 1);
+        e = Math.min(e, len - 1);
+        const limit = e - s + 1;
+        const offset = s;
+        const rows = rangeByRankStmt.all(key, limit, offset);
+        let n = 0;
+        for (const r of rows) {
+          n += deleteStmt.run(key, r.member).changes;
+        }
+        const row = countStmt.get(key);
+        const remaining = (row && row.n) || 0;
+        if (remaining === 0) {
+          deleteAllStmt.run(key);
+          keys.delete(key);
+        }
+        return n;
+      });
+    },
+
+    removeRangeByScore(key, min, max) {
+      return runInTransaction(db, () => {
+        const r = deleteByScoreRangeStmt.run(key, min, max);
+        const remaining = countStmt.get(key);
+        const n = (remaining && remaining.n) || 0;
+        if (n === 0) {
+          deleteAllStmt.run(key);
+          keys.delete(key);
+        } else if (r.changes > 0) {
+          keys.bumpVersion(key);
+        }
+        return r.changes;
+      });
+    },
   };
 }

package/test/integration/new-commands.test.js

@@ -0,0 +1,135 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { createTestServer } from '../helpers/server.js';
+import { sendCommand, argv } from '../helpers/client.js';
+import { tryParseValue } from '../../src/resp/parser.js';
+
+function parseIntegerReply(buf) {
+  const r = tryParseValue(buf, 0);
+  return r && typeof r.value === 'number' ? r.value : null;
+}
+
+function parseBulkReply(buf) {
+  const r = tryParseValue(buf, 0);
+  return r && r.value && Buffer.isBuffer(r.value) ? r.value.toString('utf8') : null;
+}
+
+function parseArrayReply(buf) {
+  const r = tryParseValue(buf, 0);
+  if (!r || !Array.isArray(r.value)) return null;
+  return r.value.map((v) => (Buffer.isBuffer(v) ? v.toString('utf8') : v));
+}
+
+describe('New commands integration (STRLEN, HKEYS, HVALS, LSET, LTRIM, RENAME, Z*, SPOP, SRANDMEMBER)', () => {
+  let s;
+  let port;
+
+  before(async () => {
+    s = await createTestServer();
+    port = s.port;
+  });
+
+  after(async () => {
+    await s.closeAsync();
+  });
+
+  it('STRLEN returns byte length, 0 for missing key', async () => {
+    await sendCommand(port, argv('SET', 'slen', 'hello'));
+    const r = await sendCommand(port, argv('STRLEN', 'slen'));
+    assert.equal(parseIntegerReply(r), 5);
+    const r0 = await sendCommand(port, argv('STRLEN', 'nonexistent'));
+    assert.equal(parseIntegerReply(r0), 0);
+  });
+
+  it('HKEYS returns field names', async () => {
+    await sendCommand(port, argv('HSET', 'hk', 'a', '1', 'b', '2'));
+    const r = await sendCommand(port, argv('HKEYS', 'hk'));
+    const arr = parseArrayReply(r);
+    assert.ok(Array.isArray(arr));
+    assert.ok(arr.includes('a') && arr.includes('b'));
+    const empty = await sendCommand(port, argv('HKEYS', 'nonexistent'));
+    assert.equal(parseArrayReply(empty).length, 0);
+  });
+
+  it('HVALS returns values', async () => {
+    await sendCommand(port, argv('HSET', 'hv', 'x', '10', 'y', '20'));
+    const r = await sendCommand(port, argv('HVALS', 'hv'));
+    const arr = parseArrayReply(r);
+    assert.ok(arr.includes('10') && arr.includes('20'));
+  });
+
+  it('LSET sets element at index and returns OK', async () => {
+    await sendCommand(port, argv('RPUSH', 'lst', 'one', 'two', 'three'));
+    const ok = await sendCommand(port, argv('LSET', 'lst', '1', 'TWO'));
+    assert.ok(ok.toString('utf8').startsWith('+OK'));
+    const r = await sendCommand(port, argv('LRANGE', 'lst', '0', '-1'));
+    const arr = parseArrayReply(r);
+    assert.equal(arr[1], 'TWO');
+  });
+
+  it('LTRIM keeps only range and returns OK', async () => {
+    await sendCommand(port, argv('RPUSH', 'lt', 'a', 'b', 'c', 'd'));
+    await sendCommand(port, argv('LTRIM', 'lt', '1', '2'));
+    const r = await sendCommand(port, argv('LRANGE', 'lt', '0', '-1'));
+    const arr = parseArrayReply(r);
+    assert.deepEqual(arr, ['b', 'c']);
+  });
+
+  it('RENAME renames key and overwrites destination', async () => {
+    await sendCommand(port, argv('SET', 'old', 'value'));
+    const ok = await sendCommand(port, argv('RENAME', 'old', 'new'));
+    assert.ok(ok.toString('utf8').startsWith('+OK'));
+    const v = await sendCommand(port, argv('GET', 'new'));
+    assert.equal(parseBulkReply(v), 'value');
+    const missing = await sendCommand(port, argv('GET', 'old'));
+    assert.equal(missing.toString('ascii'), '$-1\r\n');
+  });
+
+  it('ZCOUNT returns count in score range', async () => {
+    await sendCommand(port, argv('ZADD', 'zc', '1', 'a', '2', 'b', '3', 'c'));
+    const r = await sendCommand(port, argv('ZCOUNT', 'zc', '1', '2'));
+    assert.equal(parseIntegerReply(r), 2);
+    assert.equal(parseIntegerReply(await sendCommand(port, argv('ZCOUNT', 'zc', '10', '20'))), 0);
+  });
+
+  it('ZINCRBY increments score and returns new score', async () => {
+    await sendCommand(port, argv('ZADD', 'zi', '10', 'm'));
+    const r = await sendCommand(port, argv('ZINCRBY', 'zi', '5', 'm'));
+    const score = r.toString('utf8').replace(/\r\n$/, '');
+    assert.ok(score.includes('15'));
+    const r2 = await sendCommand(port, argv('ZINCRBY', 'zi', '1', 'new'));
+    assert.ok(r2.toString('utf8').includes('1'));
+  });
+
+  it('ZREMRANGEBYRANK removes by rank and returns count', async () => {
+    await sendCommand(port, argv('ZADD', 'zr', '1', 'a', '2', 'b', '3', 'c'));
+    const n = await sendCommand(port, argv('ZREMRANGEBYRANK', 'zr', '0', '0'));
+    assert.equal(parseIntegerReply(n), 1);
+    const arr = await sendCommand(port, argv('ZRANGE', 'zr', '0', '-1'));
+    assert.equal(parseArrayReply(arr).length, 2);
+  });
+
+  it('ZREMRANGEBYSCORE removes by score range and returns count', async () => {
+    await sendCommand(port, argv('ZADD', 'zs', '1', 'a', '2', 'b', '3', 'c'));
+    const n = await sendCommand(port, argv('ZREMRANGEBYSCORE', 'zs', '1', '2'));
+    assert.equal(parseIntegerReply(n), 2);
+    const arr = await sendCommand(port, argv('ZRANGE', 'zs', '0', '-1'));
+    assert.deepEqual(parseArrayReply(arr), ['c']);
+  });
+
+  it('SPOP removes and returns random member(s)', async () => {
+    await sendCommand(port, argv('SADD', 'sp', 'x', 'y', 'z'));
+    const one = await sendCommand(port, argv('SPOP', 'sp'));
+    const v = parseBulkReply(one);
+    assert.ok(['x', 'y', 'z'].includes(v));
+    const card = await sendCommand(port, argv('SCARD', 'sp'));
+    assert.equal(parseIntegerReply(card), 2);
+  });
+
+  it('SRANDMEMBER returns random member without removing', async () => {
+    await sendCommand(port, argv('SADD', 'sr', 'a', 'b'));
+    const r = await sendCommand(port, argv('SRANDMEMBER', 'sr'));
+    assert.ok(['a', 'b'].includes(parseBulkReply(r)));
+    assert.equal(parseIntegerReply(await sendCommand(port, argv('SCARD', 'sr'))), 2);
+  });
+});