jsql-neo 5.1.1 → 5.1.3

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/lib/query.js

@@ -537,7 +537,7 @@ class Query {
                 const key = fr[join.foreignField];
                 const matches = localRows.filter(lr => lr[join.localField] === key);
                 if (matches.length === 0) {
-                    result.push({ ...fr, ...this._nullRow(join, true) });
+                    result.push(this._rightNullRow(localRows, fr, join));
                 } else {
                     for (const lr of matches) {
                         result.push(this._mergeJoinRow(lr, fr, join));
@@ -582,7 +582,7 @@ class Query {
             for (const fr of foreignRows) {
                 const matches = localRows.filter(lr => lr[join.localField] === fr[join.foreignField]);
                 if (matches.length === 0) {
-                    result.push({ ...fr, ...this._nullRow(join, true) });
+                    result.push(this._rightNullRow(localRows, fr, join));
                 } else {
                     for (const lr of matches) {
                         result.push(this._mergeJoinRow(lr, fr, join));
@@ -621,6 +621,24 @@ class Query {
         return nulls;
     }
 
+    /**
+     * RIGHT JOIN 未匹配右表行：保留右表数据，本地表字段填 null。
+     * 返回 { localNulls, merged }，其中 merged = { ...nulls, ...fr }
+     */
+    _rightNullRow(localRows, foreignRow, join) {
+        const localSchema = this._table._schema || {};
+        const localNulls = {};
+        for (const field of Object.keys(localSchema)) {
+            if (field !== '_softDelete') localNulls[field] = null;
+        }
+        const prefix = join.as ? join.as + '_' : '';
+        const foreignPrefixed = {};
+        for (const [key, value] of Object.entries(foreignRow)) {
+            foreignPrefixed[prefix + key] = value;
+        }
+        return { ...localNulls, ...foreignPrefixed };
+    }
+
     // ============================================================
     // 内部: 排序
     // ============================================================

package/lib/sql.js

@@ -261,12 +261,18 @@ class Parser {
     if (this.peek().type === 'op' && this.peek().value === '.') {
       this.next();
       const t2 = this.next();
-      if (t2.type !== 'ident') throw new Error(`Expected table name after '.', got '${t2.value}'`);
+      if (t2.type !== 'ident' && !(t2.type === 'keyword' && this._isSchemaView(t2.value))) {
+        throw new Error(`Expected table name after '.', got '${t2.value}'`);
+      }
       return t.value + '.' + t2.value;
     }
     return t.value;
   }
 
+  _isSchemaView(v) {
+    return ['TABLES', 'COLUMNS', 'SCHEMATA', 'STATISTICS', 'KEY_COLUMN_USAGE', 'REFERENTIAL_CONSTRAINTS', 'TABLE_CONSTRAINTS', 'VIEWS'].includes(String(v).toUpperCase());
+  }
+
   parseCreateTable() {
     this.expectKeyword('CREATE');
     this.expectKeyword('TABLE');
@@ -1870,11 +1876,12 @@ class SQLExecutor {
         const schema = this.engine.getTableSchema
           ? await this.engine.getTableSchema(statement.table)
           : (this.engine._schemas ? this.engine._schemas[statement.table] : null);
+        const pkCols = schema ? Object.keys(schema).filter(k => schema[k].primaryKey) : [];
         const all = (await this.engine.find(statement.table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
         let count = 0;
         for (const row of all) {
           if (!statement.where || evaluateExpr(statement.where, row, this.ctx)) {
-            const id = row._rid !== undefined ? row._rid : row.id;
+            const id = this._rowPkId(row, pkCols);
             if (id !== undefined) {
               const data = {};
               for (const [col, val] of statement.assignments) {
@@ -1892,11 +1899,12 @@ class SQLExecutor {
         const schema = this.engine.getTableSchema
           ? await this.engine.getTableSchema(statement.table)
           : (this.engine._schemas ? this.engine._schemas[statement.table] : null);
+        const pkCols = schema ? Object.keys(schema).filter(k => schema[k].primaryKey) : [];
         const all = (await this.engine.find(statement.table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
         const ids = [];
         for (const row of all) {
           if (!statement.where || evaluateExpr(statement.where, row, this.ctx)) {
-            const id = row._rid !== undefined ? row._rid : row.id;
+            const id = this._rowPkId(row, pkCols);
             if (id !== undefined) ids.push(id);
           }
         }
@@ -2166,6 +2174,19 @@ class SQLExecutor {
     return schema;
   }
 
+  /**
+   * 取行的行 ID：优先内部 _rid，否则用实际主键字段值（不再硬编码 id）。
+   */
+  _rowPkId(row, pkCols) {
+    if (row && row._rid !== undefined) return row._rid;
+    if (pkCols.length > 0) {
+      for (const c of pkCols) {
+        if (row[c] !== undefined && row[c] !== null) return row[c];
+      }
+    }
+    return row ? row.id : undefined;
+  }
+
   async _readTable(table) {
     const schema = await this._getSchema(table);
     const rows = (await this.engine.find(table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
@@ -2366,6 +2387,19 @@ class SQLExecutor {
     return out;
   }
 
+  /**
+   * 生成对端表的前缀 null 行：仅含 `prefix.col` 键（值为 null），
+   * 用于 JOIN 未匹配行补齐限定列，避免回退到未前缀副本拿错值。
+   */
+  _nullPrefixedRow(schema, prefix) {
+    const out = {};
+    for (const k of Object.keys(schema)) {
+      if (k === '_softDelete') continue;
+      out[prefix + '.' + k] = null;
+    }
+    return out;
+  }
+
   _aggValue(rows, fn, column) {
     if (fn === 'COUNT') return rows.length;
     const op = typeof column === 'string' ? { type: 'column', name: column } : column;
@@ -2445,6 +2479,7 @@ class SQLExecutor {
 
     let schema = null;
     let all;
+    let rowsAll;
     if (!statement.from) {
       // 无 FROM：虚拟行（SELECT 1, 'a'）
       all = [{ _virtual: true }];
@@ -2469,7 +2504,6 @@ class SQLExecutor {
         const rows = filtered.map(r => outCols.map(c => (c in r ? r[c] : null)));
         return { ok: true, type: 'select', table: firstItem.table, columns: outCols, rows, raw: filtered };
       }
-      let rowsAll;
       if (firstItem.subquery) {
         const res = await this.executeSelect(firstItem.subquery);
         rowsAll = { rows: this._subQueryRows(res), schema: null, columns: res.columns };
@@ -2495,6 +2529,10 @@ class SQLExecutor {
         }
         const matched = [];
         const unmatchedRight = new Set(rightRows.map((r, i) => i));
+        // 未匹配行补对端表的前缀 null 列：限定列名（如 a.id / b.id）按前缀解析，
+        // 避免回退到未前缀副本拿到错误值。
+        const rightNulls = (rightRes.schema) ? this._nullPrefixedRow(rightRes.schema, rightPrefix) : null;
+        const leftNulls = (rowsAll && rowsAll.schema) ? this._nullPrefixedRow(rowsAll.schema, firstPrefix) : null;
         rows.forEach(l => {
           let m = null;
           for (let ri = 0; ri < rightRows.length; ri++) {
@@ -2507,11 +2545,11 @@ class SQLExecutor {
             matched.push({ ...l, ...rightRows[m] });
             unmatchedRight.delete(m);
           } else if (j.type === 'left') {
-            matched.push({ ...l });
+            matched.push(rightNulls ? { ...rightNulls, ...l } : { ...l });
           }
         });
         if (j.type === 'right') {
-          for (const ri of unmatchedRight) matched.push({ ...rightRows[ri] });
+          for (const ri of unmatchedRight) matched.push(leftNulls ? { ...leftNulls, ...rightRows[ri] } : { ...rightRows[ri] });
         }
         rows = matched;
       }

package/lib/table.js

@@ -242,6 +242,23 @@ class Table {
         const schema = this._schema;
         const checkConstraints = this._checkConstraints;
         const foreignKeys = this._foreignKeys;
+        // 批量预分配自增 ID 范围：先扫描显式提供的最大值，一次性推进计数器，
+        // 再在循环内用本地序号递增，避免批量内重复读取/写入同一计数器字段。
+        const baseAutoInc = this._autoIncrement;
+        if (autoIncField) {
+            let maxExplicit = 0;
+            for (const it of items) {
+                const v = it[autoIncField];
+                if (v !== undefined && v !== null) {
+                    const n = Number(v);
+                    if (!isNaN(n) && n > maxExplicit) maxExplicit = n;
+                }
+            }
+            if (maxExplicit > baseAutoInc) {
+                this._autoIncrement = maxExplicit;
+            }
+        }
+        let autoIncSeq = 0;
         for (let i = 0; i < N; i++) {
             let data = items[i];
             for (const [f, dv] of Object.entries(defaults)) {
@@ -279,8 +296,9 @@ class Table {
                 }
             }
             if (autoIncField && data[autoIncField] === undefined) {
-                this._autoIncrement++;
-                data[autoIncField] = this._autoIncrement;
+                autoIncSeq++;
+                data[autoIncField] = baseAutoInc + autoIncSeq;
+                this._autoIncrement = data[autoIncField];
             } else if (autoIncField && data[autoIncField] > this._autoIncrement) {
                 this._autoIncrement = data[autoIncField];
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo",
-  "version": "5.1.1",
+  "version": "5.1.3",
   "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,10 @@
   "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 && node test/join.test.js",
+    "test:join": "node test/join.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/join.test.js

@@ -0,0 +1,110 @@
+/*
+ * Regression tests for SQL JOIN null-fill correctness.
+ * Zero runtime dependencies (uses Node builtins + in-repo libs only).
+ *
+ *   node test/join.test.js
+ *
+ * Covers:
+ *   J1 LEFT JOIN unmatched rows null-fill right-table qualified columns
+ *   J2 RIGHT JOIN unmatched rows null-fill left-table qualified columns
+ *   J3 INNER JOIN unaffected
+ *   J4 unqualified column reference in JOIN
+ *   J5 WHERE filtering on the null-filled side
+ *   J6 self-join with table alias
+ *   J7 chained joins
+ */
+const path = require('path');
+
+const ROOT = path.join(__dirname, '..');
+const Database = require(path.join(ROOT, 'lib/database'));
+const { executeSQL } = require(path.join(ROOT, 'lib/sql'));
+
+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) : ''); }
+}
+
+async function setup(db) {
+  await executeSQL(db, 'CREATE TABLE a (id INT PRIMARY KEY, a_name STRING)');
+  await executeSQL(db, 'CREATE TABLE b (id INT PRIMARY KEY, a_id INT, b_name STRING)');
+  await executeSQL(db, "INSERT INTO a VALUES (1,'A1'),(2,'A2'),(3,'A3')");
+  await executeSQL(db, "INSERT INTO b VALUES (10,2,'B2'),(20,99,'B99')");
+}
+
+(async () => {
+  /* ============ J1 LEFT JOIN null-fill ============ */
+  {
+    const db = new Database(':memory:', { autoSave: false });
+    await setup(db);
+    const r = await executeSQL(db, 'SELECT a.id AS aid, a.a_name, b.id AS bid, b.b_name FROM a LEFT JOIN b ON a.id = b.a_id');
+    const row1 = r.rows[0]; // a=1 unmatched
+    ok('J1 left unmatched row', row1 && row1[0] === 1 && row1[1] === 'A1' && row1[2] === null && row1[3] === null, row1);
+    const row3 = r.rows[2]; // a=3 unmatched
+    ok('J1 second unmatched row', row3 && row3[0] === 3 && row3[2] === null, row3);
+    const row2 = r.rows[1]; // matched
+    ok('J1 matched row intact', row2 && row2[0] === 2 && row2[1] === 'A2' && row2[2] === 10 && row2[3] === 'B2', row2);
+  }
+
+  /* ============ J2 RIGHT JOIN null-fill ============ */
+  {
+    const db = new Database(':memory:', { autoSave: false });
+    await setup(db);
+    const r = await executeSQL(db, 'SELECT a.id AS aid, a.a_name, b.id AS bid, b.b_name FROM a RIGHT JOIN b ON a.id = b.a_id');
+    const b99 = r.rows[1]; // b=20 unmatched (a_id=99)
+    ok('J2 right unmatched row', b99 && b99[0] === null && b99[1] === null && b99[2] === 20 && b99[3] === 'B99', b99);
+    const b2 = r.rows[0]; // matched
+    ok('J2 matched row intact', b2 && b2[0] === 2 && b2[1] === 'A2' && b2[2] === 10 && b2[3] === 'B2', b2);
+  }
+
+  /* ============ J3 INNER JOIN ============ */
+  {
+    const db = new Database(':memory:', { autoSave: false });
+    await setup(db);
+    const r = await executeSQL(db, 'SELECT a.id AS aid, b.id AS bid FROM a INNER JOIN b ON a.id = b.a_id');
+    ok('J3 inner join', r.rows.length === 1 && r.rows[0][0] === 2 && r.rows[0][1] === 10, r.rows);
+  }
+
+  /* ============ J4 unqualified reference ============ */
+  {
+    const db = new Database(':memory:', { autoSave: false });
+    await setup(db);
+    const r = await executeSQL(db, 'SELECT a.id AS aid, b.b_name FROM a LEFT JOIN b ON a.id = b.a_id');
+    ok('J4 unprefixed id resolves to left table', r.rows[0][0] === 1 && r.rows[0][1] === null, r.rows[0]);
+  }
+
+  /* ============ J5 WHERE on null-filled side ============ */
+  {
+    const db = new Database(':memory:', { autoSave: false });
+    await setup(db);
+    const r = await executeSQL(db, "SELECT a.id AS aid, b.b_name FROM a LEFT JOIN b ON a.id = b.a_id WHERE b.id IS NULL");
+    ok('J5 left where b.id IS NULL', r.rows.length === 2 && r.rows.every(x => x[1] === null), r.rows);
+    const r2 = await executeSQL(db, "SELECT a.a_name, b.id AS bid FROM a RIGHT JOIN b ON a.id = b.a_id WHERE a.id IS NULL");
+    ok('J5 right where a.id IS NULL', r2.rows.length === 1 && r2.rows[0][0] === null && r2.rows[0][1] === 20, r2.rows);
+  }
+
+  /* ============ J6 self-join with alias ============ */
+  {
+    const db = new Database(':memory:', { autoSave: false });
+    await executeSQL(db, 'CREATE TABLE emp (id INT PRIMARY KEY, mgr_id INT, name STRING)');
+    await executeSQL(db, "INSERT INTO emp VALUES (1,NULL,'boss'),(2,1,'alice'),(3,999,'orphan')");
+    const r = await executeSQL(db, 'SELECT e.name AS ename, m.name AS mname FROM emp e LEFT JOIN emp m ON e.mgr_id = m.id');
+    ok('J6 self left join', r.rows.length === 3 && r.rows[0][0] === 'boss' && r.rows[0][1] === null && r.rows[1][1] === 'boss' && r.rows[2][1] === null, r.rows);
+  }
+
+  /* ============ J7 chained joins ============ */
+  {
+    const db = new Database(':memory:', { autoSave: false });
+    await executeSQL(db, 'CREATE TABLE a (id INT PRIMARY KEY, a_name STRING)');
+    await executeSQL(db, 'CREATE TABLE b (id INT PRIMARY KEY, a_id INT, b_name STRING)');
+    await executeSQL(db, 'CREATE TABLE c (id INT PRIMARY KEY, b_id INT, c_name STRING)');
+    await executeSQL(db, "INSERT INTO a VALUES (1,'A1'),(2,'A2'),(3,'A3')");
+    await executeSQL(db, "INSERT INTO b VALUES (10,2,'B2'),(20,99,'B99')");
+    await executeSQL(db, "INSERT INTO c VALUES (100,10,'C10'),(200,77,'C77')");
+    const r = await executeSQL(db, 'SELECT a.id AS aid, b.id AS bid, c.id AS cid, c.c_name FROM a LEFT JOIN b ON a.id = b.a_id LEFT JOIN c ON b.id = c.b_id');
+    ok('J7 chained left joins', r.rows.length === 3 && r.rows[1][1] === 10 && r.rows[1][2] === 100 && r.rows[1][3] === 'C10' && r.rows[0][1] === null && r.rows[0][2] === null, r.rows);
+  }
+
+  console.log(failed === 0 ? `\nALL ${passed} JOIN TESTS PASSED` : `\n${failed} FAILURES (${passed} passed)`);
+  process.exit(failed === 0 ? 0 : 1);
+})().catch((e) => { console.error('FATAL', e); process.exit(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); });