resplite 1.4.6 → 1.4.10

package/package.json

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

package/skills/{resplite-command-vertical-slice → resplite}/SKILL.md

@@ -1,12 +1,9 @@
 ---
-name: resplite-command-vertical-slice
+name: resplite
 description: Implements or extends a Redis-like command in RESPLite from spec to docs and tests. Use when the user says "add a command", "support a Redis option", "fix command compatibility", "implement ZRANGE behavior", or "update the compatibility matrix". Do not use for migration-only or FT-only work unless the change also affects the general command surface.
-license: MIT
 metadata:
-  author: Cursor Agent
-  version: 1.0.0
   category: workflow-automation
-  tags: [resplite, redis-compatibility, commands, tests]
+  tags: [resplite, redis, commands, tests]
 ---
 
 # RESPLite Command Vertical Slice

package/skills/{resplite-ft-search-workbench → resplite-ft-search}/SKILL.md

@@ -1,10 +1,7 @@
 ---
-name: resplite-ft-search-workbench
+name: resplite-ft-search
 description: Builds or refines RESPLite `FT.*` behavior and RediSearch migration mapping on top of SQLite FTS5. Use when the user says "add FT command support", "fix FT.SEARCH", "adjust SQLite FTS5 behavior", "migrate RediSearch indices", or "work on FT.CREATE or FT.ADD semantics". Do not use for unrelated command work outside the search surface.
-license: MIT
 metadata:
-  author: Cursor Agent
-  version: 1.0.0
   category: workflow-automation
   tags: [resplite, search, redisearch, sqlite, fts5]
 ---

package/skills/{resplite-migration-cutover-assistant → resplite-migration}/SKILL.md

@@ -1,10 +1,7 @@
 ---
-name: resplite-migration-cutover-assistant
+name: resplite-migration
 description: Guides Redis to RESPLite migration work using the programmatic migration API, dirty-key tracking, cutover, and verification. Use when the user says "migrate Redis", "dirty tracker", "cutover", "resume bulk import", "verify migration", or "move RediSearch data during migration". Do not use for generic command work that does not touch the migration flow.
-license: MIT
 metadata:
-  author: Cursor Agent
-  version: 1.0.0
   category: workflow-automation
   tags: [resplite, migration, redis, cutover, verification]
 ---

package/src/commands/score-bounds.js

@@ -0,0 +1,15 @@
+/**
+ * Parse score bound used by sorted-set score range commands.
+ * Supports Redis-style infinities: -inf, +inf, inf.
+ *
+ * @param {Buffer|string|number} raw
+ * @returns {number|null}
+ */
+export function parseScoreBound(raw) {
+  const s = Buffer.isBuffer(raw) ? raw.toString('utf8') : String(raw);
+  const lower = s.toLowerCase();
+  if (lower === '-inf') return Number.NEGATIVE_INFINITY;
+  if (lower === '+inf' || lower === 'inf') return Number.POSITIVE_INFINITY;
+  const n = parseFloat(s);
+  return Number.isNaN(n) ? null : n;
+}

package/src/commands/zcount.js

@@ -2,14 +2,16 @@
  * ZCOUNT key min max - returns count of members in sorted set with score in [min, max].
  */
 
