resplite 1.1.2 → 1.1.6

package/README.md

@@ -1,15 +1,65 @@
 # RESPLite
 
-A RESP2 server with practical Redis compatibility, backed by SQLite for persistent single-node workloads.
+A RESP server backed by SQLite. Compatible with `redis` clients and `redis-cli`, persistent by default, zero external daemons, and minimal memory footprint.
 
 ## Overview
 
-RESPLite is not a full Redis clone. It is a RESP server with Redis-like semantics for a carefully selected subset of commands that map naturally to SQLite. Ideal for small to medium applications, persistent caches, local development, and low-ops deployments.
+RESPLite speaks **RESP** (the Redis Serialization Protocol), so your existing `redis` npm client and `redis-cli` work without changes. The storage layer is **SQLite**: WAL mode, FTS5 for full-text search, and a single `.db` file that survives restarts without snapshots or AOF.
 
-- **Zero external services** — just Node.js and a SQLite file.
+It is not a Redis clone. It covers a practical subset of commands that map naturally to SQLite, suited for single-node workloads where Redis' in-memory latency is not a hard requirement.
+
+- **Zero external services** — just Node.js and a `.db` file.
 - **Drop-in compatible** — works with the official `redis` npm client and `redis-cli`.
-- **Persistent by default** — data survives restarts without snapshots or AOF.
-- **Embeddable** — start the server and connect from the same script (see examples below).
+- **Persistent by default** — no snapshots, no AOF, no config.
+- **Embeddable** — start the server and connect from the same script.
+- **Full-text search** — FT.\* commands via SQLite FTS5.
+- **Simple queues** — lists with BLPOP/BRPOP.
+
+### When RESPLite beats Redis in Docker
+
+Building this project surfaced a clear finding: **Redis running inside Docker** on the same host often has **worse latency** than **RESPLite running locally**. Docker's virtual network adds overhead that disappears when the server runs in the same process/host. For single-node workloads this makes RESPLite the faster, simpler option.
+
+The strongest use case is **migrating a non-replicated Redis instance that has grown large** (tens of GB). You don't need to manage replicas, AOF, or RDB. Once migrated, you get a single SQLite file and latency that is good enough for most workloads. The built-in migration tooling (see [Migration from Redis](#migration-from-redis)) handles datasets of that size with minimal downtime.
+
+## Benchmark (Redis vs RESPLite)
+
+A typical comparison is **Redis (e.g. in Docker)** on one side and **RESPLite locally** on the other. In that setup, RESPLite often shows **better latency** because it avoids Docker networking and runs in the same process/host. The benchmark below uses RESPLite with the **default** PRAGMA template only.
+
+**Example results (Redis vs RESPLite, default pragma, 10k iterations):**
+
+| Suite           | Redis (Docker) | RESPLite (default) |
+|-----------------|----------------|--------------------|
+| PING            | 8.79K/s        | 37.36K/s           |
+| SET+GET         | 4.68K/s        | 11.96K/s           |
+| MSET+MGET(10)   | 4.41K/s        | 5.81K/s            |
+| INCR            | 9.54K/s        | 18.97K/s           |
+| HSET+HGET       | 4.40K/s        | 11.91K/s           |
+| HGETALL(50)     | 8.39K/s        | 11.01K/s           |
+| HLEN(50)        | 9.36K/s        | 31.21K/s           |
+| SADD+SMEMBERS   | 9.27K/s        | 17.37K/s           |
+| LPUSH+LRANGE    | 8.34K/s        | 14.27K/s           |
+| LREM            | 4.37K/s        | 6.08K/s            |
+| ZADD+ZRANGE     | 7.80K/s        | 17.12K/s           |
+| SET+DEL         | 4.39K/s        | 9.57K/s            |
+| FT.SEARCH       | 8.36K/s        | 8.22K/s            |
+
+*Run `npm run benchmark -- --template default` to reproduce. Numbers depend on host and whether Redis is native or in Docker.*
+
+How to run:
+
+```bash
+# Terminal 1: Redis on 6379 (e.g. docker run -p 6379:6379 redis). Terminal 2: RESPLite on 6380
+RESPLITE_PORT=6380 npm start
+
+# Terminal 3: run benchmark (Redis=6379, RESPLite=6380 by default)
+npm run benchmark
+
+# Only RESPLite with default pragma
+npm run benchmark -- --template default
+
+# Custom iterations and ports
+npm run benchmark -- --iterations 10000 --redis-port 6379 --resplite-port 6380
+```
 
 ## Install
 
