@dbcube/core 5.2.1 → 5.2.3

package/dist/index.js

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/lib/Engine.ts
 import path4 from "path";
 
@@ -132,7 +139,7 @@ import * as unzipper from "unzipper";
 import ora from "ora";
 import chalk from "chalk";
 import { fileURLToPath } from "url";
-import { dirname } from "path";
+import { dirname as dirname2 } from "path";
 var { https } = followRedirects;
 var Downloader = class {
   static mainSpinner = null;
@@ -147,7 +154,7 @@ var Downloader = class {
    */
   static async fetchLatestVersion(prefix) {
     const url = this.VERSION_URLS[prefix];
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       https.get(url, (response) => {
         let data = "";
         response.on("data", (chunk) => {
@@ -157,7 +164,7 @@ var Downloader = class {
           try {
             const versions = JSON.parse(data);
             if (versions && versions.length > 0) {
-              resolve5(versions[0].version);
+              resolve6(versions[0].version);
             } else {
               reject(new Error("No versions found"));
             }
@@ -366,7 +373,7 @@ var Downloader = class {
             if (attempt < maxRetries && (errorMessage.includes("ECONNRESET") || errorMessage.includes("timeout") || errorMessage.includes("ETIMEDOUT") || errorMessage.includes("ENOTFOUND"))) {
               attempt++;
               console.log(`\u{1F504} Retrying ${binary.prefix}-engine (${attempt}/${maxRetries})...`);
-              await new Promise((resolve5) => setTimeout(resolve5, 1e3 + Math.random() * 1e3));
+              await new Promise((resolve6) => setTimeout(resolve6, 1e3 + Math.random() * 1e3));
             } else {
               throw new Error(`Error downloading ${binary.prefix}: ${errorMessage}`);
             }
@@ -414,12 +421,12 @@ var Downloader = class {
     return `[${filledBar}${emptyBar}] ${percentage}`;
   }
   static downloadFileWithProgress(url, outputPath, prefix) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const request = https.get(url, { timeout: 0 }, (response) => {
         if (response.statusCode === 302 || response.statusCode === 301) {
           const redirectUrl = response.headers.location;
           if (redirectUrl) {
-            return this.downloadFileWithProgress(redirectUrl, outputPath, prefix).then(resolve5).catch(reject);
+            return this.downloadFileWithProgress(redirectUrl, outputPath, prefix).then(resolve6).catch(reject);
           }
         }
         if (response.statusCode !== 200) {
@@ -442,7 +449,7 @@ var Downloader = class {
           }
         });
         response.on("end", () => {
-          file.end(() => resolve5());
+          file.end(() => resolve6());
         });
         response.on("error", (err) => {
           file.close();
@@ -474,35 +481,47 @@ var Downloader = class {
     this.mainSpinner.text = `\u{1F4E5} ${chalk.bold(binary)} - ${progressText}`;
   }
   static extractBinary(zipPath, outputPath, prefix) {
-    return new Promise((resolve5, reject) => {
-      let extracted = false;
+    return new Promise((resolve6, reject) => {
+      const outDir = path.dirname(outputPath);
+      let extracted = 0;
+      const pending = [];
       fs.createReadStream(zipPath).pipe(unzipper.Parse()).on("entry", (entry) => {
-        if (entry.type === "File" && !extracted) {
-          extracted = true;
-          const writeStream = fs.createWriteStream(outputPath);
+        if (entry.type !== "File") {
+          entry.autodrain();
+          return;
+        }
+        const isMain = extracted === 0;
+        extracted++;
+        const target = isMain ? outputPath : path.join(outDir, path.basename(entry.path));
+        pending.push(new Promise((res, rej) => {
+          const writeStream = fs.createWriteStream(target);
           entry.pipe(writeStream);
           writeStream.on("finish", () => {
             if (process.platform !== "win32") {
-              fs.chmodSync(outputPath, 493);
+              try {
+                fs.chmodSync(target, 493);
+              } catch {
+              }
             }
-            this.cleanupFile(zipPath);
-            resolve5();
-          });
-          writeStream.on("error", (err) => {
-            this.cleanupFile(zipPath);
-            reject(err);
+            res();
           });
-        } else {
-          entry.autodrain();
-        }
+          writeStream.on("error", rej);
+        }));
       }).on("error", (err) => {
         this.cleanupFile(zipPath);
         reject(err);
       }).on("close", () => {
-        if (!extracted) {
+        Promise.all(pending).then(() => {
           this.cleanupFile(zipPath);
-          reject(new Error(`No se encontr\xF3 archivo v\xE1lido en el ZIP para ${prefix}`));
-        }
+          if (extracted === 0) {
+            reject(new Error(`No se encontr\xF3 archivo v\xE1lido en el ZIP para ${prefix}`));
+          } else {
+            resolve6();
+          }
+        }).catch((err) => {
+          this.cleanupFile(zipPath);
+          reject(err);
+        });
       });
     });
   }
@@ -516,7 +535,7 @@ var Downloader = class {
   }
   static getDefaultBinDir() {
     const __filename2 = typeof import.meta !== "undefined" && import.meta.url ? fileURLToPath(import.meta.url) : "";
-    const __dirname = __filename2 ? dirname(__filename2) : process.cwd();
+    const __dirname = __filename2 ? dirname2(__filename2) : process.cwd();
     const possibleDirs = [
       path.resolve(process.cwd(), ".dbcube", "bin"),
       path.resolve(process.cwd(), "node_modules", ".dbcube", "bin"),
@@ -546,7 +565,7 @@ import * as fs2 from "fs";
 import * as path2 from "path";
 import * as os3 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname3 } from "path";
 var Binary = class {
   static isDownloading = false;
   static downloadPromise = null;
@@ -579,7 +598,7 @@ var Binary = class {
   }
   static getBinDir() {
     const __filename2 = typeof import.meta !== "undefined" && import.meta.url ? fileURLToPath2(import.meta.url) : "";
-    const __dirname = __filename2 ? dirname2(__filename2) : process.cwd();
+    const __dirname = __filename2 ? dirname3(__filename2) : process.cwd();
     const possibleDirs = [
       path2.resolve(process.cwd(), ".dbcube", "bin"),
       path2.resolve(process.cwd(), "node_modules", ".dbcube", "bin"),
@@ -816,22 +835,22 @@ var DaemonClient = class _DaemonClient {
     child.unref();
   }
   tryConnect(port) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const socket = net.createConnection({ host: "127.0.0.1", port }, async () => {
         socket.setNoDelay(true);
         this.attach(socket);
         try {
           const pong = await this.send({ action: "ping" }, 2e3);
-          resolve5(pong.status === 200);
+          resolve6(pong.status === 200);
         } catch {
           this.detach();
-          resolve5(false);
+          resolve6(false);
         }
       });
-      socket.once("error", () => resolve5(false));
+      socket.once("error", () => resolve6(false));
       socket.setTimeout(3e3, () => {
         socket.destroy();
-        resolve5(false);
+        resolve6(false);
       });
     });
   }
@@ -879,7 +898,7 @@ var DaemonClient = class _DaemonClient {
    * single socket, so pending requests resolve in send order.
    */
   send(payload, timeoutMs) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       if (!this.socket || this.socket.destroyed) {
         reject(new Error("Daemon not connected"));
         return;
@@ -890,12 +909,12 @@ var DaemonClient = class _DaemonClient {
         reject(new Error("Daemon request timeout"));
         this.detach();
       }, timeoutMs ?? this.requestTimeout);
-      this.pending.push({ resolve: resolve5, reject, timer });
+      this.pending.push({ resolve: resolve6, reject, timer });
       this.socket.write(JSON.stringify(payload) + "\n");
     });
   }
   async execute(dml, txId) {
-    const payload = { action: "execute", dml: JSON.stringify(dml) };
+    const payload = { action: "execute", dml };
     if (txId) payload.tx_id = txId;
     return this.send(payload);
   }
@@ -962,8 +981,8 @@ var Engine = class {
     const binaryPath = this.binary["query_engine"];
     if (!binaryPath) return null;
     const client = DaemonClient.get(this.name, binaryPath, this.arguments);
-    const ok = await client.ensure();
-    if (!ok) {
+    const ok2 = await client.ensure();
+    if (!ok2) {
       this.daemonFailed = true;
       return null;
     }
@@ -1094,7 +1113,7 @@ var Engine = class {
     if (!this.binary) {
       throw new Error("Binary not initialized");
     }
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const child = spawn2(this.binary[binary], [...this.arguments, ...args]);
       let stdoutBuffer = "";
       let stderrBuffer = "";
@@ -1110,18 +1129,18 @@ var Engine = class {
         if (!isResolved) {
           isResolved = true;
           clearTimeout(timeoutId);
-          resolve5(response);
+          resolve6(response);
         }
       };
-      child.stdout.on("data", (data) => {
-        const text = data.toString();
-        stdoutBuffer += text;
-        const visible = text.split("\n").filter((l) => l.trim() && !l.includes("PROCESS_RESPONSE:")).join("\n");
-        if (visible) console.log(visible);
-        const match = stdoutBuffer.match(/PROCESS_RESPONSE:(\{.*\})/);
-        if (match) {
+      const tryParseLines = (buffer) => {
+        let idx;
+        while ((idx = buffer.indexOf("\n")) !== -1) {
+          const line = buffer.slice(0, idx);
+          buffer = buffer.slice(idx + 1);
+          const marker = line.indexOf("PROCESS_RESPONSE:");
+          if (marker === -1) continue;
           try {
-            const response = JSON.parse(match[1]);
+            const response = JSON.parse(line.slice(marker + "PROCESS_RESPONSE:".length));
             resolveOnce({
               status: response.status,
               message: response.message,
@@ -1135,29 +1154,19 @@ var Engine = class {
             });
           }
         }
+        return buffer;
+      };
+      child.stdout.on("data", (data) => {
+        const text = data.toString();
+        const visible = text.split("\n").filter((l) => l.trim() && !l.includes("PROCESS_RESPONSE:")).join("\n");
+        if (visible) console.log(visible);
+        stdoutBuffer = tryParseLines(stdoutBuffer + text);
       });
       child.stderr.on("data", (data) => {
         const text = data.toString();
-        stderrBuffer += text;
         const visible = text.split("\n").filter((l) => l.trim() && !l.includes("PROCESS_RESPONSE:")).join("\n");
         if (visible) console.log(visible);
-        const match = stderrBuffer.match(/PROCESS_RESPONSE:(\{.*\})/);
-        if (match) {
-          try {
-            const response = JSON.parse(match[1]);
-            resolveOnce({
-              status: response.status,
-              message: response.message,
-              data: response.data
-            });
-          } catch (error) {
-            resolveOnce({
-              status: 500,
-              message: "Failed to parse response JSON",
-              data: null
-            });
-          }
-        }
+        stderrBuffer = tryParseLines(stderrBuffer + text);
       });
       child.on("close", (code) => {
         clearTimeout(timeoutId);
@@ -1185,14 +1194,265 @@ var Engine = class {
 };
 
 // src/lib/QueryEngine.ts
-import path5 from "path";
+import path6 from "path";
+
+// src/lib/EmbeddedEngine.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+if (!process.env.UV_THREADPOOL_SIZE) {
+  process.env.UV_THREADPOOL_SIZE = "16";
+}
+var backend = null;
+var loadFailed = false;
+var handles = /* @__PURE__ */ new Map();
+var connecting = /* @__PURE__ */ new Map();
+function platTag() {
+  const arch2 = process.arch === "arm64" ? "arm64" : "x64";
+  if (process.platform === "win32") return { plat: "windows", ext: "dll", arch: arch2 };
+  if (process.platform === "darwin") return { plat: "macos", ext: "dylib", arch: arch2 };
+  return { plat: "linux", ext: "so", arch: arch2 };
+}
+function findFile(name) {
+  const candidates = [
+    path5.resolve(process.cwd(), ".dbcube", "bin", name),
+    path5.resolve(process.cwd(), "node_modules", ".dbcube", "bin", name)
+  ];
+  for (const c of candidates) {
+    if (fs4.existsSync(c)) return c;
+  }
+  return null;
+}
+function ok(data) {
+  return { status: 200, message: "OK", data };
+}
+function errResp(e) {
+  const msg = e instanceof Error ? e.message : String(e);
+  return { status: 500, message: msg, data: null };
+}
+function loadNapiBackend() {
+  const { plat, arch: arch2 } = platTag();
+  const addonPath = findFile(`query-engine-node-${plat}-${arch2}.node`);
+  if (!addonPath) return null;
+  try {
+    const addon = __require(addonPath);
+    if (typeof addon.connect !== "function") return null;
+    return {
+      async connect(cfgJson) {
+        return Number(await addon.connect(cfgJson));
+      },
+      async execute(handle, dml, txId) {
+        try {
+          const rows = await addon.execute(handle, dml, txId ?? void 0);
+          return ok(rows);
+        } catch (e) {
+          return errResp(e);
+        }
+      },
+      async executeBatch(handle, ops) {
+        try {
+          const results = await addon.executeBatch(handle, ops);
+          return ok(results);
+        } catch (e) {
+          return errResp(e);
+        }
+      },
+      async raw(handle, query, params, txId) {
+        try {
+          const rows = await addon.raw(handle, query, params, txId ?? void 0);
+          return ok(rows);
+        } catch (e) {
+          return errResp(e);
+        }
+      },
+      async begin(handle) {
+        try {
+          const txId = await addon.begin(handle);
+          return ok({ tx_id: txId });
+        } catch (e) {
+          return errResp(e);
+        }
+      },
+      async commit(_handle, txId) {
+        try {
+          await addon.commit(txId);
+          return ok(null);
+        } catch (e) {
+          return errResp(e);
+        }
+      },
+      async rollback(_handle, txId) {
+        try {
+          await addon.rollback(txId);
+          return ok(null);
+        } catch (e) {
+          return errResp(e);
+        }
+      },
+      async disconnect(handle) {
+        try {
+          addon.disconnect(handle);
+        } catch {
+        }
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+function loadKoffiBackend() {
+  const { plat, ext, arch: arch2 } = platTag();
+  const libPath = findFile(`query-engine-embedded-${plat}-${arch2}.${ext}`);
+  if (!libPath) return null;
+  try {
+    const koffi = __require("koffi");
+    const lib = koffi.load(libPath);
+    const cConnect = lib.func("dbc_connect", "void *", ["str"]);
+    const cExecute = lib.func("dbc_execute", "void *", ["uint64", "str", "str"]);
+    const cExecuteBatch = lib.func("dbc_execute_batch", "void *", ["uint64", "str"]);
+    const cRaw = lib.func("dbc_raw", "void *", ["uint64", "str", "str", "str"]);
+    const cBegin = lib.func("dbc_begin", "void *", ["uint64"]);
+    const cCommit = lib.func("dbc_commit", "void *", ["uint64", "str"]);
+    const cRollback = lib.func("dbc_rollback", "void *", ["uint64", "str"]);
+    const cDisconnect = lib.func("dbc_disconnect", "void *", ["uint64"]);
+    const cFree = lib.func("dbc_free", "void", ["void *"]);
+    const take = (ptr) => {
+      if (!ptr) return { status: 500, message: "embedded engine returned null", data: null };
+      const s = koffi.decode(ptr, "char", -1);
+      cFree(ptr);
+      try {
+        const r = JSON.parse(s);
+        return { status: r.status ?? 500, message: r.message ?? "", data: r.data ?? null };
+      } catch (e) {
+        return { status: 500, message: `Invalid embedded response: ${e.message}`, data: null };
+      }
+    };
+    const call = (fn, ...args) => new Promise((resolve6, reject) => {
+      fn.async(...args, (err, ptr) => {
+        if (err) return reject(err);
+        resolve6(take(ptr));
+      });
+    });
+    return {
+      async connect(cfgJson) {
+        const res = await call(cConnect, cfgJson);
+        if (res.status !== 200 || !res.data?.handle) {
+          throw new Error(String(res.message || "embedded connect failed"));
+        }
+        return Number(res.data.handle);
+      },
+      execute: (handle, dml, txId) => call(cExecute, handle, JSON.stringify(dml), txId),
+      executeBatch: (handle, ops) => call(cExecuteBatch, handle, JSON.stringify(ops)),
+      raw: (handle, query, params, txId) => call(cRaw, handle, query, JSON.stringify(params ?? []), txId),
+      begin: (handle) => call(cBegin, handle),
+      commit: (handle, txId) => call(cCommit, handle, txId),
+      rollback: (handle, txId) => call(cRollback, handle, txId),
+      async disconnect(handle) {
+        try {
+          await call(cDisconnect, handle);
+        } catch {
+        }
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+function loadBackend() {
+  if (backend) return backend;
+  if (loadFailed) return null;
+  if (process.env.DBCUBE_EMBEDDED === "0" || process.env.DBCUBE_EMBEDDED === "false") {
+    loadFailed = true;
+    return null;
+  }
+  backend = loadNapiBackend() ?? loadKoffiBackend();
+  if (!backend) loadFailed = true;
+  return backend;
+}
+var EmbeddedEngine = class {
+  /** true si algún backend nativo está disponible en esta instalación. */
+  static available() {
+    return loadBackend() !== null;
+  }
+  static async handleFor(connectionId, config) {
+    const existing = handles.get(connectionId);
+    if (existing) return existing;
+    const inFlight = connecting.get(connectionId);
+    if (inFlight) return inFlight;
+    const promise = (async () => {
+      const be = loadBackend();
+      if (!be) throw new Error("embedded engine not available");
+      const motor = config.type === "postgres" ? "postgresql" : config.type;
+      const cfg = {
+        databaseRef: connectionId,
+        motor,
+        database: config.type === "sqlite" ? `${config.config.DATABASE}.db` : config.config.DATABASE,
+        host: config.config.HOST,
+        port: config.config.PORT != null ? Number(config.config.PORT) : void 0,
+        user: config.config.USER,
+        password: config.config.PASSWORD,
+        maxConnections: config.pool?.maxConnections,
+        minConnections: config.pool?.minConnections,
+        acquireTimeoutMs: config.pool?.acquireTimeoutMs,
+        idleTimeoutMs: config.pool?.idleTimeoutMs
+      };
+      const handle = await be.connect(JSON.stringify(cfg));
+      handles.set(connectionId, handle);
+      return handle;
+    })();
+    connecting.set(connectionId, promise);
+    try {
+      return await promise;
+    } finally {
+      connecting.delete(connectionId);
+    }
+  }
+  static async executeDml(connectionId, config, dml, txId) {
+    const be = loadBackend();
+    const handle = await this.handleFor(connectionId, config);
+    return be.execute(handle, dml, txId ?? null);
+  }
+  static async executeBatch(connectionId, config, ops) {
+    const be = loadBackend();
+    const handle = await this.handleFor(connectionId, config);
+    return be.executeBatch(handle, ops);
+  }
+  static async rawQuery(connectionId, config, query, params, txId) {
+    const be = loadBackend();
+    const handle = await this.handleFor(connectionId, config);
+    return be.raw(handle, query, params ?? [], txId ?? null);
+  }
+  static async begin(connectionId, config) {
+    const be = loadBackend();
+    const handle = await this.handleFor(connectionId, config);
+    return be.begin(handle);
+  }
+  static async commit(connectionId, config, txId) {
+    const be = loadBackend();
+    const handle = await this.handleFor(connectionId, config);
+    return be.commit(handle, txId);
+  }
+  static async rollback(connectionId, config, txId) {
+    const be = loadBackend();
+    const handle = await this.handleFor(connectionId, config);
+    return be.rollback(handle, txId);
+  }
+  static async disconnect(connectionId) {
+    const be = loadBackend();
+    const handle = handles.get(connectionId);
+    if (be && handle) {
+      handles.delete(connectionId);
+      await be.disconnect(handle);
+    }
+  }
+};
+
+// src/lib/QueryEngine.ts
 import { createRequire as createRequire2 } from "module";
 import * as net2 from "net";
 import { spawn as spawn3 } from "child_process";
 var globalTcpServers = /* @__PURE__ */ new Map();
-var globalTcpConnections = /* @__PURE__ */ new Map();
-var connectionQueues = /* @__PURE__ */ new Map();
-var connectionProcessing = /* @__PURE__ */ new Map();
+var socketPools = /* @__PURE__ */ new Map();
+var CLIENT_POOL_SIZE = 10;
 var queryCache = /* @__PURE__ */ new Map();
 var MAX_CACHE_SIZE = 500;
 var QueryEngine = class {
@@ -1223,12 +1483,12 @@ var QueryEngine = class {
     throw new Error("No available ports found in range 9900-9944");
   }
   isPortAvailable(port) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const tester = net2.createServer();
-      tester.once("error", () => resolve5(false));
+      tester.once("error", () => resolve6(false));
       tester.once("listening", () => {
         tester.close();
-        resolve5(true);
+        resolve6(true);
       });
       tester.listen(port, "127.0.0.1");
     });
@@ -1289,7 +1549,7 @@ var QueryEngine = class {
   setConfig(name) {
     const configInstance = new Config();
     try {
-      const configFilePath = path5.resolve(process.cwd(), "dbcube.config.js");
+      const configFilePath = path6.resolve(process.cwd(), "dbcube.config.js");
       const requireUrl = typeof __filename !== "undefined" ? __filename : process.cwd();
       const require2 = createRequire2(requireUrl);
       if (require2.cache && require2.resolve) {
@@ -1335,38 +1595,79 @@ var QueryEngine = class {
     }
     return command;
   }
+  /** El motor embebido (FFI) es el camino por defecto cuando la librería
+   *  nativa está disponible; el daemon TCP queda como fallback y como modo
+   *  multi-proceso explícito. */
+  useEmbedded() {
+    return EmbeddedEngine.available();
+  }
   /**
-   * Executes a DML plan over the persistent TCP server.
+   * Executes a DML plan. Embedded engine when available (in-process FFI,
+   * no network hop); persistent TCP daemon otherwise.
    * Pass txId to run it inside an active transaction.
    */
   async executeDml(dml, txId) {
-    const command = { action: "execute", dml: JSON.stringify(dml) };
+    if (this.useEmbedded()) {
+      return EmbeddedEngine.executeDml(this.connectionId, this.config, dml, txId);
+    }
+    const command = { action: "execute", dml };
     if (txId) command.tx_id = txId;
     return this.executeWithTcpServer(command);
   }
   /**
-   * Executes raw SQL (or a MongoDB command document) with bound parameters
-   * over the persistent TCP server.
+   * Atomic batch: N write plans inside one transaction with a single
+   * engine round-trip. Falls back to begin/ops/commit over the daemon
+   * when the embedded engine is not available.
+   */
+  async executeBatch(ops) {
+    if (this.useEmbedded()) {
+      return EmbeddedEngine.executeBatch(this.connectionId, this.config, ops);
+    }
+    const txId = await this.beginTransaction();
+    try {
+      const results = [];
+      for (const op of ops) {
+        const res = await this.executeDml(op, txId);
+        if (res.status !== 200) {
+          throw new Error(String(res.message));
+        }
+        results.push(res.data);
+      }
+      await this.commitTransaction(txId);
+      return { status: 200, message: "Batch committed", data: results };
+    } catch (error) {
+      try {
+        await this.rollbackTransaction(txId);
+      } catch {
+      }
+      return { status: 500, message: error?.message ?? String(error), data: null };
+    }
+  }
+  /**
+   * Executes raw SQL (or a MongoDB command document) with bound parameters.
    */
   async rawQuery(query, params = [], txId) {
+    if (this.useEmbedded()) {
+      return EmbeddedEngine.rawQuery(this.connectionId, this.config, query, params, txId);
+    }
     const command = { action: "raw", query, params };
     if (txId) command.tx_id = txId;
     return this.executeWithTcpServer(command);
   }
-  /** Starts a server-side transaction and returns its id. */
+  /** Starts a transaction and returns its id. */
   async beginTransaction() {
-    const res = await this.executeWithTcpServer({ action: "begin" });
+    const res = this.useEmbedded() ? await EmbeddedEngine.begin(this.connectionId, this.config) : await this.executeWithTcpServer({ action: "begin" });
     if (res.status !== 200 || !res.data?.tx_id) {
       throw new Error(String(res.message || "Failed to begin transaction (update the query-engine binary: npx dbcube update)"));
     }
     return res.data.tx_id;
   }
   async commitTransaction(txId) {
-    const res = await this.executeWithTcpServer({ action: "commit", tx_id: txId });
+    const res = this.useEmbedded() ? await EmbeddedEngine.commit(this.connectionId, this.config, txId) : await this.executeWithTcpServer({ action: "commit", tx_id: txId });
     if (res.status !== 200) throw new Error(String(res.message || "Failed to commit transaction"));
   }
   async rollbackTransaction(txId) {
-    const res = await this.executeWithTcpServer({ action: "rollback", tx_id: txId });
+    const res = this.useEmbedded() ? await EmbeddedEngine.rollback(this.connectionId, this.config, txId) : await this.executeWithTcpServer({ action: "rollback", tx_id: txId });
     if (res.status !== 200) throw new Error(String(res.message || "Failed to rollback transaction"));
   }
   async executeWithTcpServer(command) {
@@ -1385,7 +1686,63 @@ var QueryEngine = class {
       await this.startTcpServer();
       await this.waitForServerReady();
     }
-    return this.sendTcpRequestFast(command);
+    const port = globalTcpServers.get(this.connectionId).port;
+    const socket = await this.acquireSocket(port);
+    try {
+      const result = await this.executeOnConnection(socket, command);
+      this.releaseSocket(socket, false);
+      return result;
+    } catch (error) {
+      this.releaseSocket(socket, true);
+      throw error;
+    }
+  }
+  poolFor() {
+    let pool = socketPools.get(this.connectionId);
+    if (!pool) {
+      pool = { free: [], total: 0, waiters: [] };
+      socketPools.set(this.connectionId, pool);
+    }
+    return pool;
+  }
+  async acquireSocket(port) {
+    const pool = this.poolFor();
+    while (pool.free.length > 0) {
+      const s = pool.free.pop();
+      if (!s.destroyed) return s;
+      pool.total--;
+    }
+    if (pool.total < CLIENT_POOL_SIZE) {
+      pool.total++;
+      try {
+        return await this.createNewConnection(port);
+      } catch (e) {
+        pool.total--;
+        throw e;
+      }
+    }
+    return new Promise((resolve6) => pool.waiters.push(resolve6));
+  }
+  releaseSocket(socket, broken) {
+    const pool = socketPools.get(this.connectionId);
+    if (!pool) {
+      socket.destroy();
+      return;
+    }
+    if (broken || socket.destroyed) {
+      pool.total--;
+      try {
+        socket.destroy();
+      } catch {
+      }
+      return;
+    }
+    const waiter = pool.waiters.shift();
+    if (waiter) {
+      waiter(socket);
+    } else {
+      pool.free.push(socket);
+    }
   }
   async waitForServerReady() {
     const maxRetries = 10;
@@ -1403,25 +1760,25 @@ var QueryEngine = class {
     throw new Error("TCP server failed to become ready within timeout");
   }
   async isServerResponding(port) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const client = new net2.Socket();
       const timeout = setTimeout(() => {
         client.destroy();
-        resolve5(false);
+        resolve6(false);
       }, 1e3);
       client.connect(port, "127.0.0.1", () => {
         clearTimeout(timeout);
         client.destroy();
-        resolve5(true);
+        resolve6(true);
       });
       client.on("error", () => {
         clearTimeout(timeout);
-        resolve5(false);
+        resolve6(false);
       });
     });
   }
   sleep(ms) {
-    return new Promise((resolve5) => setTimeout(resolve5, ms));
+    return new Promise((resolve6) => setTimeout(resolve6, ms));
   }
   getCachedDML(dmlJson) {
     if (queryCache.has(dmlJson)) {
@@ -1441,7 +1798,7 @@ var QueryEngine = class {
       throw new Error("Binary not initialized");
     }
     this.tcpPort = await this.findAvailablePort(this.tcpPort);
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const serverArgs = [...this.arguments, "--action", "server", "--tcp-port", this.tcpPort.toString()];
       const serverProcess = spawn3(this.binary["query_engine"], serverArgs);
       let started = false;
@@ -1461,7 +1818,7 @@ var QueryEngine = class {
               port: this.tcpPort,
               process: serverProcess
             });
-            resolve5();
+            resolve6();
           }
         }
       });
@@ -1479,60 +1836,8 @@ var QueryEngine = class {
       });
     });
   }
-  async sendTcpRequestFast(command) {
-    return new Promise((resolve5, reject) => {
-      let queue = connectionQueues.get(this.connectionId);
-      if (!queue) {
-        queue = [];
-        connectionQueues.set(this.connectionId, queue);
-      }
-      queue.push({ command, resolve: resolve5, reject });
-      this.processQueue();
-    });
-  }
-  async processQueue() {
-    if (connectionProcessing.get(this.connectionId)) {
-      return;
-    }
-    const queue = connectionQueues.get(this.connectionId);
-    if (!queue || queue.length === 0) {
-      return;
-    }
-    connectionProcessing.set(this.connectionId, true);
-    try {
-      const serverInfo = globalTcpServers.get(this.connectionId);
-      if (!serverInfo) {
-        throw new Error("Server not initialized");
-      }
-      while (queue.length > 0) {
-        const request = queue.shift();
-        if (!request) break;
-        try {
-          let connection = globalTcpConnections.get(this.connectionId);
-          if (!connection || connection.destroyed || connection.readyState !== "open") {
-            connection = await this.createNewConnection(serverInfo.port);
-            globalTcpConnections.set(this.connectionId, connection);
-          }
-          const result = await this.executeOnConnection(connection, request.command);
-          request.resolve(result);
-        } catch (error) {
-          const staleConnection = globalTcpConnections.get(this.connectionId);
-          if (staleConnection) {
-            try {
-              staleConnection.destroy();
-            } catch {
-            }
-          }
-          globalTcpConnections.delete(this.connectionId);
-          request.reject(error);
-        }
-      }
-    } finally {
-      connectionProcessing.set(this.connectionId, false);
-    }
-  }
   async createNewConnection(port) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const client = new net2.Socket();
       client.setNoDelay(true);
       client.setKeepAlive(true, 6e4);
@@ -1542,7 +1847,7 @@ var QueryEngine = class {
       }, 5e3);
       client.connect(port, "127.0.0.1", () => {
         clearTimeout(timeout);
-        resolve5(client);
+        resolve6(client);
       });
       client.on("error", (error) => {
         clearTimeout(timeout);
@@ -1551,7 +1856,7 @@ var QueryEngine = class {
     });
   }
   async executeOnConnection(connection, command) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       let responseBuffer = "";
       let isResolved = false;
       const timeout = setTimeout(() => {
@@ -1564,15 +1869,19 @@ var QueryEngine = class {
       }, this.timeout);
       const onData = (data) => {
         responseBuffer += data.toString();
-        const match = responseBuffer.match(/PROCESS_RESPONSE:(\{.*\})/);
-        if (match && !isResolved) {
+        let idx;
+        while ((idx = responseBuffer.indexOf("\n")) !== -1 && !isResolved) {
+          const line = responseBuffer.slice(0, idx);
+          responseBuffer = responseBuffer.slice(idx + 1);
+          const marker = line.indexOf("PROCESS_RESPONSE:");
+          if (marker === -1) continue;
           isResolved = true;
           clearTimeout(timeout);
           connection.removeListener("data", onData);
           connection.removeListener("error", onError);
           try {
-            const response = JSON.parse(match[1]);
-            resolve5({
+            const response = JSON.parse(line.slice(marker + "PROCESS_RESPONSE:".length));
+            resolve6({
               status: response.status,
               message: response.message,
               data: response.data
@@ -1601,7 +1910,7 @@ var QueryEngine = class {
     if (!this.binary) {
       throw new Error("Binary not initialized");
     }
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const child = spawn3(this.binary[binary], [...this.arguments, ...args]);
       let stdoutBuffer = "";
       let stderrBuffer = "";
@@ -1617,15 +1926,18 @@ var QueryEngine = class {
         if (!isResolved) {
           isResolved = true;
           clearTimeout(timeoutId);
-          resolve5(response);
+          resolve6(response);
         }
       };
-      child.stdout.on("data", (data) => {
-        stdoutBuffer += data.toString();
-        const match = stdoutBuffer.match(/PROCESS_RESPONSE:(\{.*\})/);
-        if (match) {
+      const tryParseLines = (buffer) => {
+        let idx;
+        while ((idx = buffer.indexOf("\n")) !== -1) {
+          const line = buffer.slice(0, idx);
+          buffer = buffer.slice(idx + 1);
+          const marker = line.indexOf("PROCESS_RESPONSE:");
+          if (marker === -1) continue;
           try {
-            const response = JSON.parse(match[1]);
+            const response = JSON.parse(line.slice(marker + "PROCESS_RESPONSE:".length));
             resolveOnce({
               status: response.status,
               message: response.message,
@@ -1639,26 +1951,13 @@ var QueryEngine = class {
             });
           }
         }
+        return buffer;
+      };
+      child.stdout.on("data", (data) => {
+        stdoutBuffer = tryParseLines(stdoutBuffer + data.toString());
       });
       child.stderr.on("data", (data) => {
-        stderrBuffer += data.toString();
-        const match = stderrBuffer.match(/PROCESS_RESPONSE:(\{.*\})/);
-        if (match) {
-          try {
-            const response = JSON.parse(match[1]);
-            resolveOnce({
-              status: response.status,
-              message: response.message,
-              data: response.data
-            });
-          } catch (error) {
-            resolveOnce({
-              status: 500,
-              message: "Failed to parse response JSON",
-              data: null
-            });
-          }
-        }
+        stderrBuffer = tryParseLines(stderrBuffer + data.toString());
       });
       child.on("close", (code) => {
         clearTimeout(timeoutId);
@@ -1684,11 +1983,16 @@ var QueryEngine = class {
     });
   }
   async disconnect() {
-    const connection = globalTcpConnections.get(this.connectionId);
-    if (connection && connection.readyState === "open") {
-      connection.write(JSON.stringify({ action: "disconnect" }));
-      connection.destroy();
-      globalTcpConnections.delete(this.connectionId);
+    await EmbeddedEngine.disconnect(this.connectionId);
+    const pool = socketPools.get(this.connectionId);
+    if (pool) {
+      for (const s of pool.free) {
+        try {
+          s.destroy();
+        } catch {
+        }
+      }
+      socketPools.delete(this.connectionId);
     }
     const serverInfo = globalTcpServers.get(this.connectionId);
     if (serverInfo && serverInfo.process && !serverInfo.process.killed) {
@@ -1710,12 +2014,12 @@ var QueryEngine = class {
 
 // src/lib/SqliteExecutor.ts
 import { exec } from "child_process";
-import * as path6 from "path";
-import * as fs4 from "fs";
+import * as path7 from "path";
+import * as fs5 from "fs";
 import { promisify } from "util";
 import { createRequire as createRequire3 } from "module";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname3 } from "path";
+import { dirname as dirname4 } from "path";
 var execAsync = promisify(exec);
 var SqliteExecutor = class {
   binaryPath;
@@ -1726,13 +2030,13 @@ var SqliteExecutor = class {
   }
   findVersionedBinary(binDir, platform2) {
     try {
-      const files = fs4.readdirSync(binDir);
+      const files = fs5.readdirSync(binDir);
       const extension = platform2 === "win32" ? ".exe" : "";
       const platformName = platform2 === "win32" ? "windows" : platform2 === "darwin" ? "macos" : "linux";
       const pattern = new RegExp(`^sqlite-engine-v\\d+\\.\\d+\\.\\d+-${platformName}-x64${extension.replace(".", "\\.")}$`);
       const matchingFile = files.find((f) => pattern.test(f));
       if (matchingFile) {
-        return path6.join(binDir, matchingFile);
+        return path7.join(binDir, matchingFile);
       }
     } catch (error) {
     }
@@ -1740,36 +2044,36 @@ var SqliteExecutor = class {
   }
   getBinaryPath() {
     const __filename2 = typeof import.meta !== "undefined" && import.meta.url ? fileURLToPath3(import.meta.url) : "";
-    const __dirname = __filename2 ? dirname3(__filename2) : process.cwd();
+    const __dirname = __filename2 ? dirname4(__filename2) : process.cwd();
     const possibleDirs = [
-      path6.resolve(process.cwd(), ".dbcube", "bin"),
-      path6.resolve(process.cwd(), "node_modules", ".dbcube", "bin"),
-      path6.resolve(__dirname, "..", "bin")
+      path7.resolve(process.cwd(), ".dbcube", "bin"),
+      path7.resolve(process.cwd(), "node_modules", ".dbcube", "bin"),
+      path7.resolve(__dirname, "..", "bin")
     ];
     const platform2 = process.platform;
     const extension = platform2 === "win32" ? ".exe" : "";
     const platformName = platform2 === "win32" ? "windows" : platform2 === "darwin" ? "macos" : "linux";
     for (const dir of possibleDirs) {
       const versionedPath = this.findVersionedBinary(dir, platform2);
-      if (versionedPath && fs4.existsSync(versionedPath)) {
+      if (versionedPath && fs5.existsSync(versionedPath)) {
         return versionedPath;
       }
     }
     const binaryName = `sqlite-engine-${platformName}-x64${extension}`;
     for (const dir of possibleDirs) {
-      const fullPath = path6.join(dir, binaryName);
-      if (fs4.existsSync(fullPath)) {
+      const fullPath = path7.join(dir, binaryName);
+      if (fs5.existsSync(fullPath)) {
         return fullPath;
       }
     }
     const fallbackName = `sqlite-engine${extension}`;
     for (const dir of possibleDirs) {
-      const fullPath = path6.join(dir, fallbackName);
-      if (fs4.existsSync(fullPath)) {
+      const fullPath = path7.join(dir, fallbackName);
+      if (fs5.existsSync(fullPath)) {
         return fullPath;
       }
     }
-    return path6.join(possibleDirs[0], binaryName);
+    return path7.join(possibleDirs[0], binaryName);
   }
   async executeBinary(args) {
     const escapedArgs = args.map((arg) => {
@@ -1920,9 +2224,9 @@ var SqliteExecutor = class {
 };
 
 // src/lib/DbConfig.ts
-import * as path7 from "path";
-import fs5 from "fs";
-var rootPath = path7.resolve(process.cwd(), ".dbcube");
+import * as path8 from "path";
+import fs6 from "fs";
+var rootPath = path8.resolve(process.cwd(), ".dbcube");
 var SQLite = class {
   executor = null;
   database;
@@ -1932,11 +2236,11 @@ var SQLite = class {
   async ifExist() {
     if (this.database) {
       const dbPath = this.database || ":memory:";
-      const configPath = path7.join(rootPath, dbPath + ".db");
-      if (!fs5.existsSync(rootPath)) {
-        fs5.mkdirSync(rootPath, { recursive: true });
+      const configPath = path8.join(rootPath, dbPath + ".db");
+      if (!fs6.existsSync(rootPath)) {
+        fs6.mkdirSync(rootPath, { recursive: true });
       }
-      if (fs5.existsSync(configPath)) {
+      if (fs6.existsSync(configPath)) {
         return true;
       }
       if (!this.executor) {
@@ -1947,13 +2251,13 @@ var SQLite = class {
     return false;
   }
   async connect() {
-    return new Promise(async (resolve5, reject) => {
+    return new Promise(async (resolve6, reject) => {
       try {
         if (!this.executor) {
           const dbPath = this.database || ":memory:";
-          const configPath = path7.join(rootPath, dbPath + ".db");
-          if (!fs5.existsSync(rootPath)) {
-            fs5.mkdirSync(rootPath, { recursive: true });
+          const configPath = path8.join(rootPath, dbPath + ".db");
+          if (!fs6.existsSync(rootPath)) {
+            fs6.mkdirSync(rootPath, { recursive: true });
           }
           this.executor = new SqliteExecutor(configPath);
           const connected = await this.executor.connect();
@@ -1961,22 +2265,22 @@ var SQLite = class {
             throw new Error("Failed to connect to SQLite database");
           }
         }
-        resolve5(this.executor);
+        resolve6(this.executor);
       } catch (error) {
         reject(error);
       }
     });
   }
   async disconnect() {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       if (this.executor) {
         this.executor = null;
       }
-      resolve5();
+      resolve6();
     });
   }
   async query(sqlQuery) {
-    return new Promise(async (resolve5) => {
+    return new Promise(async (resolve6) => {
       try {
         if (typeof sqlQuery !== "string") {
           throw new Error("The SQL query must be a string.");
@@ -1989,20 +2293,20 @@ var SQLite = class {
         }
         const result = await this.executor.queryMultiple(sqlQuery);
         if (result.status === "error") {
-          resolve5({
+          resolve6({
             status: "error",
             message: result.message,
             data: null
           });
         } else {
-          resolve5({
+          resolve6({
             status: "success",
             message: "Query executed successfully",
             data: result.data
           });
         }
       } catch (error) {
-        resolve5({
+        resolve6({
           status: "error",
           message: error.message || "An error occurred while executing the query.",
           data: null
@@ -2011,7 +2315,7 @@ var SQLite = class {
     });
   }
   async queryWithParameters(sqlQuery, params = []) {
-    return new Promise(async (resolve5) => {
+    return new Promise(async (resolve6) => {
       try {
         if (typeof sqlQuery !== "string") {
           throw new Error("The SQL query must be a string.");
@@ -2027,13 +2331,13 @@ var SQLite = class {
         }
         const result = await this.executor.query(sqlQuery, params);
         if (result.status === "error") {
-          resolve5({
+          resolve6({
             status: "error",
             message: result.message,
             data: null
           });
         } else {
-          resolve5({
+          resolve6({
             status: "success",
             message: "Query executed successfully",
             data: result.data
@@ -2041,7 +2345,7 @@ var SQLite = class {
         }
       } catch (error) {
         console.log(error);
-        resolve5({
+        resolve6({
           status: "error",
           message: error.message || "An error occurred while executing the query.",
           data: null
@@ -2135,8 +2439,8 @@ var DbConfig = new SQLite({ DATABASE: "config" });
 var DbConfig_default = DbConfig;
 
 // src/lib/FileLogger.ts
-import * as fs6 from "fs";
-import * as path8 from "path";
+import * as fs7 from "fs";
+import * as path9 from "path";
 import { EventEmitter } from "events";
 var FileLogger = class _FileLogger extends EventEmitter {
   static watchers = /* @__PURE__ */ new Map();
@@ -2151,9 +2455,9 @@ var FileLogger = class _FileLogger extends EventEmitter {
    */
   static async write(filePath, message, level = "INFO", append = true) {
     try {
-      const dir = path8.dirname(filePath);
-      if (!fs6.existsSync(dir)) {
-        fs6.mkdirSync(dir, { recursive: true });
+      const dir = path9.dirname(filePath);
+      if (!fs7.existsSync(dir)) {
+        fs7.mkdirSync(dir, { recursive: true });
       }
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       const formattedMessage = `[${timestamp}] [${level}] ${message}
@@ -2163,9 +2467,9 @@ var FileLogger = class _FileLogger extends EventEmitter {
         return true;
       }
       if (append) {
-        await fs6.promises.appendFile(filePath, formattedMessage, "utf8");
+        await fs7.promises.appendFile(filePath, formattedMessage, "utf8");
       } else {
-        await fs6.promises.writeFile(filePath, formattedMessage, "utf8");
+        await fs7.promises.writeFile(filePath, formattedMessage, "utf8");
       }
       return true;
     } catch (error) {
@@ -2190,12 +2494,12 @@ var FileLogger = class _FileLogger extends EventEmitter {
     const buffer = _FileLogger.buffers.get(filePath);
     if (buffer && buffer.length > 0) {
       try {
-        const dir = path8.dirname(filePath);
-        if (!fs6.existsSync(dir)) {
-          fs6.mkdirSync(dir, { recursive: true });
+        const dir = path9.dirname(filePath);
+        if (!fs7.existsSync(dir)) {
+          fs7.mkdirSync(dir, { recursive: true });
         }
         const content = buffer.join("");
-        await fs6.promises.appendFile(filePath, content, "utf8");
+        await fs7.promises.appendFile(filePath, content, "utf8");
         _FileLogger.buffers.delete(filePath);
         return true;
       } catch (error) {
@@ -2331,10 +2635,10 @@ var FileLogger = class _FileLogger extends EventEmitter {
       // Si debe retornar como array de líneas
     } = options;
     try {
-      if (!fs6.existsSync(filePath)) {
+      if (!fs7.existsSync(filePath)) {
         return asArray ? [] : "";
       }
-      let content = await fs6.promises.readFile(filePath, "utf8");
+      let content = await fs7.promises.readFile(filePath, "utf8");
       if (asArray) {
         let linesArray = content.split("\n").filter((line) => line.trim() !== "");
         if (lines !== null) {
@@ -2377,15 +2681,15 @@ var FileLogger = class _FileLogger extends EventEmitter {
     } = options;
     let lastSize = 0;
     let lastPosition = 0;
-    if (fs6.existsSync(filePath)) {
-      const stats = fs6.statSync(filePath);
+    if (fs7.existsSync(filePath)) {
+      const stats = fs7.statSync(filePath);
       lastSize = stats.size;
       lastPosition = fromEnd ? stats.size : 0;
     }
     const listener = async (curr, prev) => {
       try {
         if (curr.size > lastSize) {
-          const stream = fs6.createReadStream(filePath, {
+          const stream = fs7.createReadStream(filePath, {
             start: lastPosition,
             end: curr.size - 1,
             encoding: "utf8"
@@ -2413,7 +2717,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
         console.error("Error en watcher:", error);
       }
     };
-    fs6.watchFile(filePath, { persistent, interval }, listener);
+    fs7.watchFile(filePath, { persistent, interval }, listener);
     const watcherId = `${filePath}_${Date.now()}`;
     _FileLogger.watchers.set(watcherId, listener);
     return {
@@ -2421,7 +2725,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
       stop: () => {
         const storedListener = _FileLogger.watchers.get(watcherId);
         if (storedListener) {
-          fs6.unwatchFile(filePath, storedListener);
+          fs7.unwatchFile(filePath, storedListener);
           _FileLogger.watchers.delete(watcherId);
         }
       },
@@ -2434,7 +2738,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
   static stopAllWatchers() {
     for (const [watcherId] of _FileLogger.watchers) {
       const filePath = watcherId.split("_")[0];
-      fs6.unwatchFile(filePath);
+      fs7.unwatchFile(filePath);
     }
     _FileLogger.watchers.clear();
   }
@@ -2464,7 +2768,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
       if (lines.length > maxLines) {
         const keepLines = lines.slice(-maxLines);
         const content = keepLines.join("\n") + "\n";
-        await fs6.promises.writeFile(filePath, content, "utf8");
+        await fs7.promises.writeFile(filePath, content, "utf8");
         return lines.length - maxLines;
       }
       return 0;
@@ -2479,8 +2783,8 @@ var FileLogger = class _FileLogger extends EventEmitter {
    */
   static async deleteLogFile(filePath) {
     try {
-      if (fs6.existsSync(filePath)) {
-        await fs6.promises.unlink(filePath);
+      if (fs7.existsSync(filePath)) {
+        await fs7.promises.unlink(filePath);
         return true;
       }
       return false;