drixio 1.1.9 → 1.2.0

package/dist/cli.js

@@ -28,27 +28,201 @@ var init_types = __esm({
 // src/logic/loader.ts
 import fs from "fs/promises";
 import path from "path";
+function parseEnvContent(content) {
+  const env = {};
+  const lines = content.split(/\r?\n/);
+  for (let line of lines) {
+    line = line.trim();
+    if (!line || line.startsWith("#")) continue;
+    if (line.startsWith("export ")) {
+      line = line.slice(7).trim();
+    }
+    const eqIdx = line.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = line.slice(0, eqIdx).trim();
+    let val = line.slice(eqIdx + 1).trim();
+    if (val.startsWith('"')) {
+      const endQuote = val.indexOf('"', 1);
+      val = endQuote !== -1 ? val.slice(1, endQuote) : val.slice(1);
+    } else if (val.startsWith("'")) {
+      const endQuote = val.indexOf("'", 1);
+      val = endQuote !== -1 ? val.slice(1, endQuote) : val.slice(1);
+    } else {
+      const commentIdx = val.indexOf("#");
+      if (commentIdx !== -1) {
+        val = val.slice(0, commentIdx).trim();
+      }
+    }
+    if (key) {
+      env[key] = val;
+    }
+  }
+  return env;
+}
+async function loadCascadedEnv(cwd) {
+  const envFiles = [
+    ".env",
+    ".env.production",
+    ".env.development",
+    ".env.local",
+    ".env.development.local"
+  ];
+  const mergedEnv = {};
+  for (const file of envFiles) {
+    try {
+      const filePath = path.join(cwd, file);
+      const content = await fs.readFile(filePath, "utf-8");
+      const parsed = parseEnvContent(content);
+      Object.assign(mergedEnv, parsed);
+    } catch {
+    }
+  }
+  for (const [key, val] of Object.entries(process.env)) {
+    if (typeof val === "string" && val.trim() !== "") {
+      mergedEnv[key] = val.trim();
+    }
+  }
+  return mergedEnv;
+}
+function classifyDatabaseUrl(rawUrl, cwd) {
+  let trimmed = rawUrl.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    trimmed = trimmed.slice(1, -1).trim();
+  }
+  if (trimmed.startsWith("postgres://") || trimmed.startsWith("postgresql://")) {
+    return { type: "postgres", targetUrl: trimmed };
+  }
+  if (trimmed.startsWith("mysql://")) {
+    return { type: "mysql", targetUrl: trimmed };
+  }
+  const lower = trimmed.toLowerCase();
+  const isSqlitePrefix = lower.startsWith("file:") || lower.startsWith("sqlite://") || lower.startsWith("sqlite:");
+  const isSqliteExt = lower.endsWith(".db") || lower.endsWith(".sqlite") || lower.endsWith(".sqlite3") || lower.endsWith(".db3");
+  const isMemory = lower === ":memory:";
+  if (isSqlitePrefix || isSqliteExt || isMemory) {
+    let cleanPath = trimmed.replace(/^sqlite:\/\//i, "").replace(/^sqlite:/i, "").replace(/^file:/i, "");
+    if (cleanPath === ":memory:") {
+      return { type: "sqlite", targetUrl: ":memory:" };
+    }
+    if (!path.isAbsolute(cleanPath)) {
+      cleanPath = path.resolve(cwd, cleanPath);
+    }
+    return { type: "sqlite", targetUrl: cleanPath };
+  }
+  return null;
+}
+function buildUrlFromComponentEnv(env) {
+  const host = env.DB_HOST || env.DATABASE_HOST || env.MYSQL_HOST || env.POSTGRES_HOST || env.PGHOST;
+  const dbName = env.DB_NAME || env.DB_DATABASE || env.DATABASE_NAME || env.MYSQL_DATABASE || env.POSTGRES_DB || env.PGDATABASE;
+  if (!host || !dbName) return null;
+  const driver = (env.DB_CONNECTION || env.DB_TYPE || env.DB_DRIVER || "").toLowerCase();
+  const portStr = env.DB_PORT || env.MYSQL_PORT || env.POSTGRES_PORT || env.PGPORT;
+  let type = "mysql";
+  if (driver.includes("postgres") || driver.includes("pgsql") || driver.includes("pg") || env.POSTGRES_HOST || env.PGHOST || portStr === "5432") {
+    type = "postgres";
+  } else if (driver.includes("mysql") || driver.includes("mariadb") || env.MYSQL_HOST || portStr === "3306") {
+    type = "mysql";
+  }
+  const defaultPort = type === "postgres" ? 5432 : 3306;
+  const port = portStr ? parseInt(portStr, 10) || defaultPort : defaultPort;
+  const user = env.DB_USER || env.DB_USERNAME || env.MYSQL_USER || env.POSTGRES_USER || env.PGUSER || (type === "postgres" ? "postgres" : "root");
+  const pass = env.DB_PASSWORD || env.DB_PASS || env.MYSQL_PASSWORD || env.POSTGRES_PASSWORD || env.PGPASSWORD || "";
+  const auth = pass ? `${encodeURIComponent(user)}:${encodeURIComponent(pass)}` : encodeURIComponent(user);
+  const targetUrl = `${type}://${auth}@${host}:${port}/${dbName}`;
+  return { type, targetUrl };
+}
 async function detectDatabase(databaseUrl) {
   const cwd = process.cwd();
   if (databaseUrl) {
-    let type = "sqlite";
-    if (databaseUrl.startsWith("postgres://") || databaseUrl.startsWith("postgresql://")) {
-      type = "postgres";
-    } else if (databaseUrl.startsWith("mysql://")) {
-      type = "mysql";
-    } else {
-      type = "sqlite";
-    }
-    let targetUrl = databaseUrl.replace("file:", "");
-    if (type === "sqlite" && !path.isAbsolute(targetUrl)) {
-      targetUrl = path.resolve(cwd, targetUrl);
+    const classified = classifyDatabaseUrl(databaseUrl, cwd);
+    if (classified) {
+      return {
+        type: classified.type,
+        targetUrl: classified.targetUrl,
+        source: "manual"
+      };
     }
     return {
-      type,
-      targetUrl,
+      type: "unknown",
+      targetUrl: databaseUrl,
       source: "manual"
     };
   }
+  const allEnv = await loadCascadedEnv(cwd);
+  const prismaPaths = [
+    path.join(cwd, "prisma", "schema.prisma"),
+    path.join(cwd, "src", "prisma", "schema.prisma")
+  ];
+  for (const schemaPath of prismaPaths) {
+    try {
+      const schemaContent = await fs.readFile(schemaPath, "utf-8");
+      const providerMatch = schemaContent.match(
+        /provider\s*=\s*["']([^"']+)["']/
+      );
+      const urlMatch = schemaContent.match(
+        /url\s*=\s*(?:env\(["']([^"']+)["']\)|["']([^"']+)["'])/
+      );
+      if (providerMatch) {
+        let provider = providerMatch[1];
+        if (provider === "postgresql") provider = "postgres";
+        let rawUrl;
+        if (urlMatch) {
+          if (urlMatch[1]) {
+            rawUrl = allEnv[urlMatch[1]];
+          } else if (urlMatch[2]) {
+            rawUrl = urlMatch[2];
+          }
+        }
+        if (rawUrl) {
+          if (provider === "sqlite") {
+            let cleanPath = rawUrl.replace(/^file:/i, "");
+            if (!path.isAbsolute(cleanPath)) {
+              cleanPath = path.resolve(
+                path.dirname(schemaPath),
+                cleanPath
+              );
+            }
+            return {
+              type: "sqlite",
+              targetUrl: cleanPath,
+              source: ".env"
+            };
+          }
+          const classified = classifyDatabaseUrl(rawUrl, cwd);
+          if (classified) {
+            return {
+              type: classified.type,
+              targetUrl: classified.targetUrl,
+              source: ".env"
+            };
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  for (const key of DB_ENV_KEYS) {
+    const candidate = allEnv[key];
+    if (candidate) {
+      const classified = classifyDatabaseUrl(candidate, cwd);
+      if (classified) {
+        return {
+          type: classified.type,
+          targetUrl: classified.targetUrl,
+          source: ".env"
+        };
+      }
+    }
+  }
+  const assembled = buildUrlFromComponentEnv(allEnv);
+  if (assembled) {
+    return {
+      type: assembled.type,
+      targetUrl: assembled.targetUrl,
+      source: ".env"
+    };
+  }
   const searchDirs = [
     ".",
     "prisma",
@@ -61,9 +235,10 @@ async function detectDatabase(databaseUrl) {
     try {
       const targetDir = path.join(cwd, dir);
       const files = await fs.readdir(targetDir);
-      const sqliteFile = files.find(
-        (file) => file.endsWith(".db") || file.endsWith(".sqlite") || file.endsWith(".sqlite3")
-      );
+      const sqliteFile = files.find((file) => {
+        const lower = file.toLowerCase();
+        return lower.endsWith(".db") || lower.endsWith(".sqlite") || lower.endsWith(".sqlite3") || lower.endsWith(".db3");
+      });
       if (sqliteFile) {
         return {
           type: "sqlite",
@@ -74,81 +249,6 @@ async function detectDatabase(databaseUrl) {
     } catch {
     }
   }
-  const prismaSchemaPath = path.join(cwd, "prisma", "schema.prisma");
-  try {
-    const schemaContent = await fs.readFile(prismaSchemaPath, "utf-8");
-    const providerMatch = schemaContent.match(
-      /provider\s*=\s*["']([^"']+)["']/
-    );
-    const urlMatch = schemaContent.match(
-      /url\s*=\s*(?:env\(["']([^"']+)["']\)|["']([^"']+)["'])/
-    );
-    if (providerMatch) {
-      let provider = providerMatch[1];
-      if (provider === "postgresql") provider = "postgres";
-      let targetUrl = "";
-      if (urlMatch && urlMatch[2]) {
-        targetUrl = urlMatch[2];
-        if (targetUrl.startsWith("file:")) {
-          targetUrl = path.join(
-            cwd,
-            "prisma",
-            targetUrl.replace("file:", "")
-          );
-        }
-      }
-      if (targetUrl && (provider === "sqlite" || provider === "postgres" || provider === "mysql")) {
-        return {
-          type: provider,
-          targetUrl,
-          source: ".env"
-        };
-      }
-    }
-  } catch {
-  }
-  const envPath = path.join(cwd, ".env");
-  try {
-    const envContent = await fs.readFile(envPath, "utf-8");
-    const dbKeys = [
-      "DATABASE_URL",
-      "DB_URL",
-      "POSTGRES_URL",
-      "POSTGRES_PRISMA_URL",
-      "MYSQL_URL"
-    ];
-    for (const key of dbKeys) {
-      const regex = new RegExp(`${key}\\s*=\\s*["']?([^"'\\r\\n]+)["']?`);
-      const match = envContent.match(regex);
-      if (match) {
-        const url = match[1];
-        if (url.startsWith("file:") || url.endsWith(".db") || url.includes(".sqlite")) {
-          let targetUrl = url.replace("file:", "");
-          if (!path.isAbsolute(targetUrl)) {
-            targetUrl = path.resolve(cwd, targetUrl);
-          }
-          return {
-            type: "sqlite",
-            targetUrl,
-            source: ".env"
-          };
-        } else if (url.startsWith("postgres://") || url.startsWith("postgresql://")) {
-          return {
-            type: "postgres",
-            targetUrl: url,
-            source: ".env"
-          };
-        } else if (url.startsWith("mysql://")) {
-          return {
-            type: "mysql",
-            targetUrl: url,
-            source: ".env"
-          };
-        }
-      }
-    }
-  } catch (error) {
-  }
   return {
     type: "unknown",
     targetUrl: "",
@@ -161,7 +261,7 @@ async function saveDatabaseUrl(url) {
     let envContent = "";
     try {
       envContent = await fs.readFile(envPath, "utf-8");
-    } catch (e) {
+    } catch {
     }
     const regex = /DATABASE_URL\s*=\s*["']?([^"'\r\n]+)["']?/;
     if (regex.test(envContent)) {
@@ -183,10 +283,351 @@ async function saveDatabaseUrl(url) {
     );
   }
 }
+function assembleConnectionUrl(type, host, port, user, password, database) {
+  const targetHost = host || "localhost";
+  const targetPort = port || (type === "postgres" ? "5432" : "3306");
+  const targetUser = user || (type === "postgres" ? "postgres" : "root");
+  const auth = password ? `${encodeURIComponent(targetUser)}:${encodeURIComponent(password)}` : encodeURIComponent(targetUser);
+  const defaultDb = type === "postgres" ? "postgres" : "";
+  const dbNameStr = database || defaultDb;
+  return `${type}://${auth}@${targetHost}:${targetPort}/${dbNameStr}`;
+}
+function resolveLocalDbPath(targetUrl, cwd) {
+  const cleanPath = targetUrl.replace(/^file:/, "").trim();
+  return path.isAbsolute(cleanPath) ? cleanPath : path.resolve(cwd, cleanPath);
+}
+function isConnectionString(url) {
+  const trimmed = url.trim();
+  return trimmed.startsWith("postgres://") || trimmed.startsWith("postgresql://") || trimmed.startsWith("mysql://");
+}
+var DB_ENV_KEYS;
 var init_loader = __esm({
   "src/logic/loader.ts"() {
     "use strict";
     init_types();
+    DB_ENV_KEYS = [
+      "DATABASE_URL",
+      "DB_URL",
+      "DATABASE_URI",
+      "DB_URI",
+      "DIRECT_URL",
+      "POSTGRES_URL",
+      "POSTGRESQL_URL",
+      "POSTGRES_PRISMA_URL",
+      "POSTGRES_URL_NON_POOLING",
+      "SUPABASE_DB_URL",
+      "MYSQL_URL",
+      "MYSQL_DATABASE_URL",
+      "JAWSDB_URL",
+      "CLEARDB_DATABASE_URL"
+    ];
+  }
+});
+
+// src/logic/dialect.ts
+function getDialect(type) {
+  switch (type) {
+    case "sqlite":
+      return new SqliteDialect();
+    case "postgres":
+      return new PostgresDialect();
+    case "mysql":
+      return new MysqlDialect();
+    default:
+      return new SqliteDialect();
+  }
+}
+function buildSearchWhereClause(adapter, dbType, columns, searchInput) {
+  const searchVal = (searchInput || "").trim();
+  if (!searchVal) return "";
+  const isSqlCondition = /[=<>]|LIKE|IN|AND|OR/i.test(searchVal);
+  if (isSqlCondition) {
+    return searchVal;
+  }
+  const dialect = getDialect(dbType);
+  const strCols = columns.filter((c) => {
+    const t = c.type.toLowerCase();
+    return t.includes("char") || t.includes("text") || t.includes("string") || t.includes("uuid");
+  });
+  if (strCols.length > 0) {
+    const likeOp = dbType === "postgres" ? "ILIKE" : "LIKE";
+    const escaped = dialect.escapeString(searchVal);
+    const conditions = strCols.map(
+      (c) => `${adapter.quoteIdentifier(c.name)} ${likeOp} '%${escaped}%'`
+    );
+    return conditions.join(" OR ");
+  }
+  if (columns.length > 0) {
+    const col = columns[0];
+    const escaped = dialect.escapeString(searchVal);
+    return `${adapter.quoteIdentifier(col.name)} = '${escaped}'`;
+  }
+  return "";
+}
+function formatSqlDefaultValue(rawDefault) {
+  if (rawDefault === void 0 || rawDefault === null) return null;
+  let trimmed = String(rawDefault).trim();
+  if (!trimmed || trimmed.toLowerCase() === "null" || trimmed === "-") {
+    return null;
+  }
+  while (trimmed.startsWith("''") && trimmed.endsWith("''") && trimmed.length > 4) {
+    trimmed = trimmed.slice(1, -1);
+  }
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+    return trimmed;
+  }
+  const lower = trimmed.toLowerCase();
+  if (lower === "true" || lower === "false") {
+    return lower.toUpperCase();
+  }
+  const upper = trimmed.toUpperCase();
+  if (upper === "CURRENT_TIMESTAMP" || upper === "CURRENT_DATE" || upper === "CURRENT_TIME" || upper === "NOW()" || upper === "TIMESTAMP" || upper.startsWith("CURRENT_TIMESTAMP") || upper.startsWith("NOW()") || upper.startsWith("GEN_RANDOM_UUID(") || upper.startsWith("UUID_GENERATE_") || upper.startsWith("UUID(") || trimmed.startsWith("(") && trimmed.endsWith(")")) {
+    return upper === "TIMESTAMP" ? "CURRENT_TIMESTAMP" : trimmed;
+  }
+  const pgCastMatch = trimmed.match(/^('[\s\S]*')(?:::[\w\s()]+)$/);
+  if (pgCastMatch) {
+    return pgCastMatch[1];
+  }
+  if (trimmed.startsWith("'") && trimmed.endsWith("'") && trimmed.length >= 2) {
+    return trimmed;
+  }
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
+    const inner = trimmed.slice(1, -1).replace(/'/g, "''");
+    return `'${inner}'`;
+  }
+  const escaped = trimmed.replace(/'/g, "''");
+  return `'${escaped}'`;
+}
+function generateExplainQuery(rawSql, dbType) {
+  let cleanSql = rawSql.replace(/--.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").trim().replace(/;+$/, "").trim();
+  if (!cleanSql) {
+    return { sql: "", error: "SQL query is empty after stripping comments" };
+  }
+  if (/^(CREATE|DROP|ALTER|TRUNCATE)\s+/i.test(cleanSql)) {
+    return {
+      sql: "",
+      error: "DDL statements (CREATE, DROP, ALTER, TRUNCATE) do not have query execution plans to explain."
+    };
+  }
+  const hasUserExplain = /^EXPLAIN\b/i.test(cleanSql);
+  let targetSql = cleanSql;
+  if (hasUserExplain) {
+    targetSql = cleanSql.replace(/^EXPLAIN\s+(QUERY\s+PLAN\s+)?/i, "").replace(
+      /^\((ANALYZE|COSTS|VERBOSE|BUFFERS|FORMAT\s+\w+|,|\s)+\)\s*/i,
+      ""
+    ).trim();
+  }
+  let explainSql = "";
+  const isDmlWrite = /^(INSERT|UPDATE|DELETE)\s+/i.test(targetSql);
+  if (dbType === "sqlite") {
+    explainSql = `EXPLAIN QUERY PLAN ${targetSql}`;
+  } else if (dbType === "postgres") {
+    if (isDmlWrite) {
+      explainSql = `EXPLAIN (COSTS, VERBOSE) ${targetSql}`;
+    } else {
+      explainSql = `EXPLAIN (ANALYZE, COSTS, VERBOSE, BUFFERS) ${targetSql}`;
+    }
+  } else if (dbType === "mysql") {
+    explainSql = `EXPLAIN ${targetSql}`;
+  } else {
+    explainSql = `EXPLAIN ${targetSql}`;
+  }
+  return { sql: explainSql };
+}
+var SqliteDialect, PostgresDialect, MysqlDialect;
+var init_dialect = __esm({
+  "src/logic/dialect.ts"() {
+    "use strict";
+    SqliteDialect = class {
+      quoteIdentifier(name) {
+        return `"${name}"`;
+        return `"${name.replace(/"/g, '""')}"`;
+      }
+      escapeString(val) {
+        return val.replace(/'/g, "''");
+      }
+      buildCreateTable(tableName, columns) {
+        const lines = columns.map((col) => {
+          const isPk = !!(col.isPk || col.primaryKey);
+          const tLower = col.type.toLowerCase();
+          let typeStr = col.type;
+          if (tLower === "integer" || tLower === "int") typeStr = "INTEGER";
+          else if (tLower === "text" || tLower === "string") typeStr = "TEXT";
+          else if (tLower === "boolean" || tLower === "bool")
+            typeStr = "BOOLEAN";
+          else if (tLower === "decimal" || tLower === "numeric" || tLower === "float" || tLower === "double")
+            typeStr = "REAL";
+          else if (tLower === "datetime" || tLower === "timestamp")
+            typeStr = "DATETIME";
+          else if (col.enumValues && col.enumValues.length > 0) {
+            typeStr = `TEXT CHECK(${this.quoteIdentifier(col.name)} IN (${col.enumValues.map((v) => `'${this.escapeString(v)}'`).join(", ")}))`;
+          }
+          if (isPk && (tLower.includes("int") || typeStr === "INTEGER")) {
+            typeStr = "INTEGER PRIMARY KEY AUTOINCREMENT";
+          } else if (isPk) {
+            typeStr += " PRIMARY KEY";
+          } else {
+            if (!col.nullable) typeStr += " NOT NULL";
+            if (col.isUnique) typeStr += " UNIQUE";
+          }
+          if (col.defaultValue && col.defaultValue !== "AutoInc" && !col.defaultValue.startsWith("FK ->")) {
+            const formatted = formatSqlDefaultValue(col.defaultValue);
+            if (formatted !== null) {
+              typeStr += ` DEFAULT ${formatted}`;
+            }
+          }
+          return `  ${this.quoteIdentifier(col.name)} ${typeStr}`;
+        });
+        const fks = columns.filter(
+          (col) => col.fkTarget && col.fkTarget.table && col.fkTarget.column
+        ).map((col) => {
+          let fkStr = `  FOREIGN KEY (${this.quoteIdentifier(col.name)}) REFERENCES ${this.quoteIdentifier(col.fkTarget.table)}(${this.quoteIdentifier(col.fkTarget.column)})`;
+          if (col.fkTarget.onDelete && col.fkTarget.onDelete !== "NO ACTION") {
+            fkStr += ` ON DELETE ${col.fkTarget.onDelete}`;
+          }
+          if (col.fkTarget.onUpdate && col.fkTarget.onUpdate !== "NO ACTION") {
+            fkStr += ` ON UPDATE ${col.fkTarget.onUpdate}`;
+          }
+          return fkStr;
+        });
+        if (fks.length > 0) {
+          lines.push(...fks);
+        }
+        return `CREATE TABLE ${this.quoteIdentifier(tableName)} (
+${lines.join(",\n")}
+);`;
+      }
+    };
+    PostgresDialect = class {
+      quoteIdentifier(name) {
+        return `"${name}"`;
+        return `"${name.replace(/"/g, '""')}"`;
+      }
+      escapeString(val) {
+        return val.replace(/'/g, "''");
+      }
+      buildCreateTable(tableName, columns) {
+        const lines = columns.map((col) => {
+          const isPk = !!(col.isPk || col.primaryKey);
+          const tLower = col.type.toLowerCase();
+          let typeStr = col.type;
+          if (isPk && (tLower === "integer" || tLower === "int")) {
+            typeStr = "SERIAL PRIMARY KEY";
+          } else {
+            if (tLower === "integer" || tLower === "int") typeStr = "INTEGER";
+            else if (tLower === "text" || tLower === "string") typeStr = "TEXT";
+            else if (tLower === "boolean" || tLower === "bool")
+              typeStr = "BOOLEAN";
+            else if (tLower === "decimal" || tLower === "numeric")
+              typeStr = "NUMERIC";
+            else if (tLower === "datetime" || tLower === "timestamp")
+              typeStr = "TIMESTAMP";
+            else if (col.enumValues && col.enumValues.length > 0) {
+              if (col.type && ![
+                "enum",
+                "varchar",
+                "varchar(255)",
+                "text",
+                "string"
+              ].includes(tLower)) {
+                typeStr = this.quoteIdentifier(col.type);
+              } else {
+                typeStr = `VARCHAR(255) CHECK(${this.quoteIdentifier(col.name)} IN (${col.enumValues.map((v) => `'${this.escapeString(v)}'`).join(", ")}))`;
+              }
+            }
+            if (isPk) typeStr += " PRIMARY KEY";
+            if (!col.nullable && !isPk) typeStr += " NOT NULL";
+            if (col.isUnique && !isPk) typeStr += " UNIQUE";
+          }
+          if (col.defaultValue && col.defaultValue !== "AutoInc" && !col.defaultValue.startsWith("FK ->")) {
+            const formatted = formatSqlDefaultValue(col.defaultValue);
+            if (formatted !== null) {
+              typeStr += ` DEFAULT ${formatted}`;
+            }
+          }
+          return `  ${this.quoteIdentifier(col.name)} ${typeStr}`;
+        });
+        const fks = columns.filter(
+          (col) => col.fkTarget && col.fkTarget.table && col.fkTarget.column
+        ).map((col) => {
+          let fkStr = `  FOREIGN KEY (${this.quoteIdentifier(col.name)}) REFERENCES ${this.quoteIdentifier(col.fkTarget.table)}(${this.quoteIdentifier(col.fkTarget.column)})`;
+          if (col.fkTarget.onDelete && col.fkTarget.onDelete !== "NO ACTION") {
+            fkStr += ` ON DELETE ${col.fkTarget.onDelete}`;
+          }
+          if (col.fkTarget.onUpdate && col.fkTarget.onUpdate !== "NO ACTION") {
+            fkStr += ` ON UPDATE ${col.fkTarget.onUpdate}`;
+          }
+          return fkStr;
+        });
+        if (fks.length > 0) {
+          lines.push(...fks);
+        }
+        return `CREATE TABLE ${this.quoteIdentifier(tableName)} (
+${lines.join(",\n")}
+);`;
+      }
+    };
+    MysqlDialect = class {
+      quoteIdentifier(name) {
+        return `\`${name}\``;
+        return `\`${name.replace(/`/g, "``")}\``;
+      }
+      escapeString(val) {
+        return val.replace(/'/g, "''");
+        return val.replace(/\\/g, "\\\\").replace(/'/g, "''");
+      }
+      buildCreateTable(tableName, columns) {
+        const lines = columns.map((col) => {
+          const isPk = !!(col.isPk || col.primaryKey);
+          const tLower = col.type.toLowerCase();
+          let typeStr = col.type;
+          if (tLower === "integer" || tLower === "int") typeStr = "INT";
+          else if (tLower === "text" || tLower === "string")
+            typeStr = "VARCHAR(255)";
+          else if (tLower === "boolean" || tLower === "bool")
+            typeStr = "BOOLEAN";
+          else if (tLower === "decimal" || tLower === "numeric")
+            typeStr = "DOUBLE";
+          else if (tLower === "datetime" || tLower === "timestamp")
+            typeStr = "DATETIME";
+          else if (col.enumValues && col.enumValues.length > 0) {
+            typeStr = `ENUM(${col.enumValues.map((v) => `'${this.escapeString(v)}'`).join(", ")})`;
+          }
+          if (isPk && (tLower.includes("int") || typeStr === "INT")) {
+            typeStr += " AUTO_INCREMENT PRIMARY KEY";
+          } else if (isPk) {
+            typeStr += " PRIMARY KEY";
+          }
+          if (!col.nullable && !isPk) typeStr += " NOT NULL";
+          if (col.isUnique && !isPk) typeStr += " UNIQUE";
+          if (col.defaultValue && col.defaultValue !== "AutoInc" && !col.defaultValue.startsWith("FK ->")) {
+            const formatted = formatSqlDefaultValue(col.defaultValue);
+            if (formatted !== null) {
+              typeStr += ` DEFAULT ${formatted}`;
+            }
+          }
+          return `  ${this.quoteIdentifier(col.name)} ${typeStr}`;
+        });
+        const fks = columns.filter(
+          (col) => col.fkTarget && col.fkTarget.table && col.fkTarget.column
+        ).map((col) => {
+          let fkStr = `  FOREIGN KEY (${this.quoteIdentifier(col.name)}) REFERENCES ${this.quoteIdentifier(col.fkTarget.table)}(${this.quoteIdentifier(col.fkTarget.column)})`;
+          if (col.fkTarget.onDelete && col.fkTarget.onDelete !== "NO ACTION") {
+            fkStr += ` ON DELETE ${col.fkTarget.onDelete}`;
+          }
+          if (col.fkTarget.onUpdate && col.fkTarget.onUpdate !== "NO ACTION") {
+            fkStr += ` ON UPDATE ${col.fkTarget.onUpdate}`;
+          }
+          return fkStr;
+        });
+        if (fks.length > 0) {
+          lines.push(...fks);
+        }
+        return `CREATE TABLE ${this.quoteIdentifier(tableName)} (
+${lines.join(",\n")}
+);`;
+      }
+    };
   }
 });
 
@@ -195,6 +636,7 @@ var SqliteAdapter;
 var init_sqlite = __esm({
   "src/logic/adapters/sqlite.ts"() {
     "use strict";
+    init_dialect();
     SqliteAdapter = class {
       dbPath;
       db = null;
@@ -203,10 +645,14 @@ var init_sqlite = __esm({
       }
       async getDb() {
         if (!this.db) {
-          let modFs = "node:fs";
-          const fs16 = await import(modFs);
-          if (!fs16.existsSync(this.dbPath)) {
-            throw new Error(`Failed to found database file at: ${this.dbPath}`);
+          if (this.dbPath !== ":memory:") {
+            let modFs = "node:fs";
+            const fs19 = await import(modFs);
+            if (!fs19.existsSync(this.dbPath)) {
+              throw new Error(
+                `Failed to found database file at: ${this.dbPath}`
+              );
+            }
           }
           let mod = "node:sqlite";
           const sqlite = await import(mod);
@@ -222,12 +668,17 @@ var init_sqlite = __esm({
           const db = await this.getDb();
           const vQuery = db.prepare("SELECT sqlite_version() as v");
           const vRow = vQuery.get();
-          let modFs = "node:fs";
-          const fs16 = await import(modFs);
-          const stats = fs16.statSync(this.dbPath);
-          let modPath = "node:path";
-          const path17 = await import(modPath);
-          const dbName = path17.basename(this.dbPath);
+          let sizeBytes = 0;
+          let dbName = ":memory:";
+          if (this.dbPath !== ":memory:") {
+            let modFs = "node:fs";
+            const fs19 = await import(modFs);
+            const stats = fs19.statSync(this.dbPath);
+            sizeBytes = stats.size;
+            let modPath = "node:path";
+            const path20 = await import(modPath);
+            dbName = path20.basename(this.dbPath);
+          }
           return {
             status: "connected",
             dbType: "sqlite",
@@ -235,7 +686,7 @@ var init_sqlite = __esm({
             version: vRow?.v,
             activeConnections: 1,
             // SQLite is single file, essentially 1 active connection for the app
-            sizeBytes: stats.size,
+            sizeBytes,
             uptime: process.uptime()
           };
         } catch (e) {
@@ -463,15 +914,21 @@ var init_sqlite = __esm({
         const isCompositePk = pkColumns.length > 1;
         const colDefs = [];
         for (const col of newColumns) {
-          let def = `${this.quoteIdentifier(col.name)} ${col.type || "TEXT"}`;
+          let colType = col.type || "TEXT";
+          if (col.enumValues && col.enumValues.length > 0) {
+            const vals = col.enumValues.map((v) => `'${v.replace(/'/g, "''")}'`).join(", ");
+            colType = `TEXT CHECK(${this.quoteIdentifier(col.name)} IN (${vals}))`;
+          }
+          let def = `${this.quoteIdentifier(col.name)} ${colType}`;
           if (col.isPk && !isCompositePk) {
             def += " PRIMARY KEY";
           }
           if (!col.nullable && (!col.isPk || isCompositePk)) {
             def += " NOT NULL";
           }
-          if (col.defaultValue !== void 0 && col.defaultValue !== null && col.defaultValue !== "") {
-            def += ` DEFAULT '${String(col.defaultValue).replace(/'/g, "''")}'`;
+          const formattedDef = formatSqlDefaultValue(col.defaultValue);
+          if (formattedDef !== null) {
+            def += ` DEFAULT ${formattedDef}`;
           }
           if (col.fkTarget && col.fkTarget.table && col.fkTarget.column) {
             def += ` REFERENCES ${this.quoteIdentifier(col.fkTarget.table)}(${this.quoteIdentifier(col.fkTarget.column)})`;
@@ -549,23 +1006,74 @@ var init_sqlite = __esm({
 
 // src/logic/adapters/postgres.ts
 import pg from "pg";
+function buildPgPoolConfig(connectionString) {
+  const config = {
+    connectionString,
+    connectionTimeoutMillis: 1e4
+    // 10s timeout to prevent hanging on unreachable hosts
+  };
+  try {
+    const lower = connectionString.toLowerCase();
+    const isExplicitSslDisable = lower.includes("sslmode=disable");
+    const isExplicitSslRequire = lower.includes("sslmode=require") || lower.includes("sslmode=prefer") || lower.includes("ssl=true") || lower.includes("ssl=1");
+    let isCloudProvider = false;
+    const match = connectionString.match(/@([^/:?#]+)/);
+    if (match && match[1]) {
+      const host = match[1].toLowerCase();
+      isCloudProvider = host.includes("supabase.") || host.includes("neon.tech") || host.includes("railway.") || host.includes("render.com") || host.includes("cockroach") || host.includes("aiven") || host.includes("rds.amazonaws.com");
+    }
+    if (!isExplicitSslDisable && (isExplicitSslRequire || isCloudProvider)) {
+      config.ssl = {
+        rejectUnauthorized: false
+      };
+    }
+  } catch {
+  }
+  return config;
+}
 var PostgresAdapter;
 var init_postgres = __esm({
   "src/logic/adapters/postgres.ts"() {
     "use strict";
-    PostgresAdapter = class {
+    PostgresAdapter = class _PostgresAdapter {
       connectionString;
       pool = null;
+      currentSchema;
       constructor(connection) {
         this.connectionString = connection;
+        this.currentSchema = _PostgresAdapter.extractSchema(connection);
+      }
+      /**
+       * Extract the schema parameter from a PostgreSQL connection URL.
+       * Supports both `?schema=xxx` (Prisma-style) and `?options=-c search_path%3Dxxx`.
+       * Defaults to 'public' if not found.
+       */
+      static extractSchema(url) {
+        try {
+          const qIdx = url.indexOf("?");
+          if (qIdx === -1) return "public";
+          const params = new URLSearchParams(url.slice(qIdx + 1));
+          const schema = params.get("schema");
+          if (schema) return schema;
+          const opts = params.get("options");
+          if (opts) {
+            const m = opts.match(/search_path[=](\w+)/);
+            if (m) return m[1];
+          }
+        } catch {
+        }
+        return "public";
       }
       getPool() {
         if (!this.pool) {
-          this.pool = new pg.Pool({
-            connectionString: this.connectionString
-          });
+          this.pool = new pg.Pool(buildPgPoolConfig(this.connectionString));
           this.pool.on("error", () => {
           });
+          this.pool.on("connect", (client) => {
+            const quoted = this.currentSchema.replace(/"/g, '""');
+            client.query(`SET search_path TO "${quoted}", public`).catch(() => {
+            });
+          });
         }
         return this.pool;
       }
@@ -626,15 +1134,15 @@ var init_postgres = __esm({
         const query = `
       SELECT tablename 
       FROM pg_catalog.pg_tables 
-      WHERE schemaname = 'public'
+      WHERE schemaname = $1
       ORDER BY tablename;
     `;
-        const res = await this.getPool().query(query);
+        const res = await this.getPool().query(query, [this.currentSchema]);
         return res.rows.map((row) => row.tablename);
       }
       async getSchema(tableName) {
         const query = `
-      SELECT c.column_name, c.data_type, c.is_nullable, c.column_default,
+      SELECT c.column_name, c.data_type, c.udt_name, c.is_nullable, c.column_default,
              (SELECT count(*) 
               FROM information_schema.key_column_usage kcu 
               JOIN information_schema.table_constraints tc 
@@ -692,11 +1200,44 @@ var init_postgres = __esm({
                  AND kcu.column_name = c.column_name
                LIMIT 1) as fk_on_update
       FROM information_schema.columns c
-      WHERE c.table_name = $1 AND c.table_schema = 'public'
+      WHERE c.table_name = $1 AND c.table_schema = $2
       ORDER BY c.ordinal_position;
     `;
-        const res = await this.getPool().query(query, [tableName]);
+        const res = await this.getPool().query(query, [
+          tableName,
+          this.currentSchema
+        ]);
         const enumMap = /* @__PURE__ */ new Map();
+        try {
+          const nativeEnumQuery = `
+            SELECT 
+                a.attname AS column_name,
+                t.typname AS enum_name,
+                e.enumlabel AS enum_value
+            FROM pg_attribute a
+            JOIN pg_class c ON a.attrelid = c.oid
+            JOIN pg_namespace nc ON nc.oid = c.relnamespace
+            JOIN pg_type t ON a.atttypid = t.oid
+            JOIN pg_enum e ON t.oid = e.enumtypid
+            WHERE c.relname = $1
+              AND nc.nspname = $2
+              AND a.attnum > 0
+              AND NOT a.attisdropped
+            ORDER BY a.attnum, e.enumsortorder;
+         `;
+          const nativeEnumRes = await this.getPool().query(nativeEnumQuery, [
+            tableName,
+            this.currentSchema
+          ]);
+          for (const r of nativeEnumRes.rows) {
+            const colName = r.column_name;
+            if (!enumMap.has(colName)) {
+              enumMap.set(colName, []);
+            }
+            enumMap.get(colName).push(r.enum_value);
+          }
+        } catch {
+        }
         try {
           const checkQuery = `
             SELECT cc.check_clause
@@ -704,16 +1245,19 @@ var init_postgres = __esm({
             JOIN information_schema.table_constraints tc 
               ON cc.constraint_name = tc.constraint_name 
              AND cc.constraint_schema = tc.constraint_schema
-            WHERE tc.table_name = $1 AND tc.table_schema = 'public';
+            WHERE tc.table_name = $1 AND tc.table_schema = $2;
          `;
-          const checkRes = await this.getPool().query(checkQuery, [tableName]);
+          const checkRes = await this.getPool().query(checkQuery, [
+            tableName,
+            this.currentSchema
+          ]);
           for (const r of checkRes.rows) {
             const inRegex = /["'`]?(\w+)["'`]?\s+(?:COLLATE\s+\w+\s+)?IN\s*\(([^)]+)\)/gi;
             let inMatch;
             while ((inMatch = inRegex.exec(r.check_clause)) !== null) {
               const colName = inMatch[1];
               const values = inMatch[2].split(",").map((s) => s.trim().replace(/^['"`]|['"`]$/g, "")).filter((s) => s.length > 0);
-              if (values.length > 0) {
+              if (values.length > 0 && !enumMap.has(colName)) {
                 enumMap.set(colName, values);
               }
             }
@@ -731,13 +1275,22 @@ var init_postgres = __esm({
               onUpdate: col.fk_on_update && col.fk_on_update.toUpperCase() !== "NO ACTION" ? col.fk_on_update.toUpperCase() : void 0
             };
           }
+          let colType = col.data_type;
+          if (col.data_type === "USER-DEFINED" && col.udt_name) {
+            colType = col.udt_name;
+          }
           return {
             name: col.column_name,
-            type: col.data_type,
+            type: colType,
             isPk: parseInt(col.is_pk) > 0,
             nullable: parseInt(col.is_pk) > 0 ? false : col.is_nullable === "YES",
             isUnique: parseInt(col.is_pk) > 0 || parseInt(col.is_unique) > 0,
-            defaultValue: col.column_default != null ? String(col.column_default) : void 0,
+            defaultValue: (() => {
+              if (col.column_default == null) return void 0;
+              const raw = String(col.column_default).trim();
+              const castMatch = raw.match(/^('[\s\S]*')(?:::[\w\s()]+)$/);
+              return castMatch ? castMatch[1] : raw;
+            })(),
             enumValues: enumMap.get(col.column_name),
             fkTarget
           };
@@ -751,22 +1304,22 @@ var init_postgres = __esm({
           ix.indisunique as is_unique,
           ix.indisprimary as is_primary
       FROM
-          pg_class t,
-          pg_class i,
-          pg_index ix,
-          pg_attribute a
+          pg_class t
+          JOIN pg_namespace n ON n.oid = t.relnamespace
+          JOIN pg_index ix ON t.oid = ix.indrelid
+          JOIN pg_class i ON i.oid = ix.indexrelid
+          JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
       WHERE
-          t.oid = ix.indrelid
-          AND i.oid = ix.indexrelid
-          AND a.attrelid = t.oid
-          AND a.attnum = ANY(ix.indkey)
-          AND t.relkind = 'r'
+          t.relkind = 'r'
           AND t.relname = $1
-          AND t.relnamespace = 'public'::regnamespace
+          AND n.nspname = $2
       ORDER BY
           i.relname, array_position(ix.indkey, a.attnum);
     `;
-        const res = await this.getPool().query(query, [tableName]);
+        const res = await this.getPool().query(query, [
+          tableName,
+          this.currentSchema
+        ]);
         const rows = res.rows;
         const indexMap = /* @__PURE__ */ new Map();
         for (const row of rows) {
@@ -786,7 +1339,7 @@ var init_postgres = __esm({
       async getData(tableName, limit = 50, offset = 0, whereClause, orderBy) {
         const schema = await this.getSchema(tableName);
         const columns = schema.map((col) => col.name);
-        let sql = `SELECT * FROM ${this.quoteIdentifier(tableName)}`;
+        let sql = `SELECT * FROM ${this.quoteTable(tableName)}`;
         if (whereClause) {
           sql += ` WHERE ${whereClause}`;
         }
@@ -828,7 +1381,7 @@ var init_postgres = __esm({
           await client.query("BEGIN");
           for (const row of rows) {
             const placeholders = cols.map((_, i) => `$${i + 1}`).join(", ");
-            const sql = `INSERT INTO ${this.quoteIdentifier(tableName)} (${colsQuoted}) VALUES (${placeholders})`;
+            const sql = `INSERT INTO ${this.quoteTable(tableName)} (${colsQuoted}) VALUES (${placeholders})`;
             const values = cols.map((c) => row[c]);
             await client.query(sql, values);
           }
@@ -840,12 +1393,83 @@ var init_postgres = __esm({
           client.release();
         }
       }
-      async truncateTable(tableName) {
-        const quoted = this.quoteIdentifier(tableName);
-        await this.getPool().query(
-          `TRUNCATE TABLE ${quoted} RESTART IDENTITY CASCADE;`
-        );
-      }
+      async truncateTable(tableName) {
+        const quoted = this.quoteTable(tableName);
+        await this.getPool().query(
+          `TRUNCATE TABLE ${quoted} RESTART IDENTITY CASCADE;`
+        );
+      }
+      /**
+       * Quote a table name with schema prefix, e.g. "zen_stream"."users".
+       * When the schema is 'public', only the table name is quoted for simplicity.
+       */
+      quoteTable(tableName) {
+        if (this.currentSchema === "public") {
+          return this.quoteIdentifier(tableName);
+        }
+        return `${this.quoteIdentifier(this.currentSchema)}.${this.quoteIdentifier(tableName)}`;
+      }
+      /**
+       * List all user-accessible schemas (excluding internal PostgreSQL schemas).
+       */
+      async getSchemas() {
+        const query = `
+         SELECT schema_name
+         FROM information_schema.schemata
+         WHERE schema_name NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+           AND schema_name NOT LIKE 'pg_temp_%'
+           AND schema_name NOT LIKE 'pg_toast_temp_%'
+         ORDER BY schema_name;
+      `;
+        const res = await this.getPool().query(query);
+        return res.rows.map((row) => row.schema_name);
+      }
+      getCurrentSchema() {
+        return this.currentSchema;
+      }
+      async setSchema(schema) {
+        this.currentSchema = schema;
+        if (this.pool) {
+          await this.pool.end();
+          this.pool = null;
+        }
+      }
+      /**
+       * List all user-defined enum types in the current schema or public.
+       * Prioritizes enums in the current active schema over public.
+       */
+      async getCustomEnums() {
+        const query = `
+         SELECT 
+             t.typname AS name,
+             n.nspname AS schema_name,
+             array_agg(e.enumlabel ORDER BY e.enumsortorder) AS values
+         FROM pg_type t
+         JOIN pg_enum e ON t.oid = e.enumtypid
+         JOIN pg_namespace n ON n.oid = t.typnamespace
+         WHERE n.nspname = $1 OR n.nspname = 'public'
+         GROUP BY t.oid, t.typname, n.nspname
+         ORDER BY (CASE WHEN n.nspname = $1 THEN 0 ELSE 1 END), t.typname;
+      `;
+        try {
+          const res = await this.getPool().query(query, [this.currentSchema]);
+          const seen = /* @__PURE__ */ new Set();
+          const result = [];
+          for (const row of res.rows) {
+            const lower = row.name.toLowerCase();
+            if (!seen.has(lower)) {
+              seen.add(lower);
+              result.push({
+                name: row.name,
+                values: Array.isArray(row.values) ? row.values : []
+              });
+            }
+          }
+          return result;
+        } catch {
+          return [];
+        }
+      }
     };
   }
 });
@@ -866,7 +1490,8 @@ var init_mysql = __esm({
         if (!this.pool) {
           this.pool = mysql.createPool({
             uri: this.connection,
-            multipleStatements: true
+            multipleStatements: true,
+            connectTimeout: 1e4
           });
           this.pool.on("connection", (connection) => {
             connection.query("SET SESSION sql_mode = 'ANSI_QUOTES'").catch(() => {
@@ -1032,331 +1657,106 @@ var init_mysql = __esm({
         const pool = await this.getPool();
         const schema = await this.getSchema(tableName);
         const columns = schema.map((col) => col.name);
-        let sql = `SELECT * FROM ${this.quoteIdentifier(tableName)}`;
-        if (whereClause) {
-          sql += ` WHERE ${whereClause}`;
-        }
-        if (orderBy) {
-          sql += ` ORDER BY ${this.quoteIdentifier(orderBy.col)} ${orderBy.asc ? "ASC" : "DESC"}`;
-        }
-        const [rows] = await pool.query(sql + " LIMIT ? OFFSET ?", [
-          limit,
-          offset
-        ]);
-        return { columns, rows };
-      }
-      async query(sql) {
-        const pool = await this.getPool();
-        const [rows, fields] = await pool.query(sql);
-        let columns = [];
-        let data = [];
-        let affectedRows = void 0;
-        if (fields && Array.isArray(fields)) {
-          columns = fields.map((f) => f.name);
-          data = rows;
-        } else {
-          columns = ["Result"];
-          const count = rows.affectedRows ?? 0;
-          affectedRows = count;
-          data = [{ Result: "Success", AffectedRows: count }];
-        }
-        return { columns, rows: data, affectedRows };
-      }
-      async executeSql(sql) {
-        const pool = await this.getPool();
-        await pool.query(sql);
-      }
-      async close() {
-        if (this.pool) {
-          await this.pool.end();
-          this.pool = null;
-        }
-      }
-      async insert(tableName, rows) {
-        if (rows.length === 0) return;
-        const pool = await this.getPool();
-        const connection = await pool.getConnection();
-        try {
-          const cols = Object.keys(rows[0]);
-          const colsQuoted = cols.map((c) => this.quoteIdentifier(c)).join(", ");
-          const placeholders = cols.map(() => "?").join(", ");
-          const sql = `INSERT INTO ${this.quoteIdentifier(tableName)} (${colsQuoted}) VALUES (${placeholders})`;
-          await connection.beginTransaction();
-          for (const row of rows) {
-            const values = cols.map((c) => row[c]);
-            await connection.query(sql, values);
-          }
-          await connection.commit();
-        } catch (e) {
-          await connection.rollback();
-          throw e;
-        } finally {
-          connection.release();
-        }
-      }
-      async truncateTable(tableName) {
-        const quoted = this.quoteIdentifier(tableName);
-        await this.executeSql(`TRUNCATE TABLE ${quoted};`);
-      }
-    };
-  }
-});
-
-// src/logic/adapters/index.ts
-var init_adapters = __esm({
-  "src/logic/adapters/index.ts"() {
-    "use strict";
-    init_sqlite();
-    init_postgres();
-    init_mysql();
-  }
-});
-
-// src/logic/factory.ts
-function createDBAdapter(config) {
-  switch (config.type) {
-    case "sqlite":
-      return new SqliteAdapter(config.targetUrl);
-    case "postgres":
-      return new PostgresAdapter(config.targetUrl);
-    case "mysql":
-      return new MysqlAdapter(config.targetUrl);
-    default:
-      throw new Error(`Unsupported database type: ${config.type}`);
-  }
-}
-var init_factory = __esm({
-  "src/logic/factory.ts"() {
-    "use strict";
-    init_adapters();
-  }
-});
-
-// src/logic/dialect.ts
-function getDialect(type) {
-  switch (type) {
-    case "sqlite":
-      return new SqliteDialect();
-    case "postgres":
-      return new PostgresDialect();
-    case "mysql":
-      return new MysqlDialect();
-    default:
-      return new SqliteDialect();
-  }
-}
-function buildSearchWhereClause(adapter, dbType, columns, searchInput) {
-  const searchVal = (searchInput || "").trim();
-  if (!searchVal) return "";
-  const isSqlCondition = /[=<>]|LIKE|IN|AND|OR/i.test(searchVal);
-  if (isSqlCondition) {
-    return searchVal;
-  }
-  const strCols = columns.filter((c) => {
-    const t = c.type.toLowerCase();
-    return t.includes("char") || t.includes("text") || t.includes("string") || t.includes("uuid");
-  });
-  if (strCols.length > 0) {
-    const likeOp = dbType === "postgres" ? "ILIKE" : "LIKE";
-    const escaped = searchVal.replace(/'/g, "''");
-    const conditions = strCols.map(
-      (c) => `${adapter.quoteIdentifier(c.name)} ${likeOp} '%${escaped}%'`
-    );
-    return conditions.join(" OR ");
-  }
-  if (columns.length > 0) {
-    const col = columns[0];
-    const escaped = searchVal.replace(/'/g, "''");
-    return `${adapter.quoteIdentifier(col.name)} = '${escaped}'`;
-  }
-  return "";
-}
-var SqliteDialect, PostgresDialect, MysqlDialect;
-var init_dialect = __esm({
-  "src/logic/dialect.ts"() {
-    "use strict";
-    SqliteDialect = class {
-      quoteIdentifier(name) {
-        return `"${name}"`;
-      }
-      escapeString(val) {
-        return val.replace(/'/g, "''");
-      }
-      buildCreateTable(tableName, columns) {
-        const lines = columns.map((col) => {
-          const isPk = !!(col.isPk || col.primaryKey);
-          const tLower = col.type.toLowerCase();
-          let typeStr = col.type;
-          if (tLower === "integer" || tLower === "int") typeStr = "INTEGER";
-          else if (tLower === "text" || tLower === "string") typeStr = "TEXT";
-          else if (tLower === "boolean" || tLower === "bool")
-            typeStr = "BOOLEAN";
-          else if (tLower === "decimal" || tLower === "numeric" || tLower === "float" || tLower === "double")
-            typeStr = "REAL";
-          else if (tLower === "datetime" || tLower === "timestamp")
-            typeStr = "DATETIME";
-          else if (col.enumValues && col.enumValues.length > 0) {
-            typeStr = `TEXT CHECK(${this.quoteIdentifier(col.name)} IN (${col.enumValues.map((v) => `'${this.escapeString(v)}'`).join(", ")}))`;
-          }
-          if (isPk && (tLower.includes("int") || typeStr === "INTEGER")) {
-            typeStr = "INTEGER PRIMARY KEY AUTOINCREMENT";
-          } else if (isPk) {
-            typeStr += " PRIMARY KEY";
-          } else {
-            if (!col.nullable) typeStr += " NOT NULL";
-            if (col.isUnique) typeStr += " UNIQUE";
-          }
-          if (col.defaultValue && col.defaultValue !== "AutoInc" && !col.defaultValue.startsWith("FK ->")) {
-            if (col.defaultValue === "Timestamp") {
-              typeStr += " DEFAULT CURRENT_TIMESTAMP";
-            } else {
-              typeStr += ` DEFAULT ${col.defaultValue}`;
-            }
-          }
-          return `  ${this.quoteIdentifier(col.name)} ${typeStr}`;
-        });
-        const fks = columns.filter(
-          (col) => col.fkTarget && col.fkTarget.table && col.fkTarget.column
-        ).map((col) => {
-          let fkStr = `  FOREIGN KEY (${this.quoteIdentifier(col.name)}) REFERENCES ${this.quoteIdentifier(col.fkTarget.table)}(${this.quoteIdentifier(col.fkTarget.column)})`;
-          if (col.fkTarget.onDelete && col.fkTarget.onDelete !== "NO ACTION") {
-            fkStr += ` ON DELETE ${col.fkTarget.onDelete}`;
-          }
-          if (col.fkTarget.onUpdate && col.fkTarget.onUpdate !== "NO ACTION") {
-            fkStr += ` ON UPDATE ${col.fkTarget.onUpdate}`;
-          }
-          return fkStr;
-        });
-        if (fks.length > 0) {
-          lines.push(...fks);
-        }
-        return `CREATE TABLE ${this.quoteIdentifier(tableName)} (
-${lines.join(",\n")}
-);`;
-      }
-    };
-    PostgresDialect = class {
-      quoteIdentifier(name) {
-        return `"${name}"`;
-      }
-      escapeString(val) {
-        return val.replace(/'/g, "''");
-      }
-      buildCreateTable(tableName, columns) {
-        const lines = columns.map((col) => {
-          const isPk = !!(col.isPk || col.primaryKey);
-          const tLower = col.type.toLowerCase();
-          let typeStr = col.type;
-          if (isPk && (tLower === "integer" || tLower === "int")) {
-            typeStr = "SERIAL PRIMARY KEY";
-          } else {
-            if (tLower === "integer" || tLower === "int") typeStr = "INTEGER";
-            else if (tLower === "text" || tLower === "string") typeStr = "TEXT";
-            else if (tLower === "boolean" || tLower === "bool")
-              typeStr = "BOOLEAN";
-            else if (tLower === "decimal" || tLower === "numeric")
-              typeStr = "NUMERIC";
-            else if (tLower === "datetime" || tLower === "timestamp")
-              typeStr = "TIMESTAMP";
-            else if (col.enumValues && col.enumValues.length > 0) {
-              typeStr = `VARCHAR(255) CHECK(${this.quoteIdentifier(col.name)} IN (${col.enumValues.map((v) => `'${this.escapeString(v)}'`).join(", ")}))`;
-            }
-            if (isPk) typeStr += " PRIMARY KEY";
-            if (!col.nullable && !isPk) typeStr += " NOT NULL";
-            if (col.isUnique && !isPk) typeStr += " UNIQUE";
-          }
-          if (col.defaultValue && col.defaultValue !== "AutoInc" && !col.defaultValue.startsWith("FK ->")) {
-            if (col.defaultValue === "Timestamp") {
-              typeStr += " DEFAULT CURRENT_TIMESTAMP";
-            } else {
-              typeStr += ` DEFAULT ${col.defaultValue}`;
-            }
-          }
-          return `  ${this.quoteIdentifier(col.name)} ${typeStr}`;
-        });
-        const fks = columns.filter(
-          (col) => col.fkTarget && col.fkTarget.table && col.fkTarget.column
-        ).map((col) => {
-          let fkStr = `  FOREIGN KEY (${this.quoteIdentifier(col.name)}) REFERENCES ${this.quoteIdentifier(col.fkTarget.table)}(${this.quoteIdentifier(col.fkTarget.column)})`;
-          if (col.fkTarget.onDelete && col.fkTarget.onDelete !== "NO ACTION") {
-            fkStr += ` ON DELETE ${col.fkTarget.onDelete}`;
-          }
-          if (col.fkTarget.onUpdate && col.fkTarget.onUpdate !== "NO ACTION") {
-            fkStr += ` ON UPDATE ${col.fkTarget.onUpdate}`;
-          }
-          return fkStr;
-        });
-        if (fks.length > 0) {
-          lines.push(...fks);
+        let sql = `SELECT * FROM ${this.quoteIdentifier(tableName)}`;
+        if (whereClause) {
+          sql += ` WHERE ${whereClause}`;
         }
-        return `CREATE TABLE ${this.quoteIdentifier(tableName)} (
-${lines.join(",\n")}
-);`;
+        if (orderBy) {
+          sql += ` ORDER BY ${this.quoteIdentifier(orderBy.col)} ${orderBy.asc ? "ASC" : "DESC"}`;
+        }
+        const [rows] = await pool.query(sql + " LIMIT ? OFFSET ?", [
+          limit,
+          offset
+        ]);
+        return { columns, rows };
       }
-    };
-    MysqlDialect = class {
-      quoteIdentifier(name) {
-        return `\`${name}\``;
+      async query(sql) {
+        const pool = await this.getPool();
+        const [rows, fields] = await pool.query(sql);
+        let columns = [];
+        let data = [];
+        let affectedRows = void 0;
+        if (fields && Array.isArray(fields)) {
+          columns = fields.map((f) => f.name);
+          data = rows;
+        } else {
+          columns = ["Result"];
+          const count = rows.affectedRows ?? 0;
+          affectedRows = count;
+          data = [{ Result: "Success", AffectedRows: count }];
+        }
+        return { columns, rows: data, affectedRows };
       }
-      escapeString(val) {
-        return val.replace(/'/g, "''");
+      async executeSql(sql) {
+        const pool = await this.getPool();
+        await pool.query(sql);
       }
-      buildCreateTable(tableName, columns) {
-        const lines = columns.map((col) => {
-          const isPk = !!(col.isPk || col.primaryKey);
-          const tLower = col.type.toLowerCase();
-          let typeStr = col.type;
-          if (tLower === "integer" || tLower === "int") typeStr = "INT";
-          else if (tLower === "text" || tLower === "string")
-            typeStr = "VARCHAR(255)";
-          else if (tLower === "boolean" || tLower === "bool")
-            typeStr = "BOOLEAN";
-          else if (tLower === "decimal" || tLower === "numeric")
-            typeStr = "DOUBLE";
-          else if (tLower === "datetime" || tLower === "timestamp")
-            typeStr = "DATETIME";
-          else if (col.enumValues && col.enumValues.length > 0) {
-            typeStr = `VARCHAR(255) CHECK(${this.quoteIdentifier(col.name)} IN (${col.enumValues.map((v) => `'${this.escapeString(v)}'`).join(", ")}))`;
-          }
-          if (isPk && (tLower.includes("int") || typeStr === "INT")) {
-            typeStr += " AUTO_INCREMENT PRIMARY KEY";
-          } else if (isPk) {
-            typeStr += " PRIMARY KEY";
-          }
-          if (!col.nullable && !isPk) typeStr += " NOT NULL";
-          if (col.isUnique && !isPk) typeStr += " UNIQUE";
-          if (col.defaultValue && col.defaultValue !== "AutoInc" && !col.defaultValue.startsWith("FK ->")) {
-            if (col.defaultValue === "Timestamp") {
-              typeStr += " DEFAULT CURRENT_TIMESTAMP";
-            } else {
-              typeStr += ` DEFAULT ${col.defaultValue}`;
-            }
-          }
-          return `  ${this.quoteIdentifier(col.name)} ${typeStr}`;
-        });
-        const fks = columns.filter(
-          (col) => col.fkTarget && col.fkTarget.table && col.fkTarget.column
-        ).map((col) => {
-          let fkStr = `  FOREIGN KEY (${this.quoteIdentifier(col.name)}) REFERENCES ${this.quoteIdentifier(col.fkTarget.table)}(${this.quoteIdentifier(col.fkTarget.column)})`;
-          if (col.fkTarget.onDelete && col.fkTarget.onDelete !== "NO ACTION") {
-            fkStr += ` ON DELETE ${col.fkTarget.onDelete}`;
-          }
-          if (col.fkTarget.onUpdate && col.fkTarget.onUpdate !== "NO ACTION") {
-            fkStr += ` ON UPDATE ${col.fkTarget.onUpdate}`;
+      async close() {
+        if (this.pool) {
+          await this.pool.end();
+          this.pool = null;
+        }
+      }
+      async insert(tableName, rows) {
+        if (rows.length === 0) return;
+        const pool = await this.getPool();
+        const connection = await pool.getConnection();
+        try {
+          const cols = Object.keys(rows[0]);
+          const colsQuoted = cols.map((c) => this.quoteIdentifier(c)).join(", ");
+          const placeholders = cols.map(() => "?").join(", ");
+          const sql = `INSERT INTO ${this.quoteIdentifier(tableName)} (${colsQuoted}) VALUES (${placeholders})`;
+          await connection.beginTransaction();
+          for (const row of rows) {
+            const values = cols.map((c) => row[c]);
+            await connection.query(sql, values);
           }
-          return fkStr;
-        });
-        if (fks.length > 0) {
-          lines.push(...fks);
+          await connection.commit();
+        } catch (e) {
+          await connection.rollback();
+          throw e;
+        } finally {
+          connection.release();
         }
-        return `CREATE TABLE ${this.quoteIdentifier(tableName)} (
-${lines.join(",\n")}
-);`;
+      }
+      async truncateTable(tableName) {
+        const quoted = this.quoteIdentifier(tableName);
+        await this.executeSql(`TRUNCATE TABLE ${quoted};`);
       }
     };
   }
 });
 
+// src/logic/adapters/index.ts
+var init_adapters = __esm({
+  "src/logic/adapters/index.ts"() {
+    "use strict";
+    init_sqlite();
+    init_postgres();
+    init_mysql();
+  }
+});
+
+// src/logic/factory.ts
+function createDBAdapter(config) {
+  switch (config.type) {
+    case "sqlite":
+      return new SqliteAdapter(config.targetUrl);
+    case "postgres":
+      return new PostgresAdapter(config.targetUrl);
+    case "mysql":
+      return new MysqlAdapter(config.targetUrl);
+    default:
+      throw new Error(`Unsupported database type: ${config.type}`);
+  }
+}
+var init_factory = __esm({
+  "src/logic/factory.ts"() {
+    "use strict";
+    init_adapters();
+  }
+});
+
 // src/logic/mutation.ts
 async function batchMutateTableData(adapter, dbType, options) {
   const {
@@ -1461,12 +1861,18 @@ async function batchMutateTableData(adapter, dbType, options) {
   }
   let executedCount = 0;
   try {
+    await adapter.executeSql("BEGIN;");
     for (const sql of sqls) {
       await adapter.executeSql(sql);
       executedCount++;
     }
+    await adapter.executeSql("COMMIT;");
     return ok({ modifiedCount: executedCount, executedCount });
   } catch (e) {
+    try {
+      await adapter.executeSql("ROLLBACK;");
+    } catch {
+    }
     return err(
       e.message || "Failed to execute database mutations",
       void 0,
@@ -1485,6 +1891,33 @@ var init_mutation = __esm({
 // src/logic/schema.ts
 async function createTable(adapter, dbType, tableName, columns) {
   try {
+    if (dbType === "postgres") {
+      const processedEnums = /* @__PURE__ */ new Set();
+      for (const col of columns) {
+        if (col.enumValues && col.enumValues.length > 0 && col.type && !["enum", "varchar", "varchar(255)", "text", "string"].includes(
+          col.type.toLowerCase()
+        ) && !processedEnums.has(col.type.toLowerCase())) {
+          processedEnums.add(col.type.toLowerCase());
+          const vals = col.enumValues.map((v) => `'${v.replace(/'/g, "''")}'`).join(", ");
+          const enumTypeQuoted = adapter.quoteIdentifier(col.type);
+          const escapedName = col.type.replace(/'/g, "''");
+          const createTypeSql = `
+                  DO $$
+                  BEGIN
+                     IF NOT EXISTS (
+                        SELECT 1 FROM pg_type t
+                        JOIN pg_namespace n ON n.oid = t.typnamespace
+                        WHERE t.typname = '${escapedName}'
+                          AND (n.nspname = current_schema() OR n.nspname = 'public')
+                     ) THEN
+                        CREATE TYPE ${enumTypeQuoted} AS ENUM (${vals});
+                     END IF;
+                  END$$;
+               `;
+          await adapter.executeSql(createTypeSql);
+        }
+      }
+    }
     const dialect = getDialect(dbType);
     const sql = dialect.buildCreateTable(tableName, columns);
     await adapter.executeSql(sql);
@@ -1575,6 +2008,7 @@ async function applySchemaChanges(adapter, dbType, options) {
           let nullable = edits.nullable !== void 0 ? !!edits.nullable : col.nullable;
           let defaultValue = edits.defaultValue !== void 0 ? edits.defaultValue : col.defaultValue;
           let isUnique = edits.isUnique !== void 0 ? !!edits.isUnique : col.isPk && !isPk ? false : !!col.isUnique;
+          let enumValues = edits.enumValues !== void 0 ? edits.enumValues : col.enumValues;
           if (edits.name && edits.name !== col.name) {
             renames[col.name] = edits.name;
           }
@@ -1585,7 +2019,8 @@ async function applySchemaChanges(adapter, dbType, options) {
             nullable,
             defaultValue,
             isUnique,
-            fkTarget
+            fkTarget,
+            enumValues
           });
         }
         for (const ins of pendingInserts) {
@@ -1620,7 +2055,8 @@ async function applySchemaChanges(adapter, dbType, options) {
             nullable: ins.nullable !== void 0 ? !!ins.nullable : true,
             defaultValue: ins.defaultValue,
             isUnique: !!ins.isUnique,
-            fkTarget
+            fkTarget,
+            enumValues: ins.enumValues
           });
         }
         targetColumns = updated;
@@ -1678,8 +2114,32 @@ async function applySchemaChanges(adapter, dbType, options) {
       const quotedCol = dialect.quoteIdentifier(currentName);
       const type = edits.type || "TEXT";
       if (dbType === "postgres") {
+        let pgType = type;
+        if (edits.enumValues && edits.enumValues.length > 0) {
+          if (edits.isNewEnum && edits.type) {
+            const escapedName = edits.type.replace(/'/g, "''");
+            const vals = edits.enumValues.map((v) => `'${dialect.escapeString(v)}'`).join(", ");
+            const quotedType = dialect.quoteIdentifier(edits.type);
+            sqls.push(`
+                     DO $$
+                     BEGIN
+                        IF NOT EXISTS (
+                           SELECT 1 FROM pg_type t
+                           JOIN pg_namespace n ON n.oid = t.typnamespace
+                           WHERE t.typname = '${escapedName}'
+                             AND (n.nspname = current_schema() OR n.nspname = 'public')
+                        ) THEN
+                           CREATE TYPE ${quotedType} AS ENUM (${vals});
+                        END IF;
+                     END$$;
+                  `);
+            pgType = quotedType;
+          } else if (edits.type) {
+            pgType = dialect.quoteIdentifier(edits.type);
+          }
+        }
         sqls.push(
-          `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedCol} TYPE ${type};`
+          `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedCol} TYPE ${pgType} USING ${quotedCol}::text::${pgType};`
         );
         if (edits.nullable === false) {
           sqls.push(
@@ -1690,17 +2150,29 @@ async function applySchemaChanges(adapter, dbType, options) {
             `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedCol} DROP NOT NULL;`
           );
         }
-        if (edits.defaultValue) {
-          const escapedDef = dialect.escapeString(edits.defaultValue);
-          sqls.push(
-            `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedCol} SET DEFAULT '${escapedDef}';`
-          );
+        if (edits.defaultValue !== void 0) {
+          const formatted = formatSqlDefaultValue(edits.defaultValue);
+          if (formatted !== null) {
+            sqls.push(
+              `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedCol} SET DEFAULT ${formatted};`
+            );
+          } else {
+            sqls.push(
+              `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedCol} DROP DEFAULT;`
+            );
+          }
         }
       } else if (dbType === "mysql") {
+        let mysqlType = type;
+        if (edits.enumValues && edits.enumValues.length > 0) {
+          const vals = edits.enumValues.map((v) => `'${dialect.escapeString(v)}'`).join(", ");
+          mysqlType = `ENUM(${vals})`;
+        }
         const nullStr = edits.nullable === false ? "NOT NULL" : "NULL";
-        const defStr = edits.defaultValue ? `DEFAULT '${dialect.escapeString(edits.defaultValue)}'` : "";
+        const formatted = formatSqlDefaultValue(edits.defaultValue);
+        const defStr = formatted !== null ? `DEFAULT ${formatted}` : "";
         sqls.push(
-          `ALTER TABLE ${quotedTable} MODIFY COLUMN ${quotedCol} ${type} ${nullStr} ${defStr};`
+          `ALTER TABLE ${quotedTable} MODIFY COLUMN ${quotedCol} ${mysqlType} ${nullStr} ${defStr};`
         );
       }
     }
@@ -1708,9 +2180,36 @@ async function applySchemaChanges(adapter, dbType, options) {
   for (const ins of pendingInserts) {
     if (!ins.name || ins.name.trim() === "") continue;
     const quotedCol = dialect.quoteIdentifier(ins.name.trim());
-    const type = ins.type || "TEXT";
+    let type = ins.type || "TEXT";
+    if (dbType === "postgres" && ins.enumValues && ins.enumValues.length > 0) {
+      if (ins.isNewEnum && ins.type) {
+        const escapedName = ins.type.replace(/'/g, "''");
+        const vals = ins.enumValues.map((v) => `'${dialect.escapeString(v)}'`).join(", ");
+        const quotedType = dialect.quoteIdentifier(ins.type);
+        sqls.push(`
+               DO $$
+               BEGIN
+                  IF NOT EXISTS (
+                     SELECT 1 FROM pg_type t
+                     JOIN pg_namespace n ON n.oid = t.typnamespace
+                     WHERE t.typname = '${escapedName}'
+                       AND (n.nspname = current_schema() OR n.nspname = 'public')
+                  ) THEN
+                     CREATE TYPE ${quotedType} AS ENUM (${vals});
+                  END IF;
+               END$$;
+            `);
+        type = quotedType;
+      } else if (ins.type) {
+        type = dialect.quoteIdentifier(ins.type);
+      }
+    } else if (dbType === "mysql" && ins.enumValues && ins.enumValues.length > 0) {
+      const vals = ins.enumValues.map((v) => `'${dialect.escapeString(v)}'`).join(", ");
+      type = `ENUM(${vals})`;
+    }
     const nullStr = ins.nullable === false ? "NOT NULL" : "";
-    const defStr = ins.defaultValue ? `DEFAULT '${dialect.escapeString(ins.defaultValue)}'` : "";
+    const formattedDef = formatSqlDefaultValue(ins.defaultValue);
+    const defStr = formattedDef !== null ? `DEFAULT ${formattedDef}` : "";
     sqls.push(
       `ALTER TABLE ${quotedTable} ADD COLUMN ${quotedCol} ${type} ${nullStr} ${defStr};`
     );
@@ -1749,7 +2248,7 @@ async function applySchemaChanges(adapter, dbType, options) {
 }
 async function getTableRowCount(adapter, tableName) {
   try {
-    const quoted = adapter.quoteIdentifier(tableName);
+    const quoted = adapter.quoteTable ? adapter.quoteTable(tableName) : adapter.quoteIdentifier(tableName);
     const countRes = await adapter.query(
       `SELECT COUNT(*) as cnt FROM ${quoted}`
     );
@@ -1921,6 +2420,43 @@ async function exportDatabaseSchemaDdl(adapter, dbType) {
     );
   }
 }
+async function getDatabaseEnums(adapter) {
+  try {
+    if (adapter.getCustomEnums) {
+      const enums = await adapter.getCustomEnums();
+      return ok(enums);
+    }
+    const enumsMap = /* @__PURE__ */ new Map();
+    try {
+      const tables = await adapter.getTables();
+      for (const t of tables.slice(0, 30)) {
+        const cols = await adapter.getSchema(t);
+        for (const col of cols) {
+          if (col.enumValues && col.enumValues.length > 0) {
+            const key = col.type && ![
+              "enum",
+              "varchar",
+              "varchar(255)",
+              "text",
+              "string"
+            ].includes(col.type.toLowerCase()) ? col.type : col.name;
+            if (!enumsMap.has(key)) {
+              enumsMap.set(key, col.enumValues);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    const data = Array.from(enumsMap.entries()).map(([name, values]) => ({
+      name,
+      values
+    }));
+    return ok(data);
+  } catch (e) {
+    return err(e.message || "Failed to get database enums", void 0, e);
+  }
+}
 var init_schema = __esm({
   "src/logic/schema.ts"() {
     "use strict";
@@ -1984,6 +2520,9 @@ function inferColumnStrategy(col) {
   if (name.includes("last_name")) {
     return { type: "last_name", label: "Last Name" };
   }
+  if (name.includes("username") || name.includes("user_name") || name.includes("handle")) {
+    return { type: "username", label: "Username" };
+  }
   if (name.includes("name") || name.includes("author") || name.includes("user")) {
     return { type: "full_name", label: "Full Name" };
   }
@@ -2064,6 +2603,11 @@ function generateFieldValue(strategy, fkCache = {}) {
       return getRandomItem(FIRST_NAMES);
     case "last_name":
       return getRandomItem(LAST_NAMES);
+    case "username": {
+      const f = getRandomItem(FIRST_NAMES).toLowerCase();
+      const l = getRandomItem(LAST_NAMES).toLowerCase();
+      return `${f}_${l}${getRandomInt(100, 99999)}`;
+    }
     case "full_name":
       return `${getRandomItem(FIRST_NAMES)} ${getRandomItem(LAST_NAMES)}`;
     case "avatar":
@@ -2285,6 +2829,27 @@ var init_seeder = __esm({
 // src/logic/transfer.ts
 import fs2 from "fs/promises";
 import path2 from "path";
+async function getRestoreCandidates(dir) {
+  const candidates = [];
+  try {
+    const entries = await fs2.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name.startsWith("drixio_backup_")) {
+        candidates.push({
+          name: `\u{1F4C1} ${entry.name} (Backup Directory)`,
+          value: entry.name
+        });
+      } else if (entry.isFile() && (entry.name.endsWith(".sql") || entry.name.endsWith(".json"))) {
+        candidates.push({
+          name: `\u{1F4C4} ${entry.name} (${entry.name.endsWith(".sql") ? "SQL Script" : "JSON Dump"})`,
+          value: entry.name
+        });
+      }
+    }
+  } catch {
+  }
+  return candidates;
+}
 function formatCsvValue(val) {
   if (val === null || val === void 0) return "";
   const str = String(val);
@@ -2778,10 +3343,157 @@ function generateDatabaseSqlDumpStream(adapter, dbType) {
           encoder.encode(`-- Error generating backup: ${e}
 `)
         );
-        controller.close();
+        controller.close();
+      }
+    }
+  });
+}
+function nodeToWebStream(nodeStream) {
+  return new ReadableStream({
+    start(controller) {
+      nodeStream.on("data", (chunk) => controller.enqueue(chunk));
+      nodeStream.on("end", () => controller.close());
+      nodeStream.on("error", (err2) => controller.error(err2));
+    },
+    cancel() {
+      nodeStream.destroy();
+    }
+  });
+}
+async function exportDatabaseNative(dbType, connectionUrl, schemaOnly) {
+  try {
+    const executeNativeDump = (cmd, args, envName) => {
+      return new Promise((resolve, reject) => {
+        const cp = import("child_process").then((m) => m.spawn(cmd, args));
+        let started = false;
+        cp.then((cpInstance) => {
+          const stream2 = nodeToWebStream(cpInstance.stdout);
+          cpInstance.on("error", (e) => {
+            if (!started)
+              reject(
+                new Error(
+                  `Native tool '${cmd}' not found. Please install ${envName}.`
+                )
+              );
+          });
+          setTimeout(() => {
+            if (!cpInstance.killed) {
+              started = true;
+              resolve(stream2);
+            }
+          }, 100);
+        });
+      });
+    };
+    let stream;
+    if (dbType === "sqlite") {
+      const dbPath = connectionUrl.replace("file:", "");
+      stream = await executeNativeDump(
+        "sqlite3",
+        [dbPath, schemaOnly ? ".schema" : ".dump"],
+        "SQLite CLI"
+      );
+    } else if (dbType === "mysql") {
+      const parsed = new URL(connectionUrl);
+      const user = parsed.username;
+      const pass = parsed.password;
+      const host = parsed.hostname;
+      const port = parsed.port || "3306";
+      const dbname = parsed.pathname.substring(1);
+      const args = ["-u", user, `-p${pass}`, "-h", host, "-P", port];
+      if (schemaOnly) args.push("--no-data");
+      args.push(dbname);
+      stream = await executeNativeDump(
+        "mysqldump",
+        args,
+        "MySQL Client"
+      );
+    } else if (dbType === "postgres") {
+      const args = [connectionUrl];
+      if (schemaOnly) args.push("--schema-only");
+      stream = await executeNativeDump(
+        "pg_dump",
+        args,
+        "PostgreSQL CLI"
+      );
+    } else {
+      return err("Unsupported database type for native export");
+    }
+    return ok(stream);
+  } catch (e) {
+    return err(e.message || "Failed to export database using native tool", void 0, e);
+  }
+}
+async function importDatabaseNative(adapter, dbType, connectionUrl, sqlContent) {
+  try {
+    const executeNativeImport = (cmd, args, fileContent, envName) => {
+      return new Promise((resolve, reject) => {
+        import("child_process").then((m) => {
+          const cp = m.spawn(cmd, args);
+          let started = false;
+          let errStr = "";
+          cp.on("error", (e) => {
+            if (!started)
+              reject(
+                new Error(
+                  `Native tool '${cmd}' not found. Please install ${envName}.`
+                )
+              );
+          });
+          cp.stderr.on("data", (d) => errStr += d.toString());
+          cp.on("close", (code) => {
+            if (code === 0) resolve();
+            else reject(new Error(`Native import failed: ${errStr}`));
+          });
+          cp.stdin.write(fileContent);
+          cp.stdin.end();
+          started = true;
+        });
+      });
+    };
+    try {
+      if (dbType === "sqlite") {
+        const dbPath = connectionUrl.replace("file:", "");
+        await executeNativeImport(
+          "sqlite3",
+          [dbPath],
+          sqlContent,
+          "SQLite CLI"
+        );
+      } else if (dbType === "mysql") {
+        const parsed = new URL(connectionUrl);
+        const user = parsed.username;
+        const pass = parsed.password;
+        const host = parsed.hostname;
+        const port = parsed.port || "3306";
+        const dbname = parsed.pathname.substring(1);
+        await executeNativeImport(
+          "mysql",
+          ["-u", user, `-p${pass}`, "-h", host, "-P", port, dbname],
+          sqlContent,
+          "MySQL Client"
+        );
+      } else if (dbType === "postgres") {
+        await executeNativeImport(
+          "psql",
+          [connectionUrl],
+          sqlContent,
+          "PostgreSQL CLI"
+        );
+      } else {
+        return err("Unsupported database type for native import");
+      }
+    } catch (e) {
+      if (e.message.includes("Native tool")) {
+        await adapter.executeSql(sqlContent);
+      } else {
+        throw e;
       }
     }
-  });
+    return ok({ message: "Import completed successfully" });
+  } catch (e) {
+    return err(`Import Failed: ${e.message}`, void 0, e);
+  }
 }
 var init_transfer = __esm({
   "src/logic/transfer.ts"() {
@@ -2842,6 +3554,10 @@ async function createDatabase(options) {
       });
       try {
         await conn.query(`CREATE DATABASE IF NOT EXISTS \`${dbName}\``);
+        const quotedDbName = dbName.replace(/`/g, "``");
+        await conn.query(
+          `CREATE DATABASE IF NOT EXISTS \`${quotedDbName}\``
+        );
       } finally {
         await conn.end();
       }
@@ -2872,6 +3588,8 @@ async function createDatabase(options) {
         );
         if (res.rowCount === 0) {
           await conn.query(`CREATE DATABASE "${dbName}"`);
+          const quotedDbName = dbName.replace(/"/g, '""');
+          await conn.query(`CREATE DATABASE "${quotedDbName}"`);
         }
       } finally {
         await conn.end();
@@ -2923,6 +3641,8 @@ async function dropDatabase(options) {
       });
       try {
         await conn.query(`DROP DATABASE IF EXISTS \`${dbName}\``);
+        const quotedDbName = dbName.replace(/`/g, "``");
+        await conn.query(`DROP DATABASE IF EXISTS \`${quotedDbName}\``);
       } finally {
         await conn.end();
       }
@@ -2949,6 +3669,8 @@ async function dropDatabase(options) {
       await conn.connect();
       try {
         await conn.query(`DROP DATABASE IF EXISTS "${dbName}"`);
+        const quotedDbName = dbName.replace(/"/g, '""');
+        await conn.query(`DROP DATABASE IF EXISTS "${quotedDbName}"`);
       } finally {
         await conn.end();
       }
@@ -3680,7 +4402,10 @@ function generateMigrationSql(diff, dbType) {
         let typeStr = col.type || "TEXT";
         if (col.nullable === false) typeStr += " NOT NULL";
         if (col.defaultValue !== void 0 && col.defaultValue !== null) {
-          typeStr += ` DEFAULT '${dialect.escapeString(col.defaultValue)}'`;
+          const formatted = formatSqlDefaultValue(col.defaultValue);
+          if (formatted !== null) {
+            typeStr += ` DEFAULT ${formatted}`;
+          }
         }
         lines.push(`ALTER TABLE ${qTable} ADD COLUMN ${qCol} ${typeStr};`);
       }
@@ -3809,7 +4534,10 @@ function generateRollbackSql(diff, dbType) {
         let typeStr = col.type || "TEXT";
         if (col.nullable === false) typeStr += " NOT NULL";
         if (col.defaultValue !== void 0 && col.defaultValue !== null) {
-          typeStr += ` DEFAULT '${dialect.escapeString(col.defaultValue)}'`;
+          const formatted = formatSqlDefaultValue(col.defaultValue);
+          if (formatted !== null) {
+            typeStr += ` DEFAULT ${formatted}`;
+          }
         }
         lines.push(`ALTER TABLE ${qTable} ADD COLUMN ${qCol} ${typeStr};`);
       }
@@ -4050,9 +4778,18 @@ function extractSnippetParams(sql) {
 function substituteSnippetParams(sql, params, dbType = "sqlite") {
   if (!sql) return "";
   const dialect = getDialect(dbType);
+  const identifierKeys = /* @__PURE__ */ new Set([
+    "table",
+    "column",
+    "child_table",
+    "parent_table",
+    "fk_col",
+    "pk_col"
+  ]);
   let result = sql;
   for (const [key, rawValue] of Object.entries(params)) {
     const valStr = rawValue !== void 0 && rawValue !== null ? String(rawValue) : "";
+    const isIdentifier = identifierKeys.has(key);
     const isNumber = !isNaN(Number(valStr)) && valStr.trim() !== "";
     const quotedMustache = new RegExp(`'\\{\\{\\s*${key}\\s*\\}\\}'`, "g");
     const quotedColon = new RegExp(`':${key}'`, "g");
@@ -4062,10 +4799,16 @@ function substituteSnippetParams(sql, params, dbType = "sqlite") {
     const rawMustache = new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, "g");
     result = result.replace(rawMustache, () => {
       return isNumber ? valStr : valStr;
+      if (isIdentifier) return dialect.quoteIdentifier(valStr);
+      if (isNumber) return valStr;
+      return `'${escapedVal}'`;
     });
     const rawColon = new RegExp(`(^|[^:]):${key}\\b`, "g");
     result = result.replace(rawColon, (_match, prefix) => {
       return `${prefix}${valStr}`;
+      if (isIdentifier) return `${prefix}${dialect.quoteIdentifier(valStr)}`;
+      if (isNumber) return `${prefix}${valStr}`;
+      return `${prefix}'${escapedVal}'`;
     });
   }
   return result;
@@ -4116,6 +4859,96 @@ var init_snippets = __esm({
   }
 });
 
+// src/logic/version.ts
+import fs5 from "fs";
+import path5 from "path";
+import { fileURLToPath } from "url";
+function getDrixioVersion() {
+  if (cachedVersion) {
+    return cachedVersion;
+  }
+  if ("1.2.0") {
+    cachedVersion = "1.2.0";
+    return cachedVersion;
+  }
+  try {
+    let currentDir = path5.dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 5; i++) {
+      const candidate = path5.join(currentDir, "package.json");
+      if (fs5.existsSync(candidate)) {
+        const pkg = JSON.parse(fs5.readFileSync(candidate, "utf-8"));
+        if (pkg.name === "drixio" && typeof pkg.version === "string") {
+          cachedVersion = pkg.version;
+          return pkg.version;
+        }
+      }
+      const parent = path5.dirname(currentDir);
+      if (parent === currentDir) break;
+      currentDir = parent;
+    }
+  } catch {
+  }
+  try {
+    const cwdPkgPath = path5.resolve(process.cwd(), "package.json");
+    if (fs5.existsSync(cwdPkgPath)) {
+      const pkg = JSON.parse(fs5.readFileSync(cwdPkgPath, "utf-8"));
+      if (pkg.name === "drixio" && typeof pkg.version === "string") {
+        cachedVersion = pkg.version;
+        return pkg.version;
+      }
+    }
+  } catch {
+  }
+  if (typeof process.env.npm_package_version === "string") {
+    cachedVersion = process.env.npm_package_version;
+    return cachedVersion;
+  }
+  cachedVersion = "0.0.0";
+  return cachedVersion;
+}
+var cachedVersion;
+var init_version = __esm({
+  "src/logic/version.ts"() {
+    "use strict";
+  }
+});
+
+// src/logic/serialization.ts
+var init_serialization = __esm({
+  "src/logic/serialization.ts"() {
+    "use strict";
+    if (!("toJSON" in BigInt.prototype)) {
+      BigInt.prototype.toJSON = function() {
+        return this.toString();
+      };
+    }
+  }
+});
+
+// src/logic/repl.ts
+function parseReplCommand(rawSql) {
+  const trimmed = rawSql.trim();
+  const connectMatch = trimmed.match(/^CONNECT\s+([^\s;]+)\s*;?$/i);
+  if (connectMatch) {
+    return { type: "connect", url: connectMatch[1], originalSql: rawSql };
+  }
+  if (/^DISCONNECT\s*;?$/i.test(trimmed)) {
+    return { type: "disconnect", originalSql: rawSql };
+  }
+  const createDbMatch = trimmed.match(
+    /^CREATE\s+DATABASE\s+(?:IF\s+NOT\s+EXISTS\s+)?['"`]?([^'";`\s]+)['"`]?\s*;?$/i
+  );
+  if (createDbMatch) {
+    return { type: "create_database", dbName: createDbMatch[1], originalSql: rawSql };
+  }
+  return { type: "sql", originalSql: rawSql };
+}
+var init_repl = __esm({
+  "src/logic/repl.ts"() {
+    "use strict";
+  }
+});
+
 // src/logic/index.ts
 var init_logic = __esm({
   "src/logic/index.ts"() {
@@ -4134,6 +4967,9 @@ var init_logic = __esm({
     init_safety();
     init_diff();
     init_snippets();
+    init_version();
+    init_serialization();
+    init_repl();
   }
 });
 
@@ -4177,7 +5013,7 @@ function printCustomDashboard(title, rows) {
   );
 }
 function printDashboard(dbConfig) {
-  const version = true ? "1.1.9" : process.env.npm_package_version || "unknown";
+  const version = getDrixioVersion();
   const headerTitle = ` Lightweight Interactive TUI Database Client  \u2022  v${version} `;
   let dbTypeVal = "None";
   let targetVal = "-";
@@ -4208,6 +5044,7 @@ var rgb, l1, l2, l3, l4, l5, l6;
 var init_logo = __esm({
   "src/tui/ui/logo.ts"() {
     "use strict";
+    init_version();
     rgb = (r, g, b) => (text) => `\x1B[38;2;${r};${g};${b}m${text}\x1B[39m`;
     l1 = rgb(0, 255, 255);
     l2 = rgb(0, 230, 245);
@@ -4526,8 +5363,8 @@ x Error creating table: ${e.message}`));
   await waitForEnter2();
 }
 async function waitForEnter2() {
-  const { input: input8 } = await import("@inquirer/prompts");
-  await input8({
+  const { input: input11 } = await import("@inquirer/prompts");
+  await input11({
     message: "Press Enter to continue..."
   });
 }
@@ -4600,8 +5437,8 @@ var init_buildTable = __esm({
 });
 
 // src/tui/views/sqlRunner.ts
-import fs14 from "fs/promises";
-import path14 from "path";
+import fs15 from "fs/promises";
+import path15 from "path";
 import { input as input5 } from "@inquirer/prompts";
 import pc29 from "picocolors";
 async function runSqlRunner(dbConfig) {
@@ -4622,10 +5459,10 @@ No database connection found. Please setup first.`)
       message: "Enter the path to your .md or .sql file:"
     });
     if (filePath && filePath.trim()) {
-      const absolutePath = path14.resolve(process.cwd(), filePath.trim());
+      const absolutePath = path15.resolve(process.cwd(), filePath.trim());
       let fileContent = "";
       try {
-        fileContent = await fs14.readFile(absolutePath, "utf-8");
+        fileContent = await fs15.readFile(absolutePath, "utf-8");
       } catch (err2) {
         console.log(pc29.red(`
 x Failed to read file: ${err2.message}`));
@@ -5157,45 +5994,486 @@ async function handleModifyMenu(dbConfig) {
       await runModifyTable(dbConfig, "delete");
       break;
   }
-  await waitForEnter3();
-}
-async function waitForEnter3() {
-  const { input: input8 } = await import("@inquirer/prompts");
-  await input8({
-    message: "Press Enter to continue..."
-  });
+  await waitForEnter3();
+}
+async function waitForEnter3() {
+  const { input: input11 } = await import("@inquirer/prompts");
+  await input11({
+    message: "Press Enter to continue..."
+  });
+}
+var init_tableManagerFlow = __esm({
+  "src/tui/wizards/tableManagerFlow.ts"() {
+    "use strict";
+    init_logic();
+    init_tableManager();
+    init_buildTable();
+    init_sqlRunner();
+    init_modifyTable();
+    init_mockWizard();
+    init_truncateWizard();
+    init_logo();
+  }
+});
+
+// src/tui/wizards/ormWizard.ts
+var ormWizard_exports = {};
+__export(ormWizard_exports, {
+  runOrmWizard: () => runOrmWizard
+});
+import { select as select13, input as input8 } from "@inquirer/prompts";
+import fs16 from "fs/promises";
+import path16 from "path";
+import pc34 from "picocolors";
+async function runOrmWizard(dbConfig) {
+  if (dbConfig.type === "unknown") {
+    console.log(
+      pc34.yellow(
+        "\nNo database connection found. Please setup database first."
+      )
+    );
+    return;
+  }
+  const adapter = createDBAdapter(dbConfig);
+  try {
+    const allSchemasRes = await getTableSchemas(adapter, void 0, true);
+    if (!allSchemasRes.success) {
+      console.log(
+        pc34.red(`
+\u2718 Failed to inspect schema: ${allSchemasRes.error}`)
+      );
+      return;
+    }
+    const allTables = allSchemasRes.data;
+    if (allTables.length === 0) {
+      console.log(pc34.yellow("\nNo tables found in this database."));
+      return;
+    }
+    console.log(pc34.cyan("\n--- Modern ORM & Type Definition Generator ---"));
+    console.log(
+      pc34.dim(
+        "Generate production-ready Prisma, Drizzle, or TypeScript definitions.\n"
+      )
+    );
+    const targetFormat = await select13({
+      message: "Select target ORM or definition format:",
+      choices: [
+        {
+          name: "Prisma Schema (schema.prisma)",
+          value: "prisma",
+          description: "Standard Prisma models with data source and generator"
+        },
+        {
+          name: "Drizzle ORM (schema.ts)",
+          value: "drizzle",
+          description: "Type-safe Drizzle table definitions with core packages"
+        },
+        {
+          name: "TypeScript Interfaces (drixio-types.d.ts)",
+          value: "types",
+          description: "Pure TypeScript interface definitions for database records"
+        }
+      ]
+    });
+    const scope = await select13({
+      message: "Select generation scope:",
+      choices: [
+        {
+          name: `All Tables (${allTables.length} tables)`,
+          value: "all"
+        },
+        {
+          name: "Single Table",
+          value: "single"
+        }
+      ]
+    });
+    let selectedTables = allTables;
+    if (scope === "single") {
+      const chosenTableName = await select13({
+        message: "Select table to generate code for:",
+        choices: allTables.map((t) => ({
+          name: t.tableName,
+          value: t.tableName
+        }))
+      });
+      selectedTables = allTables.filter((t) => t.tableName === chosenTableName);
+    }
+    let generatedCode = "";
+    let defaultFileName = "schema.ts";
+    if (targetFormat === "prisma") {
+      generatedCode = generatePrismaSchema(selectedTables, dbConfig.type);
+      defaultFileName = "schema.prisma";
+    } else if (targetFormat === "drizzle") {
+      generatedCode = generateDrizzleSchema(selectedTables, dbConfig.type);
+      defaultFileName = "schema.ts";
+    } else {
+      generatedCode = generateTypeScriptDefinitions(selectedTables, dbConfig.type);
+      defaultFileName = "drixio-types.d.ts";
+    }
+    const outputAction = await select13({
+      message: "What would you like to do with the generated code?",
+      choices: [
+        {
+          name: `Save to file (${defaultFileName})`,
+          value: "save"
+        },
+        {
+          name: "Print directly to terminal",
+          value: "print"
+        }
+      ]
+    });
+    if (outputAction === "print") {
+      console.log(pc34.bold(pc34.cyan(`
+--- Generated Code ---`)));
+      console.log(generatedCode);
+      console.log(pc34.bold(pc34.cyan(`----------------------
+`)));
+    } else {
+      const outPath = await input8({
+        message: "Enter destination file path:",
+        default: defaultFileName
+      });
+      const resolvedPath = path16.resolve(process.cwd(), outPath);
+      await fs16.mkdir(path16.dirname(resolvedPath), { recursive: true });
+      await fs16.writeFile(resolvedPath, generatedCode, "utf-8");
+      console.log(
+        pc34.green(
+          `
+\u2714 Successfully generated and saved to: ${pc34.bold(resolvedPath)}`
+        )
+      );
+    }
+  } catch (e) {
+    console.log(pc34.red(`
+\u2718 Code generation failed: ${e.message}`));
+  } finally {
+    await adapter.close();
+  }
+}
+var init_ormWizard = __esm({
+  "src/tui/wizards/ormWizard.ts"() {
+    "use strict";
+    init_logic();
+  }
+});
+
+// src/tui/wizards/snippetsWizard.ts
+var snippetsWizard_exports = {};
+__export(snippetsWizard_exports, {
+  runSnippetsWizard: () => runSnippetsWizard
+});
+import { select as select14, input as input9 } from "@inquirer/prompts";
+import pc35 from "picocolors";
+async function runSnippetsWizard(dbConfig) {
+  if (dbConfig.type === "unknown") {
+    console.log(
+      pc35.yellow(
+        "\nNo database connection found. Please setup database first."
+      )
+    );
+    return;
+  }
+  const snippets = await loadSnippets();
+  if (snippets.length === 0) {
+    console.log(pc35.yellow("\nNo SQL snippets found in workspace."));
+    return;
+  }
+  console.log(pc35.cyan("\n--- SQL Snippets & Operational Templates ---"));
+  console.log(
+    pc35.dim(
+      "Run parameterized diagnostic queries and high-frequency templates.\n"
+    )
+  );
+  const snippetChoices = snippets.map((s) => ({
+    name: `${s.title} ${pc35.dim(`(${s.tags?.join(", ") || "general"})`)}`,
+    value: s.id,
+    description: s.description || s.sql
+  }));
+  const chosenId = await select14({
+    message: "Select a snippet to execute:",
+    choices: snippetChoices
+  });
+  const snippet = snippets.find((s) => s.id === chosenId);
+  if (!snippet) return;
+  console.log(pc35.bold(pc35.cyan(`
+Template SQL:`)));
+  console.log(pc35.dim(snippet.sql));
+  const params = extractSnippetParams(snippet.sql);
+  const paramValues = {};
+  if (params.length > 0) {
+    console.log(pc35.yellow(`
+This query requires ${params.length} parameter(s):`));
+    for (const param of params) {
+      let defaultVal = "";
+      if (param === "limit") defaultVal = "20";
+      if (param === "table") defaultVal = "users";
+      const val = await input9({
+        message: `Enter value for :${pc35.bold(param)}:`,
+        default: defaultVal
+      });
+      paramValues[param] = val;
+    }
+  }
+  const finalSql = substituteSnippetParams(
+    snippet.sql,
+    paramValues,
+    dbConfig.type
+  );
+  console.log(pc35.bold(pc35.cyan(`
+Executing Query:`)));
+  console.log(pc35.white(finalSql));
+  const adapter = createDBAdapter(dbConfig);
+  try {
+    const startTime = performance.now();
+    const result = await adapter.query(finalSql);
+    const elapsed = Math.round(performance.now() - startTime);
+    console.log(
+      pc35.green(
+        `
+\u2714 Query executed successfully in ${elapsed}ms (${result.rows.length} row(s) returned):
+`
+      )
+    );
+    if (result.rows.length > 0) {
+      console.table(result.rows.slice(0, 50));
+      if (result.rows.length > 50) {
+        console.log(
+          pc35.dim(`... and ${result.rows.length - 50} more row(s) hidden.`)
+        );
+      }
+    } else {
+      console.log(pc35.dim("(No rows returned)"));
+    }
+  } catch (e) {
+    console.log(pc35.red(`
+\u2718 Query execution failed: ${e.message}`));
+  } finally {
+    await adapter.close();
+  }
+}
+var init_snippetsWizard = __esm({
+  "src/tui/wizards/snippetsWizard.ts"() {
+    "use strict";
+    init_logic();
+  }
+});
+
+// src/tui/wizards/diffWizard.ts
+var diffWizard_exports = {};
+__export(diffWizard_exports, {
+  runDiffWizard: () => runDiffWizard
+});
+import { select as select15, input as input10 } from "@inquirer/prompts";
+import fs17 from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import path17 from "path";
+import pc36 from "picocolors";
+async function runDiffWizard(dbConfig) {
+  if (dbConfig.type === "unknown") {
+    console.log(
+      pc36.yellow(
+        "\nNo database connection found. Please setup database first."
+      )
+    );
+    return;
+  }
+  console.log(pc36.cyan("\n--- Schema Diff & Migration Wizard ---"));
+  console.log(
+    pc36.dim(
+      "Compare schemas against snapshots or external databases, and generate Up/Down migration SQL.\n"
+    )
+  );
+  const action = await select15({
+    message: "Select diff action:",
+    choices: [
+      {
+        name: "Capture Schema Snapshot (JSON)",
+        value: "snapshot",
+        description: "Save current database structure to a versioned JSON snapshot"
+      },
+      {
+        name: "Compare with Snapshot File (.json)",
+        value: "compare-file",
+        description: "Compare current database with a saved schema snapshot file"
+      },
+      {
+        name: "Compare with Another Database URL",
+        value: "compare-url",
+        description: "Compare current database directly with a remote/local database"
+      }
+    ]
+  });
+  const adapter = createDBAdapter(dbConfig);
+  try {
+    if (action === "snapshot") {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const defaultFileName = `.drixio/snapshot_${timestamp}.json`;
+      const outPath = await input10({
+        message: "Enter output file path for snapshot:",
+        default: defaultFileName
+      });
+      const resolvedPath = path17.resolve(process.cwd(), outPath);
+      await fs17.mkdir(path17.dirname(resolvedPath), { recursive: true });
+      console.log(pc36.dim("\nCapturing schema snapshot..."));
+      const snapshotRes = await createSchemaSnapshot(
+        adapter,
+        dbConfig.type,
+        path17.basename(outPath, ".json")
+      );
+      if (!snapshotRes.success) {
+        console.log(pc36.red(`
+\u2718 Failed to create snapshot: ${snapshotRes.error}`));
+        return;
+      }
+      await fs17.writeFile(
+        resolvedPath,
+        JSON.stringify(snapshotRes.data, null, 2),
+        "utf-8"
+      );
+      console.log(
+        pc36.green(
+          `
+\u2714 Successfully saved snapshot with ${snapshotRes.data.tables.length} table(s) to: ${pc36.bold(resolvedPath)}`
+        )
+      );
+      return;
+    }
+    let diffResult;
+    if (action === "compare-file") {
+      const defaultPath = existsSync3(path17.resolve(process.cwd(), ".drixio/schema.json")) ? ".drixio/schema.json" : "schema.json";
+      const snapshotPath = await input10({
+        message: "Enter path to snapshot JSON file:",
+        default: defaultPath
+      });
+      const resolvedSnapshot = path17.resolve(process.cwd(), snapshotPath);
+      if (!existsSync3(resolvedSnapshot)) {
+        console.log(pc36.red(`
+\u2718 Snapshot file not found: ${resolvedSnapshot}`));
+        return;
+      }
+      console.log(pc36.dim("\nComparing current database with snapshot..."));
+      const content = await fs17.readFile(resolvedSnapshot, "utf-8");
+      let snapshot;
+      try {
+        snapshot = JSON.parse(content);
+      } catch {
+        console.log(pc36.red(`
+\u2718 Invalid JSON content in snapshot file: ${resolvedSnapshot}`));
+        return;
+      }
+      const res = await diffDatabaseWithSnapshot(
+        adapter,
+        snapshot,
+        dbConfig.type,
+        "Current Database",
+        `Snapshot (${path17.basename(resolvedSnapshot)})`
+      );
+      if (!res.success) {
+        console.log(pc36.red(`
+\u2718 Diff failed: ${res.error}`));
+        return;
+      }
+      diffResult = res.data;
+    } else {
+      const targetUrl = await input10({
+        message: "Enter target database connection URL (e.g. postgres://user:pass@host:5432/other_db):"
+      });
+      if (!targetUrl.trim()) {
+        console.log(pc36.yellow("Target URL cannot be empty."));
+        return;
+      }
+      console.log(pc36.dim("\nConnecting to target database and comparing..."));
+      const targetConfig = await detectDatabase(targetUrl.trim());
+      const targetAdapter = createDBAdapter(targetConfig);
+      try {
+        const res = await diffDatabases(
+          adapter,
+          targetAdapter,
+          dbConfig.type,
+          "Current Database",
+          "Target Database"
+        );
+        if (!res.success) {
+          console.log(pc36.red(`
+\u2718 Diff failed: ${res.error}`));
+          return;
+        }
+        diffResult = res.data;
+      } finally {
+        await targetAdapter.close();
+      }
+    }
+    if (!diffResult.hasChanges) {
+      console.log(pc36.green("\n\u2714 No schema differences detected. Both schemas are identical!"));
+      return;
+    }
+    console.log(pc36.bold(pc36.yellow(`
+--- Schema Differences Detected ---`)));
+    console.log(`  Added Tables:    ${diffResult.stats.addedTablesCount}`);
+    console.log(`  Dropped Tables:  ${diffResult.stats.droppedTablesCount}`);
+    console.log(`  Altered Tables:  ${diffResult.stats.alteredTablesCount}`);
+    console.log(`  Added Columns:   ${diffResult.stats.addedColumnsCount}`);
+    console.log(`  Dropped Columns: ${diffResult.stats.droppedColumnsCount}`);
+    console.log(`  Added Indexes:   ${diffResult.stats.addedIndexesCount}`);
+    console.log(`  Dropped Indexes: ${diffResult.stats.droppedIndexesCount}`);
+    const nextStep = await select15({
+      message: "What would you like to inspect?",
+      choices: [
+        {
+          name: "View Forward Migration SQL (Up)",
+          value: "view-up"
+        },
+        {
+          name: "View Rollback SQL (Down)",
+          value: "view-down"
+        },
+        {
+          name: "Save Migration SQL to File",
+          value: "save-sql"
+        }
+      ]
+    });
+    if (nextStep === "view-up") {
+      console.log(pc36.bold(pc36.cyan("\n--- Forward Migration SQL (Up) ---")));
+      console.log(diffResult.migrationSql);
+      console.log(pc36.bold(pc36.cyan("----------------------------------\n")));
+    } else if (nextStep === "view-down") {
+      console.log(pc36.bold(pc36.cyan("\n--- Rollback SQL (Down) ---")));
+      console.log(diffResult.rollbackSql);
+      console.log(pc36.bold(pc36.cyan("---------------------------\n")));
+    } else if (nextStep === "save-sql") {
+      const outSqlPath = await input10({
+        message: "Enter destination file path:",
+        default: "migration.sql"
+      });
+      const resolvedOut = path17.resolve(process.cwd(), outSqlPath);
+      await fs17.mkdir(path17.dirname(resolvedOut), { recursive: true });
+      await fs17.writeFile(resolvedOut, diffResult.migrationSql, "utf-8");
+      console.log(
+        pc36.green(`
+\u2714 Migration SQL successfully saved to: ${pc36.bold(resolvedOut)}`)
+      );
+    }
+  } catch (e) {
+    console.log(pc36.red(`
+\u2718 Schema diff failed: ${e.message}`));
+  } finally {
+    await adapter.close();
+  }
 }
-var init_tableManagerFlow = __esm({
-  "src/tui/wizards/tableManagerFlow.ts"() {
+var init_diffWizard = __esm({
+  "src/tui/wizards/diffWizard.ts"() {
     "use strict";
     init_logic();
-    init_tableManager();
-    init_buildTable();
-    init_sqlRunner();
-    init_modifyTable();
-    init_mockWizard();
-    init_truncateWizard();
-    init_logo();
   }
 });
 
 // src/studio/api.ts
 import { Hono } from "hono";
-import { spawn } from "child_process";
-import path15 from "path";
-import fs15 from "fs";
-function nodeToWebStream(nodeStream) {
-  return new ReadableStream({
-    start(controller) {
-      nodeStream.on("data", (chunk) => controller.enqueue(chunk));
-      nodeStream.on("end", () => controller.close());
-      nodeStream.on("error", (err2) => controller.error(err2));
-    },
-    cancel() {
-      nodeStream.destroy();
-    }
-  });
-}
+import path18 from "path";
+import fs18 from "fs";
 function registerApiRoutes(app, dbConfig) {
   const api = new Hono();
   let currentDbConfig = { ...dbConfig };
@@ -5279,15 +6557,41 @@ function registerApiRoutes(app, dbConfig) {
       return c.json({ success: false, error: e.message }, 500);
     }
   });
+  const detectHostEnvironment = (cfg) => {
+    if (cfg.type === "sqlite") {
+      return {
+        isRemote: false,
+        host: "local",
+        badgeLabel: "LOCAL (SQLite)"
+      };
+    }
+    if (cfg.type === "mysql" || cfg.type === "postgres") {
+      let host = "localhost";
+      const match = cfg.targetUrl.match(/@([^:/@?]+)/);
+      if (match) host = match[1];
+      const isLocal = host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "0.0.0.0" || host === "host.docker.internal";
+      return {
+        isRemote: !isLocal,
+        host,
+        badgeLabel: isLocal ? `LOCAL (${cfg.type.toUpperCase()})` : `REMOTE (${host})`
+      };
+    }
+    return { isRemote: false, host: "", badgeLabel: "DISCONNECTED" };
+  };
   api.get("/config", (c) => {
     const isConnected = !!currentAdapter && currentDbConfig.type !== "unknown";
+    const envInfo = detectHostEnvironment(currentDbConfig);
     return c.json({
       success: true,
       data: {
+        appVersion: getDrixioVersion(),
         connected: isConnected,
         dbType: isConnected ? currentDbConfig.type : "none",
         dbName: isConnected ? getDbName() : "No Database",
-        targetUrl: currentDbConfig.targetUrl || ""
+        targetUrl: currentDbConfig.targetUrl || "",
+        isRemote: envInfo.isRemote,
+        host: envInfo.host,
+        badgeLabel: isConnected ? envInfo.badgeLabel : "DISCONNECTED"
       }
     });
   });
@@ -5538,7 +6842,7 @@ function registerApiRoutes(app, dbConfig) {
       return c.json({ success: false, error: e.message }, 500);
     }
   });
-  api.post("/analyze-query", async (c) => {
+  api.post("/query/analyze", async (c) => {
     try {
       const { sql } = await c.req.json().catch(() => ({}));
       const result = analyzeDangerousQuery(sql);
@@ -5556,10 +6860,9 @@ function registerApiRoutes(app, dbConfig) {
           400
         );
       }
-      const trimmed = sql.trim();
-      const connectMatch = trimmed.match(/^CONNECT\s+([^\s;]+)\s*;?$/i);
-      if (connectMatch) {
-        const rawUrl = connectMatch[1];
+      const replCmd = parseReplCommand(sql);
+      if (replCmd.type === "connect" && replCmd.url) {
+        const rawUrl = replCmd.url;
         const newConfig = await detectDatabase(rawUrl);
         const newAdapter = createDBAdapter(newConfig);
         await newAdapter.getTables();
@@ -5591,7 +6894,7 @@ function registerApiRoutes(app, dbConfig) {
           }
         });
       }
-      if (/^DISCONNECT\s*;?$/i.test(trimmed)) {
+      if (replCmd.type === "disconnect") {
         if (currentAdapter) {
           try {
             await currentAdapter.close();
@@ -5618,11 +6921,8 @@ function registerApiRoutes(app, dbConfig) {
           }
         });
       }
-      const createDbMatch = trimmed.match(
-        /^CREATE\s+DATABASE\s+(?:IF\s+NOT\s+EXISTS\s+)?['"`]?([^'";`\s]+)['"`]?\s*;?$/i
-      );
-      if (createDbMatch) {
-        const dbName = createDbMatch[1];
+      if (replCmd.type === "create_database" && replCmd.dbName) {
+        const dbName = replCmd.dbName;
         if (currentAdapter && (currentDbConfig.type === "postgres" || currentDbConfig.type === "mysql")) {
           const quote = currentDbConfig.type === "mysql" ? "`" : '"';
           await currentAdapter.executeSql(
@@ -5694,6 +6994,49 @@ function registerApiRoutes(app, dbConfig) {
       return c.json({ success: false, error: e.message }, 500);
     }
   });
+  api.post("/query/explain", async (c) => {
+    try {
+      const { sql } = await c.req.json().catch(() => ({}));
+      if (!sql || typeof sql !== "string") {
+        return c.json(
+          { success: false, error: "SQL query is required for explain" },
+          400
+        );
+      }
+      const adapter = getAdapter();
+      const explainRes = generateExplainQuery(sql, currentDbConfig.type);
+      if (explainRes.error || !explainRes.sql) {
+        return c.json({ success: false, error: explainRes.error }, 400);
+      }
+      let explainSql = explainRes.sql;
+      const startTime = performance.now();
+      let res;
+      try {
+        res = await adapter.query(explainSql);
+      } catch (primaryErr) {
+        if (currentDbConfig.type === "postgres") {
+          const fallbackRes = generateExplainQuery(sql, "unknown");
+          explainSql = fallbackRes.sql;
+          res = await adapter.query(explainSql);
+        } else {
+          throw primaryErr;
+        }
+      }
+      const durationMs = Math.round(performance.now() - startTime);
+      return c.json({
+        success: true,
+        data: {
+          columns: res.columns,
+          rows: res.rows,
+          durationMs,
+          explainSql,
+          dialect: currentDbConfig.type
+        }
+      });
+    } catch (e) {
+      return c.json({ success: false, error: e.message }, 500);
+    }
+  });
   api.post("/query/export", async (c) => {
     try {
       const body = await c.req.json();
@@ -5766,68 +7109,25 @@ function registerApiRoutes(app, dbConfig) {
       }
       const type = currentDbConfig.type;
       const url = currentDbConfig.targetUrl;
-      let child;
       let filename = "backup.sql";
-      const executeNativeDump = (cmd, args, envName) => {
-        return new Promise((resolve, reject) => {
-          const cp = spawn(cmd, args);
-          let started = false;
-          const stream = nodeToWebStream(cp.stdout);
-          cp.on("error", (err2) => {
-            if (!started)
-              reject(
-                new Error(
-                  `Native tool '${cmd}' not found. Please install ${envName}.`
-                )
-              );
-          });
-          setTimeout(() => {
-            if (!cp.killed) {
-              started = true;
-              resolve(stream);
-            }
-          }, 100);
-        });
-      };
       try {
-        let stream;
         const baseName = getDbName();
         const timeStr = getDatetimeStr();
         filename = `${baseName}_backup_${timeStr}.sql`;
-        if (type === "sqlite") {
-          const dbPath = url.replace("file:", "");
-          stream = await executeNativeDump(
-            "sqlite3",
-            [dbPath, ".dump"],
-            "SQLite CLI"
-          );
-        } else if (type === "mysql") {
-          const parsed = new URL(url);
-          const user = parsed.username;
-          const pass = parsed.password;
-          const host = parsed.hostname;
-          const port = parsed.port || "3306";
-          const dbname = parsed.pathname.substring(1);
-          stream = await executeNativeDump(
-            "mysqldump",
-            ["-u", user, `-p${pass}`, "-h", host, "-P", port, dbname],
-            "MySQL Client"
-          );
-        } else if (type === "postgres") {
-          stream = await executeNativeDump(
-            "pg_dump",
-            [url],
-            "PostgreSQL CLI"
-          );
-        } else {
-          throw new Error("Unsupported database type for native export");
+        const exportRes = await exportDatabaseNative(
+          type,
+          url,
+          false
+        );
+        if (!exportRes.success) {
+          throw new Error(exportRes.error);
         }
         c.header(
           "Content-Disposition",
           `attachment; filename="${filename}"`
         );
         c.header("Content-Type", "application/sql");
-        return c.body(stream);
+        return c.body(exportRes.data);
       } catch (err2) {
         if (err2.message.includes("Native tool")) {
           const baseName = getDbName();
@@ -5883,67 +7183,14 @@ function registerApiRoutes(app, dbConfig) {
       const sqlContent = await file.text();
       const type = currentDbConfig.type;
       const url = currentDbConfig.targetUrl;
-      const executeNativeImport = (cmd, args, fileContent, envName) => {
-        return new Promise((resolve, reject) => {
-          const cp = spawn(cmd, args);
-          let started = false;
-          let errStr = "";
-          cp.on("error", (err2) => {
-            if (!started)
-              reject(
-                new Error(
-                  `Native tool '${cmd}' not found. Please install ${envName}.`
-                )
-              );
-          });
-          cp.stderr.on("data", (d) => errStr += d.toString());
-          cp.on("close", (code) => {
-            if (code === 0) resolve();
-            else reject(new Error(`Native import failed: ${errStr}`));
-          });
-          cp.stdin.write(fileContent);
-          cp.stdin.end();
-          started = true;
-        });
-      };
-      try {
-        if (type === "sqlite") {
-          const dbPath = url.replace("file:", "");
-          await executeNativeImport(
-            "sqlite3",
-            [dbPath],
-            sqlContent,
-            "SQLite CLI"
-          );
-        } else if (type === "mysql") {
-          const parsed = new URL(url);
-          const user = parsed.username;
-          const pass = parsed.password;
-          const host = parsed.hostname;
-          const port = parsed.port || "3306";
-          const dbname = parsed.pathname.substring(1);
-          await executeNativeImport(
-            "mysql",
-            ["-u", user, `-p${pass}`, "-h", host, "-P", port, dbname],
-            sqlContent,
-            "MySQL Client"
-          );
-        } else if (type === "postgres") {
-          await executeNativeImport(
-            "psql",
-            [url],
-            sqlContent,
-            "PostgreSQL CLI"
-          );
-        } else {
-          throw new Error("Unsupported database type for native import");
-        }
-      } catch (err2) {
-        if (err2.message.includes("Native tool")) {
-          await getAdapter().executeSql(sqlContent);
-        } else {
-          throw err2;
-        }
+      const importRes = await importDatabaseNative(
+        getAdapter(),
+        type,
+        url,
+        sqlContent
+      );
+      if (!importRes.success) {
+        return c.json({ success: false, error: importRes.error }, 500);
       }
       return c.json({
         success: true,
@@ -6283,11 +7530,10 @@ function registerApiRoutes(app, dbConfig) {
       const dialect = (dbType || "sqlite").toLowerCase();
       if (dialect === "sqlite") {
         const rawPath = body.url || body.sqlitePath || dbName || "drixio.sqlite";
-        const cleanPath = rawPath.replace(/^file:/, "").trim();
-        const fullPath = path15.isAbsolute(cleanPath) ? cleanPath : path15.resolve(process.cwd(), cleanPath);
+        const fullPath = resolveLocalDbPath(rawPath, process.cwd());
         if (mode === "create") {
-          const dir = path15.dirname(fullPath);
-          if (!fs15.existsSync(dir)) {
+          const dir = path18.dirname(fullPath);
+          if (!fs18.existsSync(dir)) {
             return c.json(
               {
                 success: false,
@@ -6296,18 +7542,18 @@ function registerApiRoutes(app, dbConfig) {
               400
             );
           }
-          const exists = fs15.existsSync(fullPath);
+          const exists = fs18.existsSync(fullPath);
           const latencyMs2 = Date.now() - startTime;
           return c.json({
             success: true,
             data: {
               latencyMs: latencyMs2,
-              message: exists ? `File already exists at "${path15.basename(fullPath)}". Will connect and reuse.` : `Target path is valid. File will be created on connect.`,
+              message: exists ? `File already exists at "${path18.basename(fullPath)}". Will connect and reuse.` : `Target path is valid. File will be created on connect.`,
               fullPath
             }
           });
         } else {
-          if (!fs15.existsSync(fullPath)) {
+          if (!fs18.existsSync(fullPath)) {
             return c.json(
               {
                 success: false,
@@ -6316,7 +7562,7 @@ function registerApiRoutes(app, dbConfig) {
               400
             );
           }
-          const stats = fs15.statSync(fullPath);
+          const stats = fs18.statSync(fullPath);
           if (stats.isDirectory()) {
             return c.json(
               {
@@ -6344,12 +7590,7 @@ function registerApiRoutes(app, dbConfig) {
       }
       let targetUrl = "";
       if (mode === "create") {
-        const targetHost = host || "localhost";
-        const targetPort = port || (dialect === "postgres" ? "5432" : "3306");
-        const targetUser = user || (dialect === "postgres" ? "postgres" : "root");
-        const auth = password ? `${encodeURIComponent(targetUser)}:${encodeURIComponent(password)}` : encodeURIComponent(targetUser);
-        const defaultDb = dialect === "postgres" ? "postgres" : "";
-        targetUrl = `${dialect}://${auth}@${targetHost}:${targetPort}/${defaultDb}`;
+        targetUrl = assembleConnectionUrl(dialect, host, port, user, password, "");
       } else {
         const rawUrl = body.url;
         if (!rawUrl) {
@@ -6417,6 +7658,73 @@ function registerApiRoutes(app, dbConfig) {
       return c.json({ success: false, error: e.message }, 500);
     }
   });
+  api.get("/schemas", async (c) => {
+    try {
+      const adapter = currentAdapter;
+      const supported = !!adapter && typeof adapter.getSchemas === "function" && currentDbConfig.type === "postgres";
+      if (!supported || !adapter) {
+        return c.json({
+          success: true,
+          data: { supported: false, schemas: [], currentSchema: "public" }
+        });
+      }
+      const schemas = await adapter.getSchemas();
+      const currentSchema = adapter.getCurrentSchema ? adapter.getCurrentSchema() : "public";
+      return c.json({
+        success: true,
+        data: { supported: true, schemas, currentSchema }
+      });
+    } catch (e) {
+      return c.json({ success: false, error: e.message }, 500);
+    }
+  });
+  api.post("/schemas/switch", async (c) => {
+    try {
+      const { schema } = await c.req.json().catch(() => ({}));
+      if (!schema || typeof schema !== "string") {
+        return c.json(
+          { success: false, error: "Schema name is required" },
+          400
+        );
+      }
+      const adapter = currentAdapter;
+      if (!adapter || typeof adapter.setSchema !== "function" || currentDbConfig.type !== "postgres") {
+        return c.json(
+          {
+            success: false,
+            error: "Schema switching is only supported for PostgreSQL"
+          },
+          400
+        );
+      }
+      await adapter.setSchema(schema);
+      const tables = await adapter.getTables();
+      return c.json({
+        success: true,
+        data: {
+          schema,
+          tableCount: tables.length
+        }
+      });
+    } catch (e) {
+      return c.json({ success: false, error: e.message }, 500);
+    }
+  });
+  api.get("/database/enums", async (c) => {
+    try {
+      const adapter = currentAdapter;
+      if (!adapter) {
+        return c.json({ success: true, data: [] });
+      }
+      const result = await getDatabaseEnums(adapter);
+      if (!result.success) {
+        return c.json({ success: false, error: result.error }, 500);
+      }
+      return c.json({ success: true, data: result.data });
+    } catch (e) {
+      return c.json({ success: false, error: e.message }, 500);
+    }
+  });
   app.route("/api", api);
 }
 var init_api = __esm({
@@ -6435,27 +7743,27 @@ import { serve } from "@hono/node-server";
 import { Hono as Hono2 } from "hono";
 import { serveStatic } from "@hono/node-server/serve-static";
 import open from "open";
-import path16 from "path";
-import pc35 from "picocolors";
-import { fileURLToPath } from "url";
+import path19 from "path";
+import pc38 from "picocolors";
+import { fileURLToPath as fileURLToPath2 } from "url";
 async function runStudio(dbConfig) {
   const app = new Hono2();
   registerApiRoutes(app, dbConfig);
   const isDev = __dirname.includes("src") || __dirname.includes("studio");
-  const studioDistPath = isDev ? path16.resolve(__dirname, "../../dist/studio") : path16.resolve(__dirname, "./studio");
-  const fs16 = await import("fs/promises");
+  const studioDistPath = isDev ? path19.resolve(__dirname, "../../dist/studio") : path19.resolve(__dirname, "./studio");
+  const fs19 = await import("fs/promises");
   app.use("/*", async (c, next) => {
     c.header("Cache-Control", "no-cache, no-store, must-revalidate");
     await next();
   });
   app.use(
     "/*",
-    serveStatic({ root: path16.relative(process.cwd(), studioDistPath) })
+    serveStatic({ root: path19.relative(process.cwd(), studioDistPath) })
   );
   app.get("*", async (c) => {
-    const indexPath = path16.join(studioDistPath, "index.html");
+    const indexPath = path19.join(studioDistPath, "index.html");
     try {
-      const html = await fs16.readFile(indexPath, "utf-8");
+      const html = await fs19.readFile(indexPath, "utf-8");
       return c.html(html);
     } catch (e) {
       return c.text(
@@ -6467,23 +7775,23 @@ async function runStudio(dbConfig) {
   const defaultPort = process.env.PORT ? parseInt(process.env.PORT, 10) : 51213;
   const port = await getAvailablePort(defaultPort);
   console.log(
-    pc35.cyan(`
+    pc38.cyan(`
 Starting Drixio Studio on http://localhost:${port}...`)
   );
   if (dbConfig.type === "unknown") {
     console.log(
-      pc35.yellow(
+      pc38.yellow(
         `\u26A0\uFE0F  No database detected. Studio started in standalone mode.`
       )
     );
     console.log(
-      pc35.dim(
+      pc38.dim(
         `You can create or connect to a database in the SQL Console.
 `
       )
     );
   }
-  console.log(pc35.dim(`Press Ctrl+C to stop the server.
+  console.log(pc38.dim(`Press Ctrl+C to stop the server.
 `));
   serve({
     fetch: app.fetch,
@@ -6512,14 +7820,14 @@ var init_studio = __esm({
   "src/studio/index.ts"() {
     "use strict";
     init_api();
-    __filename = fileURLToPath(import.meta.url);
-    __dirname = path16.dirname(__filename);
+    __filename = fileURLToPath2(import.meta.url);
+    __dirname = path19.dirname(__filename);
   }
 });
 
 // bin/cli.ts
 init_logic();
-import pc36 from "picocolors";
+import pc39 from "picocolors";
 import { parseArgs } from "util";
 
 // src/commands/query.ts
@@ -6603,8 +7911,8 @@ async function runQueryCommand(dbConfig, args) {
   const adapter = createDBAdapter(dbConfig);
   let sql = args[0];
   if (!sql) {
-    const { input: input8 } = await import("@inquirer/prompts");
-    sql = await input8({
+    const { input: input11 } = await import("@inquirer/prompts");
+    sql = await input11({
       message: "Enter your SQL query:"
     });
   }
@@ -6637,8 +7945,8 @@ Query Error: ${e.message}
 // src/commands/export.ts
 init_logic();
 import pc3 from "picocolors";
-import fs5 from "fs/promises";
-import path5 from "path";
+import fs6 from "fs/promises";
+import path6 from "path";
 async function runExportCommand(dbConfig, args, options) {
   if (dbConfig.type === "unknown") {
     console.log(
@@ -6650,7 +7958,7 @@ async function runExportCommand(dbConfig, args, options) {
   let tableName = args[0];
   let format = options.format?.toLowerCase();
   const schemaOnly = options["schema-only"];
-  const { select: select13 } = await import("@inquirer/prompts");
+  const { select: select16 } = await import("@inquirer/prompts");
   if (!tableName) {
     const allTables = await adapter.getTables();
     if (allTables.length === 0) {
@@ -6661,13 +7969,13 @@ async function runExportCommand(dbConfig, args, options) {
       { name: "All Tables (*)", value: "*" },
       ...allTables.map((t) => ({ name: t, value: t }))
     ];
-    tableName = await select13({
+    tableName = await select16({
       message: "Which table do you want to export?",
       choices: tableChoices
     });
   }
   if (!format || !["csv", "json"].includes(format)) {
-    format = await select13({
+    format = await select16({
       message: "Which format do you want to export?",
       choices: [
         { name: "CSV", value: "csv" },
@@ -6675,8 +7983,8 @@ async function runExportCommand(dbConfig, args, options) {
       ]
     });
   }
-  const exportDir = path5.join(process.cwd(), "drixio_exports");
-  await fs5.mkdir(exportDir, { recursive: true });
+  const exportDir = path6.join(process.cwd(), "drixio_exports");
+  await fs6.mkdir(exportDir, { recursive: true });
   const tablesToExport = tableName === "*" ? await adapter.getTables() : [tableName];
   console.log(pc3.cyan(`
 Starting export to ${exportDir}...`));
@@ -6695,8 +8003,8 @@ Starting export to ${exportDir}...`));
       const content = exportRes.data;
       const suffix = schemaOnly ? "_schema" : "_data";
       const ext = format === "json" ? ".json" : ".csv";
-      const fp = path5.join(exportDir, `${table}${suffix}${ext}`);
-      await fs5.writeFile(fp, content, "utf-8");
+      const fp = path6.join(exportDir, `${table}${suffix}${ext}`);
+      await fs6.writeFile(fp, content, "utf-8");
       const typeLabel = schemaOnly ? "Schema" : "Data";
       console.log(
         pc3.green(
@@ -6715,8 +8023,8 @@ Starting export to ${exportDir}...`));
 // src/commands/import.ts
 init_logic();
 import pc4 from "picocolors";
-import fs6 from "fs/promises";
-import path6 from "path";
+import fs7 from "fs/promises";
+import path7 from "path";
 async function runImportCommand(dbConfig, args, options) {
   if (dbConfig.type === "unknown") {
     console.log(
@@ -6727,15 +8035,15 @@ async function runImportCommand(dbConfig, args, options) {
   const adapter = createDBAdapter(dbConfig);
   let filePath = args[0];
   let tableName = options.table;
-  const { input: input8, select: select13 } = await import("@inquirer/prompts");
+  const { input: input11, select: select16 } = await import("@inquirer/prompts");
   if (!filePath) {
-    filePath = await input8({
+    filePath = await input11({
       message: "Enter the path to your CSV or JSON file:"
     });
   }
-  const resolvedPath = path6.resolve(process.cwd(), filePath);
+  const resolvedPath = path7.resolve(process.cwd(), filePath);
   try {
-    await fs6.access(resolvedPath);
+    await fs7.access(resolvedPath);
   } catch {
     console.log(pc4.red(`Error: File not found at ${resolvedPath}`));
     process.exit(1);
@@ -6748,14 +8056,14 @@ async function runImportCommand(dbConfig, args, options) {
       );
       process.exit(1);
     }
-    tableName = await select13({
+    tableName = await select16({
       message: "Which table do you want to import data into?",
       choices: allTables.map((t) => ({ name: t, value: t }))
     });
   }
   console.log(pc4.cyan(`
 Reading file...`));
-  const fileContent = await fs6.readFile(resolvedPath, "utf-8");
+  const fileContent = await fs7.readFile(resolvedPath, "utf-8");
   const isJson = filePath.toLowerCase().endsWith(".json");
   const isCsv = filePath.toLowerCase().endsWith(".csv");
   if (!isJson && !isCsv) {
@@ -6808,7 +8116,7 @@ async function runSeedCommand(dbConfig, args) {
   const adapter = createDBAdapter(dbConfig);
   let tableName = args[0];
   let countStr = args[1];
-  const { input: input8, select: select13 } = await import("@inquirer/prompts");
+  const { input: input11, select: select16 } = await import("@inquirer/prompts");
   if (!tableName) {
     const allTables = await adapter.getTables();
     if (allTables.length === 0) {
@@ -6817,14 +8125,14 @@ async function runSeedCommand(dbConfig, args) {
       );
       process.exit(1);
     }
-    tableName = await select13({
+    tableName = await select16({
       message: "Which table do you want to seed with realistic fake data?",
       choices: allTables.map((t) => ({ name: t, value: t }))
     });
   }
   let count = parseInt(countStr);
   if (isNaN(count) || count <= 0) {
-    const res = await input8({
+    const res = await input11({
       message: "How many rows to generate?",
       default: "50"
     });
@@ -6883,19 +8191,19 @@ async function runTruncateCommand(dbConfig, args) {
   }
   const adapter = createDBAdapter(dbConfig);
   let tableName = args[0];
-  const { select: select13, confirm: confirm6 } = await import("@inquirer/prompts");
+  const { select: select16, confirm: confirm8 } = await import("@inquirer/prompts");
   if (!tableName) {
     const allTables = await adapter.getTables();
     if (allTables.length === 0) {
       console.log(pc6.yellow("No tables found in the database."));
       process.exit(0);
     }
-    tableName = await select13({
+    tableName = await select16({
       message: "Which table do you want to truncate (empty all data)?",
       choices: allTables.map((t) => ({ name: t, value: t }))
     });
   }
-  const sure = await confirm6({
+  const sure = await confirm8({
     message: `Are you sure you want to TRUNCATE '${tableName}'? This will delete all rows and cannot be undone!`,
     default: false
   });
@@ -6921,8 +8229,8 @@ async function runTruncateCommand(dbConfig, args) {
 // src/commands/exec.ts
 init_logic();
 import pc7 from "picocolors";
-import fs7 from "fs/promises";
-import path7 from "path";
+import fs8 from "fs/promises";
+import path8 from "path";
 async function runExecCommand(dbConfig, args) {
   if (dbConfig.type === "unknown") {
     console.log(
@@ -6931,18 +8239,18 @@ async function runExecCommand(dbConfig, args) {
     process.exit(1);
   }
   let filePath = args[0];
-  const { input: input8 } = await import("@inquirer/prompts");
+  const { input: input11 } = await import("@inquirer/prompts");
   if (!filePath) {
-    filePath = await input8({ message: "Enter the path to your .sql file:" });
+    filePath = await input11({ message: "Enter the path to your .sql file:" });
   }
-  const resolvedPath = path7.resolve(process.cwd(), filePath);
+  const resolvedPath = path8.resolve(process.cwd(), filePath);
   try {
-    await fs7.access(resolvedPath);
+    await fs8.access(resolvedPath);
   } catch {
     console.log(pc7.red(`Error: File not found at ${resolvedPath}`));
     process.exit(1);
   }
-  const sqlContent = await fs7.readFile(resolvedPath, "utf-8");
+  const sqlContent = await fs8.readFile(resolvedPath, "utf-8");
   if (!sqlContent.trim()) {
     console.log(pc7.yellow("File is empty."));
     process.exit(0);
@@ -7021,8 +8329,8 @@ Backup Error: ${e.message}
 // src/commands/restore.ts
 init_logic();
 import pc9 from "picocolors";
-import fs8 from "fs/promises";
-import path8 from "path";
+import fs9 from "fs/promises";
+import path9 from "path";
 async function runRestoreCommand(dbConfig, args, options = {}) {
   if (dbConfig.type === "unknown") {
     console.log(
@@ -7031,49 +8339,33 @@ async function runRestoreCommand(dbConfig, args, options = {}) {
     process.exit(1);
   }
   let targetPath = args[0];
-  const { input: input8, select: select13, confirm: confirm6 } = await import("@inquirer/prompts");
+  const { input: input11, select: select16, confirm: confirm8 } = await import("@inquirer/prompts");
   if (!targetPath) {
     try {
-      const entries = await fs8.readdir(process.cwd(), {
-        withFileTypes: true
-      });
-      const candidates = [];
-      for (const entry of entries) {
-        if (entry.isDirectory() && entry.name.startsWith("drixio_backup_")) {
-          candidates.push({
-            name: `\u{1F4C1} ${entry.name} (Backup Directory)`,
-            value: entry.name
-          });
-        } else if (entry.isFile() && (entry.name.endsWith(".sql") || entry.name.endsWith(".json"))) {
-          candidates.push({
-            name: `\u{1F4C4} ${entry.name} (${entry.name.endsWith(".sql") ? "SQL Script" : "JSON Dump"})`,
-            value: entry.name
-          });
-        }
-      }
+      const candidates = await getRestoreCandidates(process.cwd());
       if (candidates.length > 0) {
         candidates.push({
           name: "\u270F\uFE0F  Enter a custom path manually...",
           value: "__custom__"
         });
-        const choice = await select13({
+        const choice = await select16({
           message: "Select a backup directory or file to restore:",
           choices: candidates
         });
         if (choice === "__custom__") {
-          targetPath = await input8({
+          targetPath = await input11({
             message: "Enter path to backup directory, .sql, or .json file:"
           });
         } else {
           targetPath = choice;
         }
       } else {
-        targetPath = await input8({
+        targetPath = await input11({
           message: "Enter path to backup directory, .sql, or .json file:"
         });
       }
     } catch {
-      targetPath = await input8({
+      targetPath = await input11({
         message: "Enter path to backup directory, .sql, or .json file:"
       });
     }
@@ -7082,9 +8374,9 @@ async function runRestoreCommand(dbConfig, args, options = {}) {
     console.log(pc9.yellow("No restore source specified. Aborting."));
     process.exit(0);
   }
-  const resolvedPath = path8.resolve(process.cwd(), targetPath.trim());
+  const resolvedPath = path9.resolve(process.cwd(), targetPath.trim());
   try {
-    await fs8.access(resolvedPath);
+    await fs9.access(resolvedPath);
   } catch {
     console.log(pc9.red(`Error: Backup path not found: ${resolvedPath}`));
     process.exit(1);
@@ -7100,7 +8392,7 @@ async function runRestoreCommand(dbConfig, args, options = {}) {
     console.log(pc9.dim(`Database: ${dbConfig.type} (${dbConfig.targetUrl})`));
     console.log(pc9.dim(`Source:   ${resolvedPath}
 `));
-    const proceed = await confirm6({
+    const proceed = await confirm8({
       message: "Are you sure you want to proceed with the database restore?",
       default: false
     });
@@ -7147,8 +8439,8 @@ Starting database restore from: ${resolvedPath}...`));
 // src/commands/diagram.ts
 init_logic();
 import pc10 from "picocolors";
-import fs9 from "fs/promises";
-import path9 from "path";
+import fs10 from "fs/promises";
+import path10 from "path";
 async function runDiagramCommand(dbConfig) {
   if (dbConfig.type === "unknown") {
     console.log(
@@ -7186,8 +8478,8 @@ You can paste this Mermaid code directly into [Draw.io](https://app.diagrams.net
 ${mermaidCode}
 \`\`\`
 `;
-    const outPath = path9.resolve(process.cwd(), "drixio_schema.md");
-    await fs9.writeFile(outPath, markdownOutput.trim(), "utf-8");
+    const outPath = path10.resolve(process.cwd(), "drixio_schema.md");
+    await fs10.writeFile(outPath, markdownOutput.trim(), "utf-8");
     console.log(pc10.green(`
 \u2714 Diagram generated successfully!`));
     console.log(pc10.white(`Output saved to: ${pc10.bold(outPath)}`));
@@ -7208,8 +8500,8 @@ ${mermaidCode}
 // src/commands/generateTypes.ts
 init_logic();
 import pc11 from "picocolors";
-import fs10 from "fs/promises";
-import path10 from "path";
+import fs11 from "fs/promises";
+import path11 from "path";
 async function runGenerateTypesCommand(dbConfig) {
   if (dbConfig.type === "unknown") {
     console.log(
@@ -7233,8 +8525,8 @@ Scanning database to generate TypeScript interfaces...`)
       process.exit(0);
     }
     const tsCode = generateTypeScriptDefinitions(tableInfos, dbConfig.type);
-    const outPath = path10.resolve(process.cwd(), "drixio-types.d.ts");
-    await fs10.writeFile(outPath, tsCode, "utf-8");
+    const outPath = path11.resolve(process.cwd(), "drixio-types.d.ts");
+    await fs11.writeFile(outPath, tsCode, "utf-8");
     console.log(pc11.green(`\u2714 TypeScript interfaces generated successfully!`));
     console.log(pc11.white(`Output saved to: ${pc11.bold(outPath)}`));
   } catch (e) {
@@ -7249,8 +8541,8 @@ Scanning database to generate TypeScript interfaces...`)
 // src/commands/generateOrm.ts
 init_logic();
 import pc12 from "picocolors";
-import fs11 from "fs/promises";
-import path11 from "path";
+import fs12 from "fs/promises";
+import path12 from "path";
 async function runGenerateOrmCommand(dbConfig, options = {}) {
   if (dbConfig.type === "unknown") {
     console.log(
@@ -7306,11 +8598,11 @@ Scanning database to generate ${target === "prisma" ? "Prisma" : "Drizzle"} sche
     if (options.print) {
       console.log("\n" + generatedCode);
     } else {
-      const outPath = path11.resolve(
+      const outPath = path12.resolve(
         process.cwd(),
         options.out || defaultFileName
       );
-      await fs11.writeFile(outPath, generatedCode, "utf-8");
+      await fs12.writeFile(outPath, generatedCode, "utf-8");
       console.log(
         pc12.green(
           `\u2714 ${target === "prisma" ? "Prisma" : "Drizzle"} schema generated successfully!`
@@ -7331,10 +8623,10 @@ Scanning database to generate ${target === "prisma" ? "Prisma" : "Drizzle"} sche
 init_logic();
 import pc13 from "picocolors";
 async function runInitCommand(args) {
-  const { select: select13, input: input8, password } = await import("@inquirer/prompts");
+  const { select: select16, input: input11, password } = await import("@inquirer/prompts");
   let dialect = args[0];
   if (!dialect || !["sqlite", "mysql", "postgres"].includes(dialect.toLowerCase())) {
-    dialect = await select13({
+    dialect = await select16({
       message: "Which database do you want to initialize locally?",
       choices: [
         { name: "SQLite (Local File)", value: "sqlite" },
@@ -7380,15 +8672,15 @@ Initializing a local ${dialect} database...`));
         "Please provide credentials for your local server (e.g. running via XAMPP, Homebrew, etc.)"
       )
     );
-    const host = await input8({
+    const host = await input11({
       message: "Server Host:",
       default: "localhost"
     });
-    const port = await input8({
+    const port = await input11({
       message: "Server Port:",
       default: dialect === "mysql" ? "3306" : "5432"
     });
-    const user = await input8({
+    const user = await input11({
       message: "Username:",
       default: dialect === "mysql" ? "root" : "postgres"
     });
@@ -7397,7 +8689,7 @@ Initializing a local ${dialect} database...`));
     });
     let dbName = args[1];
     if (!dbName) {
-      dbName = await input8({
+      dbName = await input11({
         message: "New Database Name (e.g. my_project):"
       });
     }
@@ -7489,10 +8781,10 @@ Could not connect to the local ${dialect} server on ${host}:${port}.`
 init_logic();
 import pc14 from "picocolors";
 async function runDropDbCommand(args) {
-  const { select: select13, input: input8, password, confirm: confirm6 } = await import("@inquirer/prompts");
+  const { select: select16, input: input11, password, confirm: confirm8 } = await import("@inquirer/prompts");
   let dialect = args[0];
   if (!dialect || !["sqlite", "mysql", "postgres"].includes(dialect.toLowerCase())) {
-    dialect = await select13({
+    dialect = await select16({
       message: "Which database type do you want to drop?",
       choices: [
         { name: "SQLite (Local File)", value: "sqlite" },
@@ -7505,12 +8797,12 @@ async function runDropDbCommand(args) {
   let dbName = args[1];
   if (dialect === "sqlite") {
     if (!dbName) {
-      dbName = await input8({
+      dbName = await input11({
         message: "Enter the SQLite filename to delete (e.g. database.sqlite):",
         default: "database.sqlite"
       });
     }
-    const sure = await confirm6({
+    const sure = await confirm8({
       message: `Are you absolutely sure you want to delete ${dbName}? This cannot be undone!`,
       default: false
     });
@@ -7535,15 +8827,15 @@ async function runDropDbCommand(args) {
         `Please provide credentials for your local ${dialect} server to drop a database.`
       )
     );
-    const host = await input8({
+    const host = await input11({
       message: "Server Host:",
       default: "localhost"
     });
-    const port = await input8({
+    const port = await input11({
       message: "Server Port:",
       default: dialect === "mysql" ? "3306" : "5432"
     });
-    const user = await input8({
+    const user = await input11({
       message: "Username:",
       default: dialect === "mysql" ? "root" : "postgres"
     });
@@ -7551,11 +8843,11 @@ async function runDropDbCommand(args) {
       message: "Password (leave empty if none):"
     });
     if (!dbName) {
-      dbName = await input8({
+      dbName = await input11({
         message: "Which Database Name do you want to DROP?"
       });
     }
-    const sure = await confirm6({
+    const sure = await confirm8({
       message: `Are you absolutely sure you want to DROP DATABASE '${dbName}' from ${host}? All data will be lost!`,
       default: false
     });
@@ -7676,8 +8968,8 @@ async function runDescribeCommand(dbConfig, args, options = {}) {
       if (tables.length === 1) {
         tableName = tables[0];
       } else {
-        const { select: select13 } = await import("@inquirer/prompts");
-        tableName = await select13({
+        const { select: select16 } = await import("@inquirer/prompts");
+        tableName = await select16({
           message: "Select a table to describe:",
           choices: tables.map((t) => ({ name: t, value: t }))
         });
@@ -7766,9 +9058,9 @@ Failed to describe table: ${e.message}
 // src/commands/diff.ts
 init_logic();
 import pc17 from "picocolors";
-import fs12 from "fs/promises";
+import fs13 from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import path12 from "path";
+import path13 from "path";
 async function runDiffCommand(dbConfig, args, options = {}) {
   if (dbConfig.type === "unknown") {
     console.log(
@@ -7789,7 +9081,7 @@ Capturing schema snapshot for ${dbConfig.type.toUpperCase()} database...`
       const snapshotRes = await createSchemaSnapshot(
         adapter,
         dbConfig.type,
-        path12.basename(outPath, ".json")
+        path13.basename(outPath, ".json")
       );
       if (!snapshotRes.success) {
         console.log(
@@ -7797,9 +9089,9 @@ Capturing schema snapshot for ${dbConfig.type.toUpperCase()} database...`
         );
         process.exit(1);
       }
-      const resolvedPath = path12.resolve(process.cwd(), outPath);
-      await fs12.mkdir(path12.dirname(resolvedPath), { recursive: true });
-      await fs12.writeFile(
+      const resolvedPath = path13.resolve(process.cwd(), outPath);
+      await fs13.mkdir(path13.dirname(resolvedPath), { recursive: true });
+      await fs13.writeFile(
         resolvedPath,
         JSON.stringify(snapshotRes.data, null, 2),
         "utf-8"
@@ -7816,9 +9108,9 @@ Capturing schema snapshot for ${dbConfig.type.toUpperCase()} database...`
     }
     let targetArg = args[0];
     if (!targetArg) {
-      if (existsSync2(path12.resolve(process.cwd(), "schema.json"))) {
+      if (existsSync2(path13.resolve(process.cwd(), "schema.json"))) {
         targetArg = "schema.json";
-      } else if (existsSync2(path12.resolve(process.cwd(), ".drixio/schema.json"))) {
+      } else if (existsSync2(path13.resolve(process.cwd(), ".drixio/schema.json"))) {
         targetArg = ".drixio/schema.json";
       } else {
         console.log(
@@ -7845,7 +9137,7 @@ Usage examples:`));
       }
     }
     let diffResult;
-    const isRemoteUrl = targetArg.startsWith("postgres://") || targetArg.startsWith("postgresql://") || targetArg.startsWith("mysql://") || targetArg.startsWith("file:");
+    const isRemoteUrl = isConnectionString(targetArg) || targetArg.startsWith("file:");
     if (isRemoteUrl) {
       console.log(
         pc17.cyan(
@@ -7873,7 +9165,7 @@ Connecting to target database and computing schema diff...`
         });
       }
     } else {
-      const filePath = path12.resolve(process.cwd(), targetArg);
+      const filePath = path13.resolve(process.cwd(), targetArg);
       if (!existsSync2(filePath)) {
         console.log(
           pc17.red(`\u2718 Target snapshot file not found: ${targetArg}`)
@@ -7886,7 +9178,7 @@ Connecting to target database and computing schema diff...`
 Comparing current database with snapshot: ${targetArg}...`
         )
       );
-      const content = await fs12.readFile(filePath, "utf-8");
+      const content = await fs13.readFile(filePath, "utf-8");
       let snapshot;
       try {
         snapshot = JSON.parse(content);
@@ -7901,7 +9193,7 @@ Comparing current database with snapshot: ${targetArg}...`
         snapshot,
         dbConfig.type,
         "Current Database",
-        `Snapshot (${path12.basename(targetArg)})`
+        `Snapshot (${path13.basename(targetArg)})`
       );
       if (!diffRes.success) {
         console.log(pc17.red(`\u2718 Diff failed: ${diffRes.error}`));
@@ -7916,9 +9208,9 @@ Comparing current database with snapshot: ${targetArg}...`
     printDiffReport(diffResult, options.reverse);
     const targetSql = options.reverse ? diffResult.rollbackSql : diffResult.migrationSql;
     if (options.out) {
-      const outResolved = path12.resolve(process.cwd(), options.out);
-      await fs12.mkdir(path12.dirname(outResolved), { recursive: true });
-      await fs12.writeFile(outResolved, targetSql, "utf-8");
+      const outResolved = path13.resolve(process.cwd(), options.out);
+      await fs13.mkdir(path13.dirname(outResolved), { recursive: true });
+      await fs13.writeFile(outResolved, targetSql, "utf-8");
       console.log(
         pc17.green(`\u2714 Migration SQL written to: ${pc17.bold(options.out)}`)
       );
@@ -7934,8 +9226,8 @@ Nothing to apply. Schema is already in sync.`)
       const skipConfirm = options.force || options.y;
       let proceed = skipConfirm;
       if (!proceed) {
-        const { confirm: confirm6 } = await import("@inquirer/prompts");
-        proceed = await confirm6({
+        const { confirm: confirm8 } = await import("@inquirer/prompts");
+        proceed = await confirm8({
           message: `Apply this ${options.reverse ? "rollback" : "migration"} to "${dbConfig.type.toUpperCase()}" database?`,
           default: false
         });
@@ -8107,8 +9399,8 @@ async function runRunCommand(dbConfig, args, _options) {
   const targetIdent = args[0];
   const paramArgs = args.slice(1);
   if (!targetIdent) {
-    const { select: select13 } = await import("@inquirer/prompts");
-    const selectedId = await select13({
+    const { select: select16 } = await import("@inquirer/prompts");
+    const selectedId = await select16({
       message: "Select a saved query template to run:",
       choices: snippets.map((s) => ({
         name: `${s.title} ${pc18.dim(`(${s.id})`)}`,
@@ -8145,10 +9437,10 @@ async function runRunCommand(dbConfig, args, _options) {
     }
   }
   if (requiredParams.length > 0) {
-    const { input: input8 } = await import("@inquirer/prompts");
+    const { input: input11 } = await import("@inquirer/prompts");
     for (const param of requiredParams) {
       if (providedParams[param] === void 0) {
-        const val = await input8({
+        const val = await input11({
           message: `Enter value for :${param}:`,
           validate: (v) => v.trim() !== "" ? true : `:${param} cannot be empty`
         });
@@ -8270,7 +9562,7 @@ async function runQuickCommand(command, args, options, dbConfig) {
 // src/tui/index.ts
 init_logo();
 init_logic();
-import pc34 from "picocolors";
+import pc37 from "picocolors";
 
 // src/tui/views/editor.ts
 init_logic();
@@ -8302,8 +9594,8 @@ var selectTable = async (tableChoices) => await select({
 init_logic();
 import { input, select as select2 } from "@inquirer/prompts";
 import pc21 from "picocolors";
-import fs13 from "fs/promises";
-import path13 from "path";
+import fs14 from "fs/promises";
+import path14 from "path";
 async function runBeginnerAdd(adapter, dbType, tableName, columns) {
   console.log(pc21.cyan(`
 --- Add Data to [${tableName}] ---`));
@@ -8423,10 +9715,10 @@ async function runExpertMode(adapter) {
       message: "Enter the path to your .md or .sql file:"
     });
     if (filePath && filePath.trim()) {
-      const absolutePath = path13.resolve(process.cwd(), filePath.trim());
+      const absolutePath = path14.resolve(process.cwd(), filePath.trim());
       let fileContent = "";
       try {
-        fileContent = await fs13.readFile(absolutePath, "utf-8");
+        fileContent = await fs14.readFile(absolutePath, "utf-8");
       } catch (err2) {
         console.log(pc21.red(`
 x Failed to read file: ${err2.message}`));
@@ -8543,8 +9835,8 @@ async function viewTables(dbConfig) {
 Error fetching data: ${e.message}
 `));
           currentWhere = "";
-          const { input: input8 } = await import("@inquirer/prompts");
-          await input8({ message: "Click Enter to continue..." });
+          const { input: input11 } = await import("@inquirer/prompts");
+          await input11({ message: "Click Enter to continue..." });
           continue;
         }
         const rows = data.rows;
@@ -8613,8 +9905,8 @@ Error fetching data: ${e.message}
           continue;
         }
         if (action === "search") {
-          const { input: input8 } = await import("@inquirer/prompts");
-          const searchInput = await input8({
+          const { input: input11 } = await import("@inquirer/prompts");
+          const searchInput = await input11({
             message: "Enter Search (e.g. `age > 18` or `John` for fuzzy search):"
           });
           currentWhere = buildSearchWhereClause(
@@ -8638,18 +9930,18 @@ Error fetching data: ${e.message}
               console.log(pc22.red(`
 Export Error: ${exportRes.error}`));
             } else {
-              const fs16 = await import("fs/promises");
-              const path17 = await import("path");
-              const exportDir = path17.join(
+              const fs19 = await import("fs/promises");
+              const path20 = await import("path");
+              const exportDir = path20.join(
                 process.cwd(),
                 "drixio_exports"
               );
-              await fs16.mkdir(exportDir, { recursive: true });
-              const fp = path17.join(
+              await fs19.mkdir(exportDir, { recursive: true });
+              const fp = path20.join(
                 exportDir,
                 `${selectedTable}.${format}`
               );
-              await fs16.writeFile(fp, exportRes.data, "utf-8");
+              await fs19.writeFile(fp, exportRes.data, "utf-8");
               console.log(pc22.green(`
 \u2714 Exported to ${fp}`));
             }
@@ -8657,8 +9949,8 @@ Export Error: ${exportRes.error}`));
             console.log(pc22.red(`
 Export Error: ${e.message}`));
           }
-          const { input: input8 } = await import("@inquirer/prompts");
-          await input8({ message: "Click Enter to continue..." });
+          const { input: input11 } = await import("@inquirer/prompts");
+          await input11({ message: "Click Enter to continue..." });
           continue;
         }
         const mode = await select3({
@@ -8720,8 +10012,8 @@ x Error: ${error.message}`));
   await adapter.close();
 }
 async function waitForEnter() {
-  const { input: input8 } = await import("@inquirer/prompts");
-  await input8({
+  const { input: input11 } = await import("@inquirer/prompts");
+  await input11({
     message: "Press Enter to continue..."
   });
 }
@@ -8837,6 +10129,24 @@ var selectAction = async (dbConfig) => await select5({
       description: "Create new tables, or modify/drop existing tables.",
       disabled: dbConfig.type === "unknown"
     },
+    {
+      name: "\u26A1 ORM & Type Generator",
+      value: "orm",
+      description: "Generate Prisma Schema, Drizzle models, or TypeScript definitions.",
+      disabled: dbConfig.type === "unknown"
+    },
+    {
+      name: "\u{1F4D1} SQL Snippets & Templates",
+      value: "snippets",
+      description: "Run parameterized diagnostic queries and high-frequency templates.",
+      disabled: dbConfig.type === "unknown"
+    },
+    {
+      name: "\u{1F504} Schema Diff & Migrations",
+      value: "diff",
+      description: "Compare database schemas with snapshots and generate migration SQL.",
+      disabled: dbConfig.type === "unknown"
+    },
     new Separator2(),
     {
       name: dbConfig.type === "unknown" ? " Setup Connection" : " Connection Settings",
@@ -8858,7 +10168,7 @@ async function runRepl(dbConfig) {
   if (dbConfig.type === "unknown") return;
   const dbAdapter = createDBAdapter(dbConfig);
   let running = true;
-  const { input: input8 } = await import("@inquirer/prompts");
+  const { input: input11 } = await import("@inquirer/prompts");
   console.clear();
   console.log(
     pc25.cyan(
@@ -8889,7 +10199,7 @@ async function runRepl(dbConfig) {
   );
   while (running) {
     try {
-      const queryStr = await input8({
+      const queryStr = await input11({
         message: pc25.green(`${dbConfig.type}>`)
       });
       const sql = queryStr.trim();
@@ -8935,7 +10245,7 @@ async function runTui(initialConfig, customUrl) {
       case "editor":
         if (dbConfig.type === "unknown") {
           console.log(
-            pc34.yellow(
+            pc37.yellow(
               `
 No database connection found. Please setup database first.`
             )
@@ -8952,6 +10262,24 @@ No database connection found. Please setup database first.`
       case "repl":
         await runRepl(dbConfig);
         break;
+      case "orm": {
+        const { runOrmWizard: runOrmWizard2 } = await Promise.resolve().then(() => (init_ormWizard(), ormWizard_exports));
+        await runOrmWizard2(dbConfig);
+        await waitForEnter4();
+        break;
+      }
+      case "snippets": {
+        const { runSnippetsWizard: runSnippetsWizard2 } = await Promise.resolve().then(() => (init_snippetsWizard(), snippetsWizard_exports));
+        await runSnippetsWizard2(dbConfig);
+        await waitForEnter4();
+        break;
+      }
+      case "diff": {
+        const { runDiffWizard: runDiffWizard2 } = await Promise.resolve().then(() => (init_diffWizard(), diffWizard_exports));
+        await runDiffWizard2(dbConfig);
+        await waitForEnter4();
+        break;
+      }
       case "setup":
       case "re-configure":
         dbConfig = await runSetup(dbConfig);
@@ -8959,32 +10287,19 @@ No database connection found. Please setup database first.`
         break;
       case "exit":
         running = false;
-        console.log(pc34.dim("\nThanks for using Drixio. Goodbye!"));
+        console.log(pc37.dim("\nThanks for using Drixio. Goodbye!"));
         break;
     }
   }
   async function waitForEnter4() {
-    const { input: input8 } = await import("@inquirer/prompts");
-    await input8({
+    const { input: input11 } = await import("@inquirer/prompts");
+    await input11({
       message: "Click Enter to continue..."
     });
   }
 }
 
 // bin/cli.ts
-import { readFileSync } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname, join } from "path";
-function getVersion() {
-  try {
-    const __dirname2 = dirname(fileURLToPath2(import.meta.url));
-    const pkgPath = join(__dirname2, "../package.json");
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-    return pkg.version || "1.1.9";
-  } catch {
-    return "1.1.9";
-  }
-}
 async function main() {
   const args = process.argv.slice(2);
   let customUrl;
@@ -9012,80 +10327,80 @@ async function main() {
     allowPositionals: true
   });
   if (values.version) {
-    console.log(`drixio v${getVersion()}`);
+    console.log(`drixio v${getDrixioVersion()}`);
     process.exit(0);
   }
   if (values.help) {
-    console.log(pc36.cyan(`
+    console.log(pc39.cyan(`
 Drixio - Modern Database Manager
 `));
-    console.log(`${pc36.bold("Usage:")} npx drixio [command] [options]
+    console.log(`${pc39.bold("Usage:")} npx drixio [command] [options]
 `);
-    console.log(`${pc36.bold("Tiers & Interfaces:")}`);
+    console.log(`${pc39.bold("Tiers & Interfaces:")}`);
     console.log(
-      `  Interactive TUI:      ${pc36.green("npx drixio")} (Terminal UI with beginner wizards)`
+      `  Interactive TUI:      ${pc39.green("npx drixio")} (Terminal UI with beginner wizards)`
     );
     console.log(
-      `  Web Studio:           ${pc36.green("npx drixio studio")} (Browser UI for bulk inspection)`
+      `  Web Studio:           ${pc39.green("npx drixio studio")} (Browser UI for bulk inspection)`
     );
     console.log(`
-${pc36.bold("Quick Commands (Headless / Pro):")}`);
+${pc39.bold("Quick Commands (Headless / Pro):")}`);
     console.log(
-      `  ${pc36.green("tables")}                 List all database tables and row counts (alias: ls)`
+      `  ${pc39.green("tables")}                 List all database tables and row counts (alias: ls)`
     );
     console.log(
-      `  ${pc36.green("describe")} [table]       Inspect columns, types, PKs, and indexes (alias: desc)`
+      `  ${pc39.green("describe")} [table]       Inspect columns, types, PKs, and indexes (alias: desc)`
     );
     console.log(
-      `  ${pc36.green("query")} "<sql>"         Run a quick SQL query`
+      `  ${pc39.green("query")} "<sql>"         Run a quick SQL query`
     );
     console.log(
-      `  ${pc36.green("exec")} <file.sql>       Execute a SQL script file`
+      `  ${pc39.green("exec")} <file.sql>       Execute a SQL script file`
     );
     console.log(
-      `  ${pc36.green("export")} [table]        Export table(s) to CSV/JSON`
+      `  ${pc39.green("export")} [table]        Export table(s) to CSV/JSON`
     );
     console.log(
-      `  ${pc36.green("import")} [file]         Import JSON/CSV into a table`
+      `  ${pc39.green("import")} [file]         Import JSON/CSV into a table`
     );
     console.log(
-      `  ${pc36.green("seed")} [table] [count]  Generate realistic fake data for a table`
+      `  ${pc39.green("seed")} [table] [count]  Generate realistic fake data for a table`
     );
     console.log(
-      `  ${pc36.green("truncate")} [table]      Empty all data in a table and reset sequence`
+      `  ${pc39.green("truncate")} [table]      Empty all data in a table and reset sequence`
     );
     console.log(
-      `  ${pc36.green("diagram")}               Generate a Mermaid ER diagram`
+      `  ${pc39.green("diagram")}               Generate a Mermaid ER diagram`
     );
     console.log(
-      `  ${pc36.green("generate-types")}        Generate TypeScript interfaces`
+      `  ${pc39.green("generate-types")}        Generate TypeScript interfaces`
     );
     console.log(
-      `  ${pc36.green("generate-orm")} [target] Generate Prisma or Drizzle ORM schema`
+      `  ${pc39.green("generate-orm")} [target] Generate Prisma or Drizzle ORM schema`
     );
     console.log(
-      `  ${pc36.green("diff")} [target]         Compare schemas & generate migration SQL`
+      `  ${pc39.green("diff")} [target]         Compare schemas & generate migration SQL`
     );
     console.log(
-      `  ${pc36.green("snippets")}              List saved SQL snippets & templates (alias: snip)`
+      `  ${pc39.green("snippets")}              List saved SQL snippets & templates (alias: snip)`
     );
     console.log(
-      `  ${pc36.green("run")} [snippet]         Execute a saved snippet or parametric query`
+      `  ${pc39.green("run")} [snippet]         Execute a saved snippet or parametric query`
     );
     console.log(
-      `  ${pc36.green("backup")}                Backup the entire database`
+      `  ${pc39.green("backup")}                Backup the entire database`
     );
     console.log(
-      `  ${pc36.green("restore")} [dir|file]    Restore database from a backup directory or .sql file`
+      `  ${pc39.green("restore")} [dir|file]    Restore database from a backup directory or .sql file`
     );
     console.log(
-      `  ${pc36.green("init")} [db_type]        Initialize a local database & .env`
+      `  ${pc39.green("init")} [db_type]        Initialize a local database & .env`
     );
     console.log(
-      `  ${pc36.green("drop-db")} [db_type]     Drop a local database`
+      `  ${pc39.green("drop-db")} [db_type]     Drop a local database`
     );
     console.log(`
-${pc36.bold("Options:")}`);
+${pc39.bold("Options:")}`);
     console.log(`  -v, --version         Show drixio version`);
     console.log(`  --help                Show this help message`);
     console.log(`  --json                Output results as JSON`);