jsql-neo 5.1.1 → 5.2.0

package/README.md

@@ -13,8 +13,6 @@
 
 ## Why JSQL-NEO?
 
-My web ： https://jsql.vexify.top/
-
 Most embedded databases make you choose: *native speed*, *portable WASM*, or *a familiar file format*.
 JSQL-NEO gives you **all three in one install** — plus drop-in compatibility with the **two most popular
 database protocols in the world**.

package/index.js

@@ -1,5 +1,5 @@
 /**
- * JSQL-NEO v5.1.1 — Rust-Powered Embedded Database (WASM + HTTP)
+ * JSQL-NEO v5.1.2 — Rust-Powered Embedded Database (WASM + HTTP)
  *
  * @example
  * const jsql = require('jsql-neo');

package/lib/btree.js

@@ -24,6 +24,7 @@ class BTree {
         this._unique = unique;
         this._root = new BTreeNode();
         this._size = 0;
+        this._minKeys = Math.floor(order / 2) - 1;
         this._minDegree = Math.ceil(order / 2);
     }
 
@@ -50,14 +51,17 @@ class BTree {
     }
 
     _insertNonFull(node, key, rowIndex) {
-        let i = node.keys.length - 1;
-
         if (node.leaf) {
             // 查找插入位置
+            let i = node.keys.length - 1;
             while (i >= 0 && key < node.keys[i]) i--;
             i++;
 
             if (i > 0 && node.keys[i - 1] === key) {
+                if (this._unique) {
+                    this._size--;
+                    return;
+                }
                 if (!node.values[i - 1].includes(rowIndex)) {
                     node.values[i - 1].push(rowIndex);
                 }
@@ -68,12 +72,10 @@ class BTree {
             node.keys.splice(i, 0, key);
             node.values.splice(i, 0, [rowIndex]);
         } else {
-            while (i >= 0 && key < node.keys[i]) i--;
-            i++;
-
+            let i = this._route(node, key);
             if (node.children[i] && node.children[i].keys.length === this._order - 1) {
                 this._splitChild(node, i);
-                if (key >= node.keys[i] && i + 1 < node.children.length) i++;
+                i = this._route(node, key);
             }
             this._insertNonFull(node.children[i], key, rowIndex);
         }
@@ -84,23 +86,22 @@ class BTree {
         const newChild = new BTreeNode(child.leaf);
         const mid = Math.floor((this._order - 1) / 2);
 
-        // 右半部分移到新节点
-        newChild.keys = child.keys.splice(mid + 1);
-        newChild.values = child.values.splice(mid + 1);
-
-        // 中间键提升到父节点
         const midKey = child.keys[mid];
         const midVal = child.values[mid];
 
-        // 非叶子节点：移动子节点
-        if (!child.leaf) {
-            newChild.children = child.children.splice(mid + 1);
-        }
-
-        // 叶子节点：维护链表
         if (child.leaf) {
+            // 叶子：右半移到新节点；分隔键保留在左叶（它是真实数据键），父节点只存副本
+            newChild.keys = child.keys.splice(mid + 1);
+            newChild.values = child.values.splice(mid + 1);
             newChild.next = child.next;
             child.next = newChild;
+        } else {
+            // 内部：分隔键提升到父节点并从子节点移除，保持 children = keys + 1
+            newChild.keys = child.keys.splice(mid + 1);
+            newChild.values = child.values.splice(mid + 1);
+            child.keys.splice(mid, 1);
+            child.values.splice(mid, 1);
+            newChild.children = child.children.splice(mid + 1);
         }
 
         parent.keys.splice(index, 0, midKey);
@@ -113,23 +114,28 @@ class BTree {
     // ============================================================
 
     /**
-     * 精确查找
-     * @returns {number[]} 行号数组
+     * 内部节点路由：返回 key 应下降到的子节点下标。
+     * 命中分隔键副本时，根据左子树最大键判定真实数据所在子树
+     * （分隔键副本可能在左子树作为最大值，或在右子树作为最小值）。
+     */
+    _route(node, key) {
+        let i = 0;
+        while (i < node.keys.length && key > node.keys[i]) i++;
+        if (i < node.keys.length && node.keys[i] === key) {
+            return this._getMax(node.children[i]).key === key ? i : i + 1;
+        }
+        return i;
+    }
+
+    /**
+     * 精确查找（始终下探到叶子取真实数据；内部分隔键只是叶子的副本，仅用于导航）
+     * @returns {number[]} 行号数组；未找到时返回空数组
      */
     search(key) {
         let node = this._root;
-        while (node) {
-            let i = 0;
-            while (i < node.keys.length && key > node.keys[i]) i++;
-
-            if (i < node.keys.length && key === node.keys[i]) {
-                return node.values[i];
-            }
-
-            if (node.leaf) break;
-            node = node.children[i];
-        }
-        return [];
+        while (!node.leaf) node = node.children[this._route(node, key)];
+        const i = node.keys.indexOf(key);
+        return i === -1 ? [] : node.values[i];
     }
 
     /**
@@ -209,58 +215,85 @@ class BTree {
     }
 
     _removeFromNode(node, key, rowIndex) {
-        let i = 0;
-        while (i < node.keys.length && key > node.keys[i]) i++;
-
         if (node.leaf) {
-            if (i < node.keys.length && node.keys[i] === key) {
-                const vals = node.values[i].filter(v => v !== rowIndex);
-                if (vals.length === 0) {
-                    node.keys.splice(i, 1);
-                    node.values.splice(i, 1);
-                } else {
-                    node.values[i] = vals;
-                }
+            const i = node.keys.indexOf(key);
+            if (i === -1) return false;
+            if (!node.values[i].includes(rowIndex)) return false;
+            const vals = node.values[i].filter(v => v !== rowIndex);
+            if (vals.length === 0) {
+                node.keys.splice(i, 1);
+                node.values.splice(i, 1);
                 return true;
             }
+            node.values[i] = vals;
             return false;
         }
 
-        if (i < node.keys.length && node.keys[i] === key) {
-            return this._removeFromInternal(node, i, rowIndex);
-        }
+        let i = this._route(node, key);
 
+        // 下降前确保子节点有足够键，避免欠满子节点
+        const child = node.children[i];
+        if (child.keys.length <= this._minKeys) {
+            i = this._rebalanceChild(node, i);
+        }
         return this._removeFromNode(node.children[i], key, rowIndex);
     }
 
-    _removeFromInternal(node, index, rowIndex) {
-        const vals = node.values[index].filter(v => v !== rowIndex);
-        if (vals.length > 0) {
-            node.values[index] = vals;
-            return true;
+    _rebalanceChild(parent, i) {
+        if (i > 0 && parent.children[i - 1].keys.length > this._minKeys) {
+            this._borrowFromLeft(parent, i);
+            return i;
         }
-
-        const leftChild = node.children[index];
-        if (leftChild.keys.length >= this._minDegree) {
-            const pred = this._getMax(leftChild);
-            node.keys[index] = pred.key;
-            node.values[index] = pred.value;
-            this._removeFromNode(leftChild, pred.key, rowIndex);
-            return true;
+        if (i + 1 < parent.children.length && parent.children[i + 1].keys.length > this._minKeys) {
+            this._borrowFromRight(parent, i);
+            return i;
+        }
+        if (i > 0) {
+            this._mergeChildren(parent, i - 1);
+            return i - 1;
         }
+        this._mergeChildren(parent, i);
+        return i;
+    }
 
-        const rightChild = node.children[index + 1];
-        if (rightChild.keys.length >= this._minDegree) {
-            const succ = this._getMin(rightChild);
-            node.keys[index] = succ.key;
-            node.values[index] = succ.value;
-            this._removeFromNode(rightChild, succ.key, rowIndex);
-            return true;
+    _borrowFromLeft(parent, i) {
+        const left = parent.children[i - 1];
+        const right = parent.children[i];
+        if (right.leaf) {
+            // 叶子节点：分隔键是叶子的副本，用被移动的键而非旧分隔键，避免重复
+            const k = left.keys.pop();
+            const v = left.values.pop();
+            right.keys.unshift(k);
+            right.values.unshift(v);
+            parent.keys[i - 1] = k;
+            parent.values[i - 1] = v;
+        } else {
+            right.keys.unshift(parent.keys[i - 1]);
+            right.values.unshift(parent.values[i - 1]);
+            parent.keys[i - 1] = left.keys.pop();
+            parent.values[i - 1] = left.values.pop();
+            right.children.unshift(left.children.pop());
         }
+    }
 
-        const origKey = node.keys[index];
-        this._mergeChildren(node, index);
-        return this._removeFromNode(node.children[index], origKey, rowIndex);
+    _borrowFromRight(parent, i) {
+        const left = parent.children[i];
+        const right = parent.children[i + 1];
+        if (left.leaf) {
+            // 叶子节点：用被移动的键而非旧分隔键，避免重复
+            const k = right.keys.shift();
+            const v = right.values.shift();
+            left.keys.push(k);
+            left.values.push(v);
+            parent.keys[i] = k;
+            parent.values[i] = v;
+        } else {
+            left.keys.push(parent.keys[i]);
+            left.values.push(parent.values[i]);
+            parent.keys[i] = right.keys.shift();
+            parent.values[i] = right.values.shift();
+            left.children.push(right.children.shift());
+        }
     }
 
     _getMax(node) {
@@ -269,19 +302,17 @@ class BTree {
         return { key: node.keys[i], value: node.values[i] };
     }
 
-    _getMin(node) {
-        while (!node.leaf) node = node.children[0];
-        return { key: node.keys[0], value: node.values[0] };
-    }
-
     _mergeChildren(parent, index) {
         const left = parent.children[index];
         const right = parent.children[index + 1];
         const midKey = parent.keys[index];
         const midVal = parent.values[index];
 
-        left.keys.push(midKey);
-        left.values.push(midVal);
+        // 叶子节点：分隔键是叶子的副本（已在 left 或 right 中），不能重复压入
+        if (!left.leaf) {
+            left.keys.push(midKey);
+            left.values.push(midVal);
+        }
         left.keys.push(...right.keys);
         left.values.push(...right.values);
         if (!left.leaf) left.children.push(...right.children);
@@ -297,26 +328,19 @@ class BTree {
     // ============================================================
 
     /**
-     * 获取所有索引条目
+     * 获取所有索引条目（仅叶子数据，分隔键为内部副本，不重复计入）
      */
     entries() {
         const result = [];
-        this._traverse(this._root, result);
-        return result;
-    }
-
-    _traverse(node, result) {
-        if (node.leaf) {
-            for (let i = 0; i < node.keys.length; i++) {
-                result.push({ key: node.keys[i], value: node.values[i] });
-            }
-        } else {
+        let node = this._root;
+        while (node && !node.leaf) node = node.children[0];
+        while (node) {
             for (let i = 0; i < node.keys.length; i++) {
-                this._traverse(node.children[i], result);
                 result.push({ key: node.keys[i], value: node.values[i] });
             }
-            this._traverse(node.children[node.children.length - 1], result);
+            node = node.next;
         }
+        return result;
     }
 
     /**

package/lib/database.js

@@ -20,13 +20,18 @@ const JSQLFormat = require('./jsql_format');
  */
 function parseFieldShorthand(str) {
     const def = { type: str };
-    if (/\bprimary\s+key\b/.test(str)) { def.primaryKey = true; def.type = str.replace(/\bprimary\s+key\b/g, '').trim() || def.type; }
-    if (/\bauto_?increment\b/.test(str)) { def.autoIncrement = true; def.type = str.replace(/\bauto_?increment\b/g, '').trim() || def.type; }
-    if (/\bnot\s+null\b/.test(str)) { def.required = true; def.type = str.replace(/\bnot\s+null\b/g, '').trim() || def.type; }
-    if (/\bunique\b/.test(str)) { def.unique = true; def.type = str.replace(/\bunique\b/g, '').trim() || def.type; }
-    if (/\bdefault\s+(\S+)/.test(str)) {
-        def.default = RegExp.$1.replace(/^['"]|['"]$/g, '');
-        def.type = str.replace(/\bdefault\s+\S+/g, '').trim() || def.type;
+    const strip = (re) => {
+        const next = def.type.replace(re, '').trim();
+        def.type = next || def.type;
+    };
+    if (/\bprimary\s+key\b/i.test(def.type)) { def.primaryKey = true; strip(/\bprimary\s+key\b/gi); }
+    if (/\bauto_?increment\b/i.test(def.type)) { def.autoIncrement = true; strip(/\bauto_?increment\b/gi); }
+    if (/\bnot\s+null\b/i.test(def.type)) { def.required = true; strip(/\bnot\s+null\b/gi); }
+    if (/\bunique\b/i.test(def.type)) { def.unique = true; strip(/\bunique\b/gi); }
+    if (/\bdefault\s+(\S+)/i.test(def.type)) {
+        const m = def.type.match(/\bdefault\s+(\S+)/i);
+        def.default = m[1].replace(/^['"]|['"]$/g, '');
+        strip(/\bdefault\s+\S+/gi);
     }
     return def;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo",
-  "version": "5.1.1",
+  "version": "5.2.0",
   "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
   "main": "index.js",
   "types": "index.d.ts",
@@ -47,6 +47,9 @@
   "scripts": {
     "postinstall": "node postinstall.js",
     "test": "node test/smoke.js",
+    "test:btree": "node test/btree.test.js",
+    "test:regress": "node test/regress-5.1.0.js",
+    "test:all": "node test/smoke.js && node test/coverage.js && node test/regress-5.1.0.js && node test/btree.test.js",
     "test:coverage": "c8 --all --include='lib/**' --exclude='lib/mysql_server.js' --exclude='lib/native_client.js' --exclude='lib/wasm_client.js' --exclude='lib/mysql_compat.js' --exclude='lib/nedb_compat.js' --exclude='lib/plugin.js' --reporter=text --reporter=lcov node test/coverage.js",
     "test:orms": "node examples/orms/run-all.js"
   },

package/test/btree.test.js

@@ -0,0 +1,128 @@
+/*
+ * B-Tree 专项回归测试 — 覆盖 GitHub Issue #3 的三个 bug 及随机混合操作不变量。
+ *   node test/btree.test.js
+ */
+const BTree = require('../lib/btree');
+
+let passed = 0, failed = 0;
+function ok(name, cond, extra) {
+  if (cond) { passed++; }
+  else { failed++; console.log('[FAIL]', name, extra !== undefined ? '-> ' + JSON.stringify(extra) : ''); }
+}
+
+function validate(bt) {
+  const errs = [];
+  (function walk(node) {
+    if (node.leaf) {
+      if (node.children.length !== 0) errs.push('leaf has children');
+      for (let i = 1; i < node.keys.length; i++) if (node.keys[i] <= node.keys[i - 1]) errs.push('leaf unsorted');
+    } else {
+      if (node.children.length !== node.keys.length + 1) errs.push('internal children !== keys+1');
+      for (let i = 1; i < node.keys.length; i++) if (node.keys[i] <= node.keys[i - 1]) errs.push('internal unsorted');
+      node.children.forEach(walk);
+    }
+  })(bt._root);
+  return errs;
+}
+
+/* ---- Issue #3 Bug #1: 删除崩溃 ---- */
+{
+  const bt = new BTree(4);
+  for (let i = 0; i < 20; i++) bt.insert(i, i);
+  const removed = bt.remove(0, 0);
+  ok('issue#3 Bug#1 remove(0,0) no crash', removed === true && bt.search(0).length === 0 && bt.size === 19);
+}
+
+/* ---- Issue #3 Bug #2: entries() 乱序重复 ---- */
+{
+  const bt = new BTree(4);
+  for (let i = 0; i < 20; i++) bt.insert(i, i);
+  const e = bt.entries();
+  let dup = 0, disorder = 0;
+  for (let i = 0; i < e.length; i++) {
+    if (i > 0 && e[i].key <= e[i - 1].key) disorder++;
+    for (let j = i + 1; j < e.length; j++) if (e[i].key === e[j].key) dup++;
+  }
+  ok('issue#3 Bug#2 entries sorted & dedup', e.length === 20 && dup === 0 && disorder === 0, { len: e.length, dup, disorder });
+}
+
+/* ---- Issue #3 Bug #3: 唯一索引返回所有 values ---- */
+{
+  const bt = new BTree(4, true);
+  bt.insert('a', 1); bt.insert('a', 2); bt.insert('a', 3);
+  ok('issue#3 Bug#3 unique search single value', JSON.stringify(bt.search('a')) === '[1]' && bt.size === 1);
+  const n = new BTree(4, false);
+  n.insert('a', 1); n.insert('a', 2); n.insert('b', 5);
+  ok('non-unique accumulates values', JSON.stringify(n.search('a')) === '[1,2]');
+  n.remove('a', 1); n.remove('a', 2); n.remove('a', 3);
+  ok('non-unique remove value keeps key until last', n.search('a').length === 0 && n.size === 1);
+}
+
+/* ---- 多值键删除只影响目标 rowIndex（size 对照 distinct keys） ---- */
+{
+  const bt = new BTree(8);
+  bt.insert('x', 1); bt.insert('x', 2); bt.insert('x', 3);
+  bt.remove('x', 2);
+  ok('multi-value remove one keeps others', JSON.stringify(bt.search('x').sort()) === '[1,3]' && bt.size === 1);
+}
+
+/* ---- 随机顺序插入/删除压力 ---- */
+for (const order of [4, 8, 16, 64]) {
+  for (let trial = 0; trial < 15; trial++) {
+    const bt = new BTree(order);
+    const n = 200;
+    const seq = [...Array(n).keys()];
+    for (let i = n - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [seq[i], seq[j]] = [seq[j], seq[i]]; }
+    for (const k of seq) bt.insert(k, k);
+    const e = validate(bt);
+    ok('o' + order + ' insert invariant t' + trial, e.length === 0, e.slice(0, 2));
+    for (const k of seq) bt.remove(k, k);
+    ok('o' + order + ' full removal t' + trial, bt.size === 0 && bt.entries().length === 0 && validate(bt).length === 0);
+  }
+}
+
+/* ---- 随机混合操作 vs 参考模型 ---- */
+for (let t = 0; t < 25; t++) {
+  const order = [4, 8, 64][t % 3];
+  const bt = new BTree(order);
+  const ref = new Map(); // key -> Set(rowIndex)
+  let okAll = true;
+  for (let op = 0; op < 300; op++) {
+    const k = Math.floor(Math.random() * 40);
+    if (Math.random() < 0.55) {
+      const r = Math.floor(Math.random() * 5);
+      bt.insert(k, r);
+      if (!ref.has(k)) ref.set(k, new Set());
+      ref.get(k).add(r);
+    } else {
+      const r = Math.floor(Math.random() * 5);
+      bt.remove(k, r);
+      if (ref.has(k)) { ref.get(k).delete(r); if (ref.get(k).size === 0) ref.delete(k); }
+    }
+    if (op % 60 === 0) {
+      for (let x = 0; x < 40 && okAll; x++) {
+        const got = bt.search(x);
+        const exp = ref.has(x) ? [...ref.get(x)].sort((a, b) => a - b) : [];
+        const g = got ? [...got].sort((a, b) => a - b) : [];
+        if (JSON.stringify(g) !== JSON.stringify(exp)) okAll = false;
+      }
+      const es = bt.entries();
+      const emap = new Map(es.map(e => [e.key, [...e.value].sort((a, b) => a - b)]));
+      for (const [key, vals] of ref) {
+        const g = emap.get(key);
+        if (!g || JSON.stringify([...vals].sort()) !== JSON.stringify(g)) okAll = false;
+      }
+      const gtExp = [...ref.keys()].filter(k => k > 20).flatMap(k => [...ref.get(k)]).sort((a, b) => a - b);
+      const gt = bt.greaterThan(20).sort((a, b) => a - b);
+      if (JSON.stringify(gt) !== JSON.stringify(gtExp)) okAll = false;
+      const ltExp = [...ref.keys()].filter(k => k < 20).flatMap(k => [...ref.get(k)]).sort((a, b) => a - b);
+      const lt = bt.lessThan(20).sort((a, b) => a - b);
+      if (JSON.stringify(lt) !== JSON.stringify(ltExp)) okAll = false;
+      if (validate(bt).length) okAll = false;
+    }
+  }
+  ok('random mixed t' + t + ' vs reference', okAll && bt.size === ref.size, { size: bt.size, ref: ref.size });
+}
+
+console.log(failed === 0 ? `\nALL ${passed} BTREE TESTS PASSED` : `\n${failed} FAILURES (${passed} passed)`);
+process.exit(failed === 0 ? 0 : 1);

package/test/regress-5.1.0.js

@@ -0,0 +1,271 @@
+/*
+ * Regression tests locking in the bug fixes shipped in 5.1.0 / 5.1.1.
+ * Zero runtime dependencies (uses Node builtins + in-repo libs only).
+ *
+ *   node test/regress-5.1.0.js
+ *
+ * Covers:
+ *   M1 $like regex-escape   M2 removeById(s) index consistency
+ *   M3 B-Tree open intervals  M4 transaction deep-copy snapshot
+ *   M5 swap-pop hash sync   M6 importFromJSON shapes/overwrite
+ *   H1/H3 parseFieldShorthand + ER_DUP_ENTRY
+ *   S1 Redis per-socket AUTH   S2/S4 WebUI CORS & authToken
+ *   S3/S4 MySQL ACL (1044)     S6 mysql_compat pool filename
+ *   N1 CLI --version sync
+ */
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const net = require('net');
+const { execFileSync } = require('child_process');
+
+const ROOT = path.join(__dirname, '..');
+const Database = require(path.join(ROOT, 'lib/database'));
+const BTree = require(path.join(ROOT, 'lib/btree'));
+const migrate = require(path.join(ROOT, 'lib/migrate'));
+const { RedisServer } = require(path.join(ROOT, 'lib/redis_server'));
+const { WebUI } = require(path.join(ROOT, 'lib/web_ui'));
+const { MysqlServer } = require(path.join(ROOT, 'lib/mysql_server'));
+const compat = require(path.join(ROOT, 'lib/mysql_compat'));
+
+let passed = 0, failed = 0;
+function ok(name, cond, extra) {
+  if (cond) { passed++; console.log('[OK]', name); }
+  else { failed++; console.log('[FAIL]', name, extra !== undefined ? '-> ' + JSON.stringify(extra) : ''); }
+}
+
+function tmp(name) {
+  const p = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'jsql-r-')), name);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  return p;
+}
+
+function freePort() {
+  return new Promise((res) => {
+    const s = net.createServer();
+    s.listen(0, '127.0.0.1', () => { const p = s.address().port; s.close(() => res(p)); });
+  });
+}
+
+/* Minimal RESP client for integration tests. */
+function respClient(port) {
+  return new Promise((resolve, reject) => {
+    const socket = net.connect(port, '127.0.0.1');
+    let buf = '';
+    const queue = [];
+    socket.on('connect', () => resolve({
+      cmd(line) {
+        return new Promise((r) => {
+          queue.push(r);
+          socket.write(line);
+        });
+      },
+      end() { socket.end(); },
+    }));
+    socket.on('data', (chunk) => {
+      buf += chunk.toString('utf8');
+      while (queue.length) {
+        const idx = buf.indexOf('\r\n');
+        if (idx < 0) break;
+        const line = buf.slice(0, idx);
+        buf = buf.slice(idx + 2);
+        queue.shift()(line);
+      }
+    });
+    socket.on('error', reject);
+  });
+}
+
+(async () => {
+  /* ============ M3: B-Tree strict open intervals ============ */
+  {
+    const t = new BTree();
+    for (const k of [1, 3, 5, 7, 9]) t.insert(k, k);
+    ok('btree.greaterThan excludes min', JSON.stringify(t.greaterThan(5)) === '[7,9]', t.greaterThan(5));
+    ok('btree.greaterThan(9) empty', JSON.stringify(t.greaterThan(9)) === '[]');
+    ok('btree.lessThan excludes max', JSON.stringify(t.lessThan(5)) === '[1,3]', t.lessThan(5));
+    ok('btree.lessThan(1) empty', JSON.stringify(t.lessThan(1)) === '[]');
+  }
+
+  /* ============ Core engine ============ */
+  const db = new Database(':memory:', { autoSave: false });
+  await db.start();
+  db.createTable('users', { id: 'integer primary key auto_increment', name: 'string', email: 'string unique', age: 'integer' });
+  for (const [n, a] of [['A', 10], ['B', 20], ['C', 30]]) db.insert('users', { name: n, email: n.toLowerCase() + '@x', age: a });
+
+  {
+    const gt = db.find('users', { age: { $gt: 20 } }).map(r => r.name);
+    ok('find $gt excludes boundary', JSON.stringify(gt) === '["C"]', gt);
+    const lt = db.find('users', { age: { $lt: 20 } }).map(r => r.name);
+    ok('find $lt excludes boundary', JSON.stringify(lt) === '["A"]', lt);
+  }
+
+  {
+    db.removeById('users', 2); // B (id=2) removed, C still id=3
+    ok('removeById with PK count', db.count('users') === 2, db.count('users'));
+    ok('removeById PK lookup null', db.findById('users', 2) === null);
+    ok('removeById B-Tree still consistent', db.find('users', { age: { $gt: 15 } }).length === 1);
+  }
+
+  {
+    db.createTable('np', { v: 'string', n: 'integer' });
+    for (let i = 0; i < 10; i++) db.insert('np', { v: 'v' + i, n: i });
+    db.createTable('h', { id: 'integer primary key auto_increment', grp: 'string', val: 'integer' });
+    for (let i = 0; i < 12; i++) db.insert('h', { grp: 'g' + (i % 4), val: i });
+    db._tables.h.createIndex('grp');
+
+    db.removeByIds('np', [1, 2]);
+    ok('removeByIds no-PK rebuilds indexes', db.find('np').length === 8, db.find('np').length);
+
+    const pre = db.find('h', { grp: 'g1' }).map(r => r.id).sort((a, b) => a - b);
+    db.removeById('h', 1); db.removeById('h', 5); db.removeById('h', 9); // the g0 rows
+    const post = db.find('h', { grp: 'g1' }).map(r => r.id).sort((a, b) => a - b);
+    ok('hash index survives swap-pop (g1 intact)', JSON.stringify(post) === JSON.stringify(pre), { pre, post });
+    ok('hash index has no stale g0 rows', db.find('h', { grp: 'g0' }).length === 0);
+    let stale = 0;
+    for (const list of db._tables.h._indexes.grp.values()) for (const i of list) if (!db._tables.h._rows[i]) stale++;
+    ok('hash index zero stale entries', stale === 0, stale);
+  }
+
+  {
+    db.createTable('docs', { id: 'integer primary key', data: 'string' });
+    db.insert('docs', { id: 1, data: JSON.stringify({ a: { b: 1 }, list: [1, 2, 3] }) });
+    db.begin();
+    db.updateById('docs', 1, { data: JSON.stringify({ a: { b: 2 }, list: [9] }) });
+    db.rollback();
+    const d = JSON.parse(db.findById('docs', 1).data);
+    ok('transaction snapshot deep-copies nested object', d.a.b === 1, d);
+    ok('transaction snapshot deep-copies arrays', JSON.stringify(d.list) === '[1,2,3]', d.list);
+  }
+
+  {
+    const pfs = Database.parseFieldShorthand;
+    const s1 = pfs('integer primary key auto_increment');
+    ok('parseFieldShorthand pk+ai', s1.primaryKey === true && s1.autoIncrement === true && s1.type === 'integer', s1);
+    const s2 = pfs('string unique not null');
+    ok('parseFieldShorthand unique+notnull', s2.unique === true && s2.required === true && s2.type === 'string', s2);
+    const s3 = pfs('string default x');
+    ok('parseFieldShorthand default', s3.default === 'x' && s3.type === 'string', s3);
+
+    let e = null;
+    try { db.insert('users', { name: 'X', email: 'a@x', age: 1 }); } catch (err) { e = err; }
+    ok('duplicate unique throws ER_DUP_ENTRY', e && (e.code === 1062 || String(e).includes('1062')), e && (e.code || e.message));
+    db.createTable('pk2', { a: 'integer primary key', b: 'string' });
+    db.insert('pk2', { a: 1, b: 'x' });
+    e = null;
+    try { db.insert('pk2', { a: 1, b: 'y' }); } catch (err) { e = err; }
+    ok('duplicate primary key throws ER_DUP_ENTRY', e && (e.code === 1062 || String(e).includes('1062')), e && (e.code || e.message));
+  }
+
+  {
+    const r = await migrate.importFromJSON(db, { table: 't1', schema: { id: 'integer primary key' }, rows: [{ id: 1 }, { id: 2 }] });
+    ok('importFromJSON single-table shape', r && db.count('t1') === 2);
+    let threw = null;
+    try { await migrate.importFromJSON(db, { table: 't1', schema: { id: 'integer primary key' }, rows: [{ id: 3 }] }); } catch (err) { threw = err; }
+    ok('importFromJSON refuses existing table without overwrite', !!threw, threw && (threw.message || String(threw)));
+    await migrate.importFromJSON(db, { table: 't1', schema: { id: 'integer primary key' }, rows: [{ id: 3 }] }, { overwrite: true });
+    ok('importFromJSON overwrite replaces table', db.count('t1') === 1, db.count('t1'));
+  }
+
+  {
+    db.createTable('lk', { s: 'string' });
+    for (const s of ['a.b', 'axb', 'aXb', 'abc']) db.insert('lk', { s });
+    const m = db.find('lk', { s: { $like: 'a.b' } }).map(r => r.s);
+    ok('$like escapes regex metacharacters', JSON.stringify(m) === '["a.b"]', m);
+    const m2 = db.find('lk', { s: { $like: 'a%b' } }).map(r => r.s);
+    ok('$like % wildcard still works', JSON.stringify(m2) === '["a.b","axb","aXb"]', m2);
+  }
+  await db.stop();
+
+  /* ============ CLI (N1) ============ */
+  {
+    const pkg = require(path.join(ROOT, 'package.json')).version;
+    const v = execFileSync(process.execPath, [path.join(ROOT, 'bin/jsql'), '--version']).toString().trim();
+    ok('cli --version reports package version', v === pkg, v);
+    const v2 = execFileSync(process.execPath, [path.join(ROOT, 'bin/jsql'), 'version']).toString().trim();
+    ok('cli version command matches', v2 === pkg, v2);
+    const help = execFileSync(process.execPath, [path.join(ROOT, 'bin/jsql'), 'ui', '--help']).toString();
+    ok('cli subcommand --help does not crash', help.includes('127.0.0.1') && help.includes('auth-token'));
+  }
+
+  /* ============ WebUI CORS + auth (N2 / S2) ============ */
+  {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'jsql-wui-'));
+    fs.writeFileSync(path.join(dir, 'db.json'), JSON.stringify({ __schema__: { u: { id: { type: 'integer', primaryKey: true } } }, u: [{ id: 1 }] }));
+
+    const p1 = await freePort();
+    const w1 = new WebUI({ port: p1, host: undefined, dataDir: dir });
+    await w1.start();
+    ok('webui default host is 127.0.0.1', w1.host === '127.0.0.1', w1.host);
+    let r = await fetch('http://127.0.0.1:' + p1 + '/api/databases', { headers: { Origin: 'http://evil.example' } });
+    ok('webui no-token emits no ACAO', r.headers.get('access-control-allow-origin') === null, r.headers.get('access-control-allow-origin'));
+    r = await fetch('http://127.0.0.1:' + p1 + '/api/query', { method: 'OPTIONS', headers: { Origin: 'http://evil.example', 'Access-Control-Request-Method': 'POST' } });
+    ok('webui no-token preflight emits no ACAO', r.headers.get('access-control-allow-origin') === null);
+    await w1.stop();
+
+    const p2 = await freePort();
+    const w2 = new WebUI({ port: p2, host: '127.0.0.1', dataDir: dir, authToken: 'tok' });
+    await w2.start();
+    r = await fetch('http://127.0.0.1:' + p2 + '/api/databases', { headers: { Origin: 'http://evil.example' } });
+    ok('webui missing bearer returns 401', r.status === 401);
+    r = await fetch('http://127.0.0.1:' + p2 + '/api/databases', { headers: { Origin: 'http://good.example', Authorization: 'Bearer tok' } });
+    ok('webui auth echoes origin', r.status === 200 && r.headers.get('access-control-allow-origin') === 'http://good.example', { status: r.status, acao: r.headers.get('access-control-allow-origin') });
+    await w2.stop();
+
+    const p3 = await freePort();
+    const w3 = new WebUI({ port: p3, host: '127.0.0.1', dataDir: dir, allowOrigin: '*' });
+    await w3.start();
+    r = await fetch('http://127.0.0.1:' + p3 + '/api/databases', { headers: { Origin: 'http://any.example' } });
+    ok('webui explicit allowOrigin honored', r.headers.get('access-control-allow-origin') === '*');
+    await w3.stop();
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+
+  /* ============ Redis per-socket AUTH (S1) ============ */
+  {
+    const p = await freePort();
+    const rs = new RedisServer({ port: p, host: '127.0.0.1', password: 'pw' });
+    rs.listen();
+    await new Promise((res) => rs.server.once('listening', res));
+
+    const a = await respClient(p);
+    const b = await respClient(p);
+    const noauthA = await a.cmd('*1\r\n$4\r\nPING\r\n');
+    ok('redis unauth socket gets NOAUTH', noauthA.startsWith('-NOAUTH'), noauthA);
+    const authB = await b.cmd('*2\r\n$4\r\nAUTH\r\n$2\r\npw\r\n');
+    ok('redis AUTH pw succeeds', authB === '+OK', authB);
+    const pingB = await b.cmd('*1\r\n$4\r\nPING\r\n');
+    ok('redis authed socket works', pingB === '+PONG', pingB);
+    const pingA = await a.cmd('*1\r\n$4\r\nPING\r\n');
+    ok('redis auth is per-socket (other socket still NOAUTH)', pingA.startsWith('-NOAUTH'), pingA);
+    a.end(); b.end();
+    rs.server.close();
+  }
+
+  /* ============ MySQL ACL (S3 / S4) ============ */
+  {
+    const ms = new MysqlServer({ dataDir: ':memory:', auth: { alice: { password: 'pw', databases: ['app'] } } });
+    ok('mysql acl allows member db', ms._canAccessDb('alice', 'app') === true);
+    ok('mysql acl denies foreign db', ms._canAccessDb('alice', 'other') === false);
+    let code = null;
+    try { await ms._switchDb({ user: 'alice' }, 'other'); } catch (e) { code = e.code; }
+    ok('mysql cross-db switch denied (1044)', code === 1044, code);
+  }
+
+  /* ============ mysql_compat pool filename (S6) ============ */
+  {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'jsql-cp-'));
+    const file = path.join(dir, 'pool.json');
+    const pool = compat.createPool({ filename: file });
+    await pool.query('CREATE TABLE t (id INT PRIMARY KEY, v VARCHAR(20))');
+    await pool.query("INSERT INTO t VALUES (1,'x')");
+    const [rows] = await pool.query('SELECT * FROM t');
+    ok('mysql_compat pool query roundtrip', rows.length === 1 && rows[0].v === 'x', rows);
+    ok('mysql_compat pool persists to filename', fs.existsSync(file) && fs.statSync(file).size > 0);
+    if (typeof pool.end === 'function') await pool.end();
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+
+  console.log(failed === 0 ? `\nALL ${passed} REGRESSION TESTS PASSED` : `\n${failed} FAILURES (${passed} passed)`);
+  process.exit(failed === 0 ? 0 : 1);
+})().catch((e) => { console.error('FATAL', e); process.exit(1); });