@@ -265,6 +315,8 @@ await srv2.close();
 
 ## Compatibility matrix
 
+RESPLite implements **47 core Redis commands** (~19% of the ~246 commands in Redis 7). The uncovered 81% is mostly entire subsystems that are out of scope by design: pub/sub (~10 commands), Streams (~20), cluster/replication (~30), Lua scripting (~5), server admin (~40), and extended variants of data-structure commands. For typical single-node application workloads — strings, hashes, sets, lists, sorted sets, key TTLs — coverage is close to the commands developers reach for daily.
+
 ### Supported (v1)
 
 | Category | Commands |
@@ -294,6 +346,8 @@ Unsupported commands return: `ERR command not supported yet`.
 
 ## Migration from Redis
 
+RESPLite is a good fit for migrating **non-replicated Redis** instances that have **grown large** (e.g. tens of GB) and where RESPLite’s latency is acceptable. The SPEC_F flow (dirty-key tracker, bulk import, cutover) is designed for that scenario with minimal downtime.
+
 Migration supports two modes:
 
 ### Simple one-shot import (legacy)
@@ -494,21 +548,6 @@ import {
 } from 'resplite/migration';
 ```
 
-## Benchmark (Redis vs RESPLite)
-
-Compare throughput of local Redis and RESPLite with the same workload (PING, SET/GET, hashes, sets, lists, zsets, etc.):
-
-```bash
-# Terminal 1: Redis on 6379 (default). Terminal 2: RESPLite on 6380
-RESPLITE_PORT=6380 npm start
-
-# Terminal 3: run benchmark (Redis=6379, RESPLite=6380 by default)
-npm run benchmark
-
-# Optional: custom iterations and ports
-npm run benchmark -- --iterations 10000 --redis-port 6379 --resplite-port 6380
-```
-
 ## Scripts
 
 | Script | Description |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "resplite",
-  "version": "1.1.2",
+  "version": "1.1.6",
   "description": "A RESP2 server with practical Redis compatibility, backed by SQLite",
   "type": "module",
   "main": "src/index.js",
@@ -24,6 +24,25 @@
     "benchmark": "node scripts/benchmark-redis-vs-resplite.js",
     "test:all": "node --test 'test/**/*.test.js'"
   },
+  "keywords": [
+    "redis",
+    "sqlite",
+    "resp",
+    "emulator",
+    "sdd",
+    "persist",
+    "cache",
+    "key-value",
+    "store",
+    "embedded",
+    "server",
+    "valkey",
+    "compatible",
+    "dragonfly",
+    "keydb",
+    "garnet",
+    "clasen"
+  ],
   "dependencies": {
     "better-sqlite3": "^11.6.0"
   },

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

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 /**
- * Comparative benchmark: Redis (local) vs RESPlite (all PRAGMA templates).
+ * Comparative benchmark: Redis (local) vs RESPlite (all or one PRAGMA template).
  *
  * Prerequisites:
  *   - Redis running on port 6379 (default)
  *
- * The script spawns one RESPlite process per PRAGMA template (default, performance, safety, minimal)
- * on consecutive ports (6380, 6381, 6382, 6383 by default) and runs the same workload against each.
+ * By default the script spawns one RESPlite process per PRAGMA template (default, performance, safety, minimal)
+ * on consecutive ports. Use --template <name> to run only one template (e.g. default).
  *
  * Usage:
- *   node scripts/benchmark-redis-vs-resplite.js [--iterations N] [--redis-port P] [--resplite-port P]
+ *   node scripts/benchmark-redis-vs-resplite.js [--iterations N] [--redis-port P] [--resplite-port P] [--template NAME]
  */
 
 import { createClient } from 'redis';
@@ -26,8 +26,11 @@ const DEFAULTS = {
   iterations: 10000,
   redisPort: 6379,
   resplitePort: 6380,
+  template: null, // null = all templates (except none); or 'default' | 'performance' | 'safety' | 'minimal'
 };
 
+const VALID_TEMPLATES = ['default', 'performance', 'safety', 'minimal'];
+
 function parseArgs() {
   const out = { ...DEFAULTS };
   const args = process.argv.slice(2);
@@ -38,6 +41,13 @@ function parseArgs() {
       out.redisPort = parseInt(args[++i], 10);
     } else if (args[i] === '--resplite-port' && args[i + 1]) {
       out.resplitePort = parseInt(args[++i], 10);
+    } else if (args[i] === '--template' && args[i + 1]) {
+      const name = args[++i];
+      if (!VALID_TEMPLATES.includes(name)) {
+        console.error(`Invalid --template "${name}". Must be one of: ${VALID_TEMPLATES.join(', ')}`);
+        process.exit(1);
+      }
+      out.template = name;
     }
   }
   return out;
@@ -204,6 +214,13 @@ async function benchHgetall(client, n) {
   for (let i = 0; i < n; i++) await client.hGetAll(key);
 }
 
+async function benchHlen(client, n) {
+  const key = 'bm:hash:hlen';
+  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.hLen(key);
+}
+
 async function benchSaddSmembers(client, n) {
   const key = 'bm:set';
   for (let i = 0; i < n; i++) {
@@ -221,6 +238,18 @@ async function benchLpushLrange(client, n) {
   }
 }
 
+async function benchLrem(client, n) {
+  const key = 'bm:list:lrem';
+  await client.del(key);
+  // Pre-populate with a mix of values so LREM always finds something to do.
+  // Each iteration pushes one 'target' element and removes it — net-zero list size.
+  await client.rPush(key, Array.from({ length: 20 }, (_, i) => `item-${i}`));
+  for (let i = 0; i < n; i++) {
+    await client.rPush(key, 'target');
+    await client.lRem(key, 1, 'target');
+  }
+}
+
 async function benchZaddZrange(client, n) {
   const key = 'bm:zset';
   for (let i = 0; i < n; i++) {
@@ -277,8 +306,10 @@ const SUITES = [
   { name: 'INCR', fn: benchIncr, iterScale: 1 },
   { name: 'HSET+HGET', fn: benchHsetHget, iterScale: 1 },
   { name: 'HGETALL(50)', fn: benchHgetall, iterScale: 1 },
+  { name: 'HLEN(50)', fn: benchHlen, iterScale: 1 },
   { name: 'SADD+SMEMBERS', fn: benchSaddSmembers, iterScale: 1 },
   { name: 'LPUSH+LRANGE', fn: benchLpushLrange, iterScale: 1 },
+  { name: 'LREM', fn: benchLrem, iterScale: 1 },
   { name: 'ZADD+ZRANGE', fn: benchZaddZrange, iterScale: 1 },
   { name: 'SET+DEL', fn: benchDel, iterScale: 1 },
   { name: 'FT.SEARCH', fn: benchFtSearch, iterScale: 1 },
@@ -304,15 +335,17 @@ async function runSuite(redis, respliteClients, suite, iterations) {
 }
 
 async function main() {
-  const { iterations, redisPort, resplitePort } = parseArgs();
-  const templateNames = getPragmaTemplateNames().filter((t) => t !== 'none');
+  const { iterations, redisPort, resplitePort, template } = parseArgs();
+  const templateNames = template
+    ? [template]
+    : getPragmaTemplateNames().filter((t) => t !== 'none');
 
   const benchTmpDir = path.join(PROJECT_ROOT, 'tmp', 'bench');
   fs.mkdirSync(benchTmpDir, { recursive: true });
 
-  console.log('Benchmark: Redis vs RESPlite (all PRAGMA templates)');
+  console.log(template ? `Benchmark: Redis vs RESPlite (template: ${template})` : 'Benchmark: Redis vs RESPlite (all PRAGMA templates)');
   console.log(`  Redis:    127.0.0.1:${redisPort}`);
-  console.log(`  RESPlite: one process per template on ports ${resplitePort}..${resplitePort + templateNames.length - 1}`);
+  console.log(`  RESPlite: ${templateNames.length} process(es) on port(s) ${resplitePort}${templateNames.length > 1 ? `..${resplitePort + templateNames.length - 1}` : ''}`);
   console.log(`  Templates: ${templateNames.join(', ')}`);
   console.log(`  Iterations per suite: ${iterations}`);
   console.log('');

package/src/commands/hlen.js

@@ -0,0 +1,15 @@
+/**
+ * HLEN key
+ */
+
+export function handleHlen(engine, args) {
+  if (!args || args.length < 1) {
+    return { error: "ERR wrong number of arguments for 'HLEN' command" };
+  }
+  try {
+    return engine.hlen(args[0]);
+  } 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/lrem.js

@@ -0,0 +1,15 @@
+/**
+ * LREM key count element
+ */
+
+export function handleLrem(engine, args) {
+  if (!args || args.length < 3) {
+    return { error: "ERR wrong number of arguments for 'LREM' command" };
+  }
+  try {
+    return engine.lrem(args[0], args[1], args[2]);
+  } 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

@@ -27,6 +27,7 @@ import * as hget from './hget.js';
 import * as hmget from './hmget.js';
 import * as hgetall from './hgetall.js';
 import * as hdel from './hdel.js';
+import * as hlen from './hlen.js';
 import * as hexists from './hexists.js';
 import * as hincrby from './hincrby.js';
 import * as sadd from './sadd.js';
@@ -41,6 +42,7 @@ import * as lrange from './lrange.js';
 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 blpop from './blpop.js';
 import * as brpop from './brpop.js';
 import * as scan from './scan.js';
@@ -87,6 +89,7 @@ const HANDLERS = new Map([
   ['HMGET', (e, a) => hmget.handleHmget(e, a)],
   ['HGETALL', (e, a) => hgetall.handleHgetall(e, a)],
   ['HDEL', (e, a) => hdel.handleHdel(e, a)],
+  ['HLEN', (e, a) => hlen.handleHlen(e, a)],
   ['HEXISTS', (e, a) => hexists.handleHexists(e, a)],
   ['HINCRBY', (e, a) => hincrby.handleHincrby(e, a)],
   ['SADD', (e, a) => sadd.handleSadd(e, a)],
@@ -101,6 +104,7 @@ const HANDLERS = new Map([
   ['LINDEX', (e, a) => lindex.handleLindex(e, a)],
   ['LPOP', (e, a, ctx) => lpop.handleLpop(e, a)],
   ['RPOP', (e, a, ctx) => rpop.handleRpop(e, a)],
+  ['LREM', (e, a) => lrem.handleLrem(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)],

package/src/engine/engine.js

@@ -209,6 +209,14 @@ export function createEngine(opts = {}) {
       return hashes.delete(k, fields.map((f) => asKey(f)));
     },
 
+    hlen(key) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return 0;
+      expectHash(meta);
+      return hashes.count(k);
+    },
+
     hexists(key, field) {
       const v = this.hget(key, field);
       return v != null ? 1 : 0;
@@ -322,6 +330,17 @@ export function createEngine(opts = {}) {
       return lists.rpop(k, count);
     },
 
+    lrem(key, count, element) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return 0;
+      expectList(meta);
+      const c = parseInt(Buffer.isBuffer(count) ? count.toString() : String(count), 10);
+      if (Number.isNaN(c)) throw new Error('ERR value is not an integer or out of range');
+      const elem = Buffer.isBuffer(element) ? element : asValue(element);
+      return lists.lrem(k, c, elem);
+    },
+
     zadd(key, scoreMemberPairs) {
       const k = asKey(key);
       getKeyMeta(key);

package/src/storage/sqlite/lists.js

@@ -37,6 +37,10 @@ export function createListsStorage(db, keys) {
   const deleteRangeStmt = db.prepare(
     'DELETE FROM redis_list_items WHERE key = ? AND seq BETWEEN ? AND ?'
   );
+  const selectAllWithSeqStmt = db.prepare(
+    'SELECT seq, value FROM redis_list_items WHERE key = ? ORDER BY seq ASC'
+  );
+  const deleteAllItemsStmt = db.prepare('DELETE FROM redis_list_items WHERE key = ?');
 
   function getMeta(key) {
     return getMetaStmt.get(key) || null;
@@ -229,5 +233,51 @@ export function createListsStorage(db, keys) {
         return values;
       });
     },
+
+    lrem(key, count, element) {
+      return runInTransaction(db, () => {
+        const meta = getMeta(key);
+        if (!meta) return 0;
+
+        const allItems = selectAllWithSeqStmt.all(key);
+        const matches = allItems.filter((item) => {
+          const v = item.value;
+          return Buffer.isBuffer(v) && Buffer.isBuffer(element)
+            ? v.equals(element)
+            : String(v) === String(element);
+        });
+
+        if (matches.length === 0) return 0;
+
+        let toDelete;
+        if (count === 0) {
+          toDelete = matches;
+        } else if (count > 0) {
+          toDelete = matches.slice(0, count);
+        } else {
+          toDelete = matches.slice(count);
+        }
+
+        for (const item of toDelete) {
+          deleteItemStmt.run(key, item.seq);
+        }
+
+        const remaining = selectAllWithSeqStmt.all(key);
+        if (remaining.length === 0) {
+          deleteMetaStmt.run(key);
+          keys.delete(key);
+        } else {
+          deleteAllItemsStmt.run(key);
+          const baseSeq = meta.headSeq;
+          for (let i = 0; i < remaining.length; i++) {
+            insertItemStmt.run(key, baseSeq + i, remaining[i].value);
+          }
+          updateMetaStmt.run(baseSeq, baseSeq + remaining.length - 1, key);
+          keys.bumpVersion(key);
+        }
+
+        return toDelete.length;
+      });
+    },
   };
 }

package/src/storage/sqlite/zsets.js

@@ -63,11 +63,13 @@ export function createZsetsStorage(db, keys) {
         } else {
           keys.set(key, KEY_TYPES.ZSET, { updatedAt: now });
         }
-        const before = countStmt.get(key)?.n ?? 0;
+        let newCount = 0;
         for (const { score, member } of pairs) {
+          const existed = scoreStmt.get(key, member) != null;
           upsertStmt.run(key, member, score);
+          if (!existed) newCount++;
         }
-        return (countStmt.get(key)?.n ?? 0) - before;
+        return newCount;
       });
     },
 
@@ -112,6 +114,17 @@ export function createZsetsStorage(db, keys) {
      * @returns {Buffer[] | Array<Buffer|string>} members or [member, score, ...]
      */
     rangeByRank(key, start, stop, options = {}) {
+      if (start >= 0 && stop >= 0) {
+        if (start > stop) return [];
+        const rows = rangeByRankStmt.all(key, stop - start + 1, start);
+        if (rows.length === 0) return [];
+        if (!options.withScores) return rows.map((r) => r.member);
+        const out = [];
+        for (const r of rows) {
+          out.push(r.member, formatScore(r.score));
+        }
+        return out;
+      }
       const len = this.count(key);
       if (len === 0) return [];
       let s = start < 0 ? Math.max(0, len + start) : start;

package/test/contract/redis-client.test.js

@@ -35,4 +35,44 @@ describe('redis client compatibility', () => {
     assert.equal(arr[0], 'v1');
     assert.equal(arr[1], null);
   });
+
+  it('HLEN returns field count', async () => {
+    await client.hSet('hlen:c1', { f1: 'v1', f2: 'v2', f3: 'v3' });
+    const n = await client.hLen('hlen:c1');
+    assert.equal(n, 3);
+  });
+
+  it('HLEN on non-existent key returns 0', async () => {
+    const n = await client.hLen('hlen:c:missing');
+    assert.equal(n, 0);
+  });
+
+  it('LREM count=0 removes all occurrences', async () => {
+    await client.rPush('lrem:c1', ['a', 'b', 'a', 'c', 'a']);
+    const removed = await client.lRem('lrem:c1', 0, 'a');
+    assert.equal(removed, 3);
+    const items = await client.lRange('lrem:c1', 0, -1);
+    assert.deepEqual(items, ['b', 'c']);
+  });
+
+  it('LREM count>0 removes from head', async () => {
+    await client.rPush('lrem:c2', ['a', 'b', 'a', 'c', 'a']);
+    const removed = await client.lRem('lrem:c2', 2, 'a');
+    assert.equal(removed, 2);
+    const items = await client.lRange('lrem:c2', 0, -1);
+    assert.deepEqual(items, ['b', 'c', 'a']);
+  });
+
+  it('LREM count<0 removes from tail', async () => {
+    await client.rPush('lrem:c3', ['a', 'b', 'a', 'c', 'a']);
+    const removed = await client.lRem('lrem:c3', -2, 'a');
+    assert.equal(removed, 2);
+    const items = await client.lRange('lrem:c3', 0, -1);
+    assert.deepEqual(items, ['a', 'b', 'c']);
+  });
+
+  it('LREM on non-existent key returns 0', async () => {
+    const n = await client.lRem('lrem:c:missing', 1, 'x');
+    assert.equal(n, 0);
+  });
 });

package/test/integration/hashes.test.js

@@ -2,6 +2,7 @@ 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';
 
 describe('Hashes integration', () => {
   let s;
@@ -31,4 +32,28 @@ describe('Hashes integration', () => {
     assert.ok(s.includes('$1\r\nb\r\n'));
     assert.ok(s.includes('$1\r\n2\r\n'));
   });
+
+  it('HLEN returns field count', async () => {
+    await sendCommand(port, argv('HSET', 'hlen:1', 'f1', 'v1', 'f2', 'v2', 'f3', 'v3'));
+    const reply = await sendCommand(port, argv('HLEN', 'hlen:1'));
+    assert.equal(tryParseValue(reply, 0).value, 3);
+  });
+
+  it('HLEN on non-existent key returns 0', async () => {
+    const reply = await sendCommand(port, argv('HLEN', 'hlen:nonexistent'));
+    assert.equal(tryParseValue(reply, 0).value, 0);
+  });
+
+  it('HLEN decreases after HDEL', async () => {
+    await sendCommand(port, argv('HSET', 'hlen:2', 'a', '1', 'b', '2'));
+    await sendCommand(port, argv('HDEL', 'hlen:2', 'a'));
+    const reply = await sendCommand(port, argv('HLEN', 'hlen:2'));
+    assert.equal(tryParseValue(reply, 0).value, 1);
+  });
+
+  it('HLEN on wrong type returns WRONGTYPE', async () => {
+    await sendCommand(port, argv('SET', 'hlen:str', 'value'));
+    const reply = await sendCommand(port, argv('HLEN', 'hlen:str'));
+    assert.ok(reply.toString('utf8').includes('WRONGTYPE'));
+  });
 });

package/test/integration/lists.test.js

@@ -129,4 +129,56 @@ describe('Lists integration', () => {
     assert.equal(parsed[1], 0xff);
     assert.equal(parsed[2], 0x80);
   });
+
+  it('LREM count=0 removes all occurrences', async () => {
+    await sendCommand(port, argv('RPUSH', 'lrem:1', 'a', 'b', 'a', 'c', 'a'));
+    const removed = tryParseValue(await sendCommand(port, argv('LREM', 'lrem:1', '0', 'a')), 0).value;
+    assert.equal(removed, 3);
+    const remaining = tryParseValue(await sendCommand(port, argv('LRANGE', 'lrem:1', '0', '-1')), 0).value;
+    assert.equal(remaining.length, 2);
+    assert.equal(remaining[0].toString('utf8'), 'b');
+    assert.equal(remaining[1].toString('utf8'), 'c');
+  });
+
+  it('LREM count>0 removes from head', async () => {
+    await sendCommand(port, argv('RPUSH', 'lrem:2', 'a', 'b', 'a', 'c', 'a'));
+    const removed = tryParseValue(await sendCommand(port, argv('LREM', 'lrem:2', '2', 'a')), 0).value;
+    assert.equal(removed, 2);
+    const remaining = tryParseValue(await sendCommand(port, argv('LRANGE', 'lrem:2', '0', '-1')), 0).value;
+    assert.equal(remaining.length, 3);
+    assert.equal(remaining[0].toString('utf8'), 'b');
+    assert.equal(remaining[1].toString('utf8'), 'c');
+    assert.equal(remaining[2].toString('utf8'), 'a');
+  });
+
+  it('LREM count<0 removes from tail', async () => {
+    await sendCommand(port, argv('RPUSH', 'lrem:3', 'a', 'b', 'a', 'c', 'a'));
+    const removed = tryParseValue(await sendCommand(port, argv('LREM', 'lrem:3', '-2', 'a')), 0).value;
+    assert.equal(removed, 2);
+    const remaining = tryParseValue(await sendCommand(port, argv('LRANGE', 'lrem:3', '0', '-1')), 0).value;
+    assert.equal(remaining.length, 3);
+    assert.equal(remaining[0].toString('utf8'), 'a');
+    assert.equal(remaining[1].toString('utf8'), 'b');
+    assert.equal(remaining[2].toString('utf8'), 'c');
+  });
+
+  it('LREM on non-existent key returns 0', async () => {
+    const reply = tryParseValue(await sendCommand(port, argv('LREM', 'lrem:none', '1', 'x')), 0).value;
+    assert.equal(reply, 0);
+  });
+
+  it('LREM when no matches returns 0', async () => {
+    await sendCommand(port, argv('RPUSH', 'lrem:4', 'a', 'b', 'c'));
+    const reply = tryParseValue(await sendCommand(port, argv('LREM', 'lrem:4', '1', 'z')), 0).value;
+    assert.equal(reply, 0);
+    const len = tryParseValue(await sendCommand(port, argv('LLEN', 'lrem:4')), 0).value;
+    assert.equal(len, 3);
+  });
+
+  it('LREM removes all elements, key disappears', async () => {
+    await sendCommand(port, argv('RPUSH', 'lrem:5', 'x', 'x', 'x'));
+    await sendCommand(port, argv('LREM', 'lrem:5', '0', 'x'));
+    const lenReply = tryParseValue(await sendCommand(port, argv('LLEN', 'lrem:5')), 0).value;
+    assert.equal(lenReply, 0);
+  });
 });

package/test/unit/engine-hashes.test.js

@@ -34,4 +34,25 @@ describe('Engine hashes', () => {
     engine.hset('cnt', 'n', '10');
     assert.equal(engine.hincrby('cnt', 'n', 5), 15);
   });
+
+  it('HLEN returns number of fields', () => {
+    engine.hset('hlen:u', 'f1', 'v1', 'f2', 'v2', 'f3', 'v3');
+    assert.equal(engine.hlen('hlen:u'), 3);
+  });
+
+  it('HLEN on non-existent key returns 0', () => {
+    assert.equal(engine.hlen('hlen:missing'), 0);
+  });
+
+  it('HLEN decreases when fields are deleted', () => {
+    engine.hset('hlen:dec', 'a', '1', 'b', '2');
+    assert.equal(engine.hlen('hlen:dec'), 2);
+    engine.hdel('hlen:dec', ['a']);
+    assert.equal(engine.hlen('hlen:dec'), 1);
+  });
+
+  it('HLEN throws WRONGTYPE on non-hash key', () => {
+    engine.set('hlen:str', 'value');
+    assert.throws(() => engine.hlen('hlen:str'), /WRONGTYPE/);
+  });
 });

package/test/unit/engine-lists.test.js

@@ -0,0 +1,73 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { createEngine } from '../../src/engine/engine.js';
+import { openDb } from '../../src/storage/sqlite/db.js';
+import { tmpDbPath } from '../helpers/tmp.js';
+
+describe('Engine lists', () => {
+  const dbPath = tmpDbPath();
+  const db = openDb(dbPath);
+  const engine = createEngine({ db });
+
+  it('LPUSH and LLEN', () => {
+    engine.lpush('mylist', 'a', 'b', 'c');
+    assert.equal(engine.llen('mylist'), 3);
+  });
+
+  it('LRANGE returns elements in order', () => {
+    const items = engine.lrange('mylist', 0, -1).map((v) => v.toString());
+    assert.deepEqual(items, ['c', 'b', 'a']);
+  });
+
+  it('LREM count=0 removes all occurrences', () => {
+    engine.rpush('lrem1', 'a', 'b', 'a', 'c', 'a');
+    const n = engine.lrem('lrem1', 0, 'a');
+    assert.equal(n, 3);
+    const items = engine.lrange('lrem1', 0, -1).map((v) => v.toString());
+    assert.deepEqual(items, ['b', 'c']);
+  });
+
+  it('LREM count>0 removes from head', () => {
+    engine.rpush('lrem2', 'a', 'b', 'a', 'c', 'a');
+    const n = engine.lrem('lrem2', 2, 'a');
+    assert.equal(n, 2);
+    const items = engine.lrange('lrem2', 0, -1).map((v) => v.toString());
+    assert.deepEqual(items, ['b', 'c', 'a']);
+  });
+
+  it('LREM count<0 removes from tail', () => {
+    engine.rpush('lrem3', 'a', 'b', 'a', 'c', 'a');
+    const n = engine.lrem('lrem3', -2, 'a');
+    assert.equal(n, 2);
+    const items = engine.lrange('lrem3', 0, -1).map((v) => v.toString());
+    assert.deepEqual(items, ['a', 'b', 'c']);
+  });
+
+  it('LREM on non-existent key returns 0', () => {
+    assert.equal(engine.lrem('lrem:missing', 1, 'x'), 0);
+  });
+
+  it('LREM with no matches returns 0 and list is unchanged', () => {
+    engine.rpush('lrem4', 'x', 'y', 'z');
+    assert.equal(engine.lrem('lrem4', 1, 'nope'), 0);
+    assert.equal(engine.llen('lrem4'), 3);
+  });
+
+  it('LREM removes all elements, key disappears', () => {
+    engine.rpush('lrem5', 'x', 'x', 'x');
+    engine.lrem('lrem5', 0, 'x');
+    assert.equal(engine.type('lrem5'), 'none');
+  });
+
+  it('LREM subsequent LRANGE still works correctly', () => {
+    engine.rpush('lrem6', 'a', 'b', 'c', 'b', 'd');
+    engine.lrem('lrem6', 1, 'b');
+    const items = engine.lrange('lrem6', 0, -1).map((v) => v.toString());
+    assert.deepEqual(items, ['a', 'c', 'b', 'd']);
+  });
+
+  it('LREM throws WRONGTYPE on non-list key', () => {
+    engine.set('lrem:str', 'value');
+    assert.throws(() => engine.lrem('lrem:str', 1, 'x'), /WRONGTYPE/);
+  });
+});