@vibeorm/migrate 1.3.1 → 2.0.0-alpha.2

package/dist/index.js

@@ -0,0 +1,3858 @@
+// @bun
+// packages/migrate/src/types.ts
+function describeStep(params) {
+  const { step } = params;
+  switch (step.kind) {
+    case "createEnum":
+      return `create enum "${step.enumDef.dbName ?? step.enumDef.name}"`;
+    case "dropEnum":
+      return `drop enum "${step.enumName}"`;
+    case "addEnumValue":
+      return `add value "${step.value}" to enum "${step.enumName}"`;
+    case "createTable":
+      return `create table "${step.table}"`;
+    case "dropTable":
+      return `drop table "${step.table}"`;
+    case "addColumn":
+      return `add column "${step.table}"."${step.column.dbName ?? step.column.name}"`;
+    case "dropColumn":
+      return `drop column "${step.table}"."${step.column}"`;
+    case "alterColumn":
+      return `alter column "${step.table}"."${step.column}" (${step.changes.join(", ")})`;
+    case "createIndex":
+      return `create ${step.unique ? "unique " : ""}index "${step.name}" on "${step.table}"`;
+    case "dropIndex":
+      return `drop index "${step.name}"`;
+    case "addForeignKey":
+      return `add foreign key "${step.constraintName}" on "${step.table}"`;
+    case "dropForeignKey":
+      return `drop foreign key "${step.constraintName}" on "${step.table}"`;
+    case "createJoinTable":
+      return `create join table "${step.table}"`;
+    case "dropJoinTable":
+      return `drop join table "${step.table}"`;
+    case "addPrimaryKey":
+      return `add primary key on "${step.table}"`;
+    case "dropPrimaryKey":
+      return `drop primary key on "${step.table}"`;
+    case "dropView":
+      return `drop view "${step.table}"`;
+  }
+}
+// packages/migrate/src/differ.ts
+import { isEnumType as isEnumType4, unsupportedCapability as unsupportedCapability3 } from "@vibeorm/schema";
+
+// packages/migrate/src/enum-values.ts
+function resolveEnumValues(params) {
+  const { name, enums } = params;
+  const direct = enums.get(name);
+  if (direct !== undefined)
+    return direct.values;
+  for (const enumDef of enums.values()) {
+    if (enumDef.name === name)
+      return enumDef.values;
+  }
+  return;
+}
+
+// packages/migrate/src/normalize.ts
+import { VibeError as VibeError4 } from "@vibeorm/schema";
+
+// packages/migrate/src/relations.ts
+import { implicitJoinTable } from "@vibeorm/schema";
+function detectImplicitM2MPairs(params) {
+  const { schema } = params;
+  const modelsByName = new Map(schema.models.map((model) => [model.name, model]));
+  const pairs = [];
+  const seen = new Set;
+  for (const model of schema.models) {
+    if (model.isView)
+      continue;
+    for (const relation of model.relations) {
+      if (!isFieldlessListSide({ relation }))
+        continue;
+      const target = modelsByName.get(relation.targetModel);
+      if (target === undefined || target.isView)
+        continue;
+      const counterpart = soleCounterpart({ relation, ownModel: model.name, target });
+      if (counterpart === undefined || !isFieldlessListSide({ relation: counterpart }))
+        continue;
+      if (soleCounterpart({ relation: counterpart, ownModel: target.name, target: model }) !== relation) {
+        continue;
+      }
+      const joinTable = implicitJoinTable({
+        modelA: model.name,
+        modelB: relation.targetModel,
+        ...relation.relationName === undefined ? {} : { relationName: relation.relationName }
+      });
+      if (seen.has(joinTable.tableName))
+        continue;
+      seen.add(joinTable.tableName);
+      pairs.push({
+        modelA: joinTable.modelA,
+        modelB: joinTable.modelB,
+        ...relation.relationName === undefined ? {} : { relationName: relation.relationName },
+        tableName: joinTable.tableName
+      });
+    }
+  }
+  return pairs;
+}
+function isFieldlessListSide(params) {
+  const { relation } = params;
+  return relation.isList && (relation.fields === undefined || relation.fields.length === 0);
+}
+function soleCounterpart(params) {
+  const { relation, ownModel, target } = params;
+  const candidates = target.relations.filter((candidate) => candidate !== relation && candidate.targetModel === ownModel && candidate.relationName === relation.relationName);
+  return candidates.length === 1 ? candidates[0] : undefined;
+}
+
+// packages/migrate/src/postgres-types.ts
+import { VibeError, isEnumType } from "@vibeorm/schema";
+import { postgresDialect } from "@vibeorm/sql";
+var SCALAR_TO_PG = {
+  String: "text",
+  Boolean: "boolean",
+  Int: "integer",
+  BigInt: "bigint",
+  Float: "double precision",
+  Decimal: "numeric",
+  DateTime: "timestamptz",
+  Json: "jsonb",
+  Bytes: "bytea"
+};
+var CANONICAL_EQUIVALENTS = {
+  DateTime: ["timestamptz(3)", "timestamptz(6)"]
+};
+var NATIVE_ALIASES = {
+  charactervarying: "varchar",
+  character: "char",
+  bpchar: "char",
+  int: "integer",
+  int4: "integer",
+  int2: "smallint",
+  int8: "bigint",
+  serial: "integer",
+  bigserial: "bigint",
+  bool: "boolean",
+  float4: "real",
+  float8: "doubleprecision",
+  double: "doubleprecision",
+  doubleprecision: "doubleprecision",
+  decimal: "numeric",
+  timestampwithtimezone: "timestamptz",
+  timestampwithouttimezone: "timestamp",
+  timewithtimezone: "timetz",
+  timewithouttimezone: "time"
+};
+function normalizeNativeType(params) {
+  const compact = params.raw.toLowerCase().replace(/\s+/g, "");
+  const match = compact.match(/^([a-z_0-9]+)(\(.*\))?(\[\])?$/);
+  if (match === null)
+    return compact;
+  const base = NATIVE_ALIASES[match[1]] ?? match[1];
+  return `${base}${match[2] ?? ""}${match[3] ?? ""}`;
+}
+function columnTypeKey(params) {
+  const { field } = params;
+  const listSuffix = field.isList ? "[]" : "";
+  if (field.isUnsupported === true) {
+    return `u:${normalizeNativeType({ raw: field.nativeType ?? "" })}`;
+  }
+  if (isEnumType(field.type)) {
+    return `e:${field.type.enum}${listSuffix}`;
+  }
+  if (field.nativeType !== undefined) {
+    const normalized = normalizeNativeType({ raw: field.nativeType });
+    const canonical = normalizeNativeType({ raw: SCALAR_TO_PG[field.type] });
+    const isCanonical = normalized === canonical || (CANONICAL_EQUIVALENTS[field.type]?.includes(normalized) ?? false);
+    if (!isCanonical)
+      return `n:${normalized}${listSuffix}`;
+  }
+  return `s:${field.type}${listSuffix}`;
+}
+function isScalarToArrayChange(params) {
+  const { from, to } = params;
+  if (from.isList || !to.isList)
+    return false;
+  const fromBase = columnTypeKey({ field: { ...from, isList: false } });
+  const toBase = columnTypeKey({ field: { ...to, isList: false } });
+  return fromBase === toBase;
+}
+function columnTypeSql(params) {
+  const { field } = params;
+  if (field.isUnsupported === true) {
+    if (field.nativeType === undefined) {
+      throw new VibeError({
+        code: "VIBE_MIGRATION",
+        message: `unsupported column "${field.name}" carries no native type to render`,
+        meta: { field: field.name }
+      });
+    }
+    return field.nativeType;
+  }
+  const listSuffix = field.isList ? "[]" : "";
+  if (isEnumType(field.type)) {
+    return `${postgresDialect.quoteIdent({ name: field.type.enum })}${listSuffix}`;
+  }
+  if (field.nativeType !== undefined) {
+    const normalized = normalizeNativeType({ raw: field.nativeType });
+    const canonical = normalizeNativeType({ raw: SCALAR_TO_PG[field.type] });
+    if (normalized !== canonical)
+      return `${field.nativeType.toLowerCase()}${listSuffix}`;
+  }
+  return `${SCALAR_TO_PG[field.type]}${listSuffix}`;
+}
+function isIdentityColumn(params) {
+  const { field } = params;
+  return field.default?.kind === "autoincrement" && !field.isList && !isEnumType(field.type) && (field.type === "Int" || field.type === "BigInt");
+}
+function defaultFingerprint(params) {
+  const { field } = params;
+  const def = field.default;
+  if (def === undefined)
+    return null;
+  switch (def.kind) {
+    case "autoincrement":
+      return "autoincrement";
+    case "now":
+      return "now";
+    case "uuid":
+    case "cuid":
+    case "nanoid":
+    case "ulid":
+      return null;
+    case "literal": {
+      const value = def.value;
+      if (typeof value === "boolean")
+        return `bool:${value}`;
+      if (typeof value === "number")
+        return `num:${value}`;
+      if (isEnumType(field.type))
+        return `enum:${value}`;
+      if (isNumericScalar({ type: field.type }) && NUMERIC_LITERAL.test(value)) {
+        return `num:${Number(value)}`;
+      }
+      return `str:${value}`;
+    }
+    case "enumValue":
+      return `enum:${def.value}`;
+    case "dbgenerated":
+      return `db:${def.sql.toLowerCase().replace(/\s+/g, "")}`;
+  }
+}
+function defaultSql(params) {
+  const def = params.field.default;
+  if (def === undefined)
+    return;
+  switch (def.kind) {
+    case "autoincrement":
+    case "uuid":
+    case "cuid":
+    case "nanoid":
+    case "ulid":
+      return;
+    case "now":
+      return "CURRENT_TIMESTAMP";
+    case "literal": {
+      const value = def.value;
+      if (typeof value === "boolean")
+        return value ? "true" : "false";
+      if (typeof value === "number")
+        return String(value);
+      return quotePgString({ value });
+    }
+    case "enumValue":
+      return quotePgString({ value: def.value });
+    case "dbgenerated":
+      return def.sql;
+  }
+}
+var NUMERIC_LITERAL = /^-?\d+(\.\d+)?$/;
+function isNumericScalar(params) {
+  const { type } = params;
+  return type === "Int" || type === "BigInt" || type === "Float" || type === "Decimal";
+}
+var PG_CHAR_TO_CASCADE_ACTION = {
+  a: "NoAction",
+  r: "Restrict",
+  c: "Cascade",
+  n: "SetNull",
+  d: "SetDefault"
+};
+var CASCADE_ACTION_SQL = {
+  Cascade: "CASCADE",
+  Restrict: "RESTRICT",
+  NoAction: "NO ACTION",
+  SetNull: "SET NULL",
+  SetDefault: "SET DEFAULT"
+};
+function resolveOnDelete(params) {
+  if (params.explicit !== undefined)
+    return params.explicit;
+  return params.required ? "Restrict" : "SetNull";
+}
+function resolveOnUpdate(params) {
+  return params.explicit ?? "Cascade";
+}
+function quotePgString(params) {
+  return `'${params.value.replaceAll("'", "''")}'`;
+}
+
+// packages/migrate/src/sqlite-types.ts
+import { VibeError as VibeError2, isEnumType as isEnumType2, unsupportedCapability } from "@vibeorm/schema";
+var SCALAR_TO_SQLITE = {
+  String: "TEXT",
+  Boolean: "INTEGER",
+  Int: "INTEGER",
+  BigInt: "INTEGER",
+  Float: "REAL",
+  Decimal: "TEXT",
+  DateTime: "TEXT",
+  Json: "TEXT",
+  Bytes: "BLOB"
+};
+function refuseSqliteScalarList(params) {
+  throw unsupportedCapability({
+    dialect: "sqlite",
+    feature: `scalar list column "${params.field.name}"`,
+    hint: "sqlite has no array column type \u2014 model the list as a separate table or a Json column"
+  });
+}
+function sqliteStorageType(params) {
+  const { field } = params;
+  if (field.isUnsupported === true) {
+    if (field.nativeType === undefined) {
+      throw new VibeError2({
+        code: "VIBE_MIGRATION",
+        message: `unsupported column "${field.name}" carries no native type to render`,
+        meta: { field: field.name }
+      });
+    }
+    return field.nativeType;
+  }
+  if (field.isList)
+    refuseSqliteScalarList({ field });
+  if (isEnumType2(field.type))
+    return "TEXT";
+  return SCALAR_TO_SQLITE[field.type];
+}
+function sqliteColumnTypeKey(params) {
+  const { field, enums } = params;
+  if (field.isUnsupported === true) {
+    return `u:${(field.nativeType ?? "").toLowerCase().replace(/\s+/g, "")}`;
+  }
+  if (isEnumType2(field.type)) {
+    const values = resolveEnumValues({ name: field.type.enum, enums });
+    return values === undefined ? `e:?${field.type.enum}` : `e:${values.join("|")}`;
+  }
+  const listSuffix = field.isList ? "[]" : "";
+  return `t:${SCALAR_TO_SQLITE[field.type]}${listSuffix}`;
+}
+function sqliteDefaultFingerprint(params) {
+  const { field } = params;
+  const def = field.default;
+  if (def?.kind === "literal" && typeof def.value === "boolean") {
+    return `num:${def.value ? 1 : 0}`;
+  }
+  return defaultFingerprint({ field });
+}
+function sqliteDefaultSql(params) {
+  const def = params.field.default;
+  if (def === undefined)
+    return;
+  switch (def.kind) {
+    case "autoincrement":
+    case "uuid":
+    case "cuid":
+    case "nanoid":
+    case "ulid":
+      return;
+    case "now":
+      return "CURRENT_TIMESTAMP";
+    case "literal": {
+      const value = def.value;
+      if (typeof value === "boolean")
+        return value ? "1" : "0";
+      if (typeof value === "number")
+        return String(value);
+      return quotePgString({ value });
+    }
+    case "enumValue":
+      return quotePgString({ value: def.value });
+    case "dbgenerated":
+      return def.sql;
+  }
+}
+function sqliteEnumCheckName(params) {
+  return `${params.table}_${params.column}_enum_${params.enumName}`;
+}
+var ENUM_CHECK_PATTERN = /CONSTRAINT "((?:[^"]|"")+)_enum_((?:[^"]|"")+)" CHECK \("((?:[^"]|"")+)" IN \(([^)]*)\)\)/g;
+function parseSqliteEnumChecks(params) {
+  const result = [];
+  for (const match of params.tableSql.matchAll(ENUM_CHECK_PATTERN)) {
+    const enumName = match[2].replaceAll('""', '"');
+    const column = match[3].replaceAll('""', '"');
+    const values = [];
+    for (const value of match[4].matchAll(/'((?:[^']|'')*)'/g)) {
+      values.push(value[1].replaceAll("''", "'"));
+    }
+    result.push({ column, enumName, values });
+  }
+  return result;
+}
+
+// packages/migrate/src/mysql-types.ts
+import { VibeError as VibeError3, isEnumType as isEnumType3, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
+var SCALAR_TO_MYSQL = {
+  String: "varchar(191)",
+  Boolean: "tinyint(1)",
+  Int: "int",
+  BigInt: "bigint",
+  Float: "double",
+  Decimal: "decimal(65,30)",
+  DateTime: "datetime(3)",
+  Json: "json",
+  Bytes: "longblob"
+};
+function refuseMysqlScalarList(params) {
+  throw unsupportedCapability2({
+    dialect: "mysql",
+    feature: `scalar list column "${params.field.name}"`,
+    hint: "mysql has no array column type \u2014 model the list as a separate table or a JSON column"
+  });
+}
+var MYSQL_NATIVE_ALIASES = {
+  integer: "int",
+  dec: "decimal",
+  numeric: "decimal",
+  bool: "tinyint(1)",
+  boolean: "tinyint(1)",
+  character: "char"
+};
+function normalizeMysqlType(params) {
+  const compact = params.raw.toLowerCase().replace(/\s+/g, "");
+  if (compact === "tinyint(1)" || compact === "bool" || compact === "boolean")
+    return "tinyint(1)";
+  const match = compact.match(/^([a-z_0-9]+)(\(.*\))?(.*)$/);
+  if (match === null)
+    return compact;
+  const base = MYSQL_NATIVE_ALIASES[match[1]] ?? match[1];
+  let modifier = match[2] ?? "";
+  if (/^(tinyint|smallint|mediumint|int|bigint)$/.test(base))
+    modifier = "";
+  return `${base}${modifier}${match[3] ?? ""}`;
+}
+function mysqlColumnTypeKey(params) {
+  const { field, enums } = params;
+  if (field.isUnsupported === true) {
+    return `u:${normalizeMysqlType({ raw: field.nativeType ?? "" })}`;
+  }
+  if (isEnumType3(field.type)) {
+    const values = resolveEnumValues({ name: field.type.enum, enums });
+    return values === undefined ? `e:?${field.type.enum}` : `e:${values.join("|")}`;
+  }
+  const listSuffix = field.isList ? "[]" : "";
+  if (field.nativeType !== undefined) {
+    const normalized = normalizeMysqlType({ raw: field.nativeType });
+    const canonical = normalizeMysqlType({ raw: SCALAR_TO_MYSQL[field.type] });
+    if (normalized !== canonical)
+      return `n:${normalized}${listSuffix}`;
+  }
+  return `t:${normalizeMysqlType({ raw: SCALAR_TO_MYSQL[field.type] })}${listSuffix}`;
+}
+function mysqlDefaultFingerprint(params) {
+  return defaultFingerprint({ field: params.field });
+}
+function mysqlColumnTypeSql(params) {
+  const { field, enums } = params;
+  if (field.isUnsupported === true) {
+    if (field.nativeType === undefined) {
+      throw new VibeError3({
+        code: "VIBE_MIGRATION",
+        message: `unsupported column "${field.name}" carries no native type to render`,
+        meta: { field: field.name }
+      });
+    }
+    return field.nativeType;
+  }
+  if (field.isList)
+    refuseMysqlScalarList({ field });
+  if (isEnumType3(field.type)) {
+    const values = resolveEnumValues({ name: field.type.enum, enums });
+    if (values === undefined) {
+      throw new VibeError3({
+        code: "VIBE_MIGRATION",
+        message: `enum "${field.type.enum}" on column "${field.name}" is not declared in the schema`,
+        meta: { field: field.name, enum: field.type.enum }
+      });
+    }
+    return `ENUM(${values.map((value) => quotePgString({ value })).join(", ")})`;
+  }
+  if (field.nativeType !== undefined) {
+    const normalized = normalizeMysqlType({ raw: field.nativeType });
+    const canonical = normalizeMysqlType({ raw: SCALAR_TO_MYSQL[field.type] });
+    if (normalized !== canonical)
+      return field.nativeType.toLowerCase();
+  }
+  return SCALAR_TO_MYSQL[field.type];
+}
+function mysqlDefaultSql(params) {
+  const def = params.field.default;
+  if (def === undefined)
+    return;
+  switch (def.kind) {
+    case "autoincrement":
+    case "uuid":
+    case "cuid":
+    case "nanoid":
+    case "ulid":
+      return;
+    case "now":
+      return "CURRENT_TIMESTAMP(3)";
+    case "literal": {
+      const value = def.value;
+      if (typeof value === "boolean")
+        return value ? "1" : "0";
+      if (typeof value === "number")
+        return String(value);
+      return quotePgString({ value });
+    }
+    case "enumValue":
+      return quotePgString({ value: def.value });
+    case "dbgenerated":
+      return def.sql;
+  }
+}
+function parseMysqlEnumColumnType(params) {
+  const match = params.columnType.trim().match(/^enum\((.*)\)$/i);
+  if (match === null)
+    return null;
+  const values = [];
+  for (const value of match[1].matchAll(/'((?:[^']|'')*)'/g)) {
+    values.push(value[1].replaceAll("''", "'"));
+  }
+  return values;
+}
+
+// packages/migrate/src/normalize.ts
+function normalizeSchema(params) {
+  const { schema } = params;
+  const dialect = params.dialect ?? "postgres";
+  const enums = new Map;
+  for (const enumDef of schema.enums) {
+    enums.set(enumDef.dbName ?? enumDef.name, enumDef);
+  }
+  const tables = new Map;
+  const views = new Map;
+  for (const model of schema.models) {
+    if (model.isView) {
+      views.set(model.dbName ?? model.name, model);
+      continue;
+    }
+    const table = normalizeModel({ model, schema, dialect, enums });
+    tables.set(table.table, table);
+  }
+  const joinTables = new Map;
+  for (const pair of detectImplicitM2MPairs({ schema })) {
+    joinTables.set(pair.tableName, normalizeJoinTable({ pair, schema }));
+  }
+  return { tables, joinTables, enums, views };
+}
+function columnTypeKeyFor(params) {
+  const { field, dialect, enums } = params;
+  switch (dialect) {
+    case "postgres":
+      return columnTypeKey({ field });
+    case "sqlite":
+      return sqliteColumnTypeKey({ field, enums });
+    case "mysql":
+      return mysqlColumnTypeKey({ field, enums });
+  }
+}
+function defaultFingerprintFor(params) {
+  const { field, dialect } = params;
+  switch (dialect) {
+    case "postgres":
+      return defaultFingerprint({ field });
+    case "sqlite":
+      return sqliteDefaultFingerprint({ field });
+    case "mysql":
+      return mysqlDefaultFingerprint({ field });
+  }
+}
+function normalizeModel(params) {
+  const { model, schema, dialect, enums } = params;
+  const table = model.dbName ?? model.name;
+  const columns = new Map;
+  for (const field of model.fields) {
+    const name = field.dbName ?? field.name;
+    columns.set(name, {
+      name,
+      field,
+      typeKey: columnTypeKeyFor({ field, dialect, enums }),
+      nullable: field.isOptional,
+      defaultKey: defaultFingerprintFor({ field, dialect })
+    });
+  }
+  const pk = normalizePk({ model });
+  const indexes = normalizeIndexes({ model, table });
+  const fks = normalizeFks({ model, table, schema });
+  return { model, table, columns, pk, indexes, fks };
+}
+function normalizePk(params) {
+  const { model } = params;
+  if (model.primaryKey !== undefined && model.primaryKey.fields.length > 0) {
+    return model.primaryKey.fields.map((name) => fieldDbName({ model, name }));
+  }
+  return model.fields.filter((field) => field.isId).map((field) => field.dbName ?? field.name);
+}
+function normalizeIndexes(params) {
+  const { model, table } = params;
+  const result = new Map;
+  const add = (index) => {
+    const unique = index.kind === "unique";
+    const kind = unique ? "btree" : index.kind;
+    const columns = index.fields.map((field) => {
+      const fieldIR = model.fields.find((candidate) => candidate.name === field.name);
+      const decimal = fieldIR !== undefined && fieldIR.type === "Decimal" && fieldIR.isList !== true;
+      return {
+        name: fieldDbName({ model, name: field.name }),
+        desc: field.sort === "desc",
+        ...decimal ? { decimal: true } : {}
+      };
+    });
+    const where = index.where;
+    const key = indexComparisonKey({ unique, kind, columns, where });
+    if (result.has(key))
+      return;
+    const name = index.name ?? `${table}_${columns.map((column) => column.name).join("_")}_${unique ? "key" : "idx"}`;
+    result.set(key, {
+      key,
+      name,
+      kind,
+      unique,
+      columns,
+      ...where === undefined ? {} : { where }
+    });
+  };
+  for (const index of model.indexes)
+    add(index);
+  for (const field of model.fields) {
+    if (!field.isUnique)
+      continue;
+    add({ kind: "unique", fields: [{ name: field.name }] });
+  }
+  return result;
+}
+function indexComparisonKey(params) {
+  const { unique, kind, columns, where } = params;
+  const cols = columns.map((column) => `${column.name}${column.desc ? " desc" : ""}`).join(",");
+  return `${unique ? "u" : "i"}:${kind}:${cols}:${normalizeWhere({ where })}`;
+}
+function normalizeWhere(params) {
+  const { where } = params;
+  if (where === undefined)
+    return "";
+  return where.toLowerCase().replace(/::[a-z_0-9 ]+/g, "").replace(/[()"'\s]/g, "");
+}
+function normalizeFks(params) {
+  const { model, table, schema } = params;
+  const result = new Map;
+  for (const relation of model.relations) {
+    if (relation.fields === undefined || relation.fields.length === 0)
+      continue;
+    const target = schema.models.find((candidate) => candidate.name === relation.targetModel);
+    if (target !== undefined && target.isView)
+      continue;
+    const refTable = target === undefined ? relation.targetModel : target.dbName ?? target.name;
+    const columns = relation.fields.map((name) => fieldDbName({ model, name }));
+    const refColumns = (relation.references ?? []).map((name) => target === undefined ? name : fieldDbName({ model: target, name }));
+    const required = relation.fields.every((name) => {
+      const field = model.fields.find((candidate) => candidate.name === name);
+      return field === undefined ? true : !field.isOptional;
+    });
+    const key = `${columns.join(",")}\u2192${refTable}.${refColumns.join(",")}`;
+    if (result.has(key))
+      continue;
+    result.set(key, {
+      key,
+      constraintName: `${table}_${columns.join("_")}_fkey`,
+      columns,
+      refTable,
+      refColumns,
+      onDelete: resolveOnDelete({ explicit: relation.onDelete, required }),
+      onUpdate: resolveOnUpdate({ explicit: relation.onUpdate })
+    });
+  }
+  return result;
+}
+function normalizeJoinTable(params) {
+  const { pair, schema } = params;
+  return {
+    table: pair.tableName,
+    a: joinTableEnd({ modelName: pair.modelA, schema, joinTable: pair.tableName }),
+    b: joinTableEnd({ modelName: pair.modelB, schema, joinTable: pair.tableName })
+  };
+}
+function joinTableEnd(params) {
+  const { modelName, schema, joinTable } = params;
+  const model = schema.models.find((candidate) => candidate.name === modelName);
+  if (model === undefined) {
+    throw new VibeError4({
+      code: "VIBE_MIGRATION",
+      message: `implicit many-to-many table "${joinTable}" references unknown model "${modelName}"`,
+      meta: { joinTable, model: modelName }
+    });
+  }
+  const pkFields = model.primaryKey !== undefined && model.primaryKey.fields.length > 0 ? model.primaryKey.fields.map((name) => model.fields.find((field) => field.name === name)) : model.fields.filter((field) => field.isId);
+  const pkField = pkFields[0];
+  if (pkFields.length !== 1 || pkField === undefined) {
+    throw new VibeError4({
+      code: "VIBE_MIGRATION",
+      message: `implicit many-to-many relations require a single-column primary key on "${modelName}" (join table "${joinTable}")`,
+      meta: { joinTable, model: modelName }
+    });
+  }
+  return {
+    table: model.dbName ?? model.name,
+    column: pkField.dbName ?? pkField.name,
+    field: pkField
+  };
+}
+function fieldDbName(params) {
+  const { model, name } = params;
+  const field = model.fields.find((candidate) => candidate.name === name);
+  return field === undefined ? name : field.dbName ?? field.name;
+}
+
+// packages/migrate/src/differ.ts
+function diffSchemas(params) {
+  const dialect = params.dialect ?? "postgres";
+  if (dialect !== "postgres")
+    refuseScalarListColumns({ schema: params.to, dialect });
+  const from = normalizeSchema({ schema: params.from, dialect });
+  const to = normalizeSchema({ schema: params.to, dialect });
+  const buckets = {
+    dropView: [],
+    createEnum: [],
+    addEnumValue: [],
+    dropForeignKey: [],
+    dropIndex: [],
+    dropJoinTable: [],
+    dropTable: [],
+    createTable: [],
+    addColumn: [],
+    alterColumn: [],
+    dropColumn: [],
+    dropPrimaryKey: [],
+    addPrimaryKey: [],
+    createIndex: [],
+    addForeignKey: [],
+    createJoinTable: [],
+    dropEnum: []
+  };
+  if (dialect === "postgres")
+    diffEnums({ from, to, buckets });
+  diffViews({ from, to, buckets });
+  diffJoinTables({ from, to, buckets });
+  diffTables({ from, to, buckets, dialect });
+  return [
+    ...buckets.dropView,
+    ...buckets.createEnum,
+    ...buckets.addEnumValue,
+    ...buckets.dropForeignKey,
+    ...buckets.dropIndex,
+    ...buckets.dropJoinTable,
+    ...buckets.dropTable,
+    ...buckets.createTable,
+    ...buckets.addColumn,
+    ...buckets.alterColumn,
+    ...buckets.dropColumn,
+    ...buckets.dropPrimaryKey,
+    ...buckets.addPrimaryKey,
+    ...buckets.createIndex,
+    ...buckets.addForeignKey,
+    ...buckets.createJoinTable,
+    ...buckets.dropEnum
+  ];
+}
+function refuseScalarListColumns(params) {
+  const { schema, dialect } = params;
+  for (const model of schema.models) {
+    if (model.isView)
+      continue;
+    for (const field of model.fields) {
+      if (!field.isList || field.isUnsupported === true)
+        continue;
+      throw unsupportedCapability3({
+        dialect,
+        feature: `scalar list column "${model.name}.${field.name}"`,
+        hint: `${dialect} has no array column type \u2014 model the list as a separate table or a ${dialect === "mysql" ? "JSON" : "Json"} column`
+      });
+    }
+  }
+}
+function diffEnums(params) {
+  const { from, to, buckets } = params;
+  for (const [name, enumDef] of to.enums) {
+    const previous = from.enums.get(name);
+    if (previous === undefined) {
+      buckets.createEnum.push({ kind: "createEnum", enumDef, destructive: false });
+      continue;
+    }
+    const previousValues = new Set(previous.values);
+    const currentValues = new Set(enumDef.values);
+    for (const value of enumDef.values) {
+      if (!previousValues.has(value)) {
+        buckets.addEnumValue.push({ kind: "addEnumValue", enumName: name, value, destructive: false });
+      }
+    }
+    for (const value of previous.values) {
+      if (!currentValues.has(value)) {
+        throw unsupportedCapability3({
+          dialect: "postgres",
+          feature: `removing value "${value}" from enum "${name}"`,
+          hint: "postgres cannot drop enum values \u2014 recreate the type manually (create new type, ALTER COLUMN ... USING, drop old type)"
+        });
+      }
+    }
+  }
+  for (const [name] of from.enums) {
+    if (!to.enums.has(name)) {
+      buckets.dropEnum.push({ kind: "dropEnum", enumName: name, destructive: true });
+    }
+  }
+}
+function diffViews(params) {
+  const { from, to, buckets } = params;
+  for (const [name] of from.views) {
+    if (!to.views.has(name)) {
+      buckets.dropView.push({ kind: "dropView", table: name, destructive: true });
+    }
+  }
+}
+function diffJoinTables(params) {
+  const { from, to, buckets } = params;
+  for (const [table, joinTable] of to.joinTables) {
+    if (!from.joinTables.has(table)) {
+      buckets.createJoinTable.push({
+        kind: "createJoinTable",
+        table,
+        a: joinTable.a,
+        b: joinTable.b,
+        destructive: false
+      });
+    }
+  }
+  for (const [table] of from.joinTables) {
+    if (!to.joinTables.has(table)) {
+      buckets.dropJoinTable.push({ kind: "dropJoinTable", table, destructive: true });
+    }
+  }
+}
+function diffTables(params) {
+  const { from, to, buckets, dialect } = params;
+  for (const [name, table] of to.tables) {
+    const previous = from.tables.get(name);
+    if (previous === undefined)
+      createWholeTable({ table, buckets });
+    else
+      diffOneTable({
+        previous,
+        current: table,
+        buckets,
+        dialect,
+        fromEnums: from.enums,
+        toEnums: to.enums
+      });
+  }
+  for (const [name] of from.tables) {
+    if (to.tables.has(name))
+      continue;
+    buckets.dropTable.push({ kind: "dropTable", table: name, destructive: true });
+  }
+}
+function createWholeTable(params) {
+  const { table, buckets } = params;
+  buckets.createTable.push({
+    kind: "createTable",
+    table: table.table,
+    columns: [...table.columns.values()].map((column) => column.field),
+    primaryKey: table.pk,
+    destructive: false
+  });
+  for (const index of table.indexes.values()) {
+    buckets.createIndex.push({
+      kind: "createIndex",
+      table: table.table,
+      name: index.name,
+      indexKind: index.kind,
+      unique: index.unique,
+      columns: index.columns,
+      ...index.where === undefined ? {} : { where: index.where },
+      destructive: false
+    });
+  }
+  for (const fk of table.fks.values()) {
+    buckets.addForeignKey.push({
+      kind: "addForeignKey",
+      table: table.table,
+      constraintName: fk.constraintName,
+      columns: fk.columns,
+      refTable: fk.refTable,
+      refColumns: fk.refColumns,
+      onDelete: fk.onDelete,
+      onUpdate: fk.onUpdate,
+      destructive: false
+    });
+  }
+}
+function diffOneTable(params) {
+  const { previous, current, buckets, dialect, fromEnums, toEnums } = params;
+  const table = current.table;
+  for (const [name, column] of current.columns) {
+    const before = previous.columns.get(name);
+    if (before === undefined) {
+      buckets.addColumn.push({ kind: "addColumn", table, column: column.field, destructive: false });
+      continue;
+    }
+    const changes = [];
+    if (before.typeKey !== column.typeKey)
+      changes.push("type");
+    if (before.nullable !== column.nullable)
+      changes.push("nullability");
+    if (before.defaultKey !== column.defaultKey)
+      changes.push("default");
+    if (changes.length === 0)
+      continue;
+    let narrowingType = changes.includes("type") && !isScalarToArrayChange({ from: before.field, to: column.field });
+    if (dialect !== "postgres" && changes.includes("type") && isEnumType4(before.field.type) && isEnumType4(column.field.type)) {
+      const fromValues = resolveEnumValues({ name: before.field.type.enum, enums: fromEnums });
+      const toValues = resolveEnumValues({ name: column.field.type.enum, enums: toEnums });
+      if (fromValues !== undefined && toValues !== undefined) {
+        const removed = fromValues.filter((value) => !toValues.includes(value));
+        if (removed.length > 0) {
+          throw unsupportedCapability3({
+            dialect,
+            feature: `removing value(s) ${removed.map((value) => `"${value}"`).join(", ")} from enum column "${table}"."${name}"`,
+            hint: "migrate the stored values away first, then recreate the column with the narrower enum"
+          });
+        }
+        narrowingType = false;
+      }
+    }
+    buckets.alterColumn.push({
+      kind: "alterColumn",
+      table,
+      column: name,
+      from: before.field,
+      to: column.field,
+      changes,
+      destructive: narrowingType
+    });
+  }
+  for (const [name] of previous.columns) {
+    if (!current.columns.has(name)) {
+      buckets.dropColumn.push({ kind: "dropColumn", table, column: name, destructive: true });
+    }
+  }
+  const pkBefore = previous.pk.join(",");
+  const pkAfter = current.pk.join(",");
+  if (pkBefore !== pkAfter) {
+    if (previous.pk.length > 0) {
+      buckets.dropPrimaryKey.push({ kind: "dropPrimaryKey", table, destructive: false });
+    }
+    if (current.pk.length > 0) {
+      buckets.addPrimaryKey.push({
+        kind: "addPrimaryKey",
+        table,
+        columns: current.pk,
+        destructive: false
+      });
+    }
+  }
+  for (const [key, index] of current.indexes) {
+    if (previous.indexes.has(key))
+      continue;
+    buckets.createIndex.push({
+      kind: "createIndex",
+      table,
+      name: index.name,
+      indexKind: index.kind,
+      unique: index.unique,
+      columns: index.columns,
+      ...index.where === undefined ? {} : { where: index.where },
+      destructive: false
+    });
+  }
+  for (const [key, index] of previous.indexes) {
+    if (current.indexes.has(key))
+      continue;
+    buckets.dropIndex.push({ kind: "dropIndex", name: index.name, table, destructive: false });
+  }
+  for (const [key, fk] of current.fks) {
+    const before = previous.fks.get(key);
+    if (before === undefined) {
+      buckets.addForeignKey.push({
+        kind: "addForeignKey",
+        table,
+        constraintName: fk.constraintName,
+        columns: fk.columns,
+        refTable: fk.refTable,
+        refColumns: fk.refColumns,
+        onDelete: fk.onDelete,
+        onUpdate: fk.onUpdate,
+        destructive: false
+      });
+      continue;
+    }
+    if (before.onDelete !== fk.onDelete || before.onUpdate !== fk.onUpdate) {
+      buckets.dropForeignKey.push({
+        kind: "dropForeignKey",
+        table,
+        constraintName: before.constraintName,
+        destructive: false
+      });
+      buckets.addForeignKey.push({
+        kind: "addForeignKey",
+        table,
+        constraintName: fk.constraintName,
+        columns: fk.columns,
+        refTable: fk.refTable,
+        refColumns: fk.refColumns,
+        onDelete: fk.onDelete,
+        onUpdate: fk.onUpdate,
+        destructive: false
+      });
+    }
+  }
+  for (const [key, fk] of previous.fks) {
+    if (current.fks.has(key))
+      continue;
+    buckets.dropForeignKey.push({
+      kind: "dropForeignKey",
+      table,
+      constraintName: fk.constraintName,
+      destructive: false
+    });
+  }
+}
+// packages/migrate/src/ddl/postgres.ts
+import { VibeError as VibeError5 } from "@vibeorm/schema";
+import { postgresDialect as postgresDialect2 } from "@vibeorm/sql";
+function renderPostgresSteps(params) {
+  return params.steps.flatMap((step) => renderStep({ step }));
+}
+function renderStep(params) {
+  const { step } = params;
+  switch (step.kind) {
+    case "createEnum": {
+      const name = step.enumDef.dbName ?? step.enumDef.name;
+      const values = step.enumDef.values.map((value) => quotePgString({ value })).join(", ");
+      return [`CREATE TYPE ${q(name)} AS ENUM (${values});`];
+    }
+    case "dropEnum":
+      return [`DROP TYPE ${q(step.enumName)};`];
+    case "addEnumValue":
+      return [
+        `ALTER TYPE ${q(step.enumName)} ADD VALUE IF NOT EXISTS ${quotePgString({ value: step.value })};`
+      ];
+    case "createTable": {
+      const lines = step.columns.map((column) => `  ${columnDefSql({ field: column })}`);
+      if (step.primaryKey.length > 0) {
+        const pkCols = step.primaryKey.map((column) => q(column)).join(", ");
+        lines.push(`  CONSTRAINT ${q(`${step.table}_pkey`)} PRIMARY KEY (${pkCols})`);
+      }
+      return [`CREATE TABLE ${q(step.table)} (
+${lines.join(`,
+`)}
+);`];
+    }
+    case "dropTable":
+    case "dropJoinTable":
+      return [`DROP TABLE ${q(step.table)} CASCADE;`];
+    case "dropView":
+      return [`DROP VIEW IF EXISTS ${q(step.table)};`];
+    case "addColumn":
+      return [`ALTER TABLE ${q(step.table)} ADD COLUMN ${columnDefSql({ field: step.column })};`];
+    case "dropColumn":
+      return [`ALTER TABLE ${q(step.table)} DROP COLUMN ${q(step.column)};`];
+    case "alterColumn":
+      return renderAlterColumn({ step });
+    case "createIndex": {
+      const unique = step.unique ? "UNIQUE " : "";
+      const using = !step.unique && step.indexKind !== "btree" ? ` USING ${step.indexKind}` : "";
+      const cols = step.columns.map((column) => `${q(column.name)}${column.desc ? " DESC" : ""}`).join(", ");
+      const where = step.where === undefined ? "" : ` WHERE ${step.where}`;
+      return [
+        `CREATE ${unique}INDEX ${q(step.name)} ON ${q(step.table)}${using} (${cols})${where};`
+      ];
+    }
+    case "dropIndex":
+      return [`DROP INDEX ${q(step.name)};`];
+    case "addForeignKey": {
+      const cols = step.columns.map((column) => q(column)).join(", ");
+      const refCols = step.refColumns.map((column) => q(column)).join(", ");
+      return [
+        `ALTER TABLE ${q(step.table)} ADD CONSTRAINT ${q(step.constraintName)} FOREIGN KEY (${cols}) REFERENCES ${q(step.refTable)} (${refCols}) ON DELETE ${CASCADE_ACTION_SQL[step.onDelete]} ON UPDATE ${CASCADE_ACTION_SQL[step.onUpdate]};`
+      ];
+    }
+    case "dropForeignKey":
+      return [`ALTER TABLE ${q(step.table)} DROP CONSTRAINT ${q(step.constraintName)};`];
+    case "createJoinTable": {
+      const aType = columnTypeSql({ field: { ...step.a.field, isList: false } });
+      const bType = columnTypeSql({ field: { ...step.b.field, isList: false } });
+      return [
+        `CREATE TABLE ${q(step.table)} (
+  "A" ${aType} NOT NULL,
+  "B" ${bType} NOT NULL
+);`,
+        `CREATE UNIQUE INDEX ${q(`${step.table}_AB_unique`)} ON ${q(step.table)} ("A", "B");`,
+        `CREATE INDEX ${q(`${step.table}_B_index`)} ON ${q(step.table)} ("B");`,
+        `ALTER TABLE ${q(step.table)} ADD CONSTRAINT ${q(`${step.table}_A_fkey`)} FOREIGN KEY ("A") REFERENCES ${q(step.a.table)} (${q(step.a.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`,
+        `ALTER TABLE ${q(step.table)} ADD CONSTRAINT ${q(`${step.table}_B_fkey`)} FOREIGN KEY ("B") REFERENCES ${q(step.b.table)} (${q(step.b.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`
+      ];
+    }
+    case "addPrimaryKey": {
+      const cols = step.columns.map((column) => q(column)).join(", ");
+      return [
+        `ALTER TABLE ${q(step.table)} ADD CONSTRAINT ${q(`${step.table}_pkey`)} PRIMARY KEY (${cols});`
+      ];
+    }
+    case "dropPrimaryKey":
+      return [`ALTER TABLE ${q(step.table)} DROP CONSTRAINT ${q(`${step.table}_pkey`)};`];
+  }
+}
+function columnDefSql(params) {
+  const { field } = params;
+  const name = q(field.dbName ?? field.name);
+  if (field.default?.kind === "autoincrement" && !isIdentityColumn({ field })) {
+    throw new VibeError5({
+      code: "VIBE_MIGRATION",
+      message: `autoincrement default on "${field.name}" requires a non-list Int or BigInt column`,
+      meta: { field: field.name }
+    });
+  }
+  let def = `${name} ${columnTypeSql({ field })}`;
+  if (isIdentityColumn({ field }))
+    def += " GENERATED BY DEFAULT AS IDENTITY";
+  if (!field.isOptional)
+    def += " NOT NULL";
+  const defaultExpr = defaultSql({ field });
+  if (defaultExpr !== undefined)
+    def += ` DEFAULT ${defaultExpr}`;
+  return def;
+}
+function renderAlterColumn(params) {
+  const { step } = params;
+  const statements = [];
+  const column = q(step.column);
+  const alterPrefix = `ALTER TABLE ${q(step.table)} ALTER COLUMN ${column}`;
+  if (step.changes.includes("type")) {
+    const scalarToArray = step.to.isList && !step.from.isList ? ` USING CASE WHEN ${column} IS NULL THEN NULL ELSE ARRAY[${column}] END` : "";
+    statements.push(`${alterPrefix} SET DATA TYPE ${columnTypeSql({ field: step.to })}${scalarToArray};`);
+  }
+  if (step.changes.includes("nullability")) {
+    statements.push(`${alterPrefix} ${step.to.isOptional ? "DROP" : "SET"} NOT NULL;`);
+  }
+  if (step.changes.includes("default")) {
+    if (step.to.default?.kind === "autoincrement") {
+      throw new VibeError5({
+        code: "VIBE_MIGRATION",
+        message: `cannot add autoincrement to existing column "${step.table}"."${step.column}" \u2014 drop and recreate the column instead`,
+        meta: { table: step.table, column: step.column }
+      });
+    }
+    const defaultExpr = defaultSql({ field: step.to });
+    statements.push(defaultExpr === undefined ? `${alterPrefix} DROP DEFAULT;` : `${alterPrefix} SET DEFAULT ${defaultExpr};`);
+  }
+  return statements;
+}
+function q(name) {
+  return postgresDialect2.quoteIdent({ name });
+}
+
+// packages/migrate/src/ddl/sqlite.ts
+import { VibeError as VibeError6, isEnumType as isEnumType5, unsupportedCapability as unsupportedCapability4 } from "@vibeorm/schema";
+import { sqliteDialect } from "@vibeorm/sql";
+
+// packages/migrate/src/ddl/drop-order.ts
+function orderDropsChildrenFirst(params) {
+  const { names, fromNorm } = params;
+  if (fromNorm === undefined || names.length < 2)
+    return [...names];
+  const references = new Map;
+  for (const name of names) {
+    const table = fromNorm.tables.get(name);
+    if (table !== undefined) {
+      references.set(name, new Set([...table.fks.values()].map((fk) => fk.refTable)));
+      continue;
+    }
+    const joinTable = fromNorm.joinTables.get(name);
+    if (joinTable !== undefined) {
+      references.set(name, new Set([joinTable.a.table, joinTable.b.table]));
+      continue;
+    }
+    references.set(name, new Set);
+  }
+  const remaining = new Set(names);
+  const result = [];
+  while (remaining.size > 0) {
+    let progressed = false;
+    for (const name of names) {
+      if (!remaining.has(name))
+        continue;
+      const stillReferenced = [...remaining].some((other) => other !== name && (references.get(other) ?? new Set).has(name));
+      if (!stillReferenced) {
+        result.push(name);
+        remaining.delete(name);
+        progressed = true;
+      }
+    }
+    if (!progressed) {
+      for (const name of names)
+        if (remaining.has(name))
+          result.push(name);
+      break;
+    }
+  }
+  return result;
+}
+
+// packages/migrate/src/ddl/sqlite.ts
+function renderSqliteSteps(params) {
+  const { steps } = params;
+  const fromNorm = params.from === undefined ? undefined : normalizeSchema({ schema: params.from, dialect: "sqlite" });
+  const toNorm = params.to === undefined ? undefined : normalizeSchema({ schema: params.to, dialect: "sqlite" });
+  const enums = toNorm?.enums ?? new Map;
+  const createdTables = new Set;
+  for (const step of steps) {
+    if (step.kind === "createTable" || step.kind === "createJoinTable") {
+      createdTables.add(step.table);
+    }
+  }
+  const foldedFks = new Map;
+  const rebuildTables = [];
+  const markRebuild = (table) => {
+    if (!rebuildTables.includes(table))
+      rebuildTables.push(table);
+  };
+  for (const step of steps) {
+    switch (step.kind) {
+      case "alterColumn":
+      case "dropForeignKey":
+      case "addPrimaryKey":
+      case "dropPrimaryKey":
+        markRebuild(step.table);
+        break;
+      case "addColumn":
+        if (!isCheapAddColumn({ field: step.column }))
+          markRebuild(step.table);
+        break;
+      case "dropColumn":
+        if (!canCheapDropColumn({ table: step.table, column: step.column, fromNorm })) {
+          markRebuild(step.table);
+        }
+        break;
+      case "addForeignKey":
+        if (createdTables.has(step.table)) {
+          const list = foldedFks.get(step.table);
+          if (list === undefined)
+            foldedFks.set(step.table, [step]);
+          else
+            list.push(step);
+        } else {
+          markRebuild(step.table);
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  const rebuildSet = new Set(rebuildTables);
+  const dropNames = steps.filter((step) => step.kind === "dropTable" || step.kind === "dropJoinTable").map((step) => step.table);
+  const orderedDrops = orderDropsChildrenFirst({ names: dropNames, fromNorm });
+  let dropCursor = 0;
+  const statements = [];
+  for (const step of steps) {
+    switch (step.kind) {
+      case "createEnum":
+      case "dropEnum":
+      case "addEnumValue":
+        break;
+      case "createTable":
+        statements.push(createTableSql({
+          table: step.table,
+          constraintTable: step.table,
+          columns: step.columns,
+          primaryKey: step.primaryKey,
+          fks: (foldedFks.get(step.table) ?? []).map((fk) => ({
+            constraintName: fk.constraintName,
+            columns: fk.columns,
+            refTable: fk.refTable,
+            refColumns: fk.refColumns,
+            onDelete: CASCADE_ACTION_SQL[fk.onDelete],
+            onUpdate: CASCADE_ACTION_SQL[fk.onUpdate]
+          })),
+          enums
+        }));
+        break;
+      case "createJoinTable": {
+        const aType = sqliteStorageType({ field: { ...step.a.field, isList: false } });
+        const bType = sqliteStorageType({ field: { ...step.b.field, isList: false } });
+        statements.push(`CREATE TABLE ${q2(step.table)} (
+  "A" ${aType} NOT NULL,
+  "B" ${bType} NOT NULL,
+  CONSTRAINT ${q2(`${step.table}_A_fkey`)} FOREIGN KEY ("A") REFERENCES ${q2(step.a.table)} (${q2(step.a.column)}) ON DELETE CASCADE ON UPDATE CASCADE,
+  CONSTRAINT ${q2(`${step.table}_B_fkey`)} FOREIGN KEY ("B") REFERENCES ${q2(step.b.table)} (${q2(step.b.column)}) ON DELETE CASCADE ON UPDATE CASCADE
+);`, `CREATE UNIQUE INDEX ${q2(`${step.table}_AB_unique`)} ON ${q2(step.table)} ("A", "B");`, `CREATE INDEX ${q2(`${step.table}_B_index`)} ON ${q2(step.table)} ("B");`);
+        break;
+      }
+      case "addColumn":
+        if (!rebuildSet.has(step.table)) {
+          statements.push(`ALTER TABLE ${q2(step.table)} ADD COLUMN ${columnDefSql2({
+            field: step.column,
+            constraintTable: step.table,
+            enums,
+            inlinePkAutoincrement: false
+          })};`);
+        }
+        break;
+      case "dropColumn":
+        if (!rebuildSet.has(step.table)) {
+          statements.push(`ALTER TABLE ${q2(step.table)} DROP COLUMN ${q2(step.column)};`);
+        }
+        break;
+      case "createIndex":
+        if (!rebuildSet.has(step.table)) {
+          statements.push(createIndexSql({
+            table: step.table,
+            name: step.name,
+            unique: step.unique,
+            kind: step.indexKind,
+            columns: step.columns,
+            where: step.where
+          }));
+        }
+        break;
+      case "dropIndex":
+        statements.push(`DROP INDEX ${q2(step.name)};`);
+        break;
+      case "dropTable":
+      case "dropJoinTable":
+        statements.push(`DROP TABLE ${q2(orderedDrops[dropCursor])};`);
+        dropCursor += 1;
+        break;
+      case "dropView":
+        statements.push(`DROP VIEW IF EXISTS ${q2(step.table)};`);
+        break;
+      case "alterColumn":
+      case "addForeignKey":
+      case "dropForeignKey":
+      case "addPrimaryKey":
+      case "dropPrimaryKey":
+        if (step.kind === "addForeignKey" && createdTables.has(step.table) || !rebuildSet.has(step.table)) {
+          break;
+        }
+        requireSchemas({ step, fromNorm, toNorm });
+        break;
+    }
+  }
+  for (const table of rebuildTables) {
+    const step = steps.find((candidate) => ("table" in candidate) && candidate.table === table);
+    requireSchemas({ step, fromNorm, toNorm });
+    statements.push(...renderTableRebuild({
+      table,
+      from: fromNorm,
+      to: toNorm
+    }));
+  }
+  return statements;
+}
+function renderTableRebuild(params) {
+  const { table, from, to } = params;
+  const source = from.tables.get(table);
+  const target = to.tables.get(table);
+  if (source === undefined || target === undefined) {
+    throw new VibeError6({
+      code: "VIBE_MIGRATION",
+      message: `cannot rebuild "${table}" \u2014 the table is missing from the ${source === undefined ? "from" : "to"} schema`,
+      meta: { table }
+    });
+  }
+  const tmp = `${table}_new`;
+  const statements = ["PRAGMA foreign_keys=OFF;", "BEGIN;"];
+  statements.push(createTableSql({
+    table: tmp,
+    constraintTable: table,
+    columns: [...target.columns.values()].map((column) => column.field),
+    primaryKey: target.pk,
+    fks: [...target.fks.values()].map((fk) => ({
+      constraintName: fk.constraintName,
+      columns: fk.columns,
+      refTable: fk.refTable,
+      refColumns: fk.refColumns,
+      onDelete: CASCADE_ACTION_SQL[fk.onDelete],
+      onUpdate: CASCADE_ACTION_SQL[fk.onUpdate]
+    })),
+    enums: to.enums
+  }));
+  const common = [...target.columns.keys()].filter((name) => source.columns.has(name));
+  if (common.length > 0) {
+    const cols = common.map((name) => q2(name)).join(", ");
+    statements.push(`INSERT INTO ${q2(tmp)} (${cols}) SELECT ${cols} FROM ${q2(table)};`);
+  }
+  statements.push(`DROP TABLE ${q2(table)};`, `ALTER TABLE ${q2(tmp)} RENAME TO ${q2(table)};`);
+  for (const index of target.indexes.values()) {
+    statements.push(createIndexSql({
+      table,
+      name: index.name,
+      unique: index.unique,
+      kind: index.kind,
+      columns: index.columns,
+      where: index.where
+    }));
+  }
+  statements.push("PRAGMA foreign_key_check;", "COMMIT;", "PRAGMA foreign_keys=ON;");
+  return statements;
+}
+function isCheapAddColumn(params) {
+  const { field } = params;
+  const kind = field.default?.kind;
+  if (kind === "autoincrement" || kind === "now" || kind === "dbgenerated")
+    return false;
+  const hasLiteralDefault = kind === "literal" || kind === "enumValue";
+  if (!field.isOptional && !hasLiteralDefault)
+    return false;
+  return true;
+}
+function canCheapDropColumn(params) {
+  const { table, column, fromNorm } = params;
+  if (fromNorm === undefined)
+    return false;
+  const fromTable = fromNorm.tables.get(table);
+  if (fromTable === undefined)
+    return false;
+  if (fromTable.pk.includes(column))
+    return false;
+  const normalized = fromTable.columns.get(column);
+  if (normalized !== undefined && isEnumType5(normalized.field.type))
+    return false;
+  for (const index of fromTable.indexes.values()) {
+    if (index.columns.some((indexColumn) => indexColumn.name === column))
+      return false;
+    if (index.where !== undefined && index.where.includes(column))
+      return false;
+  }
+  for (const fk of fromTable.fks.values()) {
+    if (fk.columns.includes(column))
+      return false;
+  }
+  for (const other of fromNorm.tables.values()) {
+    for (const fk of other.fks.values()) {
+      if (fk.refTable === table && fk.refColumns.includes(column))
+        return false;
+    }
+  }
+  return true;
+}
+function createTableSql(params) {
+  const { table, constraintTable, columns, primaryKey, fks, enums } = params;
+  const autoincrementPk = autoincrementPkColumn({ columns, primaryKey });
+  const lines = columns.map((field) => `  ${columnDefSql2({
+    field,
+    constraintTable,
+    enums,
+    inlinePkAutoincrement: (field.dbName ?? field.name) === autoincrementPk
+  })}`);
+  if (primaryKey.length > 0 && autoincrementPk === undefined) {
+    lines.push(`  PRIMARY KEY (${primaryKey.map((column) => q2(column)).join(", ")})`);
+  }
+  for (const fk of fks) {
+    lines.push(`  CONSTRAINT ${q2(fk.constraintName)} FOREIGN KEY (${fk.columns.map((column) => q2(column)).join(", ")}) REFERENCES ${q2(fk.refTable)} (${fk.refColumns.map((column) => q2(column)).join(", ")}) ON DELETE ${fk.onDelete} ON UPDATE ${fk.onUpdate}`);
+  }
+  return `CREATE TABLE ${q2(table)} (
+${lines.join(`,
+`)}
+);`;
+}
+function autoincrementPkColumn(params) {
+  const { columns, primaryKey } = params;
+  if (primaryKey.length !== 1)
+    return;
+  const pkName = primaryKey[0];
+  const field = columns.find((candidate) => (candidate.dbName ?? candidate.name) === pkName);
+  if (field === undefined)
+    return;
+  const eligible = field.default?.kind === "autoincrement" && !field.isList && !isEnumType5(field.type) && (field.type === "Int" || field.type === "BigInt");
+  return eligible ? pkName : undefined;
+}
+function columnDefSql2(params) {
+  const { field, constraintTable, enums, inlinePkAutoincrement } = params;
+  const name = field.dbName ?? field.name;
+  if (field.default?.kind === "autoincrement" && !inlinePkAutoincrement) {
+    throw new VibeError6({
+      code: "VIBE_MIGRATION",
+      message: `autoincrement on sqlite requires "${field.name}" to be the single-column Int or BigInt primary key`,
+      meta: { field: field.name }
+    });
+  }
+  if (inlinePkAutoincrement) {
+    return `${q2(name)} INTEGER PRIMARY KEY AUTOINCREMENT`;
+  }
+  let def = `${q2(name)} ${sqliteStorageType({ field })}`;
+  if (!field.isOptional)
+    def += " NOT NULL";
+  const defaultExpr = sqliteDefaultSql({ field });
+  if (defaultExpr !== undefined)
+    def += ` DEFAULT ${defaultExpr}`;
+  if (isEnumType5(field.type) && field.isUnsupported !== true) {
+    const enumName = field.type.enum;
+    const values = resolveEnumValues({ name: enumName, enums });
+    if (values === undefined) {
+      throw new VibeError6({
+        code: "VIBE_MIGRATION",
+        message: `enum "${enumName}" on column "${field.name}" is not declared in the schema \u2014 sqlite rendering needs the target schema's enums for the CHECK constraint`,
+        meta: { field: field.name, enum: enumName }
+      });
+    }
+    const check = sqliteEnumCheckName({ table: constraintTable, column: name, enumName });
+    def += ` CONSTRAINT ${q2(check)} CHECK (${q2(name)} IN (${values.map((value) => quotePgString({ value })).join(", ")}))`;
+  }
+  return def;
+}
+function createIndexSql(params) {
+  const { table, name, unique, kind, columns, where } = params;
+  if (!unique && kind !== "btree") {
+    throw unsupportedCapability4({
+      dialect: "sqlite",
+      feature: `index kind "${kind}" (index "${name}")`,
+      hint: "sqlite indexes are btree only; use an extension-specific virtual table for others"
+    });
+  }
+  const cols = columns.map((column) => `${column.decimal === true ? `CAST(${q2(column.name)} AS REAL)` : q2(column.name)}${column.desc ? " DESC" : ""}`).join(", ");
+  const whereClause = where === undefined ? "" : ` WHERE ${where}`;
+  return `CREATE ${unique ? "UNIQUE " : ""}INDEX ${q2(name)} ON ${q2(table)} (${cols})${whereClause};`;
+}
+function requireSchemas(params) {
+  const { step, fromNorm, toNorm } = params;
+  if (fromNorm !== undefined && toNorm !== undefined)
+    return;
+  throw new VibeError6({
+    code: "VIBE_MIGRATION",
+    message: `sqlite step "${describeStep({ step })}" requires a table rebuild \u2014 renderSteps needs the { from, to } schemas to construct it`,
+    meta: { step: step.kind }
+  });
+}
+function q2(name) {
+  return sqliteDialect.quoteIdent({ name });
+}
+
+// packages/migrate/src/ddl/mysql.ts
+import { VibeError as VibeError7, unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
+import { mysqlDialect } from "@vibeorm/sql";
+function renderMysqlSteps(params) {
+  const enums = new Map;
+  for (const enumDef of params.to?.enums ?? []) {
+    enums.set(enumDef.dbName ?? enumDef.name, enumDef);
+  }
+  const dropNames = params.steps.filter((step) => step.kind === "dropTable" || step.kind === "dropJoinTable").map((step) => step.table);
+  const fromNorm = params.from === undefined ? undefined : normalizeSchema({ schema: params.from, dialect: "mysql" });
+  const orderedDrops = orderDropsChildrenFirst({ names: dropNames, fromNorm });
+  let dropCursor = 0;
+  return params.steps.flatMap((step) => {
+    if (step.kind === "dropTable" || step.kind === "dropJoinTable") {
+      const table = orderedDrops[dropCursor];
+      dropCursor += 1;
+      return [`DROP TABLE ${q3(table)};`];
+    }
+    return renderStep2({ step, enums });
+  });
+}
+function renderStep2(params) {
+  const { step, enums } = params;
+  switch (step.kind) {
+    case "createEnum":
+    case "dropEnum":
+    case "addEnumValue":
+      return [];
+    case "createTable": {
+      const lines = step.columns.map((column) => `  ${columnDefSql3({ field: column, enums })}`);
+      if (step.primaryKey.length > 0) {
+        lines.push(`  PRIMARY KEY (${step.primaryKey.map((column) => q3(column)).join(", ")})`);
+      }
+      return [`CREATE TABLE ${q3(step.table)} (
+${lines.join(`,
+`)}
+);`];
+    }
+    case "dropTable":
+    case "dropJoinTable":
+      return [`DROP TABLE ${q3(step.table)};`];
+    case "dropView":
+      return [`DROP VIEW IF EXISTS ${q3(step.table)};`];
+    case "addColumn":
+      return [
+        `ALTER TABLE ${q3(step.table)} ADD COLUMN ${columnDefSql3({ field: step.column, enums })};`
+      ];
+    case "dropColumn":
+      return [`ALTER TABLE ${q3(step.table)} DROP COLUMN ${q3(step.column)};`];
+    case "alterColumn":
+      return renderAlterColumn2({ step, enums });
+    case "createIndex": {
+      if (step.where !== undefined) {
+        throw unsupportedCapability5({
+          dialect: "mysql",
+          feature: `partial index "${step.name}"`,
+          hint: "mysql has no partial indexes \u2014 drop the WHERE predicate or gate the index per dialect"
+        });
+      }
+      if (!step.unique && step.indexKind !== "btree") {
+        throw unsupportedCapability5({
+          dialect: "mysql",
+          feature: `index kind "${step.indexKind}" (index "${step.name}")`,
+          hint: "mysql secondary indexes are btree only"
+        });
+      }
+      const cols = step.columns.map((column) => `${q3(column.name)}${column.desc ? " DESC" : ""}`).join(", ");
+      return [
+        `CREATE ${step.unique ? "UNIQUE " : ""}INDEX ${q3(step.name)} ON ${q3(step.table)} (${cols});`
+      ];
+    }
+    case "dropIndex": {
+      if (step.table === undefined) {
+        throw new VibeError7({
+          code: "VIBE_MIGRATION",
+          message: `dropIndex "${step.name}" carries no table \u2014 mysql's DROP INDEX requires one`,
+          meta: { index: step.name }
+        });
+      }
+      return [`DROP INDEX ${q3(step.name)} ON ${q3(step.table)};`];
+    }
+    case "addForeignKey": {
+      const cols = step.columns.map((column) => q3(column)).join(", ");
+      const refCols = step.refColumns.map((column) => q3(column)).join(", ");
+      return [
+        `ALTER TABLE ${q3(step.table)} ADD CONSTRAINT ${q3(step.constraintName)} FOREIGN KEY (${cols}) REFERENCES ${q3(step.refTable)} (${refCols}) ON DELETE ${CASCADE_ACTION_SQL[step.onDelete]} ON UPDATE ${CASCADE_ACTION_SQL[step.onUpdate]};`
+      ];
+    }
+    case "dropForeignKey":
+      return [`ALTER TABLE ${q3(step.table)} DROP FOREIGN KEY ${q3(step.constraintName)};`];
+    case "createJoinTable": {
+      const aType = mysqlColumnTypeSql({ field: { ...step.a.field, isList: false }, enums });
+      const bType = mysqlColumnTypeSql({ field: { ...step.b.field, isList: false }, enums });
+      return [
+        `CREATE TABLE ${q3(step.table)} (
+  \`A\` ${aType} NOT NULL,
+  \`B\` ${bType} NOT NULL
+);`,
+        `CREATE UNIQUE INDEX ${q3(`${step.table}_AB_unique`)} ON ${q3(step.table)} (\`A\`, \`B\`);`,
+        `CREATE INDEX ${q3(`${step.table}_B_index`)} ON ${q3(step.table)} (\`B\`);`,
+        `ALTER TABLE ${q3(step.table)} ADD CONSTRAINT ${q3(`${step.table}_A_fkey`)} FOREIGN KEY (\`A\`) REFERENCES ${q3(step.a.table)} (${q3(step.a.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`,
+        `ALTER TABLE ${q3(step.table)} ADD CONSTRAINT ${q3(`${step.table}_B_fkey`)} FOREIGN KEY (\`B\`) REFERENCES ${q3(step.b.table)} (${q3(step.b.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`
+      ];
+    }
+    case "addPrimaryKey":
+      return [
+        `ALTER TABLE ${q3(step.table)} ADD PRIMARY KEY (${step.columns.map((column) => q3(column)).join(", ")});`
+      ];
+    case "dropPrimaryKey":
+      return [`ALTER TABLE ${q3(step.table)} DROP PRIMARY KEY;`];
+  }
+}
+function columnDefSql3(params) {
+  const { field, enums } = params;
+  const name = q3(field.dbName ?? field.name);
+  const autoincrement = field.default?.kind === "autoincrement";
+  if (autoincrement && field.type !== "Int" && field.type !== "BigInt") {
+    throw new VibeError7({
+      code: "VIBE_MIGRATION",
+      message: `autoincrement default on "${field.name}" requires a non-list Int or BigInt column`,
+      meta: { field: field.name }
+    });
+  }
+  let def = `${name} ${mysqlColumnTypeSql({ field, enums })}`;
+  if (!field.isOptional)
+    def += " NOT NULL";
+  if (autoincrement)
+    def += " AUTO_INCREMENT";
+  const defaultExpr = mysqlDefaultSql({ field });
+  if (defaultExpr !== undefined)
+    def += ` DEFAULT ${defaultExpr}`;
+  return def;
+}
+function renderAlterColumn2(params) {
+  const { step, enums } = params;
+  if (step.to.default?.kind === "autoincrement" && step.from.default?.kind !== "autoincrement") {
+    throw new VibeError7({
+      code: "VIBE_MIGRATION",
+      message: `cannot add autoincrement to existing column "${step.table}"."${step.column}" \u2014 drop and recreate the column instead`,
+      meta: { table: step.table, column: step.column }
+    });
+  }
+  if (step.changes.includes("type") || step.changes.includes("nullability")) {
+    return [
+      `ALTER TABLE ${q3(step.table)} MODIFY COLUMN ${columnDefSql3({ field: step.to, enums })};`
+    ];
+  }
+  const defaultExpr = mysqlDefaultSql({ field: step.to });
+  return [
+    defaultExpr === undefined ? `ALTER TABLE ${q3(step.table)} ALTER COLUMN ${q3(step.column)} DROP DEFAULT;` : `ALTER TABLE ${q3(step.table)} ALTER COLUMN ${q3(step.column)} SET DEFAULT ${defaultExpr};`
+  ];
+}
+function q3(name) {
+  return mysqlDialect.quoteIdent({ name });
+}
+
+// packages/migrate/src/ddl/render.ts
+function renderSteps(params) {
+  const { steps, dialect, from, to } = params;
+  switch (dialect) {
+    case "postgres":
+      return renderPostgresSteps({ steps });
+    case "sqlite":
+      return renderSqliteSteps({
+        steps,
+        ...from === undefined ? {} : { from },
+        ...to === undefined ? {} : { to }
+      });
+    case "mysql":
+      return renderMysqlSteps({
+        steps,
+        ...from === undefined ? {} : { from },
+        ...to === undefined ? {} : { to }
+      });
+  }
+}
+// packages/migrate/src/runner.ts
+import { createHash } from "crypto";
+import { VibeError as VibeError9 } from "@vibeorm/schema";
+import { DIALECT_CAPABILITIES, getSqlDialect } from "@vibeorm/sql";
+
+// packages/migrate/src/extensions.ts
+import { extensionDeclarations } from "@vibeorm/schema";
+function collectExtensionArtifacts(params) {
+  const { schema, dialect, extensions } = params;
+  const setup = [];
+  const objects = [];
+  for (const extension of extensions) {
+    const artifactsHook = extension.migrate?.artifacts;
+    if (artifactsHook === undefined)
+      continue;
+    const declarations = extensionDeclarations({ schema, name: extension.name });
+    if (Object.keys(declarations).length === 0 && extension.schema?.configOnly !== true)
+      continue;
+    for (const artifact of artifactsHook({
+      schema,
+      dialect,
+      provider: schema.datasource.provider,
+      options: extension.options,
+      declarations
+    })) {
+      (artifact.owns.kind === "postgresExtension" ? setup : objects).push(artifact);
+    }
+  }
+  return { setup, objects };
+}
+function ownedTableNames(params) {
+  const exact = new Set;
+  const prefixes = [];
+  for (const artifact of params.artifacts) {
+    if (artifact.owns.kind !== "table")
+      continue;
+    exact.add(artifact.owns.name);
+    prefixes.push(...artifact.owns.auxiliaryPrefixes ?? []);
+  }
+  return { exact, prefixes };
+}
+function stripExtensionArtifacts(params) {
+  const { schema, artifacts } = params;
+  if (artifacts.length === 0)
+    return schema;
+  const tables = ownedTableNames({ artifacts });
+  const ownedColumns = new Map;
+  const ownedIndexes = new Map;
+  for (const artifact of artifacts) {
+    if (artifact.owns.kind === "column") {
+      const set = ownedColumns.get(artifact.owns.table) ?? new Set;
+      set.add(artifact.owns.column);
+      ownedColumns.set(artifact.owns.table, set);
+    } else if (artifact.owns.kind === "index") {
+      const set = ownedIndexes.get(artifact.owns.table) ?? new Set;
+      set.add(artifact.owns.name);
+      ownedIndexes.set(artifact.owns.table, set);
+    }
+  }
+  const models = [];
+  for (const model of schema.models) {
+    const tableName = model.dbName ?? model.name;
+    if (tables.exact.has(tableName) || tables.prefixes.some((prefix) => tableName.startsWith(prefix))) {
+      continue;
+    }
+    const columns = ownedColumns.get(tableName);
+    const indexes = ownedIndexes.get(tableName);
+    if (columns === undefined && indexes === undefined) {
+      models.push(model);
+      continue;
+    }
+    models.push({
+      ...model,
+      fields: model.fields.filter((field) => !(columns?.has(field.dbName ?? field.name) ?? false)),
+      indexes: model.indexes.filter((index) => !(index.name !== undefined && (indexes?.has(index.name) ?? false)))
+    });
+  }
+  return { ...schema, models };
+}
+function planMissingArtifacts(params) {
+  const { introspected, artifacts, installed } = params;
+  if (artifacts.length === 0)
+    return [];
+  const modelByTable = new Map;
+  for (const model of introspected.models) {
+    modelByTable.set(model.dbName ?? model.name, model);
+  }
+  return artifacts.filter((artifact) => {
+    const owner = artifact.owns;
+    switch (owner.kind) {
+      case "postgresExtension":
+        return installed?.pgExtensions === undefined ? true : !installed.pgExtensions.has(owner.name);
+      case "trigger":
+        return installed?.triggers === undefined ? true : !installed.triggers.has(owner.name);
+      case "table":
+        return !modelByTable.has(owner.name);
+      case "column": {
+        const model = modelByTable.get(owner.table);
+        if (model === undefined)
+          return true;
+        return !model.fields.some((field) => (field.dbName ?? field.name) === owner.column);
+      }
+      case "index": {
+        const model = modelByTable.get(owner.table);
+        if (model === undefined)
+          return true;
+        return !model.indexes.some((index) => index.name === owner.name);
+      }
+    }
+  });
+}
+async function probeInstalledExtensionState(params) {
+  const { executor, dialect, artifacts } = params;
+  const state = {};
+  if (dialect === "postgres" && artifacts.some((artifact) => artifact.owns.kind === "postgresExtension")) {
+    const rows = await executor({ text: "SELECT extname FROM pg_extension" });
+    state.pgExtensions = new Set(rows.map((row) => String(row["extname"])));
+  }
+  if (dialect === "sqlite" && artifacts.some((artifact) => artifact.owns.kind === "trigger")) {
+    const rows = await executor({
+      text: "SELECT name FROM sqlite_master WHERE type = 'trigger'",
+      values: []
+    });
+    state.triggers = new Set(rows.map((row) => String(row["name"])));
+  }
+  return state;
+}
+function artifactCreateSql(params) {
+  return params.artifacts.flatMap((artifact) => [...artifact.create]);
+}
+
+// packages/migrate/src/execute.ts
+import { VibeError as VibeError8 } from "@vibeorm/schema";
+var SELF_MANAGED_MARKER = "PRAGMA foreign_keys=OFF";
+var FK_CHECK_PREFIX = "PRAGMA foreign_key_check";
+function usesSelfManagedTransactions(params) {
+  return params.sql.some((statement) => statement.startsWith(SELF_MANAGED_MARKER));
+}
+async function executeStatement(params) {
+  const { executor, statement, dialect } = params;
+  if (dialect === "sqlite" && statement.startsWith(FK_CHECK_PREFIX)) {
+    const rows = await executor({ text: statement, values: [] });
+    if (rows.length > 0) {
+      const sample = rows.slice(0, 5).map((row) => `${String(row.table)} rowid ${String(row.rowid)} \u2192 ${String(row.parent)}`).join("; ");
+      throw new VibeError8({
+        code: "VIBE_MIGRATION",
+        message: `foreign key check failed after table rebuild: ${rows.length} violation(s) \u2014 ${sample}`,
+        meta: { violations: rows }
+      });
+    }
+    return;
+  }
+  await executor({ text: statement });
+}
+async function cleanupSelfManagedFailure(params) {
+  try {
+    await params.executor({ text: "ROLLBACK;" });
+  } catch {}
+  try {
+    await params.executor({ text: "PRAGMA foreign_keys=ON;" });
+  } catch {}
+}
+
+// packages/migrate/src/runner.ts
+var MIGRATIONS_TABLE_NAME = "_vibe_migrations";
+var PG_ADVISORY_LOCK_KEY = 1447645253;
+var MYSQL_LOCK_NAME = "vibeorm_migrate";
+var MYSQL_LOCK_TIMEOUT_SECONDS = 60;
+var RESOLVED_STATEMENT_INDEX = 2147483647;
+var CREATE_TABLE_SQL = {
+  postgres: `CREATE TABLE IF NOT EXISTS "${MIGRATIONS_TABLE_NAME}" (
+  "id" integer GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+  "name" text NOT NULL UNIQUE,
+  "checksum" text NOT NULL,
+  "applied_at" timestamptz(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "statement_index" integer NOT NULL DEFAULT 0,
+  "error" text
+);`,
+  sqlite: `CREATE TABLE IF NOT EXISTS "${MIGRATIONS_TABLE_NAME}" (
+  "id" INTEGER PRIMARY KEY AUTOINCREMENT,
+  "name" TEXT NOT NULL UNIQUE,
+  "checksum" TEXT NOT NULL,
+  "applied_at" TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "statement_index" INTEGER NOT NULL DEFAULT 0,
+  "error" TEXT
+);`,
+  mysql: `CREATE TABLE IF NOT EXISTS \`${MIGRATIONS_TABLE_NAME}\` (
+  \`id\` int NOT NULL AUTO_INCREMENT,
+  \`name\` varchar(191) NOT NULL UNIQUE,
+  \`checksum\` text NOT NULL,
+  \`applied_at\` datetime(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
+  \`statement_index\` int NOT NULL DEFAULT 0,
+  \`error\` text,
+  PRIMARY KEY (\`id\`)
+);`
+};
+async function ensureMigrationsTable(params) {
+  await params.executor({ text: CREATE_TABLE_SQL[params.dialect ?? "postgres"] });
+}
+function migrationChecksum(params) {
+  return createHash("sha256").update(params.sql.join(`
+`)).digest("hex");
+}
+function generateMigration(params) {
+  const { from, to, name } = params;
+  const dialect = params.dialect ?? "postgres";
+  const artifacts = collectExtensionArtifacts({
+    schema: to,
+    dialect,
+    extensions: params.extensions ?? []
+  });
+  const allArtifacts = [...artifacts.setup, ...artifacts.objects];
+  const strippedFrom = stripExtensionArtifacts({ schema: from, artifacts: allArtifacts });
+  const steps = diffSchemas({ from: strippedFrom, to, dialect });
+  const coreSql = renderSteps({ steps, dialect, from: strippedFrom, to });
+  const missing = planMissingArtifacts({ introspected: from, artifacts: allArtifacts });
+  const sql = [
+    ...artifactCreateSql({
+      artifacts: missing.filter((artifact) => artifact.owns.kind === "postgresExtension")
+    }),
+    ...coreSql,
+    ...artifactCreateSql({
+      artifacts: missing.filter((artifact) => artifact.owns.kind !== "postgresExtension")
+    })
+  ];
+  return {
+    name,
+    sql,
+    destructive: steps.some((step) => step.destructive)
+  };
+}
+async function applyMigrations(params) {
+  const { executor, migrations } = params;
+  const dialect = params.dialect ?? "postgres";
+  const transactional = DIALECT_CAPABILITIES[dialect].transactionalDdl;
+  await ensureMigrationsTable({ executor, dialect });
+  await acquireLock({ executor, dialect });
+  try {
+    const recorded = await recordedRows({ executor, dialect });
+    const applied = [];
+    const skipped = [];
+    for (const migration of migrations) {
+      const stored = recorded.get(migration.name);
+      if (stored !== undefined) {
+        if (stored.statementIndex < 0) {
+          throw new VibeError9({
+            code: "VIBE_MIGRATION",
+            message: `migration "${migration.name}" is mid-rollback (${-stored.statementIndex - 1} down statement(s) done) \u2014 finish it with \`migrate down\` or repair with resolveMigration before applying`,
+            meta: { migration: migration.name, statementIndex: stored.statementIndex }
+          });
+        }
+        const complete = stored.checksum === "" || transactional || stored.statementIndex >= migration.sql.length;
+        if (complete) {
+          assertChecksumMatches({ migration, stored: stored.checksum });
+          skipped.push(migration.name);
+          continue;
+        }
+        assertResumable({ migration, stored });
+        await runNonTransactional({
+          executor,
+          dialect,
+          migration,
+          start: stored.statementIndex,
+          insertRecord: false
+        });
+        applied.push(migration.name);
+        continue;
+      }
+      if (transactional) {
+        await runTransactional({ executor, dialect, migration });
+      } else {
+        await runNonTransactional({ executor, dialect, migration, start: 0, insertRecord: true });
+      }
+      applied.push(migration.name);
+    }
+    return { applied, skipped };
+  } finally {
+    await releaseLock({ executor, dialect });
+  }
+}
+async function migrationStatus(params) {
+  const { executor, migrations } = params;
+  const dialect = params.dialect ?? "postgres";
+  const transactional = DIALECT_CAPABILITIES[dialect].transactionalDdl;
+  await ensureMigrationsTable({ executor, dialect });
+  const recorded = await recordedRows({ executor, dialect });
+  const applied = [];
+  const pending = [];
+  const mismatched = [];
+  const rollingBack = [];
+  for (const migration of migrations) {
+    const stored = recorded.get(migration.name);
+    if (stored === undefined) {
+      pending.push(migration.name);
+      continue;
+    }
+    if (stored.statementIndex < 0) {
+      rollingBack.push(migration.name);
+      continue;
+    }
+    if (stored.checksum === "") {
+      applied.push(migration.name);
+      continue;
+    }
+    if (stored.checksum !== migrationChecksum({ sql: migration.sql })) {
+      mismatched.push(migration.name);
+      continue;
+    }
+    const complete = transactional || stored.statementIndex >= migration.sql.length;
+    if (complete)
+      applied.push(migration.name);
+    else
+      pending.push(migration.name);
+  }
+  return { applied, pending, mismatched, rollingBack };
+}
+async function resolveMigration(params) {
+  const { executor, name } = params;
+  const dialect = params.dialect ?? "postgres";
+  await ensureMigrationsTable({ executor, dialect });
+  if (params.as === "applied") {
+    const insert = `INSERT INTO ${q4(dialect, MIGRATIONS_TABLE_NAME)} (${q4(dialect, "name")}, ${q4(dialect, "checksum")}, ${q4(dialect, "statement_index")}) VALUES (${ph(dialect, 1)}, ${ph(dialect, 2)}, ${RESOLVED_STATEMENT_INDEX})`;
+    const upsert = dialect === "mysql" ? `${insert} ON DUPLICATE KEY UPDATE \`checksum\` = VALUES(\`checksum\`), \`statement_index\` = VALUES(\`statement_index\`), \`error\` = NULL` : `${insert} ON CONFLICT ("name") DO UPDATE SET "checksum" = EXCLUDED."checksum", "statement_index" = EXCLUDED."statement_index"`;
+    await executor({ text: upsert, values: [name, params.checksum ?? ""] });
+    return;
+  }
+  await executor({
+    text: `DELETE FROM ${q4(dialect, MIGRATIONS_TABLE_NAME)} WHERE ${q4(dialect, "name")} = ${ph(dialect, 1)}`,
+    values: [name]
+  });
+}
+async function rollbackMigration(params) {
+  const { executor, migration } = params;
+  const dialect = params.dialect ?? "postgres";
+  const transactional = DIALECT_CAPABILITIES[dialect].transactionalDdl;
+  const downSql = migration.downSql;
+  if (downSql === undefined) {
+    throw new VibeError9({
+      code: "VIBE_MIGRATION",
+      message: `migration "${migration.name}" has no down.sql \u2014 it predates down-migration support; roll it back manually, then repair with resolveMigration (as: "rolled-back")`,
+      meta: { migration: migration.name }
+    });
+  }
+  await ensureMigrationsTable({ executor, dialect });
+  await acquireLock({ executor, dialect });
+  try {
+    const recorded = await recordedRows({ executor, dialect });
+    const stored = recorded.get(migration.name);
+    if (stored === undefined) {
+      throw new VibeError9({
+        code: "VIBE_MIGRATION",
+        message: `migration "${migration.name}" is not recorded as applied \u2014 nothing to roll back`,
+        meta: { migration: migration.name }
+      });
+    }
+    const resumingDown = stored.statementIndex < 0;
+    assertChecksumMatches({ migration, stored: stored.checksum });
+    if (!resumingDown) {
+      const partialUp = !transactional && stored.checksum !== "" && stored.statementIndex < migration.sql.length;
+      if (partialUp) {
+        throw new VibeError9({
+          code: "VIBE_MIGRATION",
+          message: `migration "${migration.name}" is only partially applied (${stored.statementIndex} of ${migration.sql.length} statement(s)) \u2014 its down migration mirrors the FULL up; re-run applyMigrations to finish it (it resumes), or repair with resolveMigration`,
+          meta: { migration: migration.name, statementIndex: stored.statementIndex }
+        });
+      }
+    }
+    if (transactional) {
+      await runTransactionalDown({ executor, dialect, migration, downSql });
+    } else {
+      const start = resumingDown ? -stored.statementIndex - 1 : 0;
+      await runNonTransactionalDown({ executor, dialect, migration, downSql, start });
+    }
+  } finally {
+    await releaseLock({ executor, dialect });
+  }
+}
+async function runTransactionalDown(params) {
+  const { executor, dialect, migration, downSql } = params;
+  const selfManaged = dialect === "sqlite" && usesSelfManagedTransactions({ sql: downSql });
+  const wrap = !selfManaged;
+  if (wrap)
+    await executor({ text: "BEGIN" });
+  try {
+    for (const statement of downSql) {
+      await executeStatement({ executor, statement, dialect });
+    }
+    await executor({
+      text: `DELETE FROM ${q4(dialect, MIGRATIONS_TABLE_NAME)} WHERE ${q4(dialect, "name")} = ${ph(dialect, 1)}`,
+      values: [migration.name]
+    });
+    if (wrap)
+      await executor({ text: "COMMIT" });
+  } catch (error) {
+    if (wrap) {
+      try {
+        await executor({ text: "ROLLBACK" });
+      } catch {}
+    } else {
+      await cleanupSelfManagedFailure({ executor });
+    }
+    throw new VibeError9({
+      code: "VIBE_MIGRATION",
+      message: `rollback of "${migration.name}" failed: ${error instanceof Error ? error.message : String(error)}`,
+      meta: { migration: migration.name },
+      cause: error
+    });
+  }
+}
+async function runNonTransactionalDown(params) {
+  const { executor, dialect, migration, downSql, start } = params;
+  const table = q4(dialect, MIGRATIONS_TABLE_NAME);
+  const recordProgress = async (completed) => {
+    await executor({
+      text: `UPDATE ${table} SET ${q4(dialect, "statement_index")} = ${ph(dialect, 1)}, ${q4(dialect, "error")} = NULL WHERE ${q4(dialect, "name")} = ${ph(dialect, 2)}`,
+      values: [-(completed + 1), migration.name]
+    });
+  };
+  if (start === 0)
+    await recordProgress(0);
+  for (let index = start;index < downSql.length; index += 1) {
+    try {
+      await executeStatement({ executor, statement: downSql[index], dialect });
+    } catch (error) {
+      try {
+        await executor({
+          text: `UPDATE ${table} SET ${q4(dialect, "error")} = ${ph(dialect, 1)} WHERE ${q4(dialect, "name")} = ${ph(dialect, 2)}`,
+          values: [error instanceof Error ? error.message : String(error), migration.name]
+        });
+      } catch {}
+      throw new VibeError9({
+        code: "VIBE_MIGRATION",
+        message: `rollback of "${migration.name}" failed at down statement ${index + 1} of ${downSql.length}: ${error instanceof Error ? error.message : String(error)} \u2014 progress is recorded; re-running the rollback resumes from this statement`,
+        meta: { migration: migration.name, statementIndex: index },
+        cause: error
+      });
+    }
+    await recordProgress(index + 1);
+  }
+  await executor({
+    text: `DELETE FROM ${table} WHERE ${q4(dialect, "name")} = ${ph(dialect, 1)}`,
+    values: [migration.name]
+  });
+}
+async function runTransactional(params) {
+  const { executor, dialect, migration } = params;
+  const selfManaged = dialect === "sqlite" && usesSelfManagedTransactions({ sql: migration.sql });
+  const wrap = !selfManaged;
+  if (wrap)
+    await executor({ text: "BEGIN" });
+  try {
+    let statementIndex = 0;
+    for (const statement of migration.sql) {
+      await executeStatement({ executor, statement, dialect });
+      statementIndex += 1;
+    }
+    await executor({
+      text: `INSERT INTO ${q4(dialect, MIGRATIONS_TABLE_NAME)} (${q4(dialect, "name")}, ${q4(dialect, "checksum")}, ${q4(dialect, "statement_index")}) VALUES (${ph(dialect, 1)}, ${ph(dialect, 2)}, ${ph(dialect, 3)})`,
+      values: [migration.name, migrationChecksum({ sql: migration.sql }), statementIndex]
+    });
+    if (wrap)
+      await executor({ text: "COMMIT" });
+  } catch (error) {
+    if (wrap) {
+      try {
+        await executor({ text: "ROLLBACK" });
+      } catch {}
+    } else {
+      await cleanupSelfManagedFailure({ executor });
+    }
+    throw new VibeError9({
+      code: "VIBE_MIGRATION",
+      message: `migration "${migration.name}" failed: ${error instanceof Error ? error.message : String(error)}`,
+      meta: { migration: migration.name },
+      cause: error
+    });
+  }
+}
+async function runNonTransactional(params) {
+  const { executor, dialect, migration, start, insertRecord } = params;
+  const table = q4(dialect, MIGRATIONS_TABLE_NAME);
+  if (insertRecord) {
+    await executor({
+      text: `INSERT INTO ${table} (${q4(dialect, "name")}, ${q4(dialect, "checksum")}, ${q4(dialect, "statement_index")}) VALUES (${ph(dialect, 1)}, ${ph(dialect, 2)}, 0)`,
+      values: [migration.name, migrationChecksum({ sql: migration.sql })]
+    });
+  }
+  for (let index = start;index < migration.sql.length; index += 1) {
+    try {
+      await executeStatement({ executor, statement: migration.sql[index], dialect });
+    } catch (error) {
+      try {
+        await executor({
+          text: `UPDATE ${table} SET ${q4(dialect, "error")} = ${ph(dialect, 1)} WHERE ${q4(dialect, "name")} = ${ph(dialect, 2)}`,
+          values: [error instanceof Error ? error.message : String(error), migration.name]
+        });
+      } catch {}
+      throw new VibeError9({
+        code: "VIBE_MIGRATION",
+        message: `migration "${migration.name}" failed at statement ${index + 1} of ${migration.sql.length}: ${error instanceof Error ? error.message : String(error)} \u2014 progress is recorded; re-running applyMigrations resumes from this statement`,
+        meta: { migration: migration.name, statementIndex: index },
+        cause: error
+      });
+    }
+    await executor({
+      text: `UPDATE ${table} SET ${q4(dialect, "statement_index")} = ${ph(dialect, 1)}, ${q4(dialect, "error")} = NULL WHERE ${q4(dialect, "name")} = ${ph(dialect, 2)}`,
+      values: [index + 1, migration.name]
+    });
+  }
+}
+async function acquireLock(params) {
+  const { executor, dialect } = params;
+  if (dialect === "postgres") {
+    await executor({ text: `SELECT pg_advisory_lock(${PG_ADVISORY_LOCK_KEY})` });
+    return;
+  }
+  if (dialect === "mysql") {
+    const rows = await executor({
+      text: `SELECT GET_LOCK('${MYSQL_LOCK_NAME}', ${MYSQL_LOCK_TIMEOUT_SECONDS}) AS \`vibe_lock\``,
+      values: []
+    });
+    const acquired = Number(rows[0]?.vibe_lock) === 1;
+    if (!acquired) {
+      throw new VibeError9({
+        code: "VIBE_MIGRATION",
+        message: `could not acquire the migration lock ('${MYSQL_LOCK_NAME}') within ${MYSQL_LOCK_TIMEOUT_SECONDS}s \u2014 another migration run is in progress`,
+        meta: { lock: MYSQL_LOCK_NAME }
+      });
+    }
+  }
+}
+async function releaseLock(params) {
+  const { executor, dialect } = params;
+  try {
+    if (dialect === "postgres") {
+      await executor({ text: `SELECT pg_advisory_unlock(${PG_ADVISORY_LOCK_KEY})` });
+    } else if (dialect === "mysql") {
+      await executor({ text: `SELECT RELEASE_LOCK('${MYSQL_LOCK_NAME}')` });
+    }
+  } catch {}
+}
+async function recordedRows(params) {
+  const { executor, dialect } = params;
+  const rows = await executor({
+    text: `SELECT ${q4(dialect, "name")}, ${q4(dialect, "checksum")}, ${q4(dialect, "statement_index")} FROM ${q4(dialect, MIGRATIONS_TABLE_NAME)} ORDER BY ${q4(dialect, "id")}`,
+    values: []
+  });
+  const result = new Map;
+  for (const row of rows) {
+    const rawIndex = Number(row.statement_index);
+    result.set(row.name, {
+      checksum: row.checksum,
+      statementIndex: Number.isNaN(rawIndex) ? RESOLVED_STATEMENT_INDEX : rawIndex
+    });
+  }
+  return result;
+}
+function assertChecksumMatches(params) {
+  const { migration, stored } = params;
+  if (stored === "")
+    return;
+  const actual = migrationChecksum({ sql: migration.sql });
+  if (stored === actual)
+    return;
+  throw new VibeError9({
+    code: "VIBE_MIGRATION",
+    message: `checksum mismatch for migration "${migration.name}" \u2014 its SQL changed after it was applied (recorded ${stored.slice(0, 12)}\u2026, current ${actual.slice(0, 12)}\u2026)`,
+    meta: { migration: migration.name, recorded: stored, current: actual }
+  });
+}
+function assertResumable(params) {
+  const { migration, stored } = params;
+  const actual = migrationChecksum({ sql: migration.sql });
+  if (stored.checksum === actual)
+    return;
+  throw new VibeError9({
+    code: "VIBE_MIGRATION",
+    message: `migration "${migration.name}" is partially applied (${stored.statementIndex} statement(s) done) and its SQL has CHANGED since \u2014 refusing to resume; restore the original SQL or repair with resolveMigration`,
+    meta: {
+      migration: migration.name,
+      statementIndex: stored.statementIndex,
+      recorded: stored.checksum,
+      current: actual
+    }
+  });
+}
+function q4(dialect, name) {
+  return getSqlDialect({ dialect }).quoteIdent({ name });
+}
+function ph(dialect, index) {
+  return getSqlDialect({ dialect }).placeholder({ index });
+}
+
+// packages/migrate/src/introspect/shared.ts
+function detectJoinTable(params) {
+  const { table, columnNames, fkGroups, indexes } = params;
+  if (!table.startsWith("_"))
+    return null;
+  const names = [...columnNames].sort();
+  if (names.length !== 2 || names[0] !== "A" || names[1] !== "B")
+    return null;
+  const tableFks = fkGroups.filter((group) => group.table === table);
+  if (tableFks.length !== 2)
+    return null;
+  const fkA = tableFks.find((group) => group.columns.length === 1 && group.columns[0] === "A");
+  const fkB = tableFks.find((group) => group.columns.length === 1 && group.columns[0] === "B");
+  if (fkA === undefined || fkB === undefined)
+    return null;
+  const hasAbUnique = indexes.some((index) => index.table === table && index.unique && index.columns.length === 2 && index.columns[0]?.name === "A" && index.columns[1]?.name === "B");
+  if (!hasAbUnique)
+    return null;
+  const sorted = [fkA.refTable, fkB.refTable].sort();
+  const defaultName = `_${sorted[0]}To${sorted[1]}`;
+  return {
+    tableA: fkA.refTable,
+    tableB: fkB.refTable,
+    ...table === defaultName ? {} : { relationName: table.slice(1) }
+  };
+}
+function addFkRelations(params) {
+  const { models, fkGroups, joinTables } = params;
+  const modelsByName = new Map(models.map((model) => [model.name, model]));
+  const relationsByModel = new Map;
+  const takeName = nameAllocator({ models });
+  const ambiguousPairs = detectAmbiguousPairs({ fkGroups, joinTables, modelsByName });
+  for (const group of fkGroups) {
+    if (joinTables.has(group.table))
+      continue;
+    const owner = modelsByName.get(group.table);
+    const target = modelsByName.get(group.refTable);
+    if (owner === undefined || target === undefined)
+      continue;
+    const relationName = ambiguousPairs.has(modelPairKey({ a: group.table, b: group.refTable })) ? `${group.table}_${group.columns.join("_")}To${group.refTable}` : undefined;
+    const fkSide = {
+      name: takeName({ model: owner.name, base: lowerFirst(group.refTable) }),
+      model: owner.name,
+      targetModel: group.refTable,
+      type: "manyToOne",
+      fields: group.columns,
+      references: group.refColumns,
+      onDelete: group.onDelete,
+      onUpdate: group.onUpdate,
+      isList: false,
+      isOptional: !group.required,
+      ...relationName === undefined ? {} : { relationName }
+    };
+    pushRelation({ relationsByModel, relation: fkSide });
+    const listSide = {
+      name: takeName({ model: target.name, base: lowerFirst(group.table) }),
+      model: target.name,
+      targetModel: group.table,
+      type: "oneToMany",
+      isList: true,
+      isOptional: false,
+      ...relationName === undefined ? {} : { relationName }
+    };
+    pushRelation({ relationsByModel, relation: listSide });
+  }
+  applyRelations({ models, relationsByModel });
+}
+function addJoinTableRelations(params) {
+  const { models, joinTables } = params;
+  const modelsByName = new Map(models.map((model) => [model.name, model]));
+  const relationsByModel = new Map;
+  const takeName = nameAllocator({ models });
+  for (const [, joinTable] of joinTables) {
+    const modelA = modelsByName.get(joinTable.tableA);
+    const modelB = modelsByName.get(joinTable.tableB);
+    if (modelA === undefined || modelB === undefined)
+      continue;
+    const shared = joinTable.relationName;
+    pushRelation({
+      relationsByModel,
+      relation: {
+        name: takeName({ model: modelA.name, base: lowerFirst(modelB.name) }),
+        model: modelA.name,
+        targetModel: modelB.name,
+        type: "oneToMany",
+        isList: true,
+        isOptional: false,
+        ...shared === undefined ? {} : { relationName: shared }
+      }
+    });
+    pushRelation({
+      relationsByModel,
+      relation: {
+        name: takeName({ model: modelB.name, base: lowerFirst(modelA.name) }),
+        model: modelB.name,
+        targetModel: modelA.name,
+        type: "oneToMany",
+        isList: true,
+        isOptional: false,
+        ...shared === undefined ? {} : { relationName: shared }
+      }
+    });
+  }
+  applyRelations({ models, relationsByModel });
+}
+function modelPairKey(params) {
+  const { a, b } = params;
+  return [a, b].sort().join("\x00");
+}
+function detectAmbiguousPairs(params) {
+  const { fkGroups, joinTables, modelsByName } = params;
+  const counts = new Map;
+  const bump = (key) => {
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  };
+  for (const group of fkGroups) {
+    if (joinTables.has(group.table))
+      continue;
+    if (!modelsByName.has(group.table) || !modelsByName.has(group.refTable))
+      continue;
+    bump(modelPairKey({ a: group.table, b: group.refTable }));
+  }
+  for (const [, joinTable] of joinTables) {
+    if (joinTable.relationName !== undefined)
+      continue;
+    bump(modelPairKey({ a: joinTable.tableA, b: joinTable.tableB }));
+  }
+  return new Set([...counts.entries()].filter(([, count]) => count > 1).map(([key]) => key));
+}
+function pushRelation(params) {
+  const { relationsByModel, relation } = params;
+  const list = relationsByModel.get(relation.model);
+  if (list === undefined)
+    relationsByModel.set(relation.model, [relation]);
+  else
+    list.push(relation);
+}
+function applyRelations(params) {
+  const { models, relationsByModel } = params;
+  for (let index = 0;index < models.length; index += 1) {
+    const model = models[index];
+    const additions = relationsByModel.get(model.name);
+    if (additions === undefined)
+      continue;
+    models[index] = { ...model, relations: [...model.relations, ...additions] };
+  }
+}
+function nameAllocator(params) {
+  const { models } = params;
+  const used = new Map;
+  for (const model of models) {
+    used.set(model.name, new Set([
+      ...model.fields.map((field) => field.name),
+      ...model.relations.map((relation) => relation.name)
+    ]));
+  }
+  return ({ model, base }) => {
+    const names = used.get(model) ?? new Set;
+    used.set(model, names);
+    let candidate = base;
+    let suffix = 2;
+    while (names.has(candidate)) {
+      candidate = `${base}_${suffix}`;
+      suffix += 1;
+    }
+    names.add(candidate);
+    return candidate;
+  };
+}
+function lowerFirst(value) {
+  return value.charAt(0).toLowerCase() + value.slice(1);
+}
+
+// packages/migrate/src/introspect/postgres.ts
+var EXTENSION_OWNED_FILTER = `NOT EXISTS (
+      SELECT 1
+      FROM pg_catalog.pg_depend d
+      JOIN pg_catalog.pg_class c ON c.oid = d.objid
+      JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+      WHERE d.classid = 'pg_class'::regclass
+        AND d.deptype = 'e'
+        AND n.nspname = 'public'
+        AND c.relname = table_name
+    )`;
+var TABLES_QUERY = `
+  SELECT table_name
+  FROM information_schema.tables
+  WHERE table_schema = 'public'
+    AND table_type = 'BASE TABLE'
+    AND table_name <> '${MIGRATIONS_TABLE_NAME}'
+    AND ${EXTENSION_OWNED_FILTER}
+  ORDER BY table_name;
+`;
+var VIEWS_QUERY = `
+  SELECT table_name
+  FROM information_schema.views
+  WHERE table_schema = 'public'
+    AND ${EXTENSION_OWNED_FILTER}
+  ORDER BY table_name;
+`;
+var COLUMNS_QUERY = `
+  SELECT
+    table_name,
+    column_name,
+    data_type,
+    udt_name,
+    is_nullable,
+    is_identity,
+    column_default,
+    datetime_precision,
+    character_maximum_length,
+    numeric_precision,
+    numeric_scale,
+    ordinal_position,
+    (
+      SELECT format_type(a.atttypid, a.atttypmod)
+      FROM pg_attribute a
+      JOIN pg_class c ON c.oid = a.attrelid
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+      WHERE n.nspname = 'public'
+        AND c.relname = columns.table_name
+        AND a.attname = columns.column_name
+    ) AS full_type
+  FROM information_schema.columns AS columns
+  WHERE table_schema = 'public'
+  ORDER BY table_name, ordinal_position;
+`;
+var CONSTRAINTS_QUERY = `
+  SELECT
+    c.conname AS constraint_name,
+    CASE c.contype WHEN 'p' THEN 'PRIMARY KEY' ELSE 'UNIQUE' END AS constraint_type,
+    cl.relname AS table_name,
+    att.attname AS column_name
+  FROM pg_catalog.pg_constraint c
+  JOIN pg_catalog.pg_class cl    ON cl.oid = c.conrelid
+  JOIN pg_catalog.pg_namespace n ON n.oid = cl.relnamespace
+  JOIN unnest(c.conkey) WITH ORDINALITY AS k(attnum, ord) ON true
+  JOIN pg_catalog.pg_attribute att ON att.attrelid = c.conrelid AND att.attnum = k.attnum
+  WHERE c.contype IN ('p', 'u')
+    AND n.nspname = 'public'
+  ORDER BY cl.relname, c.conname, k.ord;
+`;
+var FOREIGN_KEYS_QUERY = `
+  SELECT
+    c.conname   AS constraint_name,
+    cl.relname  AS table_name,
+    att.attname AS column_name,
+    fcl.relname AS foreign_table_name,
+    fatt.attname AS foreign_column_name,
+    c.confdeltype AS on_delete_char,
+    c.confupdtype AS on_update_char
+  FROM pg_catalog.pg_constraint c
+  JOIN pg_catalog.pg_class cl     ON cl.oid = c.conrelid
+  JOIN pg_catalog.pg_namespace n  ON n.oid = cl.relnamespace
+  JOIN pg_catalog.pg_class fcl    ON fcl.oid = c.confrelid
+  JOIN pg_catalog.pg_namespace fn ON fn.oid = fcl.relnamespace
+  JOIN unnest(c.conkey)  WITH ORDINALITY AS lk(attnum, ord) ON true
+  JOIN unnest(c.confkey) WITH ORDINALITY AS rk(attnum, ord) ON lk.ord = rk.ord
+  JOIN pg_catalog.pg_attribute att  ON att.attrelid = c.conrelid  AND att.attnum = lk.attnum
+  JOIN pg_catalog.pg_attribute fatt ON fatt.attrelid = c.confrelid AND fatt.attnum = rk.attnum
+  WHERE c.contype = 'f'
+    AND n.nspname = 'public'
+    AND fn.nspname = 'public'
+  ORDER BY cl.relname, c.conname, lk.ord;
+`;
+var ENUMS_QUERY = `
+  SELECT
+    t.typname AS type_name,
+    e.enumlabel AS enum_value,
+    e.enumsortorder AS sort_order
+  FROM pg_type t
+  JOIN pg_enum e ON t.oid = e.enumtypid
+  JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+  WHERE n.nspname = 'public'
+  ORDER BY t.typname, e.enumsortorder;
+`;
+var INDEXES_QUERY = `
+  SELECT
+    tablename AS table_name,
+    indexname AS index_name,
+    indexdef AS index_def
+  FROM pg_indexes
+  WHERE schemaname = 'public'
+  ORDER BY tablename, indexname;
+`;
+async function introspectPostgres(params) {
+  const { executor } = params;
+  const [tableRows, viewRows, columnRows, constraintRows, fkRows, enumRows, indexRows] = await Promise.all([
+    executor({ text: TABLES_QUERY }),
+    executor({ text: VIEWS_QUERY }),
+    executor({ text: COLUMNS_QUERY }),
+    executor({ text: CONSTRAINTS_QUERY }),
+    executor({ text: FOREIGN_KEYS_QUERY }),
+    executor({ text: ENUMS_QUERY }),
+    executor({ text: INDEXES_QUERY })
+  ]);
+  const tables = tableRows.map((row) => row.table_name);
+  const views = viewRows.map((row) => row.table_name);
+  const columns = columnRows.map((row) => ({
+    table: row.table_name,
+    name: row.column_name,
+    dataType: row.data_type,
+    udtName: row.udt_name,
+    nullable: row.is_nullable === "YES",
+    identity: row.is_identity === "YES",
+    columnDefault: row.column_default ?? null,
+    datetimePrecision: toNumberOrNull(row.datetime_precision),
+    charMaxLength: toNumberOrNull(row.character_maximum_length),
+    numericPrecision: toNumberOrNull(row.numeric_precision),
+    numericScale: toNumberOrNull(row.numeric_scale),
+    fullType: row.full_type ?? null
+  }));
+  const enums = [];
+  {
+    const valuesByName = new Map;
+    for (const row of enumRows) {
+      const name = row.type_name;
+      const list = valuesByName.get(name);
+      if (list === undefined)
+        valuesByName.set(name, [row.enum_value]);
+      else
+        list.push(row.enum_value);
+    }
+    for (const [name, values] of valuesByName)
+      enums.push({ name, values });
+  }
+  const enumNames = new Set(enums.map((entry) => entry.name));
+  const pkByTable = new Map;
+  const uniquesByConstraint = new Map;
+  const constraintNames = new Set;
+  for (const row of constraintRows) {
+    const table = row.table_name;
+    const constraintName = row.constraint_name;
+    const columnName = row.column_name;
+    constraintNames.add(constraintName);
+    if (row.constraint_type === "PRIMARY KEY") {
+      const list = pkByTable.get(table);
+      if (list === undefined)
+        pkByTable.set(table, [columnName]);
+      else
+        list.push(columnName);
+    } else {
+      const entry = uniquesByConstraint.get(constraintName);
+      if (entry === undefined)
+        uniquesByConstraint.set(constraintName, { table, columns: [columnName] });
+      else
+        entry.columns.push(columnName);
+    }
+  }
+  const fkGroupsByName = new Map;
+  for (const row of fkRows) {
+    const constraintName = row.constraint_name;
+    const existing = fkGroupsByName.get(constraintName);
+    if (existing === undefined) {
+      fkGroupsByName.set(constraintName, {
+        constraintName,
+        table: row.table_name,
+        columns: [row.column_name],
+        refTable: row.foreign_table_name,
+        refColumns: [row.foreign_column_name],
+        onDelete: PG_CHAR_TO_CASCADE_ACTION[row.on_delete_char ?? "a"] ?? "NoAction",
+        onUpdate: PG_CHAR_TO_CASCADE_ACTION[row.on_update_char ?? "a"] ?? "NoAction"
+      });
+    } else {
+      existing.columns.push(row.column_name);
+      existing.refColumns.push(row.foreign_column_name);
+    }
+  }
+  const fkGroups = [...fkGroupsByName.values()].map((group) => ({
+    ...group,
+    required: group.columns.every((columnName) => {
+      const column = columns.find((c) => c.table === group.table && c.name === columnName);
+      return column === undefined ? true : !column.nullable;
+    })
+  }));
+  const indexes = [];
+  for (const row of indexRows) {
+    const parsed = parseIndexDef({
+      table: row.table_name,
+      name: row.index_name,
+      def: row.index_def
+    });
+    if (parsed !== null)
+      indexes.push(parsed);
+  }
+  const joinTables = new Map;
+  for (const table of tables) {
+    const detected = detectJoinTable({
+      table,
+      columnNames: columns.filter((column) => column.table === table).map((column) => column.name),
+      fkGroups,
+      indexes
+    });
+    if (detected !== null)
+      joinTables.set(table, detected);
+  }
+  const models = [];
+  for (const table of tables) {
+    if (joinTables.has(table))
+      continue;
+    models.push(buildModel({
+      table,
+      isView: false,
+      columns,
+      pkByTable,
+      uniquesByConstraint,
+      constraintNames,
+      indexes,
+      enumNames
+    }));
+  }
+  for (const view of views) {
+    models.push(buildModel({
+      table: view,
+      isView: true,
+      columns,
+      pkByTable,
+      uniquesByConstraint,
+      constraintNames,
+      indexes: [],
+      enumNames
+    }));
+  }
+  addFkRelations({ models, fkGroups, joinTables });
+  addJoinTableRelations({ models, joinTables });
+  return {
+    datasource: { provider: "postgresql" },
+    models,
+    enums,
+    extensions: []
+  };
+}
+function buildModel(params) {
+  const { table, isView, columns, pkByTable, uniquesByConstraint, constraintNames, indexes, enumNames } = params;
+  const tableColumns = columns.filter((column) => column.table === table);
+  const pk = pkByTable.get(table) ?? [];
+  const uniqueSingles = new Set;
+  const multiUniques = [];
+  for (const [name, unique] of uniquesByConstraint) {
+    if (unique.table !== table)
+      continue;
+    if (unique.columns.length === 1)
+      uniqueSingles.add(unique.columns[0]);
+    else
+      multiUniques.push({ name, columns: unique.columns });
+  }
+  const tableIndexes = indexes.filter((index) => index.table === table && !constraintNames.has(index.name));
+  for (const index of tableIndexes) {
+    if (!index.unique)
+      continue;
+    if (index.columns.length === 1)
+      uniqueSingles.add(index.columns[0].name);
+  }
+  const fields = tableColumns.map((column) => buildField({ column, pk, uniqueSingles, enumNames }));
+  const modelIndexes = [];
+  for (const unique of multiUniques) {
+    modelIndexes.push({
+      name: unique.name,
+      kind: "unique",
+      fields: unique.columns.map((name) => ({ name }))
+    });
+  }
+  for (const index of tableIndexes) {
+    if (index.unique && index.columns.length === 1)
+      continue;
+    modelIndexes.push({
+      name: index.name,
+      kind: index.unique ? "unique" : index.kind,
+      fields: index.columns.map((column) => ({
+        name: column.name,
+        ...column.desc ? { sort: "desc" } : {}
+      })),
+      ...index.where === undefined ? {} : { where: index.where }
+    });
+  }
+  return {
+    name: table,
+    fields,
+    relations: [],
+    indexes: modelIndexes,
+    isView,
+    ...pk.length > 1 ? { primaryKey: { fields: pk } } : {}
+  };
+}
+function buildField(params) {
+  const { column, pk, uniqueSingles, enumNames } = params;
+  const mapped = reverseMapType({ column, enumNames });
+  const isId = pk.length === 1 && pk[0] === column.name;
+  const defaultValue = parseColumnDefault({ column, mapped });
+  return {
+    name: column.name,
+    type: mapped.type,
+    isList: mapped.isList,
+    isOptional: column.nullable,
+    isId,
+    isUnique: uniqueSingles.has(column.name),
+    isUpdatedAt: false,
+    ...defaultValue === undefined ? {} : { default: defaultValue },
+    ...mapped.nativeType === undefined ? {} : { nativeType: mapped.nativeType },
+    ...mapped.isUnsupported === true ? { isUnsupported: true } : {}
+  };
+}
+var CANONICAL_UDT = {
+  text: "String",
+  bool: "Boolean",
+  int4: "Int",
+  int8: "BigInt",
+  float8: "Float",
+  numeric: "Decimal",
+  timestamptz: "DateTime",
+  jsonb: "Json",
+  bytea: "Bytes"
+};
+var NON_CANONICAL_UDT = {
+  varchar: "String",
+  bpchar: "String",
+  uuid: "String",
+  int2: "Int",
+  float4: "Float",
+  timestamp: "DateTime",
+  date: "DateTime",
+  json: "Json"
+};
+function reverseMapType(params) {
+  const { column, enumNames } = params;
+  const isList = column.dataType === "ARRAY";
+  const udt = isList ? column.udtName.replace(/^_/, "") : column.udtName;
+  if (enumNames.has(udt)) {
+    return { type: { enum: udt }, isList };
+  }
+  const canonical = CANONICAL_UDT[udt];
+  if (canonical !== undefined) {
+    const nativeType = nonCanonicalModifier({ column, udt, scalar: canonical });
+    return { type: canonical, isList, ...nativeType === undefined ? {} : { nativeType } };
+  }
+  const nonCanonical = NON_CANONICAL_UDT[udt];
+  if (nonCanonical !== undefined) {
+    return { type: nonCanonical, isList, nativeType: withModifier({ column, udt }) };
+  }
+  const raw = column.fullType ?? udt;
+  return {
+    type: "String",
+    isList: false,
+    nativeType: isList && !raw.endsWith("[]") ? `${raw}[]` : raw,
+    isUnsupported: true
+  };
+}
+function nonCanonicalModifier(params) {
+  const { column, udt, scalar } = params;
+  if (scalar === "DateTime" && udt === "timestamptz") {
+    const precision = column.datetimePrecision;
+    return precision === null || precision === 6 ? undefined : `timestamptz(${precision})`;
+  }
+  if (scalar === "Decimal" && udt === "numeric") {
+    if (column.numericPrecision === null)
+      return;
+    const scale = column.numericScale ?? 0;
+    return `numeric(${column.numericPrecision},${scale})`;
+  }
+  return;
+}
+function withModifier(params) {
+  const { column, udt } = params;
+  if ((udt === "varchar" || udt === "bpchar") && column.charMaxLength !== null) {
+    return `${udt === "bpchar" ? "char" : "varchar"}(${column.charMaxLength})`;
+  }
+  if (udt === "bpchar")
+    return "char";
+  if (udt === "timestamp" && column.datetimePrecision !== null && column.datetimePrecision !== 6) {
+    return `timestamp(${column.datetimePrecision})`;
+  }
+  return udt;
+}
+function parseColumnDefault(params) {
+  const { column, mapped } = params;
+  if (column.identity)
+    return { kind: "autoincrement" };
+  const raw = column.columnDefault;
+  if (raw === null)
+    return;
+  if (raw.startsWith("NULL::"))
+    return;
+  if (raw.includes("nextval("))
+    return { kind: "autoincrement" };
+  if (raw === "now()" || raw.startsWith("CURRENT_TIMESTAMP"))
+    return { kind: "now" };
+  if (raw === "true" || raw === "false")
+    return { kind: "literal", value: raw === "true" };
+  if (/^-?\d+(\.\d+)?$/.test(raw))
+    return { kind: "literal", value: Number(raw) };
+  const quoted = raw.match(/^'((?:[^']|'')*)'(::.*)?$/);
+  if (quoted !== null) {
+    const value = quoted[1].replaceAll("''", "'");
+    if (typeof mapped.type === "object")
+      return { kind: "enumValue", value };
+    if (isNumericScalar({ type: mapped.type }) && /^-?\d+(\.\d+)?$/.test(value)) {
+      return { kind: "literal", value: Number(value) };
+    }
+    const cast = quoted[2];
+    if (cast !== undefined && cast !== "" && mapped.isList) {
+      return { kind: "dbgenerated", sql: raw };
+    }
+    return { kind: "literal", value };
+  }
+  return { kind: "dbgenerated", sql: raw };
+}
+function parseIndexDef(params) {
+  const { table, name, def } = params;
+  const head = def.match(/^CREATE (UNIQUE )?INDEX .*? USING (\w+) \(/);
+  if (head === null)
+    return null;
+  const start = (head.index ?? 0) + head[0].length;
+  let depth = 1;
+  let end = -1;
+  for (let position = start;position < def.length; position += 1) {
+    const char = def[position];
+    if (char === "(")
+      depth += 1;
+    else if (char === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        end = position;
+        break;
+      }
+    }
+  }
+  if (end === -1)
+    return null;
+  const columns = splitTopLevel({ text: def.slice(start, end) }).map((entry) => {
+    const trimmed = entry.trim();
+    const desc = / DESC$/i.test(trimmed);
+    const nameOnly = trimmed.replace(/ (DESC|ASC)( NULLS (FIRST|LAST))?$/i, "");
+    return { name: nameOnly.replaceAll('"', ""), desc };
+  });
+  const tail = def.slice(end + 1).trim();
+  const whereMatch = tail.match(/^WHERE (.*)$/);
+  const whereRaw = whereMatch?.[1];
+  return {
+    table,
+    name,
+    unique: head[1] !== undefined,
+    kind: head[2].toLowerCase(),
+    columns,
+    ...whereRaw === undefined ? {} : { where: whereRaw }
+  };
+}
+function splitTopLevel(params) {
+  const { text } = params;
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (const char of text) {
+    if (char === "(")
+      depth += 1;
+    if (char === ")")
+      depth -= 1;
+    if (char === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim().length > 0)
+    parts.push(current);
+  return parts;
+}
+function toNumberOrNull(value) {
+  if (value === null || value === undefined)
+    return null;
+  const parsed = Number(value);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+// packages/migrate/src/introspect/sqlite.ts
+import { sqliteDialect as sqliteDialect2 } from "@vibeorm/sql";
+var SQLITE_ACTION_TO_CASCADE = {
+  "NO ACTION": "NoAction",
+  RESTRICT: "Restrict",
+  CASCADE: "Cascade",
+  "SET NULL": "SetNull",
+  "SET DEFAULT": "SetDefault"
+};
+async function introspectSqlite(params) {
+  const { executor } = params;
+  const masterRows = await executor({
+    text: `SELECT name, type, sql FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%' AND name <> '${MIGRATIONS_TABLE_NAME}' ORDER BY name`,
+    values: []
+  });
+  const indexSqlRows = await executor({
+    text: `SELECT name, tbl_name, sql FROM sqlite_master WHERE type = 'index' ORDER BY name`,
+    values: []
+  });
+  const entries = masterRows.map((row) => ({
+    name: row.name,
+    type: row.type,
+    sql: row.sql ?? null
+  }));
+  const tables = entries.filter((entry) => entry.type === "table");
+  const views = entries.filter((entry) => entry.type === "view");
+  const indexSqlByName = new Map;
+  for (const row of indexSqlRows) {
+    indexSqlByName.set(row.name, row.sql ?? null);
+  }
+  const columnsByTable = new Map;
+  const indexes = [];
+  const uniqueSinglesByTable = new Map;
+  const modelIndexesByTable = new Map;
+  const fkGroups = [];
+  const enumsByColumn = new Map;
+  const enumRegistry = new Map;
+  const autoincrementTables = new Set;
+  for (const table of tables) {
+    const columns = await readColumns({ executor, table: table.name });
+    columnsByTable.set(table.name, columns);
+    for (const check of parseSqliteEnumChecks({ tableSql: table.sql ?? "" })) {
+      enumsByColumn.set(`${table.name}.${check.column}`, {
+        enumName: check.enumName,
+        values: check.values
+      });
+      if (!enumRegistry.has(check.enumName)) {
+        enumRegistry.set(check.enumName, { name: check.enumName, values: check.values });
+      }
+    }
+    if (/PRIMARY KEY AUTOINCREMENT/i.test(table.sql ?? "")) {
+      autoincrementTables.add(table.name);
+    }
+    const { tableIndexes, uniqueSingles, modelIndexes } = await readIndexes({
+      executor,
+      table: table.name,
+      indexSqlByName
+    });
+    indexes.push(...tableIndexes);
+    uniqueSinglesByTable.set(table.name, uniqueSingles);
+    modelIndexesByTable.set(table.name, modelIndexes);
+    fkGroups.push(...await readForeignKeys({ executor, table: table.name, columns }));
+  }
+  const joinTables = new Map;
+  for (const table of tables) {
+    const detected = detectJoinTable({
+      table: table.name,
+      columnNames: (columnsByTable.get(table.name) ?? []).map((column) => column.name),
+      fkGroups,
+      indexes
+    });
+    if (detected !== null)
+      joinTables.set(table.name, detected);
+  }
+  const models = [];
+  for (const table of tables) {
+    if (joinTables.has(table.name))
+      continue;
+    models.push(buildModel2({
+      table: table.name,
+      isView: false,
+      columns: columnsByTable.get(table.name) ?? [],
+      uniqueSingles: uniqueSinglesByTable.get(table.name) ?? new Set,
+      modelIndexes: modelIndexesByTable.get(table.name) ?? [],
+      enumsByColumn,
+      autoincrement: autoincrementTables.has(table.name)
+    }));
+  }
+  for (const view of views) {
+    models.push(buildModel2({
+      table: view.name,
+      isView: true,
+      columns: await readColumns({ executor, table: view.name }),
+      uniqueSingles: new Set,
+      modelIndexes: [],
+      enumsByColumn,
+      autoincrement: false
+    }));
+  }
+  addFkRelations({ models, fkGroups, joinTables });
+  addJoinTableRelations({ models, joinTables });
+  return {
+    datasource: { provider: "sqlite" },
+    models,
+    enums: [...enumRegistry.values()],
+    extensions: []
+  };
+}
+async function readColumns(params) {
+  const rows = await params.executor({
+    text: `PRAGMA table_info(${q5(params.table)})`,
+    values: []
+  });
+  return rows.map((row) => ({
+    name: row.name,
+    declaredType: row.type ?? "",
+    notNull: Number(row.notnull) === 1,
+    defaultValue: row.dflt_value === null || row.dflt_value === undefined ? null : String(row.dflt_value),
+    pkPosition: Number(row.pk)
+  }));
+}
+async function readIndexes(params) {
+  const { executor, table, indexSqlByName } = params;
+  const listRows = await executor({ text: `PRAGMA index_list(${q5(table)})`, values: [] });
+  const tableIndexes = [];
+  const uniqueSingles = new Set;
+  const modelIndexes = [];
+  for (const listRow of listRows) {
+    const origin = listRow.origin;
+    if (origin === "pk")
+      continue;
+    const name = listRow.name;
+    const unique = Number(listRow.unique) === 1;
+    const partial = Number(listRow.partial) === 1;
+    const infoRows = await executor({ text: `PRAGMA index_xinfo(${q5(name)})`, values: [] });
+    const keyRows = infoRows.filter((row) => Number(row.key) === 1).sort((a, b) => Number(a.seqno) - Number(b.seqno));
+    let columns;
+    if (keyRows.some((row) => row.name === null || row.name === undefined)) {
+      const recovered = parseIndexColumnsFromSql({ sql: indexSqlByName.get(name) ?? null });
+      if (recovered === null)
+        continue;
+      columns = recovered;
+    } else {
+      columns = keyRows.map((row) => ({
+        name: row.name,
+        desc: Number(row.desc) === 1
+      }));
+    }
+    let where;
+    if (partial) {
+      const sql = indexSqlByName.get(name);
+      const match = sql?.match(/\sWHERE\s+(.*)$/is);
+      where = match?.[1]?.trim();
+    }
+    tableIndexes.push({
+      table,
+      name,
+      unique,
+      kind: "btree",
+      columns,
+      ...where === undefined ? {} : { where }
+    });
+    if (unique && columns.length === 1 && where === undefined) {
+      uniqueSingles.add(columns[0].name);
+      continue;
+    }
+    modelIndexes.push({
+      name,
+      kind: unique ? "unique" : "btree",
+      fields: columns.map((column) => ({
+        name: column.name,
+        ...column.desc ? { sort: "desc" } : {}
+      })),
+      ...where === undefined ? {} : { where }
+    });
+  }
+  return { tableIndexes, uniqueSingles, modelIndexes };
+}
+var PLAIN_INDEX_COLUMN = /^"((?:[^"]|"")+)"(?:\s+(ASC|DESC))?$/i;
+var CAST_REAL_INDEX_COLUMN = /^CAST\s*\(\s*"((?:[^"]|"")+)"\s+AS\s+REAL\s*\)(?:\s+(ASC|DESC))?$/i;
+function parseIndexColumnsFromSql(params) {
+  const { sql } = params;
+  if (sql === null)
+    return null;
+  const onMatch = /\sON\s+"(?:[^"]|"")+"\s*\(/i.exec(sql);
+  if (onMatch === null)
+    return null;
+  const open = onMatch.index + onMatch[0].length - 1;
+  let listDepth = 0;
+  let close = -1;
+  for (let index = open;index < sql.length; index++) {
+    const char = sql[index];
+    if (char === "(")
+      listDepth += 1;
+    else if (char === ")") {
+      listDepth -= 1;
+      if (listDepth === 0) {
+        close = index;
+        break;
+      }
+    }
+  }
+  if (close === -1)
+    return null;
+  const list = sql.slice(open + 1, close);
+  const terms = [];
+  let depth = 0;
+  let start = 0;
+  for (let index = 0;index < list.length; index++) {
+    const char = list[index];
+    if (char === "(")
+      depth += 1;
+    else if (char === ")")
+      depth -= 1;
+    else if (char === "," && depth === 0) {
+      terms.push(list.slice(start, index));
+      start = index + 1;
+    }
+  }
+  terms.push(list.slice(start));
+  const columns = [];
+  for (const term of terms) {
+    const trimmed = term.trim();
+    const match = PLAIN_INDEX_COLUMN.exec(trimmed) ?? CAST_REAL_INDEX_COLUMN.exec(trimmed);
+    if (match === null)
+      return null;
+    columns.push({
+      name: match[1].replaceAll('""', '"'),
+      desc: (match[2] ?? "").toUpperCase() === "DESC"
+    });
+  }
+  return columns;
+}
+async function readForeignKeys(params) {
+  const { executor, table, columns } = params;
+  const rows = await executor({ text: `PRAGMA foreign_key_list(${q5(table)})`, values: [] });
+  const groups = new Map;
+  const ordered = [...rows].sort((a, b) => Number(a.id) - Number(b.id) || Number(a.seq) - Number(b.seq));
+  for (const row of ordered) {
+    const id = Number(row.id);
+    const from = row.from;
+    const to = row.to ?? "rowid";
+    const existing = groups.get(id);
+    if (existing === undefined) {
+      groups.set(id, {
+        columns: [from],
+        refTable: row.table,
+        refColumns: [to],
+        onDelete: SQLITE_ACTION_TO_CASCADE[row.on_delete ?? "NO ACTION"] ?? "NoAction",
+        onUpdate: SQLITE_ACTION_TO_CASCADE[row.on_update ?? "NO ACTION"] ?? "NoAction"
+      });
+    } else {
+      existing.columns.push(from);
+      existing.refColumns.push(to);
+    }
+  }
+  return [...groups.values()].map((group) => ({
+    constraintName: `${table}_${group.columns.join("_")}_fkey`,
+    table,
+    columns: group.columns,
+    refTable: group.refTable,
+    refColumns: group.refColumns,
+    onDelete: group.onDelete,
+    onUpdate: group.onUpdate,
+    required: group.columns.every((columnName) => {
+      const column = columns.find((candidate) => candidate.name === columnName);
+      return column === undefined ? true : column.notNull;
+    })
+  }));
+}
+function buildModel2(params) {
+  const { table, isView, columns, uniqueSingles, modelIndexes, enumsByColumn, autoincrement } = params;
+  const pk = columns.filter((column) => column.pkPosition > 0).sort((a, b) => a.pkPosition - b.pkPosition).map((column) => column.name);
+  const fields = columns.map((column) => {
+    const enumRef = enumsByColumn.get(`${table}.${column.name}`);
+    const mapped = reverseMapType2({ column, enumRef });
+    const isId = pk.length === 1 && pk[0] === column.name;
+    const isAutoincrement = autoincrement && isId && column.declaredType.toUpperCase() === "INTEGER";
+    const defaultValue = isAutoincrement ? { kind: "autoincrement" } : parseColumnDefault2({ column, mapped });
+    return {
+      name: column.name,
+      type: mapped.type,
+      isList: false,
+      isOptional: column.pkPosition > 0 ? false : !column.notNull,
+      isId,
+      isUnique: uniqueSingles.has(column.name),
+      isUpdatedAt: false,
+      ...defaultValue === undefined ? {} : { default: defaultValue },
+      ...mapped.nativeType === undefined ? {} : { nativeType: mapped.nativeType },
+      ...mapped.isUnsupported === true ? { isUnsupported: true } : {}
+    };
+  });
+  return {
+    name: table,
+    fields,
+    relations: [],
+    indexes: [...modelIndexes],
+    isView,
+    ...pk.length > 1 ? { primaryKey: { fields: pk } } : {}
+  };
+}
+function reverseMapType2(params) {
+  const { column, enumRef } = params;
+  const declared = column.declaredType.trim().toUpperCase();
+  if (enumRef !== undefined && declared === "TEXT") {
+    return { type: { enum: enumRef.enumName } };
+  }
+  switch (declared) {
+    case "TEXT":
+      return { type: "String" };
+    case "INTEGER":
+      return { type: "Int" };
+    case "REAL":
+      return { type: "Float" };
+    case "BLOB":
+      return { type: "Bytes" };
+    default:
+      return { type: "String", nativeType: column.declaredType, isUnsupported: true };
+  }
+}
+function parseColumnDefault2(params) {
+  const { column, mapped } = params;
+  const raw = column.defaultValue;
+  if (raw === null)
+    return;
+  if (raw === "CURRENT_TIMESTAMP")
+    return { kind: "now" };
+  if (/^-?\d+(\.\d+)?$/.test(raw))
+    return { kind: "literal", value: Number(raw) };
+  const quoted = raw.match(/^'((?:[^']|'')*)'$/);
+  if (quoted !== null) {
+    const value = quoted[1].replaceAll("''", "'");
+    if (typeof mapped.type === "object")
+      return { kind: "enumValue", value };
+    if ((mapped.type === "Int" || mapped.type === "Float") && /^-?\d+(\.\d+)?$/.test(value)) {
+      return { kind: "literal", value: Number(value) };
+    }
+    return { kind: "literal", value };
+  }
+  return { kind: "dbgenerated", sql: raw };
+}
+function q5(name) {
+  return sqliteDialect2.quoteIdent({ name });
+}
+// packages/migrate/src/introspect/mysql.ts
+var TABLES_QUERY2 = `
+  SELECT table_name
+  FROM information_schema.tables
+  WHERE table_schema = DATABASE()
+    AND table_type = 'BASE TABLE'
+    AND table_name <> '${MIGRATIONS_TABLE_NAME}'
+  ORDER BY table_name;
+`;
+var VIEWS_QUERY2 = `
+  SELECT table_name
+  FROM information_schema.views
+  WHERE table_schema = DATABASE()
+  ORDER BY table_name;
+`;
+var COLUMNS_QUERY2 = `
+  SELECT
+    table_name,
+    column_name,
+    column_type,
+    is_nullable,
+    column_default,
+    extra,
+    ordinal_position
+  FROM information_schema.columns
+  WHERE table_schema = DATABASE()
+  ORDER BY table_name, ordinal_position;
+`;
+var STATISTICS_QUERY = `
+  SELECT
+    table_name,
+    index_name,
+    non_unique,
+    seq_in_index,
+    column_name,
+    collation
+  FROM information_schema.statistics
+  WHERE table_schema = DATABASE()
+  ORDER BY table_name, index_name, seq_in_index;
+`;
+var FOREIGN_KEYS_QUERY2 = `
+  SELECT
+    constraint_name,
+    table_name,
+    column_name,
+    ordinal_position,
+    referenced_table_name,
+    referenced_column_name
+  FROM information_schema.key_column_usage
+  WHERE table_schema = DATABASE()
+    AND referenced_table_name IS NOT NULL
+  ORDER BY table_name, constraint_name, ordinal_position;
+`;
+var REFERENTIAL_QUERY = `
+  SELECT constraint_name, update_rule, delete_rule
+  FROM information_schema.referential_constraints
+  WHERE constraint_schema = DATABASE();
+`;
+var MYSQL_RULE_TO_CASCADE = {
+  "NO ACTION": "NoAction",
+  RESTRICT: "Restrict",
+  CASCADE: "Cascade",
+  "SET NULL": "SetNull",
+  "SET DEFAULT": "SetDefault"
+};
+function catalogField(params) {
+  const value = params.row[params.name];
+  return value !== undefined ? value : params.row[params.name.toUpperCase()];
+}
+async function introspectMysql(params) {
+  const { executor } = params;
+  const [tableRows, viewRows, columnRows, statisticRows, fkRows, refRows] = await Promise.all([
+    executor({ text: TABLES_QUERY2 }),
+    executor({ text: VIEWS_QUERY2 }),
+    executor({ text: COLUMNS_QUERY2 }),
+    executor({ text: STATISTICS_QUERY }),
+    executor({ text: FOREIGN_KEYS_QUERY2 }),
+    executor({ text: REFERENTIAL_QUERY })
+  ]);
+  const tables = tableRows.map((row) => catalogField({ row, name: "table_name" }));
+  const views = viewRows.map((row) => catalogField({ row, name: "table_name" }));
+  const columns = columnRows.map((row) => ({
+    table: catalogField({ row, name: "table_name" }),
+    name: catalogField({ row, name: "column_name" }),
+    columnType: catalogField({ row, name: "column_type" }),
+    nullable: catalogField({ row, name: "is_nullable" }) === "YES",
+    columnDefault: catalogField({ row, name: "column_default" }) ?? null,
+    extra: (catalogField({ row, name: "extra" }) ?? "").toLowerCase()
+  }));
+  const rulesByConstraint = new Map;
+  for (const row of refRows) {
+    rulesByConstraint.set(catalogField({ row, name: "constraint_name" }), {
+      onDelete: MYSQL_RULE_TO_CASCADE[(catalogField({ row, name: "delete_rule" }) ?? "NO ACTION").toUpperCase()] ?? "NoAction",
+      onUpdate: MYSQL_RULE_TO_CASCADE[(catalogField({ row, name: "update_rule" }) ?? "NO ACTION").toUpperCase()] ?? "NoAction"
+    });
+  }
+  const groupsByKey = new Map;
+  for (const row of fkRows) {
+    const constraintName = catalogField({ row, name: "constraint_name" });
+    const table = catalogField({ row, name: "table_name" });
+    const key = `${table}\x00${constraintName}`;
+    const existing = groupsByKey.get(key);
+    if (existing === undefined) {
+      groupsByKey.set(key, {
+        constraintName,
+        table,
+        columns: [catalogField({ row, name: "column_name" })],
+        refTable: catalogField({ row, name: "referenced_table_name" }),
+        refColumns: [catalogField({ row, name: "referenced_column_name" })]
+      });
+    } else {
+      existing.columns.push(catalogField({ row, name: "column_name" }));
+      existing.refColumns.push(catalogField({ row, name: "referenced_column_name" }));
+    }
+  }
+  const fkGroups = [...groupsByKey.values()].map((group) => {
+    const rules = rulesByConstraint.get(group.constraintName);
+    return {
+      ...group,
+      onDelete: rules?.onDelete ?? "NoAction",
+      onUpdate: rules?.onUpdate ?? "NoAction",
+      required: group.columns.every((columnName) => {
+        const column = columns.find((candidate) => candidate.table === group.table && candidate.name === columnName);
+        return column === undefined ? true : !column.nullable;
+      })
+    };
+  });
+  const fkNamesByTable = new Map;
+  for (const group of fkGroups) {
+    const set = fkNamesByTable.get(group.table) ?? new Set;
+    set.add(group.constraintName);
+    fkNamesByTable.set(group.table, set);
+  }
+  const pkByTable = new Map;
+  const indexes = [];
+  {
+    const byKey = new Map;
+    for (const row of statisticRows) {
+      const table = catalogField({ row, name: "table_name" });
+      const name = catalogField({ row, name: "index_name" });
+      const columnName = catalogField({ row, name: "column_name" });
+      if (name === "PRIMARY") {
+        const list = pkByTable.get(table);
+        if (list === undefined)
+          pkByTable.set(table, [columnName]);
+        else
+          list.push(columnName);
+        continue;
+      }
+      if (fkNamesByTable.get(table)?.has(name) === true)
+        continue;
+      const key = `${table}\x00${name}`;
+      const entry = byKey.get(key);
+      const column = {
+        name: columnName,
+        desc: catalogField({ row, name: "collation" }) === "D"
+      };
+      if (entry === undefined) {
+        byKey.set(key, {
+          table,
+          name,
+          unique: Number(catalogField({ row, name: "non_unique" })) === 0,
+          columns: [column]
+        });
+      } else {
+        entry.columns.push(column);
+      }
+    }
+    for (const entry of byKey.values()) {
+      indexes.push({ ...entry, kind: "btree" });
+    }
+  }
+  const enums = [];
+  const joinTables = new Map;
+  for (const table of tables) {
+    const detected = detectJoinTable({
+      table,
+      columnNames: columns.filter((column) => column.table === table).map((column) => column.name),
+      fkGroups,
+      indexes
+    });
+    if (detected !== null)
+      joinTables.set(table, detected);
+  }
+  const models = [];
+  for (const table of tables) {
+    if (joinTables.has(table))
+      continue;
+    models.push(buildModel3({ table, isView: false, columns, pkByTable, indexes, enums }));
+  }
+  for (const view of views) {
+    models.push(buildModel3({ table: view, isView: true, columns, pkByTable: new Map, indexes: [], enums }));
+  }
+  addFkRelations({ models, fkGroups, joinTables });
+  addJoinTableRelations({ models, joinTables });
+  return {
+    datasource: { provider: "mysql" },
+    models,
+    enums,
+    extensions: []
+  };
+}
+function buildModel3(params) {
+  const { table, isView, columns, pkByTable, indexes, enums } = params;
+  const tableColumns = columns.filter((column) => column.table === table);
+  const pk = pkByTable.get(table) ?? [];
+  const tableIndexes = indexes.filter((index) => index.table === table);
+  const uniqueSingles = new Set;
+  for (const index of tableIndexes) {
+    if (index.unique && index.columns.length === 1) {
+      uniqueSingles.add(index.columns[0].name);
+    }
+  }
+  const fields = tableColumns.map((column) => {
+    const mapped = reverseMapType3({ table, column, enums });
+    const isId = pk.length === 1 && pk[0] === column.name;
+    const defaultValue = parseColumnDefault3({ column, mapped });
+    return {
+      name: column.name,
+      type: mapped.type,
+      isList: false,
+      isOptional: column.nullable,
+      isId,
+      isUnique: uniqueSingles.has(column.name),
+      isUpdatedAt: false,
+      ...defaultValue === undefined ? {} : { default: defaultValue },
+      ...mapped.nativeType === undefined ? {} : { nativeType: mapped.nativeType },
+      ...mapped.isUnsupported === true ? { isUnsupported: true } : {}
+    };
+  });
+  const modelIndexes = [];
+  for (const index of tableIndexes) {
+    if (index.unique && index.columns.length === 1)
+      continue;
+    modelIndexes.push({
+      name: index.name,
+      kind: index.unique ? "unique" : "btree",
+      fields: index.columns.map((column) => ({
+        name: column.name,
+        ...column.desc ? { sort: "desc" } : {}
+      }))
+    });
+  }
+  return {
+    name: table,
+    fields,
+    relations: [],
+    indexes: modelIndexes,
+    isView,
+    ...pk.length > 1 ? { primaryKey: { fields: pk } } : {}
+  };
+}
+var CANONICAL_MYSQL = {
+  "varchar(191)": "String",
+  "tinyint(1)": "Boolean",
+  int: "Int",
+  bigint: "BigInt",
+  double: "Float",
+  "decimal(65,30)": "Decimal",
+  "datetime(3)": "DateTime",
+  json: "Json",
+  longblob: "Bytes"
+};
+var BASE_TO_SCALAR = {
+  varchar: "String",
+  char: "String",
+  text: "String",
+  tinytext: "String",
+  mediumtext: "String",
+  longtext: "String",
+  tinyint: "Int",
+  smallint: "Int",
+  mediumint: "Int",
+  int: "Int",
+  bigint: "BigInt",
+  double: "Float",
+  float: "Float",
+  real: "Float",
+  decimal: "Decimal",
+  datetime: "DateTime",
+  timestamp: "DateTime",
+  date: "DateTime",
+  json: "Json",
+  blob: "Bytes",
+  tinyblob: "Bytes",
+  mediumblob: "Bytes",
+  longblob: "Bytes",
+  binary: "Bytes",
+  varbinary: "Bytes"
+};
+function reverseMapType3(params) {
+  const { table, column, enums } = params;
+  const enumValues = parseMysqlEnumColumnType({ columnType: column.columnType });
+  if (enumValues !== null) {
+    const name = `${table}_${column.name}`;
+    if (!enums.some((entry) => entry.name === name)) {
+      enums.push({ name, values: enumValues });
+    }
+    return { type: { enum: name } };
+  }
+  const normalized = normalizeMysqlType({ raw: column.columnType });
+  const canonical = CANONICAL_MYSQL[normalized];
+  if (canonical !== undefined)
+    return { type: canonical };
+  const base = normalized.match(/^([a-z_0-9]+)/)?.[1] ?? normalized;
+  const scalar = BASE_TO_SCALAR[base];
+  if (scalar !== undefined) {
+    return { type: scalar, nativeType: column.columnType };
+  }
+  return { type: "String", nativeType: column.columnType, isUnsupported: true };
+}
+function parseColumnDefault3(params) {
+  const { column, mapped } = params;
+  if (column.extra.includes("auto_increment"))
+    return { kind: "autoincrement" };
+  const raw = column.columnDefault;
+  if (raw === null)
+    return;
+  if (/^current_timestamp(\(\d+\))?$/i.test(raw))
+    return { kind: "now" };
+  if (column.extra.includes("default_generated"))
+    return { kind: "dbgenerated", sql: raw };
+  if (typeof mapped.type === "object")
+    return { kind: "enumValue", value: raw };
+  if (mapped.type === "Boolean") {
+    if (raw === "1" || raw === "0")
+      return { kind: "literal", value: raw === "1" };
+    return { kind: "dbgenerated", sql: raw };
+  }
+  if (isNumericScalar2({ type: mapped.type }) && /^-?\d+(\.\d+)?$/.test(raw)) {
+    return { kind: "literal", value: Number(raw) };
+  }
+  return { kind: "literal", value: raw };
+}
+function isNumericScalar2(params) {
+  const { type } = params;
+  return type === "Int" || type === "BigInt" || type === "Float" || type === "Decimal";
+}
+// packages/migrate/src/down.ts
+function buildRollbackTarget(params) {
+  const { from, to, dialect } = params;
+  const skipped = [];
+  const toEnumsByKey = new Map;
+  for (const enumDef of to.enums) {
+    toEnumsByKey.set(enumDef.dbName ?? enumDef.name, enumDef);
+  }
+  let patched = false;
+  const enums = from.enums.map((enumDef) => {
+    const key = enumDef.dbName ?? enumDef.name;
+    const after = toEnumsByKey.get(key);
+    if (after === undefined)
+      return enumDef;
+    const before = new Set(enumDef.values);
+    const added = after.values.filter((value) => !before.has(value));
+    if (added.length === 0)
+      return enumDef;
+    for (const value of added) {
+      skipped.push(`enum "${key}": value "${value}" added by the up migration is kept \u2014 ${dialect} cannot drop enum values`);
+    }
+    patched = true;
+    return { ...enumDef, values: [...enumDef.values, ...added] };
+  });
+  return { target: patched ? { ...from, enums } : from, skipped };
+}
+function forceReAddedColumnsNullable(params) {
+  return params.steps.map((step) => {
+    if (step.kind !== "addColumn" || step.column.isOptional)
+      return step;
+    return { ...step, column: { ...step.column, isOptional: true } };
+  });
+}
+function generateDownMigration(params) {
+  const { from, to, name } = params;
+  const dialect = params.dialect ?? "postgres";
+  const artifacts = collectExtensionArtifacts({
+    schema: to,
+    dialect,
+    extensions: params.extensions ?? []
+  });
+  const allArtifacts = [...artifacts.setup, ...artifacts.objects];
+  const strippedFrom = stripExtensionArtifacts({ schema: from, artifacts: allArtifacts });
+  const { target, skipped } = buildRollbackTarget({ from: strippedFrom, to, dialect });
+  const toViewNames = new Set(to.models.filter((model) => model.isView).map((model) => model.dbName ?? model.name));
+  for (const model of target.models) {
+    if (!model.isView)
+      continue;
+    const name2 = model.dbName ?? model.name;
+    if (!toViewNames.has(name2)) {
+      skipped.push(`view "${name2}" dropped by the up migration is not re-created \u2014 its definition is not stored in the schema; re-create it manually`);
+    }
+  }
+  const steps = forceReAddedColumnsNullable({
+    steps: diffSchemas({ from: to, to: target, dialect })
+  });
+  const coreSql = renderSteps({ steps, dialect, from: to, to: target });
+  const created = planMissingArtifacts({ introspected: from, artifacts: allArtifacts });
+  const artifactDropSql = [];
+  for (const artifact of [...created].reverse()) {
+    if (artifact.owns.kind === "postgresExtension") {
+      skipped.push(`extension "${artifact.owns.name}" stays installed \u2014 other objects may depend on it (drop it manually if intended)`);
+      continue;
+    }
+    artifactDropSql.push(...artifact.drop);
+  }
+  return {
+    name,
+    sql: [...artifactDropSql, ...coreSql],
+    destructive: steps.some((step) => step.destructive),
+    skipped
+  };
+}
+// packages/migrate/src/push.ts
+import { VibeError as VibeError10, assertValidSchemaIR, providerToDialect } from "@vibeorm/schema";
+import { DIALECT_CAPABILITIES as DIALECT_CAPABILITIES2 } from "@vibeorm/sql";
+async function push(params) {
+  const { executor, schema } = params;
+  assertValidSchemaIR({ schema });
+  const dialect = providerToDialect({ provider: schema.datasource.provider });
+  const artifacts = collectExtensionArtifacts({
+    schema,
+    dialect,
+    extensions: params.extensions ?? []
+  });
+  const allArtifacts = [...artifacts.setup, ...artifacts.objects];
+  const introspected = await introspectDialect({ executor, dialect });
+  const from = stripExtensionArtifacts({ schema: introspected, artifacts: allArtifacts });
+  const steps = diffSchemas({ from, to: schema, dialect });
+  const destructive = steps.filter((step) => step.destructive);
+  if (destructive.length > 0 && params.acceptDataLoss !== true) {
+    throw new VibeError10({
+      code: "VIBE_MIGRATION",
+      message: `push refused: ${destructive.length} destructive step(s) would lose data \u2014 pass acceptDataLoss: true to proceed:
+${destructive.map((step) => `  - ${describeStep({ step })}`).join(`
+`)}`,
+      meta: { destructive: destructive.map((step) => describeStep({ step })) }
+    });
+  }
+  const installed = await probeInstalledExtensionState({
+    executor,
+    dialect,
+    artifacts: allArtifacts
+  });
+  const missing = planMissingArtifacts({ introspected, artifacts: allArtifacts, installed });
+  const setupSql = artifactCreateSql({
+    artifacts: missing.filter((artifact) => artifact.owns.kind === "postgresExtension")
+  });
+  const objectSql = artifactCreateSql({
+    artifacts: missing.filter((artifact) => artifact.owns.kind !== "postgresExtension")
+  });
+  const coreSql = renderSteps({ steps, dialect, from, to: schema });
+  const sql = [...setupSql, ...coreSql, ...objectSql];
+  if (sql.length === 0)
+    return { steps, applied: [] };
+  const wrap = DIALECT_CAPABILITIES2[dialect].transactionalDdl && !usesSelfManagedTransactions({ sql });
+  if (wrap)
+    await executor({ text: "BEGIN" });
+  try {
+    for (const statement of sql) {
+      await executeStatement({ executor, statement, dialect });
+    }
+    if (wrap)
+      await executor({ text: "COMMIT" });
+  } catch (error) {
+    if (wrap) {
+      try {
+        await executor({ text: "ROLLBACK" });
+      } catch {}
+    } else if (dialect === "sqlite") {
+      await cleanupSelfManagedFailure({ executor });
+    }
+    throw new VibeError10({
+      code: "VIBE_MIGRATION",
+      message: `push failed while applying schema changes: ${error instanceof Error ? error.message : String(error)}`,
+      meta: { statements: sql },
+      cause: error
+    });
+  }
+  return { steps, applied: sql };
+}
+async function pull(params) {
+  return introspectDialect({ executor: params.executor, dialect: params.dialect ?? "postgres" });
+}
+async function introspectDialect(params) {
+  const { executor, dialect } = params;
+  switch (dialect) {
+    case "postgres":
+      return introspectPostgres({ executor });
+    case "sqlite":
+      return introspectSqlite({ executor });
+    case "mysql":
+      return introspectMysql({ executor });
+  }
+}
+export {
+  stripExtensionArtifacts,
+  rollbackMigration,
+  resolveMigration,
+  renderSteps,
+  push,
+  pull,
+  probeInstalledExtensionState,
+  planMissingArtifacts,
+  migrationStatus,
+  migrationChecksum,
+  introspectSqlite,
+  introspectPostgres,
+  introspectMysql,
+  generateMigration,
+  generateDownMigration,
+  ensureMigrationsTable,
+  diffSchemas,
+  detectImplicitM2MPairs,
+  describeStep,
+  collectExtensionArtifacts,
+  artifactCreateSql,
+  applyMigrations,
+  MIGRATIONS_TABLE_NAME
+};
+
+//# debugId=5088DA7EA679FA1464756E2164756E21