jsql-neo 2.2.1 → 3.0.1

package/index.js

@@ -1,14 +1,18 @@
-// © Vexify 2026 All Rights Reserved.
 /**
- * JSQL-NEO — Pure JavaScript Embedded Database
- * v2.1.0 — B-Tree 索引、WAL、哈希 JOIN、Redis 兼容 Cache、事务隔离
+ * JSQL-NEO v3.0.0 — Rust-Powered Embedded Database
  *
  * @example
  * const jsql = require('jsql-neo');
- * const db = new jsql.Database('mydb.json', { wal: true, fileLock: true });
+ * const db = new jsql.JSQL({ port: 6379 });
+ * await db.start();
+ * await db.createTable('users', { name: { type: 'string' }, age: { type: 'integer' } });
+ * await db.insert('users', { name: 'Alice', age: 30 });
+ * const user = await db.findById('users', 1);
+ * await db.stop();
  */
 
 module.exports = {
+    JSQL: require('./lib/client').JSQL,
     Database: require('./lib/database'),
     Table: require('./lib/table'),
     Query: require('./lib/query'),
@@ -17,4 +21,4 @@ module.exports = {
     JSQL_Error: require('./lib/errors').JSQL_Error,
     ErrorCodes: require('./lib/errors').ErrorCodes,
     JSQLFormat: require('./lib/jsql_format')
-};
+};

package/lib/client.js

@@ -0,0 +1,125 @@
+const http = require('http');
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+function binPath() {
+    const dir = path.join(__dirname, '..', 'bin');
+    const name = process.platform === 'win32' ? 'jsql-neo-server.exe' : 'jsql-neo-server';
+    return path.join(dir, name);
+}
+
+class JSQL {
+    constructor(opts = {}) {
+        this.host = opts.host || '127.0.0.1';
+        this.port = opts.port || 6379;
+        this.dataDir = opts.dataDir || null;
+        this._process = null;
+    }
+
+    async start() {
+        if (this._process) return;
+        const bp = binPath();
+        if (!fs.existsSync(bp)) {
+            throw new Error(`jsql-neo-server binary not found at ${bp}. Run 'npm run postinstall' to build it.`);
+        }
+        const args = [];
+        if (this.dataDir) {
+            args.push('--data-dir', this.dataDir);
+        }
+        this._process = spawn(bp, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                JSQL_HOST: this.host,
+                JSQL_PORT: String(this.port),
+                ...(this.dataDir ? { JSQL_DATA_DIR: this.dataDir } : {}),
+            }
+        });
+        this._process.stdout.on('data', d => process.stdout.write(d));
+        this._process.stderr.on('data', d => process.stderr.write(d));
+        this._process.on('exit', (code) => { this._process = null; });
+        await this._waitForServer();
+    }
+
+    async stop() {
+        if (!this._process) return;
+        this._process.kill();
+        await new Promise(r => setTimeout(r, 500));
+        this._process = null;
+    }
+
+    _waitForServer(retries = 20) {
+        return new Promise((resolve, reject) => {
+            const tryConnect = (n) => {
+                if (n <= 0) return reject(new Error('server did not start'));
+                const req = http.get(`http://${this.host}:${this.port}/health`, (res) => {
+                    if (res.statusCode === 200) resolve();
+                    else setTimeout(() => tryConnect(n - 1), 200);
+                });
+                req.on('error', () => setTimeout(() => tryConnect(n - 1), 200));
+                req.setTimeout(500, () => { req.destroy(); setTimeout(() => tryConnect(n - 1), 200); });
+            };
+            tryConnect(retries);
+        });
+    }
+
+    async _request(method, path, body) {
+        return new Promise((resolve, reject) => {
+            const opts = {
+                hostname: this.host,
+                port: this.port,
+                path,
+                method,
+                headers: body ? { 'Content-Type': 'application/json' } : {},
+            };
+            const req = http.request(opts, (res) => {
+                let data = '';
+                res.on('data', c => data += c);
+                res.on('end', () => {
+                    try { resolve(JSON.parse(data)); }
+                    catch (e) { reject(new Error(`invalid JSON: ${data}`)); }
+                });
+            });
+            req.on('error', reject);
+            if (body) req.write(JSON.stringify(body));
+            req.end();
+        });
+    }
+
+    async createTable(name, schema) {
+        return this._request('POST', `/db/${name}`, schema);
+    }
+    async dropTable(name) {
+        return this._request('DELETE', `/db/${name}`);
+    }
+    async insert(table, data) {
+        return this._request('POST', `/db/${table}/insert`, { data: Array.isArray(data) ? data : [data] });
+    }
+    async insertMany(table, data) {
+        return this._request('POST', `/db/${table}/insertMany`, { data });
+    }
+    async findById(table, id) {
+        return this._request('GET', `/db/${table}/${id}`);
+    }
+    async find(table, query = {}) {
+        return this._request('POST', `/db/${table}/find`, query);
+    }
+    async count(table) {
+        return this._request('GET', `/db/${table}/count`);
+    }
+    async updateById(table, id, data) {
+        return this._request('PUT', `/db/${table}/${id}`, { data });
+    }
+    async removeById(table, id) {
+        return this._request('DELETE', `/db/${table}/${id}`);
+    }
+    async updateByFilter(table, filter, data) {
+        return this._request('POST', `/db/${table}/update`, { filter, data });
+    }
+    async removeByFilter(table, filter) {
+        return this._request('POST', `/db/${table}/remove`, { filter });
+    }
+}
+
+module.exports = { JSQL };