+import { parseScoreBound } from './score-bounds.js';
+
 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)) {
+    const min = parseScoreBound(args[1]);
+    const max = parseScoreBound(args[2]);
+    if (min == null || max == null) {
       return { error: 'ERR value is not a valid float' };
     }
     const n = engine.zcount(args[0], min, max);

package/src/commands/zrangebyscore.js

@@ -2,6 +2,8 @@
  * ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
  */
 
+import { parseScoreBound } from './score-bounds.js';
+
 export function handleZrangebyscore(engine, args) {
   if (!args || args.length < 3) {
     return { error: 'ERR wrong number of arguments for \'ZRANGEBYSCORE\' command' };
@@ -25,9 +27,9 @@ export function handleZrangebyscore(engine, args) {
     }
   }
   try {
-    const min = parseFloat(String(args[1]));
-    const max = parseFloat(String(args[2]));
-    if (Number.isNaN(min) || Number.isNaN(max)) {
+    const min = parseScoreBound(args[1]);
+    const max = parseScoreBound(args[2]);
+    if (min == null || max == null) {
       return { error: 'ERR value is not a valid float' };
     }
     const options = { withScores };

package/src/commands/zremrangebyscore.js

@@ -2,14 +2,16 @@
  * ZREMRANGEBYSCORE key min max - removes members with score in [min, max]. Returns count removed.
  */
 
+import { parseScoreBound } from './score-bounds.js';
+
 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)) {
+    const min = parseScoreBound(args[1]);
+    const max = parseScoreBound(args[2]);
+    if (min == null || max == null) {
       return { error: 'ERR value is not a valid float' };
     }
     const n = engine.zremrangebyscore(args[0], min, max);

package/src/commands/zrevrangebyscore.js

@@ -4,6 +4,8 @@
  * Note: Redis uses max min (first score is upper bound, second is lower bound).
  */
 
+import { parseScoreBound } from './score-bounds.js';
+
 export function handleZrevrangebyscore(engine, args) {
   if (!args || args.length < 3) {
     return { error: 'ERR wrong number of arguments for \'ZREVRANGEBYSCORE\' command' };
@@ -27,9 +29,9 @@ export function handleZrevrangebyscore(engine, args) {
     }
   }
   try {
-    const max = parseFloat(String(args[1]));
-    const min = parseFloat(String(args[2]));
-    if (Number.isNaN(max) || Number.isNaN(min)) {
+    const max = parseScoreBound(args[1]);
+    const min = parseScoreBound(args[2]);
+    if (max == null || min == null) {
       return { error: 'ERR value is not a valid float' };
     }
     const options = { withScores };

package/src/engine/engine.js

@@ -569,6 +569,7 @@ export function createEngine(opts = {}) {
         if (keys.get(nk)) keys.delete(nk);
         keys.set(nk, meta.type, {
           expiresAt: meta.expiresAt,
+          setCount: meta.type === KEY_TYPES.SET ? meta.setCount : undefined,
           hashCount: meta.type === KEY_TYPES.HASH ? meta.hashCount : undefined,
           zsetCount: meta.type === KEY_TYPES.ZSET ? meta.zsetCount : undefined,
         });

package/src/storage/sqlite/keys.js

@@ -9,16 +9,22 @@ import { KEY_TYPES } from './schema.js';
  */
 export function createKeysStorage(db) {
   const getByKey = db.prepare(
-    'SELECT key, type, expires_at AS expiresAt, hash_count AS hashCount, zset_count AS zsetCount, version, updated_at AS updatedAt FROM redis_keys WHERE key = ?'
+    'SELECT key, type, expires_at AS expiresAt, set_count AS setCount, hash_count AS hashCount, zset_count AS zsetCount, version, updated_at AS updatedAt FROM redis_keys WHERE key = ?'
   );
   const insert = db.prepare(
-    `INSERT INTO redis_keys (key, type, expires_at, hash_count, zset_count, version, updated_at) VALUES (?, ?, ?, ?, ?, 1, ?)`
+    `INSERT INTO redis_keys (key, type, expires_at, set_count, hash_count, zset_count, version, updated_at) VALUES (?, ?, ?, ?, ?, ?, 1, ?)`
   );
   const updateMeta = db.prepare(
-    'UPDATE redis_keys SET type = ?, expires_at = ?, hash_count = ?, zset_count = ?, version = version + 1, updated_at = ? WHERE key = ?'
+    'UPDATE redis_keys SET type = ?, expires_at = ?, set_count = ?, hash_count = ?, zset_count = ?, version = version + 1, updated_at = ? WHERE key = ?'
   );
   const updateExpires = db.prepare('UPDATE redis_keys SET expires_at = ?, updated_at = ? WHERE key = ?');
   const updateVersion = db.prepare('UPDATE redis_keys SET version = version + 1, updated_at = ? WHERE key = ?');
+  const updateSetCount = db.prepare('UPDATE redis_keys SET set_count = ?, updated_at = ? WHERE key = ?');
+  const updateSetCountOnly = db.prepare('UPDATE redis_keys SET set_count = ? WHERE key = ?');
+  const incrSetCount = db.prepare(
+    'UPDATE redis_keys SET set_count = COALESCE(set_count, 0) + ?, updated_at = ? WHERE key = ?'
+  );
+  const incrSetCountOnly = db.prepare('UPDATE redis_keys SET set_count = COALESCE(set_count, 0) + ? WHERE key = ?');
   const updateHashCount = db.prepare('UPDATE redis_keys SET hash_count = ?, updated_at = ? WHERE key = ?');
   const updateHashCountOnly = db.prepare('UPDATE redis_keys SET hash_count = ? WHERE key = ?');
   const incrHashCount = db.prepare(
@@ -50,6 +56,9 @@ export function createKeysStorage(db) {
       const now = options.updatedAt ?? Date.now();
       const expiresAt = options.expiresAt ?? null;
       const existing = getByKey.get(key);
+      const setCount = type === KEY_TYPES.SET
+        ? (options.setCount ?? existing?.setCount ?? 0)
+        : null;
       const hashCount = type === KEY_TYPES.HASH
         ? (options.hashCount ?? existing?.hashCount ?? 0)
         : null;
@@ -57,9 +66,9 @@ export function createKeysStorage(db) {
         ? (options.zsetCount ?? existing?.zsetCount ?? 0)
         : null;
       if (existing) {
-        updateMeta.run(type, expiresAt, hashCount, zsetCount, now, key);
+        updateMeta.run(type, expiresAt, setCount, hashCount, zsetCount, now, key);
       } else {
-        insert.run(key, type, expiresAt, hashCount, zsetCount, now);
+        insert.run(key, type, expiresAt, setCount, hashCount, zsetCount, now);
       }
     },
 
@@ -71,6 +80,24 @@ export function createKeysStorage(db) {
       updateVersion.run(Date.now(), key);
     },
 
+    setSetCount(key, setCount, options = {}) {
+      const touchUpdatedAt = options.touchUpdatedAt !== false;
+      if (touchUpdatedAt) {
+        updateSetCount.run(setCount, options.updatedAt ?? Date.now(), key);
+      } else {
+        updateSetCountOnly.run(setCount, key);
+      }
+    },
+
+    incrSetCount(key, delta, options = {}) {
+      const touchUpdatedAt = options.touchUpdatedAt !== false;
+      if (touchUpdatedAt) {
+        incrSetCount.run(delta, options.updatedAt ?? Date.now(), key);
+      } else {
+        incrSetCountOnly.run(delta, key);
+      }
+    },
+
     setHashCount(key, hashCount, options = {}) {
       const touchUpdatedAt = options.touchUpdatedAt !== false;
       if (touchUpdatedAt) {

package/src/storage/sqlite/schema.js

@@ -7,6 +7,7 @@ CREATE TABLE IF NOT EXISTS redis_keys (
   key BLOB PRIMARY KEY,
   type INTEGER NOT NULL,
   expires_at INTEGER,
+  set_count INTEGER,
   hash_count INTEGER,
   zset_count INTEGER,
   version INTEGER NOT NULL DEFAULT 1,
@@ -90,8 +91,12 @@ export function applySchema(db) {
   db.exec(SCHEMA);
   // Backward-compatible migration for databases created before count columns existed.
   const cols = db.prepare('PRAGMA table_info(redis_keys)').all();
+  const hasSetCount = cols.some((c) => c.name === 'set_count');
   const hasHashCount = cols.some((c) => c.name === 'hash_count');
   const hasZsetCount = cols.some((c) => c.name === 'zset_count');
+  if (!hasSetCount) {
+    db.exec('ALTER TABLE redis_keys ADD COLUMN set_count INTEGER;');
+  }
   if (!hasHashCount) {
     db.exec('ALTER TABLE redis_keys ADD COLUMN hash_count INTEGER;');
   }

package/src/storage/sqlite/search.js

@@ -209,21 +209,64 @@ export function deleteDocument(db, idx, docId) {
 }
 
 /**
- * Validate and build FTS5 MATCH expression. D.13.2: allow tokens [A-Za-z0-9_]+ optionally ending with *
- * Reject chars that break MATCH: " ' : ( ) [ ] { } \ and non-printable.
+ * Build a safe FTS5 MATCH expression from user query.
+ *
+ * We intentionally normalize punctuation so query tokenization is flexible and
+ * closer to Redis/RediSearch behavior for common free-text searches:
+ * - punctuation like ".", "#", "+", "/", ",", "(", ")" acts as separators
+ * - "?" is ignored as punctuation
+ * - "-" inside terms acts as separator (hello-world -> hello world)
+ * - "-term" (leading minus) maps to boolean NOT term
+ * - "@" and ":" are treated as unsupported query syntax and return syntax error
+ *
+ * Supported term chars are unicode letters/digits plus underscore, with
+ * optional trailing "*" for prefix queries.
+ *
+ * Reject control characters and unsafe MATCH breakers: " ' \ and non-printable.
  * @param {string} query
- * @returns {string} - Safe MATCH expression e.g. "martin clasen*"
+ * @returns {string} - Safe MATCH expression e.g. "martin NOT clasen*"
  */
 function buildMatchExpression(query) {
   if (typeof query !== 'string') throw new Error('ERR invalid query');
   const trimmed = query.trim();
   if (trimmed === '') throw new Error('ERR invalid query');
-  if (/["':()\[\]{}\\]/.test(query) || /[\x00-\x1f]/.test(query)) throw new Error('ERR invalid query');
-  const tokens = trimmed.split(/\s+/).filter(Boolean);
-  for (const t of tokens) {
-    if (!/^[A-Za-z0-9_]*\*?$/.test(t)) throw new Error('ERR invalid query');
+  if (/[\x00-\x1f]/.test(query) || /["'\\]/.test(query)) throw new Error('ERR invalid query');
+  if (query.includes('@') || query.includes(':')) throw new Error('ERR syntax error');
+
+  const normalized = trimmed
+    .replace(/\?/g, '')
+    .replace(/[^\p{L}\p{N}_*\-\s]+/gu, ' ')
+    .trim();
+  const rawTokens = normalized.split(/\s+/).filter(Boolean);
+  if (rawTokens.length === 0) throw new Error('ERR invalid query');
+
+  const termRe = /^[\p{L}\p{N}_]+\*?$/u;
+  const tokens = [];
+
+  for (const raw of rawTokens) {
+    if (raw.startsWith('-')) {
+      const neg = raw.slice(1);
+      if (!neg || neg.includes('-') || !termRe.test(neg)) throw new Error('ERR invalid query');
+      tokens.push('NOT', neg);
+      continue;
+    }
+    const segments = raw.split('-').filter(Boolean);
+    if (segments.length === 0) throw new Error('ERR invalid query');
+    for (const seg of segments) {
+      if (!termRe.test(seg)) throw new Error('ERR invalid query');
+      tokens.push(seg);
+    }
+  }
+
+  for (let i = 0; i < tokens.length; i += 1) {
+    if (tokens[i] === 'NOT') {
+      if (i === 0 || i === tokens.length - 1 || tokens[i + 1] === 'NOT') {
+        throw new Error('ERR invalid query');
+      }
+    }
   }
-  return trimmed;
+
+  return tokens.join(' ');
 }
 
 /**

package/src/storage/sqlite/sets.js

@@ -22,34 +22,52 @@ export function createSetsStorage(db, keys) {
       return runInTransaction(db, () => {
         const now = options.updatedAt ?? Date.now();
         const meta = keys.get(key);
+        let knownCount = 0;
         if (meta) {
           if (meta.type !== KEY_TYPES.SET) {
             throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
           }
           keys.bumpVersion(key);
+          if (meta.setCount == null) {
+            const row = countStmt.get(key);
+            knownCount = (row && row.n) || 0;
+            keys.setSetCount(key, knownCount, { touchUpdatedAt: false });
+          } else {
+            knownCount = meta.setCount;
+          }
         } else {
-          keys.set(key, KEY_TYPES.SET, { updatedAt: now });
+          keys.set(key, KEY_TYPES.SET, { updatedAt: now, setCount: 0 });
         }
         let added = 0;
         for (const m of members) {
           const r = insertStmt.run(key, m);
           if (r.changes > 0) added++;
         }
+        if (added > 0) {
+          if (meta) keys.incrSetCount(key, added, { touchUpdatedAt: false });
+          else keys.setSetCount(key, added, { touchUpdatedAt: false });
+        } else if (meta && meta.setCount == null) {
+          // Legacy rows may have null counters; persist hydrated value.
+          keys.setSetCount(key, knownCount, { touchUpdatedAt: false });
+        }
         return added;
       });
     },
 
     remove(key, members) {
       return runInTransaction(db, () => {
+        const meta = keys.get(key);
+        const before = meta && meta.setCount != null ? meta.setCount : null;
         let n = 0;
         for (const m of members) {
           n += deleteStmt.run(key, m).changes;
         }
-        const row = countStmt.get(key);
-        const remaining = (row && row.n) || 0;
+        const remaining = before != null ? Math.max(0, before - n) : ((countStmt.get(key) || {}).n || 0);
         if (remaining === 0) {
           deleteAllStmt.run(key);
           keys.delete(key);
+        } else if (n > 0) {
+          keys.setSetCount(key, remaining, { touchUpdatedAt: false });
         }
         return n;
       });
@@ -65,8 +83,17 @@ export function createSetsStorage(db, keys) {
     },
 
     count(key) {
+      const meta = keys.get(key);
+      if (meta && meta.type === KEY_TYPES.SET && meta.setCount != null) {
+        return meta.setCount;
+      }
       const row = countStmt.get(key);
-      return row ? row.n : 0;
+      const n = row ? row.n : 0;
+      if (meta && meta.type === KEY_TYPES.SET && meta.setCount == null) {
+        // One-time hydration for databases created before set_count existed.
+        keys.setSetCount(key, n, { touchUpdatedAt: false });
+      }
+      return n;
     },
 
     /** Copy all members from oldKey to newKey. Caller ensures newKey exists in redis_keys. */
@@ -75,6 +102,9 @@ export function createSetsStorage(db, keys) {
       for (const r of rows) {
         insertStmt.run(newKey, r.member);
       }
+      const sourceMeta = keys.get(oldKey);
+      const nextCount = sourceMeta && sourceMeta.setCount != null ? sourceMeta.setCount : rows.length;
+      keys.setSetCount(newKey, nextCount, { touchUpdatedAt: false });
     },
 
     /** Get random members without removing. count null/1 = single; count > 0 = up to count distinct; count < 0 = |count| with replacement. */
@@ -117,13 +147,13 @@ export function createSetsStorage(db, keys) {
           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;
+        const remaining = arr.length - chosen.length;
         if (remaining === 0) {
           deleteAllStmt.run(key);
           keys.delete(key);
         } else {
           keys.bumpVersion(key);
+          keys.setSetCount(key, remaining, { touchUpdatedAt: false });
         }
         return c === 1 ? chosen[0] : chosen;
       });

package/src/storage/sqlite/zsets.js

@@ -315,6 +315,9 @@ export function createZsetsStorage(db, keys) {
     },
 
     countByScore(key, min, max) {
+      if (min === Number.NEGATIVE_INFINITY && max === Number.POSITIVE_INFINITY) {
+        return this.count(key);
+      }
       const row = countByScoreStmt.get(key, min, max);
       return row ? row.n : 0;
     },

package/test/integration/search.test.js

@@ -55,6 +55,72 @@ describe('Search integration', () => {
     assert.ok(arr[0] >= 0);
   });
 
+  it('FT.SEARCH dotted prefix query works', async () => {
+    const ok = await sendCommand(
+      port,
+      argv('FT.ADD', 'names', 'MAIL1', '1', 'REPLACE', 'FIELDS', 'payload', 'martin clasen martin.clasen@gmail.com')
+    );
+    assert.equal(tryParseValue(ok, 0).value, 'OK');
+
+    const reply = await sendCommand(port, argv('FT.SEARCH', 'names', 'martin.clasen*', 'NOCONTENT', 'LIMIT', '0', '10'));
+    const arr = tryParseValue(reply, 0).value;
+    assert.ok(Array.isArray(arr));
+    assert.ok(arr[0] >= 1);
+    const docIds = arr.slice(1).map((v) => (v?.toString ? v.toString('utf8') : String(v)));
+    assert.ok(docIds.includes('MAIL1'));
+  });
+
+  it('FT.SEARCH handles punctuation tokenization flexibly', async () => {
+    const ok = await sendCommand(
+      port,
+      argv(
+        'FT.ADD',
+        'names',
+        'CHARS1',
+        '1',
+        'REPLACE',
+        'FIELDS',
+        'payload',
+        'martin-clasen martin@clasen.com #martin who? alpha+beta foo/bar baz,qux'
+      )
+    );
+    assert.equal(tryParseValue(ok, 0).value, 'OK');
+
+    for (const q of ['who?', 'alpha+beta', 'foo/bar', 'baz,qux', '(martin)', '#martin*']) {
+      const reply = await sendCommand(port, argv('FT.SEARCH', 'names', q, 'NOCONTENT', 'LIMIT', '0', '10'));
+      const arr = tryParseValue(reply, 0).value;
+      assert.ok(Array.isArray(arr));
+      const docIds = arr.slice(1).map((v) => (v?.toString ? v.toString('utf8') : String(v)));
+      assert.ok(docIds.includes('CHARS1'));
+    }
+  });
+
+  it('FT.SEARCH keeps Redis-like syntax errors for @ and :', async () => {
+    const atReply = await sendCommand(port, argv('FT.SEARCH', 'names', 'martin@clasen*', 'NOCONTENT'));
+    const atVal = tryParseValue(atReply, 0).value;
+    const atErr = String(atVal?.error ?? atVal);
+    assert.ok(atErr.includes('syntax error'));
+
+    const colonReply = await sendCommand(port, argv('FT.SEARCH', 'names', 'martin:clasen', 'NOCONTENT'));
+    const colonVal = tryParseValue(colonReply, 0).value;
+    const colonErr = String(colonVal?.error ?? colonVal);
+    assert.ok(colonErr.includes('syntax error'));
+  });
+
+  it('FT.SEARCH treats hyphen inside term as separator', async () => {
+    const reply = await sendCommand(port, argv('FT.SEARCH', 'names', 'martin-clasen*', 'NOCONTENT', 'LIMIT', '0', '10'));
+    const arr = tryParseValue(reply, 0).value;
+    assert.ok(Array.isArray(arr));
+    assert.ok(arr[0] >= 1);
+  });
+
+  it('FT.SEARCH keeps NOT semantics for leading minus', async () => {
+    const reply = await sendCommand(port, argv('FT.SEARCH', 'names', 'martin -clasen*', 'NOCONTENT', 'LIMIT', '0', '10'));
+    const arr = tryParseValue(reply, 0).value;
+    assert.ok(Array.isArray(arr));
+    assert.equal(arr[0], 0);
+  });
+
   it('FT.SEARCH LIMIT applies', async () => {
     const reply = await sendCommand(port, argv('FT.SEARCH', 'names', 'martin', 'NOCONTENT', 'LIMIT', '0', '1'));
     const arr = tryParseValue(reply, 0).value;

package/test/integration/sets.test.js

@@ -1,7 +1,9 @@
 import { describe, it, before, after } from 'node:test';
 import assert from 'node:assert/strict';
+import Database from 'better-sqlite3';
 import { createTestServer } from '../helpers/server.js';
 import { sendCommand, argv } from '../helpers/client.js';
+import { tryParseValue } from '../../src/resp/parser.js';
 
 describe('Sets integration', () => {
   let s;
@@ -24,4 +26,79 @@ describe('Sets integration', () => {
     assert.ok(s.includes('$1\r\nb\r\n'));
     assert.ok(s.includes('$1\r\nc\r\n'));
   });
+
+  it('SCARD returns member count', async () => {
+    await sendCommand(port, argv('SADD', 'scard:1', 'a', 'b', 'c'));
+    const reply = await sendCommand(port, argv('SCARD', 'scard:1'));
+    assert.equal(tryParseValue(reply, 0).value, 3);
+  });
+
+  it('SCARD on non-existent key returns 0', async () => {
+    const reply = await sendCommand(port, argv('SCARD', 'scard:none'));
+    assert.equal(tryParseValue(reply, 0).value, 0);
+  });
+
+  it('SCARD decreases after SREM', async () => {
+    await sendCommand(port, argv('SADD', 'scard:2', 'x', 'y'));
+    await sendCommand(port, argv('SREM', 'scard:2', 'x'));
+    const reply = await sendCommand(port, argv('SCARD', 'scard:2'));
+    assert.equal(tryParseValue(reply, 0).value, 1);
+  });
+
+  it('RENAME keeps set cardinality metadata', async () => {
+    await sendCommand(port, argv('SADD', 'srename:src', 'm1', 'm2', 'm3'));
+    await sendCommand(port, argv('RENAME', 'srename:src', 'srename:dst'));
+    const reply = await sendCommand(port, argv('SCARD', 'srename:dst'));
+    assert.equal(tryParseValue(reply, 0).value, 3);
+  });
+
+  it('concurrent SADD of same member is idempotent', async () => {
+    const key = `scon:sadd:${Date.now()}`;
+    const N = 25;
+    const replies = await Promise.all(Array.from({ length: N }, () => sendCommand(port, argv('SADD', key, 'x'))));
+    const addedCounts = replies.map((reply) => tryParseValue(reply, 0).value);
+    const firstAdds = addedCounts.filter((n) => n === 1).length;
+    const duplicateAdds = addedCounts.filter((n) => n === 0).length;
+    assert.equal(firstAdds, 1);
+    assert.equal(duplicateAdds, N - 1);
+    const card = await sendCommand(port, argv('SCARD', key));
+    assert.equal(tryParseValue(card, 0).value, 1);
+  });
+
+  it('concurrent SPOP returns unique members and drains set', async () => {
+    const key = `scon:spop:${Date.now()}`;
+    const members = Array.from({ length: 24 }, (_, i) => `m${i}`);
+    await sendCommand(port, argv('SADD', key, ...members));
+    const poppedRaw = await Promise.all(Array.from({ length: members.length }, () => sendCommand(port, argv('SPOP', key))));
+    const popped = poppedRaw.map((reply) => {
+      const parsed = tryParseValue(reply, 0);
+      return parsed.value === null ? null : parsed.value.toString('utf8');
+    });
+    assert.equal(popped.includes(null), false);
+    assert.equal(new Set(popped).size, members.length);
+    const card = await sendCommand(port, argv('SCARD', key));
+    assert.equal(tryParseValue(card, 0).value, 0);
+  });
+
+  it('legacy set rows with null set_count hydrate on first SCARD', async () => {
+    const s1 = await createTestServer();
+    await sendCommand(s1.port, argv('SADD', 'legacy:s', 'a', 'b'));
+    const dbPath = s1.dbPath;
+    await s1.closeAsync();
+    s1.db.close();
+
+    const legacyDb = new Database(dbPath);
+    legacyDb.prepare('UPDATE redis_keys SET set_count = NULL WHERE key = ?').run(Buffer.from('legacy:s', 'utf8'));
+    legacyDb.close();
+
+    const s2 = await createTestServer({ dbPath });
+    const first = await sendCommand(s2.port, argv('SCARD', 'legacy:s'));
+    assert.equal(tryParseValue(first, 0).value, 2);
+    const second = await sendCommand(s2.port, argv('SCARD', 'legacy:s'));
+    assert.equal(tryParseValue(second, 0).value, 2);
+
+    const row = s2.db.prepare('SELECT set_count AS n FROM redis_keys WHERE key = ?').get(Buffer.from('legacy:s', 'utf8'));
+    assert.equal(row.n, 2);
+    await s2.closeAsync();
+  });
 });

package/test/integration/zsets.test.js

@@ -159,6 +159,37 @@ describe('ZSET integration', () => {
     assert.equal(limited[1].toString('utf8'), 'c');
   });
 
+  it('ZCOUNT supports numeric ranges and full-range infinities', async () => {
+    await sendCommand(port, argv('ZADD', 'zc1', '1', 'a', '2', 'b', '3', 'c', '4', 'd'));
+
+    const mid = await sendCommand(port, argv('ZCOUNT', 'zc1', '2', '3'));
+    assert.equal(tryParseValue(mid, 0).value, 2);
+
+    const all = await sendCommand(port, argv('ZCOUNT', 'zc1', '-inf', '+inf'));
+    assert.equal(tryParseValue(all, 0).value, 4);
+  });
+
+  it('score-range commands accept -inf/+inf bounds', async () => {
+    await sendCommand(port, argv('ZADD', 'zinf', '1', 'a', '2', 'b', '3', 'c', '4', 'd'));
+
+    const rangeAll = await sendCommand(port, argv('ZRANGEBYSCORE', 'zinf', '-inf', '+inf'));
+    const rAll = tryParseValue(rangeAll, 0).value;
+    assert.equal(rAll.length, 4);
+    assert.equal(rAll[0].toString('utf8'), 'a');
+    assert.equal(rAll[3].toString('utf8'), 'd');
+
+    const revAll = await sendCommand(port, argv('ZREVRANGEBYSCORE', 'zinf', '+inf', '-inf'));
+    const rvAll = tryParseValue(revAll, 0).value;
+    assert.equal(rvAll.length, 4);
+    assert.equal(rvAll[0].toString('utf8'), 'd');
+    assert.equal(rvAll[3].toString('utf8'), 'a');
+
+    const removed = await sendCommand(port, argv('ZREMRANGEBYSCORE', 'zinf', '-inf', '+inf'));
+    assert.equal(tryParseValue(removed, 0).value, 4);
+    const card = await sendCommand(port, argv('ZCARD', 'zinf'));
+    assert.equal(tryParseValue(card, 0).value, 0);
+  });
+
   it('ZCARD non-existent returns 0, ZSCORE non-existent returns nil', async () => {
     const cardReply = await sendCommand(port, argv('ZCARD', 'nonexistent_z'));
     assert.equal(tryParseValue(cardReply, 0).value, 0);

package/test/unit/search.test.js

@@ -92,9 +92,43 @@ describe('Search layer', () => {
     assert.ok(Array.isArray(r.docIds));
   });
 
+  it('search dotted prefix query works', () => {
+    addDocument(db, 'names', 'mail1', 1, true, { payload: 'martin clasen martin.clasen@gmail.com' });
+    const r = search(db, 'names', 'martin.clasen*', { noContent: true });
+    assert.ok(r.total >= 1);
+    assert.ok(r.docIds.includes('mail1'));
+  });
+
+  it('search tokenization stays flexible across punctuation', () => {
+    addDocument(db, 'names', 'chars1', 1, true, {
+      payload: 'martin-clasen martin@clasen.com #martin who? alpha+beta foo/bar baz,qux',
+    });
+    assert.ok(search(db, 'names', 'who?', { noContent: true }).docIds.includes('chars1'));
+    assert.ok(search(db, 'names', 'alpha+beta', { noContent: true }).docIds.includes('chars1'));
+    assert.ok(search(db, 'names', 'foo/bar', { noContent: true }).docIds.includes('chars1'));
+    assert.ok(search(db, 'names', 'baz,qux', { noContent: true }).docIds.includes('chars1'));
+    assert.ok(search(db, 'names', '(martin)', { noContent: true }).docIds.includes('chars1'));
+    assert.ok(search(db, 'names', '#martin*', { noContent: true }).docIds.includes('chars1'));
+  });
+
+  it('search hyphen inside term is treated as separator', () => {
+    addDocument(db, 'names', 'hyphen1', 1, true, { payload: 'martin clasen' });
+    const r = search(db, 'names', 'martin-clasen*', { noContent: true });
+    assert.ok(r.total >= 1);
+    assert.ok(r.docIds.includes('hyphen1'));
+  });
+
+  it('search leading minus uses NOT operator semantics', () => {
+    addDocument(db, 'names', 'neg1', 1, true, { payload: 'martin clasen' });
+    const r = search(db, 'names', 'martin -clasen*', { noContent: true });
+    assert.equal(r.total, 0);
+  });
+
   it('search invalid query throws', () => {
     assert.throws(() => search(db, 'names', ''), /invalid query/);
     assert.throws(() => search(db, 'names', 'foo"bar'), /invalid query/);
+    assert.throws(() => search(db, 'names', 'martin@clasen*'), /syntax error/);
+    assert.throws(() => search(db, 'names', 'martin:clasen'), /syntax error/);
   });
 
   it('suggestionAdd returns 1 on insert, 0 on update', () => {