bun-query-builder 0.1.63 → 0.2.2

package/dist/bin/cli.js

@@ -11641,9 +11641,18 @@ var init_dist = __esm(() => {
 });
 
 // src/config.ts
+import process19 from "process";
 function isMysqlLike(dialect = config5.dialect) {
   return dialect === "mysql" || dialect === "singlestore";
 }
+function resolveDialect(explicit) {
+  if (explicit)
+    return explicit;
+  const fromEnv = process19.env.DB_DIALECT || process19.env.DB_CONNECTION;
+  if (fromEnv)
+    return fromEnv;
+  return config5.dialect || "postgres";
+}
 function getPlaceholder(index) {
   if (config5.dialect === "postgres") {
     return `$${index}`;
@@ -11802,7 +11811,7 @@ var {SQL } = globalThis.Bun;
 import { Database } from "bun:sqlite";
 import { mkdirSync as mkdirSync5 } from "fs";
 import { dirname as dirname5 } from "path";
-import process19 from "process";
+import process21 from "process";
 
 class SQLiteWrapper {
   db;
@@ -12080,9 +12089,13 @@ function sqliteFileFromUrl(url) {
   const path = stripped.startsWith("///") ? stripped.slice(2) : stripped.startsWith("//") ? stripped.slice(2) : stripped;
   return path || ":memory:";
 }
+function resolveDatabaseName(dbConfig = config5.database) {
+  const raw = process21.env.DB_DATABASE || dbConfig?.database || "";
+  return String(raw).replace(/^['"]|['"]$/g, "");
+}
 function createConnectionString(dialect, dbConfig) {
-  if ((dialect === "postgres" || dialect === "mysql" || dialect === "singlestore") && process19.env.DB_CONNECTION === dialect) {
-    const e = process19.env;
+  if ((dialect === "postgres" || dialect === "mysql" || dialect === "singlestore") && process21.env.DB_CONNECTION === dialect) {
+    const e = process21.env;
     const envDb = (e.DB_DATABASE || dbConfig.database || "").replace(/^['"]|['"]$/g, "");
     const envUser = e.DB_USERNAME || dbConfig.username;
     const envPass = e.DB_PASSWORD ?? dbConfig.password ?? "";
@@ -12096,7 +12109,7 @@ function createConnectionString(dialect, dbConfig) {
     return dialect === "sqlite" ? sqliteFileFromUrl(dbConfig.url) : dbConfig.url;
   }
   const { database, username, password, host = "localhost", port, ssl } = dbConfig;
-  const sslQ = ssl || process19.env.DB_SSL === "true" || process19.env.DB_SSL === "1" ? "?ssl=true" : "";
+  const sslQ = ssl || process21.env.DB_SSL === "true" || process21.env.DB_SSL === "1" ? "?ssl=true" : "";
   switch (dialect) {
     case "postgres":
       return `postgres://${username}:${password}@${host}${port ? `:${port}` : ""}/${database}${sslQ}`;
@@ -12370,6 +12383,17 @@ var init_benchmark = __esm(() => {
 });
 
 // src/inflect.ts
+function toTableName(modelName) {
+  const snake = String(modelName).replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+  if (snake.endsWith("y") && !/[aeou]y$/.test(snake))
+    return `${snake.slice(0, -1)}ies`;
+  if (snake.endsWith("s") || snake.endsWith("x") || snake.endsWith("ch") || snake.endsWith("sh"))
+    return `${snake}es`;
+  return `${snake}s`;
+}
+function tableNameFor(model) {
+  return typeof model?.table === "string" && model.table.length > 0 ? model.table : toTableName(String(model?.name ?? ""));
+}
 function stripTrailingS(name) {
   return name.endsWith("s") ? name.slice(0, -1) : name;
 }
@@ -12484,6 +12508,24 @@ var init_pivot = __esm(() => {
 function isRawExpression(expr) {
   return typeof expr === "object" && expr !== null && "raw" in expr && typeof expr.raw === "string";
 }
+function isBoundSqlExpression(expr) {
+  return typeof expr === "object" && expr !== null && "sql" in expr && typeof expr.sql === "string" && (!("parameters" in expr) || Array.isArray(expr.parameters));
+}
+function renderBoundSqlExpression(expression, startIndex) {
+  const parameters = expression.parameters ?? [];
+  if (config5.dialect !== "postgres" || parameters.length === 0)
+    return { text: expression.sql, parameters };
+  let parameterIndex = 0;
+  const text = expression.sql.replace(/\?/g, (placeholder) => {
+    if (parameterIndex >= parameters.length)
+      return placeholder;
+    return getPlaceholder(startIndex + parameterIndex++);
+  });
+  if (parameterIndex !== parameters.length) {
+    throw new TypeError(`[query-builder] SQL expression declares ${parameters.length} parameters but contains only ${parameterIndex} placeholders`);
+  }
+  return { text, parameters };
+}
 function raw(strings, ...values) {
   if (typeof strings === "string")
     return { raw: strings };
@@ -12957,6 +12999,31 @@ function createQueryBuilder(state) {
       throw err;
     });
   }
+  function mutationCount(result) {
+    if (typeof result === "number")
+      return Number.isFinite(result) ? result : 0;
+    if (typeof result === "bigint")
+      return Number(result);
+    if (!result || typeof result !== "object")
+      return 0;
+    const record = result;
+    for (const key of [
+      "changes",
+      "affectedRows",
+      "count",
+      "rowCount",
+      "numAffectedRows",
+      "numUpdatedRows",
+      "numDeletedRows",
+      "numInsertedOrUpdatedRows"
+    ]) {
+      if (record[key] !== undefined && record[key] !== null)
+        return mutationCount(record[key]);
+    }
+    if (Array.isArray(result))
+      return result.reduce((total, item) => total + mutationCount(item), 0);
+    return 0;
+  }
   function makeExecutableQuery(q, text) {
     const sqlText = text ?? computeSqlText(q);
     return {
@@ -14052,7 +14119,16 @@ function createQueryBuilder(state) {
           built = null;
           return this;
         }
-        return this;
+        if (typeof expr === "function") {
+          throw new TypeError("where(callback) is not supported. This builder has no expression callback, and " + "ignoring one silently would leave the query matching every row the filter was " + "meant to exclude. Use whereNested(subquery), whereAny(...), or the orWhere* " + "helpers to build a grouped condition.");
+        }
+        if (expr === undefined || expr === null) {
+          throw new TypeError("where() was called with no condition.");
+        }
+        if (typeof expr === "string") {
+          throw new TypeError(`where(${JSON.stringify(expr)}) is missing an operator and a value. Pass ` + "where(column, operator, value), or whereRaw() for a raw fragment.");
+        }
+        throw new TypeError(`where() does not understand a condition of type ${typeof expr}.`);
       },
       whereNull(column) {
         validateIdentifier(String(column), "whereNull(column)");
@@ -15657,8 +15733,17 @@ function createQueryBuilder(state) {
           const setClauses = Array.from({ length: len });
           for (let i = 0;i < len; i++) {
             const key = keys[i];
-            setClauses[i] = `${quoteId(key)} = ${getPlaceholder(i + 1)}`;
-            params.push(values[key]);
+            const value = values[key];
+            if (isRawExpression(value)) {
+              setClauses[i] = `${quoteId(key)} = ${value.raw}`;
+            } else if (isBoundSqlExpression(value)) {
+              const expression = renderBoundSqlExpression(value, params.length + 1);
+              setClauses[i] = `${quoteId(key)} = ${expression.text}`;
+              params.push(...expression.parameters);
+            } else {
+              setClauses[i] = `${quoteId(key)} = ${getPlaceholder(params.length + 1)}`;
+              params.push(value);
+            }
           }
           sqlText = `${sqlText} SET ${setClauses.join(", ")}`;
           built = _sql.unsafe(sqlText, params);
@@ -15666,17 +15751,29 @@ function createQueryBuilder(state) {
         },
         where(expr, op, value) {
           const getWhereKeyword = () => SQL_PATTERNS.WHERE.test(sqlText) ? "AND" : "WHERE";
-          if (typeof expr === "string" && op !== undefined) {
+          if (op !== undefined && (typeof expr === "string" || isRawExpression(expr) || isBoundSqlExpression(expr))) {
+            const safeOperator = assertSafeWhereOperator(op, "updateTable.where");
+            let left;
+            if (typeof expr === "string") {
+              left = quoteId(expr);
+            } else if (isRawExpression(expr)) {
+              left = expr.raw;
+            } else {
+              const expression = renderBoundSqlExpression(expr, params.length + 1);
+              left = expression.text;
+              params.push(...expression.parameters);
+            }
             const paramIndex = params.length + 1;
-            sqlText = `${sqlText} ${getWhereKeyword()} ${quoteId(expr)} ${op} ${getPlaceholder(paramIndex)}`;
+            sqlText = `${sqlText} ${getWhereKeyword()} ${left} ${safeOperator} ${getPlaceholder(paramIndex)}`;
             params.push(value);
             built = _sql.unsafe(sqlText, params);
             return this;
           }
           if (Array.isArray(expr)) {
             const [col, op2, val] = expr;
+            const safeOperator = assertSafeWhereOperator(op2, "updateTable.where");
             const paramIndex = params.length + 1;
-            sqlText = `${sqlText} ${getWhereKeyword()} ${quoteId(String(col))} ${String(op2)} ${getPlaceholder(paramIndex)}`;
+            sqlText = `${sqlText} ${getWhereKeyword()} ${quoteId(String(col))} ${safeOperator} ${getPlaceholder(paramIndex)}`;
             params.push(val);
             built = _sql.unsafe(sqlText, params);
             return this;
@@ -15735,15 +15832,16 @@ function createQueryBuilder(state) {
           }
           return makeExecutableQuery(built, sqlText);
         },
-        execute() {
-          return runWithHooks(built, "update");
+        async execute() {
+          const result = await runWithHooks(built, "update");
+          return mutationCount(result);
         },
         async executeTakeFirst() {
-          const result = await runWithHooks(built, "update");
+          const result = mutationCount(await runWithHooks(built, "update"));
           return { numUpdatedRows: result };
         },
         async executeTakeFirstOrThrow() {
-          const result = await runWithHooks(built, "update");
+          const result = mutationCount(await runWithHooks(built, "update"));
           if (result === 0)
             throw new Error("No rows updated");
           return { numUpdatedRows: result };
@@ -15864,18 +15962,18 @@ function createQueryBuilder(state) {
           } catch (err) {
             throw err;
           }
-          const result = await runWithHooks(ensureDelBuilt(), "delete");
+          const result = mutationCount(await runWithHooks(ensureDelBuilt(), "delete"));
           try {
             await config5.hooks?.afterDelete?.({ table: String(table), where: whereCondition, result });
           } catch {}
           return result;
         },
         async executeTakeFirst() {
-          const result = await runWithHooks(ensureDelBuilt(), "delete");
+          const result = mutationCount(await runWithHooks(ensureDelBuilt(), "delete"));
           return { numDeletedRows: result };
         },
         async executeTakeFirstOrThrow() {
-          const result = await runWithHooks(ensureDelBuilt(), "delete");
+          const result = mutationCount(await runWithHooks(ensureDelBuilt(), "delete"));
           if (result === 0)
             throw new Error("No rows deleted");
           return { numDeletedRows: result };
@@ -16590,7 +16688,7 @@ var init_cache = __esm(() => {
 });
 
 // src/actions/console.ts
-import process21 from "process";
+import process22 from "process";
 import { createInterface } from "readline";
 async function startConsole() {
   console.log("-- Query Builder Interactive Console");
@@ -16599,8 +16697,8 @@ async function startConsole() {
   console.log();
   const qb = createQueryBuilder();
   const rl = createInterface({
-    input: process21.stdin,
-    output: process21.stdout,
+    input: process22.stdin,
+    output: process22.stdout,
     prompt: "qb> "
   });
   let multilineBuffer = "";
@@ -16651,7 +16749,7 @@ Tips:
       if (cmd === ".exit" || cmd === ".quit") {
         console.log("Goodbye!");
         rl.close();
-        process21.exit(0);
+        process22.exit(0);
       } else if (cmd === ".help") {
         console.log(helpText);
       } else if (cmd === ".clear") {
@@ -16722,7 +16820,7 @@ Tips:
   rl.on("close", () => {
     console.log(`
 Goodbye!`);
-    process21.exit(0);
+    process22.exit(0);
   });
   rl.prompt();
 }
@@ -17100,9 +17198,8 @@ var init_db_info = __esm(() => {
 });
 
 // src/actions/db-optimize.ts
-import process22 from "process";
 async function dbOptimize(options = {}) {
-  const dialect = options.dialect || process22.env.DB_DIALECT || config5.dialect || "postgres";
+  const dialect = resolveDialect(options.dialect);
   const aggressive = options.aggressive || false;
   if (options.verbose) {
     console.log(`Optimizing ${dialect} database${aggressive ? " (aggressive mode)" : ""}...`);
@@ -17142,7 +17239,7 @@ async function dbOptimize(options = {}) {
           await bunSql`ANALYZE TABLE ${bunSql(table)}`;
         }
       } else {
-        const dbName = process22.env.DB_NAME || "test";
+        const dbName = resolveDatabaseName();
         const tables = await bunSql`
           SELECT table_name
           FROM information_schema.tables
@@ -17195,9 +17292,8 @@ var init_db_optimize = __esm(() => {
 });
 
 // src/actions/db-wipe.ts
-import process23 from "process";
 async function dbWipe(options = {}) {
-  const dialect = options.dialect || process23.env.DB_DIALECT || config5.dialect || "postgres";
+  const dialect = resolveDialect(options.dialect);
   if (options.verbose) {
     console.log(`Wiping all tables from ${dialect} database...`);
   }
@@ -17211,7 +17307,7 @@ async function dbWipe(options = {}) {
       `;
       tables = result.map((row) => row.tablename);
     } else if (isMysqlLike(dialect)) {
-      const dbName = process23.env.DB_NAME || "test";
+      const dbName = resolveDatabaseName();
       const result = await bunSql`
         SELECT table_name
         FROM information_schema.tables
@@ -17648,6 +17744,8 @@ function sqlTypeToNormalized(rawType, dialect, ctx) {
     return "decimal";
   if (base === "date")
     return "date";
+  if (base === "timestamptz" || /\bwith time zone\b/.test(t))
+    return "timestamptz";
   if (/^(?:timestamp|datetime)/.test(base))
     return "datetime";
   if (/^time/.test(base))
@@ -17658,10 +17756,6 @@ function sqlTypeToNormalized(rawType, dialect, ctx) {
     return "enum";
   return "string";
 }
-function stripIndexPrefix(physicalName, table) {
-  const prefix = `${table}_`;
-  return physicalName.startsWith(prefix) ? physicalName.slice(prefix.length) : physicalName;
-}
 function asAction(raw2) {
   const v = String(raw2 ?? "").toLowerCase().trim();
   if (v === "cascade" || v === "restrict" || v === "set null")
@@ -17697,7 +17791,7 @@ async function buildSqliteTable(qb, table) {
     const isUnique = Number(idx.unique) === 1;
     if (isUnique && columns2.length === 1)
       uniqueColumns.add(columns2[0]);
-    indexes.push({ name: stripIndexPrefix(physName, table), columns: columns2, type: isUnique ? "unique" : "index" });
+    indexes.push({ name: physName, columns: columns2, type: isUnique ? "unique" : "index" });
   }
   const columns = colRows.map((r) => {
     const name = String(r.name);
@@ -17734,7 +17828,31 @@ function normalizeRawDefault(raw2) {
     return raw2;
   return String(raw2);
 }
-async function buildPgTable(qb, table) {
+async function pgEnumLabels(qb) {
+  const rows = await qb.unsafe(`SELECT t.typname AS type_name, e.enumlabel AS label
+    FROM pg_type t
+      JOIN pg_enum e ON e.enumtypid = t.oid
+      JOIN pg_namespace n ON n.oid = t.typnamespace
+    WHERE n.nspname = 'public'
+    ORDER BY t.typname, e.enumsortorder`);
+  const labels = new Map;
+  for (const row of rows) {
+    const name = String(row.type_name);
+    const existing = labels.get(name);
+    if (existing)
+      existing.push(String(row.label));
+    else
+      labels.set(name, [String(row.label)]);
+  }
+  return labels;
+}
+function pgColumnType(dataType, udtName, enums) {
+  const enumValues = enums.get(udtName);
+  const type = sqlTypeToNormalized(String(dataType || udtName || ""), "postgres", { enumValues });
+  return enumValues ? { type, enumValues, enumTypeName: udtName } : { type };
+}
+async function buildPgTable(qb, table, enumLabels) {
+  const enums = enumLabels ?? await pgEnumLabels(qb);
   const colRows = await qb.unsafe(`SELECT c.column_name, c.data_type, c.udt_name, c.is_nullable, c.column_default, c.character_maximum_length,
       (SELECT COUNT(*) FROM information_schema.table_constraints tc
           JOIN information_schema.key_column_usage k ON k.constraint_name = tc.constraint_name
@@ -17782,7 +17900,7 @@ async function buildPgTable(qb, table) {
     const hasDefault = rawDefault != null && !isSerial;
     return {
       name,
-      type: sqlTypeToNormalized(String(r.data_type ?? r.udt_name ?? ""), "postgres"),
+      ...pgColumnType(String(r.data_type ?? ""), r.udt_name == null ? "" : String(r.udt_name), enums),
       isPrimaryKey,
       isUnique: uniqueColumns.has(name),
       isNullable: isPrimaryKey ? false : String(r.is_nullable).toUpperCase() === "YES",
@@ -17868,7 +17986,7 @@ function groupPhysicalIndexes(table, rows) {
     if (entry.isUnique && entry.columns.length === 1)
       uniqueColumns.add(entry.columns[0]);
     indexes.push({
-      name: stripIndexPrefix(physName, table),
+      name: physName,
       columns: entry.columns,
       type: entry.isUnique ? "unique" : "index",
       where: entry.where
@@ -17881,13 +17999,14 @@ async function buildPlanFromDatabase(dialect, opts = {}) {
   const qb = createQueryBuilder();
   const allTables = opts.tables?.length ? opts.tables : await listTables(qb, d);
   const tables = allTables.filter((t) => t !== "migrations");
+  const enumLabels = d === "postgres" ? await pgEnumLabels(qb) : undefined;
   const out = [];
   for (const table of tables) {
     let plan;
     if (d === "sqlite")
       plan = await buildSqliteTable(qb, table);
     else if (d === "postgres")
-      plan = await buildPgTable(qb, table);
+      plan = await buildPgTable(qb, table, enumLabels);
     else
       plan = await buildMysqlTable(qb, table);
     if (plan.columns.length > 0)
@@ -17903,7 +18022,7 @@ var init_introspect_db = __esm(() => {
 // src/actions/make-model.ts
 import { existsSync as existsSync14, mkdirSync as mkdirSync7, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname7, join as join7 } from "path";
-import process24 from "process";
+import process23 from "process";
 function findWorkspaceRoot(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname7(currentPath)) {
@@ -17912,10 +18031,10 @@ function findWorkspaceRoot(startPath) {
     }
     currentPath = dirname7(currentPath);
   }
-  return process24.cwd();
+  return process23.cwd();
 }
 async function makeModel(name, options = {}) {
-  const workspaceRoot = findWorkspaceRoot(process24.cwd());
+  const workspaceRoot = findWorkspaceRoot(process23.cwd());
   const modelsDir = options.dir || join7(workspaceRoot, "app/Models");
   if (!existsSync14(modelsDir)) {
     mkdirSync7(modelsDir, { recursive: true });
@@ -17958,6 +18077,12 @@ export default model
 }
 var init_make_model = () => {};
 
+// src/drivers/index-name.ts
+function qualifiedIndexName(tableName, indexName) {
+  const prefix = `${tableName}_`;
+  return indexName.startsWith(prefix) ? indexName : `${prefix}${indexName}`;
+}
+
 // src/drivers/mysql.ts
 class MySQLDriver {
   quoteIdentifier(id) {
@@ -18044,7 +18169,7 @@ class MySQLDriver {
       throw new Error(`[migrations] Partial indexes (CompositeIndex.where) are not supported on MySQL. Index '${index.name}' on table '${tableName}' uses WHERE clause: ${index.where}`);
     }
     const kind = index.type === "unique" ? "UNIQUE " : "";
-    const idxName = `${tableName}_${index.name}`;
+    const idxName = qualifiedIndexName(tableName, index.name);
     const columns = index.columns.map((c) => this.quoteIdentifier(c)).join(", ");
     return `CREATE ${kind}INDEX ${this.quoteIdentifier(idxName)} ON ${this.quoteIdentifier(tableName)} (${columns});`;
   }
@@ -18097,7 +18222,7 @@ class MySQLDriver {
     return `ALTER TABLE ${this.quoteIdentifier(tableName)} DROP COLUMN ${this.quoteIdentifier(columnName)};`;
   }
   dropIndex(tableName, indexName) {
-    const fullIndexName = `${tableName}_${indexName}`;
+    const fullIndexName = qualifiedIndexName(tableName, indexName);
     return `DROP INDEX ${this.quoteIdentifier(fullIndexName)} ON ${this.quoteIdentifier(tableName)};`;
   }
   dropEnumType(_enumTypeName) {
@@ -18111,7 +18236,7 @@ class MySQLDriver {
     )`;
   }
   getExecutedMigrationsQuery() {
-    return "SELECT migration FROM migrations ORDER BY executed_at";
+    return "SELECT migration, executed_at FROM migrations ORDER BY executed_at";
   }
   recordMigrationQuery() {
     return "INSERT INTO migrations (migration) VALUES (?)";
@@ -18144,6 +18269,7 @@ class MySQLDriver {
     return parts.join(" ");
   }
 }
+var init_mysql = () => {};
 
 // src/drivers/postgres.ts
 class PostgresDriver {
@@ -18178,7 +18304,7 @@ class PostgresDriver {
         return "jsonb";
       case "enum":
         if (column.enumValues && column.enumValues.length > 0) {
-          return this.quoteIdentifier(column.enumTypeName ?? `${column.name}_type`);
+          return column.enumTypeName ? this.quoteIdentifier(column.enumTypeName) : "text";
         }
         return "text";
       default:
@@ -18232,7 +18358,7 @@ class PostgresDriver {
   }
   createIndex(tableName, index) {
     const kind = index.type === "unique" ? "UNIQUE " : "";
-    const idxName = `${tableName}_${index.name}`;
+    const idxName = qualifiedIndexName(tableName, index.name);
     const columns = index.columns.map((c) => this.quoteIdentifier(c)).join(", ");
     const where = index.where ? ` WHERE ${index.where}` : "";
     return `CREATE ${kind}INDEX IF NOT EXISTS ${this.quoteIdentifier(idxName)} ON ${this.quoteIdentifier(tableName)} (${columns})${where};`;
@@ -18260,7 +18386,17 @@ class PostgresDriver {
   }
   modifyColumn(tableName, column) {
     const typeSql = this.getColumnType(column);
-    return `ALTER TABLE ${this.quoteIdentifier(tableName)} ALTER COLUMN ${this.quoteIdentifier(column.name)} TYPE ${typeSql} USING ${this.quoteIdentifier(column.name)}::${typeSql};`;
+    const table = this.quoteIdentifier(tableName);
+    const name = this.quoteIdentifier(column.name);
+    const statements = [
+      `ALTER TABLE ${table} ALTER COLUMN ${name} TYPE ${typeSql} USING ${name}::${typeSql};`
+    ];
+    if (!column.isPrimaryKey)
+      statements.push(`ALTER TABLE ${table} ALTER COLUMN ${name} ${column.isNullable ? "DROP NOT NULL" : "SET NOT NULL"};`);
+    const defaultValue = this.getDefaultValue(column);
+    statements.push(defaultValue ? `ALTER TABLE ${table} ALTER COLUMN ${name} SET ${defaultValue};` : `ALTER TABLE ${table} ALTER COLUMN ${name} DROP DEFAULT;`);
+    return statements.join(`
+`);
   }
   renameColumn(tableName, from, to) {
     return `ALTER TABLE ${this.quoteIdentifier(tableName)} RENAME COLUMN ${this.quoteIdentifier(from)} TO ${this.quoteIdentifier(to)};`;
@@ -18278,7 +18414,7 @@ class PostgresDriver {
     return `ALTER TABLE ${this.quoteIdentifier(tableName)} DROP COLUMN ${this.quoteIdentifier(columnName)};`;
   }
   dropIndex(tableName, indexName) {
-    const fullIndexName = `${tableName}_${indexName}`;
+    const fullIndexName = qualifiedIndexName(tableName, indexName);
     return `DROP INDEX IF EXISTS ${this.quoteIdentifier(fullIndexName)};`;
   }
   dropEnumType(enumTypeName) {
@@ -18292,7 +18428,7 @@ class PostgresDriver {
     )`;
   }
   getExecutedMigrationsQuery() {
-    return "SELECT migration FROM migrations ORDER BY executed_at";
+    return "SELECT migration, executed_at FROM migrations ORDER BY executed_at";
   }
   recordMigrationQuery() {
     return "INSERT INTO migrations (migration) VALUES ($1)";
@@ -18321,10 +18457,12 @@ class PostgresDriver {
     return parts.join(" ");
   }
 }
+var init_postgres = () => {};
 
 // src/drivers/singlestore.ts
 var SingleStoreDriver;
 var init_singlestore = __esm(() => {
+  init_mysql();
   SingleStoreDriver = class SingleStoreDriver extends MySQLDriver {
     createTable(table) {
       const columns = table.columns.map((c) => this.renderColumn(c)).join(`,
@@ -18458,7 +18596,7 @@ class SQLiteDriver {
   }
   createIndex(tableName, index) {
     const kind = index.type === "unique" ? "UNIQUE " : "";
-    const idxName = `${tableName}_${index.name}`;
+    const idxName = qualifiedIndexName(tableName, index.name);
     const columns = index.columns.map((c) => this.quoteIdentifier(c)).join(", ");
     const where = index.where ? ` WHERE ${index.where}` : "";
     return `CREATE ${kind}INDEX IF NOT EXISTS ${this.quoteIdentifier(idxName)} ON ${this.quoteIdentifier(tableName)} (${columns})${where};`;
@@ -18523,7 +18661,7 @@ class SQLiteDriver {
     return `ALTER TABLE ${this.quoteIdentifier(tableName)} DROP COLUMN ${this.quoteIdentifier(columnName)};`;
   }
   dropIndex(tableName, indexName) {
-    const fullIndexName = `${tableName}_${indexName}`;
+    const fullIndexName = qualifiedIndexName(tableName, indexName);
     return `DROP INDEX IF EXISTS ${this.quoteIdentifier(fullIndexName)};`;
   }
   dropEnumType(_enumTypeName) {
@@ -18537,7 +18675,7 @@ class SQLiteDriver {
     )`;
   }
   getExecutedMigrationsQuery() {
-    return "SELECT migration FROM migrations ORDER BY executed_at";
+    return "SELECT migration, executed_at FROM migrations ORDER BY executed_at";
   }
   recordMigrationQuery() {
     return "INSERT INTO migrations (migration) VALUES (?)";
@@ -18569,6 +18707,7 @@ class SQLiteDriver {
     return parts.join(" ");
   }
 }
+var init_sqlite = () => {};
 
 // src/drivers/index.ts
 function getDialectDriver(dialect) {
@@ -18586,10 +18725,34 @@ function getDialectDriver(dialect) {
   }
 }
 var init_drivers = __esm(() => {
+  init_mysql();
+  init_postgres();
   init_singlestore();
+  init_sqlite();
+  init_mysql();
+  init_postgres();
   init_singlestore();
+  init_sqlite();
 });
 
+// src/workspace.ts
+import { existsSync as existsSync16 } from "fs";
+import { dirname as dirname8, join as join9 } from "path";
+import process24 from "process";
+function findWorkspaceRoot2(startPath = process24.cwd()) {
+  let currentPath = startPath;
+  while (currentPath !== dirname8(currentPath)) {
+    if (existsSync16(join9(currentPath, "package.json")))
+      return currentPath;
+    currentPath = dirname8(currentPath);
+  }
+  return process24.cwd();
+}
+function getSqlDirectory(workspaceRoot) {
+  return join9(workspaceRoot ?? findWorkspaceRoot2(), "database", "migrations");
+}
+var init_workspace = () => {};
+
 // src/actions/migrate.ts
 var exports_migrate = {};
 __export(exports_migrate, {
@@ -18601,23 +18764,48 @@ __export(exports_migrate, {
   copyModelsToGenerated: () => copyModelsToGenerated,
   clearGeneratedDirectory: () => clearGeneratedDirectory
 });
-import { existsSync as existsSync16, mkdirSync as mkdirSync8, mkdtempSync, readdirSync as readdirSync6, readFileSync as readFileSync3, rmSync, unlinkSync, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync8, mkdtempSync, readdirSync as readdirSync6, readFileSync as readFileSync3, rmSync, unlinkSync, writeFileSync as writeFileSync11 } from "fs";
 import { tmpdir } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import process25 from "process";
+async function settleAppliedFiles(qb, dialect, files) {
+  if (files.length === 0)
+    return;
+  const sqlDir = ensureSqlDirectory(getWorkspaceRoot());
+  try {
+    await createMigrationsTable(qb, dialect);
+    for (const file2 of files) {
+      await recordMigration(qb, file2, dialect);
+      info(`-- \u2713 Recorded applied migration: ${file2}`);
+    }
+  } catch (err) {
+    info(`-- Could not record applied migrations (the schema change itself succeeded): ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function isGeneratedMigration(sqlDir, file2) {
+  try {
+    return isGeneratedMigrationSql(readFileSync3(join10(sqlDir, file2), "utf8"));
+  } catch {
+    return false;
+  }
+}
+function isAlreadyAppliedError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return /duplicate column name/i.test(message) || /duplicate key name/i.test(message) || /\balready exists\b/i.test(message);
+}
 function info(message) {
   if (config5.verbose)
     console.log(message);
 }
 function getSnapshotDir(workspaceRoot) {
-  return join9(workspaceRoot, config5.snapshotDir || ".qb");
+  return join10(workspaceRoot, config5.snapshotDir || ".qb");
 }
 function getSnapshotPath(workspaceRoot, dialect) {
-  return join9(getSnapshotDir(workspaceRoot), `model-snapshot.${dialect}.json`);
+  return join10(getSnapshotDir(workspaceRoot), `model-snapshot.${dialect}.json`);
 }
 function loadPlanSnapshot(workspaceRoot, dialect) {
   const snapshotPath = getSnapshotPath(workspaceRoot, dialect);
-  if (!existsSync16(snapshotPath)) {
+  if (!existsSync17(snapshotPath)) {
     return;
   }
   try {
@@ -18640,7 +18828,7 @@ function savePlanSnapshot(workspaceRoot, dialect, plan) {
   const snapshotPath = getSnapshotPath(workspaceRoot, dialect);
   const snapshotDir = getSnapshotDir(workspaceRoot);
   const hash = hashMigrationPlan(plan);
-  if (existsSync16(snapshotPath)) {
+  if (existsSync17(snapshotPath)) {
     try {
       const current = JSON.parse(readFileSync3(snapshotPath, "utf8"));
       if (current?.hash === hash && current?.dialect === dialect && current?.plan) {
@@ -18649,7 +18837,7 @@ function savePlanSnapshot(workspaceRoot, dialect, plan) {
       }
     } catch {}
   }
-  if (!existsSync16(snapshotDir)) {
+  if (!existsSync17(snapshotDir)) {
     mkdirSync8(snapshotDir, { recursive: true });
     info(`-- Created snapshot directory: ${snapshotDir}`);
   }
@@ -18667,11 +18855,11 @@ function saveMigrationSnapshot(plan, options = {}) {
   savePlanSnapshot(options.workspaceRoot ?? getWorkspaceRoot(), dialect, plan);
 }
 function getWorkspaceRoot() {
-  return process25.cwd();
+  return findWorkspaceRoot2();
 }
 function ensureSqlDirectory(workspaceRoot) {
   const sqlDir = getSqlDirectory(workspaceRoot);
-  if (!existsSync16(sqlDir)) {
+  if (!existsSync17(sqlDir)) {
     mkdirSync8(sqlDir, { recursive: true });
     info(`-- Created SQL directory: ${sqlDir}`);
   }
@@ -18680,21 +18868,22 @@ function ensureSqlDirectory(workspaceRoot) {
 async function generateMigration(dir, opts = {}) {
   await getConfig();
   if (!dir) {
-    dir = join9(process25.cwd(), "app/Models");
+    dir = join10(process25.cwd(), "app/Models");
   }
   const dialect = opts.dialect || config5.dialect || "postgres";
   const workspaceRoot = getWorkspaceRoot();
   const models = await loadModels({ modelsDir: dir });
   const plan = buildMigrationPlan2(models, { dialect });
   let previous;
+  let reconciledFromDatabase = false;
   if (!opts.full) {
     previous = loadPlanSnapshot(workspaceRoot, dialect);
     if (previous) {
       info("-- Comparing with stored model snapshot");
     } else {
-      const defaultStatePath = join9(dir, `.qb-migrations.${dialect}.json`);
+      const defaultStatePath = join10(dir, `.qb-migrations.${dialect}.json`);
       const statePath = String(opts.state || defaultStatePath);
-      if (existsSync16(statePath)) {
+      if (existsSync17(statePath)) {
         try {
           const raw2 = readFileSync3(statePath, "utf8");
           const parsed = JSON.parse(raw2);
@@ -18711,6 +18900,7 @@ async function generateMigration(dir, opts = {}) {
           const scoped = livePlan.tables.filter((t) => modelTables.has(t.table));
           if (scoped.length > 0) {
             previous = { dialect: livePlan.dialect, tables: scoped };
+            reconciledFromDatabase = true;
             info(`-- No snapshot; reconciling against live database (${scoped.length} matching table${scoped.length === 1 ? "" : "s"})`);
           }
         } catch (err) {
@@ -18724,25 +18914,34 @@ async function generateMigration(dir, opts = {}) {
   } else {
     info("-- Full migration requested, ignoring any previous state");
   }
-  const diff = opts.full ? { statements: generateSql(plan, { dryRun: opts.dryRun }), operations: plan.tables.map((t) => ({ kind: "create_table", table: t.table, destructive: false, sql: "" })) } : generateDiffOperations(previous, plan, { applyRenames: opts.applyRenames, dryRun: opts.dryRun });
+  const diff = opts.full ? { statements: generateSql(plan, { dryRun: opts.dryRun }), operations: plan.tables.map((t) => ({ kind: "create_table", table: t.table, destructive: false, sql: "" })) } : generateDiffOperations(previous, plan, {
+    applyRenames: opts.applyRenames,
+    dryRun: opts.dryRun,
+    preserveUnknownColumns: reconciledFromDatabase
+  });
   const sqlStatements = diff.statements;
   const operations = diff.operations;
   const sql = sqlStatements.join(`
 `);
   const hasChanges = sqlStatements.some((stmt) => /\b(?:CREATE|ALTER|DROP)\b/i.test(stmt));
   if (opts.apply) {
-    const dirPath = mkdtempSync(join9(tmpdir(), "qb-migrate-"));
-    const filePath = join9(dirPath, "migration.sql");
+    const dirPath = mkdtempSync(join10(tmpdir(), "qb-migrate-"));
+    const filePath = join10(dirPath, "migration.sql");
     try {
       if (hasChanges) {
         writeFileSync11(filePath, sql);
+        const qb = createQueryBuilder();
+        await qb.file(filePath);
         info("-- Migration applied");
+        await settleAppliedFiles(qb, dialect, lastCreatedMigrationFiles());
       } else {
         info("-- No changes; nothing to apply");
       }
     } catch (err) {
       console.error("-- Migration failed:", err);
       throw err;
+    } finally {
+      rmSync(dirPath, { recursive: true, force: true });
     }
   }
   if (!opts.dryRun)
@@ -18751,9 +18950,6 @@ async function generateMigration(dir, opts = {}) {
 }
 async function executeMigration(dir) {
   await getConfig();
-  if (!dir) {
-    dir = join9(process25.cwd(), "app/Models");
-  }
   const workspaceRoot = getWorkspaceRoot();
   const sqlDir = ensureSqlDirectory(workspaceRoot);
   const dialect = config5.dialect || "postgres";
@@ -18768,42 +18964,25 @@ async function executeMigration(dir) {
     const qb = createQueryBuilder();
     await createMigrationsTable(qb, dialect);
     const executedMigrations = await getExecutedMigrations(qb, dialect);
-    const permanentMigrations = [];
-    const transientMigrations = [];
-    for (const file2 of scriptFiles) {
-      if (file2.includes("alter-") && file2.includes("-table")) {
-        transientMigrations.push(file2);
-      } else if (!executedMigrations.includes(file2)) {
-        permanentMigrations.push(file2);
-      }
-    }
-    const totalPending = permanentMigrations.length + transientMigrations.length;
-    if (totalPending === 0) {
+    const pending = scriptFiles.filter((file2) => !executedMigrations.includes(file2));
+    if (pending.length === 0) {
       info("-- No pending migrations to execute");
       return true;
     }
-    info(`-- Executing ${totalPending} migrations (${permanentMigrations.length} permanent, ${transientMigrations.length} transient)`);
-    for (const file2 of permanentMigrations) {
-      const filePath = join9(sqlDir, file2);
+    info(`-- Executing ${pending.length} migration${pending.length === 1 ? "" : "s"}`);
+    for (const file2 of pending) {
+      const filePath = join10(sqlDir, file2);
       info(`-- Executing: ${file2}`);
       try {
         await qb.file(filePath);
         await recordMigration(qb, file2, dialect);
         info(`-- \u2713 Migration ${file2} executed and recorded`);
       } catch (err) {
-        console.error(`-- \u2717 Migration ${file2} failed:`, err);
-        throw err;
-      }
-    }
-    for (const file2 of transientMigrations) {
-      const filePath = join9(sqlDir, file2);
-      info(`-- Executing: ${file2} (transient)`);
-      try {
-        await qb.file(filePath);
-        info(`-- \u2713 Migration ${file2} executed (not recorded)`);
-        unlinkSync(filePath);
-        info(`-- \uD83D\uDDD1\uFE0F  Deleted transient migration: ${file2}`);
-      } catch (err) {
+        if (isGeneratedMigration(sqlDir, file2) && isAlreadyAppliedError(err)) {
+          await recordMigration(qb, file2, dialect);
+          info(`-- \u2713 Migration ${file2} was already applied; recorded it (${err instanceof Error ? err.message : String(err)})`);
+          continue;
+        }
         console.error(`-- \u2717 Migration ${file2} failed:`, err);
         throw err;
       }
@@ -18818,7 +18997,7 @@ async function executeMigration(dir) {
 async function resetDatabase(dir, opts = {}) {
   await getConfig();
   if (!dir) {
-    dir = join9(process25.cwd(), "app/Models");
+    dir = join10(process25.cwd(), "app/Models");
   }
   const dialect = opts.dialect || config5.dialect || "postgres";
   const driver = getDialectDriver(dialect);
@@ -18915,42 +19094,50 @@ async function resetDatabase(dir, opts = {}) {
 }
 async function deleteMigrationFiles(dir, workspaceRoot, opts = {}) {
   if (!dir) {
-    dir = join9(process25.cwd(), "app/Models");
+    dir = join10(process25.cwd(), "app/Models");
   }
   if (!workspaceRoot) {
     workspaceRoot = getWorkspaceRoot();
   }
   const dialect = String(opts.dialect || config5.dialect || "postgres");
   const snapshotPath = getSnapshotPath(workspaceRoot, dialect);
-  if (existsSync16(snapshotPath)) {
+  if (existsSync17(snapshotPath)) {
     unlinkSync(snapshotPath);
     info(`-- Removed model snapshot file: ${snapshotPath}`);
   }
-  const defaultStatePath = join9(dir, `.qb-migrations.${dialect}.json`);
+  const defaultStatePath = join10(dir, `.qb-migrations.${dialect}.json`);
   const statePath = String(opts.state || defaultStatePath);
-  if (existsSync16(statePath)) {
+  if (existsSync17(statePath)) {
     unlinkSync(statePath);
     info(`-- Removed legacy migration state file: ${statePath}`);
   }
-  const sqlDir = getSqlDirectory(workspaceRoot);
-  if (existsSync16(sqlDir)) {
-    const sqlFiles = readdirSync6(sqlDir);
-    const migrationFiles = sqlFiles.filter((file2) => file2.endsWith(".sql"));
-    for (const file2 of migrationFiles) {
-      const filePath = join9(sqlDir, file2);
-      unlinkSync(filePath);
-      info(`-- Removed migration file: ${file2}`);
+  removeGeneratedMigrationFiles(getSqlDirectory(workspaceRoot));
+}
+function removeGeneratedMigrationFiles(sqlDir) {
+  if (!existsSync17(sqlDir))
+    return;
+  let removed = 0;
+  const kept = [];
+  for (const file2 of readdirSync6(sqlDir).filter((f) => f.endsWith(".sql"))) {
+    if (!isGeneratedMigration(sqlDir, file2)) {
+      kept.push(file2);
+      continue;
     }
-    info(`-- Cleaned up ${migrationFiles.length} migration files from migrations directory`);
+    unlinkSync(join10(sqlDir, file2));
+    info(`-- Removed generated migration file: ${file2}`);
+    removed += 1;
   }
+  info(`-- Cleaned up ${removed} generated migration file${removed === 1 ? "" : "s"} from migrations directory`);
+  if (kept.length > 0)
+    info(`-- Kept ${kept.length} hand-written migration${kept.length === 1 ? "" : "s"}: ${kept.slice(0, 5).join(", ")}${kept.length > 5 ? `, +${kept.length - 5} more` : ""}`);
 }
 async function copyModelsToGenerated(_dir, _workspaceRoot) {}
 async function clearGeneratedDirectory(workspaceRoot) {
   if (!workspaceRoot) {
     workspaceRoot = getWorkspaceRoot();
   }
-  const generatedDir = join9(workspaceRoot, "generated");
-  if (existsSync16(generatedDir)) {
+  const generatedDir = join10(workspaceRoot, "generated");
+  if (existsSync17(generatedDir)) {
     try {
       rmSync(generatedDir, { recursive: true, force: true });
       info("-- Cleared generated directory");
@@ -18959,12 +19146,6 @@ async function clearGeneratedDirectory(workspaceRoot) {
     }
   }
 }
-function getSqlDirectory(workspaceRoot) {
-  if (!workspaceRoot) {
-    workspaceRoot = getWorkspaceRoot();
-  }
-  return join9(workspaceRoot, "database", "migrations");
-}
 async function createMigrationsTable(qb, dialect) {
   const driver = getDialectDriver(dialect);
   const createTableSql = driver.createMigrationsTable();
@@ -19003,6 +19184,7 @@ var init_migrate = __esm(() => {
   init_drivers();
   init_src2();
   init_introspect_db();
+  init_workspace();
 });
 
 // src/actions/migrate-generate.ts
@@ -19014,28 +19196,49 @@ var init_migrate_generate = __esm(() => {
 });
 
 // src/actions/migrate-rollback.ts
-import { existsSync as existsSync17, readFileSync as readFileSync4, unlinkSync as unlinkSync2 } from "fs";
-import { dirname as dirname8, join as join10 } from "path";
-import process26 from "process";
+import { existsSync as existsSync18, readFileSync as readFileSync4, unlinkSync as unlinkSync2 } from "fs";
+import { join as join11 } from "path";
 function splitSqlStatements2(sql) {
   const out = [];
   let buf = "";
-  let inString = false;
-  const lines = sql.split(`
-`).filter((l) => !/^\s*--/.test(l));
-  const text = lines.join(`
-`);
-  for (let i = 0;i < text.length; i++) {
-    const ch = text[i];
-    if (ch === "'")
-      inString = !inString;
-    if (ch === ";" && !inString) {
+  let quote = null;
+  for (let i = 0;i < sql.length; i++) {
+    const ch = sql[i];
+    if (quote) {
+      buf += ch;
+      if (ch === quote) {
+        if (sql[i + 1] === quote) {
+          buf += sql[i + 1];
+          i++;
+        } else {
+          quote = null;
+        }
+      }
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      quote = ch;
+      buf += ch;
+      continue;
+    }
+    if (ch === "-" && sql[i + 1] === "-") {
+      const newline = sql.indexOf(`
+`, i);
+      i = newline === -1 ? sql.length : newline;
+      continue;
+    }
+    if (ch === "/" && sql[i + 1] === "*") {
+      const close = sql.indexOf("*/", i + 2);
+      i = close === -1 ? sql.length : close + 1;
+      continue;
+    }
+    if (ch === ";") {
       if (buf.trim())
         out.push(buf.trim());
       buf = "";
-    } else {
-      buf += ch;
+      continue;
     }
+    buf += ch;
   }
   if (buf.trim())
     out.push(buf.trim());
@@ -19049,8 +19252,20 @@ function deriveDownStatements(forwardSql, dialect = config5.dialect) {
     let m;
     if (m = /^CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["`']?(\w+)["`']?/i.exec(stmt)) {
       down.push(`DROP TABLE IF EXISTS ${q(m[1])}`);
-    } else if (m = /^ALTER\s+TABLE\s+["`']?(\w+)["`']?\s+ADD\s+(?:COLUMN\s+)?["`']?(\w+)["`']?/i.exec(stmt)) {
-      down.push(`ALTER TABLE ${q(m[1])} DROP COLUMN ${q(m[2])}`);
+    } else if (m = /^ALTER\s+TABLE\s+["`']?(\w+)["`']?\s+ADD\s+CONSTRAINT\s+["`']?(\w+)["`']?([\s\S]*)$/i.exec(stmt)) {
+      if (dialect === "sqlite") {
+        skipped.push(stmt);
+      } else if (isMysqlLike(dialect) && /\bFOREIGN\s+KEY\b/i.test(m[3] ?? "")) {
+        down.push(`ALTER TABLE ${q(m[1])} DROP FOREIGN KEY ${q(m[2])}`);
+      } else {
+        down.push(`ALTER TABLE ${q(m[1])} DROP CONSTRAINT ${q(m[2])}`);
+      }
+    } else if (m = /^ALTER\s+TABLE\s+["`']?(\w+)["`']?\s+ADD\s+(?:COLUMN\s+["`']?(\w+)["`']?|["`'](\w+)["`']|(\w+))/i.exec(stmt)) {
+      const column = m[2] ?? m[3] ?? m[4];
+      if (m[4] && /^(?:PRIMARY|UNIQUE|INDEX|KEY|FOREIGN|CHECK|FULLTEXT|SPATIAL)$/i.test(m[4]))
+        skipped.push(stmt);
+      else
+        down.push(`ALTER TABLE ${q(m[1])} DROP COLUMN ${q(column)}`);
     } else if (m = /^CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?["`']?(\w+)["`']?(?:\s+ON\s+["`']?(\w+)["`']?)?/i.exec(stmt)) {
       down.push(isMysqlLike(dialect) && m[2] ? `DROP INDEX ${q(m[1])} ON ${q(m[2])}` : `DROP INDEX IF EXISTS ${q(m[1])}`);
     } else {
@@ -19059,22 +19274,6 @@ function deriveDownStatements(forwardSql, dialect = config5.dialect) {
   }
   return { down: down.reverse(), skipped };
 }
-function findWorkspaceRoot2(startPath) {
-  let currentPath = startPath;
-  while (currentPath !== dirname8(currentPath)) {
-    if (existsSync17(join10(currentPath, "package.json"))) {
-      return currentPath;
-    }
-    currentPath = dirname8(currentPath);
-  }
-  return process26.cwd();
-}
-function getSqlDirectory2(workspaceRoot) {
-  if (!workspaceRoot) {
-    workspaceRoot = findWorkspaceRoot2(process26.cwd());
-  }
-  return join10(workspaceRoot, "database", "migrations");
-}
 async function migrateRollback(options = {}) {
   const steps = options.steps || 1;
   const reverseSchema = options.reverseSchema !== false;
@@ -19107,12 +19306,12 @@ async function migrateRollback(options = {}) {
       console.log(`  - ${migration.migration}`);
     }
     console.log();
-    const sqlDir = getSqlDirectory2();
+    const sqlDir = getSqlDirectory();
     let reversedAny = false;
     for (const migration of migrationsToRollback) {
       try {
-        const filePath = join10(sqlDir, migration.migration);
-        if (reverseSchema && existsSync17(filePath)) {
+        const filePath = join11(sqlDir, migration.migration);
+        if (reverseSchema && existsSync18(filePath)) {
           const forwardSql = readFileSync4(filePath, "utf8");
           const { down, skipped } = deriveDownStatements(forwardSql);
           for (const stmt of down) {
@@ -19123,10 +19322,10 @@ async function migrateRollback(options = {}) {
           if (skipped.length > 0)
             console.log(`-- \u26A0\uFE0F  ${skipped.length} statement(s) in ${migration.migration} could not be auto-reversed (data/complex DDL) \u2014 reverse manually.`);
         }
-        const deleteSql = `DELETE FROM migrations WHERE migration = $1`;
+        const deleteSql = `DELETE FROM migrations WHERE migration = ${getPlaceholder(1)}`;
         await qb.unsafe(deleteSql, [migration.migration]);
         console.log(`-- \u2713 Removed migration record: ${migration.migration}`);
-        if (existsSync17(filePath)) {
+        if (options.deleteFiles && existsSync18(filePath)) {
           unlinkSync2(filePath);
           console.log(`-- \uD83D\uDDD1\uFE0F  Deleted migration file: ${migration.migration}`);
         }
@@ -19149,37 +19348,20 @@ async function migrateRollback(options = {}) {
 var init_migrate_rollback = __esm(() => {
   init_config();
   init_src2();
+  init_workspace();
 });
 
 // src/actions/migrate-status.ts
-import { existsSync as existsSync18, readdirSync as readdirSync8 } from "fs";
-import { dirname as dirname9, join as join11 } from "path";
-import process27 from "process";
-function findWorkspaceRoot3(startPath) {
-  let currentPath = startPath;
-  while (currentPath !== dirname9(currentPath)) {
-    if (existsSync18(join11(currentPath, "package.json"))) {
-      return currentPath;
-    }
-    currentPath = dirname9(currentPath);
-  }
-  return process27.cwd();
-}
-function getSqlDirectory3(workspaceRoot) {
-  if (!workspaceRoot) {
-    workspaceRoot = findWorkspaceRoot3(process27.cwd());
-  }
-  return join11(workspaceRoot, "database", "migrations");
-}
+import { existsSync as existsSync19, readdirSync as readdirSync8 } from "fs";
 async function migrateStatus() {
   const dialect = config5.dialect || "postgres";
   const driver = getDialectDriver(dialect);
-  const sqlDir = getSqlDirectory3();
+  const sqlDir = getSqlDirectory();
   console.log("-- Migration Status");
   console.log(`-- Dialect: ${dialect}`);
   console.log(`-- SQL directory: ${sqlDir}`);
   console.log();
-  if (!existsSync18(sqlDir)) {
+  if (!existsSync19(sqlDir)) {
     console.log("-- No SQL directory found. No migrations have been created yet.");
     return [];
   }
@@ -19200,27 +19382,16 @@ async function migrateStatus() {
       console.log();
     }
     const executedMap = new Map(executedMigrations.map((m) => [m.migration, m.executed_at]));
-    const statuses = migrationFiles.map((file2) => {
-      if (file2.includes("alter-") && file2.includes("-table")) {
-        return {
-          file: file2,
-          status: "transient"
-        };
-      }
-      const executedAt = executedMap.get(file2);
-      return {
-        file: file2,
-        status: executedAt ? "executed" : "pending",
-        executedAt
-      };
-    });
+    const statuses = migrationFiles.map((file2) => ({
+      file: file2,
+      status: executedMap.has(file2) ? "executed" : "pending",
+      executedAt: executedMap.get(file2)
+    }));
     const executed = statuses.filter((s) => s.status === "executed");
     const pending = statuses.filter((s) => s.status === "pending");
-    const transient = statuses.filter((s) => s.status === "transient");
     console.log(`-- Total migrations: ${migrationFiles.length}`);
     console.log(`-- Executed: ${executed.length}`);
     console.log(`-- Pending: ${pending.length}`);
-    console.log(`-- Transient: ${transient.length}`);
     console.log();
     if (executed.length > 0) {
       console.log("\u2713 Executed Migrations:");
@@ -19236,13 +19407,6 @@ async function migrateStatus() {
       }
       console.log();
     }
-    if (transient.length > 0) {
-      console.log("\u26A1 Transient Migrations (ALTER TABLE - not tracked):");
-      for (const migration of transient) {
-        console.log(`  - ${migration.file}`);
-      }
-      console.log();
-    }
     return statuses;
   } catch (err) {
     console.error("-- Failed to get migration status:", err);
@@ -19256,14 +19420,15 @@ var init_migrate_status = __esm(() => {
   init_config();
   init_drivers();
   init_src2();
+  init_workspace();
 });
 
 // src/actions/model-show.ts
 import { readdirSync as readdirSync9 } from "fs";
 import { extname as extname2, join as join12 } from "path";
-import process28 from "process";
+import process26 from "process";
 async function modelShow(modelName, options = {}) {
-  const dir = options.dir || join12(process28.cwd(), "app/Models");
+  const dir = options.dir || join12(process26.cwd(), "app/Models");
   try {
     const files = readdirSync9(dir);
     const modelFile = files.find((f) => {
@@ -19477,9 +19642,9 @@ var init_query_explain_all = __esm(() => {
 // src/actions/relation-diagram.ts
 import { writeFileSync as writeFileSync12 } from "fs";
 import { join as join14 } from "path";
-import process29 from "process";
+import process27 from "process";
 async function relationDiagram(options = {}) {
-  const dir = options.dir || join14(process29.cwd(), "app/Models");
+  const dir = options.dir || join14(process27.cwd(), "app/Models");
   const format = options.format || "mermaid";
   try {
     const models = await loadModels({ modelsDir: dir });
@@ -19599,25 +19764,25 @@ var init_relation_diagram = __esm(() => {
 });
 
 // src/actions/seed.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync9, readdirSync as readdirSync11, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync9, readdirSync as readdirSync11, writeFileSync as writeFileSync13 } from "fs";
 import { dirname as dirname10, join as join15 } from "path";
-import process30 from "process";
-function findWorkspaceRoot4(startPath) {
+import process28 from "process";
+function findWorkspaceRoot3(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname10(currentPath)) {
-    if (existsSync19(join15(currentPath, "package.json"))) {
+    if (existsSync20(join15(currentPath, "package.json"))) {
       return currentPath;
     }
     currentPath = dirname10(currentPath);
   }
-  return process30.cwd();
+  return process28.cwd();
 }
 async function loadSeeders(seedersDir) {
-  if (!existsSync19(seedersDir)) {
+  if (!existsSync20(seedersDir)) {
     console.log(`-- Seeders directory not found: ${seedersDir}`);
     return [];
   }
-  const files = readdirSync11(seedersDir);
+  const files = readdirSync11(seedersDir).sort((a, b) => a.localeCompare(b));
   const seederFiles = files.filter((file2) => (file2.endsWith(".ts") || file2.endsWith(".js")) && file2 !== "index.ts" && file2 !== "index.js");
   const seeders = [];
   for (const file2 of seederFiles) {
@@ -19630,6 +19795,7 @@ async function loadSeeders(seedersDir) {
         if (instance && typeof instance.run === "function") {
           seeders.push({
             name: file2.replace(/\.(ts|js)$/, ""),
+            className: String(SeederClass.name || ""),
             instance
           });
         }
@@ -19642,7 +19808,7 @@ async function loadSeeders(seedersDir) {
   return seeders;
 }
 async function runSeeders(config6 = {}) {
-  const workspaceRoot = findWorkspaceRoot4(process30.cwd());
+  const workspaceRoot = findWorkspaceRoot3(process28.cwd());
   const seedersDir = config6.seedersDir || join15(workspaceRoot, "database/seeders");
   const verbose = config6.verbose ?? true;
   if (verbose) {
@@ -19677,17 +19843,18 @@ async function runSeeders(config6 = {}) {
   }
 }
 async function runSeeder(className, options = {}) {
-  const workspaceRoot = findWorkspaceRoot4(process30.cwd());
+  const workspaceRoot = findWorkspaceRoot3(process28.cwd());
   const seedersDir = join15(workspaceRoot, "database/seeders");
   const verbose = options.verbose ?? true;
   if (verbose) {
     console.log(`-- Running seeder: ${className}`);
   }
   const seeders = await loadSeeders(seedersDir);
-  const seeder = seeders.find((s) => s.name === className);
+  const seeder = seeders.find((s) => s.className === className) ?? seeders.find((s) => s.name === className);
   if (!seeder) {
-    console.error(`-- Seeder not found: ${className}`);
-    throw new Error(`Seeder not found: ${className}`);
+    const known = seeders.map((s) => s.className || s.name).join(", ") || "none";
+    console.error(`-- Seeder not found: ${className}. Available: ${known}`);
+    throw new Error(`Seeder not found: ${className}. Available: ${known}`);
   }
   const qb = createQueryBuilder();
   try {
@@ -19701,9 +19868,9 @@ async function runSeeder(className, options = {}) {
   }
 }
 async function makeSeeder(name) {
-  const workspaceRoot = findWorkspaceRoot4(process30.cwd());
+  const workspaceRoot = findWorkspaceRoot3(process28.cwd());
   const seedersDir = join15(workspaceRoot, "database/seeders");
-  if (!existsSync19(seedersDir)) {
+  if (!existsSync20(seedersDir)) {
     mkdirSync9(seedersDir, { recursive: true });
     console.log(`-- Created seeders directory: ${seedersDir}`);
   }
@@ -19711,7 +19878,7 @@ async function makeSeeder(name) {
   const className = `${baseName}Seeder`;
   const fileName = `${className}.ts`;
   const filePath = join15(seedersDir, fileName);
-  if (existsSync19(filePath)) {
+  if (existsSync20(filePath)) {
     console.error(`-- Seeder already exists: ${filePath}`);
     throw new Error(`Seeder already exists: ${filePath}`);
   }
@@ -19765,7 +19932,7 @@ export default class ${className} extends Seeder {
   console.log(`-- \u2713 Created seeder: ${filePath}`);
 }
 async function freshDatabase(options = {}) {
-  const workspaceRoot = findWorkspaceRoot4(process30.cwd());
+  const workspaceRoot = findWorkspaceRoot3(process28.cwd());
   const modelsDir = options.modelsDir || join15(workspaceRoot, "app/Models");
   const seedersDir = options.seedersDir || join15(workspaceRoot, "database/seeders");
   const verbose = options.verbose ?? true;
@@ -19825,22 +19992,22 @@ var init_unsafe = __esm(() => {
 });
 
 // src/actions/validate.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 import { dirname as dirname11, join as join16 } from "path";
-import process31 from "process";
-function findWorkspaceRoot5(startPath) {
+import process29 from "process";
+function findWorkspaceRoot4(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname11(currentPath)) {
-    if (existsSync20(join16(currentPath, "package.json"))) {
+    if (existsSync21(join16(currentPath, "package.json"))) {
       return currentPath;
     }
     currentPath = dirname11(currentPath);
   }
-  return process31.cwd();
+  return process29.cwd();
 }
 async function validateSchema(dir) {
   if (!dir) {
-    dir = join16(findWorkspaceRoot5(process31.cwd()), "app/Models");
+    dir = join16(findWorkspaceRoot4(process29.cwd()), "app/Models");
   }
   const dialect = config5.dialect || "postgres";
   console.log("-- Validating Schema");
@@ -25091,18 +25258,11 @@ function toSnakeCase(str) {
   snakeCaseCache.set(str, cached);
   return cached;
 }
-function toTableName(modelName) {
+function toTableName2(modelName) {
   let cached = tableNameCache.get(modelName);
   if (cached !== undefined)
     return cached;
-  const snake = toSnakeCase(modelName);
-  if (snake.endsWith("y") && !snake.endsWith("ay") && !snake.endsWith("ey") && !snake.endsWith("oy") && !snake.endsWith("uy")) {
-    cached = snake.slice(0, -1) + "ies";
-  } else if (snake.endsWith("s") || snake.endsWith("x") || snake.endsWith("ch") || snake.endsWith("sh")) {
-    cached = `${snake}es`;
-  } else {
-    cached = `${snake}s`;
-  }
+  cached = toTableName(modelName);
   tableNameCache.set(modelName, cached);
   return cached;
 }
@@ -25187,14 +25347,14 @@ function resolveRelation(definition, relationName) {
   const hasManyModel = findModelName(definition.hasMany);
   if (hasManyModel) {
     const relatedModel = getModelFromRegistry(hasManyModel);
-    const relatedTable = relatedModel?.getTable?.() || toTableName(hasManyModel);
+    const relatedTable = relatedModel?.getTable?.() || toTableName2(hasManyModel);
     const foreignKey = toSnakeCase(parentName) + "_id";
     return { type: "hasMany", relatedModelName: hasManyModel, relatedTable, foreignKey, localKey: parentPk };
   }
   const hasOneModel = findModelName(definition.hasOne);
   if (hasOneModel) {
     const relatedModel = getModelFromRegistry(hasOneModel);
-    const relatedTable = relatedModel?.getTable?.() || toTableName(hasOneModel);
+    const relatedTable = relatedModel?.getTable?.() || toTableName2(hasOneModel);
     const foreignKey = toSnakeCase(parentName) + "_id";
     return { type: "hasOne", relatedModelName: hasOneModel, relatedTable, foreignKey, localKey: parentPk };
   }
@@ -25202,7 +25362,7 @@ function resolveRelation(definition, relationName) {
   if (belongsToEntry) {
     const belongsToModel = belongsToEntry.model;
     const relatedModel = getModelFromRegistry(belongsToModel);
-    const relatedTable = relatedModel?.getTable?.() || toTableName(belongsToModel);
+    const relatedTable = relatedModel?.getTable?.() || toTableName2(belongsToModel);
     const relatedPk = relatedModel?.getDefinition?.()?.primaryKey || "id";
     const foreignKey = belongsToEntry.foreignKey || `${toSnakeCase(belongsToModel)}_id`;
     return { type: "belongsTo", relatedModelName: belongsToModel, relatedTable, foreignKey, localKey: relatedPk };
@@ -25212,7 +25372,7 @@ function resolveRelation(definition, relationName) {
     const isConfig = typeof found.entry === "object";
     const relatedModelName = isConfig ? found.entry.model : found.entry;
     const relatedModel = getModelFromRegistry(relatedModelName);
-    const relatedTable = relatedModel?.getTable?.() || toTableName(relatedModelName);
+    const relatedTable = relatedModel?.getTable?.() || toTableName2(relatedModelName);
     const config6 = isConfig ? found.entry : null;
     let pivotTable;
     let pivotModelName;
@@ -25224,7 +25384,7 @@ function resolveRelation(definition, relationName) {
       if (!throughModel) {
         throw new Error(`[orm] belongsToMany relation '${relationName}' on '${parentName}' references unknown through model '${config6.through}'. Make sure '${config6.through}' is registered.`);
       }
-      pivotTable = throughModel.getTable?.() || throughModel.getDefinition?.()?.table || toTableName(config6.through);
+      pivotTable = throughModel.getTable?.() || throughModel.getDefinition?.()?.table || toTableName2(config6.through);
     } else {
       const a2 = singularizeWord(parentTable);
       const b2 = singularizeWord(relatedTable);
@@ -25275,10 +25435,10 @@ function resolveRelation(definition, relationName) {
       return null;
     const throughModel = getModelFromRegistry(throughModelName);
     const throughDef = throughModel?.getDefinition?.() || throughModel?.definition;
-    const throughTable = throughModel?.getTable?.() || throughDef?.table || toTableName(throughModelName);
+    const throughTable = throughModel?.getTable?.() || throughDef?.table || toTableName2(throughModelName);
     const throughPk = throughDef?.primaryKey || "id";
     const targetModel = getModelFromRegistry(targetModelName);
-    const targetTable = targetModel?.getTable?.() || toTableName(targetModelName);
+    const targetTable = targetModel?.getTable?.() || toTableName2(targetModelName);
     return {
       type,
       relatedModelName: targetModelName,
@@ -27875,7 +28035,7 @@ function buildDatabaseSchema(models) {
   for (const modelName of Object.keys(models)) {
     const rawModel = models[modelName];
     const m2 = rawModel.definition ?? rawModel.getDefinition?.() ?? rawModel;
-    const table = m2.table || `${String(m2.name).toLowerCase()}s`;
+    const table = tableNameFor(m2);
     const attrs = m2.attributes ?? {};
     const columns = {};
     for (const key of Object.keys(attrs))
@@ -27887,30 +28047,53 @@ function buildDatabaseSchema(models) {
   }
   return schema;
 }
+var init_factory = () => {};
 
 // src/loader.ts
-import { readdirSync as readdirSync12, statSync as statSync5 } from "fs";
-import { basename, extname as extname4 } from "path";
-import process33 from "process";
-async function loadModels(options) {
-  const cwd = options.cwd ?? process33.cwd();
-  const dir = options.modelsDir.startsWith("/") ? options.modelsDir : `${cwd}/${options.modelsDir}`;
-  const result = {};
-  const entries = readdirSync12(dir);
+import { readdirSync as readdirSync12 } from "fs";
+import { basename, extname as extname4, isAbsolute as isAbsolute3, join as join17 } from "path";
+import process30 from "process";
+function isModelFile(name) {
+  const ext = extname4(name);
+  if (!MODEL_EXTENSIONS.has(ext))
+    return false;
+  const base = basename(name, ext);
+  if (base.startsWith("_") || base === "index")
+    return false;
+  return !base.endsWith(".d");
+}
+function isModelDefinition(def) {
+  if (!def || typeof def !== "object")
+    return false;
+  const d2 = def;
+  return typeof d2.name === "string" || typeof d2.table === "string";
+}
+function collectModelFiles(dir) {
+  const files = [];
+  const entries = readdirSync12(dir, { withFileTypes: true }).sort((a2, b2) => a2.name.localeCompare(b2.name));
   for (const entry of entries) {
-    const full = `${dir}/${entry}`;
-    const st = statSync5(full);
-    if (st.isDirectory())
-      continue;
-    const ext = extname4(full);
-    if (![".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"].includes(ext))
+    const full = join17(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectModelFiles(full));
       continue;
+    }
+    if (isModelFile(entry.name))
+      files.push(full);
+  }
+  return files;
+}
+async function loadModels(options) {
+  const cwd = options.cwd ?? process30.cwd();
+  const dir = isAbsolute3(options.modelsDir) ? options.modelsDir : join17(cwd, options.modelsDir);
+  const result = {};
+  for (const full of collectModelFiles(dir)) {
     const cacheBuster = `?t=${Date.now()}-${Math.random().toString(36).slice(2)}`;
     const mod = await import(`${full}${cacheBuster}`);
     const rawDef = mod.default ?? mod;
     const def = rawDef.definition ?? rawDef.getDefinition?.() ?? rawDef;
-    const fileName = basename(entry, ext);
-    const name = def.name ?? fileName;
+    if (!isModelDefinition(def))
+      continue;
+    const name = def.name ?? basename(full, extname4(full));
     result[name] = {
       ...def,
       name
@@ -27918,7 +28101,10 @@ async function loadModels(options) {
   }
   return result;
 }
-var init_loader = () => {};
+var MODEL_EXTENSIONS;
+var init_loader = __esm(() => {
+  MODEL_EXTENSIONS = new Set([".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"]);
+});
 
 // src/meta.ts
 function buildSchemaMeta(models) {
@@ -27930,7 +28116,7 @@ function buildSchemaMeta(models) {
   for (const name of Object.keys(models)) {
     const rawModel = models[name];
     const m2 = rawModel.definition ?? rawModel.getDefinition?.() ?? rawModel;
-    const table = m2.table || `${String(m2.name).toLowerCase()}s`;
+    const table = tableNameFor(m2);
     modelToTable[name] = table;
     tableToModel[table] = name;
     primaryKeys[table] = m2.primaryKey ?? "id";
@@ -28004,9 +28190,9 @@ function buildSchemaMeta(models) {
 var init_meta = () => {};
 
 // src/migrations.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync10, writeFileSync as writeFileSync14 } from "fs";
-import { dirname as dirname12, join as join17 } from "path";
-import process35 from "process";
+import { existsSync as existsSync23, mkdirSync as mkdirSync10, readdirSync as readdirSync13, readFileSync as readFileSync6, writeFileSync as writeFileSync14 } from "fs";
+import { dirname as dirname12, join as join18 } from "path";
+import process31 from "process";
 function info2(message) {
   if (config5.verbose)
     console.log(message);
@@ -28017,36 +28203,80 @@ function snakeCase(str) {
 function singularizeTable(table) {
   return singularizerFor(config5.relations?.singularizeStrategy)(table);
 }
-function findWorkspaceRoot6(startPath) {
+function lastCreatedMigrationFiles() {
+  return [...createdMigrationFiles];
+}
+function findWorkspaceRoot5(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname12(currentPath)) {
-    if (existsSync21(join17(currentPath, "package.json"))) {
+    if (existsSync23(join18(currentPath, "package.json"))) {
       return currentPath;
     }
     currentPath = dirname12(currentPath);
   }
-  return process35.cwd();
+  return process31.cwd();
 }
 function ensureSqlDirectory2() {
-  const workspaceRoot = findWorkspaceRoot6(process35.cwd());
-  const sqlDir = join17(workspaceRoot, "database", "migrations");
-  if (!existsSync21(sqlDir)) {
+  const workspaceRoot = findWorkspaceRoot5(process31.cwd());
+  const sqlDir = join18(workspaceRoot, "database", "migrations");
+  if (!existsSync23(sqlDir)) {
     mkdirSync10(sqlDir, { recursive: true });
     info2(`-- Created SQL directory: ${sqlDir}`);
   }
   return sqlDir;
 }
+function isGeneratedMigrationSql(sql2) {
+  return sql2.trimStart().startsWith(GENERATED_MARKER);
+}
+function migrationBody(sql2) {
+  return sql2.split(`
+`).filter((line) => !line.trimStart().startsWith("--")).join(`
+`).replace(/\s+/g, " ").trim().replace(/;+$/, "");
+}
+function existingMigrationBodies(sqlDir) {
+  const bodies = new Set;
+  let files;
+  try {
+    files = readdirSync13(sqlDir).filter((f2) => f2.endsWith(".sql"));
+  } catch {
+    return bodies;
+  }
+  for (const file2 of files) {
+    try {
+      bodies.add(migrationBody(readFileSync6(join18(sqlDir, file2), "utf8")));
+    } catch {}
+  }
+  return bodies;
+}
 function createMigrationFile(statement, fileName) {
   if (!statement)
     return false;
   const sqlDir = ensureSqlDirectory2();
+  if (existingCorpusBodies === null)
+    existingCorpusBodies = existingMigrationBodies(sqlDir);
+  const body = migrationBody(statement);
+  if (body.length > 0 && existingCorpusBodies.has(body)) {
+    info2(`-- Migration already in the corpus, not writing it again: ${fileName}`);
+    return false;
+  }
   migrationCounter++;
-  const sequence = useDeterministicNames ? String(migrationCounter).padStart(10, "0") : String(Math.floor(Date.now() / 1000) + migrationCounter);
-  const fullFileName = `${sequence}-${fileName}.sql`;
-  const filePath = join17(sqlDir, fullFileName);
-  writeFileSync14(filePath, statement);
+  let sequence = useDeterministicNames ? String(migrationCounter).padStart(10, "0") : String(Math.floor(Date.now() / 1000) + migrationCounter);
+  let fullFileName = `${sequence}-${fileName}.sql`;
+  if (!useDeterministicNames) {
+    let next = Number(sequence);
+    while (existsSync23(join18(sqlDir, fullFileName))) {
+      next += 1;
+      sequence = String(next);
+      fullFileName = `${sequence}-${fileName}.sql`;
+    }
+  }
+  const filePath = join18(sqlDir, fullFileName);
+  writeFileSync14(filePath, `${GENERATED_MARKER}
+${statement}`);
   info2(`-- Migration file created: ${fullFileName}`);
   migrationsCreatedCount++;
+  createdMigrationFiles.push(fullFileName);
+  existingCorpusBodies?.add(body);
   return true;
 }
 function guessTypeFromName(columnName) {
@@ -28221,7 +28451,7 @@ function buildMigrationPlan2(models, options) {
   const tables = [];
   for (const modelName of Object.keys(models)) {
     const model = models[modelName];
-    const table = model.table || `${String(model.name).toLowerCase()}s`;
+    const table = tableNameFor(model);
     const primaryKey = model.primaryKey ?? "id";
     const _autoIncrement = model.autoIncrement !== false;
     const attrs = model.attributes ?? {};
@@ -28237,6 +28467,23 @@ function buildMigrationPlan2(models, options) {
         hasDefault: false
       });
     }
+    const declaredFkTargets = new Map;
+    const declaresBelongsTo = normalizeRelationList(model.belongsTo).length > 0;
+    const columnNames = new Set(Object.keys(attrs).map((name) => snakeCase(name)));
+    const polymorphicColumns = new Set;
+    for (const column of columnNames) {
+      if (!column.endsWith("_type"))
+        continue;
+      const idColumn = `${column.slice(0, -"_type".length)}_id`;
+      if (columnNames.has(idColumn))
+        polymorphicColumns.add(idColumn);
+    }
+    for (const rel of normalizeRelationList(model.belongsTo)) {
+      const column = rel.foreignKey ?? `${snakeCase(rel.model)}_id`;
+      const table2 = meta.modelToTable[rel.model];
+      if (table2)
+        declaredFkTargets.set(column, table2);
+    }
     for (const attrName of Object.keys(attrs)) {
       const attr = attrs[attrName];
       const columnName = snakeCase(attrName);
@@ -28284,7 +28531,7 @@ function buildMigrationPlan2(models, options) {
         enumValues,
         maxLength: typeof maxLen === "number" && maxLen > 0 && maxLen <= 255 ? maxLen : undefined
       };
-      if (columnName.endsWith("_id") && attr.foreignKey !== false) {
+      if (columnName.endsWith("_id") && attr.foreignKey !== false && !polymorphicColumns.has(columnName)) {
         if (typeof attr.foreignKey === "object" && attr.foreignKey !== null) {
           const fkConfig = attr.foreignKey;
           col.references = {
@@ -28296,9 +28543,10 @@ function buildMigrationPlan2(models, options) {
           if (fkConfig.nullable !== undefined)
             col.isNullable = fkConfig.nullable;
         } else {
+          const declared = declaredFkTargets.get(columnName);
           const base = columnName.replace(/_id$/, "");
           const maybeModel = base.replace(/(^|_)([a-z])/g, (_2, __, c2) => c2.toUpperCase());
-          const refTable = meta.modelToTable[maybeModel];
+          const refTable = declared ?? (declaresBelongsTo ? undefined : meta.modelToTable[maybeModel]);
           if (refTable) {
             const refPk = meta.primaryKeys[refTable] ?? "id";
             col.references = { table: refTable, column: refPk };
@@ -28313,9 +28561,7 @@ function buildMigrationPlan2(models, options) {
       if (columns.some((c2) => c2.name === fkColumnName))
         continue;
       const refTable = meta.modelToTable[rel.model];
-      if (!refTable)
-        continue;
-      const refPk = meta.primaryKeys[refTable] ?? "id";
+      const refPk = refTable ? meta.primaryKeys[refTable] ?? "id" : undefined;
       columns.push({
         name: fkColumnName,
         type: "bigint",
@@ -28323,7 +28569,7 @@ function buildMigrationPlan2(models, options) {
         isUnique: false,
         isNullable: true,
         hasDefault: false,
-        references: { table: refTable, column: refPk, onDelete: rel.onDelete }
+        references: refTable && refPk && !polymorphicColumns.has(fkColumnName) ? { table: refTable, column: refPk, onDelete: rel.onDelete } : undefined
       });
     }
     const traits = model.traits;
@@ -28404,7 +28650,7 @@ function buildMigrationPlan2(models, options) {
   for (const modelName of Object.keys(models)) {
     const model = models[modelName];
     const traits = model?.traits ?? {};
-    const modelTable = model.table || `${String(model.name).toLowerCase()}s`;
+    const modelTable = tableNameFor(model);
     const singular = singularizeTable(modelTable);
     if (traits.likeable) {
       const opts = typeof traits.likeable === "object" ? traits.likeable : {};
@@ -28424,7 +28670,7 @@ function buildMigrationPlan2(models, options) {
     }
     if (traits.taggable) {
       ensureTable({
-        table: "taggable",
+        table: "taggables",
         columns: [
           { name: "id", type: "bigint", isPrimaryKey: true, isUnique: false, isNullable: false, hasDefault: false },
           { name: "name", type: "string", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: false },
@@ -28432,37 +28678,61 @@ function buildMigrationPlan2(models, options) {
           { name: "description", type: "text", isPrimaryKey: false, isUnique: false, isNullable: true, hasDefault: false },
           { name: "order", type: "integer", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: true, defaultValue: 0 },
           { name: "is_active", type: "boolean", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: true, defaultValue: true },
+          { name: "taggable_id", type: "bigint", isPrimaryKey: false, isUnique: false, isNullable: true, hasDefault: false },
+          { name: "taggable_type", type: "string", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: false },
+          { name: "created_at", type: "datetime", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: true, defaultValue: "CURRENT_TIMESTAMP" },
+          { name: "updated_at", type: "datetime", isPrimaryKey: false, isUnique: false, isNullable: true, hasDefault: false }
+        ],
+        indexes: [
+          { name: "taggables_target_index", columns: ["taggable_id", "taggable_type"], type: "index" },
+          { name: "taggables_type_slug_unique", columns: ["taggable_type", "slug"], type: "unique" }
+        ]
+      });
+      ensureTable({
+        table: "taggable_models",
+        columns: [
+          { name: "id", type: "bigint", isPrimaryKey: true, isUnique: false, isNullable: false, hasDefault: false },
+          { name: "tag_id", type: "bigint", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: false, references: { table: "taggables", column: "id" } },
           { name: "taggable_id", type: "bigint", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: false },
           { name: "taggable_type", type: "string", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: false },
           { name: "created_at", type: "datetime", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: true, defaultValue: "CURRENT_TIMESTAMP" },
           { name: "updated_at", type: "datetime", isPrimaryKey: false, isUnique: false, isNullable: true, hasDefault: false }
         ],
-        indexes: [{ name: "taggable_target_index", columns: ["taggable_id", "taggable_type"], type: "index" }]
+        indexes: [
+          { name: "taggable_models_owner_unique", columns: ["tag_id", "taggable_id", "taggable_type"], type: "unique" },
+          { name: "taggable_models_target_index", columns: ["taggable_id", "taggable_type"], type: "index" }
+        ]
       });
     }
     if (traits.categorizable) {
       ensureTable({
-        table: "categorizable",
+        table: "categorizables",
         columns: [
           { name: "id", type: "bigint", isPrimaryKey: true, isUnique: false, isNullable: false, hasDefault: false },
           { name: "name", type: "string", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: false },
           { name: "slug", type: "string", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: false },
           { name: "description", type: "text", isPrimaryKey: false, isUnique: false, isNullable: true, hasDefault: false },
+          { name: "is_active", type: "boolean", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: true, defaultValue: true },
+          { name: "categorizable_type", type: "string", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: false },
           { name: "created_at", type: "datetime", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: true, defaultValue: "CURRENT_TIMESTAMP" },
           { name: "updated_at", type: "datetime", isPrimaryKey: false, isUnique: false, isNullable: true, hasDefault: false }
         ],
-        indexes: [{ name: "categorizable_slug_unique", columns: ["slug"], type: "unique" }]
+        indexes: [{ name: "categorizables_type_slug_unique", columns: ["categorizable_type", "slug"], type: "unique" }]
       });
       ensureTable({
         table: "categorizable_models",
         columns: [
           { name: "id", type: "bigint", isPrimaryKey: true, isUnique: false, isNullable: false, hasDefault: false },
-          { name: "category_id", type: "bigint", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: false, references: { table: "categorizable", column: "id" } },
+          { name: "category_id", type: "bigint", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: false, references: { table: "categorizables", column: "id" } },
           { name: "categorizable_id", type: "bigint", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: false },
           { name: "categorizable_type", type: "string", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: false },
-          { name: "created_at", type: "datetime", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: true, defaultValue: "CURRENT_TIMESTAMP" }
+          { name: "created_at", type: "datetime", isPrimaryKey: false, isUnique: false, isNullable: false, hasDefault: true, defaultValue: "CURRENT_TIMESTAMP" },
+          { name: "updated_at", type: "datetime", isPrimaryKey: false, isUnique: false, isNullable: true, hasDefault: false }
         ],
-        indexes: [{ name: "categorizable_models_target_index", columns: ["categorizable_id", "categorizable_type"], type: "index" }]
+        indexes: [
+          { name: "categorizable_models_owner_unique", columns: ["category_id", "categorizable_id", "categorizable_type"], type: "unique" },
+          { name: "categorizable_models_target_index", columns: ["categorizable_id", "categorizable_type"], type: "index" }
+        ]
       });
     }
   }
@@ -28471,7 +28741,7 @@ function buildMigrationPlan2(models, options) {
     const btm = model?.belongsToMany;
     if (!btm || typeof btm !== "object" || Array.isArray(btm))
       continue;
-    const parentTable = model.table || `${String(model.name).toLowerCase()}s`;
+    const parentTable = tableNameFor(model);
     const parentSingular = singularizeTable(parentTable);
     for (const [relKey, value] of Object.entries(btm)) {
       const cfg = value;
@@ -28532,6 +28802,8 @@ function generateSql(plan, opts = {}) {
   migrationCounter = 0;
   migrationsCreatedCount = 0;
   migrationsUpdatedCount = 0;
+  createdMigrationFiles = [];
+  existingCorpusBodies = null;
   useDeterministicNames = true;
   const emit = opts.dryRun ? () => false : createMigrationFile;
   const statements = [];
@@ -28793,12 +29065,13 @@ function referencesAreDifferent(r1, r2) {
   const act = (a2) => (a2 ?? "no action").toLowerCase();
   return r1.table !== r2.table || r1.column !== r2.column || act(r1.onDelete) !== act(r2.onDelete) || act(r1.onUpdate) !== act(r2.onUpdate);
 }
-function mapIndexesByKey(indexes) {
+function indexKey(index, table) {
+  return `${index.type}:${qualifiedIndexName(table, index.name)}:${index.columns.join(",")}`;
+}
+function mapIndexesByKey(indexes, table) {
   const map = {};
-  for (const i2 of indexes) {
-    const key = `${i2.type}:${i2.name}:${i2.columns.join(",")}`;
-    map[key] = i2;
-  }
+  for (const i2 of indexes)
+    map[indexKey(i2, table)] = i2;
   return map;
 }
 function generateDiffOperations(previous, next, opts = {}) {
@@ -28813,10 +29086,13 @@ function generateDiffOperations(previous, next, opts = {}) {
     return { statements: statements2, operations: operations2 };
   }
   const applyRenames = opts.applyRenames !== false;
+  const preserveUnknownColumns = opts.preserveUnknownColumns === true;
   const emit = opts.dryRun ? () => false : createMigrationFile;
   migrationCounter = 0;
   migrationsCreatedCount = 0;
   migrationsUpdatedCount = 0;
+  createdMigrationFiles = [];
+  existingCorpusBodies = null;
   useDeterministicNames = false;
   const chunks = [];
   const operations = [];
@@ -28895,42 +29171,52 @@ function generateDiffOperations(previous, next, opts = {}) {
     const prevCols = mapColumnsByName(prev.columns);
     const currCols = mapColumnsByName(curr.columns);
     for (const colName of Object.keys(currCols)) {
-      if (!prevCols[colName]) {
-        const c2 = currCols[colName];
-        if (c2.type === "enum" && c2.enumValues && c2.enumValues.length > 0) {
-          const enumTypeName = `${curr.table}_${c2.name}_type`;
-          c2.enumTypeName = enumTypeName;
-          if (!enumTypes.has(enumTypeName)) {
-            const createEnumStatement = driver.createEnumType(enumTypeName, c2.enumValues);
-            if (createEnumStatement) {
-              chunks.push(createEnumStatement);
-              operations.push({ kind: "create_enum", table: curr.table, column: c2.name, destructive: false, sql: createEnumStatement });
-              emit(createEnumStatement, `create-${enumTypeName}-enum`);
-            }
-            enumTypes.add(enumTypeName);
-          }
+      const c2 = currCols[colName];
+      if (c2.type !== "enum" || !c2.enumValues || c2.enumValues.length === 0)
+        continue;
+      const enumTypeName = `${curr.table}_${c2.name}_type`;
+      c2.enumTypeName = enumTypeName;
+      if (prevCols[colName])
+        continue;
+      if (!enumTypes.has(enumTypeName)) {
+        const createEnumStatement = driver.createEnumType(enumTypeName, c2.enumValues);
+        if (createEnumStatement) {
+          chunks.push(createEnumStatement);
+          operations.push({ kind: "create_enum", table: curr.table, column: c2.name, destructive: false, sql: createEnumStatement });
+          emit(createEnumStatement, `create-${enumTypeName}-enum`);
         }
+        enumTypes.add(enumTypeName);
       }
     }
   }
   for (const tableName of Object.keys(nextTables)) {
     const prev = prevTables[tableName];
-    const curr = nextTables[tableName];
+    let curr = nextTables[tableName];
     if (!prev)
       continue;
     const prevCols = mapColumnsByName(prev.columns);
-    const currCols = mapColumnsByName(curr.columns);
-    const prevIdx = mapIndexesByKey(prev.indexes);
-    const currIdx = mapIndexesByKey(curr.indexes);
+    const prevIdx = mapIndexesByKey(prev.indexes, prev.table);
+    let currCols = mapColumnsByName(curr.columns);
+    let currIdx = mapIndexesByKey(curr.indexes, curr.table);
     let renames = [];
     let removedCols = Object.keys(prevCols).filter((n2) => !currCols[n2]);
     let addedCols = Object.keys(currCols).filter((n2) => !prevCols[n2]);
-    if (applyRenames) {
+    if (applyRenames && !preserveUnknownColumns) {
       const detected = detectColumnRenames(prevCols, currCols, dialect);
       renames = detected.renames;
       removedCols = detected.removed;
       addedCols = detected.added;
     }
+    if (preserveUnknownColumns && removedCols.length > 0) {
+      const preserved = removedCols.map((name) => prevCols[name]);
+      const preservedNames = new Set(removedCols);
+      const keptIndexes = prev.indexes.filter((idx) => idx.columns.some((c2) => preservedNames.has(c2)) && !currIdx[indexKey(idx)]);
+      info2(`-- Keeping ${preserved.length} column(s) on "${curr.table}" no model declares: ${removedCols.join(", ")} \u2014 reconciled from the database, where an undeclared column is out of scope rather than removed`);
+      curr = { ...curr, columns: [...curr.columns, ...preserved], indexes: [...curr.indexes, ...keptIndexes] };
+      currCols = mapColumnsByName(curr.columns);
+      currIdx = mapIndexesByKey(curr.indexes, curr.table);
+      removedCols = [];
+    }
     const modifiedCols = Object.keys(currCols).filter((n2) => prevCols[n2] && columnsAreDifferent(prevCols[n2], currCols[n2], dialect));
     const fkChangedCols = Object.keys(currCols).filter((n2) => prevCols[n2] && referencesAreDifferent(prevCols[n2].references, currCols[n2].references));
     if (dialect === "sqlite") {
@@ -29078,11 +29364,13 @@ function generateDiffOperations(previous, next, opts = {}) {
 function generateDiffSql(previous, next, opts = {}) {
   return generateDiffOperations(previous, next, opts).statements;
 }
-var migrationCounter = 0, migrationsCreatedCount = 0, migrationsUpdatedCount = 0, useDeterministicNames = true;
+var migrationCounter = 0, migrationsCreatedCount = 0, migrationsUpdatedCount = 0, useDeterministicNames = true, createdMigrationFiles, existingCorpusBodies = null, GENERATED_MARKER = "-- qb:generated";
 var init_migrations = __esm(() => {
   init_config();
   init_drivers();
+  init_sqlite();
   init_meta();
+  createdMigrationFiles = [];
 });
 
 // src/schema.ts
@@ -29116,6 +29404,7 @@ var init_src2 = __esm(() => {
   init_dynamodb_single_table();
   init_dynamodb_tooling_adapter();
   init_dynamodb();
+  init_factory();
   init_loader();
   init_meta();
   init_migrations();
@@ -29125,11 +29414,11 @@ var init_src2 = __esm(() => {
 });
 
 // ../../node_modules/@stacksjs/clapp/dist/index.js
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import fs from "fs/promises";
 import os from "os";
 import path from "path";
-import process36 from "process";
+import process33 from "process";
 import { EventEmitter } from "events";
 import process52 from "process";
 import process210 from "process";
@@ -29153,10 +29442,10 @@ class Telemetry {
     this.configPath = path.join(configDir, "telemetry.json");
   }
   async isEnabled() {
-    if (process36.env.DO_NOT_TRACK === "1" || process36.env.DO_NOT_TRACK === "true") {
+    if (process33.env.DO_NOT_TRACK === "1" || process33.env.DO_NOT_TRACK === "true") {
       return false;
     }
-    if (process36.env.NO_TELEMETRY === "1" || process36.env.NO_TELEMETRY === "true") {
+    if (process33.env.NO_TELEMETRY === "1" || process33.env.NO_TELEMETRY === "true") {
       return false;
     }
     const config6 = await this.loadConfig();
@@ -29185,7 +29474,7 @@ class Telemetry {
       ...data,
       timestamp: Date.now(),
       platform: os.platform(),
-      nodeVersion: process36.version
+      nodeVersion: process33.version
     };
     this.events.push(telemetryEvent);
     if (this.events.length >= 10) {
@@ -29241,7 +29530,7 @@ class Telemetry {
     const config6 = await this.loadConfig();
     return {
       enabled: config6.enabled,
-      doNotTrack: process36.env.DO_NOT_TRACK === "1" || process36.env.DO_NOT_TRACK === "true",
+      doNotTrack: process33.env.DO_NOT_TRACK === "1" || process33.env.DO_NOT_TRACK === "true",
       eventsQueued: this.events.length,
       lastSent: config6.lastSent
     };
@@ -29251,7 +29540,7 @@ class Telemetry {
       return this.config;
     }
     try {
-      if (existsSync23(this.configPath)) {
+      if (existsSync25(this.configPath)) {
         const data = await fs.readFile(this.configPath, "utf-8");
         this.config = JSON.parse(data);
         return this.config;
@@ -31163,7 +31452,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version2 = "0.1.63";
+var version2 = "0.2.2";
 
 // bin/cli.ts
 init_actions();
@@ -31218,7 +31507,7 @@ cli.command("unsafe <sql>", "Execute an unsafe SQL string (one statement with pa
 cli.command("file <path>", "Execute a SQL file (supports $1, $2 params)").option("--params <json>", "JSON array of parameters").example("query-builder file ./migrations/seed.sql").example('query-builder file ./reports/top.sql --params "[30]"').action(async (path2, opts) => {
   await file(path2, opts);
 });
-cli.command("migrate <dir>", "Generate SQL migrations from models").option("--dialect <d>", "Dialect (postgres|mysql|sqlite)", { default: "postgres" }).option("--state <path>", "Path to migration state file (defaults to <dir>/.qb-migrations.<dialect>.json)").option("--apply", "Execute the generated SQL against the database").option("--full", "Force full migration SQL instead of incremental diff").example("query-builder migrate ./app/Models --dialect postgres").action(async (dir, opts) => {
+cli.command("migrate <dir>", "Generate SQL migrations from models").option("--dialect <d>", "Dialect (postgres|mysql|sqlite) \u2014 defaults to the configured dialect").option("--state <path>", "Path to migration state file (defaults to <dir>/.qb-migrations.<dialect>.json)").option("--apply", "Execute the generated SQL against the database").option("--full", "Force full migration SQL instead of incremental diff").example("query-builder migrate ./app/Models --dialect postgres").action(async (dir, opts) => {
   try {
     await generateMigration(dir, {
       dialect: opts.dialect,
@@ -31262,7 +31551,7 @@ cli.command("relation:diagram", "Generate relationship diagram from models").opt
     proc.default.exitCode = 1;
   }
 });
-cli.command("migrate:fresh <dir>", "Reset database and run all migrations").option("--dialect <d>", "Dialect (postgres|mysql|sqlite)", { default: "postgres" }).option("--state <path>", "Path to migration state file (defaults to <dir>/.qb-migrations.<dialect>.json)").option("--full", "Force full migration SQL instead of incremental diff").example("query-builder migrate:fresh ./app/Models --dialect postgres").action(async (dir, opts) => {
+cli.command("migrate:fresh <dir>", "Reset database and run all migrations").option("--dialect <d>", "Dialect (postgres|mysql|sqlite) \u2014 defaults to the configured dialect").option("--state <path>", "Path to migration state file (defaults to <dir>/.qb-migrations.<dialect>.json)").option("--full", "Force full migration SQL instead of incremental diff").example("query-builder migrate:fresh ./app/Models --dialect postgres").action(async (dir, opts) => {
   try {
     console.log("-- Resetting database...");
     await resetDatabase(dir, {
@@ -31283,7 +31572,7 @@ cli.command("migrate:fresh <dir>", "Reset database and run all migrations").opti
     proc.default.exitCode = 1;
   }
 });
-cli.command("reset <dir>", "Drop all tables and reset database").option("--dialect <d>", "Dialect (postgres|mysql|sqlite)", { default: "postgres" }).option("--state <path>", "Path to migration state file (defaults to <dir>/.qb-migrations.<dialect>.json)").example("query-builder reset ./app/Models --dialect postgres").action(async (dir, opts) => {
+cli.command("reset <dir>", "Drop all tables and reset database").option("--dialect <d>", "Dialect (postgres|mysql|sqlite) \u2014 defaults to the configured dialect").option("--state <path>", "Path to migration state file (defaults to <dir>/.qb-migrations.<dialect>.json)").example("query-builder reset ./app/Models --dialect postgres").action(async (dir, opts) => {
   try {
     await resetDatabase(dir, {
       dialect: opts.dialect,
@@ -31387,16 +31676,20 @@ cli.command("migrate:list", "List all migrations (alias for migrate:status)").ex
     proc.default.exitCode = 1;
   }
 });
-cli.command("migrate:rollback", "Rollback migrations").option("--steps <n>", "Number of migrations to rollback", { default: 1 }).example("query-builder migrate:rollback").example("query-builder migrate:rollback --steps 2").action(async (opts) => {
+cli.command("migrate:rollback", "Rollback migrations").option("--steps <n>", "Number of migrations to rollback", { default: 1 }).option("--no-reverse-schema", "Only remove the migration records; leave the schema alone").option("--delete-files", "Also delete the rolled-back migration files from disk").example("query-builder migrate:rollback").example("query-builder migrate:rollback --steps 2").example("query-builder migrate:rollback --no-reverse-schema").action(async (opts) => {
   try {
-    await migrateRollback({ steps: Number(opts.steps) });
+    await migrateRollback({
+      steps: Number(opts.steps),
+      reverseSchema: opts.reverseSchema,
+      deleteFiles: Boolean(opts.deleteFiles)
+    });
   } catch (err) {
     console.error("-- Rollback failed:", err);
     const proc = await import("process");
     proc.default.exitCode = 1;
   }
 });
-cli.command("migrate:generate [dir]", "Generate migration from model changes").option("--dialect <d>", "Dialect (postgres|mysql|sqlite)", { default: "postgres" }).option("--state <path>", "Path to migration state file").option("--apply", "Execute the generated SQL").option("--full", "Force full migration SQL").example("query-builder migrate:generate").example("query-builder migrate:generate ./app/Models --dialect postgres").action(async (dir, opts) => {
+cli.command("migrate:generate [dir]", "Generate migration from model changes").option("--dialect <d>", "Dialect (postgres|mysql|sqlite) \u2014 defaults to the configured dialect").option("--state <path>", "Path to migration state file").option("--apply", "Execute the generated SQL").option("--full", "Force full migration SQL").example("query-builder migrate:generate").example("query-builder migrate:generate ./app/Models --dialect postgres").action(async (dir, opts) => {
   try {
     await migrateGenerate(dir, {
       dialect: opts?.dialect,
@@ -31428,7 +31721,7 @@ cli.command("db:stats", "Show database statistics (alias for db:info)").example(
     proc.default.exitCode = 1;
   }
 });
-cli.command("db:wipe", "Drop all tables from the database").option("--dialect <d>", "Dialect (postgres|mysql|sqlite)", { default: "postgres" }).option("--force", "Skip confirmation prompt").option("--verbose", "Enable verbose output").example("query-builder db:wipe").example("query-builder db:wipe --force").action(async (opts) => {
+cli.command("db:wipe", "Drop all tables from the database").option("--dialect <d>", "Dialect (postgres|mysql|sqlite) \u2014 defaults to the configured dialect").option("--force", "Skip confirmation prompt").option("--verbose", "Enable verbose output").example("query-builder db:wipe").example("query-builder db:wipe --force").action(async (opts) => {
   try {
     await dbWipe({
       dialect: opts.dialect,
@@ -31441,7 +31734,7 @@ cli.command("db:wipe", "Drop all tables from the database").option("--dialect <d
     proc.default.exitCode = 1;
   }
 });
-cli.command("db:optimize", "Optimize database tables (VACUUM, ANALYZE, OPTIMIZE)").option("--dialect <d>", "Dialect (postgres|mysql|sqlite)", { default: "postgres" }).option("--aggressive", "Use aggressive optimization (VACUUM FULL for postgres)").option("--tables <tables>", "Comma-separated list of tables to optimize").option("--verbose", "Enable verbose output").example("query-builder db:optimize").example("query-builder db:optimize --aggressive").example("query-builder db:optimize --tables users,posts").action(async (opts) => {
+cli.command("db:optimize", "Optimize database tables (VACUUM, ANALYZE, OPTIMIZE)").option("--dialect <d>", "Dialect (postgres|mysql|sqlite) \u2014 defaults to the configured dialect").option("--aggressive", "Use aggressive optimization (VACUUM FULL for postgres)").option("--tables <tables>", "Comma-separated list of tables to optimize").option("--verbose", "Enable verbose output").example("query-builder db:optimize").example("query-builder db:optimize --aggressive").example("query-builder db:optimize --tables users,posts").action(async (opts) => {
   try {
     await dbOptimize({
       dialect: opts.dialect,