package/package.json

@@ -1,33 +1,35 @@
 {
     "name": "jsql-neo",
-    "version": "2.2.1",
-    "description": "JSQL-NEO — Pure JavaScript embedded database with B-Tree indexes, WAL, hash JOIN, Redis-compatible Cache, and MySQL-style error codes",
+    "version": "3.0.1",
+    "description": "JSQL-NEO — Rust-powered embedded database with REST API, B-Tree indexes, WAL, crash recovery",
     "main": "index.js",
     "files": [
         "index.js",
         "lib/",
+        "bin/",
+        "postinstall.js",
         "README.md",
         "LICENSE"
     ],
+    "scripts": {
+        "postinstall": "node postinstall.js",
+        "postinstall:build": "cd ../jsql-neo-server && cargo build --release"
+    },
     "keywords": [
         "database",
         "sql",
         "embedded",
+        "rust",
         "json",
         "javascript",
         "jsql",
         "nosql",
-        "sql-like",
-        "in-memory",
-        "file-based",
-        "btree",
-        "wal",
-        "index",
-        "query-optimizer"
+        "rest-api",
+        "high-performance"
     ],
     "author": "Vexify",
     "license": "Apache-2.0",
     "engines": {
         "node": ">=14.0.0"
     }
-}
+}

package/postinstall.js

@@ -0,0 +1,38 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const BIN_NAME = process.platform === 'win32' ? 'jsql-neo-server.exe' : 'jsql-neo-server';
+const BP = path.join(__dirname, 'bin', BIN_NAME);
+
+function main() {
+    if (fs.existsSync(BP)) {
+        fs.chmodSync(BP, 0o755);
+        console.log(`[jsql-neo] binary ready: ${BP}`);
+        return;
+    }
+
+    // Build from source
+    const serverDir = path.join(__dirname, '..', 'jsql-neo-server');
+    if (fs.existsSync(path.join(serverDir, 'Cargo.toml'))) {
+        console.log('[jsql-neo] building Rust server from source...');
+        try {
+            execSync('cargo build --release', { cwd: serverDir, stdio: 'inherit' });
+            const src = path.join(serverDir, 'target', 'release', BIN_NAME);
+            if (fs.existsSync(src)) {
+                fs.mkdirSync(path.join(__dirname, 'bin'), { recursive: true });
+                fs.copyFileSync(src, BP);
+                fs.chmodSync(BP, 0o755);
+                console.log(`[jsql-neo] binary built: ${BP}`);
+                return;
+            }
+        } catch (e) {
+            console.warn('[jsql-neo] cargo build failed:', e.message);
+        }
+    }
+
+    console.warn(`[jsql-neo] binary not found at ${BP}`);
+    console.warn('[jsql-neo] install Rust from https://rustup.rs and run: npm run build');
+}
+
+main();

