jsql-neo 6.5.20 → 6.5.22

package/lib/sql.js

@@ -484,6 +484,7 @@ class Parser {
     this.paramCount = 0;   // 顺序占位符 ? 的序号（从 0 开始）
     this.subquerySeq = 0;  // FROM 子查询无别名时自动生成 __subN
     this.depth = 0;        // 子查询递归深度
+    this.barePredicateDepth = 0; // >0 时允许裸布尔谓词（WHERE 1 / WHERE col / WHERE NULL）
   }
 
   peek(offset = 0) { return this.tokens[this.pos + offset]; }
@@ -717,6 +718,8 @@ class Parser {
     this.expect('op', '(');
 
     const schema = {};
+    // 表级 FOREIGN KEY 可能写在列定义之前，先收集、待所有列解析完再绑定
+    const pendingFKs = [];
     let hasPk = false;
     while (true) {
       const t = this.peek();
@@ -753,14 +756,14 @@ class Parser {
       } else if (t.type === 'keyword' && t.value === 'CONSTRAINT') {
         this.expectKeyword('CONSTRAINT');
         if (this.peek().type === 'ident') this.next();   // 约束名
-        this._parseTableConstraint(schema);
+        this._parseTableConstraint(schema, pendingFKs);
       } else if (this.isWord('FOREIGN') || this.isWord('CHECK') ||
                  t.type === 'keyword' && (t.value === 'KEY' || t.value === 'INDEX')) {
         // 表级约束：FOREIGN KEY ... REFERENCES ... / CHECK (...) / KEY name (cols)
         // KEY/INDEX 是保留字：裸写作列名（如 CREATE TABLE t (key TEXT)）必须报错，
         // 由 _parseTableConstraint 消费 KEY 后遇到类型 token 触发
         // "Expected ',' or ')'",见 identifier-keywords 测试。
-        this._parseTableConstraint(schema);
+        this._parseTableConstraint(schema, pendingFKs);
       } else if (t.type === 'eof' || (t.type === 'op' && t.value === ')')) {
         break;
       } else {
@@ -791,6 +794,13 @@ class Parser {
     if (!hasPk && schema.id === undefined) {
       schema.id = { type: 'integer', primaryKey: true, autoIncrement: true };
     }
+    // 表级外键落到对应列的 def.foreignKey 上，由 lib/table.js 统一注册/校验
+    for (const { column, fk } of pendingFKs) {
+      if (!schema[column]) {
+        throw new Error(`Unknown column '${column}' in foreign key definition of table '${name}'`);
+      }
+      schema[column].foreignKey = fk;
+    }
     return { type: 'createTable', name, schema, ifNotExists };
   }
 
@@ -853,6 +863,25 @@ class Parser {
         if (this.peek().type === 'op' && this.peek().value === '(') this._skipParens();
         continue;
       }
+      // 列级外键： pid INTEGER REFERENCES p(id) [ON DELETE ...] [ON UPDATE ...]
+      // 此前 REFERENCES 没被消费，直接留在流里 → "Expected ',' or ')'"。
+      if (this.isWord('REFERENCES')) {
+        this.next();
+        const refTable = this.parseTableName();
+        const refCols = this._parseParenNameList();
+        let onDelete = 'restrict';
+        let onUpdate = 'restrict';
+        while (this.isKeyword('ON')) {
+          this.next();
+          const which = String(this.next().value).toUpperCase();
+          const action = this._parseFKAction();
+          if (which === 'DELETE') onDelete = action;
+          else if (which === 'UPDATE') onUpdate = action;
+          else throw new Error(`Expected DELETE or UPDATE after ON, got '${which}'`);
+        }
+        def.foreignKey = { table: refTable, field: refCols[0] || 'id', onDelete, onUpdate };
+        continue;
+      }
       if (t.type === 'keyword') {
         switch (t.value) {
           case 'PRIMARY':
@@ -946,27 +975,75 @@ class Parser {
     }
   }
 
+  /** 解析括号内的名字列表： (a, b)；无括号时返回空数组。 */
+  _parseParenNameList() {
+    const names = [];
+    if (!(this.peek().type === 'op' && this.peek().value === '(')) return names;
+    this.next();
+    while (true) {
+      names.push(this.parseTableName());
+      if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
+      break;
+    }
+    this.expect('op', ')');
+    return names;
+  }
+
+  /** 解析外键动作： CASCADE / RESTRICT / SET NULL / NO ACTION */
+  _parseFKAction() {
+    const first = String(this.next().value).toUpperCase();
+    if (first === 'CASCADE') return 'cascade';
+    if (first === 'RESTRICT') return 'restrict';
+    if (first === 'SET') {
+      const second = String(this.next().value).toUpperCase();
+      if (second === 'NULL') return 'set null';
+      throw new Error(`Unsupported foreign key action: 'SET ${second}' (only SET NULL is supported)`);
+    }
+    if (first === 'NO') {
+      if (this.isWord('ACTION')) this.next();
+      return 'no action';
+    }
+    throw new Error(`Unsupported foreign key action: '${first}'`);
+  }
+
   /**
    * 解析表级约束（FOREIGN KEY / CHECK / KEY / INDEX / PRIMARY KEY / UNIQUE）。
-   * 目前只做语法层面消费并在可能时补充列属性，不做外键实际校验。
+   * FOREIGN KEY 会真正解析出 field/refTable/refField/onDelete/onUpdate 并登记，
+   * 与列级 REFERENCES 行为一致（校验在 lib/table.js）。
    */
-  _parseTableConstraint(schema) {
+  _parseTableConstraint(schema, pendingFKs) {
     if (this.isWord('FOREIGN')) {
       this.next();
       if (!this.isKeyword('KEY')) throw new Error(`Expected KEY after FOREIGN, got '${this.peek().value}'`);
       this.next();
-      if (this.peek().type === 'op' && this.peek().value === '(') this._skipParens();
-      if (this.isWord('REFERENCES')) {
-        this.next();
-        this.parseTableName();
-        if (this.peek().type === 'op' && this.peek().value === '(') this._skipParens();
-      }
-      // ON DELETE / ON UPDATE <action>
+      const cols = this._parseParenNameList();
+      if (!cols.length) throw new Error('Expected column list in FOREIGN KEY constraint');
+      if (!this.isWord('REFERENCES')) throw new Error(`Expected REFERENCES in FOREIGN KEY constraint, got '${this.peek().value}'`);
+      this.next();
+      const refTable = this.parseTableName();
+      const refCols = this._parseParenNameList();
+      let onDelete = 'restrict';
+      let onUpdate = 'restrict';
       while (this.isKeyword('ON')) {
         this.next();
-        this.next();                       // DELETE | UPDATE
-        const act = String(this.next().value).toUpperCase();
-        if (act === 'SET' || act === 'NO') this.next();   // SET NULL / NO ACTION
+        const which = String(this.next().value).toUpperCase();
+        const action = this._parseFKAction();
+        if (which === 'DELETE') onDelete = action;
+        else if (which === 'UPDATE') onUpdate = action;
+        else throw new Error(`Expected DELETE or UPDATE after ON, got '${which}'`);
+      }
+      // 复合外键无法用现有的单列校验表示；显式报错好过静默丢弃
+      if (cols.length > 1) {
+        throw new Error('Composite foreign key constraints are not supported (FOREIGN KEY with multiple columns)');
+      }
+      const fk = { table: refTable, field: refCols[0] || 'id', onDelete, onUpdate };
+      if (pendingFKs) {
+        // 列可能还没解析到，推迟到 parseCreateTable 末尾绑定
+        pendingFKs.push({ column: cols[0], fk });
+      } else if (schema[cols[0]]) {
+        schema[cols[0]].foreignKey = fk;
+      } else {
+        throw new Error(`Unknown column '${cols[0]}' in foreign key definition`);
       }
       return;
     }
@@ -1436,7 +1513,7 @@ class Parser {
       from = this.parseFrom();
     }
     let where = null;
-    if (this.isKeyword('WHERE')) { this.next(); where = this.parseExpr(); }
+    if (this.isKeyword('WHERE')) { this.next(); where = this.parseBooleanExpr(); }
     let groupBy = null;
     let rollup = false;
     if (this.isKeyword('GROUP')) {
@@ -1455,7 +1532,7 @@ class Parser {
       }
     }
     let having = null;
-    if (this.isKeyword('HAVING')) { this.next(); having = this.parseExpr(); }
+    if (this.isKeyword('HAVING')) { this.next(); having = this.parseBooleanExpr(); }
     let orderBy = null;
     if (this.isKeyword('ORDER')) {
       this.expectKeyword('ORDER'); this.expectKeyword('BY');
@@ -1590,7 +1667,7 @@ class Parser {
       }
       const item = this.parseFromItem();
       let on = null;
-      if (this.isKeyword('ON')) { this.next(); on = this.parseExpr(); }
+      if (this.isKeyword('ON')) { this.next(); on = this.parseBooleanExpr(); }
       joins.push({ type, item, on });
     }
     return { tables, joins };
@@ -1661,7 +1738,7 @@ class Parser {
       break;
     }
     let where = null;
-    if (this.isKeyword('WHERE')) { this.next(); where = this.parseExpr(); }
+    if (this.isKeyword('WHERE')) { this.next(); where = this.parseBooleanExpr(); }
     else console.warn(`⚠️  UPDATE without WHERE clause — this will modify ALL rows in '${table}'`);
     // UPDATE ... ORDER BY ... LIMIT n（与 DELETE 对称；按排序后的前 n 行更新）
     let orderBy = null, limit = null;
@@ -1694,7 +1771,7 @@ class Parser {
     this.expectKeyword('FROM');
     const table = this.parseTableName();
     let where = null;
-    if (this.isKeyword('WHERE')) { this.next(); where = this.parseExpr(); }
+    if (this.isKeyword('WHERE')) { this.next(); where = this.parseBooleanExpr(); }
     let orderBy = null, limit = null;
     if (this.isKeyword('ORDER')) {
       this.next(); this.expectKeyword('BY');
@@ -2039,6 +2116,21 @@ class Parser {
     return this.parseOr();
   }
 
+  /**
+   * 布尔上下文表达式（WHERE / HAVING / ON 条件）。
+   * 与 parseExpr 相同，但允许「裸布尔谓词」：
+   *   WHERE 1 / WHERE col / WHERE NULL / WHERE NULL AND b = 1
+   * 此时 parseComparison 在找不到比较运算符时把左侧表达式直接作为布尔值返回。
+   */
+  parseBooleanExpr() {
+    this.barePredicateDepth = (this.barePredicateDepth || 0) + 1;
+    try {
+      return this.parseExpr();
+    } finally {
+      this.barePredicateDepth--;
+    }
+  }
+
   /**
    * 函数实参用的表达式：与 parseExpr 相同，但叶子允许是"裸操作数"。
    * 例如 IF(1 > 0, 'y', 'n') 的第一个参数是完整比较表达式，
@@ -2897,6 +2989,11 @@ class Parser {
     // 函数实参场景允许裸操作数（IF(age, ...) / SUM(IF(...)) 等）
     if (this.bareExprDepth > 0) return left;
 
+    // 布尔上下文（WHERE / HAVING / ON）允许裸布尔谓词（#21）：
+    //   WHERE 1 / WHERE col / WHERE NULL / WHERE 'abc' / WHERE NULL AND b = 1
+    // 左侧表达式直接作为布尔值返回，由求值层按 MySQL 三值逻辑判真。
+    if (this.barePredicateDepth > 0) return left;
+
     throw new Error(`Expected comparison operator, got '${t2.value}'`);
   }
 }
@@ -3006,6 +3103,24 @@ function numericIfNumeric(v) {
   return Number.isFinite(n) ? n : null;
 }
 
+/**
+ * MySQL 数字上下文里的字符串→数字强转：数字与字符串比较时，
+ * 字符串按数值前缀解析，非数字/空串一律按 0（MySQL 语义）。
+ *   '' → 0、'a' → 0、'5' → 5、'5abc' → 5、'2024-01-01' → 2024
+ * 与 strict 的 numericIfNumeric 不同：它拒绝非纯数字，这里宽进。
+ */
+function mysqlNum(v) {
+  if (typeof v === 'number') return Number.isFinite(v) ? v : 0;
+  if (typeof v === 'boolean') return v ? 1 : 0;
+  if (typeof v === 'string') {
+    const m = v.trim().match(/^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?/);
+    if (!m) return 0;
+    const n = Number(m[0]);
+    return Number.isFinite(n) ? n : 0;
+  }
+  return 0;
+}
+
 function resolveOperand(operand, row, ctx) {
   if (operand === null || operand === undefined) return null;
   if (typeof operand === 'string') return resolveOperand({ type: 'column', name: operand }, row, ctx);
@@ -4525,6 +4640,37 @@ function normalizeCmpValue(a, other) {
   return otherIsNumeric ? (a ? 1 : 0) : a;
 }
 
+// MySQL 数值强转（#26 / #39）：数字原样返回，布尔按 1/0，字符串按 MySQL 规则
+// 转换（空串和非数字字符串都算 0）。数字与字符串混合比较时必须走这里，
+// 否则 '10' >= '5' 会退化成字典序比较而得到错误结果。
+function mysqlNumeric(v) {
+  if (typeof v === 'number') return v;
+  if (typeof v === 'boolean') return v ? 1 : 0;
+  if (typeof v === 'string') {
+    const t = v.trim();
+    if (t === '') return 0;
+    const n = Number(t);
+    return Number.isFinite(n) ? n : 0;
+  }
+  return NaN;
+}
+
+/** 严格数值解析：只有真正能解析成有限数值时才返回 number，否则 null。
+ *  用来判断字符串边界是否“看起来像数字”（'9' / '0.01' / ' 100 ' 是，'abc' 不是）。
+ *  与 mysqlNumeric 的区别：非数字字符串返回 null 而不是 0 —— 判断“要不要按数值比较”
+ *  时不能用 0 冒充，否则 'abc' 会被当成 0。 */
+function strictNumeric(v) {
+  if (typeof v === 'number') return Number.isFinite(v) ? v : null;
+  if (typeof v === 'boolean') return v ? 1 : 0;
+  if (typeof v === 'string') {
+    const t = v.trim();
+    if (t === '') return null;
+    const n = Number(t);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+
 // MySQL 默认 collation（utf8mb4_general_ci）下字符串比较不区分大小写，
 // 与 LIKE 保持一致。cs=true 表示显式 BINARY/COLLATE 强制大小写敏感。
 function ciEq(a, b, cs) {
@@ -4596,16 +4742,23 @@ function evaluateExpr(expr, row, ctx) {
       // 布尔与数值互通（MySQL: 1 = TRUE、0 = FALSE）
       const nl = normalizeCmpValue(l, r);
       const nr = normalizeCmpValue(r, l);
+      // MySQL 类型强转：数字与字符串比较时，字符串按数字上下文转换。
+      // 覆盖 0 = '' → 0 = 0 → 1、'a' = 0 → 0 = 0 → 1、'5' = 5 → 5 = 5 → 1（#26）。
+      // 此前只对「数字 vs 纯数字字符串」生效，'' / 'a' 这类非纯数字字符串
+      // 会退化成字符串比较而错判为不等。
       const isNum = (v) => typeof v === 'number';
-      const isNumStr = (v) => typeof v === 'string' && String(v).trim() !== '' && Number.isFinite(Number(v));
-      // 数值 vs 数值字符串（age < '10'、age = '09'）必须按数值比，
-      // 否则退化成字典序：'9' < '10' 为 false、'9' = '09' 为 false
-      const mixedNum = (isNum(nl) && isNumStr(nr)) || (isNumStr(nl) && isNum(nr));
-      if (expr.op === '=') {
-        if (mixedNum) return Number(nl) === Number(nr);
-        return ciEq(nl, nr, cs);
-      }
-      if (mixedNum) { const fn = OPERATORS[expr.op]; return fn(Number(nl), Number(nr)); }
+      // MySQL 类型强转（#26）：数字 vs 字符串统一走全局 mysqlNum
+      // （按数值前缀解析，非数字/空串视为 0，对齐 MySQL 宽松转换）。
+      // 覆盖 '5' = 5、0 = ''、'a' = 0、'09' = 9 等，避免退化成字典序比较。
+      const isStr = (v) => typeof v === 'string';
+      const numVsStr = (isNum(nl) && isStr(nr)) || (isStr(nl) && isNum(nr));
+      if (numVsStr) {
+        const an = mysqlNum(nl), bn = mysqlNum(nr);
+        if (expr.op === '=') return an === bn;
+        const fn = OPERATORS[expr.op];
+        return fn(an, bn);
+      }
+      if (expr.op === '=') return ciEq(nl, nr, cs);
       if (typeof nl === 'number' && typeof nr === 'number') { const fn = OPERATORS[expr.op]; return fn(nl, nr); }
       const c = ciCompare(nl, nr, cs);
       switch (expr.op) {
@@ -4689,21 +4842,17 @@ function evaluateExpr(expr, row, ctx) {
       // 10 BETWEEN '5' AND '9' 得 0（应为 1）。
       // 两边都是字符串时保持字符串比较（日期 '2024-01-02' 这类不能丢字典序）。
       let inRange;
-      const asNum = (x) => {
-        if (typeof x === 'number') return Number.isFinite(x) ? x : null;
-        if (typeof x === 'boolean') return x ? 1 : 0;
-        if (typeof x === 'string') {
-          const s = x.trim();
-          if (s === '') return null;
-          const num = Number(s);
-          return Number.isFinite(num) ? num : null;
-        }
-        return null;
-      };
-      const vn = typeof v === 'number' ? asNum(v) : null;
-      const ln = asNum(lo), hn = asNum(hi);
-      if (vn !== null && ln !== null && hn !== null) {
-        inRange = vn >= ln && vn <= hn;
+      const vn = strictNumeric(v), ln = strictNumeric(lo), hn = strictNumeric(hi);
+      const vIsNum = typeof v === 'number' || typeof v === 'boolean';
+      const boundIsNum = typeof lo === 'number' || typeof lo === 'boolean' ||
+        typeof hi === 'number' || typeof hi === 'boolean';
+      // 数值比较的判定与 case 'compare' 的 mixedNum 保持一致：
+      //  1) 列值本身就是数值（或布尔），且两个边界都能解析为数值；
+      //  2) 列值是可解析为数值的字符串，而任一边界本身就是数值（混合比较）。
+      // 其余情况（纯字符串列 + 纯字符串边界，如日期 '2024-01-02'）保持字典序。
+      const numericRange = ln !== null && hn !== null && (vIsNum || (boundIsNum && vn !== null));
+      if (numericRange) {
+        inRange = vn !== null && vn >= ln && vn <= hn;
       } else {
         inRange = String(v) >= String(lo) && String(v) <= String(hi);
       }
@@ -4753,7 +4902,14 @@ function evaluateExpr(expr, row, ctx) {
         default: return null;
       }
     }
-    default: return false;
+    default: {
+      // 裸布尔谓词（WHERE 1 / WHERE col / WHERE NULL / WHERE 'abc'，#21）：
+      // 解析层把左侧表达式直接作为布尔条件返回，这里按 MySQL 真值规则
+      // 归一化为 true / false / UNKNOWN(null)：NULL → null；0/''/false → false；
+      // 其余（含非空字符串）→ true。此前一律返回 false 导致谓词被静默算错。
+      const v = resolveOperand(expr, row, ctx);
+      return sqlTruthy(v);
+    }
   }
 }
 
@@ -5047,9 +5203,8 @@ class SQLExecutor {
             }
             case 'addForeign':
             case 'dropForeign':
-              // 外键在这个引擎里没有实现（连 CREATE TABLE 的表级 FOREIGN KEY
-              // 都只是解析掉、不记录、不强制）。与其返回成功让人以为约束生效，
-              // 不如明确报错。要支持得先做引用完整性检查。
+              // ALTER TABLE ... ADD/DROP FOREIGN KEY 仍未实现（CREATE TABLE 的表级/列级
+              // FOREIGN KEY 已真正生效）。与其返回成功让人以为约束变更了，不如明确报错。
               throw new Error(
                 `ALTER TABLE ... ${op.op === 'addForeign' ? 'ADD FOREIGN KEY' : 'DROP FOREIGN KEY'} is not supported: ` +
                 `this engine does not implement foreign key constraints.`

package/lib/table.js

@@ -450,7 +450,7 @@ class Table {
     // 更新
     // ============================================================
 
-    update(query, updates) {
+    update(query, updates, opts = {}) {
         for (const hook of this._hooks.beforeUpdate) {
             updates = hook(query, { ...updates }) || updates;
         }
@@ -465,7 +465,7 @@ class Table {
 
             const oldData = { ...this._rows[index] };
             const merged = { ...this._rows[index], ...updates };
-            this._validateConstraints(merged, index);
+            this._validateConstraints(merged, index, undefined, opts);
 
             this._removeFromIndexes(index, oldData);
             Object.assign(this._rows[index], updates);
@@ -1354,7 +1354,7 @@ class Table {
     // 内部: 约束校验
     // ============================================================
 
-    _validateConstraints(data, excludeIndex, uniqueTracker) {
+    _validateConstraints(data, excludeIndex, uniqueTracker, opts = {}) {
         for (const [field, def] of Object.entries(this._schema)) {
             if (field === '_softDelete') continue;
 
@@ -1438,6 +1438,13 @@ class Table {
         }
 
         // FOREIGN KEY 校验
+        // skipForeignKeys：父表主键 CASCADE 传播时，子表的新值尚未在父表生效，
+        // 此时跳过本表 FK 复查（否则合法的 CASCADE 会被自己拦住）。
+        if (!opts.skipForeignKeys) this._validateForeignKeys(data);
+    }
+
+    /** 仅校验外键引用是否存在（供插入/更新路径复用） */
+    _validateForeignKeys(data) {
         for (const fk of this._foreignKeys) {
             if (data[fk.field] !== undefined && data[fk.field] !== null) {
                 const refTable = this._resolveTable(fk.table);
@@ -1504,9 +1511,10 @@ class Table {
                 if (refs.length === 0) continue;
                 const action = (fk.onUpdate || 'restrict').toLowerCase();
                 if (action === 'cascade') {
-                    table.update({ [fk.field]: oldVal }, { [fk.field]: newVal });
+                    // 父行此时还没写入新值，跳过子表 FK 复查
+                    table.update({ [fk.field]: oldVal }, { [fk.field]: newVal }, { skipForeignKeys: true });
                 } else if (action === 'set null') {
-                    table.update({ [fk.field]: oldVal }, { [fk.field]: null });
+                    table.update({ [fk.field]: oldVal }, { [fk.field]: null }, { skipForeignKeys: true });
                 } else {
                     throw createError('ER_ROW_IS_REFERENCED');
                 }

package/lib/tui.js

@@ -252,7 +252,10 @@ class TUIShell {
           else if (b >= 0xe0) n = 3;
           else if (b >= 0xc0) n = 2;
           ch = seq.toString('utf8', i, i + n);
-          step = ch.length || n;
+          // #34：step 必须是 UTF-8 字节数 n，不能是 ch.length（UTF-16 码元数）。
+          // 3 字节 CJK 字符 ch.length=1 而 n=3，若按 1 字节推进 i，剩下的 2 个
+          // 续字节会被当成新字符重新解析，产生乱码并破坏后续输入。
+          step = n;
         }
         this.line = this.line.slice(0, this.cursor) + ch + this.line.slice(this.cursor);
         this.cursor += ch.length;
@@ -305,21 +308,40 @@ class TUIShell {
     return !inSQ && !inDQ && parens <= 0 && (trimmed.endsWith(';') || trimmed.endsWith('\\g'));
   }
 
+  // 返回 cursor 左侧最近的 UTF-16 字符边界（跳过代理对，不把一个码元拆开）
+  _prevChar(c) {
+    if (c <= 0) return 0;
+    const code = this.line.charCodeAt(c - 1);
+    // 低代理（0xDC00-0xDFFF）前面一定是高代理 → 一起回退一个码点
+    if (code >= 0xdc00 && code <= 0xdfff) return c - 2;
+    return c - 1;
+  }
+  // 返回 cursor 右侧最近的 UTF-16 字符边界
+  _nextChar(c) {
+    if (c >= this.line.length) return this.line.length;
+    const code = this.line.charCodeAt(c);
+    // 高代理（0xD800-0xDBFF）后面一定是低代理 → 一起前进一个码点
+    if (code >= 0xd800 && code <= 0xdbff) return c + 2;
+    return c + 1;
+  }
+
   _backspace() {
     if (this.cursor <= 0) return;
-    this.line = this.line.slice(0, this.cursor - 1) + this.line.slice(this.cursor);
-    this.cursor--;
+    const nc = this._prevChar(this.cursor);
+    this.line = this.line.slice(0, nc) + this.line.slice(this.cursor);
+    this.cursor = nc;
     this._redrawPrompt();
   }
 
   _deleteAt() {
     if (this.cursor >= this.line.length) return;
-    this.line = this.line.slice(0, this.cursor) + this.line.slice(this.cursor + 1);
+    const nc = this._nextChar(this.cursor);
+    this.line = this.line.slice(0, this.cursor) + this.line.slice(nc);
     this._redrawPrompt();
   }
 
-  _moveLeft() { if (this.cursor > 0) { this.cursor--; this._redrawPrompt(); } }
-  _moveRight() { if (this.cursor < this.line.length) { this.cursor++; this._redrawPrompt(); } }
+  _moveLeft() { if (this.cursor > 0) { this.cursor = this._prevChar(this.cursor); this._redrawPrompt(); } }
+  _moveRight() { if (this.cursor < this.line.length) { this.cursor = this._nextChar(this.cursor); this._redrawPrompt(); } }
 
   _histPrev() {
     if (this.history.length === 0) return;

package/lib/wasm_client.js

@@ -10,6 +10,18 @@ function safeJsonParse(str) {
   try { return JSON.parse(str); } catch { return str; }
 }
 
+/**
+ * 把 limit / offset / id 规范成非负整数，供 WASM jsql_find 等使用。
+ * 负值/NaN/Infinity 在绑定层抛错，避免 WASM 侧把负值当 usize/i32 出问题（#35）。
+ */
+function toNonNeg(name, v, def) {
+  if (v === undefined || v === null) return def;
+  const n = Number(v);
+  if (!Number.isFinite(n)) throw new Error(`jsql-neo: ${name} must be a finite number, got ${v}`);
+  if (n < 0) throw new Error(`jsql-neo: ${name} must be non-negative, got ${v}`);
+  return Math.trunc(n);
+}
+
 /**
  * 深度相等比较两个行对象（用于无主键表行匹配）。
  * 剥离内部字段（_rid, _deleted）后逐字段比较。
@@ -445,16 +457,24 @@ class JSQL {
   _findRawById(table, id) {
     const pk = this._pkOf(table);
     if (pk) {
+      // 显式拒绝负 id：自增主键场景下会落到 jsql_find(filter) 或 u64 参数，统一语义（issue #35）。
+      const nid = Number(id);
+      if (Number.isFinite(nid) && nid < 0) throw new Error('id must be a non-negative number');
       const filter = {};
       filter[pk] = this._coercePkId(table, id);
       const r = safeJsonParse(wasmBindings.jsql_find(table, JSON.stringify(filter), 1, 0));
       if (r && r.error) return r;
       return Array.isArray(r) && r.length > 0 ? r[0] : null;
     }
-    return safeJsonParse(wasmBindings.jsql_find_by_id(table, BigInt(id)));
+    // 无主键表：id 是 1-based 行号（BigInt 序列）。#35：负数/NaN 会被 WASM 的
+    // u64 参数静默回绕，绑定层显式拒绝（与 native 端校验对齐）。
+    return safeJsonParse(wasmBindings.jsql_find_by_id(table, BigInt(toNonNeg('id', id, 0))));
   }
 
   _seqIdByPk(table, id) {
+    // 负 id 会被后续 BigInt(seq) -> u64 静默回绕（updateById/removeById 等），显式拒绝（issue #35）。
+    const nid0 = Number(id);
+    if (Number.isFinite(nid0) && nid0 < 0) throw new Error('id must be a non-negative number');
     const pk = this._pkOf(table);
     if (pk) {
       const filter = {};
@@ -503,16 +523,44 @@ class JSQL {
       });
     }
     const rawJson = JSON.stringify(rows);
+    const pk = this._pkOf(table);
+    const isAutoPk = this._pkAutoIncrement(table);
+    // #36：旧 WASM 二进制对自增主键表按「保留区间 [next_id, next_id+n)」批量分配 id，
+    // 若某行带了落在该区间内的显式主键，会与另一行的自动 id 冲突、覆盖 pk_index
+    // 遮蔽原行，且返回的 id 列表恒为保留区间（错）。
+    // 解决：显式主键逐行插入（单行批不会与自身保留区间冲突），并把返回 id 映射回
+    // 显式主键值；无显式主键时保持原有批量路径。
+    const hasExplicitPk = isAutoPk && pk && rows.some(row => row[pk] !== undefined && row[pk] !== null);
+    if (hasExplicitPk) {
+      // 旧 WASM 二进制缺重复主键检查：显式插入已存在的主键会覆盖 pk_index
+      // 遮蔽原行。绑定层先查一遍，已存在则报重复主键错（与 add_rows 语义一致）。
+      const seen = new Set();
+      const ids = [];
+      for (const row of rows) {
+        const explicitPk = row[pk] !== undefined && row[pk] !== null ? row[pk] : null;
+        if (explicitPk !== null) {
+          const key = String(explicitPk);
+          if (seen.has(key)) throw new Error(`ER_DUP_ENTRY: Duplicate entry '${explicitPk}' for key '${pk}'`);
+          seen.add(key);
+          const existing = this._findRawById(table, explicitPk);
+          if (existing && !existing.error) {
+            throw new Error(`ER_DUP_ENTRY: Duplicate entry '${explicitPk}' for key '${pk}'`);
+          }
+        }
+        const r = safeJsonParse(wasmBindings.jsql_insert_json(table, JSON.stringify([row])));
+        if (r && r.error) throw new Error(r.error);
+        ids.push(explicitPk !== null ? explicitPk : (Array.isArray(r) ? r[0] : undefined));
+      }
+      return ids;
+    }
     const r = safeJsonParse(wasmBindings.jsql_insert_json(table, rawJson));
     if (r && r.error) throw new Error(r.error);
-    if (r && Array.isArray(r) && !this._pkAutoIncrement(table)) {
-      const pk = this._pkOf(table);
-      if (pk) {
-        return r.map((seq, i) => {
-          const row = rows[i];
-          return (row && row[pk] !== undefined && row[pk] !== null) ? row[pk] : seq;
-        });
-      }
+    // 把返回的序列 id 映射回显式主键（若行内带了主键值），保证返回值正确。
+    if (r && Array.isArray(r) && pk) {
+      return r.map((seq, i) => {
+        const row = rows[i];
+        return (row && row[pk] !== undefined && row[pk] !== null) ? row[pk] : seq;
+      });
     }
     return r;
   }
@@ -653,7 +701,11 @@ class JSQL {
     if (!(await this._runHooks('beforeFind', [table, { filter, opts }]))) return [];
     const filterStr = filter ? JSON.stringify(filter) : '';
     const { limit = 100, offset = 0 } = opts;
-    const r = safeJsonParse(wasmBindings.jsql_find(table, filterStr, limit, offset));
+    // WASM 端 jsql_find 的 limit/offset 是 usize（无符号），负数会经 wasm-bindgen
+    // 静默回绕成巨大值，导致空结果或溢出。#35：绑定层先校验（同 native_client.js）。
+    const lim = toNonNeg('limit', limit, 100);
+    const off = toNonNeg('offset', offset, 0);
+    const r = safeJsonParse(wasmBindings.jsql_find(table, filterStr, lim, off));
     if (r && r.error) throw new Error(r.error);
     await this._runHooks('afterFind', [table, { filter, opts }, r]);
     const schema = this._schemas[table];