metal-orm 1.1.25 → 1.1.27

package/dist/index.js

@@ -1533,159 +1533,6 @@ var SelectAstNormalizer = class {
   }
 };
 
-// src/core/dialect/abstract.ts
-var DialectBase = class _DialectBase {
-  expressionCompilerRegistry;
-  selectAstNormalizer;
-  functionStrategy;
-  tableFunctionStrategy;
-  constructor(functionStrategy, tableFunctionStrategy) {
-    this.functionStrategy = functionStrategy ?? new StandardFunctionStrategy();
-    this.tableFunctionStrategy = tableFunctionStrategy ?? new StandardTableFunctionStrategy();
-    this.selectAstNormalizer = new SelectAstNormalizer((kind) => this.supportsSetOperation(kind));
-    this.expressionCompilerRegistry = new ExpressionCompilerRegistry({
-      quoteIdentifier: (id) => this.quoteIdentifier(id),
-      compileSelectAst: (ast, ctx) => this.compileSelectAst(ast, ctx),
-      compileSelectForExists: (ast, ctx) => this.compileSelectForExists(ast, ctx),
-      compileJsonPath: (node) => this.compileJsonPath(node),
-      compileFunctionOperand: (node, ctx) => this.compileFunctionOperand(node, ctx),
-      describe: () => this.constructor.name
-    });
-  }
-  compileSelect(ast) {
-    const ctx = this.createCompilerContext();
-    const normalized = this.normalizeSelectAst(ast);
-    const rawSql = this.compileSelectAst(normalized, ctx).trim();
-    return {
-      sql: rawSql.endsWith(";") ? rawSql : `${rawSql};`,
-      params: [...ctx.params]
-    };
-  }
-  compileInsert(ast) {
-    const ctx = this.createCompilerContext();
-    const rawSql = this.compileInsertAst(ast, ctx).trim();
-    return {
-      sql: rawSql.endsWith(";") ? rawSql : `${rawSql};`,
-      params: [...ctx.params]
-    };
-  }
-  compileUpdate(ast) {
-    const ctx = this.createCompilerContext();
-    const rawSql = this.compileUpdateAst(ast, ctx).trim();
-    return {
-      sql: rawSql.endsWith(";") ? rawSql : `${rawSql};`,
-      params: [...ctx.params]
-    };
-  }
-  compileDelete(ast) {
-    const ctx = this.createCompilerContext();
-    const rawSql = this.compileDeleteAst(ast, ctx).trim();
-    return {
-      sql: rawSql.endsWith(";") ? rawSql : `${rawSql};`,
-      params: [...ctx.params]
-    };
-  }
-  supportsDmlReturningClause() {
-    return false;
-  }
-  compileWhere(where, ctx) {
-    if (!where) return "";
-    return ` WHERE ${this.compileExpression(where, ctx)}`;
-  }
-  compileReturning(returning, _ctx) {
-    void _ctx;
-    if (!returning || returning.length === 0) return "";
-    throw new Error("RETURNING is not supported by this dialect.");
-  }
-  compileSelectForExists(ast, ctx) {
-    const normalized = this.normalizeSelectAst(ast);
-    const full = this.compileSelectAst(normalized, ctx).trim().replace(/;$/, "");
-    if (normalized.setOps && normalized.setOps.length > 0) {
-      return `SELECT 1 FROM (${full}) AS _exists`;
-    }
-    const upper2 = full.toUpperCase();
-    const fromIndex = upper2.indexOf(" FROM ");
-    if (fromIndex === -1) return full;
-    return `SELECT 1${full.slice(fromIndex)}`;
-  }
-  createCompilerContext() {
-    const params = [];
-    let counter = 0;
-    return {
-      params,
-      addParameter: (value) => {
-        counter += 1;
-        params.push(value);
-        return this.formatPlaceholder(counter);
-      }
-    };
-  }
-  formatPlaceholder(_index) {
-    void _index;
-    return "?";
-  }
-  supportsSetOperation(_kind) {
-    void _kind;
-    return true;
-  }
-  normalizeSelectAst(ast) {
-    return this.selectAstNormalizer.normalize(ast);
-  }
-  registerExpressionCompiler(type, compiler) {
-    this.expressionCompilerRegistry.registerExpressionCompiler(type, compiler);
-  }
-  registerOperandCompiler(type, compiler) {
-    this.expressionCompilerRegistry.registerOperandCompiler(type, compiler);
-  }
-  compileExpression(node, ctx) {
-    return this.expressionCompilerRegistry.compileExpression(node, ctx);
-  }
-  compileOperand(node, ctx) {
-    return this.expressionCompilerRegistry.compileOperand(node, ctx);
-  }
-  compileOrderingTerm(term, ctx) {
-    return this.expressionCompilerRegistry.compileOrderingTerm(term, ctx);
-  }
-  compileJsonPath(_node) {
-    void _node;
-    throw new Error("JSON Path not supported by this dialect");
-  }
-  compileFunctionOperand(fnNode, ctx) {
-    const compiledArgs = fnNode.args.map((arg) => this.compileOperand(arg, ctx));
-    const renderer = this.functionStrategy.getRenderer(fnNode.name);
-    if (renderer) {
-      return renderer({
-        node: fnNode,
-        compiledArgs,
-        compileOperand: (operand) => this.compileOperand(operand, ctx)
-      });
-    }
-    return `${fnNode.name}(${compiledArgs.join(", ")})`;
-  }
-  /** Creates a minimal dialect implementation for isolated compiler tests. */
-  static create(functionStrategy, tableFunctionStrategy) {
-    class TestDialect extends _DialectBase {
-      dialect = "sqlite";
-      quoteIdentifier(id) {
-        return `"${id}"`;
-      }
-      compileSelectAst() {
-        throw new Error("Not implemented");
-      }
-      compileInsertAst() {
-        throw new Error("Not implemented");
-      }
-      compileUpdateAst() {
-        throw new Error("Not implemented");
-      }
-      compileDeleteAst() {
-        throw new Error("Not implemented");
-      }
-    }
-    return new TestDialect(functionStrategy, tableFunctionStrategy);
-  }
-};
-
 // src/core/dialect/base/pagination-strategy.ts
 var StandardLimitOffsetPagination = class {
   /**
@@ -1710,19 +1557,19 @@ var NoReturningStrategy = class {
     if (!returning || returning.length === 0) return "";
     throw new Error("RETURNING is not supported by this dialect.");
   }
-  formatReturningColumns(returning, quoteIdentifier) {
+  formatReturningColumns(returning, quoteIdentifier9) {
     return returning.map((column) => {
-      const tablePart = column.table ? `${quoteIdentifier(column.table)}.` : "";
-      const aliasPart = column.alias ? ` AS ${quoteIdentifier(column.alias)}` : "";
-      return `${tablePart}${quoteIdentifier(column.name)}${aliasPart}`;
+      const tablePart = column.table ? `${quoteIdentifier9(column.table)}.` : "";
+      const aliasPart = column.alias ? ` AS ${quoteIdentifier9(column.alias)}` : "";
+      return `${tablePart}${quoteIdentifier9(column.name)}${aliasPart}`;
     }).join(", ");
   }
 };
 var StandardReturningStrategy = class extends NoReturningStrategy {
-  compileReturning(returning, _ctx, quoteIdentifier) {
+  compileReturning(returning, _ctx, quoteIdentifier9) {
     void _ctx;
     if (!returning || returning.length === 0) return "";
-    return ` RETURNING ${this.formatReturningColumns(returning, quoteIdentifier)}`;
+    return ` RETURNING ${this.formatReturningColumns(returning, quoteIdentifier9)}`;
   }
 };
 
@@ -1853,13 +1700,13 @@ var CteCompiler = class {
    * @param stripTrailingSemicolon - Function to remove trailing semicolons from SQL.
    * @returns SQL WITH clause string (e.g., "WITH cte_name AS (...) ") or empty string if no CTEs.
    */
-  static compileCtes(ast, ctx, quoteIdentifier, compileSelectAst, normalizeSelectAst, stripTrailingSemicolon) {
+  static compileCtes(ast, ctx, quoteIdentifier9, compileSelectAst, normalizeSelectAst, stripTrailingSemicolon) {
     if (!ast.ctes || ast.ctes.length === 0) return "";
     const hasRecursive = ast.ctes.some((cte) => cte.recursive);
     const prefix = hasRecursive ? "WITH RECURSIVE " : "WITH ";
     const cteDefs = ast.ctes.map((cte) => {
-      const name = quoteIdentifier(cte.name);
-      const cols = cte.columns && cte.columns.length ? `(${cte.columns.map((c) => quoteIdentifier(c)).join(", ")})` : "";
+      const name = quoteIdentifier9(cte.name);
+      const cols = cte.columns && cte.columns.length ? `(${cte.columns.map((c) => quoteIdentifier9(c)).join(", ")})` : "";
       const query = stripTrailingSemicolon(compileSelectAst(normalizeSelectAst(cte.query), ctx));
       return `${name}${cols} AS (${query})`;
     }).join(", ");
@@ -2082,138 +1929,174 @@ var StandardDeleteCompiler = class {
   }
 };
 
-// src/core/dialect/base/sql-dialect.ts
-var SqlDialectBase = class extends DialectBase {
-  paginationStrategy;
-  returningStrategy;
-  upsertStrategy;
-  dmlReturningSupported;
-  sourceCompiler;
-  standardUpdateCompiler;
-  compilerSet;
-  constructor(options = {}) {
-    super(options.functionStrategy, options.tableFunctionStrategy);
-    this.paginationStrategy = options.paginationStrategy ?? new StandardLimitOffsetPagination();
-    this.returningStrategy = options.returningStrategy ?? new NoReturningStrategy();
-    this.upsertStrategy = options.upsertStrategy ?? new NoUpsertStrategy();
-    this.dmlReturningSupported = options.supportsDmlReturning ?? false;
-    const services = {
-      getDialectName: () => this.dialect,
-      getPaginationStrategy: () => this.paginationStrategy,
-      getTableFunctionStrategy: () => this.tableFunctionStrategy,
-      quoteIdentifier: (id) => this.quoteIdentifier(id),
-      compileOperand: (node, ctx) => this.compileOperand(node, ctx),
-      compileExpression: (node, ctx) => this.compileExpression(node, ctx),
-      compileOrderingTerm: (term, ctx) => this.compileOrderingTerm(term, ctx),
-      normalizeSelectAst: (ast) => this.normalizeSelectAst(ast),
-      compileSelectAst: (ast, ctx) => this.compileSelectAst(ast, ctx),
-      compileReturning: (returning, ctx) => this.compileReturning(returning, ctx),
-      compileUpsertClause: (ast, ctx) => this.compileUpsertClause(ast, ctx),
-      compileSetTarget: (column, table) => this.compileSetTarget(column, table),
-      renderOrderByNulls: (order) => this.renderOrderByNulls(order),
-      renderOrderByCollation: (order) => this.renderOrderByCollation(order)
-    };
-    this.sourceCompiler = new StandardSqlSourceCompiler(services);
-    const standardSelect = new StandardSelectCompiler(services, this.sourceCompiler);
-    const standardInsert = new StandardInsertCompiler(services, this.sourceCompiler);
-    this.standardUpdateCompiler = new StandardUpdateCompiler(services, this.sourceCompiler);
-    const standardDelete = new StandardDeleteCompiler(services, this.sourceCompiler);
-    const overrides = options.compilerFactory?.({
-      services,
-      sources: this.sourceCompiler
-    }) ?? {};
-    this.compilerSet = {
-      select: overrides.select ?? standardSelect,
-      insert: overrides.insert ?? standardInsert,
-      update: overrides.update ?? this.standardUpdateCompiler,
-      delete: overrides.delete ?? standardDelete
+// src/core/dialect/base/sql-dialect-composer.ts
+var terminate = (sql) => {
+  const trimmed = sql.trim();
+  return trimmed.endsWith(";") ? trimmed : `${trimmed};`;
+};
+var composeSqlDialect = (config) => {
+  const functionStrategy = config.functionStrategy ?? new StandardFunctionStrategy();
+  const tableFunctionStrategy = config.tableFunctionStrategy ?? new StandardTableFunctionStrategy();
+  const paginationStrategy = config.paginationStrategy ?? new StandardLimitOffsetPagination();
+  const returningStrategy = config.returningStrategy ?? new NoReturningStrategy();
+  const upsertStrategy = config.upsertStrategy ?? new NoUpsertStrategy();
+  const selectAstNormalizer = new SelectAstNormalizer(
+    (kind) => config.supportsSetOperation?.(kind) ?? true
+  );
+  let compilerSet;
+  let expressionRegistry2;
+  const createCompilerContext = () => {
+    const params = [];
+    let counter = 0;
+    return {
+      params,
+      addParameter(value) {
+        counter += 1;
+        params.push(value);
+        return config.formatPlaceholder?.(counter) ?? "?";
+      }
     };
-  }
-  supportsDmlReturningClause() {
-    return this.dmlReturningSupported;
-  }
-  compileSelectAst(ast, ctx) {
-    return this.compilerSet.select.compile(ast, ctx);
-  }
-  compileInsertAst(ast, ctx) {
-    return this.compilerSet.insert.compile(ast, ctx);
-  }
-  compileUpdateAst(ast, ctx) {
-    return this.compilerSet.update.compile(ast, ctx);
-  }
-  compileDeleteAst(ast, ctx) {
-    return this.compilerSet.delete.compile(ast, ctx);
-  }
-  compileUpsertClause(ast, ctx) {
-    return this.upsertStrategy.compile(ast, ctx, {
-      getDialectName: () => this.dialect,
-      quoteIdentifier: (id) => this.quoteIdentifier(id),
-      compileOperand: (node, compilerContext) => this.compileOperand(node, compilerContext),
-      compileExpression: (node, compilerContext) => this.compileExpression(node, compilerContext),
-      compileUpdateAssignments: (assignments, table, compilerContext) => this.standardUpdateCompiler.compileAssignments(assignments, table, compilerContext)
-    });
-  }
-  compileReturning(returning, ctx) {
-    return this.returningStrategy.compileReturning(
-      returning,
-      ctx,
-      (id) => this.quoteIdentifier(id)
-    );
-  }
-  ensureConflictColumns(clause, message) {
-    if (!clause.target.columns.length) throw new Error(message);
-  }
-  compileUpdateAssignments(assignments, table, ctx) {
-    return this.standardUpdateCompiler.compileAssignments(assignments, table, ctx);
-  }
-  compileSetTarget(column, table) {
-    return this.compileQualifiedColumn(column, table);
-  }
-  compileQualifiedColumn(column, table) {
-    const baseTableName = table.name;
-    const alias = table.alias;
-    const columnTable = column.table ?? alias ?? baseTableName;
-    const tableQualifier = alias && column.table === baseTableName ? alias : columnTable;
-    if (!tableQualifier) return this.quoteIdentifier(column.name);
-    return `${this.quoteIdentifier(tableQualifier)}.${this.quoteIdentifier(column.name)}`;
-  }
-  formatReturningColumns(returning) {
-    return this.returningStrategy.formatReturningColumns(
-      returning,
-      (id) => this.quoteIdentifier(id)
-    );
-  }
-  compileFrom(source, ctx) {
-    return this.sourceCompiler.compileFrom(source, ctx);
-  }
-  compileFunctionTable(fn9, ctx) {
-    return this.sourceCompiler.compileFunctionTable(fn9, ctx);
-  }
-  compileDerivedTable(table, ctx) {
-    return this.sourceCompiler.compileDerivedTable(table, ctx);
-  }
-  compileTableSource(table) {
-    return this.sourceCompiler.compileTableSource(table);
-  }
-  compileTableName(table) {
-    return this.sourceCompiler.compileTableName(table);
-  }
-  compileTableReference(table) {
-    return this.sourceCompiler.compileTableReference(table);
-  }
-  stripTrailingSemicolon(sql) {
-    return this.sourceCompiler.stripTrailingSemicolon(sql);
-  }
-  wrapSetOperand(sql) {
-    return this.sourceCompiler.wrapSetOperand(sql);
-  }
-  renderOrderByNulls(order) {
-    return order.nulls ? ` NULLS ${order.nulls}` : "";
-  }
-  renderOrderByCollation(order) {
-    return order.collation ? ` COLLATE ${order.collation}` : "";
-  }
+  };
+  const compileSelectAst = (ast, ctx) => compilerSet.select.compile(ast, ctx);
+  const normalizeSelectAst = (ast) => selectAstNormalizer.normalize(ast);
+  const compileSelectForExists = (ast, ctx) => {
+    const normalized = normalizeSelectAst(ast);
+    const full = compileSelectAst(normalized, ctx).trim().replace(/;$/, "");
+    if (normalized.setOps && normalized.setOps.length > 0) {
+      return `SELECT 1 FROM (${full}) AS _exists`;
+    }
+    const fromIndex = full.toUpperCase().indexOf(" FROM ");
+    return fromIndex === -1 ? full : `SELECT 1${full.slice(fromIndex)}`;
+  };
+  const compileJsonPath = (node) => {
+    if (!config.compileJsonPath) {
+      throw new Error(`JSON Path not supported by dialect "${config.name}".`);
+    }
+    return config.compileJsonPath(node);
+  };
+  const compileFunctionOperand = (node, ctx) => {
+    const compiledArgs = node.args.map((arg) => expressionRegistry2.compileOperand(arg, ctx));
+    const renderer = functionStrategy.getRenderer(node.name);
+    if (renderer) {
+      return renderer({
+        node,
+        compiledArgs,
+        compileOperand: (operand) => expressionRegistry2.compileOperand(operand, ctx)
+      });
+    }
+    return `${node.name}(${compiledArgs.join(", ")})`;
+  };
+  expressionRegistry2 = new ExpressionCompilerRegistry({
+    quoteIdentifier: config.quoteIdentifier,
+    compileSelectAst,
+    compileSelectForExists,
+    compileJsonPath,
+    compileFunctionOperand,
+    describe: () => config.describe ?? config.name
+  });
+  const compileSetTarget = (column, table) => {
+    if (config.compileSetTarget) return config.compileSetTarget(column, table);
+    const columnTable = column.table ?? table.alias ?? table.name;
+    const tableQualifier = table.alias && column.table === table.name ? table.alias : columnTable;
+    return tableQualifier ? `${config.quoteIdentifier(tableQualifier)}.${config.quoteIdentifier(column.name)}` : config.quoteIdentifier(column.name);
+  };
+  let standardUpdate;
+  const services = {
+    getDialectName: () => config.name,
+    getPaginationStrategy: () => paginationStrategy,
+    getTableFunctionStrategy: () => tableFunctionStrategy,
+    quoteIdentifier: config.quoteIdentifier,
+    compileOperand: (node, ctx) => expressionRegistry2.compileOperand(node, ctx),
+    compileExpression: (node, ctx) => expressionRegistry2.compileExpression(node, ctx),
+    compileOrderingTerm: (term, ctx) => expressionRegistry2.compileOrderingTerm(term, ctx),
+    normalizeSelectAst,
+    compileSelectAst,
+    compileReturning: (returning, ctx) => returningStrategy.compileReturning(returning, ctx, config.quoteIdentifier),
+    compileUpsertClause: (ast, ctx) => upsertStrategy.compile(ast, ctx, {
+      getDialectName: () => config.name,
+      quoteIdentifier: config.quoteIdentifier,
+      compileOperand: (node, compilerContext) => expressionRegistry2.compileOperand(node, compilerContext),
+      compileExpression: (node, compilerContext) => expressionRegistry2.compileExpression(node, compilerContext),
+      compileUpdateAssignments: (assignments, table, compilerContext) => standardUpdate.compileAssignments(assignments, table, compilerContext)
+    }),
+    compileSetTarget,
+    renderOrderByNulls: (order) => config.renderOrderByNulls?.(order) ?? (order.nulls ? ` NULLS ${order.nulls}` : ""),
+    renderOrderByCollation: (order) => config.renderOrderByCollation?.(order) ?? (order.collation ? ` COLLATE ${order.collation}` : "")
+  };
+  const sources = new StandardSqlSourceCompiler(services);
+  const standardSelect = new StandardSelectCompiler(services, sources);
+  const standardInsert = new StandardInsertCompiler(services, sources);
+  standardUpdate = new StandardUpdateCompiler(services, sources);
+  const standardDelete = new StandardDeleteCompiler(services, sources);
+  const overrides = config.compilerFactory?.({ services, sources }) ?? {};
+  compilerSet = {
+    select: overrides.select ?? standardSelect,
+    insert: overrides.insert ?? standardInsert,
+    update: overrides.update ?? standardUpdate,
+    delete: overrides.delete ?? standardDelete
+  };
+  const expressionApi = {
+    registerExpressionCompiler(type, compiler) {
+      expressionRegistry2.registerExpressionCompiler(type, compiler);
+    },
+    registerOperandCompiler(type, compiler) {
+      expressionRegistry2.registerOperandCompiler(type, compiler);
+    },
+    compileExpression(node, ctx) {
+      return expressionRegistry2.compileExpression(node, ctx);
+    },
+    compileOperand(node, ctx) {
+      return expressionRegistry2.compileOperand(node, ctx);
+    },
+    compileOrderingTerm(term, ctx) {
+      return expressionRegistry2.compileOrderingTerm(term, ctx);
+    }
+  };
+  config.configureExpressions?.(expressionApi);
+  const dialect = {
+    quoteIdentifier: config.quoteIdentifier,
+    supportsDmlReturningClause: () => config.supportsDmlReturning ?? false,
+    compileSelect(ast) {
+      const ctx = createCompilerContext();
+      return {
+        sql: terminate(compileSelectAst(normalizeSelectAst(ast), ctx)),
+        params: [...ctx.params]
+      };
+    },
+    compileInsert(ast) {
+      const ctx = createCompilerContext();
+      return {
+        sql: terminate(compilerSet.insert.compile(ast, ctx)),
+        params: [...ctx.params]
+      };
+    },
+    compileUpdate(ast) {
+      const ctx = createCompilerContext();
+      return {
+        sql: terminate(compilerSet.update.compile(ast, ctx)),
+        params: [...ctx.params]
+      };
+    },
+    compileDelete(ast) {
+      const ctx = createCompilerContext();
+      return {
+        sql: terminate(compilerSet.delete.compile(ast, ctx)),
+        params: [...ctx.params]
+      };
+    }
+  };
+  const runtime = {
+    quoteIdentifier: config.quoteIdentifier,
+    createCompilerContext,
+    compileOperand: (node, ctx) => expressionRegistry2.compileOperand(node, ctx),
+    compileExpression: (node, ctx) => expressionRegistry2.compileExpression(node, ctx),
+    compileOrderingTerm: (term, ctx) => expressionRegistry2.compileOrderingTerm(term, ctx),
+    normalizeSelectAst,
+    compileSelectAst
+  };
+  return { dialect, runtime };
 };
+var createSqlDialect = (config) => composeSqlDialect(config).dialect;
 
 // src/core/dialect/postgres/functions.ts
 var PostgresFunctionStrategy = class extends StandardFunctionStrategy {
@@ -2376,15 +2259,15 @@ var PostgresTableFunctionStrategy = class extends StandardTableFunctionStrategy
     this.registerOverrides();
   }
   registerOverrides() {
-    this.add("ARRAY_UNNEST", ({ node, compiledArgs, quoteIdentifier }) => {
+    this.add("ARRAY_UNNEST", ({ node, compiledArgs, quoteIdentifier: quoteIdentifier9 }) => {
       const lateral = node.lateral ?? true;
       const withOrd = node.withOrdinality ?? false;
       const base = `unnest(${compiledArgs.join(", ")})${withOrd ? " WITH ORDINALITY" : ""}`;
       if (node.columnAliases?.length && !node.alias) {
         throw new Error("tvf(ARRAY_UNNEST) with columnAliases requires an alias.");
       }
-      const alias = node.alias ? ` AS ${quoteIdentifier(node.alias)}` : "";
-      const cols = node.columnAliases?.length ? `(${node.columnAliases.map(quoteIdentifier).join(", ")})` : "";
+      const alias = node.alias ? ` AS ${quoteIdentifier9(node.alias)}` : "";
+      const cols = node.columnAliases?.length ? `(${node.columnAliases.map(quoteIdentifier9).join(", ")})` : "";
       return `${lateral ? "LATERAL " : ""}${base}${alias}${cols}`;
     });
   }
@@ -2449,52 +2332,68 @@ var PostgresUpsertStrategy = class {
 };
 
 // src/core/dialect/postgres/index.ts
-var PostgresDialect = class extends SqlDialectBase {
-  dialect = "postgres";
-  procedureCompiler;
-  constructor() {
-    super({
-      functionStrategy: new PostgresFunctionStrategy(),
-      tableFunctionStrategy: new PostgresTableFunctionStrategy(),
-      returningStrategy: new PostgresReturningStrategy(),
-      upsertStrategy: new PostgresUpsertStrategy(),
-      supportsDmlReturning: true
-    });
-    this.procedureCompiler = new PostgresProcedureCompiler({
-      quoteIdentifier: (id) => this.quoteIdentifier(id),
-      createCompilerContext: () => this.createCompilerContext(),
-      compileOperand: (node, ctx) => this.compileOperand(node, ctx)
-    });
-    this.registerExpressionCompiler("BitwiseExpression", (node, ctx) => {
-      const left2 = this.compileOperand(node.left, ctx);
-      const right2 = this.compileOperand(node.right, ctx);
-      const operator = node.operator === "^" ? "#" : node.operator;
-      return `${left2} ${operator} ${right2}`;
-    });
-    this.registerOperandCompiler("BitwiseExpression", (node, ctx) => {
-      const left2 = this.compileOperand(node.left, ctx);
-      const right2 = this.compileOperand(node.right, ctx);
-      const operator = node.operator === "^" ? "#" : node.operator;
-      return `(${left2} ${operator} ${right2})`;
-    });
-  }
+var quoteIdentifier = (id) => `"${id}"`;
+var createPostgresDialect = () => {
+  const composition = composeSqlDialect({
+    name: "postgres",
+    quoteIdentifier,
+    formatPlaceholder: (index) => `$${index}`,
+    functionStrategy: new PostgresFunctionStrategy(),
+    tableFunctionStrategy: new PostgresTableFunctionStrategy(),
+    returningStrategy: new PostgresReturningStrategy(),
+    upsertStrategy: new PostgresUpsertStrategy(),
+    supportsDmlReturning: true,
+    compileSetTarget: (column, _table) => {
+      void _table;
+      return quoteIdentifier(column.name);
+    },
+    compileJsonPath(node) {
+      const column = `${quoteIdentifier(node.column.table)}.${quoteIdentifier(node.column.name)}`;
+      return `${column}->>'${node.path}'`;
+    },
+    configureExpressions(api) {
+      api.registerExpressionCompiler("BitwiseExpression", (node, ctx) => {
+        const left2 = api.compileOperand(node.left, ctx);
+        const right2 = api.compileOperand(node.right, ctx);
+        const operator = node.operator === "^" ? "#" : node.operator;
+        return `${left2} ${operator} ${right2}`;
+      });
+      api.registerOperandCompiler("BitwiseExpression", (node, ctx) => {
+        const left2 = api.compileOperand(node.left, ctx);
+        const right2 = api.compileOperand(node.right, ctx);
+        const operator = node.operator === "^" ? "#" : node.operator;
+        return `(${left2} ${operator} ${right2})`;
+      });
+    }
+  });
+  const procedures = new PostgresProcedureCompiler(composition.runtime);
+  return {
+    ...composition.dialect,
+    compileProcedureCall: (ast) => procedures.compileProcedureCall(ast)
+  };
+};
+var PostgresDialect = class {
+  impl = createPostgresDialect();
   quoteIdentifier(id) {
-    return `"${id}"`;
+    return this.impl.quoteIdentifier(id);
   }
-  formatPlaceholder(index) {
-    return `$${index}`;
+  supportsDmlReturningClause() {
+    return this.impl.supportsDmlReturningClause();
   }
-  compileJsonPath(node) {
-    const column = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    return `${column}->>'${node.path}'`;
+  compileSelect(ast) {
+    return this.impl.compileSelect(ast);
   }
-  /** PostgreSQL requires unqualified column names in SET clauses. */
-  compileSetTarget(column, _table) {
-    void _table;
-    return this.quoteIdentifier(column.name);
+  compileInsert(ast) {
+    return this.impl.compileInsert(ast);
+  }
+  compileUpdate(ast) {
+    return this.impl.compileUpdate(ast);
+  }
+  compileDelete(ast) {
+    return this.impl.compileDelete(ast);
   }
   compileProcedureCall(ast) {
-    return this.procedureCompiler.compileProcedureCall(ast);
+    return this.impl.compileProcedureCall(ast);
   }
 };
 
@@ -2674,38 +2573,57 @@ var MySqlUpsertStrategy = class {
 };
 
 // src/core/dialect/mysql/index.ts
-var MySqlDialect = class extends SqlDialectBase {
-  dialect = "mysql";
-  procedureCompiler;
-  constructor() {
-    super({
-      functionStrategy: new MysqlFunctionStrategy(),
-      upsertStrategy: new MySqlUpsertStrategy()
-    });
-    this.procedureCompiler = new MySqlProcedureCompiler({
-      quoteIdentifier: (id) => this.quoteIdentifier(id),
-      createCompilerContext: () => this.createCompilerContext(),
-      compileOperand: (node, ctx) => this.compileOperand(node, ctx)
-    });
-    this.registerExpressionCompiler(
-      "IsDistinctExpression",
-      (node, ctx) => {
-        const left2 = this.compileOperand(node.left, ctx);
-        const right2 = this.compileOperand(node.right, ctx);
-        const spaceship = `${left2} <=> ${right2}`;
-        return node.operator === "IS NOT DISTINCT FROM" ? spaceship : `NOT (${spaceship})`;
-      }
-    );
-  }
+var quoteIdentifier2 = (id) => `\`${id}\``;
+var createMySqlDialect = () => {
+  const composition = composeSqlDialect({
+    name: "mysql",
+    quoteIdentifier: quoteIdentifier2,
+    functionStrategy: new MysqlFunctionStrategy(),
+    upsertStrategy: new MySqlUpsertStrategy(),
+    compileJsonPath(node) {
+      const column = `${quoteIdentifier2(node.column.table)}.${quoteIdentifier2(node.column.name)}`;
+      return `${column}->'${node.path}'`;
+    },
+    configureExpressions(api) {
+      api.registerExpressionCompiler(
+        "IsDistinctExpression",
+        (node, ctx) => {
+          const left2 = api.compileOperand(node.left, ctx);
+          const right2 = api.compileOperand(node.right, ctx);
+          const spaceship = `${left2} <=> ${right2}`;
+          return node.operator === "IS NOT DISTINCT FROM" ? spaceship : `NOT (${spaceship})`;
+        }
+      );
+    }
+  });
+  const procedures = new MySqlProcedureCompiler(composition.runtime);
+  return {
+    ...composition.dialect,
+    compileProcedureCall: (ast) => procedures.compileProcedureCall(ast)
+  };
+};
+var MySqlDialect = class {
+  impl = createMySqlDialect();
   quoteIdentifier(id) {
-    return `\`${id}\``;
+    return this.impl.quoteIdentifier(id);
   }
-  compileJsonPath(node) {
-    const column = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    return `${column}->'${node.path}'`;
+  supportsDmlReturningClause() {
+    return this.impl.supportsDmlReturningClause();
+  }
+  compileSelect(ast) {
+    return this.impl.compileSelect(ast);
+  }
+  compileInsert(ast) {
+    return this.impl.compileInsert(ast);
+  }
+  compileUpdate(ast) {
+    return this.impl.compileUpdate(ast);
+  }
+  compileDelete(ast) {
+    return this.impl.compileDelete(ast);
   }
   compileProcedureCall(ast) {
-    return this.procedureCompiler.compileProcedureCall(ast);
+    return this.impl.compileProcedureCall(ast);
   }
 };
 
@@ -2848,15 +2766,15 @@ var SqliteFunctionStrategy = class extends StandardFunctionStrategy {
 
 // src/core/dialect/sqlite/returning.ts
 var SqliteReturningStrategy = class {
-  compileReturning(returning, _ctx, quoteIdentifier) {
+  compileReturning(returning, _ctx, quoteIdentifier9) {
     void _ctx;
     if (!returning || returning.length === 0) return "";
-    return ` RETURNING ${this.formatReturningColumns(returning, quoteIdentifier)}`;
+    return ` RETURNING ${this.formatReturningColumns(returning, quoteIdentifier9)}`;
   }
-  formatReturningColumns(returning, quoteIdentifier) {
+  formatReturningColumns(returning, quoteIdentifier9) {
     return returning.map((column) => {
-      const alias = column.alias ? ` AS ${quoteIdentifier(column.alias)}` : "";
-      return `${quoteIdentifier(column.name)}${alias}`;
+      const alias = column.alias ? ` AS ${quoteIdentifier9(column.alias)}` : "";
+      return `${quoteIdentifier9(column.name)}${alias}`;
     }).join(", ");
   }
 };
@@ -2887,42 +2805,60 @@ var SqliteUpsertStrategy = class {
 };
 
 // src/core/dialect/sqlite/index.ts
-var SqliteDialect = class extends SqlDialectBase {
-  dialect = "sqlite";
-  constructor() {
-    super({
-      functionStrategy: new SqliteFunctionStrategy(),
-      returningStrategy: new SqliteReturningStrategy(),
-      upsertStrategy: new SqliteUpsertStrategy(),
-      supportsDmlReturning: true
-    });
-    this.registerExpressionCompiler("BitwiseExpression", (node, ctx) => {
-      const left2 = this.compileOperand(node.left, ctx);
-      const right2 = this.compileOperand(node.right, ctx);
+var quoteIdentifier3 = (id) => `"${id}"`;
+var createSqliteDialect = () => composeSqlDialect({
+  name: "sqlite",
+  quoteIdentifier: quoteIdentifier3,
+  functionStrategy: new SqliteFunctionStrategy(),
+  returningStrategy: new SqliteReturningStrategy(),
+  upsertStrategy: new SqliteUpsertStrategy(),
+  supportsDmlReturning: true,
+  compileSetTarget: (column, _table) => {
+    void _table;
+    return quoteIdentifier3(column.name);
+  },
+  compileJsonPath(node) {
+    const column = `${quoteIdentifier3(node.column.table)}.${quoteIdentifier3(node.column.name)}`;
+    return `json_extract(${column}, '${node.path}')`;
+  },
+  configureExpressions(api) {
+    api.registerExpressionCompiler("BitwiseExpression", (node, ctx) => {
+      const left2 = api.compileOperand(node.left, ctx);
+      const right2 = api.compileOperand(node.right, ctx);
       if (node.operator === "^") {
         return `(${left2} | ${right2}) & ~(${left2} & ${right2})`;
       }
       return `${left2} ${node.operator} ${right2}`;
     });
-    this.registerOperandCompiler("BitwiseExpression", (node, ctx) => {
-      const left2 = this.compileOperand(node.left, ctx);
-      const right2 = this.compileOperand(node.right, ctx);
+    api.registerOperandCompiler("BitwiseExpression", (node, ctx) => {
+      const left2 = api.compileOperand(node.left, ctx);
+      const right2 = api.compileOperand(node.right, ctx);
       if (node.operator === "^") {
         return `((${left2} | ${right2}) & ~(${left2} & ${right2}))`;
       }
       return `(${left2} ${node.operator} ${right2})`;
     });
   }
+}).dialect;
+var SqliteDialect = class {
+  impl = createSqliteDialect();
   quoteIdentifier(id) {
-    return `"${id}"`;
+    return this.impl.quoteIdentifier(id);
   }
-  compileJsonPath(node) {
-    const column = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    return `json_extract(${column}, '${node.path}')`;
+  supportsDmlReturningClause() {
+    return this.impl.supportsDmlReturningClause();
   }
-  compileQualifiedColumn(column, _table) {
-    void _table;
-    return this.quoteIdentifier(column.name);
+  compileSelect(ast) {
+    return this.impl.compileSelect(ast);
+  }
+  compileInsert(ast) {
+    return this.impl.compileInsert(ast);
+  }
+  compileUpdate(ast) {
+    return this.impl.compileUpdate(ast);
+  }
+  compileDelete(ast) {
+    return this.impl.compileDelete(ast);
   }
 };
 
@@ -3052,22 +2988,22 @@ var MssqlFunctionStrategy = class extends StandardFunctionStrategy {
 
 // src/core/dialect/mssql/output.ts
 var MssqlOutputStrategy = class {
-  compileReturning(returning, _ctx, quoteIdentifier) {
+  compileReturning(returning, _ctx, quoteIdentifier9) {
     void _ctx;
-    return this.compileOutput(returning, "inserted", quoteIdentifier);
+    return this.compileOutput(returning, "inserted", quoteIdentifier9);
   }
-  compileOutput(returning, prefix, quoteIdentifier) {
+  compileOutput(returning, prefix, quoteIdentifier9) {
     if (!returning || returning.length === 0) return "";
     const columns = returning.map((column) => {
-      const alias = column.alias ? ` AS ${quoteIdentifier(column.alias)}` : "";
-      return `${prefix}.${quoteIdentifier(column.name)}${alias}`;
+      const alias = column.alias ? ` AS ${quoteIdentifier9(column.alias)}` : "";
+      return `${prefix}.${quoteIdentifier9(column.name)}${alias}`;
     }).join(", ");
     return ` OUTPUT ${columns}`;
   }
-  formatReturningColumns(returning, quoteIdentifier) {
+  formatReturningColumns(returning, quoteIdentifier9) {
     return returning.map((column) => {
-      const alias = column.alias ? ` AS ${quoteIdentifier(column.alias)}` : "";
-      return `${quoteIdentifier(column.name)}${alias}`;
+      const alias = column.alias ? ` AS ${quoteIdentifier9(column.alias)}` : "";
+      return `${quoteIdentifier9(column.name)}${alias}`;
     }).join(", ");
   }
 };
@@ -3349,34 +3285,49 @@ var MssqlProcedureCompiler = class {
 };
 
 // src/core/dialect/mssql/index.ts
-var SqlServerDialect = class extends SqlDialectBase {
-  dialect = "mssql";
-  procedureCompiler;
-  constructor() {
-    super({
-      functionStrategy: new MssqlFunctionStrategy(),
-      returningStrategy: new MssqlOutputStrategy(),
-      compilerFactory: createMssqlCompilerSet,
-      supportsDmlReturning: true
-    });
-    this.procedureCompiler = new MssqlProcedureCompiler({
-      quoteIdentifier: (id) => this.quoteIdentifier(id),
-      createCompilerContext: () => this.createCompilerContext(),
-      compileOperand: (node, ctx) => this.compileOperand(node, ctx)
-    });
-  }
+var quoteIdentifier4 = (id) => `[${id}]`;
+var createSqlServerDialect = () => {
+  const composition = composeSqlDialect({
+    name: "mssql",
+    quoteIdentifier: quoteIdentifier4,
+    formatPlaceholder: (index) => `@p${index}`,
+    functionStrategy: new MssqlFunctionStrategy(),
+    returningStrategy: new MssqlOutputStrategy(),
+    compilerFactory: createMssqlCompilerSet,
+    supportsDmlReturning: true,
+    compileJsonPath(node) {
+      const column = `${quoteIdentifier4(node.column.table)}.${quoteIdentifier4(node.column.name)}`;
+      return `JSON_VALUE(${column}, '${node.path}')`;
+    }
+  });
+  const procedures = new MssqlProcedureCompiler(composition.runtime);
+  return {
+    ...composition.dialect,
+    compileProcedureCall: (ast) => procedures.compileProcedureCall(ast)
+  };
+};
+var SqlServerDialect = class {
+  impl = createSqlServerDialect();
   quoteIdentifier(id) {
-    return `[${id}]`;
+    return this.impl.quoteIdentifier(id);
   }
-  compileJsonPath(node) {
-    const column = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    return `JSON_VALUE(${column}, '${node.path}')`;
+  supportsDmlReturningClause() {
+    return this.impl.supportsDmlReturningClause();
   }
-  formatPlaceholder(index) {
-    return `@p${index}`;
+  compileSelect(ast) {
+    return this.impl.compileSelect(ast);
+  }
+  compileInsert(ast) {
+    return this.impl.compileInsert(ast);
+  }
+  compileUpdate(ast) {
+    return this.impl.compileUpdate(ast);
+  }
+  compileDelete(ast) {
+    return this.impl.compileDelete(ast);
   }
   compileProcedureCall(ast) {
-    return this.procedureCompiler.compileProcedureCall(ast);
+    return this.impl.compileProcedureCall(ast);
   }
 };
 
@@ -3387,59 +3338,33 @@ var DialectFactory = class {
   static ensureDefaults() {
     if (this.defaultsInitialized) return;
     this.defaultsInitialized = true;
-    if (!this.registry.has("postgres")) {
-      this.registry.set("postgres", () => new PostgresDialect());
-    }
-    if (!this.registry.has("mysql")) {
-      this.registry.set("mysql", () => new MySqlDialect());
-    }
-    if (!this.registry.has("sqlite")) {
-      this.registry.set("sqlite", () => new SqliteDialect());
-    }
-    if (!this.registry.has("mssql")) {
-      this.registry.set("mssql", () => new SqlServerDialect());
-    }
+    if (!this.registry.has("postgres")) this.registry.set("postgres", createPostgresDialect);
+    if (!this.registry.has("mysql")) this.registry.set("mysql", createMySqlDialect);
+    if (!this.registry.has("sqlite")) this.registry.set("sqlite", createSqliteDialect);
+    if (!this.registry.has("mssql")) this.registry.set("mssql", createSqlServerDialect);
   }
-  /**
-   * Register (or override) a dialect factory for a key.
-   *
-   * Implementations are structural: extending DialectBase/SqlDialectBase is
-   * optional. A composed object satisfying Dialect is a valid registration.
-   */
+  /** Register or replace a structural dialect factory. */
   static register(key, factory) {
     this.registry.set(key, factory);
   }
-  /**
-   * Resolve a key into a Dialect instance.
-   * Throws if the key is not registered.
-   */
+  /** Resolve a key into a new Dialect instance. */
   static create(key) {
     this.ensureDefaults();
     const factory = this.registry.get(key);
     if (!factory) {
       throw new Error(
-        `Dialect "${String(
-          key
-        )}" is not registered. Use DialectFactory.register(...) to register it.`
+        `Dialect "${String(key)}" is not registered. Use DialectFactory.register(...) to register it.`
       );
     }
     return factory();
   }
-  /**
-   * Clear all registrations (mainly for tests).
-   * Built-ins will be re-registered lazily on the next create().
-   */
+  /** Clear registrations; built-ins are restored lazily on the next create(). */
   static clear() {
     this.registry.clear();
     this.defaultsInitialized = false;
   }
 };
-var resolveDialectInput = (dialect) => {
-  if (typeof dialect === "string") {
-    return DialectFactory.create(dialect);
-  }
-  return dialect;
-};
+var resolveDialectInput = (dialect) => typeof dialect === "string" ? DialectFactory.create(dialect) : dialect;
 
 // src/core/ast/builders.ts
 var isColumnNode = (col2) => "type" in col2 && col2.type === "Column";
@@ -11149,6 +11074,59 @@ var deleteFrom = (target) => {
 };
 
 // src/core/ddl/sql-writing.ts
+var escapeSqlString = (value) => value.replace(/'/g, "''");
+var isRawDefault = (value) => typeof value === "object" && value !== null && "raw" in value && typeof value.raw === "string";
+var createLiteralFormatter = (options = {}) => {
+  const {
+    nullLiteral = "NULL",
+    booleanTrue = "TRUE",
+    booleanFalse = "FALSE",
+    numberFormatter = (value) => Number.isFinite(value) ? String(value) : nullLiteral,
+    dateFormatter = (value) => `'${escapeSqlString(value.toISOString())}'`,
+    stringWrapper = (escaped) => `'${escaped}'`,
+    jsonWrapper = (escaped) => `'${escaped}'`
+  } = options;
+  const wrapString = stringWrapper;
+  const wrapJson = jsonWrapper;
+  const format = (value) => {
+    if (isRawDefault(value)) return value.raw;
+    if (value === null) return nullLiteral;
+    if (typeof value === "number") {
+      return numberFormatter(value);
+    }
+    if (typeof value === "boolean") {
+      return value ? booleanTrue : booleanFalse;
+    }
+    if (value instanceof Date) {
+      return dateFormatter(value);
+    }
+    if (typeof value === "string") {
+      return wrapString(escapeSqlString(value));
+    }
+    return wrapJson(escapeSqlString(JSON.stringify(value)));
+  };
+  return {
+    formatLiteral: format
+  };
+};
+var formatLiteral = (formatter, value) => formatter.formatLiteral(value);
+var quoteQualified = (quoter, identifier) => {
+  const parts = identifier.split(".");
+  return parts.map((part) => quoter.quoteIdentifier(part)).join(".");
+};
+var renderIndexColumns = (quoter, columns) => columns.map((col2) => {
+  if (typeof col2 === "string") {
+    return quoter.quoteIdentifier(col2);
+  }
+  const parts = [quoter.quoteIdentifier(col2.column)];
+  if (col2.order) {
+    parts.push(col2.order);
+  }
+  if (col2.nulls) {
+    parts.push(`NULLS ${col2.nulls}`);
+  }
+  return parts.join(" ");
+}).join(", ");
 var resolvePrimaryKey = (table) => {
   if (Array.isArray(table.primaryKey) && table.primaryKey.length > 0) {
     return table.primaryKey;
@@ -11285,13 +11263,11 @@ var deriveIndexName = (table, index) => {
 var tableKey = (name, schema) => schema ? `${schema}.${name}` : name;
 var mapTables = (schema) => {
   const map = /* @__PURE__ */ new Map();
-  for (const table of schema.tables) {
-    map.set(tableKey(table.name, table.schema), table);
-  }
+  for (const table of schema.tables) map.set(tableKey(table.name, table.schema), table);
   return map;
 };
-var buildAddColumnSql = (table, colName, dialect) => {
-  const column = table.columns[colName];
+var buildAddColumnSql = (table, columnName, dialect) => {
+  const column = table.columns[columnName];
   const rendered = renderColumnDefinition(table, column, dialect);
   return `ALTER TABLE ${dialect.formatTableName(table)} ADD ${rendered.sql};`;
 };
@@ -11312,6 +11288,7 @@ var diffColumn = (expected, actual, dialect) => {
     autoIncrementChanged: !!expected.autoIncrement !== !!actual.autoIncrement
   };
 };
+var unsupportedMutationWarning = (dialect, operation, target) => `Dialect "${dialect.name}" does not provide the ${operation} capability for ${target}; manual migration is required.`;
 var diffSchema = (expectedTables, actualSchema, dialect, options = {}) => {
   const allowDestructive = options.allowDestructive ?? false;
   const plan = { changes: [], warnings: [] };
@@ -11330,87 +11307,121 @@ var diffSchema = (expectedTables, actualSchema, dialect, options = {}) => {
       });
       continue;
     }
-    const actualCols = new Map(actual.columns.map((c) => [c.name, c]));
-    for (const colName of Object.keys(table.columns)) {
-      if (!actualCols.has(colName)) {
+    const actualColumns = new Map(actual.columns.map((column) => [column.name, column]));
+    for (const columnName of Object.keys(table.columns)) {
+      if (!actualColumns.has(columnName)) {
         plan.changes.push({
           kind: "addColumn",
           table: key,
-          description: `Add column ${colName} to ${key}`,
-          statements: [buildAddColumnSql(table, colName, dialect)],
+          description: `Add column ${columnName} to ${key}`,
+          statements: [buildAddColumnSql(table, columnName, dialect)],
           safe: true
         });
-      } else {
-        const expectedCol = table.columns[colName];
-        const actualCol = actualCols.get(colName);
-        const colDiff = diffColumn(expectedCol, actualCol, dialect);
-        const shouldAlter = colDiff.typeChanged || colDiff.nullabilityChanged || colDiff.defaultChanged || colDiff.autoIncrementChanged;
-        if (shouldAlter) {
-          const statements = dialect.alterColumnSql?.(table, expectedCol, actualCol, colDiff) ?? [];
+        continue;
+      }
+      const expectedColumn = table.columns[columnName];
+      const actualColumn = actualColumns.get(columnName);
+      const columnDiff = diffColumn(expectedColumn, actualColumn, dialect);
+      const shouldAlter = columnDiff.typeChanged || columnDiff.nullabilityChanged || columnDiff.defaultChanged || columnDiff.autoIncrementChanged;
+      if (shouldAlter) {
+        const capability = dialect.mutations.alterColumn;
+        if (capability) {
+          const statements = capability.compile(table, expectedColumn, actualColumn, columnDiff);
           if (statements.length > 0) {
             plan.changes.push({
               kind: "alterColumn",
               table: key,
-              description: `Alter column ${colName} on ${key}`,
+              description: `Alter column ${columnName} on ${key}`,
               statements,
               safe: true
             });
           }
-          const warning = dialect.warnAlterColumn?.(table, expectedCol, actualCol, colDiff);
+          const warning = capability.warning?.(table, expectedColumn, actualColumn, columnDiff);
           if (warning) plan.warnings.push(warning);
+        } else {
+          plan.warnings.push(
+            unsupportedMutationWarning(dialect, "ALTER COLUMN", `${key}.${columnName}`)
+          );
         }
       }
     }
-    for (const colName of actualCols.keys()) {
-      if (!table.columns[colName]) {
-        plan.changes.push({
-          kind: "dropColumn",
-          table: key,
-          description: `Drop column ${colName} from ${key}`,
-          statements: allowDestructive ? dialect.dropColumnSql(actual, colName) : [],
-          safe: false
-        });
-        const warning = dialect.warnDropColumn?.(actual, colName);
+    for (const columnName of actualColumns.keys()) {
+      if (table.columns[columnName]) continue;
+      const capability = dialect.mutations.dropColumn;
+      const statements = allowDestructive && capability ? capability.compile(actual, columnName) : [];
+      plan.changes.push({
+        kind: "dropColumn",
+        table: key,
+        description: `Drop column ${columnName} from ${key}`,
+        statements,
+        safe: false
+      });
+      if (!capability) {
+        plan.warnings.push(
+          unsupportedMutationWarning(dialect, "DROP COLUMN", `${key}.${columnName}`)
+        );
+      } else {
+        const warning = capability.warning?.(actual, columnName);
         if (warning) plan.warnings.push(warning);
       }
     }
     const expectedIndexes = table.indexes ?? [];
     const actualIndexes = actual.indexes ?? [];
-    const actualIndexMap = new Map(actualIndexes.map((idx) => [idx.name, idx]));
-    for (const idx of expectedIndexes) {
-      const name = idx.name || deriveIndexName(table, idx);
+    const actualIndexMap = new Map(actualIndexes.map((index) => [index.name, index]));
+    for (const index of expectedIndexes) {
+      const name = index.name || deriveIndexName(table, index);
       if (!actualIndexMap.has(name)) {
         plan.changes.push({
           kind: "addIndex",
           table: key,
           description: `Create index ${name} on ${key}`,
-          statements: [dialect.renderIndex(table, { ...idx, name })],
+          statements: [dialect.renderIndex(table, { ...index, name })],
           safe: true
         });
       }
     }
-    for (const idx of actualIndexes) {
-      if (idx.name && !expectedIndexes.find((expected) => (expected.name || deriveIndexName(table, expected)) === idx.name)) {
-        plan.changes.push({
-          kind: "dropIndex",
-          table: key,
-          description: `Drop index ${idx.name} on ${key}`,
-          statements: allowDestructive ? dialect.dropIndexSql(actual, idx.name) : [],
-          safe: false
-        });
+    for (const index of actualIndexes) {
+      if (!index.name) continue;
+      const expected = expectedIndexes.find(
+        (candidate) => (candidate.name || deriveIndexName(table, candidate)) === index.name
+      );
+      if (expected) continue;
+      const capability = dialect.mutations.dropIndex;
+      const statements = allowDestructive && capability ? capability.compile(actual, index.name) : [];
+      plan.changes.push({
+        kind: "dropIndex",
+        table: key,
+        description: `Drop index ${index.name} on ${key}`,
+        statements,
+        safe: false
+      });
+      if (!capability) {
+        plan.warnings.push(
+          unsupportedMutationWarning(dialect, "DROP INDEX", `${key}.${index.name}`)
+        );
+      } else {
+        const warning = capability.warning?.(actual, index.name);
+        if (warning) plan.warnings.push(warning);
       }
     }
   }
   for (const actual of actualSchema.tables) {
     const key = tableKey(actual.name, actual.schema);
-    if (!expectedTables.find((t) => tableKey(t.name, t.schema) === key)) {
-      plan.changes.push({
-        kind: "dropTable",
-        table: key,
-        description: `Drop table ${key}`,
-        statements: allowDestructive ? dialect.dropTableSql(actual) : [],
-        safe: false
-      });
+    if (expectedTables.find((table) => tableKey(table.name, table.schema) === key)) continue;
+    const capability = dialect.mutations.dropTable;
+    const statements = allowDestructive && capability ? capability.compile(actual) : [];
+    plan.changes.push({
+      kind: "dropTable",
+      table: key,
+      description: `Drop table ${key}`,
+      statements,
+      safe: false
+    });
+    if (!capability) {
+      plan.warnings.push(unsupportedMutationWarning(dialect, "DROP TABLE", key));
+    } else {
+      const warning = capability.warning?.(actual);
+      if (warning) plan.warnings.push(warning);
     }
   }
   return plan;
@@ -13356,6 +13367,604 @@ var introspectSchema = async (executor, dialect, options = {}) => {
   return handler.introspect(ctx, options);
 };
 
+// src/core/ddl/schema-dialect-composer.ts
+var composeSchemaDialect = (config) => {
+  const quoteIdentifier9 = (id) => config.quoteIdentifier(id);
+  const formatTableName = (table) => table.schema ? `${quoteIdentifier9(table.schema)}.${quoteIdentifier9(table.name)}` : quoteIdentifier9(table.name);
+  let services;
+  const renderDefault = (value, column) => config.renderDefault?.(value, column, services) ?? formatLiteral(config.literalFormatter, value);
+  services = {
+    name: config.name,
+    quoteIdentifier: quoteIdentifier9,
+    formatTableName,
+    renderDefault
+  };
+  const mutations = config.mutations?.(services) ?? {};
+  return {
+    name: config.name,
+    mutations,
+    quoteIdentifier: quoteIdentifier9,
+    formatTableName,
+    renderColumnType: (column) => config.renderColumnType(column, services),
+    renderDefault,
+    renderAutoIncrement: (column, table) => config.renderAutoIncrement(column, table, services),
+    renderReference(ref, table) {
+      const parts = [
+        "REFERENCES",
+        quoteQualified({ quoteIdentifier: quoteIdentifier9 }, ref.table),
+        `(${quoteIdentifier9(ref.column)})`
+      ];
+      if (ref.onDelete) parts.push("ON DELETE", ref.onDelete);
+      if (ref.onUpdate) parts.push("ON UPDATE", ref.onUpdate);
+      const suffix = config.renderReferenceSuffix?.(ref, table, services);
+      if (suffix) parts.push(suffix);
+      return parts.join(" ");
+    },
+    renderIndex: (table, index) => config.renderIndex(table, index, services),
+    renderTableOptions: (table) => config.renderTableOptions?.(table, services),
+    supportsPartialIndexes: () => config.supportsPartialIndexes ?? false,
+    preferInlinePkAutoincrement: (column, table, pk) => config.preferInlinePkAutoincrement?.(column, table, pk, services) ?? false
+  };
+};
+var createStandardDropTableCapability = (services) => ({
+  compile: (table) => [`DROP TABLE IF EXISTS ${services.formatTableName(table)};`]
+});
+var createStandardDropColumnCapability = (services) => ({
+  compile: (table, column) => [
+    `ALTER TABLE ${services.formatTableName(table)} DROP COLUMN ${services.quoteIdentifier(column)};`
+  ]
+});
+
+// src/core/ddl/dialects/postgres-schema-dialect.ts
+var quoteIdentifier5 = (id) => `"${id}"`;
+var literalFormatter = createLiteralFormatter();
+var renderPostgresColumnType = (column, services) => {
+  const override = column.dialectTypes?.[services.name] ?? column.dialectTypes?.default;
+  if (override) return renderTypeWithArgs(override, column.args);
+  const type = normalizeColumnType(column.type);
+  switch (type) {
+    case "int":
+    case "integer":
+      return "integer";
+    case "bigint":
+      return "bigint";
+    case "uuid":
+      return "uuid";
+    case "boolean":
+      return "boolean";
+    case "json":
+      return "jsonb";
+    case "decimal":
+      return column.args?.length ? `numeric(${column.args[0]}, ${column.args[1] ?? 0})` : "numeric";
+    case "float":
+    case "double":
+      return "double precision";
+    case "timestamptz":
+      return "timestamptz";
+    case "timestamp":
+      return "timestamp";
+    case "date":
+      return "date";
+    case "datetime":
+      return "timestamp";
+    case "varchar":
+      return column.args?.length ? `varchar(${column.args[0]})` : "varchar";
+    case "text":
+      return "text";
+    case "enum":
+      return "text";
+    case "binary":
+    case "varbinary":
+    case "blob":
+    case "bytea":
+      return "bytea";
+    case "vector":
+      return column.vectorOptions?.elementType === "float16" ? `halfvec(${column.vectorOptions.dimensions})` : column.args?.length ? `vector(${column.args[0]})` : "vector";
+    case "halfvec":
+      return column.args?.length ? `halfvec(${column.args[0]})` : "halfvec";
+    default:
+      return renderTypeWithArgs(String(type).toLowerCase(), column.args);
+  }
+};
+var renderPostgresIndex = (table, index, services) => {
+  const name = index.name || deriveIndexName(table, index);
+  let columns = renderIndexColumns(services, index.columns);
+  if (index.ops) columns = `${columns} ${index.ops}`;
+  const unique = index.unique ? "UNIQUE " : "";
+  const using = index.using ? ` USING ${index.using}` : "";
+  let withClause = "";
+  if (index.with) {
+    if (typeof index.with === "string") {
+      withClause = ` WITH (${index.with})`;
+    } else {
+      const params = Object.entries(index.with).map(([key, value]) => `${key} = ${value}`).join(", ");
+      withClause = ` WITH (${params})`;
+    }
+  }
+  const where = index.where ? ` WHERE ${index.where}` : "";
+  return `CREATE ${unique}INDEX IF NOT EXISTS ${services.quoteIdentifier(name)} ON ${services.formatTableName(table)}${using} (${columns})${withClause}${where};`;
+};
+var createPostgresSchemaDialect = () => composeSchemaDialect({
+  name: "postgres",
+  quoteIdentifier: quoteIdentifier5,
+  literalFormatter,
+  renderColumnType: renderPostgresColumnType,
+  renderAutoIncrement: (column) => {
+    if (!column.autoIncrement) return void 0;
+    const strategy = column.generated === "always" ? "GENERATED ALWAYS" : "GENERATED BY DEFAULT";
+    return `${strategy} AS IDENTITY`;
+  },
+  renderIndex: renderPostgresIndex,
+  renderReferenceSuffix: (ref) => ref.deferrable ? "DEFERRABLE INITIALLY DEFERRED" : void 0,
+  supportsPartialIndexes: true,
+  mutations: (services) => ({
+    dropTable: createStandardDropTableCapability(services),
+    dropColumn: createStandardDropColumnCapability(services),
+    dropIndex: {
+      compile(table, index) {
+        const qualified = table.schema ? `${services.quoteIdentifier(table.schema)}.${services.quoteIdentifier(index)}` : services.quoteIdentifier(index);
+        return [`DROP INDEX IF EXISTS ${qualified};`];
+      }
+    },
+    alterColumn: {
+      compile(table, column, actualColumn, diff) {
+        void actualColumn;
+        const statements = [];
+        const tableName = services.formatTableName(table);
+        const columnName = services.quoteIdentifier(column.name);
+        if (diff.typeChanged) {
+          statements.push(
+            `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} TYPE ${renderPostgresColumnType(column, services)};`
+          );
+        }
+        if (diff.defaultChanged) {
+          statements.push(
+            column.default === void 0 ? `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP DEFAULT;` : `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET DEFAULT ${services.renderDefault(column.default, column)};`
+          );
+        }
+        if (diff.nullabilityChanged) {
+          statements.push(
+            `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} ${column.notNull ? "SET" : "DROP"} NOT NULL;`
+          );
+        }
+        if (diff.autoIncrementChanged) {
+          if (column.autoIncrement) {
+            const strategy = column.generated === "always" ? "ALWAYS" : "BY DEFAULT";
+            statements.push(
+              `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} ADD GENERATED ${strategy} AS IDENTITY;`
+            );
+          } else {
+            statements.push(`ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP IDENTITY IF EXISTS;`);
+          }
+        }
+        return statements;
+      },
+      warning(table, column, actualColumn, diff) {
+        void table;
+        void column;
+        void actualColumn;
+        return diff.autoIncrementChanged ? "Altering identity properties may fail if an existing sequence is attached; verify generated column state." : void 0;
+      }
+    }
+  })
+});
+var PostgresSchemaDialect = class {
+  delegate = createPostgresSchemaDialect();
+  name = this.delegate.name;
+  mutations = this.delegate.mutations;
+  quoteIdentifier(id) {
+    return this.delegate.quoteIdentifier(id);
+  }
+  formatTableName(table) {
+    return this.delegate.formatTableName(table);
+  }
+  renderColumnType(column) {
+    return this.delegate.renderColumnType(column);
+  }
+  renderDefault(value, column) {
+    return this.delegate.renderDefault(value, column);
+  }
+  renderAutoIncrement(column, table) {
+    return this.delegate.renderAutoIncrement(column, table);
+  }
+  renderReference(ref, table) {
+    return this.delegate.renderReference(ref, table);
+  }
+  renderIndex(table, index) {
+    return this.delegate.renderIndex(table, index);
+  }
+  renderTableOptions(table) {
+    return this.delegate.renderTableOptions(table);
+  }
+  supportsPartialIndexes() {
+    return this.delegate.supportsPartialIndexes();
+  }
+  preferInlinePkAutoincrement(column, table, pk) {
+    return this.delegate.preferInlinePkAutoincrement(column, table, pk);
+  }
+};
+
+// src/core/ddl/dialects/mysql-schema-dialect.ts
+var quoteIdentifier6 = (id) => `\`${id}\``;
+var literalFormatter2 = createLiteralFormatter({ booleanTrue: "1", booleanFalse: "0" });
+var renderMySqlColumnType = (column, services) => {
+  const override = column.dialectTypes?.[services.name] ?? column.dialectTypes?.default;
+  if (override) return renderTypeWithArgs(override, column.args);
+  const type = normalizeColumnType(column.type);
+  switch (type) {
+    case "int":
+    case "integer":
+      return "INT";
+    case "bigint":
+      return "BIGINT";
+    case "uuid":
+      return "CHAR(36)";
+    case "boolean":
+      return "TINYINT(1)";
+    case "json":
+      return "JSON";
+    case "decimal":
+      return column.args?.length ? `DECIMAL(${column.args[0]},${column.args[1] ?? 0})` : "DECIMAL";
+    case "float":
+      return column.args?.length ? `FLOAT(${column.args[0]})` : "FLOAT";
+    case "double":
+      return "DOUBLE";
+    case "timestamptz":
+    case "timestamp":
+      return "TIMESTAMP";
+    case "datetime":
+      return "DATETIME";
+    case "date":
+      return "DATE";
+    case "varchar":
+      return column.args?.length ? `VARCHAR(${column.args[0]})` : "VARCHAR(255)";
+    case "text":
+      return "TEXT";
+    case "binary":
+      return column.args?.length ? `BINARY(${column.args[0]})` : "BINARY(255)";
+    case "varbinary":
+      return column.args?.length ? `VARBINARY(${column.args[0]})` : "VARBINARY(255)";
+    case "blob":
+    case "bytea":
+      return "BLOB";
+    case "enum":
+      return column.args?.length ? `ENUM(${column.args.map((value) => `'${escapeSqlString(String(value))}'`).join(",")})` : "ENUM";
+    case "vector":
+    case "halfvec": {
+      const dimensions = column.vectorOptions?.dimensions ?? column.args?.[0] ?? 3;
+      return `VECTOR(${dimensions})`;
+    }
+    default:
+      return renderTypeWithArgs(String(type).toUpperCase(), column.args);
+  }
+};
+var createMySqlSchemaDialect = () => {
+  let dialect;
+  dialect = composeSchemaDialect({
+    name: "mysql",
+    quoteIdentifier: quoteIdentifier6,
+    literalFormatter: literalFormatter2,
+    renderColumnType: renderMySqlColumnType,
+    renderAutoIncrement: (column) => column.autoIncrement ? "AUTO_INCREMENT" : void 0,
+    renderIndex(table, index, services) {
+      if (index.where) throw new Error("MySQL does not support partial/filtered indexes");
+      const name = index.name || deriveIndexName(table, index);
+      const columns = renderIndexColumns(services, index.columns);
+      const unique = index.unique ? "UNIQUE " : "";
+      return `CREATE ${unique}INDEX ${services.quoteIdentifier(name)} ON ${services.formatTableName(table)} (${columns});`;
+    },
+    renderTableOptions(table) {
+      const parts = [];
+      if (table.engine) parts.push(`ENGINE=${table.engine}`);
+      if (table.charset) parts.push(`DEFAULT CHARSET=${table.charset}`);
+      if (table.collation) parts.push(`COLLATE=${table.collation}`);
+      return parts.length ? parts.join(" ") : void 0;
+    },
+    mutations: (services) => ({
+      dropTable: createStandardDropTableCapability(services),
+      dropColumn: createStandardDropColumnCapability(services),
+      dropIndex: {
+        compile: (table, index) => [
+          `DROP INDEX ${services.quoteIdentifier(index)} ON ${services.formatTableName(table)};`
+        ]
+      },
+      alterColumn: {
+        compile(table, column, actualColumn, diff) {
+          void actualColumn;
+          void diff;
+          const rendered = renderColumnDefinition(table, column, dialect);
+          return [`ALTER TABLE ${services.formatTableName(table)} MODIFY COLUMN ${rendered.sql};`];
+        }
+      }
+    })
+  });
+  return dialect;
+};
+var MySqlSchemaDialect = class {
+  delegate = createMySqlSchemaDialect();
+  name = this.delegate.name;
+  mutations = this.delegate.mutations;
+  quoteIdentifier(id) {
+    return this.delegate.quoteIdentifier(id);
+  }
+  formatTableName(table) {
+    return this.delegate.formatTableName(table);
+  }
+  renderColumnType(column) {
+    return this.delegate.renderColumnType(column);
+  }
+  renderDefault(value, column) {
+    return this.delegate.renderDefault(value, column);
+  }
+  renderAutoIncrement(column, table) {
+    return this.delegate.renderAutoIncrement(column, table);
+  }
+  renderReference(ref, table) {
+    return this.delegate.renderReference(ref, table);
+  }
+  renderIndex(table, index) {
+    return this.delegate.renderIndex(table, index);
+  }
+  renderTableOptions(table) {
+    return this.delegate.renderTableOptions(table);
+  }
+  supportsPartialIndexes() {
+    return this.delegate.supportsPartialIndexes();
+  }
+  preferInlinePkAutoincrement(column, table, pk) {
+    return this.delegate.preferInlinePkAutoincrement(column, table, pk);
+  }
+};
+
+// src/core/ddl/dialects/sqlite-schema-dialect.ts
+var quoteIdentifier7 = (id) => `"${id}"`;
+var literalFormatter3 = createLiteralFormatter({ booleanTrue: "1", booleanFalse: "0" });
+var renderSqliteColumnType = (column, services) => {
+  const override = column.dialectTypes?.[services.name] ?? column.dialectTypes?.default;
+  if (override) return renderTypeWithArgs(override, column.args);
+  const type = normalizeColumnType(column.type);
+  switch (type) {
+    case "int":
+    case "integer":
+    case "bigint":
+    case "boolean":
+      return "INTEGER";
+    case "decimal":
+    case "float":
+    case "double":
+      return "REAL";
+    case "date":
+    case "datetime":
+    case "timestamp":
+    case "timestamptz":
+    case "varchar":
+    case "text":
+    case "json":
+    case "uuid":
+    case "enum":
+      return "TEXT";
+    case "binary":
+    case "varbinary":
+    case "blob":
+    case "bytea":
+      return "BLOB";
+    case "halfvec": {
+      const dimensions = column.vectorOptions?.dimensions ?? column.args?.[0] ?? 3;
+      return `float16[${dimensions}]`;
+    }
+    case "vector": {
+      const dimensions = column.vectorOptions?.dimensions ?? column.args?.[0] ?? 3;
+      const elementType = column.vectorOptions?.elementType === "float16" ? "float16" : "float32";
+      return `${elementType}[${dimensions}]`;
+    }
+    default:
+      return "TEXT";
+  }
+};
+var createSqliteSchemaDialect = () => composeSchemaDialect({
+  name: "sqlite",
+  quoteIdentifier: quoteIdentifier7,
+  literalFormatter: literalFormatter3,
+  renderColumnType: renderSqliteColumnType,
+  renderAutoIncrement(column, table) {
+    const primaryKey = resolvePrimaryKey(table);
+    return column.autoIncrement && primaryKey.length === 1 && primaryKey[0] === column.name ? "PRIMARY KEY AUTOINCREMENT" : void 0;
+  },
+  preferInlinePkAutoincrement: (column, table, primaryKey) => {
+    void table;
+    return !!(column.autoIncrement && primaryKey.length === 1 && primaryKey[0] === column.name);
+  },
+  renderIndex(table, index, services) {
+    const name = index.name || deriveIndexName(table, index);
+    const columns = renderIndexColumns(services, index.columns);
+    const unique = index.unique ? "UNIQUE " : "";
+    const where = index.where ? ` WHERE ${index.where}` : "";
+    return `CREATE ${unique}INDEX IF NOT EXISTS ${services.quoteIdentifier(name)} ON ${services.formatTableName(table)} (${columns})${where};`;
+  },
+  supportsPartialIndexes: true,
+  mutations: (services) => ({
+    dropTable: createStandardDropTableCapability(services),
+    dropIndex: {
+      compile: (_table, index) => [`DROP INDEX IF EXISTS ${services.quoteIdentifier(index)};`]
+    }
+  })
+});
+var SQLiteSchemaDialect = class {
+  delegate = createSqliteSchemaDialect();
+  name = this.delegate.name;
+  mutations = this.delegate.mutations;
+  quoteIdentifier(id) {
+    return this.delegate.quoteIdentifier(id);
+  }
+  formatTableName(table) {
+    return this.delegate.formatTableName(table);
+  }
+  renderColumnType(column) {
+    return this.delegate.renderColumnType(column);
+  }
+  renderDefault(value, column) {
+    return this.delegate.renderDefault(value, column);
+  }
+  renderAutoIncrement(column, table) {
+    return this.delegate.renderAutoIncrement(column, table);
+  }
+  renderReference(ref, table) {
+    return this.delegate.renderReference(ref, table);
+  }
+  renderIndex(table, index) {
+    return this.delegate.renderIndex(table, index);
+  }
+  renderTableOptions(table) {
+    return this.delegate.renderTableOptions(table);
+  }
+  supportsPartialIndexes() {
+    return this.delegate.supportsPartialIndexes();
+  }
+  preferInlinePkAutoincrement(column, table, pk) {
+    return this.delegate.preferInlinePkAutoincrement(column, table, pk);
+  }
+};
+
+// src/core/ddl/dialects/mssql-schema-dialect.ts
+var quoteIdentifier8 = (id) => `[${id.replace(/]/g, "]]")}]`;
+var literalFormatter4 = createLiteralFormatter({ booleanTrue: "1", booleanFalse: "0" });
+var renderMssqlColumnType = (column, services) => {
+  const override = column.dialectTypes?.[services.name] ?? column.dialectTypes?.default;
+  if (override) return renderTypeWithArgs(override, column.args);
+  const type = normalizeColumnType(column.type);
+  switch (type) {
+    case "int":
+    case "integer":
+      return "INT";
+    case "bigint":
+      return "BIGINT";
+    case "uuid":
+      return "UNIQUEIDENTIFIER";
+    case "boolean":
+      return "BIT";
+    case "json":
+      return "NVARCHAR(MAX)";
+    case "decimal":
+      return column.args?.length ? `DECIMAL(${column.args[0]},${column.args[1] ?? 0})` : "DECIMAL(18,0)";
+    case "float":
+    case "double":
+      return "FLOAT";
+    case "timestamptz":
+    case "timestamp":
+    case "datetime":
+      return "DATETIME2";
+    case "date":
+      return "DATE";
+    case "varchar":
+      return column.args?.length ? `NVARCHAR(${column.args[0]})` : "NVARCHAR(255)";
+    case "text":
+      return "NVARCHAR(MAX)";
+    case "binary": {
+      const length2 = column.args?.[0];
+      return length2 !== void 0 ? `BINARY(${length2})` : "BINARY(255)";
+    }
+    case "varbinary": {
+      const length2 = column.args?.[0];
+      if (typeof length2 === "string" && length2.toLowerCase() === "max") return "VARBINARY(MAX)";
+      return length2 !== void 0 ? `VARBINARY(${length2})` : "VARBINARY(255)";
+    }
+    case "blob":
+    case "bytea":
+      return "VARBINARY(MAX)";
+    case "enum":
+      return "NVARCHAR(255)";
+    case "vector": {
+      const dimensions = column.vectorOptions?.dimensions ?? column.args?.[0] ?? 3;
+      const elementType = column.vectorOptions?.elementType;
+      return elementType ? `VECTOR(${dimensions}, ${elementType})` : `VECTOR(${dimensions})`;
+    }
+    case "halfvec": {
+      const dimensions = column.vectorOptions?.dimensions ?? column.args?.[0] ?? 3;
+      return `VECTOR(${dimensions}, float16)`;
+    }
+    default:
+      return renderTypeWithArgs(String(type).toUpperCase(), column.args);
+  }
+};
+var createMssqlSchemaDialect = () => composeSchemaDialect({
+  name: "mssql",
+  quoteIdentifier: quoteIdentifier8,
+  literalFormatter: literalFormatter4,
+  renderColumnType: renderMssqlColumnType,
+  renderAutoIncrement: (column) => column.autoIncrement ? "IDENTITY(1,1)" : void 0,
+  renderIndex(table, index, services) {
+    const name = index.name || deriveIndexName(table, index);
+    const columns = renderIndexColumns(services, index.columns);
+    const unique = index.unique ? "UNIQUE " : "";
+    const where = index.where ? ` WHERE ${index.where}` : "";
+    return `CREATE ${unique}INDEX ${services.quoteIdentifier(name)} ON ${services.formatTableName(table)} (${columns})${where};`;
+  },
+  supportsPartialIndexes: true,
+  mutations: (services) => ({
+    dropTable: createStandardDropTableCapability(services),
+    dropColumn: createStandardDropColumnCapability(services),
+    dropIndex: {
+      compile: (table, index) => [
+        `DROP INDEX ${services.quoteIdentifier(index)} ON ${services.formatTableName(table)};`
+      ]
+    },
+    alterColumn: {
+      compile(table, column, actualColumn, diff) {
+        void actualColumn;
+        const statements = [];
+        if (diff.typeChanged || diff.nullabilityChanged) {
+          const nullability = column.notNull ? "NOT NULL" : "NULL";
+          statements.push(
+            `ALTER TABLE ${services.formatTableName(table)} ALTER COLUMN ${services.quoteIdentifier(column.name)} ${renderMssqlColumnType(column, services)} ${nullability};`
+          );
+        }
+        return statements;
+      },
+      warning(table, column, actualColumn, diff) {
+        void table;
+        void column;
+        void actualColumn;
+        return diff.defaultChanged || diff.autoIncrementChanged ? "Altering defaults or identity on MSSQL is not automated (requires dropping/adding default or identity constraints manually)." : void 0;
+      }
+    }
+  })
+});
+var MSSqlSchemaDialect = class {
+  delegate = createMssqlSchemaDialect();
+  name = this.delegate.name;
+  mutations = this.delegate.mutations;
+  quoteIdentifier(id) {
+    return this.delegate.quoteIdentifier(id);
+  }
+  formatTableName(table) {
+    return this.delegate.formatTableName(table);
+  }
+  renderColumnType(column) {
+    return this.delegate.renderColumnType(column);
+  }
+  renderDefault(value, column) {
+    return this.delegate.renderDefault(value, column);
+  }
+  renderAutoIncrement(column, table) {
+    return this.delegate.renderAutoIncrement(column, table);
+  }
+  renderReference(ref, table) {
+    return this.delegate.renderReference(ref, table);
+  }
+  renderIndex(table, index) {
+    return this.delegate.renderIndex(table, index);
+  }
+  renderTableOptions(table) {
+    return this.delegate.renderTableOptions(table);
+  }
+  supportsPartialIndexes() {
+    return this.delegate.supportsPartialIndexes();
+  }
+  preferInlinePkAutoincrement(column, table, pk) {
+    return this.delegate.preferInlinePkAutoincrement(column, table, pk);
+  }
+};
+
 // src/core/functions/numeric.ts
 var isColumnDef2 = (val) => !!val && typeof val === "object" && "type" in val && "name" in val;
 var toOperand3 = (input) => {
@@ -21839,7 +22448,6 @@ export {
   DefaultMorphToReference,
   DefaultTypeStrategy,
   DeleteQueryBuilder,
-  DialectBase,
   DialectFactory,
   DomainEventBus,
   Email,
@@ -21853,6 +22461,7 @@ export {
   KeyvCacheAdapter,
   Length,
   Lower,
+  MSSqlSchemaDialect,
   MemoryCacheAdapter,
   MorphMany,
   MorphOne,
@@ -21865,6 +22474,7 @@ export {
   MssqlUpdateCompiler,
   MySqlDialect,
   MySqlProcedureCompiler,
+  MySqlSchemaDialect,
   MySqlUpsertStrategy,
   NestedSetStrategy,
   NoReturningStrategy,
@@ -21876,6 +22486,7 @@ export {
   PostgresDialect,
   PostgresProcedureCompiler,
   PostgresReturningStrategy,
+  PostgresSchemaDialect,
   PostgresUpsertStrategy,
   PrimaryKey,
   ProcedureCallBuilder,
@@ -21883,9 +22494,9 @@ export {
   QueryCacheManager,
   RedisCacheAdapter,
   RelationKinds,
+  SQLiteSchemaDialect,
   STANDARD_COLUMN_TYPES,
   SelectQueryBuilder,
-  SqlDialectBase,
   SqlServerDialect,
   SqliteDialect,
   SqliteReturningStrategy,
@@ -21967,6 +22578,8 @@ export {
   columnToOpenApiSchema,
   columnTypeToOpenApiFormat,
   columnTypeToOpenApiType,
+  composeSchemaDialect,
+  composeSqlDialect,
   computePaginationMetadata,
   computeSchemaHash,
   concat,
@@ -21984,14 +22597,26 @@ export {
   createEntityFromRow,
   createEntityProxy,
   createExecutorFromQueryRunner,
+  createLiteralFormatter,
   createMssqlCompilerSet,
   createMssqlExecutor,
+  createMssqlSchemaDialect,
+  createMySqlDialect,
+  createMySqlSchemaDialect,
   createMysqlExecutor,
   createPooledExecutorFactory,
+  createPostgresDialect,
   createPostgresExecutor,
+  createPostgresSchemaDialect,
   createQueryLoggingExecutor,
   createRef,
+  createSqlDialect,
+  createSqlServerDialect,
+  createSqliteDialect,
   createSqliteExecutor,
+  createSqliteSchemaDialect,
+  createStandardDropColumnCapability,
+  createStandardDropTableCapability,
   createTediousExecutor,
   createTediousMssqlClient,
   createTreeManager,