package/lib/jsql_format2.js

@@ -1,448 +0,0 @@
-const zlib = require('zlib');
-const crypto = require('crypto');
-const fs = require('fs');
-
-const MAGIC = Buffer.from('4A534F4C', 'hex');
-const VERSION = 1;
-const BLOCK_SIZE = 65536;
-const BLOCK_HEADER_SIZE = 64;
-const BLOCK_DATA_SIZE = BLOCK_SIZE - BLOCK_HEADER_SIZE;
-const SUPERBLOCK_SIZE = 4096;
-
-const BT = { FREE: 0, DATA: 1, PK_INDEX: 2, SUPER: 3 };
-
-const TYPE = {
-  NULL: 0, BOOL: 1, INT: 2, UINT: 3, FLOAT: 4,
-  STRING: 5, BUFFER: 6, ARRAY: 7, OBJECT: 8
-};
-
-function typeTag(v) {
-  if (v === null || v === undefined) return TYPE.NULL;
-  if (typeof v === 'boolean') return TYPE.BOOL;
-  if (typeof v === 'number') return Number.isInteger(v) ? TYPE.INT : TYPE.FLOAT;
-  if (typeof v === 'string') return TYPE.STRING;
-  if (v instanceof Buffer) return TYPE.BUFFER;
-  return Array.isArray(v) ? TYPE.ARRAY : TYPE.OBJECT;
-}
-
-function encodeValue(v) {
-  const tag = typeTag(v);
-  switch (tag) {
-    case TYPE.NULL: return Buffer.from([tag]);
-    case TYPE.BOOL: return Buffer.from([tag, v ? 1 : 0]);
-    case TYPE.INT: { const b = Buffer.alloc(5); b[0] = tag; b.writeInt32LE(v, 1); return b; }
-    case TYPE.UINT: { const b = Buffer.alloc(5); b[0] = tag; b.writeUInt32LE(v, 1); return b; }
-    case TYPE.FLOAT: { const b = Buffer.alloc(9); b[0] = tag; b.writeDoubleLE(v, 1); return b; }
-    case TYPE.STRING: { const s = Buffer.from(v, 'utf8'); const b = Buffer.alloc(5 + s.length); b[0] = tag; b.writeUInt32LE(s.length, 1); s.copy(b, 5); return b; }
-    case TYPE.BUFFER: { const b = Buffer.alloc(5 + v.length); b[0] = tag; b.writeUInt32LE(v.length, 1); v.copy(b, 5); return b; }
-    case TYPE.ARRAY: {
-      const parts = [Buffer.from([tag]), encodeValue(v.length)];
-      for (const item of v) parts.push(encodeValue(item));
-      return Buffer.concat(parts);
-    }
-    case TYPE.OBJECT: {
-      const keys = Object.keys(v);
-      const parts = [Buffer.from([tag]), encodeValue(keys.length)];
-      for (const k of keys) { parts.push(encodeValue(k)); parts.push(encodeValue(v[k])); }
-      return Buffer.concat(parts);
-    }
-  }
-}
-
-function decodeValue(buf, off) {
-  const tag = buf[off++];
-  switch (tag) {
-    case TYPE.NULL: return { v: null, off };
-    case TYPE.BOOL: return { v: buf[off] !== 0, off: off + 1 };
-    case TYPE.INT: return { v: buf.readInt32LE(off), off: off + 4 };
-    case TYPE.UINT: return { v: buf.readUInt32LE(off), off: off + 4 };
-    case TYPE.FLOAT: return { v: buf.readDoubleLE(off), off: off + 8 };
-    case TYPE.STRING: { const len = buf.readUInt32LE(off); off += 4; return { v: buf.toString('utf8', off, off + len), off: off + len }; }
-    case TYPE.BUFFER: { const len = buf.readUInt32LE(off); off += 4; return { v: Buffer.from(buf.subarray(off, off + len)), off: off + len }; }
-    case TYPE.ARRAY: {
-      let r = decodeValue(buf, off); off = r.off;
-      const len = r.v, arr = new Array(len);
-      for (let i = 0; i < len; i++) { r = decodeValue(buf, off); arr[i] = r.v; off = r.off; }
-      return { v: arr, off };
-    }
-    case TYPE.OBJECT: {
-      let r = decodeValue(buf, off); off = r.off;
-      const len = r.v, obj = {};
-      for (let i = 0; i < len; i++) { r = decodeValue(buf, off); const k = r.v; off = r.off; r = decodeValue(buf, off); obj[k] = r.v; off = r.off; }
-      return { v: obj, off };
-    }
-    default: throw new Error('Unknown type: ' + tag);
-  }
-}
-
-function makeBlockHeader(type, seq) {
-  const h = Buffer.alloc(BLOCK_HEADER_SIZE);
-  h.writeUInt32LE(seq, 32);
-  h[36] = type;
-  return h;
-}
-
-function finalizeBlock(block) {
-  const hash = crypto.createHash('sha256').update(block.subarray(32)).digest();
-  hash.copy(block, 0);
-  return block;
-}
-
-function verifyBlockHash(block) {
-  const stored = block.slice(0, 32);
-  const computed = crypto.createHash('sha256').update(block.subarray(32)).digest();
-  return stored.equals(computed);
-}
-
-function encodeRow(row, schema) {
-  const fields = Object.keys(schema).filter(f => f !== '_softDelete');
-  const parts = [encodeValue(fields.length)];
-  for (const f of fields) {
-    parts.push(encodeValue(f));
-    parts.push(encodeValue(row[f]));
-  }
-  return Buffer.concat(parts);
-}
-
-function decodeRow(buf, off) {
-  let r = decodeValue(buf, off); off = r.off;
-  const fieldCount = r.v;
-  const row = {};
-  for (let i = 0; i < fieldCount; i++) {
-    r = decodeValue(buf, off); const field = r.v; off = r.off;
-    r = decodeValue(buf, off); row[field] = r.v; off = r.off;
-  }
-  return { row, off };
-}
-
-class JSQLFile {
-  constructor(path, blockSize = BLOCK_SIZE) {
-    this.path = path;
-    this.blockSize = blockSize;
-    this.dataSize = blockSize - BLOCK_HEADER_SIZE;
-    this.fd = null;
-    this.tables = new Map();
-    this.pkIndex = new Map();
-    this.totalBlocks = 1;
-    this.freeBlocks = [];
-    this.dirty = false;
-  }
-
-  _rowSize(row, schema) {
-    return encodeRow(row, schema).length + 4;
-  }
-
-  open() {
-    if (this.fd) return;
-    if (fs.existsSync(this.path)) {
-      this.fd = fs.openSync(this.path, 'r+');
-      this._load();
-    } else {
-      this.fd = fs.openSync(this.path, 'w+');
-      this._initFile();
-    }
-  }
-
-  close() {
-    if (!this.fd) return;
-    if (this.dirty) this._flush();
-    fs.closeSync(this.fd);
-    this.fd = null;
-  }
-
-  _initFile() {
-    fs.ftruncateSync(this.fd, SUPERBLOCK_SIZE);
-  }
-
-  _load() {
-    const sb = Buffer.alloc(SUPERBLOCK_SIZE);
-    fs.readSync(this.fd, sb, 0, SUPERBLOCK_SIZE, 0);
-    const magic = sb.slice(0, 4);
-    if (magic.compare(MAGIC) !== 0) throw new Error('Not a JSQL file');
-    const version = sb.readUInt16LE(4);
-    this.blockSize = sb.readUInt32LE(6) || BLOCK_SIZE;
-    this.dataSize = this.blockSize - BLOCK_HEADER_SIZE;
-
-    const tableCount = sb.readUInt16LE(10);
-    let off = 12;
-    for (let i = 0; i < tableCount; i++) {
-      const nameLen = Math.min(sb[off], 64);
-      const name = sb.toString('utf8', off + 1, off + 1 + nameLen);
-      off += 1 + nameLen;
-      const schemaLen = sb.readUInt32LE(off); off += 4;
-      const rowCount = sb.readUInt32LE(off); off += 4;
-      const pkBlock = sb.readUInt32LE(off); off += 4;
-      const dataBlock = sb.readUInt32LE(off); off += 4;
-      const schemaStr = sb.toString('utf8', off, off + schemaLen);
-      off += schemaLen;
-
-      this.tables.set(name, {
-        schema: JSON.parse(schemaStr),
-        rowCount, pkBlock, dataBlock
-      });
-
-      // Load PK index
-      this.pkIndex.set(name, this._loadPKIndex(pkBlock));
-    }
-
-    this.totalBlocks = Math.max(1, Math.ceil(fs.fstatSync(this.fd).size / this.blockSize));
-  }
-
-  _loadPKIndex(blockId) {
-    const entries = [];
-    if (blockId < 1 || blockId >= this.totalBlocks) return entries;
-    const buf = Buffer.alloc(this.blockSize);
-    fs.readSync(this.fd, buf, 0, this.blockSize, blockId * this.blockSize);
-    if (!verifyBlockHash(buf)) throw new Error('PK index block corrupted');
-
-    const type = buf[36];
-    if (type !== BT.PK_INDEX) throw new Error('Not a PK index block');
-
-    let off = BLOCK_HEADER_SIZE;
-    const count = buf.readUInt32LE(off); off += 4;
-    for (let i = 0; i < count; i++) {
-      const pkHash = buf.readBigUInt64LE(off); off += 8;
-      const pkOff = buf.readUInt32LE(off); off += 4;
-      const rowLen = buf.readUInt32LE(off); off += 4;
-      const dataBlock = buf.readUInt32LE(off); off += 4;
-      const dataOff = buf.readUInt32LE(off); off += 4;
-      entries.push({ pkHash, pkOff, rowLen, dataBlock, dataOff });
-    }
-    return entries;
-  }
-
-  _savePKIndex(name) {
-    const entries = this.pkIndex.get(name) || [];
-    const table = this.tables.get(name);
-    const buf = Buffer.alloc(this.blockSize);
-    makeBlockHeader(BT.PK_INDEX, table ? table.pkBlock : 0).copy(buf);
-
-    let off = BLOCK_HEADER_SIZE;
-    buf.writeUInt32LE(entries.length, off); off += 4;
-    for (const e of entries) {
-      buf.writeBigUInt64LE(e.pkHash, off); off += 8;
-      buf.writeUInt32LE(e.pkOff, off); off += 4;
-      buf.writeUInt32LE(e.rowLen, off); off += 4;
-      buf.writeUInt32LE(e.dataBlock, off); off += 4;
-      buf.writeUInt32LE(e.dataOff, off); off += 4;
-    }
-    finalizeBlock(buf);
-
-    const blockId = table ? table.pkBlock : this._allocBlock();
-    fs.writeSync(this.fd, buf, 0, this.blockSize, blockId * this.blockSize);
-    if (table) table.pkBlock = blockId;
-    return blockId;
-  }
-
-  _allocBlock() {
-    if (this.freeBlocks.length) return this.freeBlocks.pop();
-    return this.totalBlocks++;
-  }
-
-  _flush() {
-    // Save all PK indexes and superblock
-    for (const name of this.tables.keys()) {
-      this._savePKIndex(name);
-    }
-    this._saveSuperBlock();
-    this.dirty = false;
-  }
-
-  _saveSuperBlock() {
-    const sb = Buffer.alloc(SUPERBLOCK_SIZE);
-    MAGIC.copy(sb, 0);
-    sb.writeUInt16LE(VERSION, 4);
-    sb.writeUInt32LE(this.blockSize, 6);
-    sb.writeUInt16LE(this.tables.size, 10);
-
-    let off = 12;
-    for (const [name, table] of this.tables) {
-      const nameBuf = Buffer.from(name, 'utf8');
-      sb[off] = nameBuf.length; off += 1;
-      nameBuf.copy(sb, off); off += nameBuf.length;
-      const schemaStr = JSON.stringify(table.schema);
-      sb.writeUInt32LE(schemaStr.length, off); off += 4;
-      sb.writeUInt32LE(table.rowCount, off); off += 4;
-      sb.writeUInt32LE(table.pkBlock || 0, off); off += 4;
-      sb.writeUInt32LE(table.dataBlock || 0, off); off += 4;
-      Buffer.from(schemaStr, 'utf8').copy(sb, off); off += schemaStr.length;
-    }
-
-    fs.writeSync(this.fd, sb, 0, SUPERBLOCK_SIZE, 0);
-    fs.fsyncSync(this.fd);
-  }
-
-  writeTable(name, schema, rows, pkField) {
-    this.open();
-    const table = this.tables.get(name) || { schema, rowCount: 0, pkBlock: 0, dataBlock: 0 };
-    table.schema = schema;
-    this.tables.set(name, table);
-
-    const pkEntries = [];
-    let currentBlock = this._allocBlock();
-    let blockBuf = Buffer.alloc(this.blockSize);
-    let blockOff = BLOCK_HEADER_SIZE;
-    let seq = currentBlock;
-    let hasData = false;
-
-    makeBlockHeader(BT.DATA, seq).copy(blockBuf);
-
-    for (const row of rows) {
-      const rowData = encodeRow(row, schema);
-      const rowLen = rowData.length + 4;
-      const lenBuf = Buffer.alloc(4);
-      lenBuf.writeUInt32LE(rowData.length);
-
-      if (blockOff + rowLen > this.blockSize) {
-        // Flush current block
-        blockBuf.writeUInt16LE(0, 38); // rowCount
-        // Actually write row count
-        // We need to track rows per block properly
-        const written = blockOff - BLOCK_HEADER_SIZE;
-        blockBuf.writeUInt32LE(written, 40); // data size
-
-        // Compress
-        const rawData = blockBuf.slice(BLOCK_HEADER_SIZE, blockOff);
-        const compressed = zlib.gzipSync(rawData, { level: 6 });
-        compressed.copy(blockBuf, BLOCK_HEADER_SIZE);
-        blockBuf.writeUInt32LE(compressed.length, 44);
-        blockBuf[48] = 1; // compressed flag
-
-        // TODO: track row count properly
-        finalizeBlock(blockBuf);
-        fs.writeSync(this.fd, blockBuf, 0, this.blockSize, currentBlock * this.blockSize);
-
-        // New block
-        currentBlock = this._allocBlock();
-        seq = currentBlock;
-        blockBuf = Buffer.alloc(this.blockSize);
-        blockOff = BLOCK_HEADER_SIZE;
-        makeBlockHeader(BT.DATA, seq).copy(blockBuf);
-      }
-
-      lenBuf.copy(blockBuf, blockOff); blockOff += 4;
-      rowData.copy(blockBuf, blockOff); blockOff += rowData.length;
-      hasData = true;
-
-      if (pkField && row[pkField] !== undefined) {
-        const pkVal = row[pkField];
-        const pkHash = BigInt(hashPK(pkVal));
-        pkEntries.push({ pkHash, pkOff: 0, rowLen: rowData.length, dataBlock: currentBlock, dataOff: blockOff - rowData.length - 4, pkVal });
-      }
-    }
-
-    if (hasData) {
-      const written = blockOff - BLOCK_HEADER_SIZE;
-      blockBuf.writeUInt32LE(written, 40);
-      const rawData = blockBuf.slice(BLOCK_HEADER_SIZE, blockOff);
-      const compressed = zlib.gzipSync(rawData, { level: 6 });
-      compressed.copy(blockBuf, BLOCK_HEADER_SIZE);
-      blockBuf.writeUInt32LE(compressed.length, 44);
-      blockBuf[48] = 1;
-      finalizeBlock(blockBuf);
-      fs.writeSync(this.fd, blockBuf, 0, this.blockSize, currentBlock * this.blockSize);
-    }
-
-    table.rowCount = rows.length;
-    table.dataBlock = seq;
-
-    // Sort PK entries by hash for binary search
-    pkEntries.sort((a, b) => a.pkHash < b.pkHash ? -1 : a.pkHash > b.pkHash ? 1 : 0);
-    this.pkIndex.set(name, pkEntries.map(e => ({ pkHash: e.pkHash, pkOff: 0, rowLen: e.rowLen, dataBlock: e.dataBlock, dataOff: e.dataOff })));
-    this._savePKIndex(name);
-    this._saveSuperBlock();
-    this.dirty = false;
-  }
-
-  readTable(name) {
-    this.open();
-    const table = this.tables.get(name);
-    if (!table) return { schema: null, rows: [] };
-
-    const rows = [];
-    const entries = this.pkIndex.get(name) || [];
-
-    // Collect unique blocks
-    const blockMap = new Map();
-    for (const e of entries) {
-      if (!blockMap.has(e.dataBlock)) blockMap.set(e.dataBlock, new Map());
-      blockMap.get(e.dataBlock).set(e.dataOff, e);
-    }
-
-    for (const [blockId, blockEntries] of blockMap) {
-      const buf = Buffer.alloc(this.blockSize);
-      fs.readSync(this.fd, buf, 0, this.blockSize, blockId * this.blockSize);
-      if (!verifyBlockHash(buf)) throw new Error('Block corrupted: ' + blockId);
-
-      const compressed = buf[48] === 1;
-      const compSize = buf.readUInt32LE(44);
-      let rawData;
-      if (compressed) {
-        rawData = zlib.gunzipSync(buf.slice(BLOCK_HEADER_SIZE, BLOCK_HEADER_SIZE + compSize));
-      } else {
-        rawData = buf.slice(BLOCK_HEADER_SIZE, BLOCK_HEADER_SIZE + buf.readUInt32LE(40));
-      }
-
-      // Read all rows from this block
-      let off = 0;
-      while (off < rawData.length) {
-        const rowLen = rawData.readUInt32LE(off); off += 4;
-        if (rowLen === 0 || off + rowLen > rawData.length) break;
-        const r = decodeRow(rawData, off);
-        rows.push(r.row);
-        off += rowLen;
-      }
-    }
-
-    return { schema: table.schema, rows };
-  }
-
-  readRowByName(name, pkField, pkValue) {
-    this.open();
-    const table = this.tables.get(name);
-    if (!table) return null;
-
-    const entries = this.pkIndex.get(name) || [];
-    const targetHash = BigInt(hashPK(pkValue));
-
-    // Binary search
-    let lo = 0, hi = entries.length - 1;
-    while (lo <= hi) {
-      const mid = (lo + hi) >>> 1;
-      const e = entries[mid];
-      if (e.pkHash === targetHash) return this._readRowAt(e.dataBlock, e.dataOff, e.rowLen);
-      if (e.pkHash < targetHash) lo = mid + 1;
-      else hi = mid - 1;
-    }
-    return null;
-  }
-
-  _readRowAt(blockId, dataOff, rowLen) {
-    const buf = Buffer.alloc(this.blockSize);
-    fs.readSync(this.fd, buf, 0, this.blockSize, blockId * this.blockSize);
-
-    const compressed = buf[48] === 1;
-    const compSize = buf.readUInt32LE(44);
-    let rawData;
-    if (compressed) {
-      rawData = zlib.gunzipSync(buf.slice(BLOCK_HEADER_SIZE, BLOCK_HEADER_SIZE + compSize));
-    } else {
-      rawData = buf.slice(BLOCK_HEADER_SIZE, BLOCK_HEADER_SIZE + buf.readUInt32LE(40));
-    }
-
-    const off = dataOff - (blockId * this.blockSize + BLOCK_HEADER_SIZE) + BLOCK_HEADER_SIZE;
-    const r = decodeRow(rawData, dataOff);
-    return r.row;
-  }
-}
-
-function hashPK(val) {
-  const s = String(val);
-  let h = 0;
-  for (let i = 0; i < s.length; i++) {
-    h = (Math.imul(h, 31) + s.charCodeAt(i)) | 0;
-  }
-  return h >>> 0;
-}
-
-module.exports = { JSQLFile, hashPK, encodeRow, decodeRow };